luau_vm/vm/

execute.rs

use crate::ObjectMemberLookup;
use crate::call::{CallRuntime, ThreadStack};
use crate::class::ClassRuntime;
use crate::debug::DebugRuntime;
use crate::function::FunctionRuntime;
use crate::function::{Closure, Proto};
use crate::gc::GcObject;
use crate::gc::{GcBarrier, GcRuntime};
use crate::handle::RawHandle;
use crate::handle::sealed::Sealed;
use crate::metamethod::{MetamethodRuntime, TmEvent};
use crate::native::NativeCallContext;
use crate::state::ThreadState;
use crate::state::{LUA_CALLINFO_NATIVE, LUA_CALLINFO_OP_YIELD};
use crate::table::TableRuntime;
use crate::thread::{LUA_MULTRET, Thread};
use crate::types::{
    LUA_TBOOLEAN, LUA_TBUFFER, LUA_TCLASS, LUA_TFUNCTION, LUA_TINTEGER, LUA_TLIGHTUSERDATA,
    LUA_TNIL, LUA_TNUMBER, LUA_TOBJECT, LUA_TSTRING, LUA_TTABLE, LUA_TTHREAD, LUA_TUSERDATA,
    LUA_TVECTOR, LUA_VECTOR_SIZE,
};
use crate::userdata::{LuaUserdataDirectFieldGet, USERDATA_TAG_LIMIT, UserdataDirectFieldResult};
use crate::value::{RAW_TVALUE_NIL, RawTValue, TValue, TValueCursor, nil_object};
use crate::vm::{VmCallFrame, VmOperations, string_compare};
use crate::{VmExit, VmResult};
use luau_bytecode::model::{Instruction, InstructionAux};
use luau_bytecode::opcodes::Opcode;
use luau_common::flags;
use std::mem;
use std::ptr;

const LCT_VAL: u8 = 0;
const LCT_REF: u8 = 1;
const LCT_UPVAL: u8 = 2;

/// Unstable bytecode execution capability.
///
/// # Safety
///
/// The thread's current call frame, stack, saved program counter, closure, and
/// bytecode graph must form a valid VM execution state. Execution may mutate
/// or relocate all VM state and invalidate unrooted handles and cursors.
#[allow(
    clippy::missing_safety_doc,
    reason = "all methods share the capability-level safety contract"
)]
pub trait VmExecution: Sealed {
    /// `luau_execute`
    unsafe fn execute(&self) -> VmResult;

    /// `luau_finishop`
    unsafe fn finish_op(&self) -> VmResult;
}

trait InstructionWordExt {
    fn word(self) -> u32;
    fn opcode(self) -> Opcode;
    fn a(self) -> u8;
    fn b(self) -> u8;
    fn c(self) -> u8;
    fn d(self) -> i16;
    fn e(self) -> i32;
}

impl InstructionWordExt for u32 {
    fn word(self) -> u32 {
        self
    }

    fn opcode(self) -> Opcode {
        decode_instruction_opcode(Instruction::new(self))
    }

    fn a(self) -> u8 {
        Instruction::new(self).a()
    }

    fn b(self) -> u8 {
        Instruction::new(self).b()
    }

    fn c(self) -> u8 {
        Instruction::new(self).c()
    }

    fn d(self) -> i16 {
        Instruction::new(self).d()
    }

    fn e(self) -> i32 {
        Instruction::new(self).e()
    }
}

trait InstructionBits {
    fn bits(self) -> u32;
}

impl InstructionBits for u32 {
    fn bits(self) -> u32 {
        self
    }
}

impl InstructionBits for Instruction {
    fn bits(self) -> u32 {
        self.word()
    }
}

#[inline(always)]
fn v_skip_step(op: Opcode) -> bool {
    matches!(op, Opcode::PrepVarargs | Opcode::Break)
}

impl Proto {
    /// `VM_KV`
    #[inline(always)]
    fn vm_const(&self, constants: TValueCursor, index: usize) -> TValue {
        debug_assert!(index < unsafe { self.as_ptr().as_ref().unwrap_unchecked().size_k as usize });
        unsafe { constants.add(index).value_unchecked() }
    }

    /// `VM_ASSERT_PC`
    fn assert_vm_pc(&self, pc: *const u32) {
        let code = unsafe { self.as_ptr().as_ref().unwrap_unchecked().code }.cast_const();
        let size = unsafe { self.as_ptr().as_ref().unwrap_unchecked().size_code as usize };
        debug_assert!(pc >= code);
        debug_assert!(unsafe { pc.offset_from(code) as usize } < size);
    }
}

impl TValueCursor {
    fn vm_reg_cursor(self, top: TValueCursor, index: usize) -> TValueCursor {
        debug_assert!(index < unsafe { top.offset_from(self) as usize });
        unsafe { self.add(index) }
    }
}

impl TValue {
    // lobject.h: vvalue(o) returns a contiguous float view over value.v + TValue::extra.
    #[inline(always)]
    unsafe fn vector_ptr(&self) -> *const f32 {
        debug_assert_eq!(self.tt(), LUA_TVECTOR);
        unsafe { (&raw const self.as_ptr().as_ref().unwrap_unchecked().value.vector).cast::<f32>() }
    }

    #[inline(always)]
    unsafe fn vector_eq(&self, rhs: TValue) -> bool {
        unsafe {
            let lhs = self.vector_ptr();
            let rhs = rhs.vector_ptr();

            #[cfg(feature = "vector4")]
            {
                *lhs == *rhs
                    && *lhs.add(1) == *rhs.add(1)
                    && *lhs.add(2) == *rhs.add(2)
                    && vector_w_ptr(lhs) == vector_w_ptr(rhs)
            }

            #[cfg(not(feature = "vector4"))]
            {
                *lhs == *rhs && *lhs.add(1) == *rhs.add(1) && *lhs.add(2) == *rhs.add(2)
            }
        }
    }

    /// `setvvalue`
    #[inline(always)]
    fn set_vector4(&self, x: f32, y: f32, z: f32, w: f32) {
        #[cfg(not(feature = "vector4"))]
        {
            let _ = w;
            self.set_vector([x, y, z]);
        }

        #[cfg(feature = "vector4")]
        self.set_vector([x, y, z, w]);
    }
}

#[cfg(feature = "vector4")]
#[inline(always)]
unsafe fn vector_w_ptr(value: *const f32) -> f32 {
    unsafe { *value.add(3) }
}

#[cfg(not(feature = "vector4"))]
#[inline(always)]
unsafe fn vector_w_ptr(_value: *const f32) -> f32 {
    0.0
}

impl Thread {
    /// `VM_PROTECT_PC`
    #[inline(always)]
    fn set_vm_saved_pc<T>(&self, pc: *const T) {
        unsafe {
            self.current_call_info().set_saved_pc(pc.cast());
        }
    }

    /// `VM_INTERRUPT`
    #[inline(always)]
    fn interrupt_vm(&self, pc: *const u32) -> VmResult {
        let global = unsafe { self.global() };
        let Some(interrupt) = global.take_execution_interrupt_callback() else {
            return Ok(());
        };

        unsafe { self.interrupt_vm_slow(pc, interrupt) }
    }

    #[cold]
    #[inline(never)]
    unsafe fn interrupt_vm_slow(
        &self,
        pc: *const u32,
        interrupt: fn(&Thread) -> VmResult,
    ) -> VmResult {
        unsafe {
            self.current_call_info().set_saved_pc(pc.add(1));
            let result = interrupt(self);
            if let Err(exit @ VmExit::Control(_)) = result {
                let current_call_info = self.current_call_info();
                current_call_info.set_saved_pc(current_call_info.saved_pc().sub(1));
                return Err(exit);
            }

            result
        }
    }

    unsafe fn tm_by_obj_or_nil(&self, object: TValue, event: TmEvent) -> TValue {
        unsafe { self.get_tm_by_obj(object, event).unwrap_or_else(nil_object) }
    }

    #[cold]
    #[inline(never)]
    unsafe fn finish_native_call(&self, called_closure: Closure, nresults: i32) -> VmResult {
        unsafe {
            let native_function = called_closure.native_data().function.unwrap_unchecked();
            let produced = native_function(NativeCallContext::new(self))?;

            let call_info = self.current_call_info();
            let parent_cursor = self.current_call_info_cursor().sub(1);
            let parent = parent_cursor.call_info_unchecked();

            let mut result = call_info.function();
            let mut value = self.stack_top().sub(produced);
            let value_end = self.stack_top();
            let mut remaining = nresults;

            while remaining != 0 && value < value_end {
                result.value_unchecked().set_obj(value.value_unchecked());
                result = result.add(1);
                value = value.add(1);
                remaining -= 1;
            }

            while remaining > 0 {
                result.value_unchecked().set_nil();
                result = result.add(1);
                remaining -= 1;
            }

            self.set_current_call_info(parent_cursor);
            self.set_stack_base(parent.base());
            self.set_stack_top(if nresults == LUA_MULTRET {
                result
            } else {
                parent.top()
            });
            Ok(())
        }
    }

    pub(crate) unsafe fn execute_thread(&self) -> VmResult {
        if unsafe { self.as_ptr().as_ref().unwrap_unchecked().single_step } {
            v_execute_impl::<true>(self)
        } else {
            v_execute_impl::<false>(self)
        }
    }

    pub(crate) unsafe fn finish_op_thread(&self) -> VmResult {
        unsafe {
            let call_info = self.current_call_info();
            call_info.as_ptr().as_mut().unwrap_unchecked().flags &= !LUA_CALLINFO_OP_YIELD;

            let closure = call_info.function_closure();
            let base = self.stack_base();
            let mut pc = call_info.saved_pc();
            let instruction = *pc.sub(1);

            match decode_instruction_opcode(instruction) {
                Opcode::ForGLoop => {
                    let ra = base.vm_reg_cursor(self.stack_top(), instruction.a() as usize);

                    ra.add(2)
                        .value_unchecked()
                        .set_obj(ra.add(3).value_unchecked());

                    pc = if ra.add(3).value_unchecked().is_nil() {
                        pc.add(1)
                    } else {
                        pc.offset(instruction.d() as isize)
                    };

                    closure.proto().unwrap_unchecked().assert_vm_pc(pc);
                }
                _ => unreachable!("unknown yielded opcode"),
            }

            call_info.set_saved_pc(pc);
        }
        Ok(())
    }

    unsafe fn setup_cci(&self, n_results: i32, function: TValueCursor) -> VmResult {
        unsafe {
            let call_info = self.incr_ci()?.call_info_unchecked();
            let closure = function.value_unchecked().closure_value();

            call_info.init_call(
                function,
                function.add(1).add(crate::thread::LUA_MIN_STACK),
                n_results,
                closure.proto(),
            );

            self.set_stack_base(function.add(1));
            self.check_stack_for_new_ci(crate::thread::LUA_MIN_STACK as i32)?;

            debug_assert!(call_info.top() <= self.stack_last());
            debug_assert!(call_info.function().value_unchecked().is_function());
        }
        Ok(())
    }
}

impl VmExecution for Thread {
    /// `luau_execute`
    unsafe fn execute(&self) -> VmResult {
        unsafe { self.execute_thread() }
    }

    /// `luau_finishop`
    unsafe fn finish_op(&self) -> VmResult {
        unsafe { self.finish_op_thread() }
    }
}

fn patch_instruction_c<T>(instruction: *mut T, c: u8) {
    unsafe {
        let instruction = instruction.cast::<Instruction>();
        *instruction = Instruction::new((*instruction).word()).with_c(c);
    }
}

fn patch_instruction_opcode<T>(instruction: *mut T, opcode: Opcode) {
    unsafe {
        let instruction = instruction.cast::<Instruction>();
        *instruction = Instruction::new(((*instruction).word() & !0xff) | opcode as u32);
    }
}

fn patch_aux_slot<T>(aux: *mut T, kv: u16, slot: u16) {
    unsafe {
        let aux = aux.cast::<Instruction>();
        *aux = Instruction::new(kv as u32 | ((slot as u32) << 16));
    }
}

#[inline(always)]
fn decode_opcode_byte(opcode: u8) -> Opcode {
    debug_assert!(usize::from(opcode) < Opcode::COUNT);
    unsafe { mem::transmute(opcode) }
}

#[inline(always)]
fn decode_instruction_opcode<T: InstructionBits>(instruction: T) -> Opcode {
    decode_opcode_byte((instruction.bits() & 0xff) as u8)
}

fn v_execute_impl<const SINGLE_STEP: bool>(thread: &Thread) -> VmResult {
    unsafe {
        let global = thread.global();
        let current_call_info = thread.current_call_info();

        debug_assert!(current_call_info.is_lua());
        debug_assert!(thread.as_ptr().as_ref().unwrap_unchecked().is_active);
        debug_assert!(!GcObject::from(thread).is_black());

        let mut pc = current_call_info.saved_pc();
        let mut closure = current_call_info.function_closure();
        let mut base = thread.stack_base();
        let mut proto = closure.proto().unwrap_unchecked();
        let mut constants = proto.constants();

        if current_call_info.as_ptr().as_ref().unwrap_unchecked().flags & LUA_CALLINFO_NATIVE != 0
            && !SINGLE_STEP
        {
            debug_assert!(
                !proto
                    .as_ptr()
                    .as_ref()
                    .unwrap_unchecked()
                    .exec_data
                    .is_null()
            );

            let Some(enter) = global.execution_enter() else {
                unreachable!("native lvmexecute requires an execution enter callback");
            };

            if enter(thread, proto) == 0 {
                return Ok(());
            }

            let resumed_call_info = thread.current_call_info();
            closure = resumed_call_info.function_closure();
            proto = closure.proto().unwrap_unchecked();
            pc = resumed_call_info.saved_pc();
            base = thread.stack_base();
            constants = proto.constants();
            proto.assert_vm_pc(pc);
        }

        'vm: loop {
            debug_assert!(base == thread.stack_base());
            debug_assert!(base <= thread.stack_top());
            debug_assert!(thread.stack_top() <= thread.stack_last());

            let insn_pc = pc;
            let instruction = { *insn_pc };
            let opcode = decode_instruction_opcode(instruction);
            if SINGLE_STEP
                && let Some(hook) = global.debug_step_callback()
                && !v_skip_step(opcode)
            {
                thread.set_vm_saved_pc(insn_pc);
                thread.call_hook(hook, ptr::null_mut())?;

                base = thread.stack_base();
            }

            pc = insn_pc.add(1);

            let mut dispatch_opcode = opcode;

            'dispatch: loop {
                match dispatch_opcode {
                    Opcode::Nop => {
                        debug_assert_eq!(instruction.word(), 0);
                    }
                    Opcode::Break => {
                        let debug_insn = { proto.as_ptr().as_ref().unwrap_unchecked().debug_insn };
                        debug_assert!(!debug_insn.is_null());

                        let debug_pc = {
                            insn_pc.offset_from(proto.as_ptr().as_ref().unwrap_unchecked().code)
                                as usize
                        };
                        let original_opcode = { *debug_insn.add(debug_pc) };
                        debug_assert_ne!(original_opcode, Opcode::Break as u8);

                        if let Some(hook) = global.debug_break_callback() {
                            thread.set_vm_saved_pc(insn_pc);
                            thread.call_hook(hook, ptr::null_mut())?;

                            base = thread.stack_base();
                        }

                        dispatch_opcode = decode_opcode_byte(original_opcode);
                        continue 'dispatch;
                    }
                    Opcode::LoadNil => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        ra.set_nil();
                    }
                    Opcode::LoadB => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        ra.set_boolean(i32::from(instruction.b()));

                        pc = pc.add(instruction.c() as usize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::LoadN => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        ra.set_number(f64::from(instruction.d()));
                    }
                    Opcode::LoadK => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.d() as u16 as usize);
                        ra.set_obj(kv);
                    }
                    Opcode::Move => {
                        let top = thread.stack_top();
                        let ra = base
                            .vm_reg_cursor(top, instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(top, instruction.b() as usize)
                            .value_unchecked();
                        ra.set_obj(rb);
                    }
                    Opcode::GetGlobal => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);
                        let kv = proto.vm_const(constants, aux.word() as usize);
                        debug_assert!(kv.is_string());

                        let env = closure.env();
                        let slot = instruction.c() as usize & env.node_mask_8();
                        let node = env.node(slot as i32);

                        if node.has_string_key(kv.string_value()) && !node.value_is_nil() {
                            ra.set_obj(node.value_unchecked());
                        } else {
                            let mut global_storage = RAW_TVALUE_NIL;
                            let global = TValue::from_mut(&mut global_storage);
                            global.set_table_value(env);
                            thread.set_cached_slot(slot as i32);
                            thread.set_vm_saved_pc(pc);
                            thread.get_table_internal(global, kv, ra_cursor)?;
                            let cached_slot = thread.cached_slot();
                            patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                            base = thread.stack_base();
                        }
                    }
                    Opcode::SetGlobal => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);
                        let kv = proto.vm_const(constants, aux.word() as usize);
                        debug_assert!(kv.is_string());

                        let env = closure.env();
                        let slot = instruction.c() as usize & env.node_mask_8();
                        let node = env.node(slot as i32);

                        if node.has_string_key(kv.string_value()) && !node.value_is_nil() && {
                            env.as_ptr().as_ref().unwrap_unchecked().readonly == 0
                        } {
                            node.value_unchecked().set_obj(ra);
                            if ra.is_collectable() {
                                let table_object: GcObject = env.into();
                                let child = ra.gc_value();
                                if table_object.is_black() && child.is_white() {
                                    thread.barrier_table(env, child);
                                }
                            }
                        } else {
                            let mut global_storage = RAW_TVALUE_NIL;
                            let global = TValue::from_mut(&mut global_storage);
                            global.set_table_value(env);
                            thread.set_cached_slot(slot as i32);
                            thread.set_vm_saved_pc(pc);
                            thread.set_table_internal(global, kv, ra)?;
                            let cached_slot = thread.cached_slot();
                            patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                            base = thread.stack_base();
                        }
                    }
                    Opcode::NewClosure => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let child_proto_index = instruction.d() as u16 as usize;
                        debug_assert!(
                            child_proto_index
                                < proto.as_ptr().as_ref().unwrap_unchecked().size_p as usize
                        );
                        let child_proto = proto.child_proto(child_proto_index).unwrap_unchecked();

                        thread.set_vm_saved_pc(pc);

                        let env = Some(closure.env());
                        let new_closure = thread.new_lua_closure(
                            i32::from(child_proto.as_ptr().as_ref().unwrap_unchecked().n_ups),
                            env,
                            child_proto,
                        )?;
                        ra.set_closure_value(new_closure);

                        for upvalue_index in
                            0..child_proto.as_ptr().as_ref().unwrap_unchecked().n_ups as usize
                        {
                            let capture_instruction = { *pc };
                            pc = pc.add(1);
                            debug_assert_eq!(capture_instruction.opcode(), Opcode::Capture);

                            match capture_instruction.a() {
                                LCT_VAL => {
                                    let captured = base
                                        .vm_reg_cursor(
                                            thread.stack_top(),
                                            capture_instruction.b() as usize,
                                        )
                                        .value_unchecked();
                                    new_closure.lua_upvalue_ref(upvalue_index).set_obj(captured);
                                }
                                LCT_REF => {
                                    let captured = base
                                        .vm_reg_cursor(
                                            thread.stack_top(),
                                            capture_instruction.b() as usize,
                                        )
                                        .value_unchecked();
                                    let upvalue = thread.find_upvalue(captured)?;
                                    new_closure
                                        .lua_upvalue_ref(upvalue_index)
                                        .set_upvalue_value(upvalue);
                                }
                                LCT_UPVAL => {
                                    let captured =
                                        closure.lua_upvalue_ref(capture_instruction.b() as usize);
                                    new_closure.lua_upvalue_ref(upvalue_index).set_obj(captured);
                                }
                                _ => unreachable!("unknown upvalue capture type"),
                            }
                        }

                        thread.set_vm_saved_pc(pc);
                        thread.check_gc()?;
                        base = thread.stack_base();
                    }
                    Opcode::DupClosure => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.d() as u16 as usize);
                        let constant_closure = { kv.closure_value() };

                        thread.set_vm_saved_pc(pc);

                        let env = closure.env();
                        let mut new_closure = if constant_closure.env() == env {
                            constant_closure
                        } else {
                            let constant_proto = { constant_closure.proto().unwrap_unchecked() };
                            thread.new_lua_closure(
                                i32::from(
                                    constant_closure
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .n_upvalues,
                                ),
                                Some(env),
                                constant_proto,
                            )?
                        };
                        ra.set_closure_value(new_closure);

                        let upvalue_count = {
                            constant_closure
                                .as_ptr()
                                .as_ref()
                                .unwrap_unchecked()
                                .n_upvalues as usize
                        };
                        let mut upvalue_index = 0usize;
                        while upvalue_index < upvalue_count {
                            let capture_instruction = { *pc.add(upvalue_index) };
                            debug_assert_eq!(capture_instruction.opcode(), Opcode::Capture);

                            debug_assert!(matches!(capture_instruction.a(), LCT_VAL | LCT_UPVAL));

                            let captured = match capture_instruction.a() {
                                LCT_VAL => base
                                    .vm_reg_cursor(
                                        thread.stack_top(),
                                        capture_instruction.b() as usize,
                                    )
                                    .value_unchecked(),
                                LCT_UPVAL => {
                                    closure.lua_upvalue_ref(capture_instruction.b() as usize)
                                }
                                _ => unreachable!("DUPCLOSURE capture stream must not contain REF"),
                            };

                            let target = new_closure.lua_upvalue_ref(upvalue_index);

                            if new_closure == constant_closure && target.raw_equal(captured) {
                                upvalue_index += 1;
                                continue;
                            }

                            if new_closure == constant_closure
                                && constant_closure
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .preload
                                    == 0
                            {
                                let constant_proto = constant_closure.proto().unwrap_unchecked();
                                new_closure = thread.new_lua_closure(
                                    i32::from(
                                        constant_closure
                                            .as_ptr()
                                            .as_ref()
                                            .unwrap_unchecked()
                                            .n_upvalues,
                                    ),
                                    Some(env),
                                    constant_proto,
                                )?;
                                {
                                    ra.set_closure_value(new_closure);
                                }

                                upvalue_index = 0;
                                continue;
                            }

                            target.set_obj(captured);

                            if captured.is_collectable() {
                                let object: GcObject = new_closure.into();
                                let child = captured.gc_value();
                                if object.is_black() && child.is_white() {
                                    thread.barrier_forward(object, child);
                                }
                            }

                            upvalue_index += 1;
                        }

                        {
                            new_closure.as_ptr().as_mut().unwrap_unchecked().preload = 0;
                        }

                        if constant_closure != new_closure {
                            thread.set_vm_saved_pc(pc);
                            thread.check_gc()?;
                            base = thread.stack_base();
                        }
                        pc = pc.add(upvalue_count);
                    }
                    Opcode::And => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();
                        let value = if rb.is_false() { rb } else { rc };

                        ra.set_obj(value);
                    }
                    Opcode::Or => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();
                        let value = if rb.is_false() { rc } else { rb };

                        ra.set_obj(value);
                    }
                    Opcode::AndK => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);
                        let value = if rb.is_false() { rb } else { kv };

                        ra.set_obj(value);
                    }
                    Opcode::OrK => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);
                        let value = if rb.is_false() { kv } else { rb };

                        ra.set_obj(value);
                    }
                    Opcode::Not => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();

                        {
                            ra.set_boolean(i32::from(rb.is_false()));
                        }
                    }
                    Opcode::Add => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(rb.number_value() + rc.number_value());
                            }
                        } else if rb.is_vector() && rc.is_vector() {
                            let bx = { rb.vector_ptr() };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx + *cx,
                                    *bx.add(1) + *cx.add(1),
                                    *bx.add(2) + *cx.add(2),
                                    vector_w_ptr(bx) + vector_w_ptr(cx),
                                );
                            }
                        } else {
                            let function = thread.tm_by_obj_or_nil(rb, TmEvent::Add);
                            if { rb.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(rc);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::Add)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::Sub => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(rb.number_value() - rc.number_value());
                            }
                        } else if rb.is_vector() && rc.is_vector() {
                            let bx = { rb.vector_ptr() };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx - *cx,
                                    *bx.add(1) - *cx.add(1),
                                    *bx.add(2) - *cx.add(2),
                                    vector_w_ptr(bx) - vector_w_ptr(cx),
                                );
                            }
                        } else {
                            let function = thread.tm_by_obj_or_nil(rb, TmEvent::Sub);
                            if { rb.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(rc);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::Sub)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::Mul => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(rb.number_value() * rc.number_value());
                            }
                        } else if rb.is_vector() && rc.is_number() {
                            let right = { rc.number_value() as f32 };
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx * right,
                                    *bx.add(1) * right,
                                    *bx.add(2) * right,
                                    vector_w_ptr(bx) * right,
                                );
                            }
                        } else if rb.is_vector() && rc.is_vector() {
                            let bx = { rb.vector_ptr() };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx * *cx,
                                    *bx.add(1) * *cx.add(1),
                                    *bx.add(2) * *cx.add(2),
                                    vector_w_ptr(bx) * vector_w_ptr(cx),
                                );
                            }
                        } else if rb.is_number() && rc.is_vector() {
                            let left = { rb.number_value() as f32 };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    left * *cx,
                                    left * *cx.add(1),
                                    left * *cx.add(2),
                                    left * vector_w_ptr(cx),
                                );
                            }
                        } else {
                            let tm_operand = if rb.is_number() { rc } else { rb };
                            let function = thread.tm_by_obj_or_nil(tm_operand, TmEvent::Mul);
                            if { tm_operand.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(rc);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::Mul)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::Div => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(rb.number_value() / rc.number_value());
                            }
                        } else if rb.is_vector() && rc.is_number() {
                            let right = { rc.number_value() as f32 };
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx / right,
                                    *bx.add(1) / right,
                                    *bx.add(2) / right,
                                    vector_w_ptr(bx) / right,
                                );
                            }
                        } else if rb.is_vector() && rc.is_vector() {
                            let bx = { rb.vector_ptr() };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx / *cx,
                                    *bx.add(1) / *cx.add(1),
                                    *bx.add(2) / *cx.add(2),
                                    vector_w_ptr(bx) / vector_w_ptr(cx),
                                );
                            }
                        } else if rb.is_number() && rc.is_vector() {
                            let left = { rb.number_value() as f32 };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    left / *cx,
                                    left / *cx.add(1),
                                    left / *cx.add(2),
                                    left / vector_w_ptr(cx),
                                );
                            }
                        } else {
                            let tm_operand = if rb.is_number() { rc } else { rb };
                            let function = thread.tm_by_obj_or_nil(tm_operand, TmEvent::Div);
                            if { tm_operand.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(rc);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::Div)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::IDiv => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(crate::number::num_idiv(
                                    rb.number_value(),
                                    rc.number_value(),
                                ));
                            }
                        } else if rb.is_vector() && rc.is_number() {
                            let right = { rc.number_value() as f32 };
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(
                                    crate::number::num_idiv((*bx) as f64, right as f64) as f32,
                                    crate::number::num_idiv((*bx.add(1)) as f64, right as f64)
                                        as f32,
                                    crate::number::num_idiv((*bx.add(2)) as f64, right as f64)
                                        as f32,
                                    crate::number::num_idiv(vector_w_ptr(bx) as f64, right as f64)
                                        as f32,
                                );
                            }
                        } else {
                            let tm_operand = if rb.is_number() { rc } else { rb };
                            let function = thread.tm_by_obj_or_nil(tm_operand, TmEvent::IDiv);
                            if { tm_operand.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(rc);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::IDiv)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::Mod => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(crate::number::num_mod(
                                    rb.number_value(),
                                    rc.number_value(),
                                ));
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::Mod)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::Pow => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_number() && rc.is_number() {
                            {
                                ra.set_number(rb.number_value().powf(rc.number_value()));
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, rb, rc, TmEvent::Pow)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::AddK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            {
                                ra.set_number(rb.number_value() + kv.number_value());
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::Add)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::SubK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            {
                                ra.set_number(rb.number_value() - kv.number_value());
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::Sub)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::MulK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            {
                                ra.set_number(rb.number_value() * kv.number_value());
                            }
                        } else if rb.is_vector() {
                            let right = { kv.number_value() as f32 };
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx * right,
                                    *bx.add(1) * right,
                                    *bx.add(2) * right,
                                    vector_w_ptr(bx) * right,
                                );
                            }
                        } else {
                            let function = thread.tm_by_obj_or_nil(rb, TmEvent::Mul);
                            if { rb.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(kv);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::Mul)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::DivK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            {
                                ra.set_number(rb.number_value() / kv.number_value());
                            }
                        } else if rb.is_vector() {
                            let right = { kv.number_value() as f32 };
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(
                                    *bx / right,
                                    *bx.add(1) / right,
                                    *bx.add(2) / right,
                                    vector_w_ptr(bx) / right,
                                );
                            }
                        } else {
                            let function = thread.tm_by_obj_or_nil(rb, TmEvent::Div);
                            if { rb.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(kv);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::Div)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::IDivK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            {
                                ra.set_number(crate::number::num_idiv(
                                    rb.number_value(),
                                    kv.number_value(),
                                ));
                            }
                        } else if rb.is_vector() {
                            let right = { kv.number_value() as f32 };
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(
                                    crate::number::num_idiv((*bx) as f64, right as f64) as f32,
                                    crate::number::num_idiv((*bx.add(1)) as f64, right as f64)
                                        as f32,
                                    crate::number::num_idiv((*bx.add(2)) as f64, right as f64)
                                        as f32,
                                    crate::number::num_idiv(vector_w_ptr(bx) as f64, right as f64)
                                        as f32,
                                );
                            }
                        } else {
                            let function = thread.tm_by_obj_or_nil(rb, TmEvent::IDiv);
                            if { rb.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(kv);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(2, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::IDiv)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::ModK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            {
                                ra.set_number(crate::number::num_mod(
                                    rb.number_value(),
                                    kv.number_value(),
                                ));
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::Mod)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::PowK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.c() as usize);

                        if rb.is_number() {
                            let left = { rb.number_value() };
                            let right = { kv.number_value() };
                            let result = if right == 2.0 {
                                left * left
                            } else if right == 0.5 {
                                left.sqrt()
                            } else if right == 3.0 {
                                left * left * left
                            } else {
                                left.powf(right)
                            };

                            {
                                ra.set_number(result);
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, rb, kv, TmEvent::Pow)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::Concat => {
                        let b = instruction.b() as i32;
                        let c = instruction.c() as i32;

                        thread.set_vm_saved_pc(pc);
                        thread.concat_internal(c - b + 1, c)?;
                        base = thread.stack_base();

                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        ra.set_obj(base.add(b as usize).value_unchecked());

                        thread.set_vm_saved_pc(pc);
                        thread.check_gc()?;
                        base = thread.stack_base();
                    }
                    Opcode::Minus => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();

                        if rb.is_number() {
                            {
                                ra.set_number(-rb.number_value());
                            }
                        } else if rb.is_vector() {
                            let bx = { rb.vector_ptr() };
                            {
                                ra.set_vector4(-*bx, -*bx.add(1), -*bx.add(2), -vector_w_ptr(bx));
                            }
                        } else {
                            let function = thread.tm_by_obj_or_nil(rb, TmEvent::Unm);
                            if { rb.is_userdata() } && {
                                function.is_function() && function.is_native_function()
                            } {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(2)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    thread.set_stack_top(top_cursor.add(2));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(1, i32::from(instruction.a()))?;
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_arith_impl(ra_cursor, rb, rb, TmEvent::Unm)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::Length => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();

                        if rb.is_table() {
                            let table = { rb.table_value() };
                            if thread.fast_notm(table.metatable(), TmEvent::Len) {
                                {
                                    ra.set_number(table.getn() as f64);
                                }
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.do_len(ra_cursor, rb)?;
                                base = thread.stack_base();
                            }
                        } else if rb.is_string() {
                            {
                                ra.set_number(
                                    rb.string_value().as_ptr().as_ref().unwrap_unchecked().len
                                        as f64,
                                );
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_len(ra_cursor, rb)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::NewTable => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let b = instruction.b();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);

                        thread.set_vm_saved_pc(pc);
                        let table = thread.new_table_internal(
                            aux.word() as i32,
                            if b == 0 {
                                0
                            } else {
                                1i32 << (i32::from(b) - 1)
                            },
                        )?;
                        {
                            ra.set_table_value(table);
                        }
                        thread.check_gc()?;
                        base = thread.stack_base();
                    }
                    Opcode::DupTable => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, instruction.d() as u16 as usize);
                        debug_assert!({ kv.is_table() });

                        thread.set_vm_saved_pc(pc);
                        let table = thread.clone_table_internal(kv.table_value())?;
                        {
                            ra.set_table_value(table);
                        }
                        thread.check_gc()?;
                        base = thread.stack_base();
                    }
                    Opcode::SetList => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = { base.add(instruction.b() as usize) };
                        let mut c = i32::from(instruction.c()) - 1;
                        let index = { InstructionAux::new((*pc).word()).word() as i32 };
                        pc = pc.add(1);

                        if c == LUA_MULTRET {
                            c = thread.stack_top().offset_from(rb) as i32;
                            {
                                thread.set_stack_top(thread.current_call_info().top());
                            }
                        }

                        if !ra.is_table() {
                            return Ok(());
                        }

                        let table = { ra.table_value() };
                        let last = index + c - 1;
                        if last > { table.as_ptr().as_ref().unwrap_unchecked().size_array } {
                            thread.set_vm_saved_pc(pc);
                            thread.resize_array(table, last)?;
                            base = thread.stack_base();
                        }

                        let array = table.array_cursor();
                        let index = index as usize - 1;
                        for offset in 0..c as usize {
                            array
                                .add(index + offset)
                                .value_unchecked()
                                .set_obj(rb.add(offset).value_unchecked());
                        }

                        let table_object: GcObject = table.into();
                        if table_object.is_black() {
                            let table_ref = table.as_ptr().as_mut().unwrap_unchecked();
                            thread.barrier_back(table_object, &raw mut table_ref.gc_list);
                        }
                    }
                    Opcode::SubRK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let kv = proto.vm_const(constants, instruction.b() as usize);
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rc.is_number() {
                            {
                                ra.set_number(kv.number_value() - rc.number_value());
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, kv, rc, TmEvent::Sub)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::DivRK => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let kv = proto.vm_const(constants, instruction.b() as usize);
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rc.is_number() {
                            {
                                ra.set_number(kv.number_value() / rc.number_value());
                            }
                        } else if rc.is_vector() {
                            let left = { kv.number_value() as f32 };
                            let cx = { rc.vector_ptr() };
                            {
                                ra.set_vector4(
                                    left / *cx,
                                    left / *cx.add(1),
                                    left / *cx.add(2),
                                    left / vector_w_ptr(cx),
                                );
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.do_arith_impl(ra_cursor, kv, rc, TmEvent::Div)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::GetUpval => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let upref = closure.lua_upvalue_ref(instruction.b() as usize);
                        let value = if upref.is_upvalue() {
                            upref.upvalue_value().value()
                        } else {
                            upref
                        };

                        ra.set_obj(value);
                    }
                    Opcode::SetUpval => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let upref = closure.lua_upvalue_ref(instruction.b() as usize);
                        debug_assert!(upref.is_upvalue());
                        let upval = upref.upvalue_value();

                        upval.value().set_obj(ra);

                        let value = { ra };
                        if value.is_collectable() {
                            let object: GcObject = upval.into();
                            let child = value.gc_value();
                            if object.is_black() && child.is_white() {
                                thread.barrier_forward(object, child);
                            }
                        }
                    }
                    Opcode::CloseUpvals => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        if let Some(open_upval) = thread.open_upvalue()
                            && { open_upval.value_ptr() >= ra.as_ptr() }
                        {
                            thread.close(ra);
                        }
                    }
                    Opcode::ForNPrep => {
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let limit = ra;
                        let step = { ra.add(1) };
                        let index = { ra.add(2) };

                        let non_numeric = {
                            !limit.value_unchecked().is_number()
                                || !step.value_unchecked().is_number()
                                || !index.value_unchecked().is_number()
                        };
                        if non_numeric {
                            thread.set_vm_saved_pc(pc);
                            thread.prepare_forn(limit, step, index)?;
                        }

                        let limit_value = { limit.value_unchecked().number_value() };
                        let step_value = { step.value_unchecked().number_value() };
                        let index_value = { index.value_unchecked().number_value() };

                        if !(if step_value > 0.0 {
                            index_value <= limit_value
                        } else {
                            limit_value <= index_value
                        }) {
                            pc = pc.offset(i32::from(instruction.d()) as isize);
                        }
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::ForNLoop => {
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();
                        if flags::LuauBackedgeHeapCheck.get() && thread.needs_gc() {
                            thread.set_vm_saved_pc(pc);
                            thread.step(true)?;
                            base = thread.stack_base();
                        }

                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let limit = ra;
                        let step = { ra.add(1) };
                        let index = { ra.add(2) };
                        debug_assert!(
                            limit.value_unchecked().is_number()
                                && step.value_unchecked().is_number()
                                && index.value_unchecked().is_number()
                        );

                        let limit_value = { limit.value_unchecked().number_value() };
                        let step_value = { step.value_unchecked().number_value() };
                        let next_index = { index.value_unchecked().number_value() } + step_value;

                        index.value_unchecked().set_number(next_index);

                        if if step_value > 0.0 {
                            next_index <= limit_value
                        } else {
                            limit_value <= next_index
                        } {
                            pc = pc.offset(i32::from(instruction.d()) as isize);
                            proto.assert_vm_pc(pc);
                        }
                    }
                    Opcode::ForGPrep => {
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();

                        if !{ ra_value.is_function() } {
                            let metatable = if ra_value.is_table() {
                                ra_value.table_value().metatable()
                            } else if ra_value.is_userdata() {
                                ra_value.userdata_value().metatable()
                            } else {
                                None
                            };

                            let iter = if flags::DebugLuauUserDefinedClassesRuntime.get() {
                                if let Some(function) = thread.fast_tm(metatable, TmEvent::Iter) {
                                    Some(function)
                                } else if ra_value.is_object() {
                                    let function = thread.tm_by_obj_or_nil(ra_value, TmEvent::Iter);
                                    if function.is_nil() {
                                        thread.set_vm_saved_pc(pc);
                                        return thread
                                            .type_error(ra_value, "iterate over")
                                            .map_err(Into::into);
                                    }
                                    Some(function)
                                } else if thread.fast_tm(metatable, TmEvent::Call).is_some() {
                                    None
                                } else if ra_value.is_table() {
                                    ra.add(1).value_unchecked().set_obj(ra_value);
                                    ra.add(2).value_unchecked().set_light_userdata(
                                        ptr::null_mut(),
                                        USERDATA_TAG_LIMIT as i32,
                                    );
                                    ra_value.set_nil();
                                    None
                                } else {
                                    thread.set_vm_saved_pc(pc);
                                    return thread
                                        .type_error(ra_value, "iterate over")
                                        .map_err(Into::into);
                                }
                            } else if let Some(function) = thread.fast_tm(metatable, TmEvent::Iter)
                            {
                                Some(function)
                            } else if thread.fast_tm(metatable, TmEvent::Call).is_some() {
                                None
                            } else if ra_value.is_table() {
                                ra.add(1).value_unchecked().set_obj(ra_value);
                                ra.add(2)
                                    .value_unchecked()
                                    .set_light_userdata(ptr::null_mut(), USERDATA_TAG_LIMIT as i32);
                                ra_value.set_nil();
                                None
                            } else {
                                thread.set_vm_saved_pc(pc);
                                return thread
                                    .type_error(ra_value, "iterate over")
                                    .map_err(Into::into);
                            };

                            if let Some(function) = iter {
                                ra.add(1).value_unchecked().set_obj(ra_value);
                                ra_value.set_obj(function);
                                thread.set_stack_top(ra.add(2));
                                debug_assert!({
                                    thread.stack_top()
                                        <= thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });

                                thread.set_vm_saved_pc(pc);
                                thread.call_no_yield(ra, 3)?;
                                {
                                    thread.set_stack_top(thread.current_call_info().top());
                                }

                                base = thread.stack_base();
                                let ra = base
                                    .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                                    .value_unchecked();
                                if ra.is_nil() {
                                    thread.set_vm_saved_pc(pc);
                                    return thread.type_error(ra, "call").map_err(Into::into);
                                }
                            }
                        }

                        pc = insn_pc.add(1).offset(i32::from(instruction.d()) as isize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::ForGLoop => {
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();
                        if flags::LuauBackedgeHeapCheck.get() && thread.needs_gc() {
                            thread.set_vm_saved_pc(pc);
                            thread.step(true)?;
                            base = thread.stack_base();
                        }

                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let aux_pc = { insn_pc.add(1) };
                        let aux = { (*aux_pc).word() };

                        if ra_value.is_nil() && ra.add(1).value_unchecked().is_table() {
                            let table = { ra.add(1).value_unchecked().table_value() };
                            let mut index =
                                { ra.add(2).value_unchecked().pointer_value() as usize as i32 };
                            let size_array =
                                { table.as_ptr().as_ref().unwrap_unchecked().size_array };
                            let aux_signed = aux as i32;
                            if aux_signed > 2 {
                                for offset in 2..aux_signed as usize {
                                    ra.add(3 + offset).value_unchecked().set_nil();
                                }
                            }

                            if aux_signed < 0
                                && ((index as u32) >= size_array as u32 || {
                                    table.array_slot(index as usize).is_nil()
                                })
                            {
                                pc = aux_pc.add(1);
                                proto.assert_vm_pc(pc);
                                continue 'vm;
                            }

                            while (index as u32) < size_array as u32 {
                                let value = table.array_slot(index as usize);
                                if !value.is_nil() {
                                    ra.add(2).value_unchecked().set_light_userdata(
                                        (index as usize + 1) as *mut (),
                                        USERDATA_TAG_LIMIT as i32,
                                    );
                                    ra.add(3).value_unchecked().set_number((index + 1) as f64);
                                    ra.add(4).value_unchecked().set_obj(value);

                                    pc = aux_pc.offset(i32::from(instruction.d()) as isize);
                                    proto.assert_vm_pc(pc);
                                    break 'dispatch;
                                }

                                index += 1;
                            }

                            let size_node = { table.node_count() as i32 };
                            while ((index - size_array) as u32) < size_node as u32 {
                                let node = table.node(index - size_array);
                                if !node.value_unchecked().is_nil() {
                                    ra.add(2).value_unchecked().set_light_userdata(
                                        (index as usize + 1) as *mut (),
                                        USERDATA_TAG_LIMIT as i32,
                                    );
                                    node.write_key_to_value(ra.add(3).value_unchecked());
                                    ra.add(4).value_unchecked().set_obj(node.value_unchecked());

                                    pc = aux_pc.offset(i32::from(instruction.d()) as isize);
                                    proto.assert_vm_pc(pc);
                                    break 'dispatch;
                                }

                                index += 1;
                            }

                            pc = aux_pc.add(1);
                            proto.assert_vm_pc(pc);
                            break 'dispatch;
                        }

                        ra.add(5)
                            .value_unchecked()
                            .set_obj(ra.add(2).value_unchecked());
                        ra.add(4)
                            .value_unchecked()
                            .set_obj(ra.add(1).value_unchecked());
                        ra.add(3).value_unchecked().set_obj(ra_value);
                        thread.set_stack_top(ra.add(6));
                        debug_assert!(
                            thread.stack_top()
                                <= thread.stack().add(
                                    thread.as_ptr().as_ref().unwrap_unchecked().stack_size as usize
                                )
                        );

                        thread.set_vm_saved_pc(aux_pc);
                        if flags::LuauYieldIter2.get() {
                            thread.perform_cally(ra.add(3), i32::from(aux as u8))?;
                        } else {
                            thread.call_no_yield(ra.add(3), i32::from(aux as u8))?;
                        }
                        thread.set_stack_top(thread.current_call_info().top());

                        base = thread.stack_base();
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        ra.add(2)
                            .value_unchecked()
                            .set_obj(ra.add(3).value_unchecked());

                        pc = if ra.add(3).value_unchecked().is_nil() {
                            aux_pc.add(1)
                        } else {
                            aux_pc.offset(i32::from(instruction.d()) as isize)
                        };
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::ForGPrepInext => {
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let env = closure.env();

                        if { env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 }
                            && { ra.add(1).value_unchecked().is_table() }
                            && { ra.add(2).value_unchecked().is_number() }
                            && { ra.add(2).value_unchecked().number_value() == 0.0 }
                        {
                            {
                                ra_value.set_nil();
                                ra.add(2)
                                    .value_unchecked()
                                    .set_light_userdata(ptr::null_mut(), USERDATA_TAG_LIMIT as i32);
                            }
                        } else if !ra_value.is_function() {
                            thread.set_vm_saved_pc(pc);
                            return thread
                                .type_error(ra_value, "iterate over")
                                .map_err(Into::into);
                        }

                        pc = insn_pc.add(1).offset(i32::from(instruction.d()) as isize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::ForGPrepNext => {
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let env = closure.env();

                        if { env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 }
                            && { ra.add(1).value_unchecked().is_table() }
                            && { ra.add(2).value_unchecked().is_nil() }
                        {
                            {
                                ra_value.set_nil();
                                ra.add(2)
                                    .value_unchecked()
                                    .set_light_userdata(ptr::null_mut(), USERDATA_TAG_LIMIT as i32);
                            }
                        } else if !ra_value.is_function() {
                            thread.set_vm_saved_pc(pc);
                            return thread
                                .type_error(ra_value, "iterate over")
                                .map_err(Into::into);
                        }

                        pc = insn_pc.add(1).offset(i32::from(instruction.d()) as isize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::GetVarargs => {
                        let b = i32::from(instruction.b()) - 1;
                        let n = { base.offset_from(thread.current_call_info().function()) } as i32
                            - i32::from(proto.as_ptr().as_ref().unwrap_unchecked().num_params)
                            - 1;

                        if b == LUA_MULTRET {
                            thread.set_vm_saved_pc(pc);
                            thread.check_stack_internal(n)?;
                            base = thread.stack_base();

                            let ra =
                                base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                            let varargs = { base.sub(n as usize) };

                            for index in 0..n {
                                ra.add(index as usize)
                                    .value_unchecked()
                                    .set_obj(varargs.add(index as usize).value_unchecked());
                            }

                            thread.set_stack_top(ra.add(n as usize));
                        } else {
                            let ra =
                                base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                            let varargs = { base.sub(n.max(0) as usize) };

                            for index in 0..b.min(n) {
                                ra.add(index as usize)
                                    .value_unchecked()
                                    .set_obj(varargs.add(index as usize).value_unchecked());
                            }
                            for index in n.max(0)..b {
                                ra.add(index as usize).value_unchecked().set_nil();
                            }
                        }
                    }
                    Opcode::PrepVarargs => {
                        let num_params = instruction.a() as usize;
                        thread.set_vm_saved_pc(pc);
                        thread.check_stack_internal(
                            i32::from(closure.as_ptr().as_ref().unwrap_unchecked().stack_size)
                                + num_params as i32,
                        )?;

                        base = thread.stack_base();
                        debug_assert!(thread.stack_top().offset_from(base) as usize >= num_params);

                        let fixed = base;
                        base = thread.stack_top();

                        for index in 0..num_params {
                            base.add(index)
                                .value_unchecked()
                                .set_obj(fixed.add(index).value_unchecked());
                            fixed.add(index).value_unchecked().set_nil();
                        }

                        let current_call_info = thread.current_call_info();
                        let new_top = base
                            .add(closure.as_ptr().as_ref().unwrap_unchecked().stack_size as usize);
                        current_call_info.set_base(base);
                        current_call_info.set_top(new_top);
                        thread.set_stack_base(base);
                        thread.set_stack_top(new_top);
                    }
                    Opcode::NativeCall => {
                        debug_assert!(!{
                            proto
                                .as_ptr()
                                .as_ref()
                                .unwrap_unchecked()
                                .exec_data
                                .is_null()
                        });

                        {
                            let current_call_info = thread.current_call_info();
                            current_call_info.as_ptr().as_mut().unwrap_unchecked().flags =
                                LUA_CALLINFO_NATIVE;
                            current_call_info.set_saved_pc(
                                proto.as_ptr().as_ref().unwrap_unchecked().code.cast_const(),
                            );
                        }

                        let Some(enter) = global.execution_enter() else {
                            unreachable!("native lvmexecute requires an execution enter callback");
                        };

                        if { enter(thread, proto) } == 0 {
                            return Ok(());
                        }

                        let call_info = thread.current_call_info();
                        closure = call_info.function_closure();
                        proto = closure.proto().unwrap_unchecked();
                        pc = call_info.saved_pc();
                        base = thread.stack_base();
                        constants = proto.constants();
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::Jump => {
                        pc = pc.offset(i32::from(instruction.d()) as isize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpBack => {
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();
                        if flags::LuauBackedgeHeapCheck.get() && thread.needs_gc() {
                            thread.set_vm_saved_pc(pc);
                            thread.step(true)?;
                            base = thread.stack_base();
                        }

                        pc = pc.offset(i32::from(instruction.d()) as isize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIf => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        if !{ ra.is_false() } {
                            pc = pc.offset(i32::from(instruction.d()) as isize);
                        }
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfNot => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        if ra.is_false() {
                            pc = pc.offset(i32::from(instruction.d()) as isize);
                        }
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfEq => {
                        let aux = { (*pc).word() };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), aux as usize)
                            .value_unchecked();

                        if ra.tt() == rb.tt() {
                            match ra.tt() {
                                x if x == LUA_TNIL => {
                                    pc = pc.offset(i32::from(instruction.d()) as isize);
                                }
                                x if x == LUA_TBOOLEAN => {
                                    pc = if ra.boolean_value() == rb.boolean_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TLIGHTUSERDATA => {
                                    pc = if ra.pointer_value() == rb.pointer_value()
                                        && ra.light_userdata_tag() == rb.light_userdata_tag()
                                    {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TNUMBER => {
                                    pc = if ra.number_value() == rb.number_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TVECTOR => {
                                    pc = if ra.vector_eq(rb) {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                LUA_TSTRING | LUA_TFUNCTION | LUA_TTHREAD | LUA_TBUFFER => {
                                    pc = if ra.gc_value() == rb.gc_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TTABLE => {
                                    let left = { ra.table_value() };
                                    let right = { rb.table_value() };

                                    if left.metatable() == right.metatable() {
                                        let function =
                                            thread.fast_tm(left.metatable(), TmEvent::Eq);

                                        if function.is_none() {
                                            pc = if left == right {
                                                pc.offset(i32::from(instruction.d()) as isize)
                                            } else {
                                                pc.add(1)
                                            };
                                            proto.assert_vm_pc(pc);
                                            break 'dispatch;
                                        }
                                    }

                                    thread.set_vm_saved_pc(pc);
                                    let result = thread.equal_value(ra, rb)?;

                                    pc = if result == 1 {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                    base = thread.stack_base();
                                }
                                x if x == LUA_TUSERDATA => {
                                    let left = { ra.userdata_value() };
                                    let right = { rb.userdata_value() };

                                    if left.metatable() == right.metatable() {
                                        let function =
                                            thread.fast_tm(left.metatable(), TmEvent::Eq);

                                        if function.is_none() {
                                            pc = if left == right {
                                                pc.offset(i32::from(instruction.d()) as isize)
                                            } else {
                                                pc.add(1)
                                            };
                                            proto.assert_vm_pc(pc);
                                            break 'dispatch;
                                        } else if let Some(function) = function
                                            && {
                                                function.is_function()
                                                    && function.is_native_function()
                                            }
                                        {
                                            let top_cursor = thread.stack_top();
                                            debug_assert!({
                                                top_cursor.add(3)
                                                    < thread.stack().add(
                                                        thread
                                                            .as_ptr()
                                                            .as_ref()
                                                            .unwrap_unchecked()
                                                            .stack_size
                                                            as usize,
                                                    )
                                            });

                                            let result = { top_cursor.offset_from(base) as i32 };
                                            {
                                                top_cursor.value_unchecked().set_obj(function);
                                                top_cursor.add(1).value_unchecked().set_obj(ra);
                                                top_cursor.add(2).value_unchecked().set_obj(rb);
                                                thread.set_stack_top(top_cursor.add(3));
                                            }

                                            thread.set_vm_saved_pc(pc);
                                            thread.call_tm(2, result)?;
                                            base = thread.stack_base();

                                            let result_slot = { base.add(result as usize) };
                                            pc = if !result_slot.value_unchecked().is_false() {
                                                pc.offset(i32::from(instruction.d()) as isize)
                                            } else {
                                                pc.add(1)
                                            };
                                            proto.assert_vm_pc(pc);
                                            break 'dispatch;
                                        }
                                    }

                                    thread.set_vm_saved_pc(pc);
                                    let result = thread.equal_value(ra, rb)?;

                                    pc = if result == 1 {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                    base = thread.stack_base();
                                }
                                x if x == LUA_TCLASS => {
                                    pc = if ra.class_value() == rb.class_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TOBJECT => {
                                    thread.set_vm_saved_pc(pc);
                                    let result = thread.equal_value(ra, rb)?;

                                    pc = if result == 1 {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                    base = thread.stack_base();
                                }
                                x if x == LUA_TINTEGER => {
                                    pc = if ra.integer_value() == rb.integer_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                _ => unreachable!("unknown jump equality type"),
                            }
                        } else {
                            pc = pc.add(1);
                        }

                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfNotEq => {
                        let aux = { (*pc).word() };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), aux as usize)
                            .value_unchecked();

                        if ra.tt() == rb.tt() {
                            match ra.tt() {
                                x if x == LUA_TNIL => {
                                    pc = pc.add(1);
                                }
                                x if x == LUA_TBOOLEAN => {
                                    pc = if ra.boolean_value() != rb.boolean_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TLIGHTUSERDATA => {
                                    pc = if ra.pointer_value() != rb.pointer_value()
                                        || ra.light_userdata_tag() != rb.light_userdata_tag()
                                    {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TNUMBER => {
                                    pc = if ra.number_value() != rb.number_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TVECTOR => {
                                    pc = if !ra.vector_eq(rb) {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                LUA_TSTRING | LUA_TFUNCTION | LUA_TTHREAD | LUA_TBUFFER => {
                                    pc = if ra.gc_value() != rb.gc_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TTABLE => {
                                    let left = { ra.table_value() };
                                    let right = { rb.table_value() };

                                    if left.metatable() == right.metatable() {
                                        let function =
                                            thread.fast_tm(left.metatable(), TmEvent::Eq);

                                        if function.is_none() {
                                            pc = if left != right {
                                                pc.offset(i32::from(instruction.d()) as isize)
                                            } else {
                                                pc.add(1)
                                            };
                                            proto.assert_vm_pc(pc);
                                            break 'dispatch;
                                        }
                                    }

                                    thread.set_vm_saved_pc(pc);
                                    let result = thread.equal_value(ra, rb)?;

                                    pc = if result == 0 {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                    base = thread.stack_base();
                                }
                                x if x == LUA_TUSERDATA => {
                                    let left = { ra.userdata_value() };
                                    let right = { rb.userdata_value() };

                                    if left.metatable() == right.metatable() {
                                        let function =
                                            thread.fast_tm(left.metatable(), TmEvent::Eq);

                                        if function.is_none() {
                                            pc = if left != right {
                                                pc.offset(i32::from(instruction.d()) as isize)
                                            } else {
                                                pc.add(1)
                                            };
                                            proto.assert_vm_pc(pc);
                                            break 'dispatch;
                                        } else if let Some(function) = function
                                            && {
                                                function.is_function()
                                                    && function.is_native_function()
                                            }
                                        {
                                            let top_cursor = thread.stack_top();
                                            debug_assert!({
                                                top_cursor.add(3)
                                                    < thread.stack().add(
                                                        thread
                                                            .as_ptr()
                                                            .as_ref()
                                                            .unwrap_unchecked()
                                                            .stack_size
                                                            as usize,
                                                    )
                                            });

                                            let result = { top_cursor.offset_from(base) as i32 };
                                            {
                                                top_cursor.value_unchecked().set_obj(function);
                                                top_cursor.add(1).value_unchecked().set_obj(ra);
                                                top_cursor.add(2).value_unchecked().set_obj(rb);
                                                thread.set_stack_top(top_cursor.add(3));
                                            }

                                            thread.set_vm_saved_pc(pc);
                                            thread.call_tm(2, result)?;
                                            base = thread.stack_base();

                                            let result_slot = { base.add(result as usize) };
                                            pc = if result_slot.value_unchecked().is_false() {
                                                pc.offset(i32::from(instruction.d()) as isize)
                                            } else {
                                                pc.add(1)
                                            };
                                            proto.assert_vm_pc(pc);
                                            break 'dispatch;
                                        }
                                    }

                                    thread.set_vm_saved_pc(pc);
                                    let result = thread.equal_value(ra, rb)?;

                                    pc = if result == 0 {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                    base = thread.stack_base();
                                }
                                x if x == LUA_TCLASS => {
                                    pc = if ra.class_value() != rb.class_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                x if x == LUA_TOBJECT => {
                                    thread.set_vm_saved_pc(pc);
                                    let result = thread.equal_value(ra, rb)?;

                                    pc = if result == 0 {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                    base = thread.stack_base();
                                }
                                x if x == LUA_TINTEGER => {
                                    pc = if ra.integer_value() != rb.integer_value() {
                                        pc.offset(i32::from(instruction.d()) as isize)
                                    } else {
                                        pc.add(1)
                                    };
                                }
                                _ => unreachable!("unknown jump equality type"),
                            }
                        } else {
                            pc = pc.offset(i32::from(instruction.d()) as isize);
                        }

                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfLe => {
                        let aux = { (*pc).word() };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), aux as usize)
                            .value_unchecked();

                        if ra.is_number() && rb.is_number() {
                            pc = if ra.number_value() <= rb.number_value() {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        } else if ra.is_string() && rb.is_string() {
                            pc = if string_compare(ra.string_value(), rb.string_value()) <= 0 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        } else {
                            thread.set_vm_saved_pc(pc);
                            let result = thread.less_equal(ra, rb)?;
                            pc = if result == 1 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                            base = thread.stack_base();
                        }

                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfNotLe => {
                        let aux = { (*pc).word() };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), aux as usize)
                            .value_unchecked();

                        if ra.is_number() && rb.is_number() {
                            pc = if ra.number_value() <= rb.number_value() {
                                pc.add(1)
                            } else {
                                pc.offset(i32::from(instruction.d()) as isize)
                            };
                        } else if ra.is_string() && rb.is_string() {
                            pc = if string_compare(ra.string_value(), rb.string_value()) > 0 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        } else {
                            thread.set_vm_saved_pc(pc);
                            let result = thread.less_equal(ra, rb)?;
                            pc = if result == 0 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                            base = thread.stack_base();
                        }

                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfLt => {
                        let aux = { (*pc).word() };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), aux as usize)
                            .value_unchecked();

                        if ra.is_number() && rb.is_number() {
                            pc = if ra.number_value() < rb.number_value() {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        } else if ra.is_string() && rb.is_string() {
                            pc = if string_compare(ra.string_value(), rb.string_value()) < 0 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        } else {
                            thread.set_vm_saved_pc(pc);
                            let result = thread.less_than_internal(ra, rb)?;
                            pc = if result == 1 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                            base = thread.stack_base();
                        }

                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpIfNotLt => {
                        let aux = { *pc };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), aux as usize)
                            .value_unchecked();

                        if ra.is_number() && rb.is_number() {
                            pc = if ra.number_value() < rb.number_value() {
                                pc.add(1)
                            } else {
                                pc.offset(i32::from(instruction.d()) as isize)
                            };
                        } else if ra.is_string() && rb.is_string() {
                            pc = if string_compare(ra.string_value(), rb.string_value()) >= 0 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        } else {
                            thread.set_vm_saved_pc(pc);
                            let result = thread.less_than_internal(ra, rb)?;
                            pc = if result == 0 {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                            base = thread.stack_base();
                        }

                        proto.assert_vm_pc(pc);
                    }
                    Opcode::LoadKx => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);
                        let kv = proto.vm_const(constants, aux.word() as usize);
                        {
                            ra.set_obj(kv);
                        }
                    }
                    Opcode::GetImport => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let kv = proto.vm_const(constants, instruction.d() as u16 as usize);
                        let env = closure.env();

                        if { !kv.is_nil() } && {
                            env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0
                        } {
                            {
                                ra.set_obj(kv);
                            }
                            pc = pc.add(1);
                            proto.assert_vm_pc(pc);
                        } else {
                            let aux = { InstructionAux::new((*pc).word()) };
                            pc = pc.add(1);

                            thread.set_vm_saved_pc(pc);
                            thread.get_import(env, constants, ra_cursor, aux.word(), false)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::GetTableKs => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);
                        let kv = proto.vm_const(constants, aux.word() as usize);
                        debug_assert!({ kv.is_string() });
                        let kv_string = { kv.string_value() };

                        if rb.is_table() {
                            let table = { rb.table_value() };
                            let slot = instruction.c() as usize & table.node_mask_8();
                            let node = { table.node(slot as i32) };

                            if node.has_string_key(kv_string) && !node.value_is_nil() {
                                ra.set_obj(node.value_unchecked());
                            } else if table.metatable().is_none() {
                                if let Some(node_cursor) = table.get_str_node(kv_string) {
                                    let cached_slot = { table.node_index(node_cursor) };
                                    patch_instruction_c(
                                        insn_pc as *mut Instruction,
                                        cached_slot as u8,
                                    );
                                    ra.set_obj(node_cursor.node_unchecked().value_unchecked());
                                } else {
                                    ra.set_nil();
                                }
                            } else {
                                thread.set_cached_slot(slot as i32);
                                thread.set_vm_saved_pc(pc);
                                thread.get_table_internal(rb, kv, ra_cursor)?;
                                let cached_slot = thread.cached_slot();
                                patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                                base = thread.stack_base();
                            }
                        } else {
                            let direct_field = flags::LuauDirectFieldGet.get();
                            if direct_field && { rb.is_userdata() } {
                                let userdata = { rb.userdata_value() };
                                if let Some(dispatch) = global.userdata_direct_field(
                                    userdata.as_ptr().as_ref().unwrap_unchecked().tag as usize,
                                ) {
                                    let slot = instruction.c() as usize & dispatch.node_mask_8();
                                    let node = { dispatch.node(slot as i32) };

                                    if node.has_string_key(kv_string) && !node.value_is_nil() {
                                        let function: LuaUserdataDirectFieldGet =
                                            std::mem::transmute(
                                                node.value_unchecked().pointer_value(),
                                            );
                                        let mut result = UserdataDirectFieldResult(ra);
                                        {
                                            function(userdata.data_mut_ptr().cast(), &mut result);
                                        }
                                        break 'dispatch;
                                    }

                                    if let Some(node_cursor) = dispatch.get_str_node(kv_string) {
                                        let cached_slot = dispatch.node_index(node_cursor);
                                        patch_instruction_c(
                                            insn_pc as *mut Instruction,
                                            cached_slot as u8,
                                        );

                                        let function: LuaUserdataDirectFieldGet =
                                            std::mem::transmute(
                                                node_cursor
                                                    .node_unchecked()
                                                    .value_unchecked()
                                                    .pointer_value(),
                                            );
                                        let mut result = UserdataDirectFieldResult(ra);
                                        {
                                            function(userdata.data_mut_ptr().cast(), &mut result);
                                        }
                                        break 'dispatch;
                                    }
                                }
                            }

                            if rb.is_userdata() {
                                let userdata = { rb.userdata_value() };
                                if let Some(function) =
                                    thread.fast_tm(userdata.metatable(), TmEvent::Index)
                                    && { function.is_function() && function.is_native_function() }
                                {
                                    let top_cursor = thread.stack_top();
                                    debug_assert!({
                                        top_cursor.add(3)
                                            < thread.stack().add(
                                                thread
                                                    .as_ptr()
                                                    .as_ref()
                                                    .unwrap_unchecked()
                                                    .stack_size
                                                    as usize,
                                            )
                                    });
                                    {
                                        top_cursor.value_unchecked().set_obj(function);
                                        top_cursor.add(1).value_unchecked().set_obj(rb);
                                        top_cursor.add(2).value_unchecked().set_obj(kv);
                                        thread.set_stack_top(top_cursor.add(3));
                                        thread.set_cached_slot(i32::from(instruction.c()));
                                    }

                                    thread.set_vm_saved_pc(pc);
                                    thread.call_tm(2, i32::from(instruction.a()))?;
                                    let cached_slot = thread.cached_slot();
                                    patch_instruction_c(
                                        insn_pc as *mut Instruction,
                                        cached_slot as u8,
                                    );
                                    base = thread.stack_base();
                                    break 'dispatch;
                                }
                            } else if rb.is_vector() {
                                let name = { kv_string.as_bytes() };
                                if name.len() == 1 {
                                    let component = match name[0] | b' ' {
                                        b'x' => Some(0usize),
                                        b'y' => Some(1usize),
                                        b'z' => Some(2usize),
                                        #[cfg(feature = "vector4")]
                                        b'w' => Some(3usize),
                                        _ => None,
                                    };

                                    if let Some(component) = component
                                        && component < LUA_VECTOR_SIZE
                                    {
                                        let vector = { rb.vector_ptr() };
                                        {
                                            ra.set_number(match component {
                                                0 => *vector,
                                                1 => *vector.add(1),
                                                2 => *vector.add(2),
                                                #[cfg(feature = "vector4")]
                                                3 => vector_w_ptr(vector),
                                                _ => unreachable!(),
                                            }
                                                as f64);
                                        }
                                        break 'dispatch;
                                    }
                                }

                                let vector_metatable = global.metatable(LUA_TVECTOR as usize);
                                if let Some(function) =
                                    thread.fast_tm(vector_metatable, TmEvent::Index)
                                    && { function.is_function() && function.is_native_function() }
                                {
                                    let top_cursor = thread.stack_top();
                                    debug_assert!({
                                        top_cursor.add(3)
                                            < thread.stack().add(
                                                thread
                                                    .as_ptr()
                                                    .as_ref()
                                                    .unwrap_unchecked()
                                                    .stack_size
                                                    as usize,
                                            )
                                    });
                                    {
                                        top_cursor.value_unchecked().set_obj(function);
                                        top_cursor.add(1).value_unchecked().set_obj(rb);
                                        top_cursor.add(2).value_unchecked().set_obj(kv);
                                        thread.set_stack_top(top_cursor.add(3));
                                        thread.set_cached_slot(i32::from(instruction.c()));
                                    }

                                    thread.set_vm_saved_pc(pc);
                                    thread.call_tm(2, i32::from(instruction.a()))?;
                                    let cached_slot = thread.cached_slot();
                                    patch_instruction_c(
                                        insn_pc as *mut Instruction,
                                        cached_slot as u8,
                                    );
                                    base = thread.stack_base();
                                    break 'dispatch;
                                }
                            } else if flags::DebugLuauUserDefinedClassesRuntime.get() && {
                                rb.is_object()
                            } {
                                let instance = { rb.object_value() };
                                match instance.lookup_member_cached(kv_string, instruction.c()) {
                                    ObjectMemberLookup::Cached(member) => {
                                        ra.set_obj(member);
                                    }
                                    ObjectMemberLookup::Resolved { offset, member } => {
                                        ra.set_obj(member);
                                        patch_instruction_c(
                                            insn_pc as *mut Instruction,
                                            offset as u8,
                                        );
                                    }
                                    ObjectMemberLookup::Missing => {
                                        return thread
                                            .missing_member_error(rb, kv)
                                            .map_err(Into::into);
                                    }
                                }
                                break 'dispatch;
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.get_table_internal(rb, kv, ra_cursor)?;
                                base = thread.stack_base();
                            }
                        }
                    }
                    Opcode::SetTableKs => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);
                        let kv = proto.vm_const(constants, aux.word() as usize);
                        debug_assert!({ kv.is_string() });
                        let kv_string = { kv.string_value() };

                        if rb.is_table() {
                            let table = { rb.table_value() };
                            let slot = instruction.c() as usize & table.node_mask_8();
                            let node = { table.node(slot as i32) };

                            if node.has_string_key(kv_string)
                                && !node.value_is_nil()
                                && table.as_ptr().as_ref().unwrap_unchecked().readonly == 0
                            {
                                node.value_unchecked().set_obj(ra);
                                if ra.is_collectable() {
                                    let table_object: GcObject = table.into();
                                    let child = ra.gc_value();
                                    if table_object.is_black() && child.is_white() {
                                        thread.barrier_table(table, child);
                                    }
                                }
                            } else if thread.fast_notm(table.metatable(), TmEvent::NewIndex)
                                && table.as_ptr().as_ref().unwrap_unchecked().readonly == 0
                            {
                                thread.set_vm_saved_pc(pc);
                                let node_cursor = thread.set_str(table, kv_string)?;
                                let cached_slot = { table.node_index(node_cursor) };
                                patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                                node_cursor.node_unchecked().value_unchecked().set_obj(ra);
                                if ra.is_collectable() {
                                    let table_object: GcObject = table.into();
                                    let child = ra.gc_value();
                                    if table_object.is_black() && child.is_white() {
                                        thread.barrier_table(table, child);
                                    }
                                }
                                base = thread.stack_base();
                            } else {
                                thread.set_cached_slot(slot as i32);
                                thread.set_vm_saved_pc(pc);
                                thread.set_table_internal(rb, kv, ra)?;
                                let cached_slot = thread.cached_slot();
                                patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                                base = thread.stack_base();
                            }
                        } else if rb.is_userdata() {
                            let userdata = { rb.userdata_value() };
                            if let Some(function) =
                                thread.fast_tm(userdata.metatable(), TmEvent::NewIndex)
                                && { function.is_function() && function.is_native_function() }
                            {
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(4)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(function);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(kv);
                                    top_cursor.add(3).value_unchecked().set_obj(ra);
                                    thread.set_stack_top(top_cursor.add(4));
                                    thread.set_cached_slot(i32::from(instruction.c()));
                                }

                                thread.set_vm_saved_pc(pc);
                                thread.call_tm(3, -1)?;
                                let cached_slot = thread.cached_slot();
                                patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                                base = thread.stack_base();
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.set_table_internal(rb, kv, ra)?;
                                base = thread.stack_base();
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.set_table_internal(rb, kv, ra)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::GetTable => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();

                        if rb.is_table() && rc.is_number() {
                            let table = rb.table_value();
                            let indexd = rc.number_value();
                            let index = indexd as i32;

                            if (index as u32).wrapping_sub(1)
                                < table.as_ptr().as_ref().unwrap_unchecked().size_array as u32
                                && table
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .metatable
                                    .is_null()
                                && (index as f64) == indexd
                            {
                                ra.set_obj(table.array_slot((index - 1) as usize));
                                break 'dispatch;
                            }
                        }

                        thread.set_vm_saved_pc(pc);
                        thread.get_table_internal(rb, rc, ra_cursor)?;
                        base = thread.stack_base();
                    }
                    Opcode::SetTable => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();
                        if rb.is_table() && rc.is_number() {
                            let table = { rb.table_value() };
                            let indexd = { rc.number_value() };
                            let index = indexd as i32;

                            if (index as u32).wrapping_sub(1) < {
                                table.as_ptr().as_ref().unwrap_unchecked().size_array as u32
                            } && {
                                table
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .metatable
                                    .is_null()
                            } && { table.as_ptr().as_ref().unwrap_unchecked().readonly == 0 }
                                && (index as f64) == indexd
                            {
                                table.array_slot((index - 1) as usize).set_obj(ra);
                                if ra.is_collectable() {
                                    let table_object: GcObject = table.into();
                                    let child = ra.gc_value();
                                    if table_object.is_black() && child.is_white() {
                                        thread.barrier_table(table, child);
                                    }
                                }
                            } else {
                                thread.set_vm_saved_pc(pc);
                                thread.set_table_internal(rb, rc, ra)?;
                                base = thread.stack_base();
                            }
                        } else {
                            thread.set_vm_saved_pc(pc);
                            thread.set_table_internal(rb, rc, ra)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::GetTableN => {
                        let ra_cursor =
                            base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra = ra_cursor.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let c = instruction.c() as i32;

                        if rb.is_table() {
                            let table = { rb.table_value() };
                            if (c as u32) < {
                                table.as_ptr().as_ref().unwrap_unchecked().size_array as u32
                            } && {
                                table
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .metatable
                                    .is_null()
                            } {
                                ra.set_obj(table.array_slot(c as usize));
                            } else {
                                let mut number_raw = RawTValue::number((c + 1) as f64);
                                let number = TValue::from_mut(&mut number_raw);
                                thread.set_vm_saved_pc(pc);
                                thread.get_table_internal(rb, number, ra_cursor)?;
                                base = thread.stack_base();
                            }
                        } else {
                            let mut number_raw = RawTValue::number((c + 1) as f64);
                            let number = TValue::from_mut(&mut number_raw);
                            thread.set_vm_saved_pc(pc);
                            thread.get_table_internal(rb, number, ra_cursor)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::SetTableN => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let c = instruction.c() as i32;

                        if rb.is_table() {
                            let table = { rb.table_value() };
                            if (c as u32) < {
                                table.as_ptr().as_ref().unwrap_unchecked().size_array as u32
                            } && {
                                table
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .metatable
                                    .is_null()
                            } && { table.as_ptr().as_ref().unwrap_unchecked().readonly == 0 }
                            {
                                table.array_slot(c as usize).set_obj(ra);
                                if ra.is_collectable() {
                                    let table_object: GcObject = table.into();
                                    let child = ra.gc_value();
                                    if table_object.is_black() && child.is_white() {
                                        thread.barrier_table(table, child);
                                    }
                                }
                            } else {
                                let mut number_raw = RawTValue::number((c + 1) as f64);
                                let number = TValue::from_mut(&mut number_raw);
                                thread.set_vm_saved_pc(pc);
                                thread.set_table_internal(rb, number, ra)?;
                                base = thread.stack_base();
                            }
                        } else {
                            let mut number_raw = RawTValue::number((c + 1) as f64);
                            let number = TValue::from_mut(&mut number_raw);
                            thread.set_vm_saved_pc(pc);
                            thread.set_table_internal(rb, number, ra)?;
                            base = thread.stack_base();
                        }
                    }
                    Opcode::NameCall => {
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);
                        let kv = proto.vm_const(constants, aux.word() as usize);
                        debug_assert!({ kv.is_string() });
                        let kv_string = { kv.string_value() };

                        if rb.is_table() {
                            let table = { rb.table_value() };
                            let slot = {
                                kv_string.as_ptr().as_ref().unwrap_unchecked().hash as usize
                                    & table.hash_mask()
                            };
                            let node = { table.node(slot as i32) };

                            if node.has_string_key(kv_string) && !node.value_is_nil() {
                                ra.add(1).value_unchecked().set_obj(rb);
                                ra_value.set_obj(node.value_unchecked());
                            } else if node.next() == 0 {
                                if let Some(index_tm) =
                                    thread.fast_tm(table.metatable(), TmEvent::Index)
                                    && index_tm.is_table()
                                {
                                    let meta_table = { index_tm.table_value() };
                                    let meta_slot =
                                        instruction.c() as usize & meta_table.node_mask_8();
                                    let meta_node = { meta_table.node(meta_slot as i32) };

                                    if meta_node.has_string_key(kv_string)
                                        && !meta_node.value_is_nil()
                                    {
                                        ra.add(1).value_unchecked().set_obj(rb);
                                        ra_value.set_obj(meta_node.value_unchecked());
                                        break 'dispatch;
                                    }
                                }

                                {
                                    ra.add(1).value_unchecked().set_obj(rb);
                                    thread.set_cached_slot(i32::from(instruction.c()));
                                }
                                thread.set_vm_saved_pc(pc);
                                thread.get_table_internal(rb, kv, ra)?;
                                let cached_slot = thread.cached_slot();
                                patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                                base = thread.stack_base();
                                let ra = base
                                    .vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                                if ra.value_unchecked().is_nil() {
                                    return thread
                                        .method_error(ra.add(1).value_unchecked(), kv_string)
                                        .map_err(Into::into);
                                }
                            } else {
                                {
                                    ra.add(1).value_unchecked().set_obj(rb);
                                    thread.set_cached_slot(i32::from(instruction.c()));
                                }
                                thread.set_vm_saved_pc(pc);
                                thread.get_table_internal(rb, kv, ra)?;
                                let cached_slot = thread.cached_slot();
                                patch_instruction_c(insn_pc as *mut Instruction, cached_slot as u8);
                                base = thread.stack_base();
                                let ra = base
                                    .vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                                if ra.value_unchecked().is_nil() {
                                    return thread
                                        .method_error(ra.add(1).value_unchecked(), kv_string)
                                        .map_err(Into::into);
                                }
                            }
                        } else {
                            let metatable = if rb.is_userdata() {
                                rb.userdata_value().metatable()
                            } else {
                                global.metatable(rb.tt() as usize)
                            };

                            if let Some(function) = thread.fast_tm(metatable, TmEvent::NameCall) {
                                {
                                    ra.add(1).value_unchecked().set_obj(rb);
                                    ra_value.set_obj(function);
                                    thread.set_name_call(Some(kv_string));
                                }
                            } else if let Some(index_tm) = thread.fast_tm(metatable, TmEvent::Index)
                            {
                                if index_tm.is_table() {
                                    let table = { index_tm.table_value() };
                                    let slot = instruction.c() as usize & table.node_mask_8();
                                    let node = { table.node(slot as i32) };

                                    if node.has_string_key(kv_string) && !node.value_is_nil() {
                                        ra.add(1).value_unchecked().set_obj(rb);
                                        ra_value.set_obj(node.value_unchecked());
                                    } else {
                                        {
                                            ra.add(1).value_unchecked().set_obj(rb);
                                            thread.set_cached_slot(slot as i32);
                                        }
                                        thread.set_vm_saved_pc(pc);
                                        thread.get_table_internal(rb, kv, ra)?;
                                        let cached_slot = thread.cached_slot();
                                        patch_instruction_c(
                                            insn_pc as *mut Instruction,
                                            cached_slot as u8,
                                        );
                                        base = thread.stack_base();
                                        let ra = base.vm_reg_cursor(
                                            thread.stack_top(),
                                            instruction.a() as usize,
                                        );
                                        if ra.value_unchecked().is_nil() {
                                            return thread
                                                .method_error(
                                                    ra.add(1).value_unchecked(),
                                                    kv_string,
                                                )
                                                .map_err(Into::into);
                                        }
                                    }
                                } else if flags::DebugLuauUserDefinedClassesRuntime.get() && {
                                    rb.is_object()
                                } {
                                    let instance = { rb.object_value() };
                                    ra.add(1).value_unchecked().set_obj(rb);
                                    match instance.lookup_member_cached(kv_string, instruction.c())
                                    {
                                        ObjectMemberLookup::Cached(member) => {
                                            ra_value.set_obj(member);
                                        }
                                        ObjectMemberLookup::Resolved { offset, member } => {
                                            ra_value.set_obj(member);
                                            patch_instruction_c(
                                                insn_pc as *mut Instruction,
                                                offset as u8,
                                            );
                                        }
                                        ObjectMemberLookup::Missing => {
                                            return thread
                                                .missing_member_error(rb, kv)
                                                .map_err(Into::into);
                                        }
                                    }
                                } else {
                                    {
                                        ra.add(1).value_unchecked().set_obj(rb);
                                    }
                                    thread.set_vm_saved_pc(pc);
                                    thread.get_table_internal(rb, kv, ra)?;
                                    base = thread.stack_base();
                                    let ra = base.vm_reg_cursor(
                                        thread.stack_top(),
                                        instruction.a() as usize,
                                    );
                                    if ra.value_unchecked().is_nil() {
                                        return thread
                                            .method_error(ra.add(1).value_unchecked(), kv_string)
                                            .map_err(Into::into);
                                    }
                                }
                            } else if flags::DebugLuauUserDefinedClassesRuntime.get() && {
                                rb.is_object()
                            } {
                                let instance = { rb.object_value() };
                                ra.add(1).value_unchecked().set_obj(rb);
                                match instance.lookup_member_cached(kv_string, instruction.c()) {
                                    ObjectMemberLookup::Cached(member) => {
                                        ra_value.set_obj(member);
                                    }
                                    ObjectMemberLookup::Resolved { offset, member } => {
                                        ra_value.set_obj(member);
                                        patch_instruction_c(
                                            insn_pc as *mut Instruction,
                                            offset as u8,
                                        );
                                    }
                                    ObjectMemberLookup::Missing => {
                                        return thread
                                            .missing_member_error(rb, kv)
                                            .map_err(Into::into);
                                    }
                                }
                            } else {
                                {
                                    ra.add(1).value_unchecked().set_obj(rb);
                                }
                                thread.set_vm_saved_pc(pc);
                                thread.get_table_internal(rb, kv, ra)?;
                                base = thread.stack_base();
                                let ra = base
                                    .vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                                if ra.value_unchecked().is_nil() {
                                    return thread
                                        .method_error(ra.add(1).value_unchecked(), kv_string)
                                        .map_err(Into::into);
                                }
                            }
                        }

                        #[cfg(debug_assertions)]
                        if !flags::LuauCallFeedback.get() {
                            assert_ne!((*pc).opcode(), Opcode::CallFb);
                        }
                    }
                    Opcode::GetUDataKs => {
                        let _ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let aux = { (*pc).word() };
                        pc = pc.add(1);
                        let kidx = (aux & 0xffff) as usize;
                        let kv = proto.vm_const(constants, kidx);

                        if rb.is_userdata() {
                            let userdata = { rb.userdata_value() };
                            let utag =
                                { userdata.as_ptr().as_ref().unwrap_unchecked().tag as usize };
                            let direct = {
                                &global.as_ptr().as_ref().unwrap_unchecked().userdata_direct[utag]
                            };
                            let function = direct.index;
                            let tm = TValue::from_ref(&direct.index_tm);

                            if let Some(function) = function
                                && !tm.is_nil()
                            {
                                let udata = { userdata.data_mut_ptr() };
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(3)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(tm);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(kv);
                                    thread.set_stack_top(top_cursor.add(3));
                                }

                                thread.set_vm_saved_pc(pc);
                                {
                                    thread.increment_native_call_depth();
                                }
                                if thread
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .native_call_depth
                                    >= crate::thread::LUAI_MAX_NATIVE_CALLS
                                {
                                    thread.check_c_stack()?;
                                }

                                thread.setup_cci(1, top_cursor)?;

                                let mut cached_slot = (aux >> 16) as u16;
                                {
                                    function(
                                        thread,
                                        udata.cast(),
                                        i32::from(
                                            kv.string_value()
                                                .as_ptr()
                                                .as_ref()
                                                .unwrap_unchecked()
                                                .atom,
                                        ),
                                        &mut cached_slot,
                                        utag as i32,
                                    )?;
                                }

                                if cached_slot != (aux >> 16) as u16
                                    && decode_instruction_opcode(*insn_pc) == Opcode::GetUDataKs
                                {
                                    patch_aux_slot(
                                        pc.sub(1) as *mut Instruction,
                                        kidx as u16,
                                        cached_slot,
                                    );
                                }

                                let parent_cursor = thread.current_call_info_cursor().sub(1);
                                let parent = parent_cursor.call_info_unchecked();

                                {
                                    thread.set_current_call_info(parent_cursor);
                                    thread.set_stack_base(parent.base());
                                    thread.decrement_native_call_depth();
                                }

                                base = thread.stack_base();
                                let ra = base
                                    .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                                    .value_unchecked();
                                {
                                    let result_cursor = thread.stack_top().sub(1);
                                    ra.set_obj(result_cursor.value_unchecked());
                                    thread.set_stack_top(parent.top());
                                }
                                break 'dispatch;
                            }
                        }

                        patch_instruction_opcode(insn_pc as *mut Instruction, Opcode::GetTableKs);
                        patch_aux_slot(pc.sub(1) as *mut Instruction, kidx as u16, 0);
                        pc = insn_pc.add(1);
                        dispatch_opcode = Opcode::GetTableKs;
                        continue 'dispatch;
                    }
                    Opcode::SetUDataKs => {
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let aux = { (*pc).word() };
                        pc = pc.add(1);
                        let kidx = (aux & 0xffff) as usize;
                        let kv = proto.vm_const(constants, kidx);

                        if rb.is_userdata() {
                            let userdata = { rb.userdata_value() };
                            let utag =
                                { userdata.as_ptr().as_ref().unwrap_unchecked().tag as usize };
                            let direct = {
                                &global.as_ptr().as_ref().unwrap_unchecked().userdata_direct[utag]
                            };
                            let function = direct.new_index;
                            let tm = TValue::from_ref(&direct.new_index_tm);

                            if let Some(function) = function
                                && !tm.is_nil()
                            {
                                let udata = { userdata.data_mut_ptr() };
                                let top_cursor = thread.stack_top();
                                debug_assert!({
                                    top_cursor.add(4)
                                        < thread.stack().add(
                                            thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                                as usize,
                                        )
                                });
                                {
                                    top_cursor.value_unchecked().set_obj(tm);
                                    top_cursor.add(1).value_unchecked().set_obj(rb);
                                    top_cursor.add(2).value_unchecked().set_obj(kv);
                                    top_cursor.add(3).value_unchecked().set_obj(ra);
                                    thread.set_stack_top(top_cursor.add(4));
                                }

                                thread.set_vm_saved_pc(pc);
                                {
                                    thread.increment_native_call_depth();
                                }
                                if thread
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .native_call_depth
                                    >= crate::thread::LUAI_MAX_NATIVE_CALLS
                                {
                                    thread.check_c_stack()?;
                                }

                                thread.setup_cci(0, top_cursor)?;

                                let mut cached_slot = (aux >> 16) as u16;
                                {
                                    function(
                                        thread,
                                        udata.cast(),
                                        i32::from(
                                            kv.string_value()
                                                .as_ptr()
                                                .as_ref()
                                                .unwrap_unchecked()
                                                .atom,
                                        ),
                                        &mut cached_slot,
                                        utag as i32,
                                    )?;
                                }

                                if cached_slot != (aux >> 16) as u16
                                    && decode_instruction_opcode(*insn_pc) == Opcode::SetUDataKs
                                {
                                    patch_aux_slot(
                                        pc.sub(1) as *mut Instruction,
                                        kidx as u16,
                                        cached_slot,
                                    );
                                }

                                let parent = thread.current_call_info_cursor().sub(1);

                                {
                                    let parent_call_info = parent.call_info_unchecked();
                                    thread.set_current_call_info(parent);
                                    thread.set_stack_base(parent_call_info.base());
                                    thread.set_stack_top(parent_call_info.top());
                                    thread.decrement_native_call_depth();
                                }
                                base = thread.stack_base();
                                break 'dispatch;
                            }
                        }

                        patch_instruction_opcode(insn_pc as *mut Instruction, Opcode::SetTableKs);
                        patch_aux_slot(pc.sub(1) as *mut Instruction, kidx as u16, 0);
                        pc = insn_pc.add(1);
                        dispatch_opcode = Opcode::SetTableKs;
                        continue 'dispatch;
                    }
                    Opcode::NameCallUData => {
                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let rb = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let aux = { (*pc).word() };
                        let namecall_slot = pc;
                        pc = pc.add(1);
                        let kidx = (aux & 0xffff) as usize;
                        let kv = proto.vm_const(constants, kidx);

                        if rb.is_userdata() {
                            let userdata = { rb.userdata_value() };
                            let utag =
                                { userdata.as_ptr().as_ref().unwrap_unchecked().tag as usize };
                            let direct = {
                                &global.as_ptr().as_ref().unwrap_unchecked().userdata_direct[utag]
                            };
                            let function = direct.name_call;
                            let tm = TValue::from_ref(&direct.name_call_tm);

                            if let Some(function) = function
                                && !tm.is_nil()
                            {
                                let udata = { userdata.data_mut_ptr() };
                                {
                                    ra.add(1).value_unchecked().set_obj(rb);
                                    ra_value.set_obj(tm);
                                }

                                debug_assert!(matches!(
                                    { (*pc).opcode() },
                                    Opcode::Call | Opcode::CallFb
                                ));
                                let call_instruction = { *pc };
                                pc = pc.add(1);
                                if flags::LuauCallFeedback.get()
                                    && call_instruction.opcode() == Opcode::CallFb
                                {
                                    pc = pc.add(1);
                                }

                                let call_ra = base.vm_reg_cursor(
                                    thread.stack_top(),
                                    call_instruction.a() as usize,
                                );
                                debug_assert!(call_ra == ra);

                                let n_params = i32::from(call_instruction.b()) - 1;
                                let n_results = i32::from(call_instruction.c()) - 1;

                                thread.set_vm_saved_pc(pc);
                                {
                                    thread.set_name_call(Some(kv.string_value()));
                                    let top = thread.stack_top();
                                    thread.set_stack_top(if n_params == LUA_MULTRET {
                                        top
                                    } else {
                                        ra.add(1 + n_params as usize)
                                    });
                                }

                                thread.setup_cci(n_results, ra)?;

                                let mut cached_slot = (aux >> 16) as u16;
                                debug_assert!({
                                    kv.string_value().as_ptr().as_ref().unwrap_unchecked().atom >= 0
                                });
                                let namecall_result = {
                                    function(
                                        thread,
                                        udata.cast(),
                                        i32::from(
                                            kv.string_value()
                                                .as_ptr()
                                                .as_ref()
                                                .unwrap_unchecked()
                                                .atom,
                                        ),
                                        &mut cached_slot,
                                        utag as i32,
                                    )
                                };

                                if matches!(namecall_result, Ok(_) | Err(VmExit::Control(_)))
                                    && cached_slot != (aux >> 16) as u16
                                    && decode_instruction_opcode(*insn_pc) == Opcode::NameCallUData
                                {
                                    patch_aux_slot(
                                        namecall_slot as *mut Instruction,
                                        kidx as u16,
                                        cached_slot,
                                    );
                                }
                                let results = namecall_result?;

                                let call_info = thread.current_call_info();
                                let parent = thread.current_call_info_cursor().sub(1);

                                let mut result_slot = { call_info.function() };
                                let mut value_iter = { thread.stack_top().sub(results) };
                                let value_end = { thread.stack_top() };
                                let mut remaining = n_results;

                                while remaining != 0 && value_iter < value_end {
                                    result_slot
                                        .value_unchecked()
                                        .set_obj(value_iter.value_unchecked());
                                    result_slot = result_slot.add(1);
                                    value_iter = value_iter.add(1);
                                    remaining -= 1;
                                }
                                while remaining > 0 {
                                    result_slot.value_unchecked().set_nil();
                                    result_slot = result_slot.add(1);
                                    remaining -= 1;
                                }

                                {
                                    let parent_call_info = parent.call_info_unchecked();
                                    thread.set_current_call_info(parent);
                                    thread.set_stack_base(parent_call_info.base());
                                    thread.set_stack_top(if n_results == LUA_MULTRET {
                                        result_slot
                                    } else {
                                        parent_call_info.top()
                                    });
                                }
                                base = thread.stack_base();
                                break 'dispatch;
                            }
                        }

                        patch_instruction_opcode(insn_pc as *mut Instruction, Opcode::NameCall);
                        patch_aux_slot(namecall_slot as *mut Instruction, kidx as u16, 0);
                        pc = insn_pc.add(1);
                        dispatch_opcode = Opcode::NameCall;
                        continue 'dispatch;
                    }
                    Opcode::JumpX => {
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();
                        if flags::LuauBackedgeHeapCheck.get() && thread.needs_gc() {
                            thread.set_vm_saved_pc(pc);
                            thread.step(true)?;
                            base = thread.stack_base();
                        }

                        pc = pc.offset(instruction.e() as isize);
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::FastCall => {
                        let builtin_id = instruction.a();
                        let skip = instruction.c() as usize;
                        debug_assert!(
                            {
                                pc.offset_from(proto.as_ptr().as_ref().unwrap_unchecked().code)
                                    as usize
                            } + skip
                                < { proto.as_ptr().as_ref().unwrap_unchecked().size_code as usize }
                        );

                        let call = { *pc.add(skip) };
                        debug_assert_eq!(call.opcode(), Opcode::Call);

                        let ra = base.vm_reg_cursor(thread.stack_top(), call.a() as usize);
                        let mut nparams = i32::from(call.b()) - 1;
                        let nresults = i32::from(call.c()) - 1;

                        if nparams == LUA_MULTRET {
                            nparams = thread.stack_top().offset_from(ra) as i32 - 1;
                        }

                        let builtin = crate::builtins::LUAU_F_TABLE[builtin_id as usize];
                        let env = closure.env();

                        if env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 {
                            thread.set_vm_saved_pc(pc);
                            let produced = {
                                builtin(
                                    thread,
                                    ra,
                                    ra.add(1).value_unchecked(),
                                    nresults,
                                    ra.add(2),
                                    nparams,
                                )
                            };

                            if produced >= 0 {
                                {
                                    thread.set_stack_top(if nresults == LUA_MULTRET {
                                        ra.add(produced as usize)
                                    } else {
                                        thread.current_call_info().top()
                                    });
                                }

                                pc = pc.add(skip + 1);
                                proto.assert_vm_pc(pc);
                            }
                        }
                    }
                    Opcode::Coverage => {
                        let hits = instruction.e();
                        let patched_hits = if hits < (1 << 23) - 1 { hits + 1 } else { hits };
                        let patched = Instruction::ae(Opcode::Coverage, patched_hits);
                        {
                            *(insn_pc as *mut Instruction) = patched;
                        }
                    }
                    Opcode::Capture => {
                        unreachable!(
                            "CAPTURE is a pseudo-opcode and must execute as part of closure creation"
                        );
                    }
                    Opcode::FastCall1 => {
                        let builtin_id = instruction.a();
                        let arg = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let skip = instruction.c() as usize;
                        debug_assert!(
                            {
                                pc.offset_from(proto.as_ptr().as_ref().unwrap_unchecked().code)
                                    as usize
                            } + skip
                                < { proto.as_ptr().as_ref().unwrap_unchecked().size_code as usize }
                        );

                        let call = { *pc.add(skip) };
                        debug_assert_eq!(call.opcode(), Opcode::Call);

                        let ra = base.vm_reg_cursor(thread.stack_top(), call.a() as usize);
                        let _ra_value = ra.value_unchecked();
                        let nresults = i32::from(call.c()) - 1;
                        let builtin = crate::builtins::LUAU_F_TABLE[builtin_id as usize];
                        let env = closure.env();

                        if env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 {
                            thread.set_vm_saved_pc(pc);
                            let produced = { builtin(thread, ra, arg, nresults, ra.add(1), 1) };

                            if produced >= 0 {
                                if nresults == LUA_MULTRET {
                                    {
                                        thread.set_stack_top(ra.add(produced as usize));
                                    }
                                }

                                pc = pc.add(skip + 1);
                                proto.assert_vm_pc(pc);
                            }
                        }
                    }
                    Opcode::FastCall2 => {
                        let skip = instruction.c() as usize - 1;
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);

                        let builtin_id = instruction.a();
                        let arg1 = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let arg2 = base.vm_reg_cursor(thread.stack_top(), aux.word() as usize);

                        debug_assert!(
                            {
                                pc.offset_from(proto.as_ptr().as_ref().unwrap_unchecked().code)
                                    as usize
                            } + skip
                                < { proto.as_ptr().as_ref().unwrap_unchecked().size_code as usize }
                        );

                        let call = { *pc.add(skip) };
                        debug_assert_eq!(call.opcode(), Opcode::Call);

                        let ra = base.vm_reg_cursor(thread.stack_top(), call.a() as usize);
                        let nresults = i32::from(call.c()) - 1;
                        let builtin = crate::builtins::LUAU_F_TABLE[builtin_id as usize];
                        let env = closure.env();

                        if env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 {
                            thread.set_vm_saved_pc(pc);
                            let produced = { builtin(thread, ra, arg1, nresults, arg2, 2) };

                            if produced >= 0 {
                                if nresults == LUA_MULTRET {
                                    {
                                        thread.set_stack_top(ra.add(produced as usize));
                                    }
                                }

                                pc = pc.add(skip + 1);
                                proto.assert_vm_pc(pc);
                            }
                        }
                    }
                    Opcode::FastCall2K => {
                        let skip = instruction.c() as usize - 1;
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);

                        let builtin_id = instruction.a();
                        let arg1 = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let arg2 = constants.add(aux.word() as usize);

                        debug_assert!(
                            {
                                pc.offset_from(proto.as_ptr().as_ref().unwrap_unchecked().code)
                                    as usize
                            } + skip
                                < { proto.as_ptr().as_ref().unwrap_unchecked().size_code as usize }
                        );

                        let call = { *pc.add(skip) };
                        debug_assert_eq!(call.opcode(), Opcode::Call);

                        let ra = base.vm_reg_cursor(thread.stack_top(), call.a() as usize);
                        let nresults = i32::from(call.c()) - 1;
                        let builtin = crate::builtins::LUAU_F_TABLE[builtin_id as usize];
                        let env = closure.env();

                        if env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 {
                            thread.set_vm_saved_pc(pc);
                            let produced = { builtin(thread, ra, arg1, nresults, arg2, 2) };

                            if produced >= 0 {
                                if nresults == LUA_MULTRET {
                                    {
                                        thread.set_stack_top(ra.add(produced as usize));
                                    }
                                }

                                pc = pc.add(skip + 1);
                                proto.assert_vm_pc(pc);
                            }
                        }
                    }
                    Opcode::FastCall3 => {
                        let skip = instruction.c() as usize - 1;
                        let aux = { InstructionAux::new((*pc).word()) };
                        pc = pc.add(1);

                        let builtin_id = instruction.a();
                        let arg1 = base
                            .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                            .value_unchecked();
                        let arg2 = base
                            .vm_reg_cursor(thread.stack_top(), aux.a() as usize)
                            .value_unchecked();
                        let arg3 = base
                            .vm_reg_cursor(thread.stack_top(), aux.b() as usize)
                            .value_unchecked();

                        debug_assert!(
                            {
                                pc.offset_from(proto.as_ptr().as_ref().unwrap_unchecked().code)
                                    as usize
                            } + skip
                                < { proto.as_ptr().as_ref().unwrap_unchecked().size_code as usize }
                        );

                        let call = { *pc.add(skip) };
                        debug_assert_eq!(call.opcode(), Opcode::Call);

                        let ra = base.vm_reg_cursor(thread.stack_top(), call.a() as usize);
                        let nresults = i32::from(call.c()) - 1;
                        let builtin = crate::builtins::LUAU_F_TABLE[builtin_id as usize];
                        let env = closure.env();

                        if env.as_ptr().as_ref().unwrap_unchecked().safe_env != 0 {
                            thread.set_vm_saved_pc(pc);
                            debug_assert!(
                                thread.stack_top().add(2)
                                    < thread.stack().add(
                                        thread.as_ptr().as_ref().unwrap_unchecked().stack_size
                                            as usize
                                    )
                            );
                            let top_value = thread.stack_top();
                            {
                                top_value.value_unchecked().set_obj(arg2);
                                top_value.add(1).value_unchecked().set_obj(arg3);
                            }

                            let produced = { builtin(thread, ra, arg1, nresults, top_value, 3) };

                            if produced >= 0 {
                                if nresults == LUA_MULTRET {
                                    {
                                        thread.set_stack_top(ra.add(produced as usize));
                                    }
                                }

                                pc = pc.add(skip + 1);
                                proto.assert_vm_pc(pc);
                            }
                        }
                    }
                    Opcode::Call => {
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();

                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let nparams = i32::from(instruction.b()) - 1;
                        let nresults = i32::from(instruction.c()) - 1;

                        let mut arg_top = { thread.stack_top() };
                        if nparams != LUA_MULTRET {
                            arg_top = ra.add(1 + nparams as usize);
                        }

                        if !ra_value.is_function() {
                            thread.set_vm_saved_pc(pc);
                            thread.try_func_tm(ra)?;
                            arg_top = arg_top.add(1);
                        }

                        let called_closure = { ra.value_unchecked().closure_value() };
                        thread.set_vm_saved_pc(pc);

                        let call_info = thread.incr_ci()?.call_info_unchecked();
                        {
                            call_info.init_call(
                                ra,
                                arg_top.add(
                                    called_closure
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .stack_size as usize,
                                ),
                                nresults,
                                called_closure.proto(),
                            );
                        }

                        {
                            thread.set_stack_base(call_info.base());
                            thread.set_stack_top(arg_top);
                        }

                        thread.check_stack_for_new_ci(
                            called_closure
                                .as_ptr()
                                .as_ref()
                                .unwrap_unchecked()
                                .stack_size as i32,
                        )?;
                        debug_assert!(call_info.top() <= thread.stack_last());

                        if called_closure.is_lua() {
                            let called_proto = { called_closure.proto().unwrap_unchecked() };

                            {
                                let mut arg_cursor = thread.stack_top();
                                let arg_end_cursor = thread.stack_base().add(
                                    called_proto.as_ptr().as_ref().unwrap_unchecked().num_params
                                        as usize,
                                );
                                while arg_cursor < arg_end_cursor {
                                    arg_cursor.value_unchecked().set_nil();
                                    arg_cursor = arg_cursor.add(1);
                                }

                                thread.set_stack_top(
                                    if called_proto.as_ptr().as_ref().unwrap_unchecked().is_vararg
                                        != 0
                                    {
                                        arg_cursor
                                    } else {
                                        call_info.top()
                                    },
                                );

                                call_info.set_saved_pc(
                                    called_proto
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .code
                                        .cast_const(),
                                );

                                if called_proto
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .exec_target
                                    != 0
                                    && !called_proto
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .exec_data
                                        .is_null()
                                {
                                    call_info.as_ptr().as_mut().unwrap_unchecked().flags =
                                        LUA_CALLINFO_NATIVE;
                                }
                            }

                            pc = if thread.as_ptr().as_ref().unwrap_unchecked().single_step {
                                called_proto
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .code
                                    .cast_const()
                            } else {
                                called_proto.as_ptr().as_ref().unwrap_unchecked().code_entry
                            };
                            closure = called_closure;
                            base = thread.stack_base();
                            proto = called_proto;
                            constants = called_proto.constants();
                            if pc == {
                                called_proto.as_ptr().as_ref().unwrap_unchecked().code_entry
                            } {
                                called_proto.assert_vm_pc(
                                    called_proto
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .code
                                        .cast_const(),
                                );
                            } else {
                                called_proto.assert_vm_pc(pc);
                            }
                        } else {
                            thread.finish_native_call(called_closure, nresults)?;

                            base = thread.stack_base();
                        }
                    }
                    Opcode::CallFb => {
                        debug_assert!(flags::LuauCallFeedback.get());
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();

                        let feedback_slot = { (*pc).word() };
                        pc = pc.add(1);

                        let ra = base.vm_reg_cursor(thread.stack_top(), instruction.a() as usize);
                        let ra_value = ra.value_unchecked();
                        let nparams = i32::from(instruction.b()) - 1;
                        let nresults = i32::from(instruction.c()) - 1;

                        let mut arg_top = { thread.stack_top() };
                        if nparams != LUA_MULTRET {
                            arg_top = ra.add(1 + nparams as usize);
                        }

                        if !ra_value.is_function() {
                            if feedback_slot != u32::MAX {
                                {
                                    *(pc.sub(1) as *mut Instruction) = Instruction::new(u32::MAX);
                                }
                            }

                            thread.set_vm_saved_pc(pc);
                            thread.try_func_tm(ra)?;
                            arg_top = arg_top.add(1);
                        }

                        let called_closure = { ra.value_unchecked().closure_value() };
                        thread.set_vm_saved_pc(pc);

                        let call_info = thread.incr_ci()?.call_info_unchecked();
                        {
                            call_info.init_call(
                                ra,
                                arg_top.add(
                                    called_closure
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .stack_size as usize,
                                ),
                                nresults,
                                called_closure.proto(),
                            );
                        }

                        {
                            thread.set_stack_base(call_info.base());
                            thread.set_stack_top(arg_top);
                        }

                        thread.check_stack_for_new_ci(
                            called_closure
                                .as_ptr()
                                .as_ref()
                                .unwrap_unchecked()
                                .stack_size as i32,
                        )?;
                        debug_assert!(call_info.top() <= thread.stack_last());

                        if called_closure.is_lua() {
                            let called_proto = { called_closure.proto().unwrap_unchecked() };

                            if feedback_slot != u32::MAX
                                && !thread.record_hit(closure, called_closure, feedback_slot)
                            {
                                {
                                    *(pc.sub(1) as *mut Instruction) = Instruction::new(u32::MAX);
                                }
                            }

                            {
                                let mut arg_cursor = thread.stack_top();
                                let arg_end_cursor = thread.stack_base().add(
                                    called_proto.as_ptr().as_ref().unwrap_unchecked().num_params
                                        as usize,
                                );
                                while arg_cursor < arg_end_cursor {
                                    arg_cursor.value_unchecked().set_nil();
                                    arg_cursor = arg_cursor.add(1);
                                }

                                thread.set_stack_top(
                                    if called_proto.as_ptr().as_ref().unwrap_unchecked().is_vararg
                                        != 0
                                    {
                                        arg_cursor
                                    } else {
                                        call_info.top()
                                    },
                                );

                                call_info.set_saved_pc(
                                    called_proto
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .code
                                        .cast_const(),
                                );

                                if called_proto
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .exec_target
                                    != 0
                                    && !called_proto
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .exec_data
                                        .is_null()
                                {
                                    call_info.as_ptr().as_mut().unwrap_unchecked().flags =
                                        LUA_CALLINFO_NATIVE;
                                }
                            }

                            pc = if thread.as_ptr().as_ref().unwrap_unchecked().single_step {
                                called_proto
                                    .as_ptr()
                                    .as_ref()
                                    .unwrap_unchecked()
                                    .code
                                    .cast_const()
                            } else {
                                called_proto.as_ptr().as_ref().unwrap_unchecked().code_entry
                            };
                            closure = called_closure;
                            base = thread.stack_base();
                            proto = called_proto;
                            constants = called_proto.constants();
                            if pc == {
                                called_proto.as_ptr().as_ref().unwrap_unchecked().code_entry
                            } {
                                called_proto.assert_vm_pc(
                                    called_proto
                                        .as_ptr()
                                        .as_ref()
                                        .unwrap_unchecked()
                                        .code
                                        .cast_const(),
                                );
                            } else {
                                called_proto.assert_vm_pc(pc);
                            }
                        } else {
                            if feedback_slot != u32::MAX {
                                {
                                    *(pc.sub(1) as *mut Instruction) = Instruction::new(u32::MAX);
                                }
                            }

                            thread.finish_native_call(called_closure, nresults)?;

                            base = thread.stack_base();
                        }
                    }
                    Opcode::Return => {
                        thread.interrupt_vm(insn_pc)?;
                        base = thread.stack_base();

                        let ra = { base.add(instruction.a() as usize) };
                        let b = i32::from(instruction.b()) - 1;

                        let call_info = { thread.current_call_info() };
                        let parent_cursor = thread.current_call_info_cursor().sub(1);
                        let parent = parent_cursor.call_info_unchecked();

                        {
                            let mut result = call_info.function();
                            let mut value = ra;
                            let value_end = if b == LUA_MULTRET {
                                thread.stack_top()
                            } else {
                                ra.add(b as usize)
                            };
                            let mut remaining =
                                call_info.as_ptr().as_ref().unwrap_unchecked().n_results;

                            while remaining != 0 && value < value_end {
                                result.value_unchecked().set_obj(value.value_unchecked());
                                result = result.add(1);
                                value = value.add(1);
                                remaining -= 1;
                            }

                            while remaining > 0 {
                                result.value_unchecked().set_nil();
                                result = result.add(1);
                                remaining -= 1;
                            }

                            thread.set_current_call_info(parent_cursor);
                            thread.set_stack_base(parent.base());
                            thread.set_stack_top(
                                if call_info.as_ptr().as_ref().unwrap_unchecked().n_results
                                    == LUA_MULTRET
                                {
                                    result
                                } else {
                                    parent.top()
                                },
                            );
                        }

                        if {
                            call_info.as_ptr().as_ref().unwrap_unchecked().flags
                                & crate::state::LUA_CALLINFO_RETURN
                        } != 0
                        {
                            return Ok(());
                        }

                        let next_closure = { parent.function_closure() };
                        let next_proto = { next_closure.proto().unwrap_unchecked() };

                        if {
                            parent.as_ptr().as_ref().unwrap_unchecked().flags & LUA_CALLINFO_NATIVE
                        } != 0
                            && !thread.as_ptr().as_ref().unwrap_unchecked().single_step
                        {
                            let Some(enter) = global.execution_enter() else {
                                unreachable!(
                                    "native lvmexecute requires an execution enter callback"
                                );
                            };

                            if { enter(thread, next_proto) } == 0 {
                                return Ok(());
                            }

                            let resumed_call = thread.current_call_info();
                            closure = resumed_call.function_closure();
                            proto = closure.proto().unwrap_unchecked();
                            pc = resumed_call.saved_pc();
                            base = thread.stack_base();
                            constants = proto.constants();
                            proto.assert_vm_pc(pc);
                        } else {
                            pc = parent.saved_pc();
                            closure = next_closure;
                            base = thread.stack_base();
                            proto = next_proto;
                            constants = proto.constants();
                            proto.assert_vm_pc(pc);
                        }
                    }
                    Opcode::JumpXEqKNil => {
                        let aux = { InstructionAux::new((*pc).word()) };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let condition = { ra.is_nil() } != aux.is_negated();
                        pc = if condition {
                            pc.offset(i32::from(instruction.d()) as isize)
                        } else {
                            pc.add(1)
                        };
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpXEqKB => {
                        let aux = { InstructionAux::new((*pc).word()) };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let condition =
                            { ra.is_boolean() && ra.boolean_value() == i32::from(aux.kb()) }
                                != aux.is_negated();
                        pc = if condition {
                            pc.offset(i32::from(instruction.d()) as isize)
                        } else {
                            pc.add(1)
                        };
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpXEqKN => {
                        let aux = { InstructionAux::new((*pc).word()) };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, aux.kv() as usize);
                        #[cfg(target_arch = "aarch64")]
                        {
                            if aux.is_negated() {
                                pc = if !ra.is_number() || ra.number_value() != kv.number_value() {
                                    pc.offset(i32::from(instruction.d()) as isize)
                                } else {
                                    pc.add(1)
                                };
                            } else {
                                pc = if ra.is_number() && ra.number_value() == kv.number_value() {
                                    pc.offset(i32::from(instruction.d()) as isize)
                                } else {
                                    pc.add(1)
                                };
                            }
                        }
                        #[cfg(not(target_arch = "aarch64"))]
                        {
                            let condition = (ra.is_number()
                                && ra.number_value() == kv.number_value())
                                != aux.is_negated();
                            pc = if condition {
                                pc.offset(i32::from(instruction.d()) as isize)
                            } else {
                                pc.add(1)
                            };
                        }
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::JumpXEqKS => {
                        let aux = { InstructionAux::new((*pc).word()) };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let kv = proto.vm_const(constants, aux.kv() as usize);
                        debug_assert!({ kv.is_string() });
                        let condition = { ra.is_string() && ra.gc_value() == kv.gc_value() }
                            != aux.is_negated();
                        pc = if condition {
                            pc.offset(i32::from(instruction.d()) as isize)
                        } else {
                            pc.add(1)
                        };
                        proto.assert_vm_pc(pc);
                    }
                    Opcode::NewClassMember => {
                        let aux = { (*pc).word() };
                        pc = pc.add(1);

                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let member_name = proto.vm_const(constants, aux as usize);
                        debug_assert!({ member_name.is_string() });
                        debug_assert_eq!(instruction.b(), 0);
                        let rc = base
                            .vm_reg_cursor(thread.stack_top(), instruction.c() as usize)
                            .value_unchecked();
                        thread.set_vm_saved_pc(pc);
                        { ra.class_value() }.add_class_member(
                            thread,
                            member_name.string_value(),
                            rc,
                        )?;
                    }
                    Opcode::NewClass => {
                        let aux = (*pc).word();
                        pc = pc.add(1);

                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();
                        let class_shape = proto.vm_const(constants, aux as usize);
                        debug_assert!(class_shape.is_class());
                        ra.set_obj(class_shape);

                        if instruction.b() != u8::MAX {
                            thread.set_vm_saved_pc(pc);

                            let superclass = base
                                .vm_reg_cursor(thread.stack_top(), instruction.b() as usize)
                                .value_unchecked();
                            if !superclass.is_class() {
                                return thread.type_error(superclass, "extend").map_err(Into::into);
                            }

                            let class = thread.inherit_class(
                                class_shape.class_value(),
                                superclass.class_value(),
                            )?;
                            ra.set_class_value(class);
                        }
                    }
                    Opcode::CmpProto => {
                        let fun_id = { (*pc).word() };
                        let ra = base
                            .vm_reg_cursor(thread.stack_top(), instruction.a() as usize)
                            .value_unchecked();

                        let is_function = { ra.is_function() };
                        let should_jump = if !is_function {
                            true
                        } else {
                            let called = { ra.closure_value() };
                            if called.is_native() {
                                true
                            } else {
                                let called_proto = called.proto().unwrap_unchecked();
                                called_proto.as_ptr().as_ref().unwrap_unchecked().fun_id != fun_id
                            }
                        };

                        pc = if should_jump {
                            pc.offset(i32::from(instruction.d()) as isize)
                        } else {
                            pc.add(1)
                        };
                        proto.assert_vm_pc(pc);
                    }
                }

                break 'dispatch;
            }
        }
    }
}