using System;
using System.IO;
using STCompiler.Common;
using System.Collections.Generic;
using System.Diagnostics;

class Program {
    static int Main(string[] args) {
        bool verbose = true; // Default to verbose mode
        if (args.Length > 0 && args[0] == "--verbose") {
            verbose = true;
            args = args[1..]; // Remove the --verbose argument from further processing
        } else {
            verbose = false;          
        }
        
        if (args.Length < 1) {
            Console.WriteLine("Usage: StSim [--verbose|--quiet] <file.stbc>");
            return 1;
        }
        var path = args[0];
        if (!File.Exists(path)) { Console.WriteLine("File not found: " + path); return 2; }
        var data = File.ReadAllBytes(path);
        try { Simulate(data, verbose); } catch(Exception ex) { Console.WriteLine("Error: " + ex.Message); return 3; }
        return 0;
    }

    static void Simulate(byte[] data, bool verbose) {
        using var ms = new MemoryStream(data);
        using var r = new BinaryReader(ms);

        string magic = System.Text.Encoding.ASCII.GetString(r.ReadBytes(4));
        if (magic != Bytecode.Magic) throw new Exception("Invalid magic");
        ushort ver = r.ReadUInt16();
        if (verbose) Console.WriteLine($"Version: {ver}");
        bool oldFormat = ver < Bytecode.Version;
        ushort cycletime = r.ReadUInt16();
        if (verbose) Console.WriteLine($"Cycle: {cycletime} ms");  
        ushort nConsts = r.ReadUInt16();
        if (verbose) Console.WriteLine($"Consts: {nConsts}");
        var consts = new List<object>();
        if (oldFormat) {
            // old format: constants stored as 4-byte ints
            for (int i = 0; i < nConsts; i++) { int v = r.ReadInt32(); consts.Add(v); if (verbose) Console.WriteLine($"  [{i}] = {v}"); }
        } else {
            for (int i = 0; i < nConsts; i++) {
                byte t = r.ReadByte();
                switch(t) {
                    case 1: { long v = r.ReadInt64(); consts.Add(v); if (verbose) Console.WriteLine($"  [{i}] (long) = {v}"); break; }
                    case 2: { double v = r.ReadDouble(); consts.Add(v); if (verbose) Console.WriteLine($"  [{i}] (double) = {v}"); break; }
                    case 3: { float v = r.ReadSingle(); consts.Add(v); if (verbose) Console.WriteLine($"  [{i}] (float) = {v}"); break; }
                    case 4: { int v = r.ReadInt32(); consts.Add(v); if (verbose) Console.WriteLine($"  [{i}] (int) = {v}"); break; }
                    default: { if (verbose) Console.WriteLine($"  [{i}] Unknown const type {t}"); break; }
                }
            }
        }

        ushort nVars = r.ReadUInt16();
        if (verbose) Console.WriteLine($"Vars: {nVars}");
        var varTypes = new byte[nVars];
        for (int i = 0; i < nVars; i++) { varTypes[i] = r.ReadByte(); if (verbose) Console.WriteLine($"  Var[{i}] type = {varTypes[i]}"); }

        ushort codeLen = r.ReadUInt16();
        if (verbose) Console.WriteLine($"CodeLen: {codeLen} bytes");
        var code = r.ReadBytes(codeLen);

        // Initialize arrays for element type tracking
        var arrayRanges = new Dictionary<int, (int start, int length, VarType elementType)>();
        if (verbose) Console.WriteLine("\nAnalyzing variable types:");
        for (int i = 0; i < nVars; i++) {
            if (verbose) Console.WriteLine($"  [{i}] = {(VarType)varTypes[i]}");
        }
        
        if (verbose) Console.WriteLine("\nDetecting arrays:");
        for (int i = 0; i < nVars; i++) {
            if (varTypes[i] == (byte)VarType.ARRAY && i + 2 <= nVars) {
                // An array consists of:
                // - ARRAY marker at position i
                // - ElementType at position i+1
                // - Array elements starting at position i+2
                int arrayStart = i;
                VarType elementType = (VarType)varTypes[i + 1];
                int startOfElements = i + 2;
                
                // Count elements until we hit either end of vars or a different type
                int length = 0;
                for (int j = startOfElements; j < nVars; j++) {
                    if (varTypes[j] != (byte)elementType) break;
                    length++;
                }
                
                arrayRanges[arrayStart] = (startOfElements, length, elementType);
                if (verbose) {
                    Console.WriteLine($"Found array at index {arrayStart}:");
                    Console.WriteLine($"  - Element type: {elementType}");
                    Console.WriteLine($"  - Elements start at: {startOfElements}");
                    Console.WriteLine($"  - Length: {length}");
                }
                
                // Skip past the array definition (ARRAY marker + element type)
                i = startOfElements - 1;
            }
        }

        var stack = new Stack<object>();
        var vars = new object[nVars];
        int ip = 0;
        var opcodeExecutionTimes = new Dictionary<byte, long>();
        var opcodeCounts = new Dictionary<byte, int>();
        var stopwatch = new Stopwatch();
        
        if (verbose) Console.WriteLine("\n--- Disassembly / Simulation ---");
        while (ip < code.Length) {
            int addr = ip;
            byte op = code[ip++];
            if (verbose) Console.Write($"{addr:0000}: 0x{op:X2}  ");
            
            // Track opcode execution time
            stopwatch.Restart();
            
            switch (op) {
                case Bytecode.OpCodes.NOP: if (verbose) Console.WriteLine("NOP"); break;
                case Bytecode.OpCodes.PUSH_CONST: {
                    ushort ci = (ushort)(code[ip++] | (code[ip++] << 8));
                    if (oldFormat) { byte typeMarker = code[ip++]; /* skip legacy type byte */ }
                    if (verbose) Console.WriteLine($"PUSH_CONST {ci} ({consts[ci]})");
                    stack.Push(consts[ci]);
                    break; }
                case Bytecode.OpCodes.PUSH_REAL_CONST: {
                    ushort ci = (ushort)(code[ip++] | (code[ip++] << 8));
                    if (oldFormat) { byte typeMarker = code[ip++]; /* skip legacy type byte */ }
                    if (verbose) Console.WriteLine($"PUSH_REAL_CONST {ci} ({consts[ci]})");
                    stack.Push(consts[ci]);
                    break; }
                case Bytecode.OpCodes.LOAD_VAR: { 
                    ushort vi = (ushort)(code[ip++] | (code[ip++] << 8)); 
                    if (verbose) Console.WriteLine($"LOAD_VAR {vi}"); 
                    
                    // Check if the variable index is within bounds
                    if (vi >= vars.Length) {
                        throw new Exception($"Variable index {vi} is out of bounds (max: {vars.Length - 1})");
                    }
                    
                    if (arrayRanges.ContainsKey(vi)) {
                        var (start, arrayLength, arrayElementType) = arrayRanges[vi];
                        var arrayData = new object[arrayLength];
                        Array.Copy(vars, start, arrayData, 0, arrayLength);
                        stack.Push(arrayData);
                    } else {
                        stack.Push(vars[vi]);
                    }
                    break; 
                }
                case Bytecode.OpCodes.STORE_VAR: { 
                    ushort vi = (ushort)(code[ip++] | (code[ip++] << 8)); 
                    if (verbose) Console.WriteLine($"STORE_VAR {vi}"); 
                    
                    // Check if the variable index is within bounds
                    if (vi >= vars.Length) {
                        throw new Exception($"Variable index {vi} is out of bounds (max: {vars.Length - 1})");
                    }
                    
                    var value = stack.Pop();
                    if (arrayRanges.ContainsKey(vi)) {
                        var (start, arrayLength, arrayElementType) = arrayRanges[vi];
                        if (value is object[] arr) {
                            Array.Copy(arr, 0, vars, start, Math.Min(arr.Length, arrayLength));
                        } else {
                            if (verbose) Console.WriteLine($"Warning: Attempting to store non-array value in array variable at index {vi}");
                            vars[vi] = value;
                        }
                    } else {
                        vars[vi] = value;
                    }
                    break; 
                }
                case Bytecode.OpCodes.JZ: { ushort target = (ushort)(code[ip++] | (code[ip++] << 8)); if (verbose) Console.WriteLine($"JZ addr={target:0000}"); var cond = stack.Pop(); bool isFalse = cond is int ci ? ci == 0 : cond is long cl ? cl == 0L : cond is double cd ? cd == 0.0 : cond == null; if (isFalse) ip = target; break; }
                case Bytecode.OpCodes.JMP: { 
                    ushort target = (ushort)(code[ip++] | (code[ip++] << 8)); 
                    if (verbose) Console.WriteLine($"JMP addr={target:0000}"); 
                    ip = target; 
                    break; 
                }
                case Bytecode.OpCodes.HALT: 
                    if (verbose) Console.WriteLine("HALT"); 
                    ip = code.Length; 
                    break;
                case Bytecode.OpCodes.ARRAY_BOUNDS_CHECK:
                    // Extract the array index from the instruction
                    byte arrayIndex = 0;
                    if (ip < code.Length) {
                        arrayIndex = code[ip];
                        ip++;
                    }
                    
                    // Check if this variable is actually an array
                    if (!arrayRanges.ContainsKey(arrayIndex)) {
                        if (verbose) Console.WriteLine($"Warning: ARRAY_BOUNDS_CHECK instruction for non-array variable {arrayIndex}");
                        continue;  // Skip this instruction
                    }
                    
                    if (verbose) Console.WriteLine($"ARRAY_BOUNDS_CHECK for array at index {arrayIndex}");
                    
                    if (stack.Count < 1) {
                        throw new Exception("Stack underflow during array bounds check");
                    }

                    // Convert index value safely
                    var indexObj = stack.Pop();
                    int index = Convert.ToInt32(indexObj);
                    
                    // The arrayStart from the instruction should be the array marker directly
                    if (!arrayRanges.TryGetValue(arrayIndex, out var arrayInfo)) {
                        // This should not happen since we checked above
                        throw new Exception($"Array metadata missing for index {arrayIndex}");
                    }
                    
                    var (elementsStart, length, elementType) = arrayInfo;
                    
                    // Adjust for IEC array indexing (1-based)
                    int adjustedIndex = index - 1;
                    if (adjustedIndex < 0 || adjustedIndex >= length) {
                        throw new Exception($"Array index {index} out of bounds [1..{length}]");
                    }
                    
                    // Calculate the actual element address
                    stack.Push(elementsStart + adjustedIndex);
                    if (verbose) Console.WriteLine($"Accessing element {index} of array, mapped to variable index {elementsStart + adjustedIndex}");
                    break;
                default: 
                    // fallback handlers
                    if (Bytecode.OpName(op).StartsWith("ADD_") || Bytecode.OpName(op).StartsWith("SUB_") || Bytecode.OpName(op).StartsWith("MUL_") || Bytecode.OpName(op).StartsWith("DIV_")) {
                        dynamic b = stack.Pop(); dynamic a = stack.Pop(); 
                        if (Bytecode.OpName(op).StartsWith("ADD_")) stack.Push(a + b); 
                        else if (Bytecode.OpName(op).StartsWith("SUB_")) stack.Push(a - b); 
                        else if (Bytecode.OpName(op).StartsWith("MUL_")) stack.Push(a * b); 
                        else stack.Push(a / b);
                        break;
                    }
                    if (Bytecode.OpName(op).StartsWith("LT_") || Bytecode.OpName(op).StartsWith("GT_") || Bytecode.OpName(op).StartsWith("LE_") || Bytecode.OpName(op).StartsWith("GE_") || Bytecode.OpName(op).StartsWith("EQ_") || Bytecode.OpName(op).StartsWith("NEQ_")) {
                        dynamic rVal = stack.Pop(); dynamic lVal = stack.Pop();
                        // Optimized comparison handler with type-specific operations
                        switch (op) {
                            // Signed comparisons
                            case Bytecode.OpCodes.LT_SINT: 
                                if (lVal is byte lb_s && rVal is byte rb_s) stack.Push(lb_s < rb_s ? 1 : 0);
                                else if (lVal is short ls_s && rVal is short rs_s) stack.Push(ls_s < rs_s ? 1 : 0);
                                else if (lVal is int li1_s && rVal is int ri1_s) stack.Push(li1_s < ri1_s ? 1 : 0);
                                else if (lVal is long ll_s && rVal is long rl_s) stack.Push(ll_s < rl_s ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) < Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_SINT: 
                                if (lVal is byte lb_gt && rVal is byte rb_gt) stack.Push(lb_gt > rb_gt ? 1 : 0);
                                else if (lVal is short ls_gt && rVal is short rs_gt) stack.Push(ls_gt > rs_gt ? 1 : 0);
                                else if (lVal is int li2_gt && rVal is int ri2_gt) stack.Push(li2_gt > ri2_gt ? 1 : 0);
                                else if (lVal is long ll_gt && rVal is long rl_gt) stack.Push(ll_gt > rl_gt ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) > Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_SINT: 
                                if (lVal is byte lb_le && rVal is byte rb_le) stack.Push(lb_le <= rb_le ? 1 : 0);
                                else if (lVal is short ls_le && rVal is short rs_le) stack.Push(ls_le <= rs_le ? 1 : 0);
                                else if (lVal is int li3_le && rVal is int ri3_le) stack.Push(li3_le <= ri3_le ? 1 : 0);
                                else if (lVal is long ll_le && rVal is long rl_le) stack.Push(ll_le <= rl_le ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) <= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_SINT: 
                                if (lVal is byte lb_ge && rVal is byte rb_ge) stack.Push(lb_ge >= rb_ge ? 1 : 0);
                                else if (lVal is short ls_ge && rVal is short rs_ge) stack.Push(ls_ge >= rs_ge ? 1 : 0);
                                else if (lVal is int li4_ge && rVal is int ri4_ge) stack.Push(li4_ge >= ri4_ge ? 1 : 0);
                                else if (lVal is long ll_ge && rVal is long rl_ge) stack.Push(ll_ge >= rl_ge ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) >= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_SINT: 
                                if (lVal is byte lb_eq && rVal is byte rb_eq) stack.Push(lb_eq == rb_eq ? 1 : 0);
                                else if (lVal is short ls_eq && rVal is short rs_eq) stack.Push(ls_eq == rs_eq ? 1 : 0);
                                else if (lVal is int li5_eq && rVal is int ri5_eq) stack.Push(li5_eq == ri5_eq ? 1 : 0);
                                else if (lVal is long ll_eq && rVal is long rl_eq) stack.Push(ll_eq == rl_eq ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_SINT: 
                                if (lVal is byte lb_ne && rVal is byte rb_ne) stack.Push(lb_ne != rb_ne ? 1 : 0);
                                else if (lVal is short ls_ne && rVal is short rs_ne) stack.Push(ls_ne != rs_ne ? 1 : 0);
                                else if (lVal is int li6_ne && rVal is int ri6_ne) stack.Push(li6_ne != ri6_ne ? 1 : 0);
                                else if (lVal is long ll_ne && rVal is long rl_ne) stack.Push(ll_ne != rl_ne ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_INT: 
                                if (lVal is byte lb_lt && rVal is byte rb_lt) stack.Push(lb_lt < rb_lt ? 1 : 0);
                                else if (lVal is short ls_lt && rVal is short rs_lt) stack.Push(ls_lt < rs_lt ? 1 : 0);
                                else if (lVal is int li1_lt && rVal is int ri1_lt) stack.Push(li1_lt < ri1_lt ? 1 : 0);
                                else if (lVal is long ll_lt && rVal is long rl_lt) stack.Push(ll_lt < rl_lt ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) < Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_INT: 
                                if (lVal is byte lb_gt2 && rVal is byte rb_gt2) stack.Push(lb_gt2 > rb_gt2 ? 1 : 0);
                                else if (lVal is short ls_gt2 && rVal is short rs_gt2) stack.Push(ls_gt2 > rs_gt2 ? 1 : 0);
                                else if (lVal is int li2_gt2 && rVal is int ri2_gt2) stack.Push(li2_gt2 > ri2_gt2 ? 1 : 0);
                                else if (lVal is long ll_gt2 && rVal is long rl_gt2) stack.Push(ll_gt2 > rl_gt2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) > Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_INT: 
                                if (lVal is byte lb_le2 && rVal is byte rb_le2) stack.Push(lb_le2 <= rb_le2 ? 1 : 0);
                                else if (lVal is short ls_le2 && rVal is short rs_le2) stack.Push(ls_le2 <= rs_le2 ? 1 : 0);
                                else if (lVal is int li3_le2 && rVal is int ri3_le2) stack.Push(li3_le2 <= ri3_le2 ? 1 : 0);
                                else if (lVal is long ll_le2 && rVal is long rl_le2) stack.Push(ll_le2 <= rl_le2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) <= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_INT: 
                                if (lVal is byte lb_ge2 && rVal is byte rb_ge2) stack.Push(lb_ge2 >= rb_ge2 ? 1 : 0);
                                else if (lVal is short ls_ge2 && rVal is short rs_ge2) stack.Push(ls_ge2 >= rs_ge2 ? 1 : 0);
                                else if (lVal is int li4_ge2 && rVal is int ri4_ge2) stack.Push(li4_ge2 >= ri4_ge2 ? 1 : 0);
                                else if (lVal is long ll_ge2 && rVal is long rl_ge2) stack.Push(ll_ge2 >= rl_ge2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) >= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_INT: 
                                if (lVal is byte lb_eq2 && rVal is byte rb_eq2) stack.Push(lb_eq2 == rb_eq2 ? 1 : 0);
                                else if (lVal is short ls_eq2 && rVal is short rs_eq2) stack.Push(ls_eq2 == rs_eq2 ? 1 : 0);
                                else if (lVal is int li5_eq2 && rVal is int ri5_eq2) stack.Push(li5_eq2 == ri5_eq2 ? 1 : 0);
                                else if (lVal is long ll_eq2 && rVal is long rl_eq2) stack.Push(ll_eq2 == rl_eq2 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_INT: 
                                if (lVal is byte lb_ne2 && rVal is byte rb_ne2) stack.Push(lb_ne2 != rb_ne2 ? 1 : 0);
                                else if (lVal is short ls_ne2 && rVal is short rs_ne2) stack.Push(ls_ne2 != rs_ne2 ? 1 : 0);
                                else if (lVal is int li6_ne2 && rVal is int ri6_ne2) stack.Push(li6_ne2 != ri6_ne2 ? 1 : 0);
                                else if (lVal is long ll_ne2 && rVal is long rl_ne2) stack.Push(ll_ne2 != rl_ne2 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_DINT: 
                                if (lVal is byte lb_dint && rVal is byte rb_dint) stack.Push(lb_dint < rb_dint ? 1 : 0);
                                else if (lVal is short ls_dint && rVal is short rs_dint) stack.Push(ls_dint < rs_dint ? 1 : 0);
                                else if (lVal is int li1_dint && rVal is int ri1_dint) stack.Push(li1_dint < ri1_dint ? 1 : 0);
                                else if (lVal is long ll_dint && rVal is long rl_dint) stack.Push(ll_dint < rl_dint ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) < Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_DINT: 
                                if (lVal is byte lb_dint2 && rVal is byte rb_dint2) stack.Push(lb_dint2 > rb_dint2 ? 1 : 0);
                                else if (lVal is short ls_dint2 && rVal is short rs_dint2) stack.Push(ls_dint2 > rs_dint2 ? 1 : 0);
                                else if (lVal is int li2_dint && rVal is int ri2_dint) stack.Push(li2_dint > ri2_dint ? 1 : 0);
                                else if (lVal is long ll_dint2 && rVal is long rl_dint2) stack.Push(ll_dint2 > rl_dint2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) > Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_DINT: 
                                if (lVal is byte lb_dint3 && rVal is byte rb_dint3) stack.Push(lb_dint3 <= rb_dint3 ? 1 : 0);
                                else if (lVal is short ls_dint3 && rVal is short rs_dint3) stack.Push(ls_dint3 <= rs_dint3 ? 1 : 0);
                                else if (lVal is int li3_dint && rVal is int ri3_dint) stack.Push(li3_dint <= ri3_dint ? 1 : 0);
                                else if (lVal is long ll_dint3 && rVal is long rl_dint3) stack.Push(ll_dint3 <= rl_dint3 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) <= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_DINT: 
                                if (lVal is byte lb_dint4 && rVal is byte rb_dint4) stack.Push(lb_dint4 >= rb_dint4 ? 1 : 0);
                                else if (lVal is short ls_dint4 && rVal is short rs_dint4) stack.Push(ls_dint4 >= rs_dint4 ? 1 : 0);
                                else if (lVal is int li4_dint && rVal is int ri4_dint) stack.Push(li4_dint >= ri4_dint ? 1 : 0);
                                else if (lVal is long ll_dint4 && rVal is long rl_dint4) stack.Push(ll_dint4 >= rl_dint4 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) >= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_DINT: 
                                if (lVal is byte lb_dint5 && rVal is byte rb_dint5) stack.Push(lb_dint5 == rb_dint5 ? 1 : 0);
                                else if (lVal is short ls_dint5 && rVal is short rs_dint5) stack.Push(ls_dint5 == rs_dint5 ? 1 : 0);
                                else if (lVal is int li5_dint && rVal is int ri5_dint) stack.Push(li5_dint == ri5_dint ? 1 : 0);
                                else if (lVal is long ll_dint5 && rVal is long rl_dint5) stack.Push(ll_dint5 == rl_dint5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_DINT: 
                                if (lVal is byte lb_dint6 && rVal is byte rb_dint6) stack.Push(lb_dint6 != rb_dint6 ? 1 : 0);
                                else if (lVal is short ls_dint6 && rVal is short rs_dint6) stack.Push(ls_dint6 != rs_dint6 ? 1 : 0);
                                else if (lVal is int li6_dint && rVal is int ri6_dint) stack.Push(li6_dint != ri6_dint ? 1 : 0);
                                else if (lVal is long ll_dint6 && rVal is long rl_dint6) stack.Push(ll_dint6 != rl_dint6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_LINT: 
                                if (lVal is byte lb_lint && rVal is byte rb_lint) stack.Push(lb_lint < rb_lint ? 1 : 0);
                                else if (lVal is short ls_lint && rVal is short rs_lint) stack.Push(ls_lint < rs_lint ? 1 : 0);
                                else if (lVal is int li1_lint && rVal is int ri1_lint) stack.Push(li1_lint < ri1_lint ? 1 : 0);
                                else if (lVal is long ll_lint && rVal is long rl_lint) stack.Push(ll_lint < rl_lint ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) < Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_LINT: 
                                if (lVal is byte lb_lint2 && rVal is byte rb_lint2) stack.Push(lb_lint2 > rb_lint2 ? 1 : 0);
                                else if (lVal is short ls_lint2 && rVal is short rs_lint2) stack.Push(ls_lint2 > rs_lint2 ? 1 : 0);
                                else if (lVal is int li2_lint && rVal is int ri2_lint) stack.Push(li2_lint > ri2_lint ? 1 : 0);
                                else if (lVal is long ll_lint2 && rVal is long rl_lint2) stack.Push(ll_lint2 > rl_lint2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) > Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_LINT: 
                                if (lVal is byte lb_lint3 && rVal is byte rb_lint3) stack.Push(lb_lint3 <= rb_lint3 ? 1 : 0);
                                else if (lVal is short ls_lint3 && rVal is short rs_lint3) stack.Push(ls_lint3 <= rs_lint3 ? 1 : 0);
                                else if (lVal is int li3_lint && rVal is int ri3_lint) stack.Push(li3_lint <= ri3_lint ? 1 : 0);
                                else if (lVal is long ll_lint3 && rVal is long rl_lint3) stack.Push(ll_lint3 <= rl_lint3 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) <= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_LINT: 
                                if (lVal is byte lb_lint4 && rVal is byte rb_lint4) stack.Push(lb_lint4 >= rb_lint4 ? 1 : 0);
                                else if (lVal is short ls_lint4 && rVal is short rs_lint4) stack.Push(ls_lint4 >= rs_lint4 ? 1 : 0);
                                else if (lVal is int li4_lint && rVal is int ri4_lint) stack.Push(li4_lint >= ri4_lint ? 1 : 0);
                                else if (lVal is long ll_lint4 && rVal is long rl_lint4) stack.Push(ll_lint4 >= rl_lint4 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) >= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_LINT: 
                                if (lVal is byte lb_lint5 && rVal is byte rb_lint5) stack.Push(lb_lint5 == rb_lint5 ? 1 : 0);
                                else if (lVal is short ls_lint5 && rVal is short rs_lint5) stack.Push(ls_lint5 == rs_lint5 ? 1 : 0);
                                else if (lVal is int li5_lint && rVal is int ri5_lint) stack.Push(li5_lint == ri5_lint ? 1 : 0);
                                else if (lVal is long ll_lint5 && rVal is long rl_lint5) stack.Push(ll_lint5 == rl_lint5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_LINT: 
                                if (lVal is byte lb_lint6 && rVal is byte rb_lint6) stack.Push(lb_lint6 != rb_lint6 ? 1 : 0);
                                else if (lVal is short ls_lint6 && rVal is short rs_lint6) stack.Push(ls_lint6 != rs_lint6 ? 1 : 0);
                                else if (lVal is int li6_lint && rVal is int ri6_lint) stack.Push(li6_lint != ri6_lint ? 1 : 0);
                                else if (lVal is long ll_lint6 && rVal is long rl_lint6) stack.Push(ll_lint6 != rl_lint6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            
                            // Unsigned comparisons
                            case Bytecode.OpCodes.LT_USINT: 
                                if (lVal is byte lb_us && rVal is byte rb_us) stack.Push(lb_us < rb_us ? 1 : 0);
                                else if (lVal is ushort lus_us && rVal is ushort rus_us) stack.Push(lus_us < rus_us ? 1 : 0);
                                else if (lVal is uint lu1_us && rVal is uint ru1_us) stack.Push(lu1_us < ru1_us ? 1 : 0);
                                else if (lVal is ulong llu_us && rVal is ulong rlu_us) stack.Push(llu_us < rlu_us ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) < Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_USINT: 
                                if (lVal is byte lb_us2 && rVal is byte rb_us2) stack.Push(lb_us2 > rb_us2 ? 1 : 0);
                                else if (lVal is ushort lus_us2 && rVal is ushort rus_us2) stack.Push(lus_us2 > rus_us2 ? 1 : 0);
                                else if (lVal is uint lu2_us && rVal is uint ru2_us) stack.Push(lu2_us > ru2_us ? 1 : 0);
                                else if (lVal is ulong llu_us2 && rVal is ulong rlu_us2) stack.Push(llu_us2 > rlu_us2 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) > Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_USINT: 
                                if (lVal is byte lb_us3 && rVal is byte rb_us3) stack.Push(lb_us3 <= rb_us3 ? 1 : 0);
                                else if (lVal is ushort lus_us3 && rVal is ushort rus_us3) stack.Push(lus_us3 <= rus_us3 ? 1 : 0);
                                else if (lVal is uint lu3_us && rVal is uint ru3_us) stack.Push(lu3_us <= ru3_us ? 1 : 0);
                                else if (lVal is ulong llu_us3 && rVal is ulong rlu_us3) stack.Push(llu_us3 <= rlu_us3 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) <= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_USINT: 
                                if (lVal is byte lb_us4 && rVal is byte rb_us4) stack.Push(lb_us4 >= rb_us4 ? 1 : 0);
                                else if (lVal is ushort lus_us4 && rVal is ushort rus_us4) stack.Push(lus_us4 >= rus_us4 ? 1 : 0);
                                else if (lVal is uint lu4_us && rVal is uint ru4_us) stack.Push(lu4_us >= ru4_us ? 1 : 0);
                                else if (lVal is ulong llu_us4 && rVal is ulong rlu_us4) stack.Push(llu_us4 >= rlu_us4 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) >= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_USINT: 
                                if (lVal is byte lb_us5 && rVal is byte rb_us5) stack.Push(lb_us5 == rb_us5 ? 1 : 0);
                                else if (lVal is ushort lus_us5 && rVal is ushort rus_us5) stack.Push(lus_us5 == rus_us5 ? 1 : 0);
                                else if (lVal is uint lu5_us && rVal is uint ru5_us) stack.Push(lu5_us == ru5_us ? 1 : 0);
                                else if (lVal is ulong llu_us5 && rVal is ulong rlu_us5) stack.Push(llu_us5 == rlu_us5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_USINT: 
                                if (lVal is byte lb_us6 && rVal is byte rb_us6) stack.Push(lb_us6 != rb_us6 ? 1 : 0);
                                else if (lVal is ushort lus_us6 && rVal is ushort rus_us6) stack.Push(lus_us6 != rus_us6 ? 1 : 0);
                                else if (lVal is uint lu6_us && rVal is uint ru6_us) stack.Push(lu6_us != ru6_us ? 1 : 0);
                                else if (lVal is ulong llu_us6 && rVal is ulong rlu_us6) stack.Push(llu_us6 != rlu_us6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_UINT: 
                                if (lVal is byte lb_uint && rVal is byte rb_uint) stack.Push(lb_uint < rb_uint ? 1 : 0);
                                else if (lVal is ushort lus_uint && rVal is ushort rus_uint) stack.Push(lus_uint < rus_uint ? 1 : 0);
                                else if (lVal is uint lu1_uint && rVal is uint ru1_uint) stack.Push(lu1_uint < ru1_uint ? 1 : 0);
                                else if (lVal is ulong llu_uint && rVal is ulong rlu_uint) stack.Push(llu_uint < rlu_uint ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) < Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_UINT: 
                                if (lVal is byte lb_uint2 && rVal is byte rb_uint2) stack.Push(lb_uint2 > rb_uint2 ? 1 : 0);
                                else if (lVal is ushort lus_uint2 && rVal is ushort rus_uint2) stack.Push(lus_uint2 > rus_uint2 ? 1 : 0);
                                else if (lVal is uint lu2_uint && rVal is uint ru2_uint) stack.Push(lu2_uint > ru2_uint ? 1 : 0);
                                else if (lVal is ulong llu_uint2 && rVal is ulong rlu_uint2) stack.Push(llu_uint2 > rlu_uint2 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) > Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_UINT: 
                                if (lVal is byte lb_uint3 && rVal is byte rb_uint3) stack.Push(lb_uint3 <= rb_uint3 ? 1 : 0);
                                else if (lVal is ushort lus_uint3 && rVal is ushort rus_uint3) stack.Push(lus_uint3 <= rus_uint3 ? 1 : 0);
                                else if (lVal is uint lu3_uint && rVal is uint ru3_uint) stack.Push(lu3_uint <= ru3_uint ? 1 : 0);
                                else if (lVal is ulong llu_uint3 && rVal is ulong rlu_uint3) stack.Push(llu_uint3 <= rlu_uint3 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) <= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_UINT: 
                                if (lVal is byte lb_uint4 && rVal is byte rb_uint4) stack.Push(lb_uint4 >= rb_uint4 ? 1 : 0);
                                else if (lVal is ushort lus_uint4 && rVal is ushort rus_uint4) stack.Push(lus_uint4 >= rus_uint4 ? 1 : 0);
                                else if (lVal is uint lu4_uint && rVal is uint ru4_uint) stack.Push(lu4_uint >= ru4_uint ? 1 : 0);
                                else if (lVal is ulong llu_uint4 && rVal is ulong rlu_uint4) stack.Push(llu_uint4 >= rlu_uint4 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) >= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_UINT: 
                                if (lVal is byte lb_uint5 && rVal is byte rb_uint5) stack.Push(lb_uint5 == rb_uint5 ? 1 : 0);
                                else if (lVal is ushort lus_uint5 && rVal is ushort rus_uint5) stack.Push(lus_uint5 == rus_uint5 ? 1 : 0);
                                else if (lVal is uint lu5_uint && rVal is uint ru5_uint) stack.Push(lu5_uint == ru5_uint ? 1 : 0);
                                else if (lVal is ulong llu_uint5 && rVal is ulong rlu_uint5) stack.Push(llu_uint5 == rlu_uint5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_UINT: 
                                if (lVal is byte lb_uint6 && rVal is byte rb_uint6) stack.Push(lb_uint6 != rb_uint6 ? 1 : 0);
                                else if (lVal is ushort lus_uint6 && rVal is ushort rus_uint6) stack.Push(lus_uint6 != rus_uint6 ? 1 : 0);
                                else if (lVal is uint lu6_uint && rVal is uint ru6_uint) stack.Push(lu6_uint != ru6_uint ? 1 : 0);
                                else if (lVal is ulong llu_uint6 && rVal is ulong rlu_uint6) stack.Push(llu_uint6 != rlu_uint6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_UDINT: 
                                if (lVal is byte lb_udint && rVal is byte rb_udint) stack.Push(lb_udint < rb_udint ? 1 : 0);
                                else if (lVal is ushort lus_udint && rVal is ushort rus_udint) stack.Push(lus_udint < rus_udint ? 1 : 0);
                                else if (lVal is uint lu1_udint && rVal is uint ru1_udint) stack.Push(lu1_udint < ru1_udint ? 1 : 0);
                                else if (lVal is ulong llu_udint && rVal is ulong rlu_udint) stack.Push(llu_udint < rlu_udint ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) < Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_UDINT: 
                                if (lVal is byte lb_udint2 && rVal is byte rb_udint2) stack.Push(lb_udint2 > rb_udint2 ? 1 : 0);
                                else if (lVal is ushort lus_udint2 && rVal is ushort rus_udint2) stack.Push(lus_udint2 > rus_udint2 ? 1 : 0);
                                else if (lVal is uint lu2_udint && rVal is uint ru2_udint) stack.Push(lu2_udint > ru2_udint ? 1 : 0);
                                else if (lVal is ulong llu_udint2 && rVal is ulong rlu_udint2) stack.Push(llu_udint2 > rlu_udint2 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) > Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_UDINT: 
                                if (lVal is byte lb_udint3 && rVal is byte rb_udint3) stack.Push(lb_udint3 <= rb_udint3 ? 1 : 0);
                                else if (lVal is ushort lus_udint3 && rVal is ushort rus_udint3) stack.Push(lus_udint3 <= rus_udint3 ? 1 : 0);
                                else if (lVal is uint lu3_udint && rVal is uint ru3_udint) stack.Push(lu3_udint <= ru3_udint ? 1 : 0);
                                else if (lVal is ulong llu_udint3 && rVal is ulong rlu_udint3) stack.Push(llu_udint3 <= rlu_udint3 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) <= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_UDINT: 
                                if (lVal is byte lb_udint4 && rVal is byte rb_udint4) stack.Push(lb_udint4 >= rb_udint4 ? 1 : 0);
                                else if (lVal is ushort lus_udint4 && rVal is ushort rus_udint4) stack.Push(lus_udint4 >= rus_udint4 ? 1 : 0);
                                else if (lVal is uint lu4_udint && rVal is uint ru4_udint) stack.Push(lu4_udint >= ru4_udint ? 1 : 0);
                                else if (lVal is ulong llu_udint4 && rVal is ulong rlu_udint4) stack.Push(llu_udint4 >= rlu_udint4 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) >= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_UDINT: 
                                if (lVal is byte lb_udint5 && rVal is byte rb_udint5) stack.Push(lb_udint5 == rb_udint5 ? 1 : 0);
                                else if (lVal is ushort lus_udint5 && rVal is ushort rus_udint5) stack.Push(lus_udint5 == rus_udint5 ? 1 : 0);
                                else if (lVal is uint lu5_udint && rVal is uint ru5_udint) stack.Push(lu5_udint == ru5_udint ? 1 : 0);
                                else if (lVal is ulong llu_udint5 && rVal is ulong rlu_udint5) stack.Push(llu_udint5 == rlu_udint5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_UDINT: 
                                if (lVal is byte lb_udint6 && rVal is byte rb_udint6) stack.Push(lb_udint6 != rb_udint6 ? 1 : 0);
                                else if (lVal is ushort lus_udint6 && rVal is ushort rus_udint6) stack.Push(lus_udint6 != rus_udint6 ? 1 : 0);
                                else if (lVal is uint lu6_udint && rVal is uint ru6_udint) stack.Push(lu6_udint != ru6_udint ? 1 : 0);
                                else if (lVal is ulong llu_udint6 && rVal is ulong rlu_udint6) stack.Push(llu_udint6 != rlu_udint6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_ULINT: 
                                if (lVal is byte lb_ulint && rVal is byte rb_ulint) stack.Push(lb_ulint < rb_ulint ? 1 : 0);
                                else if (lVal is ushort lus_ulint && rVal is ushort rus_ulint) stack.Push(lus_ulint < rus_ulint ? 1 : 0);
                                else if (lVal is uint lu1_ulint && rVal is uint ru1_ulint) stack.Push(lu1_ulint < ru1_ulint ? 1 : 0);
                                else if (lVal is ulong llu_ulint && rVal is ulong rlu_ulint) stack.Push(llu_ulint < rlu_ulint ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) < Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_ULINT: 
                                if (lVal is byte lb_ulint2 && rVal is byte rb_ulint2) stack.Push(lb_ulint2 > rb_ulint2 ? 1 : 0);
                                else if (lVal is ushort lus_ulint2 && rVal is ushort rus_ulint2) stack.Push(lus_ulint2 > rus_ulint2 ? 1 : 0);
                                else if (lVal is uint lu2_ulint && rVal is uint ru2_ulint) stack.Push(lu2_ulint > ru2_ulint ? 1 : 0);
                                else if (lVal is ulong llu_ulint2 && rVal is ulong rlu_ulint2) stack.Push(llu_ulint2 > rlu_ulint2 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) > Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_ULINT: 
                                if (lVal is byte lb_ulint3 && rVal is byte rb_ulint3) stack.Push(lb_ulint3 <= rb_ulint3 ? 1 : 0);
                                else if (lVal is ushort lus_ulint3 && rVal is ushort rus_ulint3) stack.Push(lus_ulint3 <= rus_ulint3 ? 1 : 0);
                                else if (lVal is uint lu3_ulint && rVal is uint ru3_ulint) stack.Push(lu3_ulint <= ru3_ulint ? 1 : 0);
                                else if (lVal is ulong llu_ulint3 && rVal is ulong rlu_ulint3) stack.Push(llu_ulint3 <= rlu_ulint3 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) <= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_ULINT: 
                                if (lVal is byte lb_ulint4 && rVal is byte rb_ulint4) stack.Push(lb_ulint4 >= rb_ulint4 ? 1 : 0);
                                else if (lVal is ushort lus_ulint4 && rVal is ushort rus_ulint4) stack.Push(lus_ulint4 >= rus_ulint4 ? 1 : 0);
                                else if (lVal is uint lu4_ulint && rVal is uint ru4_ulint) stack.Push(lu4_ulint >= ru4_ulint ? 1 : 0);
                                else if (lVal is ulong llu_ulint4 && rVal is ulong rlu_ulint4) stack.Push(llu_ulint4 >= rlu_ulint4 ? 1 : 0);
                                else stack.Push(Convert.ToUInt64(lVal) >= Convert.ToUInt64(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_ULINT: 
                                if (lVal is byte lb_ulint5 && rVal is byte rb_ulint5) stack.Push(lb_ulint5 == rb_ulint5 ? 1 : 0);
                                else if (lVal is ushort lus_ulint5 && rVal is ushort rus_ulint5) stack.Push(lus_ulint5 == rus_ulint5 ? 1 : 0);
                                else if (lVal is uint lu5_ulint && rVal is uint ru5_ulint) stack.Push(lu5_ulint == ru5_ulint ? 1 : 0);
                                else if (lVal is ulong llu_ulint5 && rVal is ulong rlu_ulint5) stack.Push(llu_ulint5 == rlu_ulint5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_ULINT: 
                                if (lVal is byte lb_ulint6 && rVal is byte rb_ulint6) stack.Push(lb_ulint6 != rb_ulint6 ? 1 : 0);
                                else if (lVal is ushort lus_ulint6 && rVal is ushort rus_ulint6) stack.Push(lus_ulint6 != rus_ulint6 ? 1 : 0);
                                else if (lVal is uint lu6_ulint && rVal is uint ru6_ulint) stack.Push(lu6_ulint != ru6_ulint ? 1 : 0);
                                else if (lVal is ulong llu_ulint6 && rVal is ulong rlu_ulint6) stack.Push(llu_ulint6 != rlu_ulint6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            
                            // Floating point comparisons
                            case Bytecode.OpCodes.LT_REAL: 
                                if (lVal is float lf1_real && rVal is float rf1_real) stack.Push(lf1_real < rf1_real ? 1 : 0);
                                else if (lVal is double ld_real && rVal is double rd_real) stack.Push(ld_real < rd_real ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) < Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_REAL: 
                                if (lVal is float lf2_real && rVal is float rf2_real) stack.Push(lf2_real > rf2_real ? 1 : 0);
                                else if (lVal is double ld_real2 && rVal is double rd_real2) stack.Push(ld_real2 > rd_real2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) > Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_REAL: 
                                if (lVal is float lf3_real && rVal is float rf3_real) stack.Push(lf3_real <= rf3_real ? 1 : 0);
                                else if (lVal is double ld_real3 && rVal is double rd_real3) stack.Push(ld_real3 <= rd_real3 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) <= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_REAL: 
                                if (lVal is float lf4_real && rVal is float rf4_real) stack.Push(lf4_real >= rf4_real ? 1 : 0);
                                else if (lVal is double ld_real4 && rVal is double rd_real4) stack.Push(ld_real4 >= rd_real4 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) >= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_REAL: 
                                if (lVal is float lf5_real && rVal is float rf5_real) stack.Push(lf5_real == rf5_real ? 1 : 0);
                                else if (lVal is double ld_real5 && rVal is double rd_real5) stack.Push(ld_real5 == rd_real5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_REAL: 
                                if (lVal is float lf6_real && rVal is float rf6_real) stack.Push(lf6_real != rf6_real ? 1 : 0);
                                else if (lVal is double ld_real6 && rVal is double rd_real6) stack.Push(ld_real6 != rd_real6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LT_LREAL: 
                                if (lVal is float lf1_lreal && rVal is float rf1_lreal) stack.Push(lf1_lreal < rf1_lreal ? 1 : 0);
                                else if (lVal is double ld_lreal && rVal is double rd_lreal) stack.Push(ld_lreal < rd_lreal ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) < Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GT_LREAL: 
                                if (lVal is float lf2_lreal && rVal is float rf2_lreal) stack.Push(lf2_lreal > rf2_lreal ? 1 : 0);
                                else if (lVal is double ld_lreal2 && rVal is double rd_lreal2) stack.Push(ld_lreal2 > rd_lreal2 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) > Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.LE_LREAL: 
                                if (lVal is float lf3_lreal && rVal is float rf3_lreal) stack.Push(lf3_lreal <= rf3_lreal ? 1 : 0);
                                else if (lVal is double ld_lreal3 && rVal is double rd_lreal3) stack.Push(ld_lreal3 <= rd_lreal3 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) <= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.GE_LREAL: 
                                if (lVal is float lf4_lreal && rVal is float rf4_lreal) stack.Push(lf4_lreal >= rf4_lreal ? 1 : 0);
                                else if (lVal is double ld_lreal4 && rVal is double rd_lreal4) stack.Push(ld_lreal4 >= rd_lreal4 ? 1 : 0);
                                else stack.Push(Convert.ToDouble(lVal) >= Convert.ToDouble(rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.EQ_LREAL: 
                                if (lVal is float lf5_lreal && rVal is float rf5_lreal) stack.Push(lf5_lreal == rf5_lreal ? 1 : 0);
                                else if (lVal is double ld_lreal5 && rVal is double rd_lreal5) stack.Push(ld_lreal5 == rd_lreal5 ? 1 : 0);
                                else stack.Push(Equals(lVal, rVal) ? 1 : 0);
                                break;
                            case Bytecode.OpCodes.NEQ_LREAL: 
                                if (lVal is float lf6_lreal && rVal is float rf6_lreal) stack.Push(lf6_lreal != rf6_lreal ? 1 : 0);
                                else if (lVal is double ld_lreal6 && rVal is double rd_lreal6) stack.Push(ld_lreal6 != rd_lreal6 ? 1 : 0);
                                else stack.Push(!Equals(lVal, rVal) ? 1 : 0);
                                break;
                        }
                        break;
                    }
                    
                    throw new Exception($"Unknown opcode 0x{op:X2}");
            }
            
            // Stop the stopwatch and record execution time
            stopwatch.Stop();
            
            // Update execution time and count for this opcode
            if (opcodeExecutionTimes.ContainsKey(op)) {
                opcodeExecutionTimes[op] += stopwatch.ElapsedTicks;
                opcodeCounts[op]++;
            } else {
                opcodeExecutionTimes[op] = stopwatch.ElapsedTicks;
                opcodeCounts[op] = 1;
            }
        }

        if (verbose) Console.WriteLine("Execution finished\n");
        
        // Calculate total execution time in milliseconds
        long totalTicks = 0;
        foreach (var ticks in opcodeExecutionTimes.Values) {
            totalTicks += ticks;
        }
        double totalMs = totalTicks * 1000.0 / Stopwatch.Frequency;
        
        // Detailed variable summary - always show this
        Console.WriteLine("=== Variable summary ===");
        Console.WriteLine("Index\tType\t\tValue");
        for (int i = 0; i < vars.Length; i++) {
            string typeName = (i < varTypes.Length) ? ((VarType)varTypes[i]).ToString() : "Unknown";
            var value = vars[i] ?? "null";
            Console.WriteLine($"{i}\t{typeName.PadRight(8)}\t{value}");
        }
        
        // Performance summary
        Console.WriteLine("\n=== Performance summary ===");
        Console.WriteLine($"Total execution time: {totalMs:F4} ms");
        Console.WriteLine($"Target cycle time: {cycletime} ms");
        
        if (totalMs > cycletime) {
            Console.WriteLine($"⚠️  Execution time exceeds target cycle time by {totalMs - cycletime:F4} ms");
        } else {
            Console.WriteLine($"✅ Execution time is within target cycle time by {cycletime - totalMs:F4} ms");
        }
        
        // Show opcode execution statistics
        Console.WriteLine("\nOpcode execution statistics:");
        Console.WriteLine("Opcode\t\tCount\tAvg Time (ms)\tTotal Time (ms)");
        foreach (var opcode in opcodeExecutionTimes.Keys) {
            double avgTicks = (double)opcodeExecutionTimes[opcode] / opcodeCounts[opcode];
            double avgMs = avgTicks * 1000.0 / Stopwatch.Frequency;
            double totalMsForOpcode = opcodeExecutionTimes[opcode] * 1000.0 / Stopwatch.Frequency;
            Console.WriteLine($"{Bytecode.OpName(opcode).PadRight(16)}\t{opcodeCounts[opcode]}\t{avgMs:F6}\t\t{totalMsForOpcode:F6}");
        }
    }
}