public static UpVal luaF_findupval (LuaState L, StkId level) {
		  GlobalState g = G(L);
		  GCObjectRef pp = new OpenValRef(L);
		  UpVal p;
		  UpVal uv;
		  while (pp.get() != null && (p = ngcotouv(pp.get())).v >= level) {
			lua_assert(p.v != p.u.value);
			if (p.v == level) {  /* found a corresponding upvalue? */
			  if (isdead(g, obj2gco(p)))  /* is it dead? */
				changewhite(obj2gco(p));  /* ressurect it */
			  return p;
			}
			pp = new NextRef(p);
		  }
		  uv = luaM_new<UpVal>(L);  /* not found: create a new one */
		  uv.tt = LUA_TUPVAL;
		  uv.marked = luaC_white(g);
		  uv.v = level;  /* current value lives in the stack */
		  uv.next = pp.get();  /* chain it in the proper position */
		  pp.set( obj2gco(uv) );
		  uv.u.l.prev = g.uvhead;  /* double link it in `uvhead' list */
		  uv.u.l.next = g.uvhead.u.l.next;
		  uv.u.l.next.u.l.prev = uv;
		  g.uvhead.u.l.next = uv;
		  lua_assert(uv.u.l.next.u.l.prev == uv && uv.u.l.prev.u.l.next == uv);
		  return uv;
		}

		public static int luaV_tostring (LuaState L, StkId obj) {
		  if (!TTIsNumber(obj))
			return 0;
		  else {
			lua_Number n = NValue(obj);
			CharPtr s = lua_number2str(n);
			SetSValue2S(L, obj, luaS_new(L, s));
			return 1;
		  }
		}

 public static int luaV_tostring (lua_State L, StkId obj) {
     if (!ttisnumber(obj))
         return 0;
     else {
         lua_Number n = nvalue(obj);
         CharPtr s = lua_number2str(n);
         setsvalue2s(L, obj, luaS_new(L, s));
         return 1;
     }
 }

 private static void callTMres (lua_State L, StkId res, TValue f,
                                TValue p1, TValue p2) {
     ptrdiff_t result = savestack(L, res);
     setobj2s(L, L.top, f);  /* push function */
     setobj2s(L, L.top+1, p1);  /* 1st argument */
     setobj2s(L, L.top+2, p2);  /* 2nd argument */
     luaD_checkstack(L, 3);
     L.top += 3;
     luaD_call(L, L.top-3, 1);
     res = restorestack(L, result);
     StkId.dec(ref L.top);
     setobjs2s(L, res, L.top);
 }

 // in the original C code these values save and restore the stack by number of bytes. marshalling sizeof
 // isn't that straightforward in managed languages, so i implement these by index instead.
 public static int SaveStack(LuaState L, StkId p)
 {
     return p;
 }

 public static void LuaDSetErrorObj(LuaState L, int errcode, StkId oldtop)
 {
     switch (errcode)
     {
         case LUA_ERRMEM:
             {
                 SetSValue2S(L, oldtop, luaS_newliteral(L, MEMERRMSG));
                 break;
             }
         case LUA_ERRERR:
             {
                 SetSValue2S(L, oldtop, luaS_newliteral(L, "error in error handling"));
                 break;
             }
         case LUA_ERRSYNTAX:
         case LUA_ERRRUN:
             {
                 SetObj2S(L, oldtop, L.top - 1);  /* error message on current top */
                 break;
             }
     }
     L.top = oldtop + 1;
 }

 static CharPtr aux_upvalue(StkId fi, int n, ref TValue val)
 {
     Closure f;
     if (!ttisfunction(fi)) return null;
     f = clvalue(fi);
     if (f.c.isC != 0)
     {
         if (!(1 <= n && n <= f.c.nupvalues)) return null;
         val = f.c.upvalue[n - 1];
         return "";
     }
     else
     {
         Proto p = f.l.p;
         if (!(1 <= n && n <= p.sizeupvalues)) return null;
         val = f.l.upvals[n - 1].v;
         return getstr(p.upvalues[n - 1]);
     }
 }

		public static void LuaGConcatError (LuaState L, StkId p1, StkId p2) {
		  if (TTIsString(p1) || TTIsNumber(p1)) p1 = p2;
		  LuaAssert(!TTIsString(p1) && !TTIsNumber(p1));
		  LuaGTypeError(L, p1, "concatenate");
		}

		public static void luaV_settable (LuaState L, TValue t, TValue key, StkId val) {
		  int loop;
		  TValue temp = new LuaTypeValue();
		  for (loop = 0; loop < MAXTAGLOOP; loop++) {
			TValue tm;
			if (TTIsTable(t)) {  /* `t' is a table? */
			  Table h = HValue(t);
			  TValue oldval = luaH_set(L, h, key); /* do a primitive set */
			  if (!TTIsNil(oldval) ||  /* result is no nil? */
				  (tm = fasttm(L, h.metatable, TMS.TM_NEWINDEX)) == null) { /* or no TM? */
				SetObj2T(L, oldval, val);
			    h.flags = 0;
				LuaCBarrierT(L, h, val);
				return;
			  }
			  /* else will try the tag method */
			}
			else if (TTIsNil(tm = luaT_gettmbyobj(L, t, TMS.TM_NEWINDEX)))
			  LuaGTypeError(L, t, "index");
			if (TTIsFunction(tm)) {
			  callTM(L, tm, t, key, val);
			  return;
			}
			/* else repeat with `tm' */
			SetObj (L, temp, tm); /* avoid pointing inside table (may rehash) */
			t = temp;
		  }
		  LuaGRunError(L, "loop in settable");
		}

		internal static TValue RKC(LuaState L, StkId base_, Instruction i, TValue[] k) { return ISK(GETARG_C(i)) != 0 ? k[INDEXK(GETARG_C(i))] : base_ + GETARG_C(i); }

 private static StkId TryFuncTM(LuaState L, StkId func)
 {
     /*const*/
     TValue tm = luaT_gettmbyobj(L, func, TMS.TM_CALL);
     StkId p;
     ptrdiff_t funcr = SaveStack(L, func);
     if (!TTIsFunction(tm))
         LuaGTypeError(L, func, "call");
     /* Open a hole inside the stack at `func' */
     for (p = L.top; p > func; StkId.Dec(ref p)) SetObj2S(L, p, p - 1);
     IncrTop(L);
     func = RestoreStack(L, funcr);  /* previous call may change stack */
     SetObj2S(L, func, tm);  /* tag method is the new function to be called */
     return func;
 }

		public static void Arith (LuaState L, StkId ra, TValue rb,
						   TValue rc, TMS op) {
		  TValue tempb = new LuaTypeValue(), tempc = new LuaTypeValue();
		  TValue b, c;
		  if ((b = luaV_tonumber(rb, tempb)) != null &&
			  (c = luaV_tonumber(rc, tempc)) != null) {
			lua_Number nb = NValue(b), nc = NValue(c);
			switch (op) {
			  case TMS.TM_ADD: SetNValue(ra, luai_numadd(nb, nc)); break;
			  case TMS.TM_SUB: SetNValue(ra, luai_numsub(nb, nc)); break;
			  case TMS.TM_MUL: SetNValue(ra, luai_nummul(nb, nc)); break;
			  case TMS.TM_DIV: SetNValue(ra, luai_numdiv(nb, nc)); break;
			  case TMS.TM_MOD: SetNValue(ra, luai_nummod(nb, nc)); break;
			  case TMS.TM_POW: SetNValue(ra, luai_numpow(nb, nc)); break;
			  case TMS.TM_UNM: SetNValue(ra, luai_numunm(nb)); break;
			  default: LuaAssert(false); break;
			}
		  }
		  else if (call_binTM(L, rb, rc, ra, op) == 0)
			LuaGArithError(L, rb, rc);
		}

		internal static TValue RC(LuaState L, StkId base_, Instruction i) { return base_ + GETARG_C(i); }

		public static int tonumber(ref StkId o, TValue n) {
			return ((TType(o) == LUA_TNUMBER || (((o) = luaV_tonumber(o, n)) != null))) ? 1 : 0;
		}

		public static int tostring(LuaState L, StkId o) {
			return ((TType(o) == LUA_TSTRING) || (luaV_tostring(L, o) != 0)) ? 1 : 0;
		}

		private static int call_binTM (LuaState L, TValue p1, TValue p2,
							   StkId res, TMS event_) {
		  TValue tm = luaT_gettmbyobj(L, p1, event_);  /* try first operand */
		  if (TTIsNil(tm))
			tm = luaT_gettmbyobj(L, p2, event_);  /* try second operand */
		  if (TTIsNil(tm)) return 0;
		  callTMres(L, res, tm, p1, p2);
		  return 1;
		}

 private static StkId CallRetHooks(LuaState L, StkId firstResult)
 {
     ptrdiff_t fr = SaveStack(L, firstResult);  /* next call may change stack */
     LuaDCallHook(L, LUA_HOOKRET, -1);
     if (FIsLua(L.ci))
     {  /* Lua function? */
         while (((L.hookmask & LUA_MASKRET) != 0) && (L.ci.tailcalls-- != 0)) /* tail calls */
             LuaDCallHook(L, LUA_HOOKTAILRET, -1);
     }
     return RestoreStack(L, fr);
 }

		public static void arith_op(LuaState 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_;
					//);
				}
		      }

        /*
        ** Call a function (C or Lua). The function to be called is at *func.
        ** The arguments are on the stack, right after the function.
        ** When returns, all the results are on the stack, starting at the original
        ** function position.
        */
        private static void LuaDCall(LuaState L, StkId func, int nResults)
        {
            if (++L.nCcalls >= LUAI_MAXCCALLS)
            {
                if (L.nCcalls == LUAI_MAXCCALLS)
                    LuaGRunError(L, "C stack overflow");
                else if (L.nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS >> 3)))
                    LuaDThrow(L, LUA_ERRERR);  /* error while handing stack error */
            }

            if (LuaDPreCall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
                luaV_execute(L, 1);  /* call it */

            L.nCcalls--;
            LuaCCheckGC(L);
        }

		public static int luaH_next (LuaState L, Table t, StkId key) {
		  int i = findindex(L, t, key);  /* find original element */
		  for (i++; i < t.sizearray; i++) {  /* try first array part */
			if (!TTIsNil(t.array[i])) {  /* a non-nil value? */
			  SetNValue(key, CastNum(i+1));
			  SetObj2S(L, key+1, t.array[i]);
			  return 1;
			}
		  }
		  for (i -= t.sizearray; i < SizeNode(t); i++) {  /* then hash part */
			if (!TTIsNil(gval(gnode(t, i)))) {  /* a non-nil value? */
			  SetObj2S(L, key, key2tval(gnode(t, i)));
			  SetObj2S(L, key+1, gval(gnode(t, i)));
			  return 1;
			}
		  }
		  return 0;  /* no more elements */
		}