Вот еще до кучи накидал вариант с union:

## Код:
```
MODULE MyTest;
IMPORT Log := StdLog, SYSTEM;

CONST
   Add = 0; Set = 1; Get = 2; Jmp = 3; Jgt = 4; End = 5;

TYPE

   Value = RECORD
      type: INTEGER;
      data: RECORD [union]
         r: REAL;
         s: POINTER [untagged] TO ARRAY OF CHAR;
      END;
   END;

PROCEDURE emit1(b1, b2, b3, b4: INTEGER): INTEGER;
   VAR w: INTEGER;
BEGIN
   w := ASH(b1, 24) + ASH(b2, 16) + ASH(b3, 8) + b4;
   RETURN w;
END emit1;

PROCEDURE emit2(b1, b2, b4: INTEGER): INTEGER;
   VAR w: INTEGER;
BEGIN
   w := ASH(b1, 24) + ASH(b2, 16) + b4;
   RETURN w;
END emit2;

PROCEDURE emit3(b1, b4: INTEGER): INTEGER;
   VAR w: INTEGER;
BEGIN
   w := ASH(b1, 24) + b4;
   RETURN w;
END emit3;

PROCEDURE emit4(b1: INTEGER): INTEGER;
   VAR w: INTEGER;
BEGIN
   w := ASH(b1, 24);
   RETURN w;
END emit4;

PROCEDURE Do*;
   VAR w: INTEGER;
   b1, b2, b3, b4: INTEGER;
   ip: INTEGER;
   ops: ARRAY 13 OF INTEGER;
   reg: POINTER TO ARRAY 256 OF Value;
   mem: POINTER TO ARRAY 1000 OF Value;
BEGIN
   
   ops[00] := emit2(Get, 0, 0);    (* 0 *)
   ops[01] := emit2(Set, 0, 10);   (* x = 0 *)
   ops[02] := emit2(Get, 0, 1);    (* 1 *)
   ops[03] := emit2(Set, 0, 11);   (* y = 1 *)
   ops[04] := emit2(Get, 0, 10);   (* x *)
   ops[05] := emit2(Get, 1, 2);    (* 100000000 *)
   ops[06] := emit3(Jgt, 11);      (* if x > 100000000 goto *)
   ops[07] := emit2(Get, 0, 10);   (* x *)
   ops[08] := emit2(Get, 1, 11);   (* y *)
   ops[09] := emit1(Add, 0, 0, 1); (* _ = x + y *)
   ops[10] := emit2(Set, 0, 10);   (* x = _ *)
   ops[11] := emit3(Jmp, 3);       (* goto *)
   ops[12] := emit4(End);          (* end *)
   
   NEW(reg);
   NEW(mem);
   
   mem[0].data.r := 0;
   mem[1].data.r := 1;
   mem[2].data.r := 100000000;
   
   ip := 0;
   LOOP
      w := ops[ip];
      
      b4 := w MOD 0100H;
      b3 := w DIV 0100H MOD 0100H;
      b2 := w DIV 010000H MOD 0100H;
      b1 := w DIV 01000000H MOD 0100H;
         
      CASE b1 OF
      |Get: reg[b2] := mem[b4];
      |Set: mem[b4] := reg[b2]; 
      |Add: reg[b2].data.r := reg[b3].data.r + reg[b4].data.r;
      |Jmp: ip := b4;
      |Jgt: IF reg[0].data.r > reg[1].data.r THEN ip := b4 END;
      |End: EXIT;
      END;
      INC(ip);
      
   END;
   
END Do;

END MyTest.Do

DevCompiler.CompileThis MyTest!!
DevDebug.UnloadThis MyTest
```


Вроде кажется что это должно быть существенно быстрее... но нет. Чуда не произошло. Этот код выполняется чуть меньше 4 сек (всего на 2 сек. быстрее)
Что я делаю не так? Я хочу добиться как минимум 2 секунд, т.к. на C аналогичный код (O1) выполняется менее 1.8 сек, а на Go на интерфейсах! 2.5 сек.