public static void arith_op(lua_State L, op_delegate op, TMS tm, StkId base_, Instruction i, TValue[] k, StkId ra, InstructionPtr pc)
 {
     TValue rb = RKB(L, base_, i, k);
         TValue rc = RKC(L, base_, i, k);
         if (ttisnumber(rb) && ttisnumber(rc))
         {
             lua_Number nb = nvalue(rb), nc = nvalue(rc);
             setnvalue(ra, op(nb, nc));
         }
         else
         {
             //Protect(
             L.savedpc = InstructionPtr.Assign(pc);
             Arith(L, ra, rb, rc, tm);
             base_ = L.base_;
             //);
         }
 }

		private static void traceexec (LuaState L, InstructionPtr pc) {
		  lu_byte mask = L.hookmask;
		  InstructionPtr oldpc = InstructionPtr.Assign(L.savedpc);
		  L.savedpc = InstructionPtr.Assign(pc);
		  if (((mask & LUA_MASKCOUNT) != 0) && (L.hookcount == 0)) {
			ResetHookCount(L);
			LuaDCallHook(L, LUA_HOOKCOUNT, -1);
		  }
		  if ((mask & LUA_MASKLINE) != 0) {
			Proto p = CIFunc(L.ci).l.p;
			int npc = PCRel(pc, p);
			int newline = GetLine(p, npc);
			/* call linehook when enter a new function, when jump back (loop),
			   or when enter a new line */
			if (npc == 0 || pc <= oldpc || newline != GetLine(p, PCRel(oldpc, p)))
			  LuaDCallHook(L, LUA_HOOKLINE, newline);
		  }
		}

        private static void traceexec (lua_State L, InstructionPtr pc) {
            lu_byte mask = L.hookmask;
            InstructionPtr oldpc = InstructionPtr.Assign(L.savedpc);
            L.savedpc = InstructionPtr.Assign(pc);
            if (((mask & LUA_MASKCOUNT) != 0) && (L.hookcount == 0)) {
                resethookcount(L);
                luaD_callhook(L, LUA_HOOKCOUNT, -1);
            }
            if ((mask & LUA_MASKLINE) != 0) {
                Proto p = ci_func(L.ci).l.p;
                int npc = pcRel(pc, p);
                int newline = getline(p, npc);
                /* call linehook when enter a new function, when jump back (loop),
			   or when enter a new line */
                if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))
                    luaD_callhook(L, LUA_HOOKLINE, newline);
            }
        }

		private static InstructionPtr GetJumpControl (FuncState fs, int pc) {
		  InstructionPtr pi = new InstructionPtr(fs.f.code, pc);
		  if (pc >= 1 && (testTMode(GET_OPCODE(pi[-1]))!=0))
			return new InstructionPtr(pi.codes, pi.pc-1);
		  else
			return new InstructionPtr(pi.codes, pi.pc);
		}

		private static void FixJump (FuncState fs, int pc, int dest) {
		  InstructionPtr jmp = new InstructionPtr(fs.f.code, pc);
		  int offset = dest-(pc+1);
		  LuaAssert(dest != NO_JUMP);
		  if (Math.Abs(offset) > MAXARG_sBx)
			LuaXSyntaxError(fs.ls, "control structure too long");
		  SETARG_sBx(jmp, offset);
		}

		public static void LuaKNil (FuncState fs, int from, int n) {
		  InstructionPtr previous;
		  if (fs.pc > fs.lasttarget) {  /* no jumps to current position? */
			if (fs.pc == 0) {  /* function start? */
			  if (from >= fs.nactvar)
				return;  /* positions are already clean */
			}
			else {
			  previous = new InstructionPtr(fs.f.code, fs.pc-1);
			  if (GET_OPCODE(previous) == OpCode.OP_LOADNIL) {
				int pfrom = GETARG_A(previous);
				int pto = GETARG_B(previous);
				if (pfrom <= from && from <= pto+1) {  /* can connect both? */
				  if (from+n-1 > pto)
					SETARG_B(previous, from+n-1);
				  return;
				}
			  }
			}
		  }
		  LuaKCodeABC(fs, OpCode.OP_LOADNIL, from, from + n - 1, 0);  /* else no optimization */
		}

 internal static void SET_OPCODE(InstructionPtr i, OpCode opcode)
 {
     SET_OPCODE(ref i.codes[i.pc], opcode);
 }

 internal static void SETARG_sBx(InstructionPtr i, int b)
 {
     SETARG_Bx(i, b + MAXARG_sBx);
 }

 internal static void SETARG_C(InstructionPtr i, int b)
 {
     i[0] = (Instruction)((i[0] & MASK0(SIZE_C, POS_C)) | ((b << POS_C) & MASK1(SIZE_C, POS_C)));
 }

		public static void dojump(LuaState L, InstructionPtr pc, int i) { pc.pc += i; LuaIThreadYield(L); }

 internal static OpCode GET_OPCODE(InstructionPtr i)
 {
     return GET_OPCODE(i[0]);
 }

 internal static int GETARG_sBx(InstructionPtr i)
 {
     return GETARG_sBx(i[0]);
 }

 public static void dojump(lua_State L, InstructionPtr pc, int i)
 {
     pc.pc += i; luai_threadyield(L);
 }

		public static int PCRel(InstructionPtr pc, Proto p)
		{
			Debug.Assert(pc.codes == p.code);
			return pc.pc - 1;
		}

		public static InstructionPtr Assign(InstructionPtr ptr)
		{
			if (ptr == null) return null;
			return new InstructionPtr(ptr.codes, ptr.pc);
		}

		public static InstructionPtr dec(ref InstructionPtr ptr)
		{
			InstructionPtr result = new InstructionPtr(ptr.codes, ptr.pc);
			ptr.pc--;
			return result;
		}

 internal static void SETARG_A(InstructionPtr i, int u)
 {
     i[0] = (Instruction)((i[0] & MASK0(SIZE_A, POS_A)) | ((u << POS_A) & MASK1(SIZE_A, POS_A)));
 }