# Your first UOR program
message = "Hello UOR!"
encoded = [chunk_data(i, ord(c)) for i, c in enumerate(message)]
decoded = ''.join(vm_execute(encoded))
print(f"Original: {message}")
print(f"Decoded:  {decoded}")
# They match perfectly or UOR throws an error

# Mathematical operations with perfect accuracy
program = [
    chunk_push(42),     # Put 42 on the stack
    chunk_push(8),      # Put 8 on the stack
    chunk_add(),        # Add them (guaranteed accurate)
    chunk_print()       # Display result
]
result = list(vm_execute(program))
print(f"42 + 8 = {result[0]}")  # Mathematically guaranteed correct

# See corruption detection in action
data = "Important data"
chunks = [chunk_data(i, ord(c)) for i, c in enumerate(data)]

# Simulate corruption
chunks[0] = chunks[0] + 1  # Slightly alter one chunk

try:
    result = ''.join(vm_execute(chunks))
    print("This won't print - corruption detected!")
except ValueError as e:
    print(f"Corruption caught: {e}")

class SecureUser:
    def __init__(self, name, email):
        self.name_chunks = [chunk_data(i, ord(c)) for i, c in enumerate(name)]
        self.email_chunks = [chunk_data(i, ord(c)) for i, c in enumerate(email)]
    
    def get_name(self):
        return ''.join(vm_execute(self.name_chunks))  # Guaranteed accurate
    
    def verify_integrity(self):
        try:
            self.get_name()
            return True
        except ValueError:
            return False  # Data corrupted

def secure_pipeline(data):
    # Create processing pipeline with built-in validation
    chunks = [chunk_data(i, ord(c)) for i, c in enumerate(data)]
    
    # Group in a block for integrity
    pipeline = [chunk_block_start(len(chunks))] + chunks
    
    # Execute with mathematical guarantees
    return ''.join(vm_execute(pipeline))

class SecureAPI:
    def process_request(self, data):
        # Encode request with UOR
        chunks = [chunk_data(i, ord(c)) for i, c in enumerate(data)]
        
        # Process with integrity checking
        try:
            result = self.business_logic(chunks)
            return {"status": "success", "data": result}
        except ValueError:
            return {"status": "error", "message": "Data corruption detected"}
    
    def business_logic(self, chunks):
        # Your business logic here, with guaranteed data integrity
        return ''.join(vm_execute(chunks)).upper()