Ну нее. В 2 раза медленнее Go - куда ближе к правде.

Все таки я сейчас замеры в BB делаю при отключенных проверках.

А вот кстати с высокоуровневым кодом на C# примерно похоже (4.5 сек против 6 сек. в BB):

## Код:
```
using System;

namespace core_hello
{
    class Program
    {
        public static class OPER {
            public const int ADD = 0;
            public const int SET = 1;
            public const int GET = 2;
            public const int JMP = 3;
            public const int JGT = 4;
            public const int END = 5;
        };
        
        public interface Value
        {
            void Set(Value v);
            void SetReal(double r);
            double Num();

        }

        class Number: Value
        {
            double n;
            public void Set(Value v) {
                n = v.Num();
            }
            public void SetReal(double r) {
                n = r;
            }
            public double Num() {
                return n;
            }

            public Number(double x) {
                n = x;
            }
        }

        static int emit1(byte b1, byte b2, byte b3, byte b4) {
            return (b1<<24) + (b2<<16) + (b3<<8) + b4; 
        }

        static int emit2(byte b1, byte b2, byte b4) {
            return (b1<<24) + (b2<<16) + b4; 
        }

        static int emit3(byte b1, byte b4) {
            return (b1<<24) + b4; 
        }

        static int emit4(byte b1) {
            return b1<<24; 
        }

        static void Main(string[] args)
        {

            int[] ops = new int[13];
    
            ops[0] = emit2(OPER.GET, 0, 0);    // 0 
            ops[1] = emit2(OPER.SET, 0, 10);   // x = 0 
            ops[2] = emit2(OPER.GET, 0, 1);    // 1 
            ops[3] = emit2(OPER.SET, 0, 11);   // y = 1 
            ops[4] = emit2(OPER.GET, 0, 10);   // x 
            ops[5] = emit2(OPER.GET, 1, 2);    // 100000000 
            ops[6] = emit3(OPER.JGT, 11);      // if x > 100000000 goto 
            ops[7] = emit2(OPER.GET, 0, 10);   // x 
            ops[8] = emit2(OPER.GET, 1, 11);   // y 
            ops[9] = emit1(OPER.ADD, 0, 0, 1); // _ = x + y 
            ops[10] = emit2(OPER.SET, 0, 10);   // x = _ 
            ops[11] = emit3(OPER.JMP, 3);       // goto 
            ops[12] = emit4(OPER.END);          // end

            Value[] reg = new Value[256];
            Value[] mem = new Value[1000];

            for(int i = 0; i < reg.Length; i++) {
                reg[i] = new Number(0);
            }

            for(int i = 0; i < mem.Length; i++) {
                mem[i] = new Number(0);
            }

            mem[0] = new Number(0);
            mem[1] = new Number(1);
            mem[2] = new Number(100000000);

            int ip = 0;

            for (;;) {
                int w = ops[ip];

                int b4 = w & 0xFF;
                int b3 = (w >> 8) & 0xFF;
                int b2 = (w >> 16) & 0xFF;
                int b1 = (w >> 24) & 0xFF;

                switch (b1) {
                case OPER.GET:
                    reg[b2].Set(mem[b4]); break;
                case OPER.SET:
                    mem[b4].Set(reg[b2]); break;
                case OPER.ADD:
                    reg[b2].SetReal(reg[b3].Num() + reg[b4].Num()); break;
                case OPER.JMP:
                    ip = b4; break;
                case OPER.JGT:
                    if (reg[0].Num() > reg[1].Num()) {
                        ip = b4;
                    }
                    break;
                case OPER.END:
                    goto endloop;
                }
                ip++;

            }

            endloop:
            
            Console.WriteLine(mem[10].Num());

        }
    }
}
```


Правда я c# готовить не умею. Впрочем видимо как и BB.