text: // Generated by generate.pl from insn.defs and priminsn.defs
  DISPATCH_BEGIN
  OP_BEGIN(enter)
      const uint8_t nargs = FETCH8;
      CHI_NOWARN_UNUSED(nargs);
      CHI_UNREACHABLE;
  OP_END
  OP_BEGIN(limit)
      Chili* const top = REG + FETCH16;
      const uint8_t lim = FETCH8;
      LIMITS_SAVE(({
              const uint8_t* ip = IP -= 5 + 3; // 5=limit, 3=enter
              FETCH16; // OP_enter
              AUX.VAARGS = FETCH8;
              for (uint32_t i = 0; i < AUX.VAARGS; ++i)
                  ASET(i, top[i]);
              SAVE_CONT(ip);
              KNOWN_JUMP(chiYieldCont);
          }), .interrupt = true, .stack = lim);
  OP_END
  OP_BEGIN(adj)
      const uint16_t delta = FETCH16;
      SP = REG + delta;
  OP_END
  OP_BEGIN(idx)
      Chili* const res = REG + FETCH8;
      const Chili var = REG[FETCH8];
      const uint8_t idx = FETCH8;
      *res = chiIdx(var, idx);
  OP_END
  OP_BEGIN(idxl)
      Chili* const res = REG + FETCH16;
      const Chili var = REG[FETCH16];
      const uint16_t idx = FETCH16;
      *res = chiIdx(var, idx);
  OP_END
  OP_BEGIN(set)
      const Chili var = REG[FETCH16];
      const uint16_t i = FETCH16;
      const Chili field = REG[FETCH16];
      chiToCbyFn(var)->clos[i] = field;
  OP_END
  OP_BEGIN(int8)
      Chili* const res = REG + FETCH8;
      const int8_t val = (int8_t)FETCH8;
      *res = chiFromInt8(val);
  OP_END
  OP_BEGIN(int32)
      Chili* const res = REG + FETCH16;
      const int32_t val = (int32_t)FETCH32;
      *res = chiFromInt32(val);
  OP_END
  OP_BEGIN(int64)
      Chili* const res = REG + FETCH16;
      const int64_t val = (int64_t)FETCH64;
      *res = chiFromInt64(val);
  OP_END
  OP_BEGIN(uint8)
      Chili* const res = REG + FETCH8;
      const uint8_t val = FETCH8;
      *res = chiFromUInt8(val);
  OP_END
  OP_BEGIN(uint32)
      Chili* const res = REG + FETCH16;
      const uint32_t val = FETCH32;
      *res = chiFromUInt32(val);
  OP_END
  OP_BEGIN(uint64)
      Chili* const res = REG + FETCH16;
      const uint64_t val = FETCH64;
      *res = chiFromUInt64(val);
  OP_END
  OP_BEGIN(float32)
      Chili* const res = REG + FETCH16;
      const float val = CHI_CAST(FETCH32, float);
      *res = chiFromFloat32(val);
  OP_END
  OP_BEGIN(float64)
      Chili* const res = REG + FETCH16;
      const double val = CHI_CAST(FETCH64, double);
      *res = chiFromFloat64(val);
  OP_END
  OP_BEGIN(string)
      Chili* const res = REG + FETCH16;
      const ChiStringRef strref = FETCH_STRING;
      *res = chiStringFromRef(strref);
  OP_END
  OP_BEGIN(buffer)
      Chili* const res = REG + FETCH16;
      const ChiStringRef bytesref = FETCH_STRING;
      *res = chiBufferFromBytes(bytesref.bytes, bytesref.size);
  OP_END
  OP_BEGIN(xint)
      Chili* const res = REG + FETCH16;
      const ChiStringRef bytesref = FETCH_STRING;
      *res = chiBigIntFromBytes(bytesref.bytes, bytesref.size);
  OP_END
  OP_BEGIN(xintn)
      Chili* const res = REG + FETCH16;
      const ChiStringRef bytesref = FETCH_STRING;
      *res = chi_Prim_intNeg(chiBigIntFromBytes(bytesref.bytes, bytesref.size));
  OP_END
  OP_BEGIN(xint8)
      Chili* const res = REG + FETCH8;
      const int8_t val = (int8_t)FETCH8;
      *res = chiInt64ToBigInt(val);
  OP_END
  OP_BEGIN(xint64)
      Chili* const res = REG + FETCH16;
      const int64_t val = (int64_t)FETCH64;
      *res = chiInt64ToBigInt(val);
  OP_END
  OP_BEGIN(movc2)
      Chili* const res = REG + FETCH8;
      Chili* const src = REG + FETCH8;
      const Chili src0 = src[0];
      const Chili src1 = src[1];
      res[0] = src0;
      res[1] = src1;
  OP_END
  OP_BEGIN(movc3)
      Chili* const res = REG + FETCH8;
      Chili* const src = REG + FETCH8;
      const Chili src0 = src[0];
      const Chili src1 = src[1];
      const Chili src2 = src[2];
      res[0] = src0;
      res[1] = src1;
      res[2] = src2;
  OP_END
  OP_BEGIN(movc4)
      Chili* const res = REG + FETCH8;
      Chili* const src = REG + FETCH8;
      const Chili src0 = src[0];
      const Chili src1 = src[1];
      const Chili src2 = src[2];
      const Chili src3 = src[3];
      res[0] = src0;
      res[1] = src1;
      res[2] = src2;
      res[3] = src3;
  OP_END
  OP_BEGIN(movcl2)
      Chili* const res = REG + FETCH16;
      Chili* const src = REG + FETCH16;
      const Chili src0 = src[0];
      const Chili src1 = src[1];
      res[0] = src0;
      res[1] = src1;
  OP_END
  OP_BEGIN(movcl3)
      Chili* const res = REG + FETCH16;
      Chili* const src = REG + FETCH16;
      const Chili src0 = src[0];
      const Chili src1 = src[1];
      const Chili src2 = src[2];
      res[0] = src0;
      res[1] = src1;
      res[2] = src2;
  OP_END
  OP_BEGIN(movcl4)
      Chili* const res = REG + FETCH16;
      Chili* const src = REG + FETCH16;
      const Chili src0 = src[0];
      const Chili src1 = src[1];
      const Chili src2 = src[2];
      const Chili src3 = src[3];
      res[0] = src0;
      res[1] = src1;
      res[2] = src2;
      res[3] = src3;
  OP_END
  OP_BEGIN(mov1)
      Chili* const res = REG + FETCH8;
      const Chili src0 = REG[FETCH8];
      res[0] = src0;
  OP_END
  OP_BEGIN(mov2)
      Chili* const res = REG + FETCH8;
      const Chili src0 = REG[FETCH8];
      const Chili src1 = REG[FETCH8];
      res[0] = src0;
      res[1] = src1;
  OP_END
  OP_BEGIN(mov3)
      Chili* const res = REG + FETCH8;
      const Chili src0 = REG[FETCH8];
      const Chili src1 = REG[FETCH8];
      const Chili src2 = REG[FETCH8];
      res[0] = src0;
      res[1] = src1;
      res[2] = src2;
  OP_END
  OP_BEGIN(mov4)
      Chili* const res = REG + FETCH8;
      const Chili src0 = REG[FETCH8];
      const Chili src1 = REG[FETCH8];
      const Chili src2 = REG[FETCH8];
      const Chili src3 = REG[FETCH8];
      res[0] = src0;
      res[1] = src1;
      res[2] = src2;
      res[3] = src3;
  OP_END
  OP_BEGIN(movl1)
      Chili* const res = REG + FETCH16;
      const Chili src0 = REG[FETCH16];
      res[0] = src0;
  OP_END
  OP_BEGIN(movl2)
      Chili* const res = REG + FETCH16;
      const Chili src0 = REG[FETCH16];
      const Chili src1 = REG[FETCH16];
      res[0] = src0;
      res[1] = src1;
  OP_END
  OP_BEGIN(choice)
      Chili* const res = REG + FETCH8;
      const Chili scrut = REG[FETCH8];
      const Chili a = REG[FETCH8];
      const Chili b = REG[FETCH8];
      *res = chiTrue(scrut) ? a : b;
  OP_END
  OP_BEGIN(thk)
      Chili* const res = REG + FETCH16;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      const uint16_t nclos = FETCH16;
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + nclos);
      NEW_LARGE(thunk, CHI_THUNK, CHI_SIZEOF_WORDS(CbyFn) + nclos);
      *res = thunk; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, thunk);
      fn->cont = chiFromCont(&interpThunk);
      fn->val = thunk;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      for (uint32_t i = 0; i < nclos; ++i)
          fn->clos[i] = REG[FETCH16];
  OP_END
  OP_BEGIN(thk0)
      Chili* const res = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 0);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 0);
      NEW(thunk, CHI_THUNK, CHI_SIZEOF_WORDS(CbyFn) + 0);
      *res = thunk; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, thunk);
      fn->cont = chiFromCont(&interpThunk);
      fn->val = thunk;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
  OP_END
  OP_BEGIN(thk1)
      Chili* const res = REG + FETCH8;
      Chili* const c0 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 1);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 1);
      NEW(thunk, CHI_THUNK, CHI_SIZEOF_WORDS(CbyFn) + 1);
      *res = thunk; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, thunk);
      fn->cont = chiFromCont(&interpThunk);
      fn->val = thunk;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
  OP_END
  OP_BEGIN(thk2)
      Chili* const res = REG + FETCH8;
      Chili* const c0 = REG + FETCH8;
      Chili* const c1 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 2);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 2);
      NEW(thunk, CHI_THUNK, CHI_SIZEOF_WORDS(CbyFn) + 2);
      *res = thunk; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, thunk);
      fn->cont = chiFromCont(&interpThunk);
      fn->val = thunk;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
      fn->clos[1] = *c1;
  OP_END
  OP_BEGIN(thk3)
      Chili* const res = REG + FETCH8;
      Chili* const c0 = REG + FETCH8;
      Chili* const c1 = REG + FETCH8;
      Chili* const c2 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 3);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 3);
      NEW(thunk, CHI_THUNK, CHI_SIZEOF_WORDS(CbyFn) + 3);
      *res = thunk; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, thunk);
      fn->cont = chiFromCont(&interpThunk);
      fn->val = thunk;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
      fn->clos[1] = *c1;
      fn->clos[2] = *c2;
  OP_END
  OP_BEGIN(thk4)
      Chili* const res = REG + FETCH8;
      Chili* const c0 = REG + FETCH8;
      Chili* const c1 = REG + FETCH8;
      Chili* const c2 = REG + FETCH8;
      Chili* const c3 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 4);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 4);
      NEW(thunk, CHI_THUNK, CHI_SIZEOF_WORDS(CbyFn) + 4);
      *res = thunk; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, thunk);
      fn->cont = chiFromCont(&interpThunk);
      fn->val = thunk;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
      fn->clos[1] = *c1;
      fn->clos[2] = *c2;
      fn->clos[3] = *c3;
  OP_END
  OP_BEGIN(fn)
      Chili* const res = REG + FETCH16;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      const uint8_t arity = FETCH8;
      const uint16_t nclos = FETCH16;
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + nclos);
      NEW_LARGE(c, CHI_FN(arity), CHI_SIZEOF_WORDS(CbyFn) + nclos);
      *res = c; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, c);
      fn->cont = chiFromCont(&interpFn);
      fn->val = CHI_FALSE;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      for (uint32_t i = 0; i < nclos; ++i)
          fn->clos[i] = REG[FETCH16];
  OP_END
  OP_BEGIN(fn0)
      Chili* const res = REG + FETCH8;
      const uint8_t arity = FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 0);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 0);
      NEW(c, CHI_FN(arity), CHI_SIZEOF_WORDS(CbyFn) + 0);
      *res = c; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, c);
      fn->cont = chiFromCont(&interpFn);
      fn->val = CHI_FALSE;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
  OP_END
  OP_BEGIN(fn1)
      Chili* const res = REG + FETCH8;
      const uint8_t arity = FETCH8;
      Chili* const c0 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 1);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 1);
      NEW(c, CHI_FN(arity), CHI_SIZEOF_WORDS(CbyFn) + 1);
      *res = c; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, c);
      fn->cont = chiFromCont(&interpFn);
      fn->val = CHI_FALSE;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
  OP_END
  OP_BEGIN(fn2)
      Chili* const res = REG + FETCH8;
      const uint8_t arity = FETCH8;
      Chili* const c0 = REG + FETCH8;
      Chili* const c1 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 2);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 2);
      NEW(c, CHI_FN(arity), CHI_SIZEOF_WORDS(CbyFn) + 2);
      *res = c; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, c);
      fn->cont = chiFromCont(&interpFn);
      fn->val = CHI_FALSE;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
      fn->clos[1] = *c1;
  OP_END
  OP_BEGIN(fn3)
      Chili* const res = REG + FETCH8;
      const uint8_t arity = FETCH8;
      Chili* const c0 = REG + FETCH8;
      Chili* const c1 = REG + FETCH8;
      Chili* const c2 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 3);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 3);
      NEW(c, CHI_FN(arity), CHI_SIZEOF_WORDS(CbyFn) + 3);
      *res = c; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, c);
      fn->cont = chiFromCont(&interpFn);
      fn->val = CHI_FALSE;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
      fn->clos[1] = *c1;
      fn->clos[2] = *c2;
  OP_END
  OP_BEGIN(fn4)
      Chili* const res = REG + FETCH8;
      const uint8_t arity = FETCH8;
      Chili* const c0 = REG + FETCH8;
      Chili* const c1 = REG + FETCH8;
      Chili* const c2 = REG + FETCH8;
      Chili* const c3 = REG + FETCH8;
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      GROW_HEAP(CHI_SIZEOF_WORDS(CbyFn) + 4);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, CHI_SIZEOF_WORDS(CbyFn) + 4);
      NEW(c, CHI_FN(arity), CHI_SIZEOF_WORDS(CbyFn) + 4);
      *res = c; // Note: *res is written before fields are read, in order to support recursion
      CbyFn* fn = NEW_PAYLOAD(CbyFn, c);
      fn->cont = chiFromCont(&interpFn);
      fn->val = CHI_FALSE;
      fn->module = chiToCbyFn(CURRFN)->module;
      fn->ip = chiFromIP(fnref);
      fn->clos[0] = *c0;
      fn->clos[1] = *c1;
      fn->clos[2] = *c2;
      fn->clos[3] = *c3;
  OP_END
  OP_BEGIN(con)
      Chili* const res = REG + FETCH16;
      const uint16_t tag = FETCH16;
      const uint16_t size = FETCH16;
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, size);
      NEW_LARGE(c, CHI_TAG(tag), size);
      for (uint32_t i = 0; i < size; ++i)
          NEW_INIT(c, i, REG[FETCH16]);
      *res = c;
  OP_END
  OP_BEGIN(con0)
      Chili* const res = REG + FETCH8;
      const uint8_t tag = FETCH8;
      *res = chiNewEmpty(CHI_TAG(tag));
  OP_END
  OP_BEGIN(conl0)
      Chili* const res = REG + FETCH16;
      const uint16_t tag = FETCH16;
      *res = chiNewEmpty(CHI_TAG(tag));
  OP_END
  OP_BEGIN(con1)
      Chili* const res = REG + FETCH8;
      const uint8_t tag = FETCH8;
      const Chili a0 = REG[FETCH8];
      GROW_HEAP(1);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, 1);
      NEW(c, CHI_TAG(tag), 1);
      NEW_INIT(c, 0, a0);
      *res = c;
  OP_END
  OP_BEGIN(con2)
      Chili* const res = REG + FETCH8;
      const uint8_t tag = FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      GROW_HEAP(2);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, 2);
      NEW(c, CHI_TAG(tag), 2);
      NEW_INIT(c, 0, a0);
      NEW_INIT(c, 1, a1);
      *res = c;
  OP_END
  OP_BEGIN(con3)
      Chili* const res = REG + FETCH8;
      const uint8_t tag = FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      GROW_HEAP(3);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, 3);
      NEW(c, CHI_TAG(tag), 3);
      NEW_INIT(c, 0, a0);
      NEW_INIT(c, 1, a1);
      NEW_INIT(c, 2, a2);
      *res = c;
  OP_END
  OP_BEGIN(con4)
      Chili* const res = REG + FETCH8;
      const uint8_t tag = FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      GROW_HEAP(4);
      instrumentAlloc(proc, &interpPS->data, CURRFN, SP, 4);
      NEW(c, CHI_TAG(tag), 4);
      NEW_INIT(c, 0, a0);
      NEW_INIT(c, 1, a1);
      NEW_INIT(c, 2, a2);
      NEW_INIT(c, 3, a3);
      *res = c;
  OP_END
  OP_BEGIN(casetbl)
      const Chili scrut = REG[FETCH16];
      const uint32_t lo = FETCH32;
      const uint32_t hi = FETCH32;
      const uint32_t x = chiToUInt32(scrut);
      IP += x >= lo && x <= hi ? chiPeekUInt32(IP + 4 * (x - lo)) : 4 * (hi - lo + 1);
  OP_END
  OP_BEGIN(case)
      const Chili scrut = REG[FETCH16];
      const uint16_t nalts = FETCH16;
      const uint32_t x = chiToUInt32(scrut);
      uint32_t first = 0, last = nalts - 1U;
      for (;;) {
          const uint32_t mid = first + (last - first) / 2, t = chiPeekUInt32(IP + 8 * mid);
          if (x < t && first < mid) {
              last = mid - 1;
              continue;
          }
          if (x > t && mid < last) {
              first = mid + 1;
              continue;
          }
          IP += x == t ? chiPeekUInt32(IP + 8 * mid + 4) : 8U * nalts;
          break;
      }
  OP_END
  OP_BEGIN(cont)
      Chili* const top = REG + FETCH8;
      const uint8_t off = FETCH8;
      SAVE_CONT(IP + off);
      chiStackDebugWalk(chiThreadStack(proc->thread), SP, SL);
  OP_END
  OP_BEGIN(contl)
      Chili* const top = REG + FETCH16;
      const uint32_t off = FETCH32;
      SAVE_CONT(IP + off);
      chiStackDebugWalk(chiThreadStack(proc->thread), SP, SL);
  OP_END
  OP_BEGIN(ret1)
      const Chili v0 = REG[FETCH8];
      _Static_assert(1 <= CBY_CONTEXT_SIZE, "Too many return values");
      INSN_LEAVE;
      if (chiToCont(SP[-1]) != &interpCont) {
          ASET(0, v0);
          RET;
      }
      FETCH_ENTER;
      CHI_ASSERT(nargs == 1);
      top[0] = v0;
      ENTER(true);
  OP_END
  OP_BEGIN(ret2)
      const Chili v0 = REG[FETCH8];
      const Chili v1 = REG[FETCH8];
      _Static_assert(2 <= CBY_CONTEXT_SIZE, "Too many return values");
      INSN_LEAVE;
      if (chiToCont(SP[-1]) != &interpCont) {
          ASET(0, v0);
          ASET(1, v1);
          RET;
      }
      FETCH_ENTER;
      CHI_ASSERT(nargs == 2);
      top[0] = v0;
      top[1] = v1;
      ENTER(true);
  OP_END
  OP_BEGIN(ret3)
      const Chili v0 = REG[FETCH8];
      const Chili v1 = REG[FETCH8];
      const Chili v2 = REG[FETCH8];
      _Static_assert(3 <= CBY_CONTEXT_SIZE, "Too many return values");
      INSN_LEAVE;
      if (chiToCont(SP[-1]) != &interpCont) {
          ASET(0, v0);
          ASET(1, v1);
          ASET(2, v2);
          RET;
      }
      FETCH_ENTER;
      CHI_ASSERT(nargs == 3);
      top[0] = v0;
      top[1] = v1;
      top[2] = v2;
      ENTER(true);
  OP_END
  OP_BEGIN(ret4)
      const Chili v0 = REG[FETCH8];
      const Chili v1 = REG[FETCH8];
      const Chili v2 = REG[FETCH8];
      const Chili v3 = REG[FETCH8];
      _Static_assert(4 <= CBY_CONTEXT_SIZE, "Too many return values");
      INSN_LEAVE;
      if (chiToCont(SP[-1]) != &interpCont) {
          ASET(0, v0);
          ASET(1, v1);
          ASET(2, v2);
          ASET(3, v3);
          RET;
      }
      FETCH_ENTER;
      CHI_ASSERT(nargs == 4);
      top[0] = v0;
      top[1] = v1;
      top[2] = v2;
      top[3] = v3;
      ENTER(true);
  OP_END
  OP_BEGIN(ret)
      const uint8_t nvals = FETCH8;
      CHI_ASSUME(nvals < CHI_AMAX);
      INSN_LEAVE;
  
      FETCH_ENTER;
      CHI_ASSERT(nargs == nvals);
  
      for (uint32_t i = 0; i < nvals; ++i)
          ASET(i, REG[FETCH16]);
  
      if (chiToCont(SP[-1]) != &interpCont)
          RET;
  
      // more precisely nargs - CBY_CONTEXT_SIZE
      LIMITS_SAVE(({
              SP = top + CBY_CONTEXT_SIZE;
              AUX.VAARGS = nvals;
              KNOWN_JUMP(chiYieldCont);
          }), .stack = CHI_AMAX - CBY_CONTEXT_SIZE);
  
      for (uint32_t i = 0; i < nvals; ++i)
          top[i] = AGET(i);
  
      ENTER(true);
  OP_END
  OP_BEGIN(if)
      const Chili scrut = REG[FETCH8];
      const uint8_t off = FETCH8;
      if (!chiTrue(scrut))
          IP += off;
  OP_END
  OP_BEGIN(ifl)
      const Chili scrut = REG[FETCH16];
      const uint32_t off = FETCH32;
      if (!chiTrue(scrut))
          IP += off;
  OP_END
  OP_BEGIN(ifeq)
      const uint8_t val = FETCH8;
      const Chili scrut = REG[FETCH8];
      const uint8_t off = FETCH8;
      if (chiToUInt32(scrut) != val)
          IP += off;
  OP_END
  OP_BEGIN(ifeql)
      const uint32_t val = FETCH32;
      const Chili scrut = REG[FETCH16];
      const uint32_t off = FETCH32;
      if (chiToUInt32(scrut) != val)
          IP += off;
  OP_END
  OP_BEGIN(jmp)
      const uint8_t off = FETCH8;
      IP += off;
  OP_END
  OP_BEGIN(jmpl)
      const uint32_t off = FETCH32;
      IP += off;
  OP_END
  OP_BEGIN(kapp)
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      const Chili fn = REG[FETCH16];
      const uint8_t nargs = FETCH8;
      CHI_ASSUME(nargs < CHI_AMAX);
      Chili tmp[CHI_AMAX];
      for (uint32_t i = 0; i < nargs; ++i)
          tmp[i] = REG[FETCH16];
      for (uint32_t i = 0; i < nargs; ++i)
          SP[i] = tmp[i];
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  OP_END
  OP_BEGIN(kapp1)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      SP[0] = a0;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  OP_END
  OP_BEGIN(kapp2)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      SP[0] = a0;
      SP[1] = a1;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  OP_END
  OP_BEGIN(kapp3)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      SP[0] = a0;
      SP[1] = a1;
      SP[2] = a2;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  OP_END
  OP_BEGIN(kapp4)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      SP[0] = a0;
      SP[1] = a1;
      SP[2] = a2;
      SP[3] = a3;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  OP_END
  OP_BEGIN(kapp5)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      const Chili a4 = REG[FETCH8];
      int32_t _fnref = (int32_t)FETCH32; const CbyCode* fnref = IP + _fnref;
      SP[0] = a0;
      SP[1] = a1;
      SP[2] = a2;
      SP[3] = a3;
      SP[4] = a4;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  OP_END
  OP_BEGIN(app)
      const Chili fn = REG[FETCH16];
      const uint8_t nargs = FETCH8;
      CHI_ASSUME(nargs < CHI_AMAX);
      if (chiFnArity(fn) != nargs || chiToCont(chiIdx(fn, 0)) != &interpFn) {
          ASET(0, fn);
          for (uint32_t i = 0; i < nargs; ++i)
              ASET(i + 1, REG[FETCH16]);
          INSN_LEAVE;
          APP(nargs);
      }
      const CbyCode* fnref = chiToIP(chiToCbyFn(fn)->ip);
      {    CHI_ASSUME(nargs < CHI_AMAX);
      Chili tmp[CHI_AMAX];
      for (uint32_t i = 0; i < nargs; ++i)
          tmp[i] = REG[FETCH16];
      for (uint32_t i = 0; i < nargs; ++i)
          SP[i] = tmp[i];
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  }
  OP_END
  OP_BEGIN(app1)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      if (chiFnArity(fn) != 1 || chiToCont(chiIdx(fn, 0)) != &interpFn) {
          ASET(0, fn);
          ASET(0 + 1, a0);
          INSN_LEAVE;
          APP(1);
      }
      const CbyCode* fnref = chiToIP(chiToCbyFn(fn)->ip);
      {    SP[0] = a0;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  }
  OP_END
  OP_BEGIN(app2)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      if (chiFnArity(fn) != 2 || chiToCont(chiIdx(fn, 0)) != &interpFn) {
          ASET(0, fn);
          ASET(0 + 1, a0);
          ASET(1 + 1, a1);
          INSN_LEAVE;
          APP(2);
      }
      const CbyCode* fnref = chiToIP(chiToCbyFn(fn)->ip);
      {    SP[0] = a0;
      SP[1] = a1;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  }
  OP_END
  OP_BEGIN(app3)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      if (chiFnArity(fn) != 3 || chiToCont(chiIdx(fn, 0)) != &interpFn) {
          ASET(0, fn);
          ASET(0 + 1, a0);
          ASET(1 + 1, a1);
          ASET(2 + 1, a2);
          INSN_LEAVE;
          APP(3);
      }
      const CbyCode* fnref = chiToIP(chiToCbyFn(fn)->ip);
      {    SP[0] = a0;
      SP[1] = a1;
      SP[2] = a2;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  }
  OP_END
  OP_BEGIN(app4)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      if (chiFnArity(fn) != 4 || chiToCont(chiIdx(fn, 0)) != &interpFn) {
          ASET(0, fn);
          ASET(0 + 1, a0);
          ASET(1 + 1, a1);
          ASET(2 + 1, a2);
          ASET(3 + 1, a3);
          INSN_LEAVE;
          APP(4);
      }
      const CbyCode* fnref = chiToIP(chiToCbyFn(fn)->ip);
      {    SP[0] = a0;
      SP[1] = a1;
      SP[2] = a2;
      SP[3] = a3;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  }
  OP_END
  OP_BEGIN(app5)
      const Chili fn = REG[FETCH8];
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      const Chili a4 = REG[FETCH8];
      if (chiFnArity(fn) != 5 || chiToCont(chiIdx(fn, 0)) != &interpFn) {
          ASET(0, fn);
          ASET(0 + 1, a0);
          ASET(1 + 1, a1);
          ASET(2 + 1, a2);
          ASET(3 + 1, a3);
          ASET(4 + 1, a4);
          INSN_LEAVE;
          APP(5);
      }
      const CbyCode* fnref = chiToIP(chiToCbyFn(fn)->ip);
      {    SP[0] = a0;
      SP[1] = a1;
      SP[2] = a2;
      SP[3] = a3;
      SP[4] = a4;
      LEAVE;
      CURRFN = fn;
      REG = SP;
      IP = fnref;
      ENTER(true);
  }
  OP_END
  OP_BEGIN(clos0)
      const uint8_t lim = FETCH8;
      LIMITS_SAVE(({ INSN_LEAVE; goto SAVE_CLOS; }), .interrupt = true, .stack = lim);
  OP_END
  OP_BEGIN(clos1)
      const uint8_t arity = FETCH8;
      const uint8_t lim = FETCH8;
      {    LIMITS_SAVE(({ INSN_LEAVE; goto SAVE_CLOS; }), .interrupt = true, .stack = lim);
  }
      CHI_ASSERT(cbyFnOrThunkArity(CURRFN) == arity);
      const Chili* clos = chiToCbyFn(CURRFN)->clos;
      SP[arity + 0] = clos[0];
  OP_END
  OP_BEGIN(clos2)
      const uint8_t arity = FETCH8;
      const uint8_t lim = FETCH8;
      {    LIMITS_SAVE(({ INSN_LEAVE; goto SAVE_CLOS; }), .interrupt = true, .stack = lim);
  }
      CHI_ASSERT(cbyFnOrThunkArity(CURRFN) == arity);
      const Chili* clos = chiToCbyFn(CURRFN)->clos;
      SP[arity + 0] = clos[0];
      SP[arity + 1] = clos[1];
  OP_END
  OP_BEGIN(clos3)
      const uint8_t arity = FETCH8;
      const uint8_t lim = FETCH8;
      {    LIMITS_SAVE(({ INSN_LEAVE; goto SAVE_CLOS; }), .interrupt = true, .stack = lim);
  }
      CHI_ASSERT(cbyFnOrThunkArity(CURRFN) == arity);
      const Chili* clos = chiToCbyFn(CURRFN)->clos;
      SP[arity + 0] = clos[0];
      SP[arity + 1] = clos[1];
      SP[arity + 2] = clos[2];
  OP_END
  OP_BEGIN(clos4)
      const uint8_t arity = FETCH8;
      const uint8_t lim = FETCH8;
      {    LIMITS_SAVE(({ INSN_LEAVE; goto SAVE_CLOS; }), .interrupt = true, .stack = lim);
  }
      CHI_ASSERT(cbyFnOrThunkArity(CURRFN) == arity);
      const Chili* clos = chiToCbyFn(CURRFN)->clos;
      SP[arity + 0] = clos[0];
      SP[arity + 1] = clos[1];
      SP[arity + 2] = clos[2];
      SP[arity + 3] = clos[3];
  OP_END
  OP_BEGIN(clos)
      const uint8_t arity = FETCH8;
      const uint16_t lim = FETCH16;
      const uint16_t size = FETCH16;
      {    LIMITS_SAVE(({ INSN_LEAVE; goto SAVE_CLOS; }), .interrupt = true, .stack = lim);
  }
      CHI_ASSERT(cbyFnOrThunkArity(CURRFN) == arity);
      const Chili* clos = chiToCbyFn(CURRFN)->clos;
      for (uint32_t i = 0; i < size; ++i)
          SP[arity + i] = clos[i];
  OP_END
  OP_BEGIN(ffiget)
      Chili* const res = REG + FETCH16;
      int32_t _ffiref = (int32_t)FETCH32; const CbyCode* ffiref = IP + _ffiref;
      const FFIType rtype = (FFIType)ffiref[8];
      instrumentFFIBegin(proc, &interpPS->data, CURRFN, SP, ffiref);
      *res = fromFFI(FFIDESC(ffiref)->fn, rtype);
      instrumentFFIEnd(proc, &interpPS->data, CURRFN, SP, ffiref);
  OP_END
  OP_BEGIN(ffiset)
      const Chili var = REG[FETCH16];
      int32_t _ffiref = (int32_t)FETCH32; const CbyCode* ffiref = IP + _ffiref;
      CbyFFI* ffi = FFIDESC(ffiref);
      const FFIType atype = (FFIType)ffiref[10];
      instrumentFFIBegin(proc, &interpPS->data, CURRFN, SP, ffiref);
      toFFI(ffi->fn, var, atype);
      instrumentFFIEnd(proc, &interpPS->data, CURRFN, SP, ffiref);
  OP_END
  OP_BEGIN(ffitail)
      int32_t _ffiref = (int32_t)FETCH32; const CbyCode* ffiref = IP + _ffiref;
      const uint8_t nargs = FETCH8;
      CbyFFI* ffi = FFIDESC(ffiref);
      instrumentFFITail(proc, &interpPS->data, CURRFN, SP, ffiref);
      for (uint32_t i = 0; i < nargs; ++i)
          ASET(i, REG[FETCH16]);
      INSN_LEAVE;
      JUMP(CHI_CHOICE(CHI_CONT_PREFIX, (ChiCont)ffi->fn, ((ChiCont)ffi->fn)->fn));
  OP_END
  OP_BEGIN(ffiinl)
      Chili* const res = REG + FETCH16;
      int32_t _ffiref = (int32_t)FETCH32; const CbyCode* ffiref = IP + _ffiref;
      const uint8_t nargs = FETCH8;
      CbyFFI* ffi = FFIDESC(ffiref);
      ffiArgs(&interpPS->ffi, ffiref, REG, nargs, IP);
      IP += 2 * nargs;
      instrumentFFIBegin(proc, &interpPS->data, CURRFN, SP, ffiref);
      *res = ffiCall(&interpPS->ffi, ffiref, ffi);
      instrumentFFIEnd(proc, &interpPS->data, CURRFN, SP, ffiref);
  OP_END
  OP_BEGIN(ffiprot)
      int32_t _ffiref = (int32_t)FETCH32; const CbyCode* ffiref = IP + _ffiref;
      const uint8_t nargs = FETCH8;
      CbyFFI* ffi = FFIDESC(ffiref);
      instrumentFFITail(proc, &interpPS->data, CURRFN, SP, ffiref);
      ffiArgs(&interpPS->ffi, ffiref, REG, nargs, IP);
      INSN_LEAVE;
      PROTECT(ffiCall(&interpPS->ffi, ffiref, ffi));
  OP_END
  OP_BEGIN(thread)
      Chili* const res = REG + FETCH16;
      *res = AUX.THREAD;
  OP_END
  OP_BEGIN(proc)
      Chili* const res = REG + FETCH16;
      *res = AUX.PROC;
  OP_END
  OP_BEGIN(plocal)
      Chili* const res = REG + FETCH16;
      *res = AUX.PLOCAL;
  OP_END
  OP_BEGIN(tstate)
      Chili* const res = REG + FETCH16;
      const Chili thr = REG[FETCH16];
      *res = chiThreadState(thr);
  OP_END
  OP_BEGIN(evfilt)
      Chili* const res = REG + FETCH16;
      const Chili f = REG[FETCH16];
      const Chili n = REG[FETCH16];
      *res = chiFromBool(chiEventFilterEnabled(chiToPtr(f), chiToUInt32(n)));
  OP_END
  OP_BEGIN(bitsToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_bitsToFloat32(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(bitsToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_bitsToFloat64(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(charEq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_charEq(chiToChar(a0), chiToChar(a1)));
  OP_END
  OP_BEGIN(charLe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_charLe(chiToChar(a0), chiToChar(a1)));
  OP_END
  OP_BEGIN(charLt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_charLt(chiToChar(a0), chiToChar(a1)));
  OP_END
  OP_BEGIN(charNe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_charNe(chiToChar(a0), chiToChar(a1)));
  OP_END
  OP_BEGIN(charToString)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_charToString(chiToChar(a0));
  OP_END
  OP_BEGIN(charToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_charToUInt32(chiToChar(a0)));
  OP_END
  OP_BEGIN(float32Abs)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Abs(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Acos)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Acos(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Add)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Add(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Asin)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Asin(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Atan)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Atan(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Ceil)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Ceil(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Cos)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Cos(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Cosh)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Cosh(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Div)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Div(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Eq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float32Eq(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Exp)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Exp(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Expm1)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Expm1(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Floor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Floor(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Le)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float32Le(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Log)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Log(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Log1p)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Log1p(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Lt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float32Lt(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Mul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Mul(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Ne)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float32Ne(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Neg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Neg(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Pow)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Pow(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Round)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Round(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Sin)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Sin(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Sinh)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Sinh(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Sqrt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Sqrt(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Sub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Sub(chiToFloat32(a0), chiToFloat32(a1)));
  OP_END
  OP_BEGIN(float32Tan)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Tan(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Tanh)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Tanh(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32ToBits)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_float32ToBits(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32ToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float32ToFloat64(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32ToInt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_float32ToInt(chiToFloat32(a0));
  OP_END
  OP_BEGIN(float32ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_float32ToInt32(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32ToInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_float32ToInt64(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_float32ToUInt32(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32ToUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_float32ToUInt64(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float32Trunc)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float32Trunc(chiToFloat32(a0)));
  OP_END
  OP_BEGIN(float64Abs)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Abs(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Acos)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Acos(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Add)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Add(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Asin)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Asin(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Atan)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Atan(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Ceil)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Ceil(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Cos)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Cos(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Cosh)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Cosh(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Div)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Div(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Eq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float64Eq(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Exp)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Exp(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Expm1)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Expm1(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Floor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Floor(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Le)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float64Le(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Log)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Log(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Log1p)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Log1p(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Lt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float64Lt(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Mul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Mul(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Ne)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_float64Ne(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Neg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Neg(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Pow)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Pow(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Round)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Round(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Sin)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Sin(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Sinh)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Sinh(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Sqrt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Sqrt(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Sub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Sub(chiToFloat64(a0), chiToFloat64(a1)));
  OP_END
  OP_BEGIN(float64Tan)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Tan(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Tanh)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Tanh(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64ToBits)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_float64ToBits(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64ToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_float64ToFloat32(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64ToInt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_float64ToInt(chiToFloat64(a0));
  OP_END
  OP_BEGIN(float64ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_float64ToInt32(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64ToInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_float64ToInt64(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_float64ToUInt32(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64ToUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_float64ToUInt64(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(float64Trunc)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_float64Trunc(chiToFloat64(a0)));
  OP_END
  OP_BEGIN(int16ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int16ToInt32(chiToInt16(a0)));
  OP_END
  OP_BEGIN(int16ToUInt16)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt16(chi_Prim_int16ToUInt16(chiToInt16(a0)));
  OP_END
  OP_BEGIN(int32Add)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Add(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32And)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32And(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Div)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Div(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Eq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int32Eq(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Le)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int32Le(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Lt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int32Lt(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Mod)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Mod(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Mul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Mul(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Ne)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int32Ne(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Neg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Neg(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32Not)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Not(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32Or)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Or(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Quo)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Quo(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Rem)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Rem(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32Shl)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Shl(chiToInt32(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(int32Shr)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Shr(chiToInt32(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(int32Sub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Sub(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int32ToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_int32ToFloat32(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32ToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_int32ToFloat64(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32ToInt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_int32ToInt(chiToInt32(a0));
  OP_END
  OP_BEGIN(int32ToInt16)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt16(chi_Prim_int32ToInt16(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32ToInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int32ToInt64(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32ToInt8)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt8(chi_Prim_int32ToInt8(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_int32ToUInt32(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32ToUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_int32ToUInt64(chiToInt32(a0)));
  OP_END
  OP_BEGIN(int32Xor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int32Xor(chiToInt32(a0), chiToInt32(a1)));
  OP_END
  OP_BEGIN(int64Add)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Add(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64And)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64And(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Div)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Div(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Eq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int64Eq(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Le)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int64Le(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Lt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int64Lt(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Mod)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Mod(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Mul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Mul(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Ne)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_int64Ne(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Neg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Neg(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64Not)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Not(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64Or)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Or(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Quo)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Quo(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Rem)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Rem(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64Shl)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Shl(chiToInt64(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(int64Shr)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Shr(chiToInt64(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(int64Sub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Sub(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int64ToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_int64ToFloat32(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64ToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_int64ToFloat64(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64ToInt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_int64ToInt(chiToInt64(a0));
  OP_END
  OP_BEGIN(int64ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int64ToInt32(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_int64ToUInt32(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64ToUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_int64ToUInt64(chiToInt64(a0)));
  OP_END
  OP_BEGIN(int64Xor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_int64Xor(chiToInt64(a0), chiToInt64(a1)));
  OP_END
  OP_BEGIN(int8ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_int8ToInt32(chiToInt8(a0)));
  OP_END
  OP_BEGIN(int8ToUInt8)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt8(chi_Prim_int8ToUInt8(chiToInt8(a0)));
  OP_END
  OP_BEGIN(intAdd)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intAdd(a0, a1);
  OP_END
  OP_BEGIN(intAnd)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intAnd(a0, a1);
  OP_END
  OP_BEGIN(intCmp)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_intCmp(a0, a1));
  OP_END
  OP_BEGIN(intDiv)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intDiv(a0, a1);
  OP_END
  OP_BEGIN(intEq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_intEq(a0, a1));
  OP_END
  OP_BEGIN(intLe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_intLe(a0, a1));
  OP_END
  OP_BEGIN(intLt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_intLt(a0, a1));
  OP_END
  OP_BEGIN(intMod)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intMod(a0, a1);
  OP_END
  OP_BEGIN(intMul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intMul(a0, a1);
  OP_END
  OP_BEGIN(intNe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_intNe(a0, a1));
  OP_END
  OP_BEGIN(intNeg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_intNeg(a0);
  OP_END
  OP_BEGIN(intNot)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_intNot(a0);
  OP_END
  OP_BEGIN(intOr)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intOr(a0, a1);
  OP_END
  OP_BEGIN(intQuo)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intQuo(a0, a1);
  OP_END
  OP_BEGIN(intRem)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intRem(a0, a1);
  OP_END
  OP_BEGIN(intShl)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intShl(a0, chiToUInt16(a1));
  OP_END
  OP_BEGIN(intShr)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intShr(a0, chiToUInt16(a1));
  OP_END
  OP_BEGIN(intSub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intSub(a0, a1);
  OP_END
  OP_BEGIN(intToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_intToFloat32(a0));
  OP_END
  OP_BEGIN(intToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_intToFloat64(a0));
  OP_END
  OP_BEGIN(intToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_intToInt32(a0));
  OP_END
  OP_BEGIN(intToInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_intToInt64(a0));
  OP_END
  OP_BEGIN(intToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_intToUInt32(a0));
  OP_END
  OP_BEGIN(intToUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_intToUInt64(a0));
  OP_END
  OP_BEGIN(intXor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_intXor(a0, a1);
  OP_END
  OP_BEGIN(stringCmp)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_stringCmp(a0, a1));
  OP_END
  OP_BEGIN(stringCursorBegin)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_stringCursorBegin(a0));
  OP_END
  OP_BEGIN(stringCursorEnd)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_stringCursorEnd(a0));
  OP_END
  OP_BEGIN(stringCursorEq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringCursorEq(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringCursorLe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringCursorLe(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringCursorLt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringCursorLt(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringCursorNe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringCursorNe(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringCursorGet)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromChar(chi_Prim_stringCursorGet(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringCursorNext)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_stringCursorNext(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringCursorPrev)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_stringCursorPrev(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(stringEq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringEq(a0, a1));
  OP_END
  OP_BEGIN(stringLe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringLe(a0, a1));
  OP_END
  OP_BEGIN(stringLt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringLt(a0, a1));
  OP_END
  OP_BEGIN(stringNe)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringNe(a0, a1));
  OP_END
  OP_BEGIN(stringNull)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_stringNull(a0));
  OP_END
  OP_BEGIN(stringSlice)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      *res = chi_Prim_stringSlice(a0, chiToUInt32(a1), chiToUInt32(a2));
  OP_END
  OP_BEGIN(uint16ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint16ToUInt32(chiToUInt16(a0)));
  OP_END
  OP_BEGIN(uint16ToInt16)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt16(chi_Prim_uint16ToInt16(chiToUInt16(a0)));
  OP_END
  OP_BEGIN(uint32Add)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Add(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32And)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32And(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Div)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Div(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Eq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint32Eq(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Le)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint32Le(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Lt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint32Lt(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Mod)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Mod(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Mul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Mul(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Ne)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint32Ne(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Neg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Neg(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32Not)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Not(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32Or)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Or(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32Shl)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Shl(chiToUInt32(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(uint32Shr)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Shr(chiToUInt32(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(uint32Sub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Sub(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint32ToChar)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromChar(chi_Prim_uint32ToChar(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_uint32ToFloat32(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_uint32ToFloat64(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToInt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_uint32ToInt(chiToUInt32(a0));
  OP_END
  OP_BEGIN(uint32ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_uint32ToInt32(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_uint32ToInt64(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToUInt16)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt16(chi_Prim_uint32ToUInt16(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint32ToUInt64(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32ToUInt8)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt8(chi_Prim_uint32ToUInt8(chiToUInt32(a0)));
  OP_END
  OP_BEGIN(uint32Xor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint32Xor(chiToUInt32(a0), chiToUInt32(a1)));
  OP_END
  OP_BEGIN(uint64Add)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Add(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64And)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64And(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Div)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Div(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Eq)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint64Eq(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Le)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint64Le(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Lt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint64Lt(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Mod)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Mod(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Mul)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Mul(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Ne)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_uint64Ne(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Neg)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Neg(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64Not)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Not(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64Or)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Or(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64Shl)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Shl(chiToUInt64(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(uint64Shr)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Shr(chiToUInt64(a0), chiToUInt8(a1)));
  OP_END
  OP_BEGIN(uint64Sub)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Sub(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint64ToFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_uint64ToFloat32(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64ToFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_uint64ToFloat64(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64ToInt)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_uint64ToInt(chiToUInt64(a0));
  OP_END
  OP_BEGIN(uint64ToInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_uint64ToInt32(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64ToInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt64(chi_Prim_uint64ToInt64(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint64ToUInt32(chiToUInt64(a0)));
  OP_END
  OP_BEGIN(uint64Xor)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_uint64Xor(chiToUInt64(a0), chiToUInt64(a1)));
  OP_END
  OP_BEGIN(uint8ToUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_uint8ToUInt32(chiToUInt8(a0)));
  OP_END
  OP_BEGIN(uint8ToInt8)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromInt8(chi_Prim_uint8ToInt8(chiToUInt8(a0)));
  OP_END
  OP_BEGIN(lazyForce)
      const Chili thk = REG[FETCH8];
      /* This is basically the same code as in cont.h (FORCE macro),
       * optimized for the interpreter reentry.
       * Furthermore we push the update frame here instead of in the continuation.
       */
      if (!chiIsThunk(thk)) {
          Chili v0 = thk;
          {    _Static_assert(1 <= CBY_CONTEXT_SIZE, "Too many return values");
      INSN_LEAVE;
      if (chiToCont(SP[-1]) != &interpCont) {
          ASET(0, v0);
          RET;
      }
      FETCH_ENTER;
      CHI_ASSERT(nargs == 1);
      top[0] = v0;
      ENTER(true);
  }
      }
  
      Chili fn = chiFieldRead(&chiToThunk(thk)->cont);
      if (chiToCont(fn) != &interpThunk) {
          PUSH_UPDATE(thk);
          ASET(0, thk);
          INSN_LEAVE;
          JUMP_FN(fn);
      }
  
      LEAVE;
      CURRFN = thk;
      REG = SP;
      IP = chiToIP(chiToCbyFn(thk)->ip);
      ENTER(true);
  OP_END
  OP_BEGIN(stringBuilderNew)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_stringBuilderNew(chiToUInt32(a0));
  OP_END
  OP_BEGIN(stringBuilderChar)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_stringBuilderChar(chiToChar(a0), a1);
  OP_END
  OP_BEGIN(stringBuilderString)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_stringBuilderString(chiStringRef(&a0), a1);
  OP_END
  OP_BEGIN(stringBuilderBuild)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_stringBuilderBuild(a0);
  OP_END
  OP_BEGIN(bufferSize)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_bufferSize(a0));
  OP_END
  OP_BEGIN(arraySize)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_arraySize(a0));
  OP_END
  OP_BEGIN(arrayCas)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_arrayCas(a0, chiToUInt32(a1), a2, a3));
  OP_END
  OP_BEGIN(arrayClone)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      *res = chi_Prim_arrayClone(a0, chiToUInt32(a1), chiToUInt32(a2));
  OP_END
  OP_BEGIN(arrayCopy)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      const Chili a4 = REG[FETCH8];
      chi_Prim_arrayCopy(a0, chiToUInt32(a1), a2, chiToUInt32(a3), chiToUInt32(a4));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(arrayNew)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_arrayNew(chiToUInt32(a0), a1);
  OP_END
  OP_BEGIN(arrayRead)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chi_Prim_arrayRead(a0, chiToUInt32(a1));
  OP_END
  OP_BEGIN(arrayWrite)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_arrayWrite(a0, chiToUInt32(a1), a2);
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferClone)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      *res = chi_Prim_bufferClone(a0, chiToUInt32(a1), chiToUInt32(a2));
  OP_END
  OP_BEGIN(bufferCmp)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      const Chili a4 = REG[FETCH8];
      *res = chiFromInt32(chi_Prim_bufferCmp( a0
                                        , chiToUInt32(a1)
                                        , a2
                                        , chiToUInt32(a3)
                                        , chiToUInt32(a4) ));
  OP_END
  OP_BEGIN(bufferCopy)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      const Chili a4 = REG[FETCH8];
      chi_Prim_bufferCopy(a0, chiToUInt32(a1), a2, chiToUInt32(a3), chiToUInt32(a4));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferFill)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      const Chili a3 = REG[FETCH8];
      chi_Prim_bufferFill(a0, chiToUInt8(a1), chiToUInt32(a2), chiToUInt32(a3));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferNew)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chi_Prim_bufferNew(chiToUInt32(a0));
  OP_END
  OP_BEGIN(bufferReadFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat32(chi_Prim_bufferReadFloat32(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(bufferReadFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromFloat64(chi_Prim_bufferReadFloat64(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(bufferReadUInt16)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt16(chi_Prim_bufferReadUInt16(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(bufferReadUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_bufferReadUInt32(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(bufferReadUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt64(chi_Prim_bufferReadUInt64(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(bufferReadUInt8)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromUInt8(chi_Prim_bufferReadUInt8(a0, chiToUInt32(a1)));
  OP_END
  OP_BEGIN(bufferWriteFloat32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_bufferWriteFloat32(a0, chiToUInt32(a1), chiToFloat32(a2));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferWriteFloat64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_bufferWriteFloat64(a0, chiToUInt32(a1), chiToFloat64(a2));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferWriteUInt16)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_bufferWriteUInt16(a0, chiToUInt32(a1), chiToUInt16(a2));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferWriteUInt32)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_bufferWriteUInt32(a0, chiToUInt32(a1), chiToUInt32(a2));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferWriteUInt64)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_bufferWriteUInt64(a0, chiToUInt32(a1), chiToUInt64(a2));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(bufferWriteUInt8)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      const Chili a2 = REG[FETCH8];
      chi_Prim_bufferWriteUInt8(a0, chiToUInt32(a1), chiToUInt8(a2));
  *res = CHI_FALSE;
  OP_END
  OP_BEGIN(identical)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      const Chili a1 = REG[FETCH8];
      *res = chiFromBool(chi_Prim_identical(a0, a1));
  OP_END
  OP_BEGIN(tag)
      Chili* const res = REG + FETCH8;
      const Chili a0 = REG[FETCH8];
      *res = chiFromUInt32(chi_Prim_tag(a0));
  OP_END
  DISPATCH_END
  