func (vm *v53) newtable(instr vm.Instr) {
	var (
		a = instr.A()
		b = instr.B()
		c = instr.C()
	)
	t := newTable(vm.thread(), fb2i(b), fb2i(c))
	vm.thread().frame().set(a, t)
}
NEWTABLE: Create a new table.

Creates a new empty table at register R(A). B and C are the encoded size information
for the array part and the hash part of the table, respectively. Appropriate values
for B and C are set in order to avoid rehashing when initially populating the table
with array values or hash key-value pairs.

Operand B and C are both encoded as a "floating point byte" (see lobject.c)
which is eeeeexxx in binary, where x is the mantissa and e is the exponent.
The actual value is calculated as 1xxx*2^(eeeee-1) if eeeee is greater than
0 (a range of 8 to 15*2^30).

If eeeee is 0, the actual value is xxx (a range of 0 to 7.)

If an empty table is created, both sizes are zero. If a table is created with a number
of objects, the code generator counts the number of array elements and the number of
hash elements. Then, each size value is rounded up and encoded in B and C using the
floating point byte format.

@args A B C

R(A) := {} (size = B,C)
package lua
import "github.com/Azure/golua/lua/vm"
func (vm *v53) move(instr vm.Instr) {
	rb := vm.thread().frame().get(instr.B())
	vm.thread().frame().set(instr.A(), rb)
}
func (vm *v53) loadk(instr vm.Instr) {
	kst := vm.constant(instr.BX())
	vm.thread().frame().set(instr.A(), kst)
}
func (vm *v53) loadkx(instr vm.Instr) {
	extra := vm.thread().frame().step(1).AX()
	ra := vm.constant(extra)
	vm.thread().frame().set(instr.A(), ra)
}
func (vm *v53) loadbool(instr vm.Instr) {
	vm.thread().frame().set(instr.A(), Bool(instr.B() == 1))
	if instr.C() != 0 {
		vm.thread().frame().step(1)
	}
}
func (vm *v53) loadnil(instr vm.Instr) {
	var (
		a = instr.A()
		b = instr.B()
	)
	for i := a; i <= a+b; i++ {
		vm.thread().frame().set(i, Nil(1))
	}
}
func (vm *v53) getupval(instr vm.Instr) {
	var (
		a = instr.A()
		b = instr.B()
	)
	up := vm.thread().frame().getUp(b)
	vm.thread().frame().set(a, up.get())
}
func (vm *v53) setupval(instr vm.Instr) {
	var (
		a = instr.A()
		b = instr.B()
	)
	ra := vm.thread().frame().get(a)
	vm.thread().frame().setUp(b, ra)
}
func (vm *v53) gettable(instr vm.Instr) {
	var (
		a = instr.A()
		b = instr.B()
		c = instr.C()
	)
	t := vm.thread().frame().get(b)
	k := vm.rk(c)
	v := vm.thread().gettable(t, k, false)
	vm.thread().frame().set(a, v)
}
func (vm *v53) settable(instr vm.Instr) {
	obj := vm.thread().frame().get(instr.A())
	key := vm.rk(instr.B())
	val := vm.rk(instr.C())
	vm.thread().settable(obj, key, val, false)
}
func (vm *v53) gettabup(instr vm.Instr) {
	up := vm.thread().frame().getUp(instr.B()).get()
	rc := vm.rk(instr.C())
	ra := vm.thread().gettable(up, rc, false)
	vm.thread().frame().set(instr.A(), ra)
}
func (vm *v53) settabup(instr vm.Instr) {
	up := vm.thread().frame().getUp(instr.A()).get()
	rb := vm.rk(instr.B())
	rc := vm.rk(instr.C())
	vm.thread().settable(up, rb, rc, false)
}