Program.cs

using SharpVM;
using SharpVM.Demos;
using SharpVM.Injector;
using SharpVM.Viewer;

// Check command line args
if (args.Length > 0 && args[0] == "--advanced")
{
    // Run advanced demos
    DemoRunner.RunAll();
    return;
}

if (args.Length > 0 && args[0] == "--bios")
{
    // Run BIOS viewer (placeholder)
    var viewer = new VMViewer();
    viewer.Run();
    return;
}

if (args.Length > 0 && args[0] == "--bios-run")
{
    // Run actual x86 CPU emulator with BIOS
    string? biosPath = args.Length > 1 ? args[1] : null;
    bool debug = args.Length > 2 && args[2] == "--debug";

    var runner = new BiosRunner();

    if (biosPath != null && File.Exists(biosPath))
    {
        if (!runner.LoadBios(biosPath))
        {
            Console.WriteLine("Failed to load BIOS file");
            return;
        }
    }
    else
    {
        Console.WriteLine("Creating test BIOS (no BIOS file specified or file not found)...");
        runner.CreateTestBios();
    }

    runner.Initialize();
    runner.TraceInstructions = true;

    if (debug)
    {
        runner.Debug();
    }
    else
    {
        runner.Run(10000);
    }
    return;
}

if (args.Length > 0 && args[0] == "--boot-cdrom")
{
    // Boot from CD-ROM ISO using SeaBIOS
    string biosPath = @"D:\SharpVM\bios\bios.bin";
    string isoPath = @"D:\SharpVM\iso\TinyCore-current.iso";
    bool debug = args.Any(a => a == "--debug");
    bool trace = args.Any(a => a == "--trace");
    int maxInstructions = 1000000;

    // Parse positional and named arguments (skip pure numbers which are --max values)
    var positionalArgs = args.Skip(1).Where(a => !a.StartsWith("--") && !int.TryParse(a, out _)).ToList();
    if (positionalArgs.Count >= 1) biosPath = positionalArgs[0];
    if (positionalArgs.Count >= 2) isoPath = positionalArgs[1];

    // Parse --max option
    for (int i = 0; i < args.Length - 1; i++)
    {
        if (args[i] == "--max" && int.TryParse(args[i + 1], out int max))
        {
            maxInstructions = max;
            break;
        }
    }

    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║           SharpVM x86 Emulator - CD-ROM Boot                  ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    if (!File.Exists(biosPath))
    {
        Console.WriteLine($"BIOS file not found: {biosPath}");
        Console.WriteLine("Usage: SharpVM --boot-cdrom [bios.bin] [iso-file] [--debug] [--trace] [--max N]");
        return;
    }

    if (!File.Exists(isoPath))
    {
        Console.WriteLine($"ISO file not found: {isoPath}");
        Console.WriteLine("Usage: SharpVM --boot-cdrom [bios.bin] [iso-file] [--debug] [--trace] [--max N]");
        return;
    }

    Console.WriteLine($"BIOS: {biosPath}");
    Console.WriteLine($"ISO:  {isoPath}");
    Console.WriteLine();

    var runner = new BiosRunner(32 * 1024 * 1024); // 32MB RAM

    // Load BIOS
    if (!runner.LoadBios(biosPath))
    {
        Console.WriteLine("Failed to load BIOS");
        return;
    }

    // Attach CD-ROM
    try
    {
        runner.AttachCdRom(isoPath);
        Console.WriteLine("CD-ROM attached successfully");

        if (runner.CdRom != null && runner.CdRom.IsBootable)
        {
            Console.WriteLine($"  Boot image at LBA {runner.CdRom.BootImageLba}, {runner.CdRom.BootImageSectors} sectors");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to attach CD-ROM: {ex.Message}");
        return;
    }

    Console.WriteLine();

    // Initialize and run
    runner.Initialize();
    runner.TraceInstructions = trace;

    if (debug)
    {
        runner.Debug();
    }
    else
    {
        runner.Run(maxInstructions);
    }

    // Show final VGA screen
    Console.WriteLine("\n=== VGA Display ===");
    runner.Viewer.Render();

    return;
}

if (args.Length > 0 && args[0] == "--direct-boot")
{
    // Direct boot from CD-ROM ISO (bypasses SeaBIOS, loads boot image directly)
    string isoPath = @"D:\SharpVM\iso\TinyCore-current.iso";
    bool debug = args.Any(a => a == "--debug");
    bool trace = args.Any(a => a == "--trace");
    int maxInstructions = 1000000;

    var positionalArgs = args.Skip(1).Where(a => !a.StartsWith("--") && !int.TryParse(a, out _)).ToList();
    if (positionalArgs.Count >= 1) isoPath = positionalArgs[0];

    for (int i = 0; i < args.Length - 1; i++)
    {
        if (args[i] == "--max" && int.TryParse(args[i + 1], out int max))
        {
            maxInstructions = max;
            break;
        }
    }

    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║        SharpVM x86 Emulator - Direct CD-ROM Boot              ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    if (!File.Exists(isoPath))
    {
        Console.WriteLine($"ISO file not found: {isoPath}");
        return;
    }

    Console.WriteLine($"ISO: {isoPath}");

    // Load ISO
    var cdrom = new SharpVM.Devices.CdRomDevice(isoPath);
    if (!cdrom.IsBootable)
    {
        Console.WriteLine("ISO is not bootable (no El Torito boot record)");
        return;
    }

    Console.WriteLine($"Boot image: LBA {cdrom.BootImageLba}, {cdrom.BootImageSectors} sectors");

    // Dump boot info table from boot image
    byte[] bootImageInfo = cdrom.GetBootImage();
    if (bootImageInfo.Length >= 24)
    {
        uint pvdLba = BitConverter.ToUInt32(bootImageInfo, 8);
        uint bootFileLba = BitConverter.ToUInt32(bootImageInfo, 12);
        uint bootFileLen = BitConverter.ToUInt32(bootImageInfo, 16);
        uint checksum = BitConverter.ToUInt32(bootImageInfo, 20);
        Console.WriteLine($"Boot Info Table:");
        Console.WriteLine($"  PVD LBA: {pvdLba}");
        Console.WriteLine($"  Boot file LBA: {bootFileLba}");
        Console.WriteLine($"  Boot file length: {bootFileLen}");
        Console.WriteLine($"  Checksum: 0x{checksum:X8}");
        Console.WriteLine($"  First 16 bytes: {BitConverter.ToString(bootImageInfo, 0, 16)}");

        // Also show sector 16 (PVD) content
        byte[] pvdSector = cdrom.ReadSector(16);
        Console.Write($"  Sector 16 (PVD) first 16 bytes: ");
        for (int i = 0; i < 16 && i < pvdSector.Length; i++) Console.Write($"{pvdSector[i]:X2} ");
        Console.Write(" |");
        for (int i = 0; i < 16 && i < pvdSector.Length; i++)
        {
            char c = (char)pvdSector[i];
            Console.Write(c >= 32 && c < 127 ? c : '.');
        }
        Console.WriteLine("|");

        // And sector 1
        byte[] sec1 = cdrom.ReadSector(1);
        Console.Write($"  Sector 1 first 16 bytes: ");
        for (int i = 0; i < 16 && i < sec1.Length; i++) Console.Write($"{sec1[i]:X2} ");
        Console.Write(" |");
        for (int i = 0; i < 16 && i < sec1.Length; i++)
        {
            char c = (char)sec1[i];
            Console.Write(c >= 32 && c < 127 ? c : '.');
        }
        Console.WriteLine("|");
    }
    Console.WriteLine();

    // Create CPU with 32MB memory
    var cpu = new SharpVM.CPU.X86Cpu(32 * 1024 * 1024);
    cpu.Reset();
    cpu.A20Enabled = true;

    // Load boot image at 0x7C00 (standard boot sector address)
    byte[] bootImage = cdrom.GetBootImage();
    Console.WriteLine($"Loading {bootImage.Length} bytes at 0x7C00");

    for (int i = 0; i < bootImage.Length; i++)
    {
        cpu.WriteByte(0x7C00 + (ulong)i, bootImage[i]);
    }

    // Set up minimal BIOS Data Area
    cpu.WriteByte(0x410, 0x21);  // Equipment: VGA, no floppy
    cpu.WriteByte(0x411, 0x00);
    cpu.WriteWord(0x413, 640);   // 640KB base memory
    cpu.WriteByte(0x449, 0x03);  // Video mode 3 (80x25 text)
    cpu.WriteByte(0x44A, 80);    // 80 columns
    cpu.WriteByte(0x484, 24);    // 25 rows - 1

    // Set up segment registers for boot
    cpu.Regs.CS = 0x0000;
    cpu.Regs.DS = 0x0000;
    cpu.Regs.ES = 0x0000;
    cpu.Regs.SS = 0x0000;
    cpu.Regs.IP = 0x7C00;
    cpu.Regs.SP = 0x7C00; // Stack just below boot sector

    // DL = boot drive (0x80 for first hard disk, 0xE0 for CD-ROM)
    cpu.Regs.SetReg8(SharpVM.CPU.X86Registers.RDX, 0xE0, false); // DL = CD-ROM drive

    // Hook up CD-ROM for INT 13h
    SharpVM.CPU.BiosInterrupts.SetCdRom(cdrom);

    Console.WriteLine($"Starting execution at {cpu.Regs.CS:X4}:{cpu.Regs.IP:X4}");
    Console.WriteLine($"DL = {cpu.Regs.DL:X2} (boot drive)");

    // Verify boot info table in memory
    uint pvdLbaInMem = cpu.ReadDword(0x7C08);
    uint bootLbaInMem = cpu.ReadDword(0x7C0C);
    Console.WriteLine($"Boot info at 0x7C08: PVD LBA={pvdLbaInMem}, Boot file LBA={bootLbaInMem}");
    Console.WriteLine();

    var viewer = new VMViewer();
    int instructionCount = 0;
    cpu.IsRunning = true;

    while (cpu.IsRunning && instructionCount < maxInstructions && !cpu.Halted)
    {
        if (trace)
        {
            ulong addr = cpu.LinearAddress(cpu.Regs.CS, cpu.Regs.IP);
            byte opcode = cpu.ReadByte(addr);
            Console.WriteLine($"[{instructionCount:D8}] {cpu.Regs.CS:X4}:{cpu.Regs.IP:X4}  {opcode:X2}  " +
                $"AX={cpu.Regs.AX:X4} BX={cpu.Regs.BX:X4} CX={cpu.Regs.CX:X4} DX={cpu.Regs.DX:X4}");
        }

        try
        {
            cpu.Step();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"\nException at {cpu.Regs.CS:X4}:{cpu.Regs.IP:X4}: {ex.Message}");
            break;
        }

        instructionCount++;

        // Sync VGA periodically
        if (instructionCount % 10000 == 0)
        {
            for (int i = 0; i < 80 * 25 * 2; i++)
            {
                viewer.WriteVideoMemory(i, cpu.ReadByte(0xB8000 + (ulong)i));
            }
        }
    }

    Console.WriteLine($"\nExecuted {instructionCount} instructions");
    Console.WriteLine($"CS:IP = {cpu.Regs.CS:X4}:{cpu.Regs.IP:X4}");
    Console.WriteLine($"Halted: {cpu.Halted}");

    // Final VGA sync and display
    for (int i = 0; i < 80 * 25 * 2; i++)
    {
        viewer.WriteVideoMemory(i, cpu.ReadByte(0xB8000 + (ulong)i));
    }
    Console.WriteLine("\n=== VGA Display ===");
    viewer.Render();

    if (debug)
    {
        // Simple debug loop
        Console.WriteLine("\nDebug mode (s=step, r=run 100, q=quit):");
        while (true)
        {
            Console.Write("> ");
            string? cmd = Console.ReadLine()?.Trim().ToLower();
            if (cmd == "q" || cmd == "quit") break;
            if (cmd == "s" || cmd == "step")
            {
                ulong addr = cpu.LinearAddress(cpu.Regs.CS, cpu.Regs.IP);
                byte opcode = cpu.ReadByte(addr);
                Console.WriteLine($"{cpu.Regs.CS:X4}:{cpu.Regs.IP:X4}  {opcode:X2}");
                try { cpu.Step(); } catch (Exception ex) { Console.WriteLine(ex.Message); }
            }
            if (cmd == "r" || cmd == "run")
            {
                for (int i = 0; i < 100 && !cpu.Halted; i++)
                    try { cpu.Step(); } catch { break; }
                Console.WriteLine($"Now at {cpu.Regs.CS:X4}:{cpu.Regs.IP:X4}");
            }
        }
    }

    return;
}

if (args.Length > 0 && args[0] == "--inject")
{
    if (args.Length < 2)
    {
        Console.WriteLine("Usage: SharpVM --inject <path-to-exe>");
        Console.WriteLine("       SharpVM --inject <path-to-exe> --analyze");
        Console.WriteLine("       SharpVM --inject <path-to-exe> --trace");
        return;
    }

    string exePath = args[1];
    bool analyzeOnly = args.Length > 2 && args[2] == "--analyze";
    bool enableTrace = args.Length > 2 && args[2] == "--trace";

    var injector = new BinaryInjector
    {
        EnableTracing = enableTrace,
        VerboseOutput = true,
        MaxInstructions = 10000
    };

    try
    {
        injector.Load(exePath);

        if (analyzeOnly)
        {
            injector.Analyze();
        }
        else
        {
            injector.Execute();
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
        if (ex.InnerException != null)
            Console.WriteLine($"  Inner: {ex.InnerException.Message}");
    }

    return;
}

// Universal Binary Analyzer
if (args.Length > 0 && args[0] == "--analyze")
{
    string filePath = args.Length > 1 ? args[1] : "";
    bool detailed = args.Any(a => a == "-v" || a == "--verbose");
    string? outputPath = null;

    // Parse --output option
    for (int i = 0; i < args.Length - 1; i++)
    {
        if (args[i] == "-o" || args[i] == "--output")
        {
            outputPath = args[i + 1];
            break;
        }
    }

    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║           SharpVM - Universal Binary Analyzer                  ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
    {
        Console.WriteLine("Usage: SharpVM --analyze <file> [options]");
        Console.WriteLine("Options:");
        Console.WriteLine("  -v, --verbose        Show detailed analysis output");
        Console.WriteLine("  -o, --output <path>  Write report to file");
        Console.WriteLine();
        Console.WriteLine("Analyzes any binary file for:");
        Console.WriteLine("  - File format detection (PE, ELF, Mach-O, etc.)");
        Console.WriteLine("  - Cryptographic patterns (AES, XTEA, RC4, MD5, SHA, etc.)");
        Console.WriteLine("  - Obfuscation/protection (VMProtect, Themida, Arxan, etc.)");
        Console.WriteLine("  - Entropy analysis (packed/encrypted regions)");
        Console.WriteLine("  - String analysis (suspicious strings, encrypted strings)");
        Console.WriteLine("  - Code pattern analysis (anti-debug, VM handlers)");
        Console.WriteLine("  - Import/export analysis (suspicious APIs)");
        return;
    }

    var analyzer = new SharpVM.Analyzer.Core.UniversalAnalyzer();
    var report = analyzer.Analyze(filePath);

    analyzer.PrintReport(report, detailed);

    if (!string.IsNullOrEmpty(outputPath))
    {
        using var writer = new StreamWriter(outputPath);
        writer.WriteLine($"SharpVM Universal Binary Analysis Report");
        writer.WriteLine($"File: {report.FilePath}");
        writer.WriteLine($"Size: {report.FileSize:N0} bytes");
        writer.WriteLine($"Analyzed: {report.AnalysisTime}");
        writer.WriteLine();

        writer.WriteLine($"Format: {report.DetectedFormat}");
        writer.WriteLine();

        writer.WriteLine("=== Findings ===");
        foreach (var finding in report.Findings.OrderByDescending(f => f.Severity))
        {
            writer.WriteLine($"[{finding.Severity}] {finding.Title}");
            writer.WriteLine($"  {finding.Description}");
            if (finding.Address.HasValue)
                writer.WriteLine($"  Address: 0x{finding.Address:X}");
        }

        writer.WriteLine();
        writer.WriteLine("=== Detected Protections ===");
        foreach (var tech in report.ObfuscationTechniques)
        {
            writer.WriteLine($"- {tech.Name} ({tech.Type}, confidence: {tech.Confidence:P0})");
            writer.WriteLine($"  {tech.Description}");
        }

        writer.WriteLine();
        writer.WriteLine("=== Crypto Patterns ===");
        foreach (var crypto in report.CryptoPatterns)
        {
            writer.WriteLine($"- {crypto.AlgorithmName} at 0x{crypto.Address:X}");
            writer.WriteLine($"  Type: {crypto.Type}, Confidence: {crypto.Confidence:P0}");
        }

        Console.WriteLine($"\nReport written to: {outputPath}");
    }

    return;
}

// PSP Firmware Analyzer
if (args.Length > 0 && args[0] == "--psp-analyze")
{
    string filePath = args.Length > 1 ? args[1] : @"D:\SharpVM\bin\PS.BIN";

    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║        SharpVM - PSP Firmware Analyzer (SCEUF Parser)         ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    var parser = new SharpVM.PSP.Firmware.SceufParser();
    if (parser.Load(filePath))
    {
        Console.WriteLine($"\nTotal entries: {parser.Entries.Count}");

        // Analyze first few entries
        Console.WriteLine("\n=== Entry Analysis ===");
        for (int i = 0; i < Math.Min(5, parser.Entries.Count); i++)
        {
            parser.AnalyzeEntry(i);
        }

        // Extract option
        if (args.Any(a => a == "--extract"))
        {
            int entryIdx = 0;
            for (int i = 0; i < args.Length - 1; i++)
            {
                if (args[i] == "--entry" && int.TryParse(args[i + 1], out int idx))
                {
                    entryIdx = idx;
                    break;
                }
            }

            string outPath = $"entry_{entryIdx}.bin";
            parser.ExtractEntry(entryIdx, outPath);
        }
    }
    return;
}

// Blackbone-style PE Loader
if (args.Length > 0 && args[0] == "--blackbone")
{
    string filePath = args.Length > 1 ? args[1] : "";
    bool interactive = args.Any(a => a == "-i" || a == "--interactive");
    bool execute = args.Any(a => a == "-x" || a == "--execute");
    bool trace = args.Any(a => a == "-t" || a == "--trace");
    bool debug = args.Any(a => a == "-d" || a == "--debug");
    bool passthrough = args.Any(a => a == "-p" || a == "--passthrough");
    bool fullRun = args.Any(a => a == "--full" || a == "-f");

    // Parse max instructions, dump path, vm analysis path, and memory dump path
    int maxInstructions = fullRun ? int.MaxValue : 1000000;
    string? dumpPath = null;
    string? vmAnalysisPath = null;
    string? memDumpPath = null;
    string? traceDumpPath = null;
    for (int i = 0; i < args.Length - 1; i++)
    {
        if (args[i] == "--max" && int.TryParse(args[i + 1], out int max))
        {
            maxInstructions = max;
        }
        if (args[i] == "--dump")
        {
            dumpPath = args[i + 1];
        }
        if (args[i] == "--vmanalysis")
        {
            vmAnalysisPath = args[i + 1];
        }
        if (args[i] == "--memdump")
        {
            memDumpPath = args[i + 1];
        }
        if (args[i] == "--tracedump")
        {
            traceDumpPath = args[i + 1];
        }
    }

    // Default trace dump path for full run mode
    if (fullRun && traceDumpPath == null)
    {
        traceDumpPath = Path.Combine(Path.GetDirectoryName(filePath) ?? ".",
            Path.GetFileNameWithoutExtension(filePath) + "_trace.log");
    }
    if (fullRun && memDumpPath == null)
    {
        memDumpPath = Path.Combine(Path.GetDirectoryName(filePath) ?? ".",
            Path.GetFileNameWithoutExtension(filePath) + "_memdump.bin");
    }

    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║        SharpVM - Blackbone Manual PE Mapper & Executor        ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
    {
        Console.WriteLine("Usage: SharpVM --blackbone <pe-file> [options]");
        Console.WriteLine("Options:");
        Console.WriteLine("  -i, --interactive    Interactive exploration mode");
        Console.WriteLine("  -x, --execute        Execute through VM with API emulation");
        Console.WriteLine("  -t, --trace          Enable instruction tracing during execution");
        Console.WriteLine("  -d, --debug          Enable debugging (break on start)");
        Console.WriteLine("  -p, --passthrough    Forward ALL API calls to real Windows (no emulation)");
        Console.WriteLine("  -f, --full           Full run mode - execute until app exits, auto-dump on exit");
        Console.WriteLine("  --dump <path>        Dump execution trace to file (VM bytecode + memory)");
        Console.WriteLine("  --max N              Maximum instructions to execute (default 1000000)");
        Console.WriteLine("  --vmanalysis <path>  Enable protection VM analysis and write to file");
        Console.WriteLine("  --memdump <path>     Dump memory regions when protection completes");
        Console.WriteLine("  --tracedump <path>   Dump instruction trace to file");
        Console.WriteLine();
        Console.WriteLine("Examples:");
        Console.WriteLine("  SharpVM --blackbone calc.exe                    # Load and analyze");
        Console.WriteLine("  SharpVM --blackbone test.exe --execute          # Execute through VM");
        Console.WriteLine("  SharpVM --blackbone test.exe -x -t              # Execute with tracing");
        Console.WriteLine("  SharpVM --blackbone test.exe -x -d              # Execute with debugger");
        Console.WriteLine("  SharpVM --blackbone test.exe -x -p --dump trace.log  # Passthrough with dump");
        Console.WriteLine("  SharpVM --blackbone test.exe -x -t --full       # Full run with auto-dump");
        return;
    }

    var loader = new SharpVM.Blackbone.BlackboneLoader();

    if (loader.LoadPE(filePath))
    {
        Console.WriteLine("\nPE file loaded successfully!");
        Console.WriteLine();
        loader.Disassemble(loader.GetEntryPoint(), 20);

        if (execute)
        {
            // Execute through VM
            Console.WriteLine("\n=== Executing through VM ===\n");

            var executor = new SharpVM.Blackbone.Execution.VmExecutor(loader);
            executor.MaxInstructions = maxInstructions;
            executor.EnableTracing = trace;
            executor.BreakOnApiCall = false;
            executor.PassthroughMode = passthrough;

            // Enable VM analysis if specified
            if (!string.IsNullOrEmpty(vmAnalysisPath))
            {
                executor.EnableVmAnalysis = true;
                executor.VmAnalysisPath = vmAnalysisPath;
                Console.WriteLine($"[VM ANALYSIS] Will write protection VM analysis to: {vmAnalysisPath}");
            }

            // Enable memory dump if specified
            if (!string.IsNullOrEmpty(memDumpPath))
            {
                executor.EnableMemoryDump = true;
                executor.MemoryDumpPath = memDumpPath;
                Console.WriteLine($"[MEM DUMP] Will dump memory to: {memDumpPath}");
                Console.WriteLine($"[MEM DUMP] Auto-dump will trigger when protection completes (new API detected)");
            }

            // Set up dump file if specified
            StreamWriter? dumpWriter = null;
            if (!string.IsNullOrEmpty(dumpPath))
            {
                dumpWriter = new StreamWriter(dumpPath, false);
                dumpWriter.WriteLine($"=== SharpVM Execution Dump ===");
                dumpWriter.WriteLine($"Target: {filePath}");
                dumpWriter.WriteLine($"Passthrough Mode: {passthrough}");
                dumpWriter.WriteLine($"Started: {DateTime.Now}");
                dumpWriter.WriteLine();
                executor.EnableApiTracing = true;
                executor.EnableTracing = true;
            }

            if (passthrough)
            {
                Console.WriteLine("[PASSTHROUGH MODE] All API calls forwarded to real Windows");
            }

            if (fullRun)
            {
                Console.WriteLine("[FULL RUN MODE] Executing until app exits or Ctrl+C pressed");
                Console.WriteLine($"  Trace dump: {traceDumpPath}");
                Console.WriteLine($"  Memory dump: {memDumpPath}");
                Console.WriteLine("  Press Ctrl+C to stop and dump state");
            }

            // Set up trace dump writer for full run mode
            StreamWriter? traceDumpWriter = null;
            if (!string.IsNullOrEmpty(traceDumpPath))
            {
                traceDumpWriter = new StreamWriter(traceDumpPath, false);
                traceDumpWriter.WriteLine($"=== SharpVM Full Trace Dump ===");
                traceDumpWriter.WriteLine($"Target: {filePath}");
                traceDumpWriter.WriteLine($"Started: {DateTime.Now}");
                traceDumpWriter.WriteLine();
            }

            // Set up Ctrl+C handler for graceful shutdown
            bool ctrlCPressed = false;
            Console.CancelKeyPress += (sender, e) =>
            {
                e.Cancel = true; // Prevent immediate termination
                ctrlCPressed = true;
                executor.RequestStop();
                Console.WriteLine("\n[CTRL+C] Stopping execution and dumping state...");
            };

            // Hook output
            executor.OnOutput += (s) => { /* Already written to console */ };
            executor.OnApiCall += (addr, name) =>
            {
                if (trace)
                {
                    // Already logged in tracer
                }
                dumpWriter?.WriteLine($"[API] {name} @ 0x{addr:X16}");
            };

            executor.Initialize();

            // Initialize unified syscall emulation (Sogen integration)
            // This enables real NT syscall handling for SYSCALL instructions
            executor.InitializeSyscallEmulation(tracingEnabled: trace);

            // Hook into ExecutionTracer for detailed dump if we have a dump file
            if (dumpWriter != null && executor.Tracer != null)
            {
                executor.Tracer.SetDumpWriter(dumpWriter);
            }

            if (debug)
            {
                // Start with a breakpoint at entry
                executor.AddBreakpoint(loader.GetEntryPoint());
            }

            var result = executor.Execute();

            Console.WriteLine($"\n=== Execution Result ===");
            Console.WriteLine($"Exit Reason: {result.ExitReason}");
            Console.WriteLine($"Exit Code: {result.ExitCode}");
            Console.WriteLine($"Instructions: {result.InstructionCount}");

            if (result.Exception != null)
            {
                Console.WriteLine($"Exception: {result.Exception.Message}");
            }

            // Write final dump summary and close
            if (dumpWriter != null)
            {
                dumpWriter.WriteLine();
                dumpWriter.WriteLine($"=== Execution Complete ===");
                dumpWriter.WriteLine($"Exit Reason: {result.ExitReason}");
                dumpWriter.WriteLine($"Exit Code: {result.ExitCode}");
                dumpWriter.WriteLine($"Instructions: {result.InstructionCount}");
                dumpWriter.WriteLine($"Ended: {DateTime.Now}");

                // Dump API call statistics
                dumpWriter.WriteLine();
                dumpWriter.WriteLine("=== API Call Statistics ===");
                executor.ApiTracer.DumpToWriter(dumpWriter);

                dumpWriter.Close();
                Console.WriteLine($"\nDump written to: {dumpPath}");
            }

            // Write VM analysis summary if enabled
            if (!string.IsNullOrEmpty(vmAnalysisPath))
            {
                executor.WriteVmAnalysisSummary();
                Console.WriteLine($"\nVM analysis written to: {vmAnalysisPath}");
            }

            // Write trace dump if enabled (full run mode)
            if (traceDumpWriter != null)
            {
                traceDumpWriter.WriteLine();
                traceDumpWriter.WriteLine($"=== Execution Complete ===");
                traceDumpWriter.WriteLine($"Exit Reason: {result.ExitReason}");
                traceDumpWriter.WriteLine($"Exit Code: {result.ExitCode}");
                traceDumpWriter.WriteLine($"Instructions: {result.InstructionCount}");
                traceDumpWriter.WriteLine($"Stopped by Ctrl+C: {ctrlCPressed}");
                traceDumpWriter.WriteLine($"Ended: {DateTime.Now}");

                // Dump API call statistics
                traceDumpWriter.WriteLine();
                traceDumpWriter.WriteLine("=== API Call Statistics ===");
                executor.ApiTracer.DumpToWriter(traceDumpWriter);

                // Dump register state
                traceDumpWriter.WriteLine();
                traceDumpWriter.WriteLine("=== Final Register State ===");
                executor.DumpRegistersToWriter(traceDumpWriter);

                traceDumpWriter.Close();
                Console.WriteLine($"\nTrace dump written to: {traceDumpPath}");
            }

            // Write memory dump if enabled (full run mode)
            if (!string.IsNullOrEmpty(memDumpPath) && fullRun)
            {
                try
                {
                    executor.DumpMemoryToFile(memDumpPath);
                    Console.WriteLine($"Memory dump written to: {memDumpPath}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Failed to write memory dump: {ex.Message}");
                }
            }
        }
        else if (interactive)
        {
            loader.Interactive();
        }
    }
    else
    {
        Console.WriteLine("Failed to load PE file");
    }

    return;
}

// Sogen Integration Test
if (args.Length > 0 && args[0] == "--sogen")
{
    string filePath = args.Length > 1 ? args[1] : @"D:\Rockstar Games\Grand Theft Auto V\Menyoo.asi";
    bool trace = args.Any(a => a == "-t" || a == "--trace");
    
    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║        SharpVM - Sogen Windows Emulator Integration           ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        Console.WriteLine();
        Console.WriteLine("Usage: SharpVM --sogen <pe-file> [options]");
        Console.WriteLine("Options:");
        Console.WriteLine("  -t, --trace    Enable syscall tracing");
        Console.WriteLine();
        Console.WriteLine("Examples:");
        Console.WriteLine("  SharpVM --sogen Menyoo.asi");
        Console.WriteLine("  SharpVM --sogen test.dll --trace");
        return;
    }

    Console.WriteLine($"Target: {filePath}");
    Console.WriteLine($"Trace:  {trace}");
    Console.WriteLine();

    try
    {
        using var sogen = new SharpVM.Sogen.Core.SogenExecutor();
        
        // Check if registry directory exists
        string registryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "registry");
        if (Directory.Exists(registryPath))
        {
            Console.WriteLine($"Using registry from: {registryPath}");
            sogen.SetRegistryPath(registryPath);
        }
        else
        {
            Console.WriteLine("No registry directory found - running without registry");
        }
        
        // Enable syscall bridge with tracing
        sogen.EnableSyscallBridge(enableTrace: trace);
        
        Console.WriteLine("Loading PE file...");
        if (sogen.LoadPE(filePath))
        {
            Console.WriteLine($"✓ Loaded at:     0x{sogen.ImageBase:X16}");
            Console.WriteLine($"✓ Entry point:   0x{sogen.EntryPoint:X16}");
            Console.WriteLine();
            
            // Get loaded modules
            var modules = sogen.GetModules();
            Console.WriteLine($"Loaded modules: {modules.Count}");
            foreach (var (name, baseAddr, size) in modules)
            {
                Console.WriteLine($"  {name,-30} @ 0x{baseAddr:X16} (0x{size:X} bytes)");
            }
            Console.WriteLine();
            
            Console.WriteLine("Executing DllMain...");
            Console.WriteLine("Press Ctrl+C to stop");
            Console.WriteLine();
            
            // Execute
            bool success = sogen.Execute();
            
            Console.WriteLine();
            Console.WriteLine("═══ Execution Results ═══");
            Console.WriteLine($"Success:      {success}");
            Console.WriteLine($"Instructions: {sogen.InstructionCount:N0}");
            Console.WriteLine($"Syscalls:     {sogen.SyscallCount:N0}");
            
            var dispatcher = sogen.GetDispatcher();
            if (dispatcher != null)
            {
                Console.WriteLine($"Dispatcher syscalls: {dispatcher.SyscallCount:N0}");
            }
            
            if (!success)
            {
                string error = sogen.GetLastError();
                Console.WriteLine($"Error: {error}");
            }
        }
        else
        {
            string error = sogen.GetLastError();
            Console.WriteLine($"✗ Failed to load PE: {error}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception: {ex.Message}");
        Console.WriteLine(ex.StackTrace);
    }
    
    return;
}

// Hybrid Execution Mode (Hypervisor + Emulation)
if (args.Length > 0 && args[0] == "--hybrid")
{
    string filePath = args.Length > 1 ? args[1] : "";
    bool trace = args.Any(a => a == "-t" || a == "--trace");
    string modeArg = args.FirstOrDefault(a => a.StartsWith("--mode=")) ?? "--mode=hybrid";
    string mode = modeArg.Split('=').Last().ToLower();

    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║   SharpVM - Hybrid Execution (Hypervisor + Emulation)         ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
    {
        Console.WriteLine("Usage: SharpVM --hybrid <pe-file> [options]");
        Console.WriteLine("Options:");
        Console.WriteLine("  -t, --trace          Enable execution tracing");
        Console.WriteLine("  --mode=<mode>        Execution mode:");
        Console.WriteLine("                         hybrid     - Use hypervisor + emulation (default)");
        Console.WriteLine("                         hypervisor - Pure hypervisor (real execution)");
        Console.WriteLine("                         emulation  - Pure emulation (full control)");
        Console.WriteLine();
        Console.WriteLine("The hypervisor mode requires the momo5502 hypervisor driver to be installed.");
        Console.WriteLine("Driver source: https://github.com/momo5502/hypervisor");
        Console.WriteLine();
        Console.WriteLine("Examples:");
        Console.WriteLine("  SharpVM --hybrid game.exe                    # Hybrid mode");
        Console.WriteLine("  SharpVM --hybrid game.exe --mode=hypervisor  # Pure hypervisor");
        Console.WriteLine("  SharpVM --hybrid game.exe --mode=emulation   # Pure emulation");
        Console.WriteLine("  SharpVM --hybrid game.exe -t                 # With tracing");
        return;
    }

    Console.WriteLine($"Target: {filePath}");
    Console.WriteLine($"Mode:   {mode}");
    Console.WriteLine($"Trace:  {trace}");
    Console.WriteLine();

    // Check hypervisor availability
    bool hypervisorAvailable = SharpVM.Hypervisor.HypervisorBridge.IsDriverAvailable();
    Console.WriteLine($"Hypervisor Driver: {(hypervisorAvailable ? "Available" : "Not Found")}");
    Console.WriteLine();

    try
    {
        var loader = new SharpVM.Blackbone.BlackboneLoader();

        if (loader.LoadPE(filePath))
        {
            Console.WriteLine("PE file loaded successfully!");
            Console.WriteLine();

            using var hybrid = new SharpVM.Hypervisor.HybridExecutor(loader);

            // Set execution mode
            hybrid.Mode = mode switch
            {
                "hypervisor" => SharpVM.Hypervisor.HybridExecutor.ExecutionMode.Hypervisor,
                "emulation" => SharpVM.Hypervisor.HybridExecutor.ExecutionMode.Emulation,
                _ => SharpVM.Hypervisor.HybridExecutor.ExecutionMode.Hybrid
            };

            hybrid.EnableTracing = trace;

            // Hook events
            hybrid.OnApiCall += (name) =>
            {
                if (trace) Console.WriteLine($"[API] {name}");
            };

            hybrid.OnCodeExecution += (addr) =>
            {
                if (trace) Console.WriteLine($"[EXEC] 0x{addr:X16}");
            };

            // Initialize and execute
            hybrid.Initialize();
            var result = hybrid.Execute();

            // Print results
            Console.WriteLine();
            Console.WriteLine("═══ Execution Results ═══");
            Console.WriteLine($"Success:       {result.Success}");
            Console.WriteLine($"Exit Code:     {result.ExitCode}");
            Console.WriteLine($"Exit Reason:   {result.ExitReason}");
            Console.WriteLine($"Mode:          {result.Mode}");
            Console.WriteLine($"Time:          {result.ExecutionTime.TotalSeconds:F2}s");
            Console.WriteLine($"Hypervisor:    {result.HypervisorInstructions:N0} instructions");
            Console.WriteLine($"Emulated:      {result.EmulatedInstructions:N0} instructions");

            if (result.ExecutionRecords.Length > 0)
            {
                Console.WriteLine($"Exec Records:  {result.ExecutionRecords.Length}");
            }

            if (!result.Success && result.ErrorMessage != null)
            {
                Console.WriteLine($"Error:         {result.ErrorMessage}");
            }
        }
        else
        {
            Console.WriteLine("Failed to load PE file");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception: {ex.Message}");
        Console.WriteLine(ex.StackTrace);
    }

    return;
}

// PSP/MIPS Emulator Test
if (args.Length > 0 && args[0] == "--psp-run")
{
    Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
    Console.WriteLine("║           SharpVM - MIPS/Allegrex CPU Emulator                ║");
    Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
    Console.WriteLine();

    var cpu = new SharpVM.PSP.CPU.MipsCpu();

    // Load a simple test program
    Console.WriteLine("Loading test program...\n");

    // Simple MIPS test program:
    // lui $t0, 0x1234       # t0 = 0x12340000
    // ori $t0, $t0, 0x5678  # t0 = 0x12345678
    // addiu $t1, $zero, 10  # t1 = 10
    // addiu $t2, $zero, 20  # t2 = 20
    // addu $t3, $t1, $t2    # t3 = t1 + t2 = 30
    // syscall               # print result

    uint[] testCode = {
        0x3C081234,  // lui $t0, 0x1234
        0x35085678,  // ori $t0, $t0, 0x5678
        0x2409000A,  // addiu $t1, $zero, 10
        0x240A0014,  // addiu $t2, $zero, 20
        0x012A5821,  // addu $t3, $t1, $t2
        0x0000000C,  // syscall
        0x00000000,  // nop (for delay slot)
    };

    // Load at address 0x08800000 (typical PSP user mode)
    uint loadAddr = 0x08800000;
    for (int i = 0; i < testCode.Length; i++)
    {
        cpu.WriteWord(loadAddr + (uint)(i * 4), testCode[i]);
    }

    cpu.Regs.PC = loadAddr;

    // Disassemble
    cpu.Disassemble(loadAddr, testCode.Length);

    // Run
    Console.WriteLine("\n=== Execution ===");
    cpu.Run(100);

    // Show registers
    Console.WriteLine();
    cpu.Regs.Dump();

    Console.WriteLine($"\nInstructions executed: {cpu.InstructionCount}");
    Console.WriteLine($"t0 = 0x{cpu.Regs[SharpVM.PSP.CPU.MipsRegisters.T0]:X8} (expected: 0x12345678)");
    Console.WriteLine($"t1 = {cpu.Regs[SharpVM.PSP.CPU.MipsRegisters.T1]} (expected: 10)");
    Console.WriteLine($"t2 = {cpu.Regs[SharpVM.PSP.CPU.MipsRegisters.T2]} (expected: 20)");
    Console.WriteLine($"t3 = {cpu.Regs[SharpVM.PSP.CPU.MipsRegisters.T3]} (expected: 30)");

    return;
}

Console.WriteLine("╔═══════════════════════════════════════════════════════════════╗");
Console.WriteLine("║              SharpVM - VMProtect-Style Virtual Machine        ║");
Console.WriteLine("║         Stack-based VM with rolling key bytecode encryption   ║");
Console.WriteLine("╚═══════════════════════════════════════════════════════════════╝");
Console.WriteLine();
Console.WriteLine("Usage:");
Console.WriteLine("  SharpVM                          - Run basic demos");
Console.WriteLine("  SharpVM --advanced               - Run algorithm demos (GCD, FizzBuzz, etc.)");
Console.WriteLine("  SharpVM --analyze <file>         - Universal binary analysis (crypto, obfuscation)");
Console.WriteLine("    Options: -v (verbose), -o <path> (output report)");
Console.WriteLine("  SharpVM --inject <exe>           - Load and execute a PE binary through VM");
Console.WriteLine("  SharpVM --inject <exe> --analyze - Analyze PE binary without execution");
Console.WriteLine("  SharpVM --inject <exe> --trace   - Execute with full instruction tracing");
Console.WriteLine("  SharpVM --blackbone <pe-file>    - Manual PE mapper (Blackbone-style)");
Console.WriteLine("    Options: -i (interactive), -x (execute), -t (trace), -d (debug)");
Console.WriteLine("  SharpVM --sogen <pe-file>        - Load PE with Sogen Windows emulator");
Console.WriteLine("    Options: -t (trace syscalls)");
Console.WriteLine("  SharpVM --hybrid <pe-file>       - Hybrid execution (hypervisor + emulation)");
Console.WriteLine("    Options: -t (trace), --mode=<hybrid|hypervisor|emulation>");
Console.WriteLine("  SharpVM --bios                   - Launch BIOS viewer (placeholder)");
Console.WriteLine("  SharpVM --bios-run [bios.bin]    - Run x86 CPU emulator with BIOS");
Console.WriteLine("  SharpVM --boot-cdrom [bios] [iso] - Boot from CD-ROM ISO");
Console.WriteLine("  SharpVM --psp-analyze [file]     - Analyze PSP firmware (SCEUF format)");
Console.WriteLine("  SharpVM --psp-run                - Test MIPS/Allegrex CPU emulator");
Console.WriteLine();

// Run basic demos
DemoBasicArithmetic();
DemoFibonacci();
DemoLoopAndConditional();
DemoAssembler();
DemoMemoryOperations();
DemoBytecodeEncryption();

Console.WriteLine("\nBasic demos completed!");

// === Demo Functions ===

void DemoBasicArithmetic()
{
    Console.WriteLine("═══ Demo 1: Basic Arithmetic (10 + 20) * 3 ═══");

    var engine = new VmEngine();
    var builder = new BytecodeBuilder(0xDEADBEEF);

    // Calculate (10 + 20) * 3 = 90
    builder.EmitPushImm8(10);      // Push 10
    builder.EmitPushImm8(20);      // Push 20
    builder.EmitAdd();             // 10 + 20 = 30
    builder.EmitPushImm8(3);       // Push 3
    builder.EmitMul();             // 30 * 3 = 90
    builder.EmitSyscall((byte)VmSyscall.PrintInt);  // Print result
    builder.EmitPushImm8((byte)'\n');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);
    builder.EmitVmExit();

    var bytecode = builder.Build();
    engine.LoadBytecode(bytecode, builder.InitialKey);
    engine.Execute();

    Console.WriteLine($"Instructions executed: {engine.InstructionCount}");
    Console.WriteLine();
}

void DemoFibonacci()
{
    Console.WriteLine("═══ Demo 2: Fibonacci Sequence (using registers) ═══");

    var engine = new VmEngine();
    var builder = new BytecodeBuilder(0xCAFEBABE);

    // Use virtual registers for cleaner Fibonacci
    // VR0 = fib(n-2), VR1 = fib(n-1), VR2 = temp

    builder.EmitMovVRegImm(VirtualRegister.VR0, 0);  // fib(0) = 0
    builder.EmitMovVRegImm(VirtualRegister.VR1, 1);  // fib(1) = 1

    // Print first 10 Fibonacci numbers using unrolled loop
    for (int i = 0; i < 10; i++)
    {
        // Print VR0 (current fib number)
        builder.EmitPushVReg(VirtualRegister.VR0);
        builder.EmitSyscall((byte)VmSyscall.PrintInt);
        builder.EmitPushImm8((byte)' ');
        builder.EmitSyscall((byte)VmSyscall.PrintChar);

        // VR2 = VR0 + VR1 (next fib)
        builder.EmitPushVReg(VirtualRegister.VR0);
        builder.EmitPushVReg(VirtualRegister.VR1);
        builder.EmitAdd();
        builder.EmitPopVReg(VirtualRegister.VR2);

        // Shift: VR0 = VR1, VR1 = VR2
        builder.EmitMovVRegVReg(VirtualRegister.VR0, VirtualRegister.VR1);
        builder.EmitMovVRegVReg(VirtualRegister.VR1, VirtualRegister.VR2);
    }

    builder.EmitPushImm8((byte)'\n');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);
    builder.EmitVmExit();

    var bytecode = builder.Build();
    engine.LoadBytecode(bytecode, builder.InitialKey);
    engine.Execute();

    Console.WriteLine($"Instructions executed: {engine.InstructionCount}");
    Console.WriteLine();
}

void DemoLoopAndConditional()
{
    Console.WriteLine("═══ Demo 3: Bitwise Operations Demo ═══");

    var engine = new VmEngine();
    var builder = new BytecodeBuilder(0x12345678);

    // Demo XOR: 0xFF XOR 0xAA = 0x55 (use 32-bit to avoid sign extension)
    builder.EmitPushImm32(0xFF);
    builder.EmitPushImm32(0xAA);
    builder.EmitXor();
    builder.EmitSyscall((byte)VmSyscall.PrintHex);
    builder.EmitPushImm8((byte)' ');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);

    // Demo AND: 0xF0 AND 0x3C = 0x30
    builder.EmitPushImm32(0xF0);
    builder.EmitPushImm32(0x3C);
    builder.EmitAnd();
    builder.EmitSyscall((byte)VmSyscall.PrintHex);
    builder.EmitPushImm8((byte)' ');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);

    // Demo OR: 0xF0 OR 0x0F = 0xFF
    builder.EmitPushImm32(0xF0);
    builder.EmitPushImm32(0x0F);
    builder.EmitOr();
    builder.EmitSyscall((byte)VmSyscall.PrintHex);
    builder.EmitPushImm8((byte)' ');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);

    // Demo SHL: 1 << 4 = 16
    builder.EmitPushImm8(1);
    builder.EmitPushImm8(4);
    builder.EmitShl();
    builder.EmitSyscall((byte)VmSyscall.PrintInt);

    builder.EmitPushImm8((byte)'\n');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);
    builder.EmitVmExit();

    var bytecode = builder.Build();
    engine.LoadBytecode(bytecode, builder.InitialKey);
    engine.Execute();

    Console.WriteLine($"Instructions executed: {engine.InstructionCount}");
    Console.WriteLine();
}

void DemoAssembler()
{
    Console.WriteLine("═══ Demo 4: Using the Assembler ═══");

    // Simple program without jumps to demonstrate assembler
    string source = @"
        ; Calculate (5 + 3) * 2 using assembler
        PUSH 5              ; Push 5
        PUSH 3              ; Push 3
        ADD                 ; 5 + 3 = 8
        PUSH 2              ; Push 2
        MUL                 ; 8 * 2 = 16

        ; Print result
        SYSCALL PrintInt
        PUSH 10             ; newline
        SYSCALL PrintChar

        VMEXIT
    ";

    var assembler = new VmAssembler(0xFEEDFACE);
    var bytecode = assembler.Assemble(source);

    Console.WriteLine("Assembled bytecode (encrypted):");
    Console.Write("  ");
    for (int i = 0; i < Math.Min(32, bytecode.Length); i++)
        Console.Write($"{bytecode.RawBytecode[i]:X2} ");
    Console.WriteLine(bytecode.Length > 32 ? "..." : "");
    Console.WriteLine();

    var engine = new VmEngine();
    engine.LoadBytecode(bytecode, assembler.InitialKey);

    Console.Write("Output: ");
    engine.Execute();

    Console.WriteLine($"Instructions executed: {engine.InstructionCount}");
    Console.WriteLine();
}

void DemoMemoryOperations()
{
    Console.WriteLine("═══ Demo 5: Memory Operations (Store and Load) ═══");

    var engine = new VmEngine();
    var builder = new BytecodeBuilder(0xABCDEF01);

    // Store "Hi!" string at memory address 0x100
    builder.EmitPushImm32(0x100);      // Address
    builder.EmitPushImm8((byte)'H');   // Value
    builder.EmitOpcode(VmOpcode.STORE8);

    builder.EmitPushImm32(0x101);
    builder.EmitPushImm8((byte)'i');
    builder.EmitOpcode(VmOpcode.STORE8);

    builder.EmitPushImm32(0x102);
    builder.EmitPushImm8((byte)'!');
    builder.EmitOpcode(VmOpcode.STORE8);

    builder.EmitPushImm32(0x103);
    builder.EmitPushImm8(0);           // Null terminator
    builder.EmitOpcode(VmOpcode.STORE8);

    // Load and print each character
    for (int i = 0; i < 3; i++)
    {
        builder.EmitPushImm32((uint)(0x100 + i));
        builder.EmitOpcode(VmOpcode.LOAD8);
        builder.EmitSyscall((byte)VmSyscall.PrintChar);
    }

    builder.EmitPushImm8((byte)'\n');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);

    // Store a 64-bit value and read it back
    builder.EmitPushImm32(0x200);
    builder.EmitPushImm64(0xDEADBEEFCAFEBABE);
    builder.EmitOpcode(VmOpcode.STORE64);

    builder.EmitPushImm32(0x200);
    builder.EmitOpcode(VmOpcode.LOAD64);
    builder.EmitSyscall((byte)VmSyscall.PrintHex);
    builder.EmitPushImm8((byte)'\n');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);

    builder.EmitVmExit();

    var bytecode = builder.Build();
    engine.LoadBytecode(bytecode, builder.InitialKey);
    engine.Execute();

    Console.WriteLine($"Instructions executed: {engine.InstructionCount}");
    Console.WriteLine();
}

void DemoBytecodeEncryption()
{
    Console.WriteLine("═══ Demo 6: Rolling Key Encryption Demo ═══");

    ulong key = 0x1234567890ABCDEF;
    var builder = new BytecodeBuilder(key);

    // Simple program: push 42, print, exit
    builder.EmitPushImm8(42);
    builder.EmitSyscall((byte)VmSyscall.PrintInt);
    builder.EmitPushImm8((byte)'\n');
    builder.EmitSyscall((byte)VmSyscall.PrintChar);
    builder.EmitVmExit();

    var bytecode = builder.Build();

    Console.WriteLine($"Initial rolling key: 0x{key:X16}");
    Console.WriteLine();

    Console.WriteLine("Encrypted bytecode (raw bytes):");
    Console.Write("  ");
    foreach (byte b in bytecode.RawBytecode)
        Console.Write($"{b:X2} ");
    Console.WriteLine();
    Console.WriteLine();

    // Decrypt and show
    Console.WriteLine("Decrypted opcodes:");
    ulong decryptKey = key;
    for (int i = 0; i < bytecode.Length; i++)
    {
        ulong keyBefore = decryptKey;
        byte decrypted = bytecode.DecryptByte(i, ref decryptKey);
        Console.WriteLine($"  [{i}] Encrypted: 0x{bytecode.RawBytecode[i]:X2} -> " +
                         $"Decrypted: 0x{decrypted:X2} " +
                         $"(Key: 0x{keyBefore:X16} -> 0x{decryptKey:X16})");
    }
    Console.WriteLine();

    // Execute
    var engine = new VmEngine();
    engine.LoadBytecode(bytecode, key);
    Console.Write("Execution output: ");
    engine.Execute();
    Console.WriteLine();
}