public static void LuaGArithError(LuaState L, TValue p1, TValue p2)
 {
     TValue temp = new LuaTypeValue();
     if (luaV_tonumber(p1, temp) == null)
         p2 = p1;  /* first operand is wrong */
     LuaGTypeError(L, p2, "perform arithmetic on");
 }

 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);
 }

 public static UpVal LuaFindUpVal(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)
     {
         LuaAssert(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 = LuaMNew<UpVal>(L);  /* not found: create a new one */
     uv.tt = LUATUPVAL;
     uv.marked = LuaCWhite(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;
     LuaAssert(uv.u.l.next.u.l.prev == uv && uv.u.l.prev.u.l.next == uv);
     return uv;
 }

 public static void LuaFClose(LuaState L, StkId level)
 {
     UpVal uv;
       GlobalState g = G(L);
       while (L.openupval != null && (uv = ngcotouv(L.openupval)).v >= level) {
     GCObject o = obj2gco(uv);
     LuaAssert(!IsBlack(o) && uv.v != uv.u.value);
     L.openupval = uv.next;  /* remove from `open' list */
     if (IsDead(g, o))
       LuaFreeUpVal(L, uv);  /* free upvalue */
     else {
       UnlinkUpVal(uv);
       SetObj(L, uv.u.value, uv.v);
       uv.v = uv.u.value;  /* now current value lives here */
       LuaCLinkUpVal(L, uv);  /* link upvalue into `gcroot' list */
     }
       }
 }

 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_;
             //);
         }
 }

        public static TValue luaT_gettmbyobj(LuaState L, TValue o, TMS event_)
        {
            Table mt;
            switch (TType(o))
            {
                case LUA_TTABLE:
                    mt = HValue(o).metatable;
                    break;

                case LUA_TUSERDATA:
                    mt = UValue(o).metatable;
                    break;

                default:
                    mt = G(L).mt[TType(o)];
                    break;
            }

            return ((mt != null) ? luaH_getstr(mt, G(L).tmname[(int)event_]) : LuaONilObject);
        }

 /*
 ** main search function
 */
 public static TValue luaH_get(Table t, TValue key)
 {
     switch (TType(key))
     {
         case LUA_TNIL: return LuaONilObject;
         case LUA_TSTRING: return luaH_getstr(t, RawTSValue(key));
         case LUA_TNUMBER:
             {
                 int k;
                 lua_Number n = NValue(key);
                 lua_number2int(out k, n);
                 if (luai_numeq(CastNum(k), NValue(key))) /* index is int? */
                     return luaH_getnum(t, k);  /* use specialized version */
                 /* else go through ... actually on second thoughts don't, because this is C#*/
                 Node node = mainposition(t, key);
                 do
                 {  /* check whether `key' is somewhere in the chain */
                     if (LuaORawEqualObj(key2tval(node), key) != 0)
                         return gval(node);  /* that's it */
                     else node = gnext(node);
                 } while (node != null);
                 return LuaONilObject;
             }
         default:
             {
                 Node node = mainposition(t, key);
                 do
                 {  /* check whether `key' is somewhere in the chain */
                     if (LuaORawEqualObj(key2tval(node), key) != 0)
                         return gval(node);  /* that's it */
                     else node = gnext(node);
                 } while (node != null);
                 return LuaONilObject;
             }
     }
 }

 public Node(TValue i_val, TKey i_key)
 {
     this.values = new Node[] { this };
     this.index = 0;
     this.i_val = i_val;
     this.i_key = i_key;
 }

 internal static bool TTIsThread(TValue o)
 {
     return (TType(o) == LUA_TTHREAD);
 }

 internal static bool TTIsString(TValue o)
 {
     return (TType(o) == LUA_TSTRING);
 }

 /* Macros to test type */
 internal static bool TTIsNil(TValue o)
 {
     return (TType(o) == LUA_TNIL);
 }

 internal static bool TTIsBoolean(TValue o)
 {
     return (TType(o) == LUA_TBOOLEAN);
 }

 internal static void SetNValue(TValue obj, LuaNumberType x)
 {
     obj.value.n = x;
     obj.tt = LUA_TNUMBER;
 }

 /* Macros to set values */
 internal static void SetNilValue(TValue obj)
 {
     obj.tt=LUA_TNIL;
 }

 internal static void SetTType(TValue obj, int tt)
 {
     obj.tt = tt;
 }

 internal static void SetUValue(LuaState L, TValue obj, GCObject x)
 {
     obj.value.gc = x;
     obj.tt = LUA_TUSERDATA;
     CheckLiveness(G(L), obj);
 }

 internal static void SetObj(LuaState L, TValue obj1, TValue obj2)
 {
     obj1.value.Copy(obj2.value);
     obj1.tt = obj2.tt;
     CheckLiveness(G(L), obj1);
 }

 internal static bool TTIsFunction(TValue o)
 {
     return (TType(o) == LUA_TFUNCTION);
 }

 internal static bool TTIsNumber(TValue o)
 {
     return (TType(o) == LUA_TNUMBER);
 }

 internal static void SetPTValue(LuaState L, TValue obj, Proto x)
 {
     obj.value.gc = x;
     obj.tt = LUATPROTO;
     CheckLiveness(G(L), obj);
 }