Luau translated to LuaJIT, as a standalone script

luau_in_luajit.lua

-- Roblox's Luau as a LuaJIT 2.1.0 command line script
-- Translated using https://github.com/Rerumu/Wasynth
local rt = (function()
	local module = {}

	local bit = require("bit")
	local ffi = require("ffi")

	local u32 = ffi.typeof("uint32_t")
	local u64 = ffi.typeof("uint64_t")
	local i64 = ffi.typeof("int64_t")

	local math_ceil = math.ceil
	local math_floor = math.floor
	local to_number = tonumber
	local to_signed = bit.tobit

	local NUM_ZERO = i64(0)
	local NUM_ONE = i64(1)

	local function truncate_f64(num)
		if num >= 0 then
			return (math_floor(num))
		else
			return (math_ceil(num))
		end
	end

	do
		local add = {}
		local sub = {}
		local mul = {}
		local div = {}
		local rem = {}
		local neg = {}
		local min = {}
		local max = {}
		local copysign = {}
		local nearest = {}

		local math_abs = math.abs
		local math_min = math.min
		local math_max = math.max

		local RE_INSTANCE = ffi.new(
			[[union {
		double f64;
		struct { int32_t a32, b32; };
	}]]
		)

		local function round(num)
			if num >= 0 then
				return (math_floor(num + 0.5))
			else
				return (math_ceil(num - 0.5))
			end
		end

		function add.i32(lhs, rhs) return (to_signed(lhs + rhs)) end

		function sub.i32(lhs, rhs) return (to_signed(lhs - rhs)) end

		function mul.i32(lhs, rhs) return (to_signed(NUM_ONE * lhs * rhs)) end

		function div.i32(lhs, rhs)
			assert(rhs ~= 0, "division by zero")

			return (truncate_f64(lhs / rhs))
		end

		function div.u32(lhs, rhs)
			assert(rhs ~= 0, "division by zero")

			lhs = to_number(u32(lhs))
			rhs = to_number(u32(rhs))

			return (to_signed(math_floor(lhs / rhs)))
		end

		function rem.u32(lhs, rhs)
			assert(rhs ~= 0, "division by zero")

			lhs = to_number(u32(lhs))
			rhs = to_number(u32(rhs))

			return (to_signed(lhs % rhs))
		end

		function div.u64(lhs, rhs)
			assert(rhs ~= 0, "division by zero")

			return (i64(u64(lhs) / u64(rhs)))
		end

		function rem.u64(lhs, rhs)
			assert(rhs ~= 0, "division by zero")

			return (i64(u64(lhs) % u64(rhs)))
		end

		function neg.f32(num) return -num end

		function min.f32(lhs, rhs)
			if lhs ~= lhs then
				return lhs
			elseif rhs ~= rhs then
				return rhs
			else
				return (math_min(lhs, rhs))
			end
		end

		function max.f32(lhs, rhs)
			if lhs ~= lhs then
				return lhs
			elseif rhs ~= rhs then
				return rhs
			else
				return (math_max(lhs, rhs))
			end
		end

		function copysign.f32(lhs, rhs)
			RE_INSTANCE.f64 = rhs

			if RE_INSTANCE.b32 >= 0 then
				return (math_abs(lhs))
			else
				return -math_abs(lhs)
			end
		end

		function nearest.f32(num)
			local result = round(num)

			if (math_abs(num) + 0.5) % 2 == 1 then
				if result >= 0 then
					result = result - 1
				else
					result = result + 1
				end
			end

			return result
		end

		neg.f64 = neg.f32
		min.f64 = min.f32
		max.f64 = max.f32
		copysign.f64 = copysign.f32
		nearest.f64 = nearest.f32

		module.add = add
		module.sub = sub
		module.mul = mul
		module.div = div
		module.rem = rem
		module.min = min
		module.max = max
		module.neg = neg
		module.copysign = copysign
		module.nearest = nearest
	end

	do
		local clz = {}
		local ctz = {}
		local popcnt = {}

		local bit_and = bit.band
		local bit_lshift = bit.lshift
		local bit_rshift = bit.rshift

		function clz.i32(num)
			if num == 0 then return 32 end

			local count = 0

			if bit_rshift(num, 16) == 0 then
				num = bit_lshift(num, 16)
				count = count + 16
			end

			if bit_rshift(num, 24) == 0 then
				num = bit_lshift(num, 8)
				count = count + 8
			end

			if bit_rshift(num, 28) == 0 then
				num = bit_lshift(num, 4)
				count = count + 4
			end

			if bit_rshift(num, 30) == 0 then
				num = bit_lshift(num, 2)
				count = count + 2
			end

			if bit_rshift(num, 31) == 0 then count = count + 1 end

			return count
		end

		function ctz.i32(num)
			if num == 0 then return 32 end

			local count = 0

			if bit_lshift(num, 16) == 0 then
				num = bit_rshift(num, 16)
				count = count + 16
			end

			if bit_lshift(num, 24) == 0 then
				num = bit_rshift(num, 8)
				count = count + 8
			end

			if bit_lshift(num, 28) == 0 then
				num = bit_rshift(num, 4)
				count = count + 4
			end

			if bit_lshift(num, 30) == 0 then
				num = bit_rshift(num, 2)
				count = count + 2
			end

			if bit_lshift(num, 31) == 0 then count = count + 1 end

			return count
		end

		function popcnt.i32(num)
			local count = 0

			while num ~= 0 do
				num = bit_and(num, num - 1)
				count = count + 1
			end

			return count
		end

		function clz.i64(num)
			if num == 0 then return 64 * NUM_ONE end

			local count = NUM_ZERO

			if bit_rshift(num, 32) == NUM_ZERO then
				num = bit_lshift(num, 32)
				count = count + 32
			end

			if bit_rshift(num, 48) == NUM_ZERO then
				num = bit_lshift(num, 16)
				count = count + 16
			end

			if bit_rshift(num, 56) == NUM_ZERO then
				num = bit_lshift(num, 8)
				count = count + 8
			end

			if bit_rshift(num, 60) == NUM_ZERO then
				num = bit_lshift(num, 4)
				count = count + 4
			end

			if bit_rshift(num, 62) == NUM_ZERO then
				num = bit_lshift(num, 2)
				count = count + 2
			end

			if bit_rshift(num, 63) == NUM_ZERO then count = count + NUM_ONE end

			return count
		end

		function ctz.i64(num)
			if num == 0 then return 64 * NUM_ONE end

			local count = NUM_ZERO

			if bit_lshift(num, 32) == NUM_ZERO then
				num = bit_rshift(num, 32)
				count = count + 32
			end

			if bit_lshift(num, 48) == NUM_ZERO then
				num = bit_rshift(num, 16)
				count = count + 16
			end

			if bit_lshift(num, 56) == NUM_ZERO then
				num = bit_rshift(num, 8)
				count = count + 8
			end

			if bit_lshift(num, 60) == NUM_ZERO then
				num = bit_rshift(num, 4)
				count = count + 4
			end

			if bit_lshift(num, 62) == NUM_ZERO then
				num = bit_rshift(num, 2)
				count = count + 2
			end

			if bit_lshift(num, 63) == NUM_ZERO then count = count + NUM_ONE end

			return count
		end

		function popcnt.i64(num)
			local count = NUM_ZERO

			while num ~= NUM_ZERO do
				num = bit_and(num, num - NUM_ONE)
				count = count + NUM_ONE
			end

			return count
		end

		module.clz = clz
		module.ctz = ctz
		module.popcnt = popcnt
	end

	do
		local le = {}
		local lt = {}
		local ge = {}
		local gt = {}

		function le.u32(lhs, rhs) return u32(lhs) <= u32(rhs) end

		function lt.u32(lhs, rhs) return u32(lhs) < u32(rhs) end

		function ge.u32(lhs, rhs) return u32(lhs) >= u32(rhs) end

		function gt.u32(lhs, rhs) return u32(lhs) > u32(rhs) end

		function le.u64(lhs, rhs) return u64(lhs) <= u64(rhs) end

		function lt.u64(lhs, rhs) return u64(lhs) < u64(rhs) end

		function ge.u64(lhs, rhs) return u64(lhs) >= u64(rhs) end

		function gt.u64(lhs, rhs) return u64(lhs) > u64(rhs) end

		module.le = le
		module.lt = lt
		module.ge = ge
		module.gt = gt
	end

	do
		local wrap = {}
		local truncate = {}
		local saturate = {}
		local extend = {}
		local convert = {}
		local promote = {}
		local demote = {}
		local reinterpret = {}

		local bit_and = bit.band

		local NUM_MIN_I64 = bit.lshift(NUM_ONE, 63)
		local NUM_MAX_I64 = bit.bnot(NUM_MIN_I64)
		local NUM_MAX_U64 = bit.bnot(NUM_ZERO)

		-- This would surely be an issue in a multi-thread environment...
		-- ... thankfully this isn't one.
		local RE_INSTANCE = ffi.new(
			[[union {
		int32_t i32;
		int64_t i64;
		float f32;
		double f64;
	}]]
		)

		function wrap.i32_i64(num)
			RE_INSTANCE.i64 = num

			return RE_INSTANCE.i32
		end

		truncate.i32_f32 = truncate_f64
		truncate.i32_f64 = truncate_f64

		function truncate.u32_f32(num) return (to_signed(truncate_f64(num))) end

		truncate.u32_f64 = truncate.u32_f32

		truncate.i64_f32 = i64
		truncate.i64_f64 = i64
		truncate.u64_f32 = i64

		function truncate.u64_f64(num) return (i64(u64(num))) end

		truncate.f32 = truncate_f64
		truncate.f64 = truncate_f64

		function saturate.i32_f32(num)
			if num <= -0x80000000 then
				return -0x80000000
			elseif num >= 0x7FFFFFFF then
				return 0x7FFFFFFF
			else
				return to_signed(truncate_f64(num))
			end
		end

		saturate.i32_f64 = saturate.i32_f32

		function saturate.u32_f32(num)
			if num <= 0 then
				return 0
			elseif num >= 0xFFFFFFFF then
				return -1
			else
				return to_signed(truncate_f64(num))
			end
		end

		saturate.u32_f64 = saturate.u32_f32

		function saturate.i64_f32(num)
			if num >= 2 ^ 63 - 1 then
				return NUM_MAX_I64
			elseif num <= -2 ^ 63 then
				return NUM_MIN_I64
			elseif num ~= num then
				return NUM_ZERO
			else
				return i64(num)
			end
		end

		saturate.i64_f64 = saturate.i64_f32

		function saturate.u64_f32(num)
			if num >= 2 ^ 64 then
				return NUM_MAX_U64
			elseif num <= 0 or num ~= num then
				return NUM_ZERO
			else
				return i64(u64(num))
			end
		end

		saturate.u64_f64 = saturate.u64_f32

		function extend.i32_n8(num)
			num = bit_and(num, 0xFF)

			if num >= 0x80 then
				return num - 0x100
			else
				return num
			end
		end

		function extend.i32_n16(num)
			num = bit_and(num, 0xFFFF)

			if num >= 0x8000 then
				return num - 0x10000
			else
				return num
			end
		end

		function extend.i64_n8(num)
			num = bit_and(num, 0xFF)

			if num >= 0x80 then
				return num - 0x100
			else
				return num
			end
		end

		function extend.i64_n16(num)
			num = bit_and(num, 0xFFFF)

			if num >= 0x8000 then
				return num - 0x10000
			else
				return num
			end
		end

		function extend.i64_n32(num)
			num = bit_and(num, 0xFFFFFFFF)

			if num >= 0x80000000 then
				return num - 0x100000000
			else
				return num
			end
		end

		extend.i64_i32 = i64

		function extend.i64_u32(num)
			RE_INSTANCE.i64 = NUM_ZERO
			RE_INSTANCE.i32 = num

			return RE_INSTANCE.i64
		end

		function convert.f32_i32(num) return num end

		function convert.f32_u32(num) return (to_number(u32(num))) end

		function convert.f32_u64(num) return (to_number(u64(num))) end

		convert.f64_i32 = convert.f32_i32
		convert.f64_u32 = convert.f32_u32
		convert.f64_u64 = convert.f32_u64

		function demote.f32_f64(num) return num end

		promote.f64_f32 = demote.f32_f64

		function reinterpret.i32_f32(num)
			RE_INSTANCE.f32 = num

			return RE_INSTANCE.i32
		end

		function reinterpret.i64_f64(num)
			RE_INSTANCE.f64 = num

			return RE_INSTANCE.i64
		end

		function reinterpret.f32_i32(num)
			RE_INSTANCE.i32 = num

			return RE_INSTANCE.f32
		end

		function reinterpret.f64_i64(num)
			RE_INSTANCE.i64 = num

			return RE_INSTANCE.f64
		end

		module.wrap = wrap
		module.truncate = truncate
		module.saturate = saturate
		module.extend = extend
		module.convert = convert
		module.demote = demote
		module.promote = promote
		module.reinterpret = reinterpret
	end

	do
		local load = {}
		local store = {}
		local allocator = {}

		ffi.cdef(
			[[
	union Any {
		int8_t i8;
		int16_t i16;
		int32_t i32;
		int64_t i64;

		uint8_t u8;
		uint16_t u16;
		uint32_t u32;
		uint64_t u64;

		float f32;
		double f64;
	};

	struct Memory {
		uint32_t min;
		uint32_t max;
		union Any *data;
	};

	void *calloc(size_t num, size_t size);
	void *realloc(void *ptr, size_t size);
	void free(void *ptr);
	]]
		)

		local alias_t = ffi.typeof("uint8_t *")
		local any_t = ffi.typeof("union Any *")
		local cast = ffi.cast

		local function by_offset(pointer, offset)
			local aliased = cast(alias_t, pointer)

			return cast(any_t, aliased + offset)
		end

		function load.i32_i8(memory, addr) return by_offset(memory.data, addr).i8 end

		function load.i32_u8(memory, addr) return by_offset(memory.data, addr).u8 end

		function load.i32_i16(memory, addr) return by_offset(memory.data, addr).i16 end

		function load.i32_u16(memory, addr) return by_offset(memory.data, addr).u16 end

		function load.i32(memory, addr) return by_offset(memory.data, addr).i32 end

		function load.i64_i8(memory, addr)
			return (i64(by_offset(memory.data, addr).i8))
		end

		function load.i64_u8(memory, addr)
			return (i64(by_offset(memory.data, addr).u8))
		end

		function load.i64_i16(memory, addr)
			return (i64(by_offset(memory.data, addr).i16))
		end

		function load.i64_u16(memory, addr)
			return (i64(by_offset(memory.data, addr).u16))
		end

		function load.i64_i32(memory, addr)
			return (i64(by_offset(memory.data, addr).i32))
		end

		function load.i64_u32(memory, addr)
			return (i64(by_offset(memory.data, addr).u32))
		end

		function load.i64(memory, addr) return by_offset(memory.data, addr).i64 end

		function load.f32(memory, addr) return by_offset(memory.data, addr).f32 end

		function load.f64(memory, addr) return by_offset(memory.data, addr).f64 end

		function load.string(memory, addr, len)
			local start = cast(alias_t, memory.data) + addr

			return ffi.string(start, len)
		end

		function store.i32_n8(memory, addr, value)
			by_offset(memory.data, addr).i8 = value
		end

		function store.i32_n16(memory, addr, value)
			by_offset(memory.data, addr).i16 = value
		end

		function store.i32(memory, addr, value)
			by_offset(memory.data, addr).i32 = value
		end

		function store.i64_n8(memory, addr, value)
			by_offset(memory.data, addr).i8 = value
		end

		function store.i64_n16(memory, addr, value)
			by_offset(memory.data, addr).i16 = value
		end

		function store.i64_n32(memory, addr, value)
			by_offset(memory.data, addr).i32 = value
		end

		function store.i64(memory, addr, value)
			by_offset(memory.data, addr).i64 = value
		end

		function store.f32(memory, addr, value)
			by_offset(memory.data, addr).f32 = value
		end

		function store.f64(memory, addr, value)
			by_offset(memory.data, addr).f64 = value
		end

		function store.string(memory, addr, data, len)
			local start = by_offset(memory.data, addr)

			ffi.copy(start, data, len or #data)
		end

		local WASM_PAGE_SIZE = 65536

		local function finalizer(memory) ffi.C.free(memory.data) end

		local function grow_unchecked(memory, old, new)
			memory.data = ffi.C.realloc(memory.data, new)

			assert(memory.data ~= nil, "failed to reallocate")

			ffi.fill(by_offset(memory.data, old), new - old, 0)
		end

		function allocator.new(min, max)
			local data = ffi.C.calloc(max, WASM_PAGE_SIZE)

			assert(data ~= nil, "failed to allocate")

			local memory = ffi.new("struct Memory", min, max, data)

			return ffi.gc(memory, finalizer)
		end

		function allocator.grow(memory, num)
			if num == 0 then return memory.min end

			local old = memory.min
			local new = old + num

			if new > memory.max then
				return -1
			else
				grow_unchecked(memory, old * WASM_PAGE_SIZE, new * WASM_PAGE_SIZE)
				memory.min = new

				return old
			end
		end

		function allocator.copy(memory, destination, source, size)
			local dest_pointer = by_offset(memory.data, destination)
			local src_pointer = by_offset(memory.data, source)

			ffi.copy(dest_pointer, src_pointer, size)
		end

		module.load = load
		module.store = store
		module.allocator = allocator
	end

	return module
end)()
local abs_f32 = math.abs
local abs_f64 = math.abs
local add_i32 = rt.add.i32
local band_i32 = bit.band
local band_i64 = bit.band
local bor_i32 = bit.bor
local bor_i64 = bit.bor
local bxor_i32 = bit.bxor
local bxor_i64 = bit.bxor
local ceil_f64 = math.ceil
local clz_i32 = rt.clz.i32
local clz_i64 = rt.clz.i64
local convert_f32_i32 = rt.convert.f32_i32
local convert_f64_i32 = rt.convert.f64_i32
local convert_f64_i64 = tonumber
local convert_f64_u32 = rt.convert.f64_u32
local convert_f64_u64 = rt.convert.f64_u64
local copysign_f64 = rt.copysign.f64
local ctz_i32 = rt.ctz.i32
local demote_f32_f64 = rt.demote.f32_f64
local div_i32 = rt.div.i32
local div_u32 = rt.div.u32
local div_u64 = rt.div.u64
local extend_i64_i32 = rt.extend.i64_i32
local extend_i64_u32 = rt.extend.i64_u32
local floor_f32 = math.floor
local floor_f64 = math.floor
local ge_u32 = rt.ge.u32
local ge_u64 = rt.ge.u64
local gt_u32 = rt.gt.u32
local gt_u64 = rt.gt.u64
local le_u32 = rt.le.u32
local le_u64 = rt.le.u64
local load_f32 = rt.load.f32
local load_f64 = rt.load.f64
local load_i32 = rt.load.i32
local load_i32_i16 = rt.load.i32_i16
local load_i32_i8 = rt.load.i32_i8
local load_i32_u16 = rt.load.i32_u16
local load_i32_u8 = rt.load.i32_u8
local load_i64 = rt.load.i64
local load_i64_i16 = rt.load.i64_i16
local load_i64_i32 = rt.load.i64_i32
local load_i64_i8 = rt.load.i64_i8
local load_i64_u16 = rt.load.i64_u16
local load_i64_u32 = rt.load.i64_u32
local load_i64_u8 = rt.load.i64_u8
local lt_u32 = rt.lt.u32
local lt_u64 = rt.lt.u64
local mul_i32 = rt.mul.i32
local neg_f32 = rt.neg.f32
local neg_f64 = rt.neg.f64
local promote_f64_f32 = rt.promote.f64_f32
local reinterpret_f64_i64 = rt.reinterpret.f64_i64
local reinterpret_i32_f32 = rt.reinterpret.i32_f32
local reinterpret_i64_f64 = rt.reinterpret.i64_f64
local rem_i32 = math.fmod
local rem_u32 = rt.rem.u32
local rotl_i32 = bit.rol
local rotl_i64 = bit.rol
local rotr_i32 = bit.ror
local shl_i32 = bit.lshift
local shl_i64 = bit.lshift
local shr_i32 = bit.arshift
local shr_i64 = bit.arshift
local shr_u32 = bit.rshift
local shr_u64 = bit.rshift
local sqrt_f64 = math.sqrt
local store_f32 = rt.store.f32
local store_f64 = rt.store.f64
local store_i32 = rt.store.i32
local store_i32_n16 = rt.store.i32_n16
local store_i32_n8 = rt.store.i32_n8
local store_i64 = rt.store.i64
local store_i64_n32 = rt.store.i64_n32
local store_i64_n8 = rt.store.i64_n8
local sub_i32 = rt.sub.i32
local truncate_i32_f32 = rt.truncate.i32_f32
local truncate_i32_f64 = rt.truncate.i32_f64
local truncate_i64_f64 = rt.truncate.i64_f64
local truncate_u32_f64 = rt.truncate.u32_f64
local truncate_u64_f64 = rt.truncate.u64_f64
local wrap_i32_i64 = rt.wrap.i32_i64
local memory_at_0
local table_new = require("table.new")
local FUNC_LIST = table_new(1436, 1)
local TABLE_LIST = table_new(0, 1)
local MEMORY_LIST = table_new(0, 1)
local GLOBAL_LIST = table_new(0, 1)
FUNC_LIST[35] = --[[ __wasm_call_ctors ]] function()
	FUNC_LIST[178]()
	FUNC_LIST[179]()
	FUNC_LIST[180]()
	FUNC_LIST[181]()
	FUNC_LIST[182]()
	FUNC_LIST[183]()
	FUNC_LIST[184]()
	FUNC_LIST[185]()
	FUNC_LIST[186]()
	FUNC_LIST[187]()
	FUNC_LIST[188]()
	FUNC_LIST[189]()
	FUNC_LIST[190]()
	FUNC_LIST[191]()
	FUNC_LIST[192]()
	FUNC_LIST[193]()
	FUNC_LIST[194]()
	FUNC_LIST[195]()
	FUNC_LIST[196]()
	FUNC_LIST[197]()
	FUNC_LIST[198]()
	FUNC_LIST[199]()
	FUNC_LIST[200]()
	FUNC_LIST[201]()
	FUNC_LIST[202]()
	FUNC_LIST[203]()
	FUNC_LIST[204]()
	FUNC_LIST[205]()
	FUNC_LIST[206]()
	FUNC_LIST[207]()
	FUNC_LIST[208]()
	FUNC_LIST[209]()
	FUNC_LIST[210]()
	FUNC_LIST[211]()
	FUNC_LIST[212]()
	FUNC_LIST[213]()
	FUNC_LIST[214]()
	FUNC_LIST[215]()
	FUNC_LIST[216]()
	FUNC_LIST[217]()
	FUNC_LIST[218]()
	FUNC_LIST[219]()
	FUNC_LIST[220]()
	FUNC_LIST[221]()
	FUNC_LIST[222]()
	FUNC_LIST[223]()
	FUNC_LIST[224]()
	FUNC_LIST[225]()
	FUNC_LIST[226]()
	FUNC_LIST[227]()
	FUNC_LIST[391]()
	FUNC_LIST[655]()
	FUNC_LIST[1097]()
	FUNC_LIST[1179]()
end
FUNC_LIST[36] = --[[ executeScript ]] function(param_0)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local reg_0
	loc_1 = sub_i32(GLOBAL_LIST[0].value, 336)
	GLOBAL_LIST[0].value = loc_1
	loc_3 = load_i32(memory_at_0, 54880)
	if loc_3 ~= 0 then
		::continue_at_2::
		while true do
			reg_0 = FUNC_LIST[1199](load_i32(memory_at_0, loc_3 + 4), 1535, 4)
			if reg_0 == 0 then store_i32_n8(memory_at_0, loc_3, 1) end
			loc_3 = load_i32(memory_at_0, loc_3 + 8)
			if loc_3 ~= 0 then goto continue_at_2 end
			break
		end
	end
	reg_0 = FUNC_LIST[610]()
	loc_3 = reg_0
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[0](1, loc_3)
	loc_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_0 == 1 then goto continue_at_13 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[0](2, loc_3)
	loc_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_0 == 1 then goto continue_at_13 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[0](3, loc_3)
	loc_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_0 == 1 then goto continue_at_13 end
	if load_i32_u8(memory_at_0, 54896) == 0 then
		store_i64(memory_at_0, 54884, 0LL )
		store_i32(memory_at_0, 54892, 0)
		reg_0 = FUNC_LIST[1102](4, 0, 1024)
		store_i32_n8(memory_at_0, 54896, 1)
	end
	reg_0 = FUNC_LIST[1197](param_0)
	loc_0 = reg_0
	if ge_u32(loc_0, -16) then
		store_i32(memory_at_0, 61960, 0)
		FUNC_LIST[0](5, loc_1)
		loc_1 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_1 == 1 then goto continue_at_12 end
		goto continue_at_4
	end
	if ge_u32(loc_0, 11) then
		store_i32(memory_at_0, 61960, 0)
		loc_5 = band_i32(add_i32(loc_0, 16), -16)
		reg_0 = FUNC_LIST[1](6, loc_5)
		loc_2 = reg_0
		loc_4 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_4 == 1 then goto continue_at_12 end
		store_i32(memory_at_0, loc_1, loc_2)
		store_i32(memory_at_0, loc_1 + 4, loc_0)
		store_i32(memory_at_0, loc_1 + 8, bor_i32(loc_5, -2147483648))
		goto continue_at_17
	end
	store_i32_n8(memory_at_0, loc_1 + 11, loc_0)
	loc_2 = loc_1
	if loc_0 == 0 then goto continue_at_16 end
	::continue_at_17::
	reg_0 = FUNC_LIST[1119](loc_2, param_0, loc_0)
	::continue_at_16::
	store_i32_n8(memory_at_0, add_i32(loc_0, loc_2), 0)
	store_i32(memory_at_0, 61960, 0)
	store_i32(memory_at_0, loc_1 + 332, 0)
	loc_0 = load_i32_i8(memory_at_0, loc_1 + 11)
	loc_2 = (loc_0 < 0 and 1 or 0)
	reg_0 = FUNC_LIST[2](
		7, (loc_2 ~= 0 and load_i32(memory_at_0, loc_1) or loc_1),
			(loc_2 ~= 0 and load_i32(memory_at_0, loc_1 + 4) or band_i32(loc_0, 255)), 0,
			add_i32(loc_1, 332)
	)
	loc_0 = reg_0
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_7 end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[3](
		8, loc_3, 4260, loc_0, load_i32(memory_at_0, loc_1 + 332), 0
	)
	param_0 = reg_0
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_7 end
	FUNC_LIST[1252](loc_0)
	if param_0 ~= 0 then
		store_i32(memory_at_0, 61960, 0)
		reg_0 = FUNC_LIST[4](9, loc_3, -1, add_i32(loc_1, 48))
		param_0 = reg_0
		loc_0 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_0 == 1 then goto continue_at_7 end
		loc_0 = load_i32(memory_at_0, loc_1 + 48)
		if ge_u32(loc_0, -16) then
			store_i32(memory_at_0, 61960, 0)
			FUNC_LIST[0](5, add_i32(loc_1, 16))
			loc_0 = load_i32(memory_at_0, 61960)
			store_i32(memory_at_0, 61960, 0)
			if loc_0 ~= 1 then goto continue_at_4 end
			goto continue_at_7
		end
		if ge_u32(loc_0, 11) then
			store_i32(memory_at_0, 61960, 0)
			loc_5 = band_i32(add_i32(loc_0, 16), -16)
			reg_0 = FUNC_LIST[1](6, loc_5)
			loc_2 = reg_0
			loc_4 = load_i32(memory_at_0, 61960)
			store_i32(memory_at_0, 61960, 0)
			if loc_4 == 1 then goto continue_at_7 end
			store_i32(memory_at_0, loc_1 + 16, loc_2)
			store_i32(memory_at_0, loc_1 + 20, loc_0)
			store_i32(memory_at_0, loc_1 + 24, bor_i32(loc_5, -2147483648))
			goto continue_at_22
		end
		store_i32_n8(memory_at_0, loc_1 + 27, loc_0)
		loc_2 = add_i32(loc_1, 16)
		if loc_0 == 0 then goto continue_at_21 end
		::continue_at_22::
		reg_0 = FUNC_LIST[1119](loc_2, param_0, loc_0)
		::continue_at_21::
		store_i32_n8(memory_at_0, add_i32(loc_0, loc_2), 0)
		store_i32(memory_at_0, 61960, 0)
		FUNC_LIST[402](loc_3, -2)
		loc_0 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_0 ~= 1 then goto continue_at_8 end
		reg_0 = FUNC_LIST[6]()
		loc_0 = reg_0
		reg_0 = FUNC_LIST[7]()
		if load_i32_i8(memory_at_0, loc_1 + 27) >= 0 then goto continue_at_6 end
		FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 16))
		goto continue_at_6
	end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[1](11, loc_3)
	loc_0 = reg_0
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_7 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[406](loc_3, -2)
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_7 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[403](loc_3, -3)
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_7 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[398](loc_3, loc_0, 1)
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_7 end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[4](15, loc_0, 0, 0)
	loc_2 = reg_0
	param_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if param_0 == 1 then goto continue_at_7 end
	if loc_2 == 0 then
		store_i32(memory_at_0, 61960, 0)
		reg_0 = FUNC_LIST[401](loc_0)
		loc_2 = reg_0
		param_0 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if param_0 == 1 then goto continue_at_7 end
		if loc_2 ~= 0 then
			store_i32(memory_at_0, 61960, 0)
			FUNC_LIST[8](17, loc_0, 20, 1838)
			param_0 = load_i32(memory_at_0, 61960)
			store_i32(memory_at_0, 61960, 0)
			if param_0 == 1 then goto continue_at_7 end
			store_i32(memory_at_0, 61960, 0)
			reg_0 = FUNC_LIST[4](18, loc_0, -10002, 1858)
			param_0 = load_i32(memory_at_0, 61960)
			store_i32(memory_at_0, 61960, 0)
			if param_0 == 1 then goto continue_at_7 end
			store_i32(memory_at_0, 61960, 0)
			FUNC_LIST[404](loc_0, 1)
			param_0 = load_i32(memory_at_0, 61960)
			store_i32(memory_at_0, 61960, 0)
			if param_0 == 1 then goto continue_at_7 end
			store_i32(memory_at_0, 61960, 0)
			reg_0 = FUNC_LIST[2](20, loc_0, loc_2, 0, 0)
			loc_0 = load_i32(memory_at_0, 61960)
			store_i32(memory_at_0, 61960, 0)
			if loc_0 == 1 then goto continue_at_7 end
		end
		store_i32(memory_at_0, 61960, 0)
		FUNC_LIST[402](loc_3, -2)
		loc_0 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_0 == 1 then goto continue_at_7 end
		store_i32(memory_at_0, loc_1 + 24, 0)
		store_i64(memory_at_0, loc_1 + 16, 0LL )
		goto continue_at_8
	end
	store_i32(memory_at_0, loc_1 + 24, 0)
	store_i64(memory_at_0, loc_1 + 16, 0LL )
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[2](21, loc_3, 0, 4210, add_i32(loc_1, 48))
	loc_4 = reg_0
	param_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if param_0 == 1 then goto continue_at_10 end
	if loc_4 == 0 then goto continue_at_26 end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[9](22, add_i32(loc_1, 16), add_i32(loc_1, 71))
	param_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if param_0 == 1 then goto continue_at_10 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[5](23, add_i32(loc_1, 16), 58)
	param_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if param_0 == 1 then goto continue_at_10 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[5](24, add_i32(loc_1, 32), load_i32(memory_at_0, loc_1 + 64))
	param_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if param_0 ~= 1 then
		store_i32(memory_at_0, 61960, 0)
		param_0 = load_i32_u8(memory_at_0, loc_1 + 43)
		loc_4 = (shr_i32(shl_i32(param_0, 24), 24) < 0 and 1 or 0)
		reg_0 = FUNC_LIST[4](
			25, add_i32(loc_1, 16),
				(loc_4 ~= 0 and load_i32(memory_at_0, loc_1 + 32) or add_i32(loc_1, 32)),
				(loc_4 ~= 0 and load_i32(memory_at_0, loc_1 + 36) or param_0)
		)
		param_0 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if param_0 == 1 then goto continue_at_27 end
		if load_i32_i8(memory_at_0, loc_1 + 43) < 0 then
			FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 32))
		end
		store_i32(memory_at_0, 61960, 0)
		reg_0 = FUNC_LIST[9](22, add_i32(loc_1, 16), 10464)
		param_0 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if param_0 ~= 1 then goto continue_at_26 end
		goto continue_at_10
	end
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	goto continue_at_9
	::continue_at_27::
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	if load_i32_i8(memory_at_0, loc_1 + 43) >= 0 then goto continue_at_9 end
	FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 32))
	goto continue_at_9
	::continue_at_26::
	if loc_2 == 1 then
		store_i32(memory_at_0, 61960, 0)
		reg_0 = FUNC_LIST[9](22, add_i32(loc_1, 16), 1211)
		loc_2 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_2 == 1 then goto continue_at_10 end
		goto continue_at_11
	end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[4](9, loc_0, -1, 0)
	loc_2 = reg_0
	param_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if param_0 ~= 1 then
		if loc_2 == 0 then goto continue_at_11 end
		store_i32(memory_at_0, 61960, 0)
		reg_0 = FUNC_LIST[9](22, add_i32(loc_1, 16), loc_2)
		loc_2 = load_i32(memory_at_0, 61960)
		store_i32(memory_at_0, 61960, 0)
		if loc_2 ~= 1 then goto continue_at_11 end
	end
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	goto continue_at_9
	::continue_at_13::
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	goto continue_at_5
	::continue_at_12::
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	goto continue_at_5
	::continue_at_11::
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[9](22, add_i32(loc_1, 16), 10470)
	loc_2 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_2 == 1 then goto continue_at_10 end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[1](26, loc_0)
	loc_2 = reg_0
	loc_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_0 == 1 then goto continue_at_10 end
	store_i32(memory_at_0, 61960, 0)
	reg_0 = FUNC_LIST[9](22, add_i32(loc_1, 16), loc_2)
	loc_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_0 == 1 then goto continue_at_10 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[402](loc_3, -2)
	loc_0 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_0 ~= 1 then goto continue_at_8 end
	::continue_at_10::
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	::continue_at_9::
	if load_i32_i8(memory_at_0, loc_1 + 27) >= 0 then goto continue_at_6 end
	FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 16))
	goto continue_at_6
	::continue_at_8::
	if load_i32_i8(memory_at_0, 54895) < 0 then
		FUNC_LIST[1276](load_i32(memory_at_0, 54884))
	end
	store_i64(memory_at_0, 54884, load_i64(memory_at_0, loc_1 + 16))
	store_i32(memory_at_0, 54892, load_i32(memory_at_0, loc_1 + 24))
	store_i32_n8(memory_at_0, loc_1 + 16, 0)
	store_i32_n8(memory_at_0, loc_1 + 27, 0)
	if load_i32_i8(memory_at_0, loc_1 + 11) < 0 then
		FUNC_LIST[1276](load_i32(memory_at_0, loc_1))
	end
	loc_0 = load_i32_i8(memory_at_0, 54895)
	loc_2 = load_i32(memory_at_0, 54884)
	param_0 = load_i32(memory_at_0, 54888)
	if loc_3 == 0 then goto continue_at_34 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[0](27, loc_3)
	loc_3 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_3 ~= 1 then goto continue_at_34 end
	reg_0 = FUNC_LIST[10](0)
	reg_0 = FUNC_LIST[7]()
	FUNC_LIST[1391]()
	error("out of code bounds")
	::continue_at_34::
	GLOBAL_LIST[0].value = add_i32(loc_1, 336)
	loc_3 = (loc_0 < 0 and 1 or 0)
	reg_0 = ((loc_3 ~= 0 and param_0 or band_i32(loc_0, 255)) ~= 0 and
		        (loc_3 ~= 0 and loc_2 or 54884) or 0)
	goto continue_at_0
	::continue_at_7::
	reg_0 = FUNC_LIST[6]()
	loc_0 = reg_0
	reg_0 = FUNC_LIST[7]()
	::continue_at_6::
	if load_i32_i8(memory_at_0, loc_1 + 11) >= 0 then goto continue_at_5 end
	FUNC_LIST[1276](load_i32(memory_at_0, loc_1))
	::continue_at_5::
	if loc_3 == 0 then goto continue_at_35 end
	store_i32(memory_at_0, 61960, 0)
	FUNC_LIST[0](27, loc_3)
	loc_3 = load_i32(memory_at_0, 61960)
	store_i32(memory_at_0, 61960, 0)
	if loc_3 ~= 1 then goto continue_at_35 end
	reg_0 = FUNC_LIST[10](0)
	reg_0 = FUNC_LIST[7]()
	FUNC_LIST[1391]()
	error("out of code bounds")
	::continue_at_35::
	FUNC_LIST[11](loc_0)
	error("out of code bounds")
	::continue_at_4::
	error("out of code bounds")
	::continue_at_0::
	return reg_0
end
FUNC_LIST[37] = --[[ __cxx_global_array_dtor ]] function(param_0)
	if load_i32_i8(memory_at_0, 54895) < 0 then
		FUNC_LIST[1276](load_i32(memory_at_0, 54884))
	end
end
FUNC_LIST[38] = --[[ std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1299](param_0)
		error("out of code bounds")
	end
FUNC_LIST[39] = --[[ Luau::Compile::assignMutable(Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> >&, Luau::AstNameTable const&, char const**) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		reg_0 = FUNC_LIST[973](param_1, 7863)
		loc_1 = reg_0
		if loc_1 ~= 0 then
			loc_2 = load_i32(memory_at_0, param_0)
			loc_0 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_2), 3)
			if ge_u32(load_i32(memory_at_0, param_0 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
				FUNC_LIST[40](param_0)
				loc_2 = load_i32(memory_at_0, param_0)
				loc_0 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_2), 3)
			end
			loc_6 = sub_i32(loc_0, 1)
			loc_0 = band_i32(loc_6, bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9)))
			loc_3 = add_i32(loc_2, shl_i32(loc_0, 3))
			loc_4 = load_i32(memory_at_0, loc_3)
			loc_7 = load_i32(memory_at_0, param_0 + 16)
			if loc_4 ~= loc_7 then
				::continue_at_5::
				while true do
					if loc_1 == loc_4 then goto continue_at_3 end
					loc_5 = add_i32(loc_5, 1)
					loc_0 = band_i32(add_i32(loc_5, loc_0), loc_6)
					loc_3 = add_i32(loc_2, shl_i32(loc_0, 3))
					loc_4 = load_i32(memory_at_0, loc_3)
					if loc_4 ~= loc_7 then goto continue_at_5 end
					break
				end
			end
			store_i32(memory_at_0, loc_3, loc_1)
			store_i32(
				memory_at_0, param_0 + 12, add_i32(load_i32(memory_at_0, param_0 + 12), 1)
			)
			::continue_at_3::
			store_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 3)) + 4, 1)
		end
		if param_2 == 0 then goto continue_at_6 end
		loc_0 = load_i32(memory_at_0, param_2)
		if loc_0 == 0 then goto continue_at_6 end
		::continue_at_7::
		while true do
			reg_0 = FUNC_LIST[973](param_1, loc_0)
			loc_1 = reg_0
			if loc_1 ~= 0 then
				loc_5 = 0
				loc_2 = load_i32(memory_at_0, param_0)
				loc_0 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_2), 3)
				if ge_u32(load_i32(memory_at_0, param_0 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
					FUNC_LIST[40](param_0)
					loc_2 = load_i32(memory_at_0, param_0)
					loc_0 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_2), 3)
				end
				loc_6 = sub_i32(loc_0, 1)
				loc_0 = band_i32(loc_6, bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9)))
				loc_3 = add_i32(loc_2, shl_i32(loc_0, 3))
				loc_4 = load_i32(memory_at_0, loc_3)
				loc_7 = load_i32(memory_at_0, param_0 + 16)
				if loc_4 ~= loc_7 then
					::continue_at_12::
					while true do
						if loc_1 == loc_4 then goto continue_at_10 end
						loc_5 = add_i32(loc_5, 1)
						loc_0 = band_i32(add_i32(loc_5, loc_0), loc_6)
						loc_3 = add_i32(loc_2, shl_i32(loc_0, 3))
						loc_4 = load_i32(memory_at_0, loc_3)
						if loc_4 ~= loc_7 then goto continue_at_12 end
						break
					end
				end
				store_i32(memory_at_0, loc_3, loc_1)
				store_i32(
					memory_at_0, param_0 + 12, add_i32(load_i32(memory_at_0, param_0 + 12), 1)
				)
				::continue_at_10::
				store_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 3)) + 4, 1)
			end
			loc_0 = load_i32(memory_at_0, param_2 + 4)
			param_2 = add_i32(param_2, 4)
			if loc_0 ~= 0 then goto continue_at_7 end
			break
		end
		::continue_at_6::
	end
FUNC_LIST[40] = --[[ Luau::detail::DenseHashTable<Luau::AstName, std::__2::pair<Luau::AstName, Luau::Compile::Global>, std::__2::pair<Luau::AstName const, Luau::Compile::Global>, Luau::detail::ItemInterfaceMap<Luau::AstName, Luau::Compile::Global>, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_4 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_4 then
			if gt_u32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 127) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_2 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 16, loc_2)
			loc_9 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_2 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_2)
		loc_9 = add_i32(param_0, 16)
		reg_0 = shr_i32(sub_i32(loc_4, loc_1), 2)
		::continue_at_4::
		loc_1 = reg_0
		store_i32(memory_at_0, loc_0 + 28, 0)
		store_i32(memory_at_0, loc_0 + 24, loc_2)
		FUNC_LIST[52](loc_0, loc_1, add_i32(loc_0, 24))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_3 then
			loc_3 = loc_1
			goto continue_at_2
		end
		loc_10 = load_i32(memory_at_0, loc_0 + 12)
		::continue_at_7::
		while true do
			loc_11 = shl_i32(loc_5, 3)
			loc_2 = load_i32(memory_at_0, add_i32(loc_3, loc_11))
			if loc_2 ~= load_i32(memory_at_0, loc_9) then
				loc_6 = load_i32(memory_at_0, loc_0)
				loc_12 = sub_i32(
					shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_6), 3), 1
				)
				loc_1 = band_i32(loc_12, bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9)))
				loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
				loc_8 = load_i32(memory_at_0, loc_7)
				loc_13 = load_i32(memory_at_0, loc_0 + 16)
				if loc_8 == loc_13 then goto continue_at_10 end
				loc_4 = 0
				if loc_2 == loc_8 then goto continue_at_9 end
				::continue_at_11::
				while true do
					loc_4 = add_i32(loc_4, 1)
					loc_1 = band_i32(add_i32(loc_4, loc_1), loc_12)
					loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
					loc_8 = load_i32(memory_at_0, loc_7)
					if loc_8 == loc_13 then goto continue_at_10 end
					if loc_2 ~= loc_8 then goto continue_at_11 end
					break
				end
				goto continue_at_9
				::continue_at_10::
				store_i32(memory_at_0, loc_7, loc_2)
				loc_10 = add_i32(loc_10, 1)
				store_i32(memory_at_0, loc_0 + 12, loc_10)
				loc_3 = load_i32(memory_at_0, param_0)
				loc_2 = load_i32(memory_at_0, add_i32(loc_3, loc_11))
				::continue_at_9::
				store_i32(memory_at_0, loc_7, loc_2)
				store_i32(
					memory_at_0, add_i32(loc_6, shl_i32(loc_1, 3)) + 4,
						load_i32(memory_at_0, add_i32(loc_3, loc_11) + 4)
				)
				loc_3 = load_i32(memory_at_0, param_0)
				loc_1 = load_i32(memory_at_0, param_0 + 4)
			end
			loc_5 = add_i32(loc_5, 1)
			if lt_u32(loc_5, shr_i32(sub_i32(loc_1, loc_3), 3)) then goto continue_at_7 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 4, 0)
		store_i32(memory_at_0, loc_0, loc_1)
		FUNC_LIST[52](param_0, 16, loc_0)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_3)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		if loc_3 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		FUNC_LIST[1276](loc_3)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	end
FUNC_LIST[41] = --[[ Luau::Compile::trackValues(Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> >&, Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Variable, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >&, Luau::AstNode*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		store_i32(memory_at_0, loc_0 + 8, param_1)
		store_i32(memory_at_0, loc_0 + 4, param_0)
		store_i32(memory_at_0, loc_0, 10516)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_2))](
			param_2, loc_0
		)
		GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	end
FUNC_LIST[42] = --[[ Luau::Compile::ValueVisitor::~ValueVisitor() ]] function(
	param_0
) FUNC_LIST[1276](param_0) end
FUNC_LIST[43] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 32)
		if loc_0 == 0 then goto continue_at_1 end
		if load_i32(memory_at_0, param_1 + 40) == 0 then goto continue_at_2 end
		::continue_at_3::
		while true do
			loc_0 = shl_i32(loc_4, 2)
			loc_2 = add_i32(loc_0, load_i32(memory_at_0, param_1 + 28))
			loc_10 = load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 36), loc_0)
			)
			loc_6 = 0
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			loc_3 = load_i32(memory_at_0, loc_1)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_3), 12)
			if ge_u32(load_i32(memory_at_0, loc_1 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
				FUNC_LIST[44](loc_1)
				loc_3 = load_i32(memory_at_0, loc_1)
				loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_3), 12)
			end
			loc_8 = sub_i32(loc_0, 1)
			loc_5 = load_i32(memory_at_0, loc_2)
			loc_0 = band_i32(loc_8, bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9)))
			loc_7 = add_i32(loc_3, mul_i32(loc_0, 12))
			loc_2 = load_i32(memory_at_0, loc_7)
			loc_9 = load_i32(memory_at_0, loc_1 + 16)
			if loc_2 ~= loc_9 then
				::continue_at_7::
				while true do
					if loc_2 == loc_5 then goto continue_at_5 end
					loc_6 = add_i32(loc_6, 1)
					loc_0 = band_i32(add_i32(loc_6, loc_0), loc_8)
					loc_7 = add_i32(loc_3, mul_i32(loc_0, 12))
					loc_2 = load_i32(memory_at_0, loc_7)
					if loc_2 ~= loc_9 then goto continue_at_7 end
					break
				end
			end
			store_i32(memory_at_0, loc_7, loc_5)
			store_i32(
				memory_at_0, loc_1 + 12, add_i32(load_i32(memory_at_0, loc_1 + 12), 1)
			)
			::continue_at_5::
			store_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_0, 12)) + 4, loc_10)
			loc_4 = add_i32(loc_4, 1)
			loc_0 = load_i32(memory_at_0, param_1 + 32)
			if ge_u32(loc_4, loc_0) then goto continue_at_2 end
			if lt_u32(loc_4, load_i32(memory_at_0, param_1 + 40)) then
				goto continue_at_3
			end
			break
		end
		::continue_at_2::
		loc_4 = load_i32(memory_at_0, param_1 + 40)
		if ge_u32(loc_4, loc_0) then goto continue_at_1 end
		::continue_at_8::
		while true do
			loc_2 = add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_4, 2))
			loc_6 = 0
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			loc_3 = load_i32(memory_at_0, loc_1)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_3), 12)
			if ge_u32(load_i32(memory_at_0, loc_1 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
				FUNC_LIST[44](loc_1)
				loc_3 = load_i32(memory_at_0, loc_1)
				loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_3), 12)
			end
			loc_8 = sub_i32(loc_0, 1)
			loc_5 = load_i32(memory_at_0, loc_2)
			loc_0 = band_i32(loc_8, bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9)))
			loc_7 = add_i32(loc_3, mul_i32(loc_0, 12))
			loc_2 = load_i32(memory_at_0, loc_7)
			loc_9 = load_i32(memory_at_0, loc_1 + 16)
			if loc_2 ~= loc_9 then
				::continue_at_12::
				while true do
					if loc_2 == loc_5 then goto continue_at_10 end
					loc_6 = add_i32(loc_6, 1)
					loc_0 = band_i32(add_i32(loc_6, loc_0), loc_8)
					loc_7 = add_i32(loc_3, mul_i32(loc_0, 12))
					loc_2 = load_i32(memory_at_0, loc_7)
					if loc_2 ~= loc_9 then goto continue_at_12 end
					break
				end
			end
			store_i32(memory_at_0, loc_7, loc_5)
			store_i32(
				memory_at_0, loc_1 + 12, add_i32(load_i32(memory_at_0, loc_1 + 12), 1)
			)
			::continue_at_10::
			store_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_0, 12)) + 4, 0)
			loc_4 = add_i32(loc_4, 1)
			if lt_u32(loc_4, load_i32(memory_at_0, param_1 + 32)) then
				goto continue_at_8
			end
			break
		end
		::continue_at_1::
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[44] = --[[ Luau::detail::DenseHashTable<Luau::AstLocal*, std::__2::pair<Luau::AstLocal*, Luau::Compile::Variable>, std::__2::pair<Luau::AstLocal* const, Luau::Compile::Variable>, Luau::detail::ItemInterfaceMap<Luau::AstLocal*, Luau::Compile::Variable>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 12), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 16, 0LL )
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			loc_4 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 24, loc_4)
			loc_8 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		loc_8 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_2, loc_1), 12), 1)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 36, 0LL )
		store_i32(memory_at_0, loc_0 + 32, loc_4)
		FUNC_LIST[50](add_i32(loc_0, 8), loc_1, add_i32(loc_0, 32))
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_2 == loc_1 then
			loc_1 = loc_2
			goto continue_at_2
		end
		loc_9 = load_i32(memory_at_0, loc_0 + 8)
		::continue_at_7::
		while true do
			loc_7 = add_i32(loc_1, mul_i32(loc_6, 12))
			loc_3 = load_i32(memory_at_0, loc_7)
			if loc_3 ~= load_i32(memory_at_0, loc_8) then
				loc_2 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
				loc_4 = sub_i32(
					div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 12), loc_9), 12), 1
				)
				loc_1 = 0
				loc_10 = load_i32(memory_at_0, loc_0 + 24)
				::continue_at_10::
				while true do
					loc_11 = band_i32(loc_2, loc_4)
					loc_5 = add_i32(loc_9, mul_i32(loc_11, 12))
					loc_2 = load_i32(memory_at_0, loc_5)
					if loc_10 == loc_2 then
						store_i32(memory_at_0, loc_5, loc_3)
						store_i32(
							memory_at_0, loc_0 + 20, add_i32(load_i32(memory_at_0, loc_0 + 20), 1)
						)
						loc_3 = load_i32(memory_at_0, loc_7)
						goto continue_at_9
					end
					if loc_2 == loc_3 then goto continue_at_9 end
					loc_1 = add_i32(loc_1, 1)
					loc_2 = add_i32(loc_1, loc_11)
					if le_u32(loc_1, loc_4) then goto continue_at_10 end
					break
				end
				loc_5 = 0
				::continue_at_9::
				store_i32(memory_at_0, loc_5, loc_3)
				store_i32(memory_at_0, loc_5 + 4, load_i32(memory_at_0, loc_7 + 4))
				store_i32_n16(memory_at_0, loc_5 + 8, load_i32_u16(memory_at_0, loc_7 + 8))
				loc_2 = load_i32(memory_at_0, param_0 + 4)
				loc_1 = load_i32(memory_at_0, param_0)
			end
			loc_6 = add_i32(loc_6, 1)
			if lt_u32(loc_6, div_i32(sub_i32(loc_2, loc_1), 12)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 12, 0LL )
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		FUNC_LIST[50](param_0, 16, add_i32(loc_0, 8))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 12))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 16))
		store_i32(memory_at_0, loc_0 + 16, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 12, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[45] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatAssign*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		if load_i32(memory_at_0, param_1 + 32) ~= 0 then
			::continue_at_2::
			while true do
				FUNC_LIST[46](
					param_0, load_i32(
						memory_at_0,
							add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
					)
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 32)) then
					goto continue_at_2
				end
				break
			end
		end
		if load_i32(memory_at_0, param_1 + 40) ~= 0 then
			loc_0 = 0
			::continue_at_4::
			while true do
				loc_1 = load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 36), shl_i32(loc_0, 2))
				)
				TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_1))](
					loc_1, param_0
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 40)) then
					goto continue_at_4
				end
				break
			end
		end
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[46] = --[[ Luau::Compile::ValueVisitor::assign(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		loc_1 = load_i32(memory_at_0, param_1 + 4)
		if param_1 == 0 then goto continue_at_1 end
		if loc_1 ~= load_i32(memory_at_0, 54940) then goto continue_at_1 end
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, loc_0)
		loc_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_2), 12)
		if ge_u32(load_i32(memory_at_0, loc_0 + 12), shr_u32(mul_i32(loc_1, 3), 2)) then
			FUNC_LIST[44](loc_0)
			loc_2 = load_i32(memory_at_0, loc_0)
			loc_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_2), 12)
		end
		loc_5 = sub_i32(loc_1, 1)
		loc_3 = load_i32(memory_at_0, param_1 + 24)
		param_1 = band_i32(loc_5, bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9)))
		loc_4 = add_i32(loc_2, mul_i32(param_1, 12))
		loc_1 = load_i32(memory_at_0, loc_4)
		loc_6 = load_i32(memory_at_0, loc_0 + 16)
		if loc_1 ~= loc_6 then
			param_0 = 0
			::continue_at_5::
			while true do
				if loc_1 == loc_3 then goto continue_at_3 end
				param_0 = add_i32(param_0, 1)
				param_1 = band_i32(add_i32(param_0, param_1), loc_5)
				loc_4 = add_i32(loc_2, mul_i32(param_1, 12))
				loc_1 = load_i32(memory_at_0, loc_4)
				if loc_1 ~= loc_6 then goto continue_at_5 end
				break
			end
		end
		store_i32(memory_at_0, loc_4, loc_3)
		store_i32(
			memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
		)
		::continue_at_3::
		store_i32_n8(memory_at_0, add_i32(loc_2, mul_i32(param_1, 12)) + 8, 1)
		goto continue_at_0
		::continue_at_1::
		if param_1 == 0 then goto continue_at_6 end
		if loc_1 ~= load_i32(memory_at_0, 54948) then goto continue_at_6 end
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		loc_2 = load_i32(memory_at_0, loc_0)
		loc_1 = shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_2), 3)
		if ge_u32(load_i32(memory_at_0, loc_0 + 12), shr_u32(mul_i32(loc_1, 3), 2)) then
			FUNC_LIST[40](loc_0)
			loc_2 = load_i32(memory_at_0, loc_0)
			loc_1 = shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_2), 3)
		end
		loc_5 = sub_i32(loc_1, 1)
		loc_3 = load_i32(memory_at_0, param_1 + 24)
		param_1 = band_i32(loc_5, bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9)))
		loc_4 = add_i32(loc_2, shl_i32(param_1, 3))
		loc_1 = load_i32(memory_at_0, loc_4)
		loc_6 = load_i32(memory_at_0, loc_0 + 16)
		if loc_1 ~= loc_6 then
			param_0 = 0
			::continue_at_10::
			while true do
				if loc_1 == loc_3 then goto continue_at_8 end
				param_0 = add_i32(param_0, 1)
				param_1 = band_i32(add_i32(param_0, param_1), loc_5)
				loc_4 = add_i32(loc_2, shl_i32(param_1, 3))
				loc_1 = load_i32(memory_at_0, loc_4)
				if loc_1 ~= loc_6 then goto continue_at_10 end
				break
			end
		end
		store_i32(memory_at_0, loc_4, loc_3)
		store_i32(
			memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
		)
		::continue_at_8::
		store_i32(memory_at_0, add_i32(loc_2, shl_i32(param_1, 3)) + 4, 2)
		goto continue_at_0
		::continue_at_6::
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, param_0
		)
		::continue_at_0::
	end
FUNC_LIST[47] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatCompoundAssign*) ]]
	function(param_0, param_1)
		local reg_0
		FUNC_LIST[46](param_0, load_i32(memory_at_0, param_1 + 32))
		param_1 = load_i32(memory_at_0, param_1 + 36)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, param_0
		)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[48] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatFunction*) ]]
	function(param_0, param_1)
		local reg_0
		FUNC_LIST[46](param_0, load_i32(memory_at_0, param_1 + 28))
		param_1 = load_i32(memory_at_0, param_1 + 32)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, param_0
		)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[49] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatLocalFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_5 = load_i32(memory_at_0, param_1 + 32)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, loc_0)
		param_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_1), 12)
		if ge_u32(load_i32(memory_at_0, loc_0 + 12), shr_u32(mul_i32(param_0, 3), 2)) then
			FUNC_LIST[44](loc_0)
			loc_1 = load_i32(memory_at_0, loc_0)
			param_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_1), 12)
		end
		loc_6 = sub_i32(param_0, 1)
		loc_2 = load_i32(memory_at_0, param_1 + 28)
		param_1 = band_i32(loc_6, bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9)))
		loc_3 = add_i32(loc_1, mul_i32(param_1, 12))
		param_0 = load_i32(memory_at_0, loc_3)
		loc_7 = load_i32(memory_at_0, loc_0 + 16)
		if param_0 ~= loc_7 then
			::continue_at_4::
			while true do
				if param_0 == loc_2 then goto continue_at_2 end
				loc_4 = add_i32(loc_4, 1)
				param_1 = band_i32(add_i32(loc_4, param_1), loc_6)
				loc_3 = add_i32(loc_1, mul_i32(param_1, 12))
				param_0 = load_i32(memory_at_0, loc_3)
				if param_0 ~= loc_7 then goto continue_at_4 end
				break
			end
		end
		store_i32(memory_at_0, loc_3, loc_2)
		store_i32(
			memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
		)
		::continue_at_2::
		store_i32(memory_at_0, add_i32(loc_1, mul_i32(param_1, 12)) + 4, loc_5)
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[50] = --[[ std::__2::vector<std::__2::pair<Luau::AstLocal*, Luau::Compile::Variable>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::Compile::Variable> > >::__append(unsigned long, std::__2::pair<Luau::AstLocal*, Luau::Compile::Variable> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_2), 12)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_4 = mul_i32(param_1, 12)
			loc_0 = loc_2
			loc_3 = sub_i32(mul_i32(param_1, 12), 12)
			param_1 = band_i32(add_i32(div_u32(loc_3, 12), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if lt_u32(loc_3, 36) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 8)
				store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
				store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 48)
				if loc_0 ~= loc_2 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_2)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_2, loc_5), 12)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 357913942) then
			loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
			loc_5 = shl_i32(loc_0, 1)
			loc_5 = (lt_u32(loc_0, 178956970) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 357913941)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 357913942) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
				loc_4 = reg_0
			end
			loc_3 = add_i32(loc_4, mul_i32(loc_6, 12))
			loc_0 = loc_3
			loc_6 = mul_i32(param_1, 12)
			loc_7 = sub_i32(loc_6, 12)
			param_1 = band_i32(add_i32(div_u32(loc_7, 12), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			param_1 = add_i32(loc_3, loc_6)
			if ge_u32(loc_7, 36) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 8)
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
					store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 48)
					if loc_0 ~= param_1 then goto continue_at_12 end
					break
				end
			end
			loc_4 = add_i32(loc_4, mul_i32(loc_5, 12))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_2, loc_0)
			loc_1 = add_i32(loc_3, mul_i32(div_i32(param_2, -12), 12))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, loc_4)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[51](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[51] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstLocal*, Luau::Compile::Variable>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::Compile::Variable> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[52] = --[[ std::__2::vector<std::__2::pair<Luau::AstName, Luau::Compile::Global>, std::__2::allocator<std::__2::pair<Luau::AstName, Luau::Compile::Global> > >::__append(unsigned long, std::__2::pair<Luau::AstName, Luau::Compile::Global> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_0, loc_1), 3)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = shl_i32(param_1, 3)
			loc_3 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_0 = loc_1
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_1 = add_i32(loc_1, loc_2)
			if lt_u32(loc_3, 7) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
				loc_0 = sub_i32(loc_0, -64)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_1)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = shr_i32(sub_i32(loc_1, loc_5), 3)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 536870912) then
			loc_0 = sub_i32(loc_0, loc_5)
			loc_5 = shr_i32(loc_0, 2)
			loc_5 = (lt_u32(loc_0, 2147483640) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 536870911)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 536870912) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
				loc_2 = reg_0
			end
			loc_7 = shl_i32(param_1, 3)
			loc_8 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_3 = add_i32(loc_2, shl_i32(loc_6, 3))
			loc_0 = loc_3
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_4 = add_i32(loc_3, loc_7)
			if ge_u32(loc_8, 7) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
					loc_0 = sub_i32(loc_0, -64)
					if loc_0 ~= loc_4 then goto continue_at_12 end
					break
				end
			end
			loc_2 = add_i32(loc_2, shl_i32(loc_5, 3))
			param_2 = load_i32(memory_at_0, param_0)
			loc_0 = sub_i32(loc_1, param_2)
			param_1 = sub_i32(loc_3, loc_0)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0) end
			store_i32(memory_at_0, param_0 + 8, loc_2)
			store_i32(memory_at_0, param_0 + 4, loc_4)
			store_i32(memory_at_0, param_0, param_1)
			if param_2 ~= 0 then FUNC_LIST[1276](param_2) end
			goto continue_at_0
		end
		FUNC_LIST[53](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[53] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstName, Luau::Compile::Global>, std::__2::allocator<std::__2::pair<Luau::AstName, Luau::Compile::Global> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[54] = --[[ Luau::Compile::foldConstants(Luau::DenseHashMap<Luau::AstExpr*, Luau::Compile::Constant, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExpr*> >&, Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Variable, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >&, Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Constant, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >&, Luau::AstNode*) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		store_i32(memory_at_0, loc_0 + 16, param_1)
		store_i32(memory_at_0, loc_0 + 8, 10796)
		store_i32(memory_at_0, loc_0 + 12, param_0)
		store_i32(memory_at_0, loc_0 + 20, param_2)
		store_i32_n8(
			memory_at_0, loc_0 + 24, (bor_i32(
				load_i32(memory_at_0, param_0 + 12), load_i32(memory_at_0, param_2 + 12)
			) == 0 and 1 or 0)
		)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_3))](
			param_3, add_i32(loc_0, 8)
		)
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	end
FUNC_LIST[55] = --[[ Luau::Compile::ConstantVisitor::~ConstantVisitor() ]]
	function(param_0) FUNC_LIST[1276](param_0) end
FUNC_LIST[56] = --[[ Luau::Compile::ConstantVisitor::visit(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		FUNC_LIST[57](loc_0, param_0, param_1)
		GLOBAL_LIST[0].value = add_i32(loc_0, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[57] = --[[ Luau::Compile::ConstantVisitor::analyze(Luau::AstExpr*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_1
		store_i64(memory_at_0, param_0, 0LL )
		store_i32(memory_at_0, param_0 + 8, 0)
		loc_0 = load_i32(memory_at_0, param_2 + 4)
		if param_2 == 0 then goto continue_at_2 end
		if loc_0 ~= load_i32(memory_at_0, 54900) then goto continue_at_2 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24))
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_1 + 40))
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_1 + 32))
		goto continue_at_1
		::continue_at_2::
		if load_i32(memory_at_0, 54908) == loc_0 then
			store_i32(memory_at_0, param_0, 1)
			goto continue_at_1
		end
		if param_2 == 0 then goto continue_at_4 end
		if loc_0 ~= load_i32(memory_at_0, 54916) then goto continue_at_4 end
		store_i32(memory_at_0, param_0, 2)
		store_i32_n8(memory_at_0, param_0 + 8, load_i32_u8(memory_at_0, param_2 + 24))
		goto continue_at_1
		::continue_at_4::
		if param_2 == 0 then goto continue_at_5 end
		if loc_0 ~= load_i32(memory_at_0, 54924) then goto continue_at_5 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(memory_at_0, param_0 + 8, load_f64(memory_at_0, param_2 + 24))
		goto continue_at_1
		::continue_at_5::
		if param_2 == 0 then goto continue_at_6 end
		if loc_0 ~= load_i32(memory_at_0, 54932) then goto continue_at_6 end
		store_i32(memory_at_0, param_0, 4)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, param_2 + 24))
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, param_2 + 28))
		goto continue_at_1
		::continue_at_6::
		if param_2 == 0 then goto continue_at_7 end
		if loc_0 ~= load_i32(memory_at_0, 54940) then goto continue_at_7 end
		reg_0 =
			FUNC_LIST[60](load_i32(memory_at_0, param_1 + 12), add_i32(param_2, 24))
		loc_0 = reg_0
		if loc_0 == 0 then goto continue_at_1 end
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_0 + 8))
		goto continue_at_1
		::continue_at_7::
		if loc_0 == load_i32(memory_at_0, 54948) then goto continue_at_1 end
		if loc_0 == load_i32(memory_at_0, 54956) then goto continue_at_1 end
		if param_2 == 0 then goto continue_at_8 end
		if loc_0 ~= load_i32(memory_at_0, 54964) then goto continue_at_8 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24))
		if load_i32(memory_at_0, param_2 + 32) == 0 then goto continue_at_1 end
		loc_0 = 0
		::continue_at_9::
		while true do
			FUNC_LIST[57](
				add_i32(loc_1, 32), param_1, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_2 + 28), shl_i32(loc_0, 2))
				)
			)
			loc_0 = add_i32(loc_0, 1)
			if lt_u32(loc_0, load_i32(memory_at_0, param_2 + 32)) then
				goto continue_at_9
			end
			break
		end
		goto continue_at_1
		::continue_at_8::
		if param_2 == 0 then goto continue_at_10 end
		if loc_0 ~= load_i32(memory_at_0, 54972) then goto continue_at_10 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24))
		goto continue_at_1
		::continue_at_10::
		if param_2 == 0 then goto continue_at_11 end
		if loc_0 ~= load_i32(memory_at_0, 54980) then goto continue_at_11 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24))
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 28))
		goto continue_at_1
		::continue_at_11::
		if param_2 == 0 then goto continue_at_12 end
		if loc_0 ~= load_i32(memory_at_0, 54988) then goto continue_at_12 end
		loc_0 = load_i32(memory_at_0, param_2 + 92)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_0))](
			loc_0, param_1
		)
		goto continue_at_1
		::continue_at_12::
		if loc_0 ~= load_i32(memory_at_0, 54996) then goto continue_at_13 end
		if param_2 == 0 then goto continue_at_13 end
		if load_i32(memory_at_0, param_2 + 28) == 0 then goto continue_at_1 end
		loc_0 = 0
		::continue_at_14::
		while true do
			loc_2 = add_i32(load_i32(memory_at_0, param_2 + 24), mul_i32(loc_0, 12))
			loc_3 = load_i32(memory_at_0, loc_2 + 4)
			if loc_3 ~= 0 then FUNC_LIST[57](add_i32(loc_1, 32), param_1, loc_3) end
			FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, loc_2 + 8))
			loc_0 = add_i32(loc_0, 1)
			if lt_u32(loc_0, load_i32(memory_at_0, param_2 + 28)) then
				goto continue_at_14
			end
			break
		end
		goto continue_at_1
		::continue_at_13::
		if param_2 == 0 then goto continue_at_16 end
		if loc_0 ~= load_i32(memory_at_0, 55004) then goto continue_at_16 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 28))
		if load_i32(memory_at_0, loc_1 + 32) == 0 then goto continue_at_1 end
		FUNC_LIST[61](param_0, load_i32(memory_at_0, param_2 + 24), add_i32(loc_1, 32))
		goto continue_at_1
		::continue_at_16::
		if param_2 == 0 then goto continue_at_17 end
		if loc_0 ~= load_i32(memory_at_0, 55012) then goto continue_at_17 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 28))
		FUNC_LIST[57](add_i32(loc_1, 16), param_1, load_i32(memory_at_0, param_2 + 32))
		if load_i32(memory_at_0, loc_1 + 32) == 0 then goto continue_at_1 end
		FUNC_LIST[62](
			param_0, load_i32(memory_at_0, param_2 + 24), add_i32(loc_1, 32),
				add_i32(loc_1, 16)
		)
		goto continue_at_1
		::continue_at_17::
		if param_2 == 0 then goto continue_at_18 end
		if loc_0 ~= load_i32(memory_at_0, 55020) then goto continue_at_18 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24))
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_1 + 40))
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_1 + 32))
		goto continue_at_1
		::continue_at_18::
		if param_2 == 0 then goto continue_at_1 end
		if loc_0 ~= load_i32(memory_at_0, 55028) then goto continue_at_1 end
		FUNC_LIST[57](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24))
		FUNC_LIST[57](add_i32(loc_1, 16), param_1, load_i32(memory_at_0, param_2 + 32))
		FUNC_LIST[57](loc_1, param_1, load_i32(memory_at_0, param_2 + 40))
		loc_0 = loc_1
		if not br_map[1] then br_map[1] = (function() return { [0] = 3, 2, 0 } end)() end
		temp = br_map[1][load_i32(memory_at_0, loc_1 + 32)] or 1
		if temp < 2 then
			if temp < 1 then
				goto continue_at_21
			else
				goto continue_at_20
			end
		elseif temp > 2 then
			goto continue_at_1
		else
			goto continue_at_19
		end
		::continue_at_21::
		if load_i32_u8(memory_at_0, loc_1 + 40) == 0 then goto continue_at_19 end
		::continue_at_20::
		loc_0 = add_i32(loc_1, 16)
		::continue_at_19::
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_0 + 8))
		::continue_at_1::
		FUNC_LIST[63](param_1, load_i32(memory_at_0, param_1 + 4), param_2, param_0)
		GLOBAL_LIST[0].value = add_i32(loc_1, 48)
	end
FUNC_LIST[58] = --[[ Luau::Compile::ConstantVisitor::visit(Luau::AstStatLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_5
		loc_1 = load_i32(memory_at_0, param_1 + 32)
		if loc_1 == 0 then
			loc_0 = load_i32(memory_at_0, param_1 + 40)
			loc_1 = 0
			goto continue_at_3
		end
		loc_0 = load_i32(memory_at_0, param_1 + 40)
		if loc_0 == 0 then goto continue_at_5 end
		::continue_at_6::
		while true do
			loc_0 = shl_i32(loc_7, 2)
			FUNC_LIST[57](
				loc_5, param_0,
					load_i32(memory_at_0, add_i32(loc_0, load_i32(memory_at_0, param_1 + 36)))
			)
			loc_1 = load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), loc_0)
			)
			loc_2 = 0
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_6 = load_i32(memory_at_0, loc_0)
			loc_3 = load_i32(memory_at_0, loc_0 + 4)
			if loc_6 == loc_3 then goto continue_at_7 end
			loc_9 = load_i32(memory_at_0, loc_0 + 16)
			if loc_9 == loc_1 then goto continue_at_7 end
			loc_4 = bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_3, loc_6), 12), 1)
			loc_0 = 0
			::continue_at_8::
			while true do
				loc_10 = band_i32(loc_3, loc_4)
				loc_2 = add_i32(loc_6, mul_i32(loc_10, 12))
				loc_4 = load_i32(memory_at_0, loc_2)
				if loc_4 == loc_1 then goto continue_at_7 end
				loc_2 = 0
				if loc_4 == loc_9 then goto continue_at_7 end
				loc_0 = add_i32(loc_0, 1)
				loc_4 = add_i32(loc_0, loc_10)
				if le_u32(loc_0, loc_3) then goto continue_at_8 end
				break
			end
			::continue_at_7::
			loc_0 = (loc_2 ~= 0 and add_i32(loc_2, 4) or 0)
			if load_i32_u8(memory_at_0, loc_0 + 4) == 0 then
				store_i32_n8(
					memory_at_0, loc_0 + 5, (load_i32(memory_at_0, loc_5) ~= 0 and 1 or 0)
				)
				FUNC_LIST[59](param_0, load_i32(memory_at_0, param_0 + 12), loc_1, loc_5)
			end
			loc_0 = load_i32(memory_at_0, param_1 + 40)
			loc_7 = add_i32(loc_7, 1)
			loc_1 = load_i32(memory_at_0, param_1 + 32)
			if ge_u32(loc_7, loc_1) then goto continue_at_5 end
			if gt_u32(loc_0, loc_7) then goto continue_at_6 end
			break
		end
		::continue_at_5::
		if lt_u32(loc_0, loc_1) then goto continue_at_2 end
		::continue_at_3::
		if le_u32(loc_0, loc_1) then goto continue_at_1 end
		::continue_at_10::
		while true do
			FUNC_LIST[57](
				loc_5, param_0, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 36), shl_i32(loc_1, 2))
				)
			)
			loc_1 = add_i32(loc_1, 1)
			if lt_u32(loc_1, load_i32(memory_at_0, param_1 + 40)) then
				goto continue_at_10
			end
			break
		end
		goto continue_at_1
		::continue_at_2::
		if loc_0 == 0 then goto continue_at_11 end
		loc_2 = load_i32(
			memory_at_0,
				sub_i32(add_i32(load_i32(memory_at_0, param_1 + 36), shl_i32(loc_0, 2)), 4)
		)
		if loc_2 == 0 then
			loc_8 = loc_0
			goto continue_at_11
		end
		loc_2 = load_i32(memory_at_0, loc_2 + 4)
		if loc_2 == load_i32(memory_at_0, 54964) then goto continue_at_1 end
		loc_8 = loc_0
		if loc_2 == load_i32(memory_at_0, 54956) then goto continue_at_1 end
		::continue_at_11::
		::continue_at_13::
		while true do
			loc_2 = 0
			store_i32(memory_at_0, loc_5 + 8, 0)
			store_i64(memory_at_0, loc_5, 1LL )
			loc_6 = load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_8, 2))
			)
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_9 = load_i32(memory_at_0, loc_0)
			loc_3 = load_i32(memory_at_0, loc_0 + 4)
			if loc_9 == loc_3 then goto continue_at_14 end
			loc_7 = load_i32(memory_at_0, loc_0 + 16)
			if loc_7 == loc_6 then goto continue_at_14 end
			loc_4 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_3, loc_9), 12), 1)
			loc_0 = 0
			::continue_at_15::
			while true do
				loc_10 = band_i32(loc_3, loc_4)
				loc_2 = add_i32(loc_9, mul_i32(loc_10, 12))
				loc_4 = load_i32(memory_at_0, loc_2)
				if loc_4 == loc_6 then goto continue_at_14 end
				loc_2 = 0
				if loc_4 == loc_7 then goto continue_at_14 end
				loc_0 = add_i32(loc_0, 1)
				loc_4 = add_i32(loc_0, loc_10)
				if le_u32(loc_0, loc_3) then goto continue_at_15 end
				break
			end
			::continue_at_14::
			loc_0 = (loc_2 ~= 0 and add_i32(loc_2, 4) or 0)
			if load_i32_u8(memory_at_0, loc_0 + 4) == 0 then
				store_i32_n8(memory_at_0, loc_0 + 5, 1)
				FUNC_LIST[59](param_0, load_i32(memory_at_0, param_0 + 12), loc_6, loc_5)
				loc_1 = load_i32(memory_at_0, param_1 + 32)
			end
			loc_8 = add_i32(loc_8, 1)
			if lt_u32(loc_8, loc_1) then goto continue_at_13 end
			break
		end
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_5, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[59] = --[[ void Luau::Compile::ConstantVisitor::recordConstant<Luau::AstLocal*>(Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Constant, std::__2::conditional<std::is_pointer_v<Luau::AstLocal*>, Luau::DenseHashPointer, std::__2::hash<Luau::AstLocal*> >::type, std::__2::equal_to<Luau::AstLocal*> >&, Luau::AstLocal*, Luau::Compile::Constant const&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		if load_i32(memory_at_0, param_3) ~= 0 then
			loc_0 = bxor_i32(shr_u32(param_2, 4), shr_u32(param_2, 9))
			loc_3 = load_i32(memory_at_0, param_1)
			param_0 = div_i32(sub_i32(load_i32(memory_at_0, param_1 + 4), loc_3), 24)
			if ge_u32(
				load_i32(memory_at_0, param_1 + 12), shr_u32(mul_i32(param_0, 3), 2)
			) then
				FUNC_LIST[381](param_1)
				loc_3 = load_i32(memory_at_0, param_1)
				param_0 = div_i32(sub_i32(load_i32(memory_at_0, param_1 + 4), loc_3), 24)
			end
			loc_2 = sub_i32(param_0, 1)
			loc_5 = load_i32(memory_at_0, param_1 + 16)
			param_0 = 0
			::continue_at_4::
			while true do
				loc_4 = band_i32(loc_0, loc_2)
				loc_1 = add_i32(loc_3, mul_i32(loc_4, 24))
				loc_0 = load_i32(memory_at_0, loc_1)
				if loc_5 == loc_0 then
					store_i32(memory_at_0, loc_1, param_2)
					store_i32(
						memory_at_0, param_1 + 12, add_i32(load_i32(memory_at_0, param_1 + 12), 1)
					)
					goto continue_at_3
				end
				if param_2 == loc_0 then goto continue_at_3 end
				param_0 = add_i32(param_0, 1)
				loc_0 = add_i32(param_0, loc_4)
				if le_u32(param_0, loc_2) then goto continue_at_4 end
				break
			end
			loc_1 = 0
			::continue_at_3::
			store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, param_3))
			store_i64(memory_at_0, loc_1 + 16, load_i64(memory_at_0, param_3 + 8))
			goto continue_at_0
		end
		if load_i32_u8(memory_at_0, param_0 + 16) ~= 0 then goto continue_at_6 end
		loc_1 = load_i32(memory_at_0, param_1)
		param_0 = load_i32(memory_at_0, param_1 + 4)
		if loc_1 == param_0 then goto continue_at_6 end
		loc_3 = load_i32(memory_at_0, param_1 + 16)
		if loc_3 == param_2 then goto continue_at_6 end
		loc_0 = bxor_i32(shr_u32(param_2, 4), shr_u32(param_2, 9))
		loc_2 = sub_i32(div_i32(sub_i32(param_0, loc_1), 24), 1)
		param_0 = 0
		::continue_at_7::
		while true do
			loc_0 = band_i32(loc_0, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)))
			if param_2 ~= loc_4 then
				if loc_3 == loc_4 then goto continue_at_6 end
				param_0 = add_i32(param_0, 1)
				loc_0 = add_i32(param_0, loc_0)
				if le_u32(param_0, loc_2) then goto continue_at_7 end
				goto continue_at_6
			end
			break
		end
		store_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)) + 8, 0)
		::continue_at_6::
		::continue_at_0::
	end
FUNC_LIST[60] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Constant, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::find(Luau::AstLocal* const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_3 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if loc_3 == loc_1 then goto continue_at_1 end
		loc_2 = load_i32(memory_at_0, param_1)
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		if loc_2 == loc_4 then goto continue_at_1 end
		param_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
		loc_1 = sub_i32(div_i32(sub_i32(loc_1, loc_3), 24), 1)
		param_0 = 0
		::continue_at_2::
		while true do
			loc_5 = band_i32(param_1, loc_1)
			loc_0 = add_i32(loc_3, mul_i32(loc_5, 24))
			param_1 = load_i32(memory_at_0, loc_0)
			if param_1 == loc_2 then goto continue_at_1 end
			loc_0 = 0
			if param_1 == loc_4 then goto continue_at_1 end
			param_0 = add_i32(param_0, 1)
			param_1 = add_i32(param_0, loc_5)
			if le_u32(param_0, loc_1) then goto continue_at_2 end
			break
		end
		::continue_at_1::
		reg_0 = (loc_0 ~= 0 and add_i32(loc_0, 8) or 0)
		return reg_0
	end
FUNC_LIST[61] = --[[ Luau::Compile::foldUnary(Luau::Compile::Constant&, Luau::AstExprUnary::Op, Luau::Compile::Constant const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local br_map, temp = {}, nil
		if not br_map[1] then br_map[1] = (function() return { [0] = 0, 1, 2 } end)() end
		temp = br_map[1][param_1] or 3
		if temp < 2 then
			if temp < 1 then
				goto continue_at_4
			else
				goto continue_at_3
			end
		elseif temp > 2 then
			goto continue_at_1
		else
			goto continue_at_2
		end
		::continue_at_4::
		if load_i32(memory_at_0, param_2) == 0 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		loc_0 = 1
		param_1 = 0
		if not br_map[2] then br_map[2] = (function() return { [0] = 2, 0 } end)() end
		temp = br_map[2][sub_i32(load_i32(memory_at_0, param_2), 1)] or 1
		if temp < 1 then
			goto continue_at_7
		elseif temp > 1 then
			goto continue_at_5
		else
			goto continue_at_6
		end
		::continue_at_7::
		loc_0 = (load_i32_u8(memory_at_0, param_2 + 8) ~= 0 and 1 or 0)
		::continue_at_6::
		param_1 = loc_0
		::continue_at_5::
		store_i32_n8(memory_at_0, param_0 + 8, bxor_i32(param_1, 1))
		goto continue_at_0
		::continue_at_3::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(
			memory_at_0, param_0 + 8, neg_f64(load_f64(memory_at_0, param_2 + 8))
		)
		goto continue_at_0
		::continue_at_2::
		if load_i32(memory_at_0, param_2) ~= 4 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(
			memory_at_0, param_0 + 8, convert_f64_u32(load_i32(memory_at_0, param_2 + 4))
		)
		::continue_at_1::
		::continue_at_0::
	end
FUNC_LIST[62] = --[[ Luau::Compile::foldBinary(Luau::Compile::Constant&, Luau::AstExprBinary::Op, Luau::Compile::Constant const&, Luau::Compile::Constant const&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0, reg_1
		local br_map, temp = {}, nil
		if not br_map[1] then
			br_map[1] = (function()
				return { [0] = 0, 1, 2, 3, 4, 5, 14, 6, 7, 8, 9, 10, 11, 12, 13 }
			end)()
		end
		temp = br_map[1][param_1] or 14
		if temp < 7 then
			if temp < 3 then
				if temp < 1 then
					goto continue_at_15
				elseif temp > 1 then
					goto continue_at_13
				else
					goto continue_at_14
				end
			elseif temp > 3 then
				if temp < 5 then
					goto continue_at_11
				elseif temp > 5 then
					goto continue_at_9
				else
					goto continue_at_10
				end
			else
				goto continue_at_12
			end
		elseif temp > 7 then
			if temp < 11 then
				if temp < 9 then
					goto continue_at_7
				elseif temp > 9 then
					goto continue_at_5
				else
					goto continue_at_6
				end
			elseif temp > 11 then
				if temp < 13 then
					goto continue_at_3
				elseif temp > 13 then
					goto continue_at_1
				else
					goto continue_at_2
				end
			else
				goto continue_at_4
			end
		else
			goto continue_at_8
		end
		::continue_at_15::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) + load_f64(memory_at_0, param_3 + 8))
		)
		goto continue_at_0
		::continue_at_14::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) - load_f64(memory_at_0, param_3 + 8))
		)
		goto continue_at_0
		::continue_at_13::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) * load_f64(memory_at_0, param_3 + 8))
		)
		goto continue_at_0
		::continue_at_12::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		store_f64(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) / load_f64(memory_at_0, param_3 + 8))
		)
		goto continue_at_0
		::continue_at_11::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		loc_1 = load_f64(memory_at_0, param_2 + 8)
		loc_2 = load_f64(memory_at_0, param_3 + 8)
		store_f64(
			memory_at_0, param_0 + 8, (loc_1 - (floor_f64((loc_1 / loc_2)) * loc_2))
		)
		goto continue_at_0
		::continue_at_10::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 3)
		reg_1 = FUNC_LIST[1173](
			load_f64(memory_at_0, param_2 + 8), load_f64(memory_at_0, param_3 + 8)
		)
		store_f64(memory_at_0, param_0 + 8, reg_1)
		goto continue_at_0
		::continue_at_9::
		if load_i32(memory_at_0, param_2) == 0 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) == 0 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		param_1 = 0
		if not br_map[2] then
			br_map[2] = (function() return { [0] = 0, 1, 2, 3 } end)()
		end
		temp = br_map[2][sub_i32(load_i32(memory_at_0, param_2), 1)] or 4
		if temp < 2 then
			if temp < 1 then
				goto continue_at_20
			else
				goto continue_at_19
			end
		elseif temp > 2 then
			if temp < 4 then
				goto continue_at_17
			else
				goto continue_at_16
			end
		else
			goto continue_at_18
		end
		::continue_at_20::
		param_1 = (load_i32(memory_at_0, param_3) == 1 and 1 or 0)
		goto continue_at_16
		::continue_at_19::
		param_1 = band_i32(
			(load_i32(memory_at_0, param_3) == 2 and 1 or 0),
				(load_i32_u8(memory_at_0, param_2 + 8) ==
					load_i32_u8(memory_at_0, param_3 + 8) and 1 or 0)
		)
		goto continue_at_16
		::continue_at_18::
		param_1 = band_i32(
			(load_i32(memory_at_0, param_3) == 3 and 1 or 0),
				(load_f64(memory_at_0, param_2 + 8) == load_f64(memory_at_0, param_3 + 8) and
					1 or 0)
		)
		goto continue_at_16
		::continue_at_17::
		if load_i32(memory_at_0, param_3) ~= 4 then goto continue_at_16 end
		loc_0 = load_i32(memory_at_0, param_2 + 4)
		if loc_0 ~= load_i32(memory_at_0, param_3 + 4) then goto continue_at_16 end
		reg_0 = FUNC_LIST[1171](
			load_i32(memory_at_0, param_2 + 8), load_i32(memory_at_0, param_3 + 8), loc_0
		)
		param_1 = (reg_0 == 0 and 1 or 0)
		::continue_at_16::
		store_i32_n8(memory_at_0, param_0 + 8, bxor_i32(param_1, 1))
		goto continue_at_0
		::continue_at_8::
		if load_i32(memory_at_0, param_2) == 0 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) == 0 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		param_1 = 0
		if not br_map[3] then
			br_map[3] = (function() return { [0] = 0, 1, 2, 3 } end)()
		end
		temp = br_map[3][sub_i32(load_i32(memory_at_0, param_2), 1)] or 4
		if temp < 2 then
			if temp < 1 then
				goto continue_at_25
			else
				goto continue_at_24
			end
		elseif temp > 2 then
			if temp < 4 then
				goto continue_at_22
			else
				goto continue_at_21
			end
		else
			goto continue_at_23
		end
		::continue_at_25::
		store_i32_n8(
			memory_at_0, param_0 + 8, (load_i32(memory_at_0, param_3) == 1 and 1 or 0)
		)
		goto continue_at_0
		::continue_at_24::
		store_i32_n8(
			memory_at_0, param_0 + 8, band_i32(
				(load_i32(memory_at_0, param_3) == 2 and 1 or 0),
					(load_i32_u8(memory_at_0, param_2 + 8) ==
						load_i32_u8(memory_at_0, param_3 + 8) and 1 or 0)
			)
		)
		goto continue_at_0
		::continue_at_23::
		store_i32_n8(
			memory_at_0, param_0 + 8, band_i32(
				(load_i32(memory_at_0, param_3) == 3 and 1 or 0),
					(load_f64(memory_at_0, param_2 + 8) == load_f64(memory_at_0, param_3 + 8) and
						1 or 0)
			)
		)
		goto continue_at_0
		::continue_at_22::
		if load_i32(memory_at_0, param_3) ~= 4 then goto continue_at_21 end
		loc_0 = load_i32(memory_at_0, param_2 + 4)
		if loc_0 ~= load_i32(memory_at_0, param_3 + 4) then goto continue_at_21 end
		reg_0 = FUNC_LIST[1171](
			load_i32(memory_at_0, param_2 + 8), load_i32(memory_at_0, param_3 + 8), loc_0
		)
		param_1 = (reg_0 == 0 and 1 or 0)
		::continue_at_21::
		store_i32_n8(memory_at_0, param_0 + 8, param_1)
		goto continue_at_0
		::continue_at_7::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		store_i32_n8(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) < load_f64(memory_at_0, param_3 + 8) and
					1 or 0)
		)
		goto continue_at_0
		::continue_at_6::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		store_i32_n8(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) <= load_f64(memory_at_0, param_3 + 8) and
					1 or 0)
		)
		goto continue_at_0
		::continue_at_5::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		store_i32_n8(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) > load_f64(memory_at_0, param_3 + 8) and
					1 or 0)
		)
		goto continue_at_0
		::continue_at_4::
		if load_i32(memory_at_0, param_2) ~= 3 then goto continue_at_1 end
		if load_i32(memory_at_0, param_3) ~= 3 then goto continue_at_1 end
		store_i32(memory_at_0, param_0, 2)
		store_i32_n8(
			memory_at_0, param_0 + 8,
				(load_f64(memory_at_0, param_2 + 8) >= load_f64(memory_at_0, param_3 + 8) and
					1 or 0)
		)
		goto continue_at_0
		::continue_at_3::
		if not br_map[4] then br_map[4] = (function() return { [0] = 4, 2, 0 } end)() end
		temp = br_map[4][load_i32(memory_at_0, param_2)] or 1
		if temp < 2 then
			if temp < 1 then
				goto continue_at_28
			else
				goto continue_at_27
			end
		elseif temp > 2 then
			goto continue_at_1
		else
			goto continue_at_26
		end
		::continue_at_28::
		if load_i32_u8(memory_at_0, param_2 + 8) == 0 then goto continue_at_26 end
		::continue_at_27::
		param_2 = param_3
		::continue_at_26::
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_2))
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_2 + 8))
		goto continue_at_0
		::continue_at_2::
		if not br_map[5] then br_map[5] = (function() return { [0] = 3, 2, 0 } end)() end
		temp = br_map[5][load_i32(memory_at_0, param_2)] or 1
		if temp < 2 then
			if temp < 1 then
				goto continue_at_31
			else
				goto continue_at_30
			end
		elseif temp > 2 then
			goto continue_at_1
		else
			goto continue_at_29
		end
		::continue_at_31::
		if load_i32_u8(memory_at_0, param_2 + 8) == 0 then goto continue_at_29 end
		::continue_at_30::
		param_3 = param_2
		::continue_at_29::
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_3))
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_3 + 8))
		::continue_at_1::
		::continue_at_0::
	end
FUNC_LIST[63] = --[[ void Luau::Compile::ConstantVisitor::recordConstant<Luau::AstExpr*>(Luau::DenseHashMap<Luau::AstExpr*, Luau::Compile::Constant, std::__2::conditional<std::is_pointer_v<Luau::AstExpr*>, Luau::DenseHashPointer, std::__2::hash<Luau::AstExpr*> >::type, std::__2::equal_to<Luau::AstExpr*> >&, Luau::AstExpr*, Luau::Compile::Constant const&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		if load_i32(memory_at_0, param_3) ~= 0 then
			loc_0 = bxor_i32(shr_u32(param_2, 4), shr_u32(param_2, 9))
			loc_3 = load_i32(memory_at_0, param_1)
			param_0 = div_i32(sub_i32(load_i32(memory_at_0, param_1 + 4), loc_3), 24)
			if ge_u32(
				load_i32(memory_at_0, param_1 + 12), shr_u32(mul_i32(param_0, 3), 2)
			) then
				FUNC_LIST[64](param_1)
				loc_3 = load_i32(memory_at_0, param_1)
				param_0 = div_i32(sub_i32(load_i32(memory_at_0, param_1 + 4), loc_3), 24)
			end
			loc_2 = sub_i32(param_0, 1)
			loc_5 = load_i32(memory_at_0, param_1 + 16)
			param_0 = 0
			::continue_at_4::
			while true do
				loc_4 = band_i32(loc_0, loc_2)
				loc_1 = add_i32(loc_3, mul_i32(loc_4, 24))
				loc_0 = load_i32(memory_at_0, loc_1)
				if loc_5 == loc_0 then
					store_i32(memory_at_0, loc_1, param_2)
					store_i32(
						memory_at_0, param_1 + 12, add_i32(load_i32(memory_at_0, param_1 + 12), 1)
					)
					goto continue_at_3
				end
				if param_2 == loc_0 then goto continue_at_3 end
				param_0 = add_i32(param_0, 1)
				loc_0 = add_i32(param_0, loc_4)
				if le_u32(param_0, loc_2) then goto continue_at_4 end
				break
			end
			loc_1 = 0
			::continue_at_3::
			store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, param_3))
			store_i64(memory_at_0, loc_1 + 16, load_i64(memory_at_0, param_3 + 8))
			goto continue_at_0
		end
		if load_i32_u8(memory_at_0, param_0 + 16) ~= 0 then goto continue_at_6 end
		loc_1 = load_i32(memory_at_0, param_1)
		param_0 = load_i32(memory_at_0, param_1 + 4)
		if loc_1 == param_0 then goto continue_at_6 end
		loc_3 = load_i32(memory_at_0, param_1 + 16)
		if loc_3 == param_2 then goto continue_at_6 end
		loc_0 = bxor_i32(shr_u32(param_2, 4), shr_u32(param_2, 9))
		loc_2 = sub_i32(div_i32(sub_i32(param_0, loc_1), 24), 1)
		param_0 = 0
		::continue_at_7::
		while true do
			loc_0 = band_i32(loc_0, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)))
			if param_2 ~= loc_4 then
				if loc_3 == loc_4 then goto continue_at_6 end
				param_0 = add_i32(param_0, 1)
				loc_0 = add_i32(param_0, loc_0)
				if le_u32(param_0, loc_2) then goto continue_at_7 end
				goto continue_at_6
			end
			break
		end
		store_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)) + 8, 0)
		::continue_at_6::
		::continue_at_0::
	end
FUNC_LIST[64] = --[[ Luau::detail::DenseHashTable<Luau::AstExpr*, std::__2::pair<Luau::AstExpr*, Luau::Compile::Constant>, std::__2::pair<Luau::AstExpr* const, Luau::Compile::Constant>, Luau::detail::ItemInterfaceMap<Luau::AstExpr*, Luau::Compile::Constant>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExpr*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 24), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_4 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 16, loc_4)
			loc_8 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_4)
		loc_8 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_2, loc_1), 24), 1)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[65](loc_0, loc_1, add_i32(loc_0, 24))
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_2 == loc_1 then
			loc_1 = loc_2
			goto continue_at_2
		end
		loc_9 = load_i32(memory_at_0, loc_0)
		loc_4 = sub_i32(
			div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_9), 24), 1
		)
		::continue_at_7::
		while true do
			loc_7 = add_i32(loc_1, mul_i32(loc_6, 24))
			loc_3 = load_i32(memory_at_0, loc_7)
			if loc_3 ~= load_i32(memory_at_0, loc_8) then
				loc_2 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
				loc_1 = 0
				loc_10 = load_i32(memory_at_0, loc_0 + 16)
				::continue_at_10::
				while true do
					loc_11 = band_i32(loc_2, loc_4)
					loc_5 = add_i32(loc_9, mul_i32(loc_11, 24))
					loc_2 = load_i32(memory_at_0, loc_5)
					if loc_10 == loc_2 then
						store_i32(memory_at_0, loc_5, loc_3)
						store_i32(
							memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
						)
						loc_3 = load_i32(memory_at_0, loc_7)
						goto continue_at_9
					end
					if loc_2 == loc_3 then goto continue_at_9 end
					loc_1 = add_i32(loc_1, 1)
					loc_2 = add_i32(loc_1, loc_11)
					if le_u32(loc_1, loc_4) then goto continue_at_10 end
					break
				end
				loc_5 = 0
				::continue_at_9::
				store_i32(memory_at_0, loc_5, loc_3)
				store_i64(memory_at_0, loc_5 + 8, load_i64(memory_at_0, loc_7 + 8))
				store_i64(memory_at_0, loc_5 + 16, load_i64(memory_at_0, loc_7 + 16))
				loc_2 = load_i32(memory_at_0, param_0 + 4)
				loc_1 = load_i32(memory_at_0, param_0)
			end
			loc_6 = add_i32(loc_6, 1)
			if lt_u32(loc_6, div_i32(sub_i32(loc_2, loc_1), 24)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		store_i32(memory_at_0, loc_0 + 24, loc_1)
		FUNC_LIST[65](param_0, 16, add_i32(loc_0, 24))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[65] = --[[ std::__2::vector<std::__2::pair<Luau::AstExpr*, Luau::Compile::Constant>, std::__2::allocator<std::__2::pair<Luau::AstExpr*, Luau::Compile::Constant> > >::__append(unsigned long, std::__2::pair<Luau::AstExpr*, Luau::Compile::Constant> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_3 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_3), 24)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = mul_i32(param_1, 24)
			loc_0 = loc_3
			loc_5 = sub_i32(mul_i32(param_1, 24), 24)
			param_1 = band_i32(add_i32(div_u32(loc_5, 24), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2 + 16))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 24)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_3 = add_i32(loc_2, loc_3)
			if lt_u32(loc_5, 72) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 16)
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_1))
				param_1 = add_i32(param_2, 8)
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, sub_i32(loc_0, -64), load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 72, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 80, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 88, load_i64(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 96)
				if loc_0 ~= loc_3 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_3)
			goto continue_at_0
		end
		loc_4 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_3, loc_4), 24)
		loc_2 = add_i32(loc_6, param_1)
		if lt_u32(loc_2, 178956971) then
			loc_0 = div_i32(sub_i32(loc_0, loc_4), 24)
			loc_4 = shl_i32(loc_0, 1)
			loc_7 =
				(lt_u32(loc_0, 89478485) and (lt_u32(loc_2, loc_4) and loc_4 or loc_2) or
					178956970)
			if loc_7 ~= 0 then
				if ge_u32(loc_7, 178956971) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_7, 24))
				loc_5 = reg_0
			end
			loc_4 = add_i32(loc_5, mul_i32(loc_6, 24))
			loc_0 = loc_4
			loc_2 = mul_i32(param_1, 24)
			loc_6 = sub_i32(loc_2, 24)
			param_1 = band_i32(add_i32(div_u32(loc_6, 24), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_4
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2 + 16))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 24)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if ge_u32(loc_6, 72) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 16)
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_1))
					param_1 = add_i32(param_2, 8)
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, sub_i32(loc_0, -64), load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 72, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 80, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 88, load_i64(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 96)
					if loc_0 ~= loc_2 then goto continue_at_12 end
					break
				end
			end
			param_1 = add_i32(loc_5, mul_i32(loc_7, 24))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_3, loc_0)
			loc_1 = add_i32(loc_4, mul_i32(div_i32(param_2, -24), 24))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, param_1)
			store_i32(memory_at_0, param_0 + 4, loc_2)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[66](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[66] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstExpr*, Luau::Compile::Constant>, std::__2::allocator<std::__2::pair<Luau::AstExpr*, Luau::Compile::Constant> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[67] = --[[ Luau::Compile::predictTableShapes(Luau::DenseHashMap<Luau::AstExprTable*, Luau::Compile::TableShape, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprTable*> >&, Luau::AstNode*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 96)
		GLOBAL_LIST[0].value = loc_0
		store_i64(memory_at_0, loc_0 + 24, 0LL )
		store_i32(memory_at_0, loc_0 + 32, 0)
		store_i64(memory_at_0, loc_0 + 48, 0LL )
		store_i64(memory_at_0, loc_0 + 56, 0LL )
		store_i64(memory_at_0, loc_0 + 76, 0LL )
		store_i32(memory_at_0, loc_0 + 84, 0)
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i32(memory_at_0, loc_0 + 12, param_0)
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 68, 0LL )
		param_0 = 11080
		store_i32(memory_at_0, loc_0 + 8, param_0)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, add_i32(loc_0, 8)
		)
		store_i32(memory_at_0, loc_0 + 8, param_0)
		param_1 = load_i32(memory_at_0, loc_0 + 68)
		if param_1 ~= 0 then
			store_i32(memory_at_0, loc_0 + 72, param_1)
			FUNC_LIST[1276](param_1)
		end
		param_1 = load_i32(memory_at_0, loc_0 + 40)
		if param_1 ~= 0 then
			store_i32(memory_at_0, loc_0 + 44, param_1)
			FUNC_LIST[1276](param_1)
		end
		param_1 = load_i32(memory_at_0, loc_0 + 16)
		if param_1 ~= 0 then
			store_i32(memory_at_0, loc_0 + 20, param_1)
			FUNC_LIST[1276](param_1)
		end
		GLOBAL_LIST[0].value = add_i32(loc_0, 96)
	end
FUNC_LIST[68] = --[[ Luau::Compile::ShapeVisitor::~ShapeVisitor() ]] function(
	param_0
)
	local loc_0 = 0
	local reg_0
	store_i32(memory_at_0, param_0, 11080)
	loc_0 = load_i32(memory_at_0, param_0 + 60)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 64, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 32)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 36, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 12, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[69] = --[[ Luau::Compile::ShapeVisitor::~ShapeVisitor().1 ]] function(
	param_0
)
	local loc_0 = 0
	store_i32(memory_at_0, param_0, 11080)
	loc_0 = load_i32(memory_at_0, param_0 + 60)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 64, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 32)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 36, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 12, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	FUNC_LIST[1276](param_0)
end
FUNC_LIST[70] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		if load_i32(memory_at_0, param_1 + 32) ~= 1 then goto continue_at_1 end
		if load_i32(memory_at_0, param_1 + 40) ~= 1 then goto continue_at_1 end
		loc_1 = load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 36))
		loc_0 = load_i32(memory_at_0, loc_1 + 4)
		loc_2 = load_i32(memory_at_0, 54996)
		if (loc_0 == loc_2 and loc_1 or 0) == 0 then
			if loc_1 == 0 then goto continue_at_1 end
			if loc_0 ~= load_i32(memory_at_0, 54964) then goto continue_at_1 end
			if load_i32_u8(memory_at_0, loc_1 + 36) ~= 0 then goto continue_at_1 end
			if load_i32(memory_at_0, loc_1 + 32) ~= 2 then goto continue_at_1 end
			loc_0 = load_i32(memory_at_0, loc_1 + 24)
			if load_i32(memory_at_0, loc_0 + 4) ~= load_i32(memory_at_0, 54948) then
				goto continue_at_1
			end
			if loc_0 == 0 then goto continue_at_1 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			if loc_0 == 0 then goto continue_at_1 end
			reg_0 = FUNC_LIST[1193](loc_0, 6356)
			if reg_0 ~= 0 then goto continue_at_1 end
			loc_1 = load_i32(memory_at_0, load_i32(memory_at_0, loc_1 + 28))
			if load_i32(memory_at_0, loc_1 + 4) ~= loc_2 then goto continue_at_1 end
			if loc_1 == 0 then goto continue_at_1 end
		end
		if load_i32(memory_at_0, loc_1 + 28) ~= 0 then goto continue_at_1 end
		loc_3 = add_i32(param_0, 8)
		loc_0 = load_i32(memory_at_0, param_1 + 28)
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		param_1 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 12), loc_2), 3)
		if ge_u32(load_i32(memory_at_0, param_0 + 20), shr_u32(mul_i32(param_1, 3), 2)) then
			FUNC_LIST[71](loc_3)
			loc_2 = load_i32(memory_at_0, loc_3)
			param_1 = shr_i32(sub_i32(load_i32(memory_at_0, loc_3 + 4), loc_2), 3)
		end
		loc_6 = sub_i32(param_1, 1)
		loc_4 = load_i32(memory_at_0, loc_0)
		param_1 = band_i32(loc_6, bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9)))
		loc_5 = add_i32(loc_2, shl_i32(param_1, 3))
		param_0 = load_i32(memory_at_0, loc_5)
		loc_7 = load_i32(memory_at_0, loc_3 + 16)
		if param_0 ~= loc_7 then
			loc_0 = 0
			::continue_at_6::
			while true do
				if param_0 == loc_4 then goto continue_at_4 end
				loc_0 = add_i32(loc_0, 1)
				param_1 = band_i32(add_i32(loc_0, param_1), loc_6)
				loc_5 = add_i32(loc_2, shl_i32(param_1, 3))
				param_0 = load_i32(memory_at_0, loc_5)
				if param_0 ~= loc_7 then goto continue_at_6 end
				break
			end
		end
		store_i32(memory_at_0, loc_5, loc_4)
		store_i32(
			memory_at_0, loc_3 + 12, add_i32(load_i32(memory_at_0, loc_3 + 12), 1)
		)
		::continue_at_4::
		store_i32(memory_at_0, add_i32(loc_2, shl_i32(param_1, 3)) + 4, loc_1)
		::continue_at_1::
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[71] = --[[ Luau::detail::DenseHashTable<Luau::AstLocal*, std::__2::pair<Luau::AstLocal*, Luau::AstExprTable*>, std::__2::pair<Luau::AstLocal* const, Luau::AstExprTable*>, Luau::detail::ItemInterfaceMap<Luau::AstLocal*, Luau::AstExprTable*>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_4 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_4 then
			if gt_u32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 127) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_2 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 16, loc_2)
			loc_9 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_2 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_2)
		loc_9 = add_i32(param_0, 16)
		reg_0 = shr_i32(sub_i32(loc_4, loc_1), 2)
		::continue_at_4::
		loc_1 = reg_0
		store_i32(memory_at_0, loc_0 + 28, 0)
		store_i32(memory_at_0, loc_0 + 24, loc_2)
		FUNC_LIST[78](loc_0, loc_1, add_i32(loc_0, 24))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_3 then goto continue_at_2 end
		loc_1 = shr_i32(sub_i32(loc_1, loc_3), 3)
		loc_13 = (gt_u32(loc_1, 1) and loc_1 or 1)
		loc_6 = load_i32(memory_at_0, loc_0)
		loc_10 = sub_i32(
			shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_6), 3), 1
		)
		loc_11 = load_i32(memory_at_0, loc_0 + 12)
		::continue_at_6::
		while true do
			loc_12 = add_i32(loc_3, shl_i32(loc_5, 3))
			loc_2 = load_i32(memory_at_0, loc_12)
			if loc_2 ~= load_i32(memory_at_0, loc_9) then
				loc_1 = band_i32(bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9)), loc_10)
				loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
				loc_8 = load_i32(memory_at_0, loc_7)
				loc_14 = load_i32(memory_at_0, loc_0 + 16)
				if loc_8 == loc_14 then goto continue_at_9 end
				loc_4 = 0
				if loc_2 == loc_8 then goto continue_at_8 end
				::continue_at_10::
				while true do
					loc_4 = add_i32(loc_4, 1)
					loc_1 = band_i32(add_i32(loc_4, loc_1), loc_10)
					loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
					loc_8 = load_i32(memory_at_0, loc_7)
					if loc_8 == loc_14 then goto continue_at_9 end
					if loc_2 ~= loc_8 then goto continue_at_10 end
					break
				end
				goto continue_at_8
				::continue_at_9::
				store_i32(memory_at_0, loc_7, loc_2)
				loc_11 = add_i32(loc_11, 1)
				store_i32(memory_at_0, loc_0 + 12, loc_11)
				loc_2 = load_i32(memory_at_0, loc_12)
				::continue_at_8::
				store_i32(memory_at_0, loc_7, loc_2)
				store_i32(
					memory_at_0, add_i32(loc_6, shl_i32(loc_1, 3)) + 4,
						load_i32(memory_at_0, loc_12 + 4)
				)
			end
			loc_5 = add_i32(loc_5, 1)
			if loc_5 ~= loc_13 then goto continue_at_6 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 4, 0)
		store_i32(memory_at_0, loc_0, loc_1)
		FUNC_LIST[78](param_0, 16, loc_0)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_3)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		if loc_3 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		FUNC_LIST[1276](loc_3)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	end
FUNC_LIST[72] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatFor*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 32)
		reg_0 = loc_0
		loc_0 = load_i32(memory_at_0, 54924)
		loc_1 = (load_i32(memory_at_0, loc_0 + 4) == loc_0 and reg_0 or 0)
		if loc_1 == 0 then goto continue_at_1 end
		loc_2 = load_i32(memory_at_0, param_1 + 36)
		loc_0 = (load_i32(memory_at_0, loc_2 + 4) == loc_0 and loc_2 or 0)
		if loc_0 == 0 then goto continue_at_1 end
		if load_f64(memory_at_0, loc_1 + 24) ~= 1e0 then goto continue_at_1 end
		loc_4 = load_f64(memory_at_0, loc_0 + 24)
		if (loc_4 >= 1e0 and 1 or 0) == 0 then goto continue_at_1 end
		if (loc_4 <= 1.6e1 and 1 or 0) == 0 then goto continue_at_1 end
		if load_i32(memory_at_0, param_1 + 40) ~= 0 then goto continue_at_1 end
		loc_2 = load_i32(memory_at_0, param_0 + 60)
		loc_0 =
			shr_i32(sub_i32(load_i32(memory_at_0, sub_i32(param_0, -64)), loc_2), 3)
		loc_1 = (lt_u32(
			load_i32(memory_at_0, param_0 + 72), shr_u32(mul_i32(loc_0, 3), 2)
		) and 1 or 0)
		if band_i32((loc_4 < 4.294967296e9 and 1 or 0), (loc_4 >= 0e0 and 1 or 0)) ~=
			0 then
			reg_0 = truncate_u32_f64(loc_4)
			goto continue_at_2
		end
		reg_0 = 0
		::continue_at_2::
		loc_6 = reg_0
		loc_3 = add_i32(param_0, 60)
		if loc_1 == 0 then
			FUNC_LIST[73](loc_3)
			loc_2 = load_i32(memory_at_0, loc_3)
			loc_0 = shr_i32(sub_i32(load_i32(memory_at_0, loc_3 + 4), loc_2), 3)
		end
		loc_7 = sub_i32(loc_0, 1)
		param_0 = load_i32(memory_at_0, param_1 + 28)
		param_1 = band_i32(loc_7, bxor_i32(shr_u32(param_0, 4), shr_u32(param_0, 9)))
		loc_5 = add_i32(loc_2, shl_i32(param_1, 3))
		loc_0 = load_i32(memory_at_0, loc_5)
		loc_8 = load_i32(memory_at_0, loc_3 + 16)
		if loc_0 ~= loc_8 then
			loc_1 = 0
			::continue_at_7::
			while true do
				if param_0 == loc_0 then goto continue_at_5 end
				loc_1 = add_i32(loc_1, 1)
				param_1 = band_i32(add_i32(loc_1, param_1), loc_7)
				loc_5 = add_i32(loc_2, shl_i32(param_1, 3))
				loc_0 = load_i32(memory_at_0, loc_5)
				if loc_0 ~= loc_8 then goto continue_at_7 end
				break
			end
		end
		store_i32(memory_at_0, loc_5, param_0)
		store_i32(
			memory_at_0, loc_3 + 12, add_i32(load_i32(memory_at_0, loc_3 + 12), 1)
		)
		::continue_at_5::
		store_i32(memory_at_0, add_i32(loc_2, shl_i32(param_1, 3)) + 4, loc_6)
		::continue_at_1::
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[73] = --[[ Luau::detail::DenseHashTable<Luau::AstLocal*, std::__2::pair<Luau::AstLocal*, unsigned int>, std::__2::pair<Luau::AstLocal* const, unsigned int>, Luau::detail::ItemInterfaceMap<Luau::AstLocal*, unsigned int>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_4 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_4 then
			if gt_u32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 127) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_2 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 16, loc_2)
			loc_9 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_2 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_2)
		loc_9 = add_i32(param_0, 16)
		reg_0 = shr_i32(sub_i32(loc_4, loc_1), 2)
		::continue_at_4::
		loc_1 = reg_0
		store_i32(memory_at_0, loc_0 + 28, 0)
		store_i32(memory_at_0, loc_0 + 24, loc_2)
		FUNC_LIST[82](loc_0, loc_1, add_i32(loc_0, 24))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_3 then goto continue_at_2 end
		loc_1 = shr_i32(sub_i32(loc_1, loc_3), 3)
		loc_13 = (gt_u32(loc_1, 1) and loc_1 or 1)
		loc_6 = load_i32(memory_at_0, loc_0)
		loc_10 = sub_i32(
			shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_6), 3), 1
		)
		loc_11 = load_i32(memory_at_0, loc_0 + 12)
		::continue_at_6::
		while true do
			loc_12 = add_i32(loc_3, shl_i32(loc_5, 3))
			loc_2 = load_i32(memory_at_0, loc_12)
			if loc_2 ~= load_i32(memory_at_0, loc_9) then
				loc_1 = band_i32(bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9)), loc_10)
				loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
				loc_8 = load_i32(memory_at_0, loc_7)
				loc_14 = load_i32(memory_at_0, loc_0 + 16)
				if loc_8 == loc_14 then goto continue_at_9 end
				loc_4 = 0
				if loc_2 == loc_8 then goto continue_at_8 end
				::continue_at_10::
				while true do
					loc_4 = add_i32(loc_4, 1)
					loc_1 = band_i32(add_i32(loc_4, loc_1), loc_10)
					loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
					loc_8 = load_i32(memory_at_0, loc_7)
					if loc_8 == loc_14 then goto continue_at_9 end
					if loc_2 ~= loc_8 then goto continue_at_10 end
					break
				end
				goto continue_at_8
				::continue_at_9::
				store_i32(memory_at_0, loc_7, loc_2)
				loc_11 = add_i32(loc_11, 1)
				store_i32(memory_at_0, loc_0 + 12, loc_11)
				loc_2 = load_i32(memory_at_0, loc_12)
				::continue_at_8::
				store_i32(memory_at_0, loc_7, loc_2)
				store_i32(
					memory_at_0, add_i32(loc_6, shl_i32(loc_1, 3)) + 4,
						load_i32(memory_at_0, loc_12 + 4)
				)
			end
			loc_5 = add_i32(loc_5, 1)
			if loc_5 ~= loc_13 then goto continue_at_6 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 4, 0)
		store_i32(memory_at_0, loc_0, loc_1)
		FUNC_LIST[82](param_0, 16, loc_0)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_3)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		if loc_3 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		FUNC_LIST[1276](loc_3)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	end
FUNC_LIST[74] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatAssign*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0
		if load_i32(memory_at_0, param_1 + 32) ~= 0 then
			::continue_at_2::
			while true do
				loc_0 = load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_1, 2))
				)
				loc_2 = load_i32(memory_at_0, loc_0 + 4)
				if loc_0 == 0 then goto continue_at_4 end
				if loc_2 ~= load_i32(memory_at_0, 54972) then goto continue_at_4 end
				FUNC_LIST[75](
					param_0, load_i32(memory_at_0, loc_0 + 24),
						load_i32(memory_at_0, loc_0 + 28)
				)
				goto continue_at_3
				::continue_at_4::
				if loc_0 == 0 then goto continue_at_3 end
				if loc_2 ~= load_i32(memory_at_0, 54980) then goto continue_at_3 end
				FUNC_LIST[76](
					param_0, load_i32(memory_at_0, loc_0 + 24),
						load_i32(memory_at_0, loc_0 + 28)
				)
				::continue_at_3::
				loc_1 = add_i32(loc_1, 1)
				if lt_u32(loc_1, load_i32(memory_at_0, param_1 + 32)) then
					goto continue_at_2
				end
				break
			end
		end
		if load_i32(memory_at_0, param_1 + 40) ~= 0 then
			loc_0 = 0
			::continue_at_6::
			while true do
				loc_1 = load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 36), shl_i32(loc_0, 2))
				)
				TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_1))](
					loc_1, param_0
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 40)) then
					goto continue_at_6
				end
				break
			end
		end
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[75] = --[[ Luau::Compile::ShapeVisitor::assignField(Luau::AstExpr*, Luau::AstName) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		if param_1 == 0 then goto continue_at_1 end
		if load_i32(memory_at_0, param_1 + 4) ~= load_i32(memory_at_0, 54940) then
			goto continue_at_1
		end
		loc_3 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 12)
		if loc_3 == loc_1 then goto continue_at_1 end
		loc_4 = load_i32(memory_at_0, param_1 + 24)
		loc_5 = load_i32(memory_at_0, param_0 + 24)
		if loc_4 == loc_5 then goto continue_at_1 end
		loc_0 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_1 = sub_i32(shr_i32(sub_i32(loc_1, loc_3), 3), 1)
		param_1 = 0
		::continue_at_2::
		while true do
			loc_0 = band_i32(loc_0, loc_1)
			loc_2 = load_i32(memory_at_0, add_i32(loc_3, shl_i32(loc_0, 3)))
			if loc_4 ~= loc_2 then
				if loc_2 == loc_5 then goto continue_at_1 end
				param_1 = add_i32(param_1, 1)
				loc_0 = add_i32(param_1, loc_0)
				if le_u32(param_1, loc_1) then goto continue_at_2 end
				goto continue_at_1
			end
			break
		end
		loc_6 = add_i32(param_0, 32)
		loc_9 = add_i32(loc_3, shl_i32(loc_0, 3))
		loc_5 = load_i32(memory_at_0, loc_9 + 4)
		loc_7 = load_i32(memory_at_0, param_0 + 32)
		loc_8 = load_i32(memory_at_0, param_0 + 36)
		if loc_7 == loc_8 then goto continue_at_4 end
		loc_4 = load_i32(memory_at_0, loc_6 + 16)
		loc_10 = load_i32(memory_at_0, loc_6 + 20)
		if band_i32((loc_4 == loc_5 and 1 or 0), (loc_10 == param_2 and 1 or 0)) ~= 0 then
			goto continue_at_4
		end
		param_1 = bxor_i32(param_2, loc_5)
		loc_0 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_1 = sub_i32(shr_i32(sub_i32(loc_8, loc_7), 3), 1)
		param_1 = 0
		::continue_at_5::
		while true do
			loc_3 = band_i32(loc_0, loc_1)
			loc_2 = add_i32(loc_7, shl_i32(loc_3, 3))
			loc_0 = load_i32(memory_at_0, loc_2 + 4)
			loc_2 = load_i32(memory_at_0, loc_2)
			if band_i32((loc_5 == loc_2 and 1 or 0), (param_2 == loc_0 and 1 or 0)) ~= 0 then
				goto continue_at_1
			end
			if band_i32((loc_2 == loc_4 and 1 or 0), (loc_0 == loc_10 and 1 or 0)) ~= 0 then
				goto continue_at_4
			end
			param_1 = add_i32(param_1, 1)
			loc_0 = add_i32(param_1, loc_3)
			if le_u32(param_1, loc_1) then goto continue_at_5 end
			break
		end
		::continue_at_4::
		loc_9 = add_i32(loc_9, 4)
		loc_0 = bxor_i32(param_2, loc_5)
		loc_0 = bxor_i32(shr_u32(loc_0, 4), shr_u32(loc_0, 9))
		param_1 = shr_i32(sub_i32(loc_8, loc_7), 3)
		if ge_u32(load_i32(memory_at_0, loc_6 + 12), shr_u32(mul_i32(param_1, 3), 2)) then
			FUNC_LIST[84](loc_6)
			loc_7 = load_i32(memory_at_0, loc_6)
			param_1 = shr_i32(sub_i32(load_i32(memory_at_0, loc_6 + 4), loc_7), 3)
		end
		loc_1 = sub_i32(param_1, 1)
		loc_8 = load_i32(memory_at_0, loc_6 + 20)
		loc_10 = load_i32(memory_at_0, loc_6 + 16)
		param_1 = 0
		::continue_at_7::
		while true do
			loc_4 = band_i32(loc_0, loc_1)
			loc_0 = add_i32(loc_7, shl_i32(loc_4, 3))
			loc_2 = load_i32(memory_at_0, loc_0 + 4)
			loc_3 = load_i32(memory_at_0, loc_0)
			if loc_3 ~= loc_10 then goto continue_at_9 end
			if loc_2 ~= loc_8 then goto continue_at_9 end
			store_i32(memory_at_0, loc_0, loc_5)
			store_i32(memory_at_0, loc_0 + 4, param_2)
			store_i32(
				memory_at_0, loc_6 + 12, add_i32(load_i32(memory_at_0, loc_6 + 12), 1)
			)
			goto continue_at_8
			::continue_at_9::
			if band_i32((loc_3 == loc_5 and 1 or 0), (param_2 == loc_2 and 1 or 0)) ~= 0 then
				goto continue_at_8
			end
			param_1 = add_i32(param_1, 1)
			loc_0 = add_i32(param_1, loc_4)
			if le_u32(param_1, loc_1) then goto continue_at_7 end
			::continue_at_8::
			break
		end
		param_2 = load_i32(memory_at_0, param_0 + 4)
		loc_2 = load_i32(memory_at_0, param_2)
		param_1 = div_i32(sub_i32(load_i32(memory_at_0, param_2 + 4), loc_2), 12)
		if ge_u32(load_i32(memory_at_0, param_2 + 12), shr_u32(mul_i32(param_1, 3), 2)) then
			FUNC_LIST[370](param_2)
			loc_2 = load_i32(memory_at_0, param_2)
			param_1 = div_i32(sub_i32(load_i32(memory_at_0, param_2 + 4), loc_2), 12)
		end
		param_0 = sub_i32(param_1, 1)
		loc_3 = load_i32(memory_at_0, loc_9)
		param_1 = band_i32(param_0, bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9)))
		loc_4 = add_i32(loc_2, mul_i32(param_1, 12))
		loc_0 = load_i32(memory_at_0, loc_4)
		loc_5 = load_i32(memory_at_0, param_2 + 16)
		if loc_0 ~= loc_5 then
			loc_1 = 0
			::continue_at_13::
			while true do
				if loc_0 == loc_3 then goto continue_at_11 end
				loc_1 = add_i32(loc_1, 1)
				param_1 = band_i32(add_i32(loc_1, param_1), param_0)
				loc_4 = add_i32(loc_2, mul_i32(param_1, 12))
				loc_0 = load_i32(memory_at_0, loc_4)
				if loc_0 ~= loc_5 then goto continue_at_13 end
				break
			end
		end
		store_i32(memory_at_0, loc_4, loc_3)
		store_i32(
			memory_at_0, param_2 + 12, add_i32(load_i32(memory_at_0, param_2 + 12), 1)
		)
		::continue_at_11::
		param_1 = add_i32(add_i32(loc_2, mul_i32(param_1, 12)), 8)
		store_i32(memory_at_0, param_1, add_i32(load_i32(memory_at_0, param_1), 1))
		::continue_at_1::
	end
FUNC_LIST[76] = --[[ Luau::Compile::ShapeVisitor::assignField(Luau::AstExpr*, Luau::AstExpr*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		if param_1 == 0 then goto continue_at_1 end
		loc_3 = load_i32(memory_at_0, param_1 + 4)
		if loc_3 ~= load_i32(memory_at_0, 54940) then goto continue_at_1 end
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, param_0 + 12)
		if loc_1 == loc_2 then goto continue_at_1 end
		loc_5 = load_i32(memory_at_0, param_1 + 24)
		loc_4 = load_i32(memory_at_0, param_0 + 24)
		if loc_5 == loc_4 then goto continue_at_1 end
		loc_0 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
		loc_2 = sub_i32(shr_i32(sub_i32(loc_2, loc_1), 3), 1)
		param_1 = 0
		::continue_at_2::
		while true do
			loc_0 = band_i32(loc_0, loc_2)
			loc_6 = load_i32(memory_at_0, add_i32(loc_1, shl_i32(loc_0, 3)))
			if loc_5 ~= loc_6 then
				if loc_4 == loc_6 then goto continue_at_1 end
				param_1 = add_i32(param_1, 1)
				loc_0 = add_i32(param_1, loc_0)
				if le_u32(param_1, loc_2) then goto continue_at_2 end
				goto continue_at_1
			end
			break
		end
		loc_1 = add_i32(add_i32(loc_1, shl_i32(loc_0, 3)), 4)
		param_1 = load_i32(memory_at_0, param_2 + 4)
		if param_2 == 0 then goto continue_at_4 end
		if param_1 ~= load_i32(memory_at_0, 54924) then goto continue_at_4 end
		loc_3 = load_i32(memory_at_0, param_0 + 4)
		loc_6 = load_i32(memory_at_0, loc_3)
		param_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_3 + 4), loc_6), 12)
		if ge_u32(load_i32(memory_at_0, loc_3 + 12), shr_u32(mul_i32(param_1, 3), 2)) then
			FUNC_LIST[370](loc_3)
			loc_6 = load_i32(memory_at_0, loc_3)
			param_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_3 + 4), loc_6), 12)
		end
		loc_4 = sub_i32(param_1, 1)
		loc_1 = load_i32(memory_at_0, loc_1)
		param_1 = band_i32(loc_4, bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9)))
		loc_5 = add_i32(loc_6, mul_i32(param_1, 12))
		loc_0 = load_i32(memory_at_0, loc_5)
		param_0 = load_i32(memory_at_0, loc_3 + 16)
		if loc_0 ~= param_0 then
			loc_2 = 0
			::continue_at_8::
			while true do
				if loc_0 == loc_1 then goto continue_at_6 end
				loc_2 = add_i32(loc_2, 1)
				param_1 = band_i32(add_i32(loc_2, param_1), loc_4)
				loc_5 = add_i32(loc_6, mul_i32(param_1, 12))
				loc_0 = load_i32(memory_at_0, loc_5)
				if loc_0 ~= param_0 then goto continue_at_8 end
				break
			end
		end
		store_i32(memory_at_0, loc_5, loc_1)
		store_i32(
			memory_at_0, loc_3 + 12, add_i32(load_i32(memory_at_0, loc_3 + 12), 1)
		)
		::continue_at_6::
		param_1 = add_i32(loc_6, mul_i32(param_1, 12))
		loc_0 = add_i32(load_i32(memory_at_0, param_1 + 4), 1)
		if load_f64(memory_at_0, param_2 + 24) ~= convert_f64_u32(loc_0) then
			goto continue_at_1
		end
		store_i32(memory_at_0, param_1 + 4, loc_0)
		goto continue_at_0
		::continue_at_4::
		if param_2 == 0 then goto continue_at_1 end
		if param_1 ~= loc_3 then goto continue_at_1 end
		loc_5 = load_i32(memory_at_0, param_0 + 60)
		param_1 = load_i32(memory_at_0, sub_i32(param_0, -64))
		if loc_5 == param_1 then goto continue_at_1 end
		loc_4 = load_i32(memory_at_0, param_2 + 24)
		param_2 = load_i32(memory_at_0, param_0 + 76)
		if loc_4 == param_2 then goto continue_at_1 end
		loc_0 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_2 = sub_i32(shr_i32(sub_i32(param_1, loc_5), 3), 1)
		param_1 = 0
		::continue_at_9::
		while true do
			loc_6 = band_i32(loc_0, loc_2)
			loc_0 = load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_6, 3)))
			if loc_4 ~= loc_0 then
				if param_2 == loc_0 then goto continue_at_1 end
				param_1 = add_i32(param_1, 1)
				loc_0 = add_i32(param_1, loc_6)
				if le_u32(param_1, loc_2) then goto continue_at_9 end
				goto continue_at_1
			end
			break
		end
		loc_7 = load_i32(memory_at_0, param_0 + 4)
		loc_4 = load_i32(memory_at_0, loc_7)
		param_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_7 + 4), loc_4), 12)
		if ge_u32(load_i32(memory_at_0, loc_7 + 12), shr_u32(mul_i32(param_1, 3), 2)) then
			FUNC_LIST[370](loc_7)
			loc_4 = load_i32(memory_at_0, loc_7)
			param_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_7 + 4), loc_4), 12)
		end
		param_2 = sub_i32(param_1, 1)
		loc_1 = load_i32(memory_at_0, loc_1)
		param_1 = band_i32(param_2, bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9)))
		param_0 = add_i32(loc_4, mul_i32(param_1, 12))
		loc_0 = load_i32(memory_at_0, param_0)
		loc_3 = load_i32(memory_at_0, loc_7 + 16)
		if loc_0 ~= loc_3 then
			loc_2 = 0
			::continue_at_14::
			while true do
				if loc_0 == loc_1 then goto continue_at_12 end
				loc_2 = add_i32(loc_2, 1)
				param_1 = band_i32(add_i32(loc_2, param_1), param_2)
				param_0 = add_i32(loc_4, mul_i32(param_1, 12))
				loc_0 = load_i32(memory_at_0, param_0)
				if loc_0 ~= loc_3 then goto continue_at_14 end
				break
			end
		end
		store_i32(memory_at_0, param_0, loc_1)
		store_i32(
			memory_at_0, loc_7 + 12, add_i32(load_i32(memory_at_0, loc_7 + 12), 1)
		)
		::continue_at_12::
		param_1 = add_i32(loc_4, mul_i32(param_1, 12))
		if load_i32(memory_at_0, param_1 + 4) ~= 0 then goto continue_at_1 end
		store_i32(
			memory_at_0, param_1 + 4,
				load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_6, 3)) + 4)
		)
		::continue_at_1::
		::continue_at_0::
	end
FUNC_LIST[77] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 28)
		loc_1 = load_i32(memory_at_0, loc_0 + 4)
		if loc_0 == 0 then goto continue_at_2 end
		if loc_1 ~= load_i32(memory_at_0, 54972) then goto continue_at_2 end
		FUNC_LIST[75](
			param_0, load_i32(memory_at_0, loc_0 + 24), load_i32(memory_at_0, loc_0 + 28)
		)
		goto continue_at_1
		::continue_at_2::
		if loc_0 == 0 then goto continue_at_1 end
		if loc_1 ~= load_i32(memory_at_0, 54980) then goto continue_at_1 end
		FUNC_LIST[76](
			param_0, load_i32(memory_at_0, loc_0 + 24), load_i32(memory_at_0, loc_0 + 28)
		)
		::continue_at_1::
		loc_0 = load_i32(memory_at_0, param_1 + 32)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_0))](
			loc_0, param_0
		)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[78] = --[[ std::__2::vector<std::__2::pair<Luau::AstLocal*, Luau::AstExprTable*>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::AstExprTable*> > >::__append(unsigned long, std::__2::pair<Luau::AstLocal*, Luau::AstExprTable*> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_0, loc_1), 3)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = shl_i32(param_1, 3)
			loc_3 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_0 = loc_1
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_1 = add_i32(loc_1, loc_2)
			if lt_u32(loc_3, 7) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
				loc_0 = sub_i32(loc_0, -64)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_1)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = shr_i32(sub_i32(loc_1, loc_5), 3)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 536870912) then
			loc_0 = sub_i32(loc_0, loc_5)
			loc_5 = shr_i32(loc_0, 2)
			loc_5 = (lt_u32(loc_0, 2147483640) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 536870911)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 536870912) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
				loc_2 = reg_0
			end
			loc_7 = shl_i32(param_1, 3)
			loc_8 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_3 = add_i32(loc_2, shl_i32(loc_6, 3))
			loc_0 = loc_3
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_4 = add_i32(loc_3, loc_7)
			if ge_u32(loc_8, 7) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
					loc_0 = sub_i32(loc_0, -64)
					if loc_0 ~= loc_4 then goto continue_at_12 end
					break
				end
			end
			loc_2 = add_i32(loc_2, shl_i32(loc_5, 3))
			param_2 = load_i32(memory_at_0, param_0)
			loc_0 = sub_i32(loc_1, param_2)
			param_1 = sub_i32(loc_3, loc_0)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0) end
			store_i32(memory_at_0, param_0 + 8, loc_2)
			store_i32(memory_at_0, param_0 + 4, loc_4)
			store_i32(memory_at_0, param_0, param_1)
			if param_2 ~= 0 then FUNC_LIST[1276](param_2) end
			goto continue_at_0
		end
		FUNC_LIST[79](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[79] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstLocal*, Luau::AstExprTable*>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::AstExprTable*> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[80] = --[[ std::__2::vector<std::__2::pair<Luau::AstExprTable*, Luau::AstName>, std::__2::allocator<std::__2::pair<Luau::AstExprTable*, Luau::AstName> > >::__append(unsigned long, std::__2::pair<Luau::AstExprTable*, Luau::AstName> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_0, loc_1), 3)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = shl_i32(param_1, 3)
			loc_3 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_0 = loc_1
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_1 = add_i32(loc_1, loc_2)
			if lt_u32(loc_3, 7) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
				loc_0 = sub_i32(loc_0, -64)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_1)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = shr_i32(sub_i32(loc_1, loc_5), 3)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 536870912) then
			loc_0 = sub_i32(loc_0, loc_5)
			loc_5 = shr_i32(loc_0, 2)
			loc_5 = (lt_u32(loc_0, 2147483640) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 536870911)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 536870912) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
				loc_2 = reg_0
			end
			loc_7 = shl_i32(param_1, 3)
			loc_8 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_3 = add_i32(loc_2, shl_i32(loc_6, 3))
			loc_0 = loc_3
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_4 = add_i32(loc_3, loc_7)
			if ge_u32(loc_8, 7) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
					loc_0 = sub_i32(loc_0, -64)
					if loc_0 ~= loc_4 then goto continue_at_12 end
					break
				end
			end
			loc_2 = add_i32(loc_2, shl_i32(loc_5, 3))
			param_2 = load_i32(memory_at_0, param_0)
			loc_0 = sub_i32(loc_1, param_2)
			param_1 = sub_i32(loc_3, loc_0)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0) end
			store_i32(memory_at_0, param_0 + 8, loc_2)
			store_i32(memory_at_0, param_0 + 4, loc_4)
			store_i32(memory_at_0, param_0, param_1)
			if param_2 ~= 0 then FUNC_LIST[1276](param_2) end
			goto continue_at_0
		end
		FUNC_LIST[81](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[81] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstExprTable*, Luau::AstName>, std::__2::allocator<std::__2::pair<Luau::AstExprTable*, Luau::AstName> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[82] = --[[ std::__2::vector<std::__2::pair<Luau::AstLocal*, unsigned int>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, unsigned int> > >::__append(unsigned long, std::__2::pair<Luau::AstLocal*, unsigned int> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_0, loc_1), 3)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = shl_i32(param_1, 3)
			loc_3 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_0 = loc_1
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_1 = add_i32(loc_1, loc_2)
			if lt_u32(loc_3, 7) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
				loc_0 = sub_i32(loc_0, -64)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_1)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = shr_i32(sub_i32(loc_1, loc_5), 3)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 536870912) then
			loc_0 = sub_i32(loc_0, loc_5)
			loc_5 = shr_i32(loc_0, 2)
			loc_5 = (lt_u32(loc_0, 2147483640) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 536870911)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 536870912) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
				loc_2 = reg_0
			end
			loc_7 = shl_i32(param_1, 3)
			loc_8 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_3 = add_i32(loc_2, shl_i32(loc_6, 3))
			loc_0 = loc_3
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_4 = add_i32(loc_3, loc_7)
			if ge_u32(loc_8, 7) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
					loc_0 = sub_i32(loc_0, -64)
					if loc_0 ~= loc_4 then goto continue_at_12 end
					break
				end
			end
			loc_2 = add_i32(loc_2, shl_i32(loc_5, 3))
			param_2 = load_i32(memory_at_0, param_0)
			loc_0 = sub_i32(loc_1, param_2)
			param_1 = sub_i32(loc_3, loc_0)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0) end
			store_i32(memory_at_0, param_0 + 8, loc_2)
			store_i32(memory_at_0, param_0 + 4, loc_4)
			store_i32(memory_at_0, param_0, param_1)
			if param_2 ~= 0 then FUNC_LIST[1276](param_2) end
			goto continue_at_0
		end
		FUNC_LIST[83](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[83] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstLocal*, unsigned int>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, unsigned int> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[84] = --[[ Luau::detail::DenseHashTable<std::__2::pair<Luau::AstExprTable*, Luau::AstName>, std::__2::pair<Luau::AstExprTable*, Luau::AstName>, std::__2::pair<Luau::AstExprTable*, Luau::AstName>, Luau::detail::ItemInterfaceSet<std::__2::pair<Luau::AstExprTable*, Luau::AstName> >, Luau::Compile::ShapeVisitor::Hasher, std::__2::equal_to<std::__2::pair<Luau::AstExprTable*, Luau::AstName> > >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0LL
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_4 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_4 then
			if gt_u32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 127) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 16, 0LL )
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			loc_10 = load_i64(memory_at_0, param_0 + 16)
			store_i64(memory_at_0, loc_0 + 24, loc_10)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		loc_10 = load_i64(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 24, loc_10)
		reg_0 = shr_i32(sub_i32(loc_4, loc_1), 2)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 40, loc_10)
		FUNC_LIST[80](add_i32(loc_0, 8), loc_1, add_i32(loc_0, 40))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_2 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_2 then
			loc_2 = loc_1
			goto continue_at_2
		end
		::continue_at_7::
		while true do
			loc_11 = shl_i32(loc_7, 3)
			loc_12 = add_i32(loc_2, loc_11)
			loc_6 = load_i32(memory_at_0, loc_12 + 4)
			loc_3 = load_i32(memory_at_0, loc_12)
			if loc_3 == load_i32(memory_at_0, param_0 + 16) then
				if loc_6 == load_i32(memory_at_0, param_0 + 20) then goto continue_at_8 end
			end
			loc_8 = load_i32(memory_at_0, loc_0 + 8)
			loc_14 = sub_i32(
				shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 12), loc_8), 3), 1
			)
			loc_1 = bxor_i32(loc_3, loc_6)
			loc_4 = band_i32(loc_14, bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9)))
			loc_1 = add_i32(loc_8, shl_i32(loc_4, 3))
			loc_5 = load_i32(memory_at_0, loc_1 + 4)
			loc_9 = load_i32(memory_at_0, loc_1)
			loc_15 = load_i32(memory_at_0, loc_0 + 24)
			loc_16 = load_i32(memory_at_0, loc_0 + 28)
			if band_i32((loc_9 == loc_15 and 1 or 0), (loc_16 == loc_5 and 1 or 0)) ~= 0 then
				goto continue_at_11
			end
			loc_13 = 0
			if band_i32((loc_3 == loc_9 and 1 or 0), (loc_5 == loc_6 and 1 or 0)) ~= 0 then
				goto continue_at_10
			end
			::continue_at_12::
			while true do
				loc_13 = add_i32(loc_13, 1)
				loc_4 = band_i32(add_i32(loc_13, loc_4), loc_14)
				loc_1 = add_i32(loc_8, shl_i32(loc_4, 3))
				loc_5 = load_i32(memory_at_0, loc_1 + 4)
				loc_9 = load_i32(memory_at_0, loc_1)
				if band_i32((loc_15 == loc_9 and 1 or 0), (loc_5 == loc_16 and 1 or 0)) ~= 0 then
					goto continue_at_11
				end
				if loc_3 ~= loc_9 then goto continue_at_12 end
				if loc_5 ~= loc_6 then goto continue_at_12 end
				break
			end
			goto continue_at_10
			::continue_at_11::
			store_i32(memory_at_0, loc_1, loc_3)
			store_i32(memory_at_0, loc_1 + 4, load_i32(memory_at_0, loc_12 + 4))
			store_i32(
				memory_at_0, loc_0 + 20, add_i32(load_i32(memory_at_0, loc_0 + 20), 1)
			)
			loc_2 = load_i32(memory_at_0, param_0)
			loc_3 = load_i32(memory_at_0, add_i32(loc_2, loc_11))
			::continue_at_10::
			store_i32(memory_at_0, loc_1, loc_3)
			store_i32(
				memory_at_0, add_i32(loc_8, shl_i32(loc_4, 3)) + 4,
					load_i32(memory_at_0, add_i32(loc_2, loc_11) + 4)
			)
			loc_2 = load_i32(memory_at_0, param_0)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			::continue_at_8::
			loc_7 = add_i32(loc_7, 1)
			if lt_u32(loc_7, shr_i32(sub_i32(loc_1, loc_2), 3)) then goto continue_at_7 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_0 + 16))
		FUNC_LIST[80](param_0, 16, add_i32(loc_0, 8))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 12))
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 16))
		store_i32(memory_at_0, loc_0 + 16, loc_1)
		if loc_2 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 12, loc_2)
		FUNC_LIST[1276](loc_2)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[85] = --[[ Luau::BytecodeBuilder::BytecodeBuilder(Luau::BytecodeEncoder*) ]]
	function(param_0, param_1)
		local reg_0, reg_1
		store_i32(memory_at_0, param_0 + 16, -1)
		store_i64(memory_at_0, param_0 + 8, -4294967296LL )
		store_i64(memory_at_0, param_0, 0LL )
		reg_0 = FUNC_LIST[1121](add_i32(param_0, 20), 0, 73)
		store_i32(memory_at_0, param_0 + 112, 0)
		store_i64(memory_at_0, param_0 + 104, 0LL )
		store_i64(memory_at_0, param_0 + 96, 0LL )
		store_i64(memory_at_0, param_0 + 120, -1LL )
		reg_0 = FUNC_LIST[1121](add_i32(param_0, 136), 0, 148)
		store_i64(memory_at_0, param_0 + 296, 0LL )
		store_i64(memory_at_0, param_0 + 288, 0LL )
		store_i64(memory_at_0, param_0 + 312, 0LL )
		store_i32(memory_at_0, param_0 + 304, -1)
		store_i64(memory_at_0, param_0 + 320, 0LL )
		store_i64(memory_at_0, param_0 + 328, 0LL )
		store_i64(memory_at_0, param_0 + 336, 0LL )
		store_i64(memory_at_0, param_0 + 344, 0LL )
		store_i64(memory_at_0, param_0 + 352, 0LL )
		store_i32(memory_at_0, param_0 + 360, 0)
		store_i64(memory_at_0, param_0 + 368, 0LL )
		store_i64(memory_at_0, param_0 + 376, 0LL )
		store_i64(memory_at_0, param_0 + 384, 0LL )
		store_i64(memory_at_0, param_0 + 396, 0LL )
		store_i32(memory_at_0, param_0 + 392, param_1)
		store_i64(memory_at_0, param_0 + 404, 0LL )
		store_i64(memory_at_0, param_0 + 412, 0LL )
		store_i64(memory_at_0, param_0 + 420, 0LL )
		store_i32(memory_at_0, param_0 + 428, 0)
		reg_1 = FUNC_LIST[1275](128)
		param_1 = reg_1
		store_i32(memory_at_0, param_0 + 24, param_1)
		store_i32(memory_at_0, param_0 + 20, param_1)
		store_i32(memory_at_0, param_0 + 28, add_i32(param_1, 128))
		reg_1 = FUNC_LIST[1275](128)
		param_1 = reg_1
		store_i32(memory_at_0, param_0 + 36, param_1)
		store_i32(memory_at_0, param_0 + 32, param_1)
		store_i32(memory_at_0, param_0 + 40, add_i32(param_1, 128))
		reg_1 = FUNC_LIST[1275](256)
		param_1 = reg_1
		store_i32(memory_at_0, param_0 + 48, param_1)
		store_i32(memory_at_0, param_0 + 44, param_1)
		store_i32(memory_at_0, param_0 + 52, add_i32(param_1, 256))
		reg_1 = FUNC_LIST[1275](64)
		param_1 = reg_1
		store_i32(memory_at_0, param_0 + 60, param_1)
		store_i32(memory_at_0, param_0 + 56, param_1)
		store_i32(memory_at_0, sub_i32(param_0, -64), sub_i32(param_1, -64))
		FUNC_LIST[86](param_0, 8)
		reg_0 = param_0
		return reg_0
	end
FUNC_LIST[86] = --[[ std::__2::vector<Luau::BytecodeBuilder::Function, std::__2::allocator<Luau::BytecodeBuilder::Function> >::reserve(unsigned long) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_0)
		if ge_u32(
			div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 48), param_1
		) then goto continue_at_1 end
		if lt_u32(param_1, 89478486) then
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			param_1 = mul_i32(param_1, 48)
			reg_0 = FUNC_LIST[1275](param_1)
			loc_2 = reg_0
			loc_4 = add_i32(loc_2, param_1)
			loc_3 = add_i32(loc_2, mul_i32(div_i32(sub_i32(loc_0, loc_1), 48), 48))
			if loc_0 == loc_1 then goto continue_at_3 end
			param_1 = loc_3
			::continue_at_5::
			while true do
				param_1 = sub_i32(param_1, 48)
				loc_0 = sub_i32(loc_0, 48)
				store_i64(memory_at_0, param_1, load_i64(memory_at_0, loc_0))
				loc_2 = add_i32(loc_0, 8)
				store_i32(memory_at_0, param_1 + 8, load_i32(memory_at_0, loc_2))
				store_i64(memory_at_0, loc_0, 0LL )
				store_i32(memory_at_0, loc_2, 0)
				store_i32(memory_at_0, param_1 + 20, load_i32(memory_at_0, loc_0 + 20))
				store_i64(memory_at_0, param_1 + 12, load_i64(memory_at_0, loc_0 + 12))
				loc_2 = add_i32(loc_0, 32)
				store_i32(memory_at_0, param_1 + 32, load_i32(memory_at_0, loc_2))
				store_i64(memory_at_0, param_1 + 24, load_i64(memory_at_0, loc_0 + 24))
				store_i32(memory_at_0, loc_2, 0)
				store_i64(memory_at_0, loc_0 + 24, 0LL )
				loc_2 = add_i32(loc_0, 44)
				store_i32(memory_at_0, param_1 + 44, load_i32(memory_at_0, loc_2))
				store_i64(memory_at_0, param_1 + 36, load_i64(memory_at_0, loc_0 + 36))
				store_i64(memory_at_0, loc_0 + 36, 0LL )
				store_i32(memory_at_0, loc_2, 0)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			store_i32(memory_at_0, param_0 + 8, loc_4)
			store_i32(memory_at_0, param_0, param_1)
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			store_i32(memory_at_0, param_0 + 4, loc_3)
			if loc_0 == loc_1 then goto continue_at_2 end
			::continue_at_6::
			while true do
				if load_i32_i8(memory_at_0, sub_i32(loc_0, 1)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 12)))
				end
				param_1 = sub_i32(loc_0, 48)
				if load_i32_i8(memory_at_0, sub_i32(loc_0, 13)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 24)))
				end
				if load_i32_i8(memory_at_0, param_1 + 11) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, param_1))
				end
				loc_0 = param_1
				if loc_1 ~= loc_0 then goto continue_at_6 end
				break
			end
			goto continue_at_2
		end
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_3::
		store_i32(memory_at_0, param_0 + 8, loc_4)
		store_i32(memory_at_0, param_0 + 4, loc_3)
		store_i32(memory_at_0, param_0, loc_3)
		::continue_at_2::
		if loc_1 == 0 then goto continue_at_1 end
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
	end
FUNC_LIST[87] = --[[ Luau::BytecodeBuilder::beginFunction(unsigned char, bool) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		loc_3 = add_i32(loc_0, 24)
		store_i64(memory_at_0, loc_3, 0LL )
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		store_i32_n8(memory_at_0, loc_0 + 15, param_2)
		store_i32_n8(memory_at_0, loc_0 + 13, param_1)
		param_1 = div_i32(sub_i32(loc_1, loc_2), 48)
		if load_i32(memory_at_0, param_0 + 8) ~= loc_1 then
			store_i64(memory_at_0, loc_1, 0LL )
			store_i32(memory_at_0, loc_1 + 8, 0)
			store_i32(memory_at_0, loc_1 + 20, load_i32(memory_at_0, loc_0 + 20))
			store_i64(memory_at_0, loc_1 + 12, load_i64(memory_at_0, loc_0 + 12))
			param_2 = add_i32(loc_1, 24)
			if load_i32_i8(memory_at_0, loc_0 + 35) >= 0 then
				store_i64(memory_at_0, param_2, load_i64(memory_at_0, loc_3))
				store_i32(memory_at_0, param_2 + 8, load_i32(memory_at_0, loc_3 + 8))
				goto continue_at_3
			end
			FUNC_LIST[1345](
				param_2, load_i32(memory_at_0, loc_0 + 24),
					load_i32(memory_at_0, loc_0 + 28)
			)
			::continue_at_3::
			param_2 = add_i32(loc_1, 36)
			if load_i32_i8(memory_at_0, loc_0 + 47) >= 0 then
				loc_2 = add_i32(loc_0, 36)
				store_i64(memory_at_0, param_2, load_i64(memory_at_0, loc_2))
				store_i32(memory_at_0, param_2 + 8, load_i32(memory_at_0, loc_2 + 8))
				goto continue_at_5
			end
			FUNC_LIST[1345](
				param_2, load_i32(memory_at_0, loc_0 + 36),
					load_i32(memory_at_0, loc_0 + 40)
			)
			::continue_at_5::
			store_i32(memory_at_0, param_0 + 4, add_i32(loc_1, 48))
			goto continue_at_1
		end
		FUNC_LIST[88](param_0, loc_0)
		::continue_at_1::
		store_i32(memory_at_0, param_0 + 312, 0)
		store_i32_n8(memory_at_0, param_0 + 92, 0)
		store_i32(memory_at_0, param_0 + 12, param_1)
		if load_i32_i8(memory_at_0, loc_0 + 47) < 0 then
			FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 36))
		end
		if load_i32_i8(memory_at_0, loc_0 + 35) < 0 then
			FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 24))
		end
		if load_i32_i8(memory_at_0, loc_0 + 11) < 0 then
			FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
		end
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
		reg_0 = param_1
		return reg_0
	end
FUNC_LIST[88] = --[[ void std::__2::vector<Luau::BytecodeBuilder::Function, std::__2::allocator<Luau::BytecodeBuilder::Function> >::__push_back_slow_path<Luau::BytecodeBuilder::Function const&>(Luau::BytecodeBuilder::Function const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_1), 48)
		loc_0 = add_i32(loc_2, 1)
		if lt_u32(loc_0, 89478486) then
			loc_1 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 48)
			loc_3 = shl_i32(loc_1, 1)
			loc_1 =
				(lt_u32(loc_1, 44739242) and (lt_u32(loc_0, loc_3) and loc_3 or loc_0) or
					89478485)
			if loc_1 ~= 0 then
				if ge_u32(loc_1, 89478486) then goto continue_at_3 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_1, 48))
				loc_4 = reg_0
			end
			loc_0 = add_i32(loc_4, mul_i32(loc_2, 48))
			if load_i32_i8(memory_at_0, param_1 + 11) >= 0 then
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
				store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_1 + 8))
				goto continue_at_6
			end
			FUNC_LIST[1345](
				loc_0, load_i32(memory_at_0, param_1), load_i32(memory_at_0, param_1 + 4)
			)
			::continue_at_6::
			loc_3 = add_i32(loc_4, mul_i32(loc_2, 48))
			store_i64(memory_at_0, loc_3 + 12, load_i64(memory_at_0, param_1 + 12))
			store_i32(memory_at_0, loc_3 + 20, load_i32(memory_at_0, param_1 + 20))
			loc_5 = add_i32(param_1, 24)
			loc_3 = add_i32(loc_3, 24)
			if load_i32_i8(memory_at_0, param_1 + 35) >= 0 then
				store_i64(memory_at_0, loc_3, load_i64(memory_at_0, loc_5))
				store_i32(memory_at_0, loc_3 + 8, load_i32(memory_at_0, loc_5 + 8))
				goto continue_at_8
			end
			FUNC_LIST[1345](
				loc_3, load_i32(memory_at_0, loc_5), load_i32(memory_at_0, loc_5 + 4)
			)
			::continue_at_8::
			loc_3 = mul_i32(loc_1, 48)
			loc_1 = add_i32(param_1, 36)
			loc_2 = add_i32(add_i32(loc_4, mul_i32(loc_2, 48)), 36)
			if load_i32_i8(memory_at_0, param_1 + 47) >= 0 then
				store_i64(memory_at_0, loc_2, load_i64(memory_at_0, loc_1))
				store_i32(memory_at_0, loc_2 + 8, load_i32(memory_at_0, loc_1 + 8))
				goto continue_at_10
			end
			FUNC_LIST[1345](
				loc_2, load_i32(memory_at_0, loc_1), load_i32(memory_at_0, loc_1 + 4)
			)
			::continue_at_10::
			loc_1 = add_i32(loc_3, loc_4)
			loc_3 = add_i32(loc_0, 48)
			param_1 = load_i32(memory_at_0, param_0 + 4)
			loc_2 = load_i32(memory_at_0, param_0)
			if param_1 == loc_2 then goto continue_at_2 end
			::continue_at_12::
			while true do
				loc_0 = sub_i32(loc_0, 48)
				param_1 = sub_i32(param_1, 48)
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
				loc_4 = add_i32(param_1, 8)
				store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_4))
				store_i64(memory_at_0, param_1, 0LL )
				store_i32(memory_at_0, loc_4, 0)
				store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, param_1 + 20))
				store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_1 + 12))
				loc_4 = add_i32(param_1, 32)
				store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_4))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_1 + 24))
				store_i32(memory_at_0, loc_4, 0)
				store_i64(memory_at_0, param_1 + 24, 0LL )
				loc_4 = add_i32(param_1, 44)
				store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_4))
				store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_1 + 36))
				store_i64(memory_at_0, param_1 + 36, 0LL )
				store_i32(memory_at_0, loc_4, 0)
				if param_1 ~= loc_2 then goto continue_at_12 end
				break
			end
			store_i32(memory_at_0, param_0 + 8, loc_1)
			param_1 = load_i32(memory_at_0, param_0 + 4)
			store_i32(memory_at_0, param_0 + 4, loc_3)
			loc_2 = load_i32(memory_at_0, param_0)
			store_i32(memory_at_0, param_0, loc_0)
			if param_1 == loc_2 then goto continue_at_1 end
			::continue_at_13::
			while true do
				if load_i32_i8(memory_at_0, sub_i32(param_1, 1)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(param_1, 12)))
				end
				loc_0 = sub_i32(param_1, 48)
				if load_i32_i8(memory_at_0, sub_i32(param_1, 13)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(param_1, 24)))
				end
				if load_i32_i8(memory_at_0, loc_0 + 11) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
				end
				param_1 = loc_0
				if param_1 ~= loc_2 then goto continue_at_13 end
				break
			end
			goto continue_at_1
		end
		FUNC_LIST[152](param_0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_2::
		store_i32(memory_at_0, param_0 + 8, loc_1)
		store_i32(memory_at_0, param_0 + 4, loc_3)
		store_i32(memory_at_0, param_0, loc_0)
		::continue_at_1::
		if loc_2 ~= 0 then FUNC_LIST[1276](loc_2) end
	end
FUNC_LIST[89] = --[[ Luau::BytecodeBuilder::endFunction(unsigned char, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0, reg_1, reg_2
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_1
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = load_i32(memory_at_0, param_0 + 12)
		loc_0 = add_i32(loc_2, mul_i32(loc_3, 48))
		store_i32_n8(memory_at_0, loc_0 + 14, param_2)
		store_i32_n8(memory_at_0, loc_0 + 12, param_1)
		FUNC_LIST[1347](
			loc_0, add_i32(
				mul_i32(
					shr_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
						), 2
					), 7
				), 32
			)
		)
		FUNC_LIST[90](param_0, loc_0, load_i32(memory_at_0, param_0 + 12))
		store_i32(memory_at_0, param_0 + 12, -1)
		param_1 = load_i32(memory_at_0, param_0 + 428)
		param_2 = band_i32(param_1, 1)
		loc_0 = load_i32(memory_at_0, param_0 + 424)
		if bor_i32(param_2, loc_0) ~= 0 then
			param_1 = add_i32(param_0, shr_i32(param_1, 1))
			reg_0 = loc_1
			reg_1 = param_1
			if param_2 ~= 0 then
				loc_0 =
					load_i32(memory_at_0, add_i32(load_i32(memory_at_0, param_1), loc_0))
			end
			reg_2 = loc_0
			TABLE_LIST[0].data[reg_2](reg_0, reg_1)
			param_1 = add_i32(loc_2, mul_i32(loc_3, 48))
			loc_0 = add_i32(param_1, 24)
			if load_i32_i8(memory_at_0, param_1 + 35) < 0 then
				FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
			end
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_1))
			store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1 + 8))
		end
		store_i32(memory_at_0, param_0 + 24, load_i32(memory_at_0, param_0 + 20))
		store_i32(memory_at_0, param_0 + 36, load_i32(memory_at_0, param_0 + 32))
		store_i32(memory_at_0, param_0 + 48, load_i32(memory_at_0, param_0 + 44))
		store_i32(memory_at_0, param_0 + 60, load_i32(memory_at_0, param_0 + 56))
		store_i32(memory_at_0, param_0 + 72, load_i32(memory_at_0, param_0 + 68))
		store_i32(memory_at_0, param_0 + 84, load_i32(memory_at_0, param_0 + 80))
		store_i32(memory_at_0, param_0 + 320, load_i32(memory_at_0, param_0 + 316))
		store_i32(memory_at_0, param_0 + 332, load_i32(memory_at_0, param_0 + 328))
		store_i32(memory_at_0, param_0 + 108, 0)
		store_i32(memory_at_0, param_0 + 100, load_i32(memory_at_0, param_0 + 96))
		store_i32(memory_at_0, param_0 + 148, 0)
		store_i32(memory_at_0, param_0 + 300, 0)
		store_i32(memory_at_0, param_0 + 140, load_i32(memory_at_0, param_0 + 136))
		store_i32(memory_at_0, param_0 + 292, load_i32(memory_at_0, param_0 + 288))
		store_i32(memory_at_0, param_0 + 372, load_i32(memory_at_0, param_0 + 368))
		if load_i32_i8(memory_at_0, param_0 + 391) < 0 then
			store_i32_n8(memory_at_0, load_i32(memory_at_0, param_0 + 380), 0)
			store_i32(memory_at_0, param_0 + 384, 0)
			goto continue_at_5
		end
		store_i32_n8(memory_at_0, param_0 + 391, 0)
		store_i32_n8(memory_at_0, param_0 + 380, 0)
		::continue_at_5::
		GLOBAL_LIST[0].value = add_i32(loc_1, 16)
	end
FUNC_LIST[90] = --[[ Luau::BytecodeBuilder::writeFunction(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >&, unsigned int) const ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_1
		loc_7 = load_i32(memory_at_0, param_0)
		loc_0 = add_i32(loc_7, mul_i32(param_2, 48))
		store_i32_n8(memory_at_0, loc_1 + 8, load_i32_u8(memory_at_0, loc_0 + 12))
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		store_i32_n8(memory_at_0, loc_1 + 8, load_i32_u8(memory_at_0, loc_0 + 13))
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		store_i32_n8(memory_at_0, loc_1 + 8, load_i32_u8(memory_at_0, loc_0 + 14))
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		store_i32_n8(memory_at_0, loc_1 + 8, load_i32_u8(memory_at_0, loc_0 + 15))
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		loc_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
			), 2
		)
		::continue_at_1::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_1 end
			break
		end
		loc_2 = load_i32(memory_at_0, param_0 + 20)
		if loc_2 ~= load_i32(memory_at_0, param_0 + 24) then
			loc_0 = 0
			::continue_at_3::
			while true do
				loc_5 = shl_i32(loc_0, 2)
				loc_2 = load_i32(memory_at_0, add_i32(loc_2, loc_5))
				loc_6 = band_i32(loc_2, 255)
				reg_0 = FUNC_LIST[91](loc_6)
				loc_3 = reg_0
				loc_4 = load_i32(memory_at_0, param_0 + 392)
				if loc_4 == 0 then
					loc_4 = loc_2
					goto continue_at_4
				end
				reg_0 = TABLE_LIST[0].data[load_i32(
					memory_at_0, load_i32(memory_at_0, loc_4) + 8
				)](loc_4, loc_6)
				loc_4 = reg_0
				loc_2 = load_i32(
					memory_at_0, add_i32(load_i32(memory_at_0, param_0 + 20), loc_5)
				)
				::continue_at_4::
				store_i32(
					memory_at_0, loc_1 + 8,
						bor_i32(band_i32(loc_2, -256), band_i32(loc_4, 255))
				)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 4)
				if ge_u32(loc_3, 2) then
					store_i32(
						memory_at_0, loc_1 + 8, load_i32(
							memory_at_0, add_i32(loc_5, load_i32(memory_at_0, param_0 + 20)) + 4
						)
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 4)
				end
				loc_0 = add_i32(loc_0, loc_3)
				loc_2 = load_i32(memory_at_0, param_0 + 20)
				if lt_u32(
					loc_0, shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 24), loc_2), 2)
				) then goto continue_at_3 end
				break
			end
		end
		loc_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 48), load_i32(memory_at_0, param_0 + 44)
			), 4
		)
		::continue_at_7::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_7 end
			break
		end
		loc_4 = load_i32(memory_at_0, param_0 + 44)
		loc_8 = load_i32(memory_at_0, param_0 + 48)
		if loc_4 ~= loc_8 then
			::continue_at_9::
			while true do
				if not br_map[1] then
					br_map[1] = (function() return { [0] = 0, 1, 2, 3, 4, 5, 6 } end)()
				end
				temp = br_map[1][load_i32(memory_at_0, loc_4)] or 7
				if temp < 4 then
					if temp < 2 then
						if temp < 1 then
							goto continue_at_17
						else
							goto continue_at_16
						end
					elseif temp > 2 then
						goto continue_at_14
					else
						goto continue_at_15
					end
				elseif temp > 4 then
					if temp < 6 then
						goto continue_at_12
					elseif temp > 6 then
						goto continue_at_10
					else
						goto continue_at_11
					end
				else
					goto continue_at_13
				end
				::continue_at_17::
				store_i32_n8(memory_at_0, loc_1 + 8, 0)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				goto continue_at_10
				::continue_at_16::
				store_i32_n8(memory_at_0, loc_1 + 8, 1)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				store_i32_n8(memory_at_0, loc_1 + 8, load_i32_u8(memory_at_0, loc_4 + 8))
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				goto continue_at_10
				::continue_at_15::
				store_i32_n8(memory_at_0, loc_1 + 8, 2)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				store_f64(memory_at_0, loc_1 + 8, load_f64(memory_at_0, loc_4 + 8))
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 8)
				goto continue_at_10
				::continue_at_14::
				store_i32_n8(memory_at_0, loc_1 + 8, 3)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				loc_0 = load_i32(memory_at_0, loc_4 + 8)
				::continue_at_18::
				while true do
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(
							band_i32(loc_0, 127), shl_i32((gt_u32(loc_0, 127) and 1 or 0), 7)
						)
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_2 = (lt_u32(loc_0, 128) and 1 or 0)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 == 0 then goto continue_at_18 end
					break
				end
				goto continue_at_10
				::continue_at_13::
				store_i32_n8(memory_at_0, loc_1 + 8, 4)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				store_i32(memory_at_0, loc_1 + 8, load_i32(memory_at_0, loc_4 + 8))
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 4)
				goto continue_at_10
				::continue_at_12::
				loc_0 = load_i32(memory_at_0, param_0 + 80)
				loc_2 = load_i32(memory_at_0, loc_4 + 8)
				store_i32_n8(memory_at_0, loc_1 + 8, 5)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				loc_5 = add_i32(loc_0, mul_i32(loc_2, 132))
				loc_6 = add_i32(loc_5, 128)
				loc_0 = load_i32(memory_at_0, loc_5 + 128)
				::continue_at_19::
				while true do
					loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 ~= 0 then goto continue_at_19 end
					break
				end
				loc_3 = 0
				if load_i32(memory_at_0, loc_6) == 0 then goto continue_at_10 end
				::continue_at_20::
				while true do
					loc_0 = load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_3, 2)))
					::continue_at_21::
					while true do
						loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
						store_i32_n8(
							memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
						)
						reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
						loc_0 = shr_u32(loc_0, 7)
						if loc_2 ~= 0 then goto continue_at_21 end
						break
					end
					loc_3 = add_i32(loc_3, 1)
					if lt_u32(loc_3, load_i32(memory_at_0, loc_6)) then goto continue_at_20 end
					break
				end
				goto continue_at_10
				::continue_at_11::
				store_i32_n8(memory_at_0, loc_1 + 8, 6)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				loc_0 = load_i32(memory_at_0, loc_4 + 8)
				::continue_at_22::
				while true do
					loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 ~= 0 then goto continue_at_22 end
					break
				end
				::continue_at_10::
				loc_4 = add_i32(loc_4, 16)
				if loc_4 ~= loc_8 then goto continue_at_9 end
				break
			end
		end
		loc_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 60), load_i32(memory_at_0, param_0 + 56)
			), 2
		)
		::continue_at_23::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_23 end
			break
		end
		loc_3 = load_i32(memory_at_0, param_0 + 56)
		loc_4 = load_i32(memory_at_0, param_0 + 60)
		if loc_3 ~= loc_4 then
			::continue_at_25::
			while true do
				loc_0 = load_i32(memory_at_0, loc_3)
				::continue_at_26::
				while true do
					loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 ~= 0 then goto continue_at_26 end
					break
				end
				loc_3 = add_i32(loc_3, 4)
				if loc_3 ~= loc_4 then goto continue_at_25 end
				break
			end
		end
		loc_0 = load_i32(memory_at_0, add_i32(loc_7, mul_i32(param_2, 48)) + 20)
		::continue_at_27::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_27 end
			break
		end
		loc_0 = load_i32(memory_at_0, add_i32(loc_7, mul_i32(param_2, 48)) + 16)
		::continue_at_28::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_28 end
			break
		end
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		loc_2 = load_i32(memory_at_0, param_0 + 36)
		if loc_0 == loc_2 then goto continue_at_30 end
		::continue_at_31::
		while true do
			if load_i32(memory_at_0, loc_0) ~= 0 then
				loc_0 = add_i32(loc_0, 4)
				if loc_2 ~= loc_0 then goto continue_at_31 end
				goto continue_at_30
			end
			break
		end
		store_i32_n8(memory_at_0, loc_1 + 8, 0)
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		goto continue_at_29
		::continue_at_30::
		store_i32_n8(memory_at_0, loc_1 + 8, 1)
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		FUNC_LIST[92](param_0, param_1)
		::continue_at_29::
		if load_i32(memory_at_0, param_0 + 316) ==
			load_i32(memory_at_0, param_0 + 320) then
			if load_i32(memory_at_0, param_0 + 328) ==
				load_i32(memory_at_0, param_0 + 332) then goto continue_at_34 end
		end
		store_i32_n8(memory_at_0, loc_1 + 8, 1)
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		loc_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 320), load_i32(memory_at_0, param_0 + 316)
			), 4
		)
		::continue_at_36::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_36 end
			break
		end
		loc_3 = load_i32(memory_at_0, param_0 + 316)
		loc_4 = load_i32(memory_at_0, param_0 + 320)
		if loc_3 ~= loc_4 then
			::continue_at_38::
			while true do
				loc_0 = load_i32(memory_at_0, loc_3)
				::continue_at_39::
				while true do
					loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 ~= 0 then goto continue_at_39 end
					break
				end
				loc_0 = load_i32(memory_at_0, loc_3 + 8)
				::continue_at_40::
				while true do
					loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 ~= 0 then goto continue_at_40 end
					break
				end
				loc_0 = load_i32(memory_at_0, loc_3 + 12)
				::continue_at_41::
				while true do
					loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_2 ~= 0 then goto continue_at_41 end
					break
				end
				store_i32_n8(memory_at_0, loc_1 + 8, load_i32_u8(memory_at_0, loc_3 + 4))
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				loc_3 = add_i32(loc_3, 16)
				if loc_3 ~= loc_4 then goto continue_at_38 end
				break
			end
		end
		loc_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 332), load_i32(memory_at_0, param_0 + 328)
			), 2
		)
		::continue_at_42::
		while true do
			loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_2 ~= 0 then goto continue_at_42 end
			break
		end
		loc_3 = load_i32(memory_at_0, param_0 + 328)
		param_0 = load_i32(memory_at_0, param_0 + 332)
		if loc_3 == param_0 then goto continue_at_33 end
		::continue_at_43::
		while true do
			loc_0 = load_i32(memory_at_0, loc_3)
			::continue_at_44::
			while true do
				loc_2 = (gt_u32(loc_0, 127) and 1 or 0)
				store_i32_n8(
					memory_at_0, loc_1 + 8, bor_i32(band_i32(loc_0, 127), shl_i32(loc_2, 7))
				)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
				loc_0 = shr_u32(loc_0, 7)
				if loc_2 ~= 0 then goto continue_at_44 end
				break
			end
			loc_3 = add_i32(loc_3, 4)
			if loc_3 ~= param_0 then goto continue_at_43 end
			break
		end
		goto continue_at_33
		::continue_at_34::
		store_i32_n8(memory_at_0, loc_1 + 8, 0)
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
		::continue_at_33::
		GLOBAL_LIST[0].value = add_i32(loc_1, 16)
	end
FUNC_LIST[91] = --[[ Luau::getOpLength(LuauOpcode) ]] function(param_0)
	local loc_0 = 0
	local reg_0
	local br_map, temp = {}, nil
	loc_0 = 2
	if not br_map[1] then
		br_map[1] = (function()
			return {
				[0] = 1,
				1,
				0,
				0,
				0,
				1,
				0,
				0,
				1,
				1,
				0,
				0,
				0,
				1,
				0,
				0,
				0,
				0,
				0,
				0,
				1,
				1,
				1,
				1,
				1,
				1,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				1,
				0,
				1,
				0,
				0,
				1,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				1,
				0,
				0,
				0,
				0,
				1,
				1,
				0,
				1,
				1,
			}
		end)()
	end
	temp = br_map[1][sub_i32(param_0, 7)] or 0
	if temp < 1 then
		goto continue_at_2
	else
		goto continue_at_1
	end
	::continue_at_2::
	loc_0 = 1
	::continue_at_1::
	reg_0 = loc_0
	return reg_0
end
FUNC_LIST[92] = --[[ Luau::BytecodeBuilder::writeLineInfo(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >&) const ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local reg_0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_3
		loc_10 = load_i32(memory_at_0, param_0 + 36)
		loc_8 = load_i32(memory_at_0, param_0 + 32)
		loc_2 = shr_i32(sub_i32(loc_10, loc_8), 2)
		loc_9 = 16777216
		if loc_8 ~= loc_10 then
			::continue_at_2::
			while true do
				loc_4 = loc_6
				loc_6 = add_i32(loc_4, loc_9)
				if ge_u32(loc_4, loc_6) then
					loc_1 = (gt_u32(loc_2, loc_4) and 1 or 0)
					loc_0 = loc_4
					goto continue_at_3
				end
				loc_5 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_4, 2)))
				loc_7 = loc_5
				loc_0 = loc_4
				::continue_at_5::
				while true do
					loc_0 = add_i32(loc_0, 1)
					loc_1 = (lt_u32(loc_0, loc_2) and 1 or 0)
					if ge_u32(loc_0, loc_2) then goto continue_at_3 end
					if ge_u32(loc_0, loc_6) then goto continue_at_3 end
					loc_1 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_0, 2)))
					loc_5 = (loc_1 < loc_5 and loc_5 or loc_1)
					loc_7 = (loc_1 < loc_7 and loc_1 or loc_7)
					if sub_i32(loc_5, loc_7) < 256 then goto continue_at_5 end
					break
				end
				loc_1 = 1
				::continue_at_3::
				if loc_1 == 0 then goto continue_at_6 end
				loc_1 = 0
				loc_5 = sub_i32(loc_0, loc_4)
				if ge_u32(loc_5, loc_9) then goto continue_at_6 end
				::continue_at_7::
				while true do
					loc_0 = loc_1
					loc_1 = add_i32(loc_0, 1)
					if shl_i32(2, loc_0) <= loc_5 then goto continue_at_7 end
					break
				end
				loc_9 = shl_i32(1, loc_0)
				loc_6 = add_i32(loc_9, loc_4)
				::continue_at_6::
				if gt_u32(loc_2, loc_6) then goto continue_at_2 end
				break
			end
		end
		loc_7 = 0
		store_i32(memory_at_0, loc_3 + 24, 0)
		store_i32(memory_at_0, loc_3 + 16, 0)
		store_i64(memory_at_0, loc_3 + 8, 0LL )
		loc_4 = add_i32(loc_3, 24)
		loc_12 = div_u32(sub_i32(loc_2, 1), loc_9)
		loc_11 = add_i32(loc_12, 1)
		if gt_u32(loc_11, 1) then
			FUNC_LIST[135](add_i32(loc_3, 8), loc_11)
			loc_4 = load_i32(memory_at_0, loc_3 + 8)
			loc_10 = load_i32(memory_at_0, param_0 + 36)
			loc_8 = load_i32(memory_at_0, param_0 + 32)
			loc_2 = shr_i32(sub_i32(loc_10, loc_8), 2)
		end
		if loc_8 ~= loc_10 then
			::continue_at_10::
			while true do
				loc_6 = loc_7
				loc_1 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_6, 2)))
				loc_7 = add_i32(loc_6, loc_9)
				if ge_u32(loc_6, loc_7) then goto continue_at_11 end
				loc_0 = add_i32(loc_6, 1)
				if ge_u32(loc_0, loc_2) then goto continue_at_11 end
				if ge_u32(loc_0, loc_7) then goto continue_at_11 end
				::continue_at_12::
				while true do
					loc_5 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_0, 2)))
					loc_1 = (loc_1 > loc_5 and loc_5 or loc_1)
					loc_0 = add_i32(loc_0, 1)
					if ge_u32(loc_0, loc_2) then goto continue_at_11 end
					if lt_u32(loc_0, loc_7) then goto continue_at_12 end
					break
				end
				::continue_at_11::
				store_i32(
					memory_at_0, add_i32(loc_4, shl_i32(div_u32(loc_6, loc_9), 2)), loc_1
				)
				if gt_u32(loc_2, loc_7) then goto continue_at_10 end
				break
			end
		end
		loc_1 = 0
		::continue_at_13::
		while true do
			loc_0 = loc_1
			loc_1 = add_i32(loc_0, 1)
			if shl_i32(2, loc_0) <= loc_9 then goto continue_at_13 end
			break
		end
		store_i32_n8(memory_at_0, loc_3 + 28, loc_0)
		reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_3, 28), 1)
		loc_2 = load_i32(memory_at_0, param_0 + 32)
		if loc_2 ~= load_i32(memory_at_0, param_0 + 36) then
			loc_1 = 0
			loc_5 = 0
			::continue_at_15::
			while true do
				loc_2 = sub_i32(
					load_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_1, 2))),
						load_i32(memory_at_0, add_i32(loc_4, shl_i32(shr_u32(loc_1, loc_0), 2)))
				)
				store_i32_n8(memory_at_0, loc_3 + 28, sub_i32(loc_2, loc_5))
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_3, 28), 1)
				loc_5 = loc_2
				loc_1 = add_i32(loc_1, 1)
				loc_2 = load_i32(memory_at_0, param_0 + 32)
				if lt_u32(
					loc_1, shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 36), loc_2), 2)
				) then goto continue_at_15 end
				break
			end
		end
		if loc_11 ~= 0 then
			loc_0 = 0
			loc_1 = 0
			::continue_at_17::
			while true do
				loc_2 = add_i32(loc_4, shl_i32(loc_0, 2))
				store_i32(
					memory_at_0, loc_3 + 28, sub_i32(load_i32(memory_at_0, loc_2), loc_1)
				)
				reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_3, 28), 4)
				loc_5 = (loc_0 == loc_12 and 1 or 0)
				loc_1 = load_i32(memory_at_0, loc_2)
				loc_0 = add_i32(loc_0, 1)
				if loc_5 == 0 then goto continue_at_17 end
				break
			end
		end
		loc_0 = load_i32(memory_at_0, loc_3 + 8)
		if loc_0 ~= 0 then
			store_i32(memory_at_0, loc_3 + 12, loc_0)
			FUNC_LIST[1276](loc_0)
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 32)
	end
FUNC_LIST[93] = --[[ Luau::BytecodeBuilder::setMainFunction(unsigned int) ]]
	function(param_0, param_1) store_i32(memory_at_0, param_0 + 16, param_1) end
FUNC_LIST[94] = --[[ Luau::BytecodeBuilder::addConstant(Luau::BytecodeBuilder::ConstantKey const&, Luau::BytecodeBuilder::Constant const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0LL
		local loc_8 = 0LL
		local loc_9 = 0
		local loc_10 = 0LL
		local reg_0
		loc_6 = add_i32(param_0, 96)
		loc_2 = load_i32(memory_at_0, param_0 + 96)
		loc_3 = load_i32(memory_at_0, param_0 + 100)
		if loc_2 == loc_3 then goto continue_at_4 end
		loc_4 = load_i32(memory_at_0, param_1)
		loc_9 = load_i32(memory_at_0, loc_6 + 16)
		loc_10 = load_i64(memory_at_0, loc_6 + 24)
		loc_7 = load_i64(memory_at_0, param_1 + 8)
		if band_i32((loc_4 == loc_9 and 1 or 0), (loc_10 == loc_7 and 1 or 0)) ~= 0 then
			goto continue_at_4
		end
		loc_0 = bxor_i32(
			wrap_i32_i64(shr_u64(loc_7, 32LL )), mul_i32(loc_4, 1540483477)
		)
		loc_1 = mul_i32(bxor_i32(wrap_i32_i64(loc_7), shr_u32(loc_0, 18)), 1540483477)
		loc_0 = mul_i32(bxor_i32(shr_u32(loc_1, 22), loc_0), 1540483477)
		loc_0 = mul_i32(
			bxor_i32(
				shr_u32(
					mul_i32(
						bxor_i32(shr_u32(loc_0, 17), loc_1), 1540483477
					), 19
				), loc_0
			), 1540483477
		)
		loc_1 = sub_i32(div_i32(sub_i32(loc_3, loc_2), 24), 1)
		loc_3 = 0
		::continue_at_5::
		while true do
			loc_5 = band_i32(loc_0, loc_1)
			loc_0 = add_i32(loc_2, mul_i32(loc_5, 24))
			loc_8 = load_i64(memory_at_0, loc_0 + 8)
			loc_0 = load_i32(memory_at_0, loc_0)
			if band_i32((loc_4 == loc_0 and 1 or 0), (loc_7 == loc_8 and 1 or 0)) ~= 0 then
				goto continue_at_3
			end
			if band_i32((loc_0 == loc_9 and 1 or 0), (loc_8 == loc_10 and 1 or 0)) ~= 0 then
				goto continue_at_4
			end
			loc_3 = add_i32(loc_3, 1)
			loc_0 = add_i32(loc_3, loc_5)
			if ge_u32(loc_1, loc_3) then goto continue_at_5 end
			break
		end
		::continue_at_4::
		loc_3 = -1
		loc_0 = sub_i32(
			load_i32(memory_at_0, param_0 + 48), load_i32(memory_at_0, param_0 + 44)
		)
		if gt_u32(loc_0, 134217712) then goto continue_at_6 end
		reg_0 = FUNC_LIST[95](loc_6, param_1)
		loc_3 = shr_i32(loc_0, 4)
		store_i32(memory_at_0, reg_0, loc_3)
		loc_0 = add_i32(param_0, 44)
		loc_1 = load_i32(memory_at_0, loc_0 + 4)
		if loc_1 ~= load_i32(memory_at_0, loc_0 + 8) then
			store_i64(memory_at_0, loc_1, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, param_2 + 8))
			store_i32(memory_at_0, loc_0 + 4, add_i32(loc_1, 16))
			reg_0 = loc_3
			goto continue_at_0
		end
		param_0 = load_i32(memory_at_0, loc_0)
		loc_1 = sub_i32(loc_1, param_0)
		loc_4 = shr_i32(loc_1, 4)
		loc_5 = add_i32(loc_4, 1)
		if ge_u32(loc_5, 268435456) then goto continue_at_2 end
		loc_2 = shr_i32(loc_1, 3)
		loc_2 = (lt_u32(loc_1, 2147483632) and
			        (gt_u32(loc_2, loc_5) and loc_2 or loc_5) or 268435455)
		if loc_2 ~= 0 then
			if ge_u32(loc_2, 268435456) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 4))
		else
			reg_0 = 0
		end
		loc_5 = reg_0
		loc_4 = add_i32(loc_5, shl_i32(loc_4, 4))
		store_i64(memory_at_0, loc_4, load_i64(memory_at_0, param_2))
		store_i64(memory_at_0, loc_4 + 8, load_i64(memory_at_0, param_2 + 8))
		loc_2 = add_i32(loc_5, shl_i32(loc_2, 4))
		loc_4 = add_i32(loc_4, 16)
		if loc_1 > 0 then reg_0 = FUNC_LIST[1119](loc_5, param_0, loc_1) end
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		store_i32(memory_at_0, loc_0 + 4, loc_4)
		store_i32(memory_at_0, loc_0, loc_5)
		if param_0 == 0 then goto continue_at_6 end
		FUNC_LIST[1276](param_0)
		::continue_at_6::
		reg_0 = loc_3
		goto continue_at_0
		::continue_at_3::
		reg_0 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_5, 24)) + 16)
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[96](loc_0)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[95] = --[[ Luau::DenseHashMap<Luau::BytecodeBuilder::ConstantKey, int, Luau::BytecodeBuilder::ConstantKeyHash, std::__2::equal_to<Luau::BytecodeBuilder::ConstantKey> >::operator[](Luau::BytecodeBuilder::ConstantKey const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0LL
		local loc_5 = 0LL
		local loc_6 = 0
		local loc_7 = 0LL
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_3 = load_i32(memory_at_0, param_0)
		loc_1 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_3), 24)
		if ge_u32(load_i32(memory_at_0, param_0 + 12), shr_u32(mul_i32(loc_1, 3), 2)) then
			FUNC_LIST[97](param_0)
			loc_3 = load_i32(memory_at_0, param_0)
			loc_1 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_3), 24)
		end
		loc_4 = load_i64(memory_at_0, param_1 + 8)
		loc_6 = load_i32(memory_at_0, param_1)
		loc_0 = bxor_i32(
			wrap_i32_i64(shr_u64(loc_4, 32LL )), mul_i32(loc_6, 1540483477)
		)
		loc_2 = mul_i32(bxor_i32(shr_u32(loc_0, 18), wrap_i32_i64(loc_4)), 1540483477)
		loc_0 = mul_i32(bxor_i32(shr_u32(loc_2, 22), loc_0), 1540483477)
		loc_0 = mul_i32(
			bxor_i32(
				shr_u32(
					mul_i32(
						bxor_i32(shr_u32(loc_0, 17), loc_2), 1540483477
					), 19
				), loc_0
			), 1540483477
		)
		loc_2 = sub_i32(loc_1, 1)
		loc_7 = load_i64(memory_at_0, param_0 + 24)
		loc_8 = load_i32(memory_at_0, param_0 + 16)
		loc_1 = 0
		::continue_at_3::
		while true do
			loc_9 = band_i32(loc_0, loc_2)
			loc_0 = add_i32(loc_3, mul_i32(loc_9, 24))
			loc_5 = load_i64(memory_at_0, loc_0 + 8)
			loc_10 = load_i32(memory_at_0, loc_0)
			if loc_10 ~= loc_8 then goto continue_at_4 end
			if loc_5 ~= loc_7 then goto continue_at_4 end
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
			store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1 + 8))
			store_i32(
				memory_at_0, param_0 + 12, add_i32(load_i32(memory_at_0, param_0 + 12), 1)
			)
			goto continue_at_2
			::continue_at_4::
			if band_i32((loc_6 == loc_10 and 1 or 0), (loc_4 == loc_5 and 1 or 0)) ~= 0 then
				goto continue_at_2
			end
			loc_1 = add_i32(loc_1, 1)
			loc_0 = add_i32(loc_1, loc_9)
			if le_u32(loc_1, loc_2) then goto continue_at_3 end
			break
		end
		loc_0 = 0
		::continue_at_2::
		reg_0 = add_i32(loc_0, 16)
		return reg_0
	end
FUNC_LIST[96] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::Constant, std::__2::allocator<Luau::BytecodeBuilder::Constant> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[97] = --[[ Luau::detail::DenseHashTable<Luau::BytecodeBuilder::ConstantKey, std::__2::pair<Luau::BytecodeBuilder::ConstantKey, int>, std::__2::pair<Luau::BytecodeBuilder::ConstantKey const, int>, Luau::detail::ItemInterfaceMap<Luau::BytecodeBuilder::ConstantKey, int>, Luau::BytecodeBuilder::ConstantKeyHash, std::__2::equal_to<Luau::BytecodeBuilder::ConstantKey> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0LL
		local loc_6 = 0LL
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0LL
		local reg_0, reg_1
		loc_0 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_0
		reg_0 = loc_0
		loc_2 = load_i32(memory_at_0, param_0)
		loc_4 = load_i32(memory_at_0, param_0 + 4)
		if loc_2 == loc_4 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 24), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_0 + 24))
			store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_0 + 16))
			loc_2 = 16
			reg_1 = add_i32(param_0, 16)
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_0 + 24))
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_0 + 16))
		loc_2 = shl_i32(div_i32(sub_i32(loc_4, loc_2), 24), 1)
		reg_1 = add_i32(param_0, 16)
		::continue_at_4::
		loc_1 = reg_1
		store_i64(memory_at_0, reg_0 + 48, load_i64(memory_at_0, loc_1 + 8))
		store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
		store_i32(memory_at_0, loc_0 + 56, 0)
		FUNC_LIST[144](loc_0, loc_2, add_i32(loc_0, 40))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_3 then
			loc_3 = loc_1
			goto continue_at_2
		end
		::continue_at_7::
		while true do
			loc_12 = mul_i32(loc_7, 24)
			loc_8 = add_i32(loc_3, loc_12)
			loc_5 = load_i64(memory_at_0, loc_8 + 8)
			loc_9 = load_i32(memory_at_0, loc_8)
			if loc_9 == load_i32(memory_at_0, param_0 + 16) then
				if loc_5 == load_i64(memory_at_0, param_0 + 24) then goto continue_at_8 end
			end
			loc_10 = load_i32(memory_at_0, loc_0)
			loc_13 = sub_i32(
				div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_10), 24), 1
			)
			loc_1 = bxor_i32(
				wrap_i32_i64(shr_u64(loc_5, 32LL )), mul_i32(loc_9, 1540483477)
			)
			loc_2 =
				mul_i32(bxor_i32(wrap_i32_i64(loc_5), shr_u32(loc_1, 18)), 1540483477)
			loc_1 = mul_i32(bxor_i32(shr_u32(loc_2, 22), loc_1), 1540483477)
			loc_2 = band_i32(
				loc_13, mul_i32(
					bxor_i32(
						shr_u32(
							mul_i32(
								bxor_i32(shr_u32(loc_1, 17), loc_2), 1540483477
							), 19
						), loc_1
					), 1540483477
				)
			)
			loc_1 = add_i32(loc_10, mul_i32(loc_2, 24))
			loc_6 = load_i64(memory_at_0, loc_1 + 8)
			loc_11 = load_i32(memory_at_0, loc_1)
			loc_14 = load_i32(memory_at_0, loc_0 + 16)
			loc_15 = load_i64(memory_at_0, loc_0 + 24)
			if band_i32((loc_11 == loc_14 and 1 or 0), (loc_15 == loc_6 and 1 or 0)) ~= 0 then
				goto continue_at_11
			end
			loc_4 = 0
			if band_i32((loc_9 == loc_11 and 1 or 0), (loc_5 == loc_6 and 1 or 0)) ~= 0 then
				goto continue_at_10
			end
			::continue_at_12::
			while true do
				loc_4 = add_i32(loc_4, 1)
				loc_2 = band_i32(add_i32(loc_4, loc_2), loc_13)
				loc_1 = add_i32(loc_10, mul_i32(loc_2, 24))
				loc_6 = load_i64(memory_at_0, loc_1 + 8)
				loc_11 = load_i32(memory_at_0, loc_1)
				if band_i32((loc_14 == loc_11 and 1 or 0), (loc_6 == loc_15 and 1 or 0)) ~=
					0 then goto continue_at_11 end
				if loc_9 ~= loc_11 then goto continue_at_12 end
				if loc_5 ~= loc_6 then goto continue_at_12 end
				break
			end
			goto continue_at_10
			::continue_at_11::
			store_i64(memory_at_0, loc_1, load_i64(memory_at_0, loc_8))
			store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, loc_8 + 8))
			store_i32(
				memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
			)
			loc_3 = load_i32(memory_at_0, param_0)
			::continue_at_10::
			loc_4 = add_i32(loc_3, loc_12)
			store_i64(memory_at_0, loc_1, load_i64(memory_at_0, loc_4))
			store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, loc_4 + 8))
			store_i32(
				memory_at_0, add_i32(loc_10, mul_i32(loc_2, 24)) + 16,
					load_i32(memory_at_0, loc_4 + 16)
			)
			loc_3 = load_i32(memory_at_0, param_0)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			::continue_at_8::
			loc_7 = add_i32(loc_7, 1)
			if lt_u32(loc_7, div_i32(sub_i32(loc_1, loc_3), 24)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_0 + 24))
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_0 + 16))
		store_i32(memory_at_0, loc_0 + 16, 0)
		FUNC_LIST[144](param_0, 16, loc_0)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_3)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		if loc_3 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		FUNC_LIST[1276](loc_3)
		::continue_at_1::
		GLOBAL_LIST[0].value = sub_i32(loc_0, -64)
	end
FUNC_LIST[98] = --[[ Luau::detail::DenseHashTable<Luau::BytecodeBuilder::StringRef, std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int>, std::__2::pair<Luau::BytecodeBuilder::StringRef const, unsigned int>, Luau::detail::ItemInterfaceMap<Luau::BytecodeBuilder::StringRef, unsigned int>, Luau::BytecodeBuilder::StringRefHash, std::__2::equal_to<Luau::BytecodeBuilder::StringRef> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0LL
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if loc_2 == loc_1 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 12), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_4 = load_i64(memory_at_0, param_0 + 16)
			store_i64(memory_at_0, loc_0 + 16, loc_4)
			loc_6 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_4 = load_i64(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 16, loc_4)
		loc_6 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_1, loc_2), 12), 1)
		::continue_at_4::
		loc_1 = reg_0
		loc_2 = 0
		store_i32(memory_at_0, loc_0 + 40, 0)
		store_i64(memory_at_0, loc_0 + 32, loc_4)
		FUNC_LIST[150](loc_0, loc_1, add_i32(loc_0, 32))
		loc_5 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_5 == loc_1 then
			loc_1 = loc_5
			goto continue_at_2
		end
		::continue_at_7::
		while true do
			loc_3 = load_i32(memory_at_0, loc_6)
			loc_8 = mul_i32(loc_2, 12)
			loc_7 = add_i32(loc_1, loc_8)
			loc_9 = load_i32(memory_at_0, loc_7)
			if loc_9 ~= 0 then
				if loc_3 == 0 then goto continue_at_9 end
				loc_10 = load_i32(memory_at_0, loc_7 + 4)
				if loc_10 ~= load_i32(memory_at_0, param_0 + 20) then goto continue_at_9 end
				reg_0 = FUNC_LIST[1171](loc_9, loc_3, loc_10)
				if reg_0 == 0 then goto continue_at_8 end
				goto continue_at_9
			end
			if loc_3 == 0 then goto continue_at_8 end
			::continue_at_9::
			reg_0 = FUNC_LIST[99](loc_0, loc_7)
			loc_1 = reg_0
			loc_3 = add_i32(load_i32(memory_at_0, param_0), loc_8)
			store_i64(memory_at_0, loc_1, load_i64(memory_at_0, loc_3))
			store_i32(memory_at_0, loc_1 + 8, load_i32(memory_at_0, loc_3 + 8))
			loc_1 = load_i32(memory_at_0, param_0)
			loc_5 = load_i32(memory_at_0, param_0 + 4)
			::continue_at_8::
			loc_2 = add_i32(loc_2, 1)
			if lt_u32(loc_2, div_i32(sub_i32(loc_5, loc_1), 12)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_4 = load_i64(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 8, 0)
		store_i64(memory_at_0, loc_0, loc_4)
		FUNC_LIST[150](param_0, 16, loc_0)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[99] = --[[ Luau::detail::DenseHashTable<Luau::BytecodeBuilder::StringRef, std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int>, std::__2::pair<Luau::BytecodeBuilder::StringRef const, unsigned int>, Luau::detail::ItemInterfaceMap<Luau::BytecodeBuilder::StringRef, unsigned int>, Luau::BytecodeBuilder::StringRefHash, std::__2::equal_to<Luau::BytecodeBuilder::StringRef> >::insert_unsafe(Luau::BytecodeBuilder::StringRef const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local reg_0
		loc_5 = sub_i32(
			div_i32(
				sub_i32(
					load_i32(memory_at_0, param_0 + 4), load_i32(memory_at_0, param_0)
				), 12
			), 1
		)
		reg_0 = FUNC_LIST[1101](
			load_i32(memory_at_0, param_1), load_i32(memory_at_0, param_1 + 4)
		)
		loc_1 = reg_0
		loc_6 = load_i32(memory_at_0, param_0 + 20)
		loc_7 = load_i32(memory_at_0, param_1 + 4)
		loc_2 = load_i32(memory_at_0, param_1)
		loc_3 = load_i32(memory_at_0, param_0 + 16)
		loc_9 = load_i32(memory_at_0, param_0)
		::continue_at_3::
		while true do
			loc_1 = band_i32(loc_1, loc_5)
			loc_0 = add_i32(loc_9, mul_i32(loc_1, 12))
			loc_8 = load_i32(memory_at_0, loc_0)
			if loc_8 ~= 0 then
				if loc_3 == 0 then goto continue_at_6 end
				if load_i32(memory_at_0, loc_0 + 4) ~= loc_6 then goto continue_at_6 end
				reg_0 = FUNC_LIST[1171](loc_8, loc_3, loc_6)
				if reg_0 == 0 then goto continue_at_1 end
				::continue_at_6::
				if loc_2 == 0 then goto continue_at_4 end
				if load_i32(memory_at_0, loc_0 + 4) ~= loc_7 then goto continue_at_4 end
				reg_0 = FUNC_LIST[1171](loc_8, loc_2, loc_7)
				if reg_0 ~= 0 then goto continue_at_4 end
				goto continue_at_2
			end
			if loc_3 == 0 then goto continue_at_1 end
			if loc_2 == 0 then goto continue_at_2 end
			::continue_at_4::
			loc_4 = add_i32(loc_4, 1)
			loc_1 = add_i32(loc_4, loc_1)
			if le_u32(loc_4, loc_5) then goto continue_at_3 end
			break
		end
		loc_0 = 0
		::continue_at_2::
		reg_0 = loc_0
		goto continue_at_0
		::continue_at_1::
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
		store_i32(
			memory_at_0, param_0 + 12, add_i32(load_i32(memory_at_0, param_0 + 12), 1)
		)
		reg_0 = loc_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[100] = --[[ Luau::BytecodeBuilder::addConstantNil() ]] function(
	param_0
)
	local loc_0 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
	GLOBAL_LIST[0].value = loc_0
	store_i64(memory_at_0, loc_0 + 24, 0LL )
	store_i64(memory_at_0, loc_0 + 16, 0LL )
	store_i64(memory_at_0, loc_0 + 8, 0LL )
	store_i64(memory_at_0, loc_0, 0LL )
	reg_0 = FUNC_LIST[94](param_0, loc_0, add_i32(loc_0, 16))
	param_0 = reg_0
	GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[101] = --[[ Luau::BytecodeBuilder::addConstantBoolean(bool) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = add_i32(loc_0, 24)
		store_i64(memory_at_0, loc_1, load_i64(memory_at_0, 11360))
		store_i32_n8(memory_at_0, loc_1, param_1)
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, 11352))
		store_i64(memory_at_0, loc_0 + 8, extend_i64_u32(param_1))
		store_i32(memory_at_0, loc_0, 1)
		reg_0 = FUNC_LIST[94](param_0, loc_0, add_i32(loc_0, 16))
		param_1 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
		reg_0 = param_1
		return reg_0
	end
FUNC_LIST[102] = --[[ Luau::BytecodeBuilder::addConstantNumber(double) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		store_f64(memory_at_0, loc_0 + 24, param_1)
		store_i64(memory_at_0, loc_0 + 16, 2LL )
		store_f64(memory_at_0, loc_0 + 8, param_1)
		store_i64(memory_at_0, loc_0, 2LL )
		reg_0 = FUNC_LIST[94](param_0, loc_0, add_i32(loc_0, 16))
		param_0 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
		reg_0 = param_0
		return reg_0
	end
FUNC_LIST[103] = --[[ Luau::BytecodeBuilder::addConstantString(Luau::BytecodeBuilder::StringRef) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_1))
		loc_1 = add_i32(param_0, 340)
		if ge_u32(
			load_i32(memory_at_0, param_0 + 352), shr_u32(
				mul_i32(
					div_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 344),
								load_i32(memory_at_0, param_0 + 340)
						), 12
					), 3
				), 2
			)
		) then FUNC_LIST[98](loc_1) end
		reg_0 = FUNC_LIST[99](loc_1, add_i32(loc_0, 16))
		loc_2 = reg_0
		param_1 = load_i32(memory_at_0, loc_2 + 8)
		if param_1 == 0 then
			param_1 = load_i32(memory_at_0, loc_1 + 12)
			store_i32(memory_at_0, loc_2 + 8, param_1)
		end
		loc_1 = add_i32(loc_0, 24)
		store_i64(memory_at_0, loc_1, load_i64(memory_at_0, 11376))
		store_i32(memory_at_0, loc_1, param_1)
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, 11368))
		store_i64(memory_at_0, loc_0 + 8, extend_i64_u32(param_1))
		store_i32(memory_at_0, loc_0, 3)
		reg_0 = FUNC_LIST[94](param_0, loc_0, add_i32(loc_0, 16))
		param_0 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
		reg_0 = param_0
		return reg_0
	end
FUNC_LIST[104] = --[[ Luau::BytecodeBuilder::addImport(unsigned int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = add_i32(loc_0, 24)
		store_i64(memory_at_0, loc_1, load_i64(memory_at_0, 11392))
		store_i32(memory_at_0, loc_1, param_1)
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, 11384))
		store_i64(memory_at_0, loc_0 + 8, extend_i64_u32(param_1))
		store_i32(memory_at_0, loc_0, 4)
		reg_0 = FUNC_LIST[94](param_0, loc_0, add_i32(loc_0, 16))
		param_1 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
		reg_0 = param_1
		return reg_0
	end
FUNC_LIST[105] = --[[ Luau::BytecodeBuilder::addConstantTable(Luau::BytecodeBuilder::TableShape const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0, reg_1
		loc_1 = add_i32(param_0, 136)
		reg_0 = FUNC_LIST[106](loc_1, param_1)
		loc_5 = reg_0
		if loc_5 ~= 0 then
			reg_0 = load_i32(memory_at_0, loc_5 + 132)
			goto continue_at_0
		end
		loc_5 = -1
		loc_0 = sub_i32(
			load_i32(memory_at_0, param_0 + 48), load_i32(memory_at_0, param_0 + 44)
		)
		if gt_u32(loc_0, 134217712) then goto continue_at_6 end
		loc_5 = shr_i32(loc_0, 4)
		loc_0 = add_i32(param_0, 80)
		loc_6 = div_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 84), load_i32(memory_at_0, param_0 + 80)
			), 132
		)
		if ge_u32(
			load_i32(memory_at_0, param_0 + 148), shr_u32(
				mul_i32(
					div_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 140),
								load_i32(memory_at_0, param_0 + 136)
						), 136
					), 3
				), 2
			)
		) then FUNC_LIST[107](loc_1) end
		reg_0 = FUNC_LIST[108](loc_1, param_1)
		store_i32(memory_at_0, reg_0 + 132, loc_5)
		loc_1 = load_i32(memory_at_0, loc_0 + 4)
		if loc_1 ~= load_i32(memory_at_0, loc_0 + 8) then
			reg_1 = FUNC_LIST[1119](loc_1, param_1, 132)
			store_i32(memory_at_0, loc_0 + 4, add_i32(reg_1, 132))
			goto continue_at_8
		end
		loc_3 = load_i32(memory_at_0, loc_0)
		loc_4 = sub_i32(loc_1, loc_3)
		loc_1 = div_i32(loc_4, 132)
		loc_2 = add_i32(loc_1, 1)
		if ge_u32(loc_2, 32537632) then goto continue_at_5 end
		loc_7 = shl_i32(loc_1, 1)
		loc_2 =
			(lt_u32(loc_1, 16268815) and (lt_u32(loc_2, loc_7) and loc_7 or loc_2) or
				32537631)
		if loc_2 ~= 0 then
			if ge_u32(loc_2, 32537632) then goto continue_at_4 end
			reg_0 = FUNC_LIST[1275](mul_i32(loc_2, 132))
		else
			reg_0 = 0
		end
		loc_7 = reg_0
		reg_0 = FUNC_LIST[1119](add_i32(loc_7, mul_i32(loc_1, 132)), param_1, 132)
		loc_1 = reg_0
		param_1 = add_i32(loc_1, mul_i32(div_i32(loc_4, -132), 132))
		loc_2 = add_i32(loc_7, mul_i32(loc_2, 132))
		loc_1 = add_i32(loc_1, 132)
		if loc_4 > 0 then reg_0 = FUNC_LIST[1119](param_1, loc_3, loc_4) end
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		store_i32(memory_at_0, loc_0, param_1)
		if loc_3 == 0 then goto continue_at_8 end
		FUNC_LIST[1276](loc_3)
		::continue_at_8::
		param_0 = add_i32(param_0, 44)
		param_1 = load_i32(memory_at_0, param_0 + 4)
		if param_1 ~= load_i32(memory_at_0, param_0 + 8) then
			store_i32(memory_at_0, param_1 + 12, 0)
			store_i32(memory_at_0, param_1 + 8, loc_6)
			store_i64(memory_at_0, param_1, 5LL )
			store_i32(memory_at_0, param_0 + 4, add_i32(param_1, 16))
			reg_0 = loc_5
			goto continue_at_0
		end
		loc_4 = load_i32(memory_at_0, param_0)
		loc_1 = sub_i32(param_1, loc_4)
		loc_2 = shr_i32(loc_1, 4)
		loc_0 = add_i32(loc_2, 1)
		if ge_u32(loc_0, 268435456) then goto continue_at_3 end
		param_1 = 0
		loc_3 = shr_i32(loc_1, 3)
		loc_3 = (lt_u32(loc_1, 2147483632) and
			        (lt_u32(loc_0, loc_3) and loc_3 or loc_0) or 268435455)
		if loc_3 ~= 0 then
			if ge_u32(loc_3, 268435456) then goto continue_at_2 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 4))
			param_1 = reg_0
		end
		loc_0 = add_i32(param_1, shl_i32(loc_2, 4))
		store_i32(memory_at_0, loc_0 + 12, 0)
		store_i32(memory_at_0, loc_0 + 8, loc_6)
		store_i64(memory_at_0, loc_0, 5LL )
		loc_6 = add_i32(param_1, shl_i32(loc_3, 4))
		loc_0 = add_i32(loc_0, 16)
		if loc_1 > 0 then reg_0 = FUNC_LIST[1119](param_1, loc_4, loc_1) end
		store_i32(memory_at_0, param_0 + 8, loc_6)
		store_i32(memory_at_0, param_0 + 4, loc_0)
		store_i32(memory_at_0, param_0, param_1)
		if loc_4 == 0 then goto continue_at_6 end
		FUNC_LIST[1276](loc_4)
		::continue_at_6::
		reg_0 = loc_5
		goto continue_at_0
		::continue_at_5::
		FUNC_LIST[109](loc_0)
		error("out of code bounds")
		::continue_at_4::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[96](param_0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[106] = --[[ Luau::detail::DenseHashTable<Luau::BytecodeBuilder::TableShape, std::__2::pair<Luau::BytecodeBuilder::TableShape, int>, std::__2::pair<Luau::BytecodeBuilder::TableShape const, int>, Luau::detail::ItemInterfaceMap<Luau::BytecodeBuilder::TableShape, int>, Luau::BytecodeBuilder::TableShapeHash, std::__2::equal_to<Luau::BytecodeBuilder::TableShape> >::find(Luau::BytecodeBuilder::TableShape const&) const ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_7 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if loc_7 == loc_1 then goto continue_at_1 end
		loc_8 = add_i32(param_0, 16)
		loc_2 = load_i32(memory_at_0, param_1 + 128)
		loc_9 = load_i32(memory_at_0, param_0 + 144)
		if loc_2 == loc_9 then
			reg_0 = FUNC_LIST[1171](param_1, loc_8, shl_i32(loc_2, 2))
			if reg_0 == 0 then goto continue_at_1 end
		end
		loc_10 = div_i32(sub_i32(loc_1, loc_7), 136)
		if loc_2 == 0 then
			loc_0 = -2128831035
			goto continue_at_3
		end
		loc_3 = band_i32(loc_2, 3)
		if lt_u32(sub_i32(loc_2, 1), 3) then
			loc_0 = -2128831035
			param_0 = 0
			goto continue_at_5
		end
		loc_6 = band_i32(loc_2, -4)
		loc_0 = -2128831035
		param_0 = 0
		::continue_at_7::
		while true do
			loc_1 = shl_i32(param_0, 2)
			loc_0 = mul_i32(
				bxor_i32(
					load_i32(
						memory_at_0, add_i32(param_1, bor_i32(loc_1, 12))
					), mul_i32(
						bxor_i32(
							load_i32(memory_at_0, add_i32(param_1, bor_i32(loc_1, 8))), mul_i32(
								bxor_i32(
									load_i32(memory_at_0, add_i32(param_1, bor_i32(loc_1, 4))), mul_i32(
										bxor_i32(load_i32(memory_at_0, add_i32(param_1, loc_1)), loc_0),
											16777619
									)
								), 16777619
							)
						), 16777619
					)
				), 16777619
			)
			param_0 = add_i32(param_0, 4)
			loc_5 = add_i32(loc_5, 4)
			if loc_5 ~= loc_6 then goto continue_at_7 end
			break
		end
		::continue_at_5::
		if loc_3 == 0 then goto continue_at_3 end
		::continue_at_8::
		while true do
			loc_0 = mul_i32(
				bxor_i32(
					load_i32(
						memory_at_0, add_i32(param_1, shl_i32(param_0, 2))
					), loc_0
				), 16777619
			)
			param_0 = add_i32(param_0, 1)
			loc_4 = add_i32(loc_4, 1)
			if loc_4 ~= loc_3 then goto continue_at_8 end
			break
		end
		::continue_at_3::
		loc_1 = sub_i32(loc_10, 1)
		loc_6 = shl_i32(loc_9, 2)
		loc_3 = shl_i32(loc_2, 2)
		param_0 = 0
		::continue_at_9::
		while true do
			loc_5 = band_i32(loc_0, loc_1)
			loc_0 = add_i32(loc_7, mul_i32(loc_5, 136))
			loc_4 = load_i32(memory_at_0, loc_0 + 128)
			if loc_2 == loc_4 then
				reg_0 = FUNC_LIST[1171](loc_0, param_1, loc_3)
				if reg_0 == 0 then goto continue_at_1 end
			end
			if loc_4 == loc_9 then
				reg_0 = FUNC_LIST[1171](loc_0, loc_8, loc_6)
				if reg_0 == 0 then goto continue_at_11 end
			end
			param_0 = add_i32(param_0, 1)
			loc_0 = add_i32(param_0, loc_5)
			if le_u32(param_0, loc_1) then goto continue_at_9 end
			::continue_at_11::
			break
		end
		loc_0 = 0
		::continue_at_1::
		reg_0 = loc_0
		return reg_0
	end
FUNC_LIST[107] = --[[ Luau::detail::DenseHashTable<Luau::BytecodeBuilder::TableShape, std::__2::pair<Luau::BytecodeBuilder::TableShape, int>, std::__2::pair<Luau::BytecodeBuilder::TableShape const, int>, Luau::detail::ItemInterfaceMap<Luau::BytecodeBuilder::TableShape, int>, Luau::BytecodeBuilder::TableShapeHash, std::__2::equal_to<Luau::BytecodeBuilder::TableShape> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 288)
		GLOBAL_LIST[0].value = loc_0
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if loc_2 == loc_1 then
			if gt_u32(
				div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 136), 15
			) then goto continue_at_3 end
			reg_0 = 16
			goto continue_at_4
		end
		reg_0 = shl_i32(div_i32(sub_i32(loc_1, loc_2), 136), 1)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_4 = add_i32(param_0, 16)
		reg_0 = FUNC_LIST[1119](add_i32(loc_0, 16), loc_4, 132)
		reg_0 = FUNC_LIST[1119](add_i32(loc_0, 152), loc_4, 132)
		loc_2 = 0
		store_i32(memory_at_0, loc_0 + 284, 0)
		FUNC_LIST[146](loc_0, loc_1, add_i32(loc_0, 152))
		loc_3 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_3 == loc_1 then
			loc_1 = loc_3
			goto continue_at_2
		end
		::continue_at_7::
		while true do
			loc_6 = mul_i32(loc_2, 136)
			loc_5 = add_i32(loc_1, loc_6)
			loc_7 = load_i32(memory_at_0, loc_5 + 128)
			if loc_7 == load_i32(memory_at_0, param_0 + 144) then
				reg_0 = FUNC_LIST[1171](loc_5, loc_4, shl_i32(loc_7, 2))
				if reg_0 == 0 then goto continue_at_8 end
			end
			reg_0 = FUNC_LIST[108](loc_0, loc_5)
			loc_1 = add_i32(load_i32(memory_at_0, param_0), loc_6)
			reg_0 = FUNC_LIST[1119](reg_0, loc_1, 132)
			store_i32(memory_at_0, reg_0 + 132, load_i32(memory_at_0, loc_1 + 132))
			loc_1 = load_i32(memory_at_0, param_0)
			loc_3 = load_i32(memory_at_0, param_0 + 4)
			::continue_at_8::
			loc_2 = add_i32(loc_2, 1)
			if lt_u32(loc_2, div_i32(sub_i32(loc_3, loc_1), 136)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		reg_0 = FUNC_LIST[1119](loc_0, add_i32(param_0, 16), 132)
		loc_2 = reg_0
		store_i32(memory_at_0, loc_2 + 132, 0)
		FUNC_LIST[146](param_0, 16, loc_2)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 288)
	end
FUNC_LIST[108] = --[[ Luau::detail::DenseHashTable<Luau::BytecodeBuilder::TableShape, std::__2::pair<Luau::BytecodeBuilder::TableShape, int>, std::__2::pair<Luau::BytecodeBuilder::TableShape const, int>, Luau::detail::ItemInterfaceMap<Luau::BytecodeBuilder::TableShape, int>, Luau::BytecodeBuilder::TableShapeHash, std::__2::equal_to<Luau::BytecodeBuilder::TableShape> >::insert_unsafe(Luau::BytecodeBuilder::TableShape const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_9 = load_i32(memory_at_0, param_0)
		loc_7 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_9), 136)
		loc_3 = load_i32(memory_at_0, param_1 + 128)
		if loc_3 == 0 then
			loc_0 = -2128831035
			goto continue_at_1
		end
		loc_4 = band_i32(loc_3, 3)
		if lt_u32(sub_i32(loc_3, 1), 3) then
			loc_0 = -2128831035
			goto continue_at_3
		end
		loc_8 = band_i32(loc_3, -4)
		loc_0 = -2128831035
		::continue_at_5::
		while true do
			loc_2 = shl_i32(loc_1, 2)
			loc_0 = mul_i32(
				bxor_i32(
					load_i32(
						memory_at_0, add_i32(param_1, bor_i32(loc_2, 12))
					), mul_i32(
						bxor_i32(
							load_i32(memory_at_0, add_i32(param_1, bor_i32(loc_2, 8))), mul_i32(
								bxor_i32(
									load_i32(memory_at_0, add_i32(param_1, bor_i32(loc_2, 4))), mul_i32(
										bxor_i32(load_i32(memory_at_0, add_i32(param_1, loc_2)), loc_0),
											16777619
									)
								), 16777619
							)
						), 16777619
					)
				), 16777619
			)
			loc_1 = add_i32(loc_1, 4)
			loc_6 = add_i32(loc_6, 4)
			if loc_6 ~= loc_8 then goto continue_at_5 end
			break
		end
		::continue_at_3::
		if loc_4 == 0 then goto continue_at_1 end
		::continue_at_6::
		while true do
			loc_0 = mul_i32(
				bxor_i32(
					load_i32(
						memory_at_0, add_i32(param_1, shl_i32(loc_1, 2))
					), loc_0
				), 16777619
			)
			loc_1 = add_i32(loc_1, 1)
			loc_5 = add_i32(loc_5, 1)
			if loc_5 ~= loc_4 then goto continue_at_6 end
			break
		end
		::continue_at_1::
		loc_2 = sub_i32(loc_7, 1)
		loc_10 = shl_i32(loc_3, 2)
		loc_8 = add_i32(param_0, 16)
		loc_4 = load_i32(memory_at_0, param_0 + 144)
		loc_7 = shl_i32(loc_4, 2)
		loc_1 = 0
		::continue_at_8::
		while true do
			loc_6 = band_i32(loc_0, loc_2)
			loc_0 = add_i32(loc_9, mul_i32(loc_6, 136))
			loc_5 = load_i32(memory_at_0, loc_0 + 128)
			if loc_5 ~= loc_4 then goto continue_at_9 end
			reg_0 = FUNC_LIST[1171](loc_0, loc_8, loc_7)
			if reg_0 ~= 0 then goto continue_at_9 end
			reg_0 = FUNC_LIST[1119](loc_0, param_1, 132)
			loc_0 = reg_0
			store_i32(
				memory_at_0, param_0 + 12, add_i32(load_i32(memory_at_0, param_0 + 12), 1)
			)
			reg_0 = loc_0
			goto continue_at_0
			::continue_at_9::
			if loc_3 == loc_5 then
				reg_0 = FUNC_LIST[1171](loc_0, param_1, loc_10)
				if reg_0 == 0 then goto continue_at_7 end
			end
			loc_1 = add_i32(loc_1, 1)
			loc_0 = add_i32(loc_1, loc_6)
			if le_u32(loc_1, loc_2) then goto continue_at_8 end
			break
		end
		loc_0 = 0
		::continue_at_7::
		reg_0 = loc_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[109] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::TableShape, std::__2::allocator<Luau::BytecodeBuilder::TableShape> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[110] = --[[ Luau::BytecodeBuilder::addConstantClosure(unsigned int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = add_i32(loc_0, 24)
		store_i64(memory_at_0, loc_1, load_i64(memory_at_0, 11408))
		store_i32(memory_at_0, loc_1, param_1)
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, 11400))
		store_i64(memory_at_0, loc_0 + 8, extend_i64_u32(param_1))
		store_i32(memory_at_0, loc_0, 6)
		reg_0 = FUNC_LIST[94](param_0, loc_0, add_i32(loc_0, 16))
		param_1 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
		reg_0 = param_1
		return reg_0
	end
FUNC_LIST[111] = --[[ Luau::BytecodeBuilder::addChildFunction(unsigned int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_5 = add_i32(param_0, 288)
		loc_2 = load_i32(memory_at_0, param_0 + 288)
		loc_4 = load_i32(memory_at_0, param_0 + 292)
		if loc_2 == loc_4 then goto continue_at_5 end
		loc_8 = load_i32(memory_at_0, loc_5 + 16)
		if loc_8 == param_1 then goto continue_at_5 end
		loc_3 = sub_i32(shr_i32(sub_i32(loc_4, loc_2), 3), 1)
		loc_1 = param_1
		::continue_at_6::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_6 = load_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_1, 3)))
			if loc_6 == param_1 then goto continue_at_4 end
			if loc_6 == loc_8 then goto continue_at_5 end
			loc_0 = add_i32(loc_0, 1)
			loc_1 = add_i32(loc_0, loc_1)
			if le_u32(loc_0, loc_3) then goto continue_at_6 end
			break
		end
		::continue_at_5::
		loc_7 = 65535
		loc_0 = sub_i32(
			load_i32(memory_at_0, param_0 + 60), load_i32(memory_at_0, param_0 + 56)
		)
		if gt_u32(loc_0, 131068) then goto continue_at_1 end
		loc_3 = shr_i32(sub_i32(loc_4, loc_2), 3)
		if ge_u32(load_i32(memory_at_0, loc_5 + 12), shr_u32(mul_i32(loc_3, 3), 2)) then
			FUNC_LIST[112](loc_5)
			loc_2 = load_i32(memory_at_0, loc_5)
			loc_3 = shr_i32(sub_i32(load_i32(memory_at_0, loc_5 + 4), loc_2), 3)
		end
		loc_4 = add_i32(param_0, 56)
		loc_7 = shr_u32(loc_0, 2)
		param_0 = sub_i32(loc_3, 1)
		loc_0 = band_i32(param_0, param_1)
		loc_6 = add_i32(loc_2, shl_i32(loc_0, 3))
		loc_3 = load_i32(memory_at_0, loc_6)
		loc_8 = load_i32(memory_at_0, loc_5 + 16)
		if loc_3 ~= loc_8 then
			loc_1 = 0
			::continue_at_10::
			while true do
				if param_1 == loc_3 then goto continue_at_8 end
				loc_1 = add_i32(loc_1, 1)
				loc_0 = band_i32(add_i32(loc_1, loc_0), param_0)
				loc_6 = add_i32(loc_2, shl_i32(loc_0, 3))
				loc_3 = load_i32(memory_at_0, loc_6)
				if loc_3 ~= loc_8 then goto continue_at_10 end
				break
			end
		end
		store_i32(memory_at_0, loc_6, param_1)
		store_i32(
			memory_at_0, loc_5 + 12, add_i32(load_i32(memory_at_0, loc_5 + 12), 1)
		)
		::continue_at_8::
		store_i32_n16(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 3)) + 4, loc_7)
		loc_0 = load_i32(memory_at_0, loc_4 + 4)
		if loc_0 ~= load_i32(memory_at_0, loc_4 + 8) then
			store_i32(memory_at_0, loc_0, param_1)
			store_i32(memory_at_0, loc_4 + 4, add_i32(loc_0, 4))
			goto continue_at_1
		end
		loc_3 = load_i32(memory_at_0, loc_4)
		loc_0 = sub_i32(loc_0, loc_3)
		loc_6 = shr_i32(loc_0, 2)
		loc_2 = add_i32(loc_6, 1)
		if ge_u32(loc_2, 1073741824) then goto continue_at_3 end
		loc_1 = shr_i32(loc_0, 1)
		loc_1 = (lt_u32(loc_0, 2147483644) and
			        (gt_u32(loc_1, loc_2) and loc_1 or loc_2) or 1073741823)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 1073741824) then goto continue_at_2 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
		else
			reg_0 = 0
		end
		loc_2 = reg_0
		loc_6 = add_i32(loc_2, shl_i32(loc_6, 2))
		store_i32(memory_at_0, loc_6, param_1)
		param_1 = add_i32(loc_2, shl_i32(loc_1, 2))
		loc_1 = add_i32(loc_6, 4)
		if loc_0 > 0 then reg_0 = FUNC_LIST[1119](loc_2, loc_3, loc_0) end
		store_i32(memory_at_0, loc_4 + 8, param_1)
		store_i32(memory_at_0, loc_4 + 4, loc_1)
		store_i32(memory_at_0, loc_4, loc_2)
		if loc_3 == 0 then goto continue_at_1 end
		FUNC_LIST[1276](loc_3)
		goto continue_at_1
		::continue_at_4::
		loc_7 = load_i32_u16(memory_at_0, add_i32(loc_2, shl_i32(loc_1, 3)) + 4)
		goto continue_at_1
		::continue_at_3::
		FUNC_LIST[113](loc_4)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_1::
		reg_0 = shr_i32(shl_i32(loc_7, 16), 16)
		return reg_0
	end
FUNC_LIST[112] = --[[ Luau::detail::DenseHashTable<unsigned int, std::__2::pair<unsigned int, short>, std::__2::pair<unsigned int const, short>, Luau::detail::ItemInterfaceMap<unsigned int, short>, std::__2::hash<unsigned int>, std::__2::equal_to<unsigned int> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if gt_u32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 127) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_4 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 16, loc_4)
			loc_9 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_4)
		loc_9 = add_i32(param_0, 16)
		reg_0 = shr_i32(sub_i32(loc_2, loc_1), 2)
		::continue_at_4::
		loc_1 = reg_0
		store_i32_n16(memory_at_0, loc_0 + 28, 0)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[148](loc_0, loc_1, add_i32(loc_0, 24))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_3 then
			loc_10 = load_i32(memory_at_0, loc_0 + 4)
			goto continue_at_2
		end
		loc_1 = shr_i32(sub_i32(loc_1, loc_3), 3)
		loc_14 = (gt_u32(loc_1, 1) and loc_1 or 1)
		loc_10 = load_i32(memory_at_0, loc_0 + 4)
		loc_6 = load_i32(memory_at_0, loc_0)
		loc_11 = sub_i32(shr_i32(sub_i32(loc_10, loc_6), 3), 1)
		loc_12 = load_i32(memory_at_0, loc_0 + 12)
		::continue_at_7::
		while true do
			loc_13 = add_i32(loc_3, shl_i32(loc_5, 3))
			loc_2 = load_i32(memory_at_0, loc_13)
			if loc_2 ~= load_i32(memory_at_0, loc_9) then
				loc_1 = band_i32(loc_2, loc_11)
				loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
				loc_8 = load_i32(memory_at_0, loc_7)
				loc_15 = load_i32(memory_at_0, loc_0 + 16)
				if loc_8 == loc_15 then goto continue_at_10 end
				loc_4 = 0
				if loc_2 == loc_8 then goto continue_at_9 end
				::continue_at_11::
				while true do
					loc_4 = add_i32(loc_4, 1)
					loc_1 = band_i32(add_i32(loc_4, loc_1), loc_11)
					loc_7 = add_i32(loc_6, shl_i32(loc_1, 3))
					loc_8 = load_i32(memory_at_0, loc_7)
					if loc_8 == loc_15 then goto continue_at_10 end
					if loc_2 ~= loc_8 then goto continue_at_11 end
					break
				end
				goto continue_at_9
				::continue_at_10::
				store_i32(memory_at_0, loc_7, loc_2)
				loc_12 = add_i32(loc_12, 1)
				store_i32(memory_at_0, loc_0 + 12, loc_12)
				loc_2 = load_i32(memory_at_0, loc_13)
				::continue_at_9::
				store_i32(memory_at_0, loc_7, loc_2)
				store_i32_n16(
					memory_at_0, add_i32(loc_6, shl_i32(loc_1, 3)) + 4,
						load_i32_u16(memory_at_0, loc_13 + 4)
				)
			end
			loc_5 = add_i32(loc_5, 1)
			if loc_14 ~= loc_5 then goto continue_at_7 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i32_n16(memory_at_0, loc_0 + 4, 0)
		store_i32(memory_at_0, loc_0, loc_1)
		FUNC_LIST[148](param_0, 16, loc_0)
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_3)
		store_i32(memory_at_0, param_0 + 4, loc_10)
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		if loc_3 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		FUNC_LIST[1276](loc_3)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	end
FUNC_LIST[113] = --[[ std::__2::__vector_base<unsigned int, std::__2::allocator<unsigned int> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[114] = --[[ Luau::BytecodeBuilder::emitABC(LuauOpcode, unsigned char, unsigned char, unsigned char) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0
		param_2 = bor_i32(
			bor_i32(
				bor_i32(shl_i32(param_2, 8), param_1), shl_i32(param_3, 16)
			), shl_i32(param_4, 24)
		)
		param_4 = add_i32(param_0, 20)
		param_1 = load_i32(memory_at_0, param_0 + 24)
		if param_1 ~= load_i32(memory_at_0, param_0 + 28) then
			store_i32(memory_at_0, param_1, param_2)
			store_i32(memory_at_0, param_4 + 4, add_i32(param_1, 4))
			goto continue_at_5
		end
		loc_0 = load_i32(memory_at_0, param_4)
		param_1 = sub_i32(param_1, loc_0)
		loc_2 = shr_i32(param_1, 2)
		param_3 = add_i32(loc_2, 1)
		if ge_u32(param_3, 1073741824) then goto continue_at_4 end
		loc_1 = shr_i32(param_1, 1)
		loc_1 = (lt_u32(param_1, 2147483644) and
			        (lt_u32(param_3, loc_1) and loc_1 or param_3) or 1073741823)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 1073741824) then goto continue_at_3 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
		else
			reg_0 = 0
		end
		param_3 = reg_0
		loc_2 = add_i32(param_3, shl_i32(loc_2, 2))
		store_i32(memory_at_0, loc_2, param_2)
		param_2 = add_i32(param_3, shl_i32(loc_1, 2))
		loc_1 = add_i32(loc_2, 4)
		if param_1 > 0 then reg_0 = FUNC_LIST[1119](param_3, loc_0, param_1) end
		store_i32(memory_at_0, param_4 + 8, param_2)
		store_i32(memory_at_0, param_4 + 4, loc_1)
		store_i32(memory_at_0, param_4, param_3)
		if loc_0 == 0 then goto continue_at_5 end
		FUNC_LIST[1276](loc_0)
		::continue_at_5::
		param_4 = load_i32(memory_at_0, param_0 + 36)
		if param_4 ~= load_i32(memory_at_0, param_0 + 40) then
			store_i32(memory_at_0, param_4, load_i32(memory_at_0, param_0 + 312))
			store_i32(memory_at_0, param_0 + 36, add_i32(param_4, 4))
			goto continue_at_0
		end
		param_2 = add_i32(param_0, 32)
		param_3 = load_i32(memory_at_0, param_2)
		param_4 = sub_i32(param_4, param_3)
		loc_1 = shr_i32(param_4, 2)
		param_1 = add_i32(loc_1, 1)
		if ge_u32(param_1, 1073741824) then goto continue_at_2 end
		loc_0 = shr_i32(param_4, 1)
		loc_0 = (lt_u32(param_4, 2147483644) and
			        (lt_u32(param_1, loc_0) and loc_0 or param_1) or 1073741823)
		if loc_0 ~= 0 then
			if ge_u32(loc_0, 1073741824) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 2))
		else
			reg_0 = 0
		end
		param_1 = reg_0
		loc_1 = add_i32(param_1, shl_i32(loc_1, 2))
		store_i32(memory_at_0, loc_1, load_i32(memory_at_0, param_0 + 312))
		param_0 = add_i32(param_1, shl_i32(loc_0, 2))
		loc_0 = add_i32(loc_1, 4)
		if param_4 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_3, param_4) end
		store_i32(memory_at_0, param_2 + 8, param_0)
		store_i32(memory_at_0, param_2 + 4, loc_0)
		store_i32(memory_at_0, param_2, param_1)
		if param_3 ~= 0 then FUNC_LIST[1276](param_3) end
		goto continue_at_0
		::continue_at_4::
		FUNC_LIST[113](param_4)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[115](param_2)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[115] = --[[ std::__2::__vector_base<int, std::__2::allocator<int> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[116] = --[[ Luau::BytecodeBuilder::emitAD(LuauOpcode, unsigned char, short) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0
		param_3 = bor_i32(bor_i32(shl_i32(param_2, 8), param_1), shl_i32(param_3, 16))
		param_1 = add_i32(param_0, 20)
		param_2 = load_i32(memory_at_0, param_0 + 24)
		if param_2 ~= load_i32(memory_at_0, param_0 + 28) then
			store_i32(memory_at_0, param_2, param_3)
			store_i32(memory_at_0, param_1 + 4, add_i32(param_2, 4))
			goto continue_at_5
		end
		loc_0 = load_i32(memory_at_0, param_1)
		param_2 = sub_i32(param_2, loc_0)
		loc_3 = shr_i32(param_2, 2)
		loc_2 = add_i32(loc_3, 1)
		if ge_u32(loc_2, 1073741824) then goto continue_at_4 end
		loc_1 = shr_i32(param_2, 1)
		loc_1 = (lt_u32(param_2, 2147483644) and
			        (gt_u32(loc_1, loc_2) and loc_1 or loc_2) or 1073741823)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 1073741824) then goto continue_at_3 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
		else
			reg_0 = 0
		end
		loc_2 = reg_0
		loc_3 = add_i32(loc_2, shl_i32(loc_3, 2))
		store_i32(memory_at_0, loc_3, param_3)
		param_3 = add_i32(loc_2, shl_i32(loc_1, 2))
		loc_1 = add_i32(loc_3, 4)
		if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_2, loc_0, param_2) end
		store_i32(memory_at_0, param_1 + 8, param_3)
		store_i32(memory_at_0, param_1 + 4, loc_1)
		store_i32(memory_at_0, param_1, loc_2)
		if loc_0 == 0 then goto continue_at_5 end
		FUNC_LIST[1276](loc_0)
		::continue_at_5::
		param_1 = load_i32(memory_at_0, param_0 + 36)
		if param_1 ~= load_i32(memory_at_0, param_0 + 40) then
			store_i32(memory_at_0, param_1, load_i32(memory_at_0, param_0 + 312))
			store_i32(memory_at_0, param_0 + 36, add_i32(param_1, 4))
			goto continue_at_0
		end
		param_3 = add_i32(param_0, 32)
		loc_2 = load_i32(memory_at_0, param_3)
		param_1 = sub_i32(param_1, loc_2)
		loc_1 = shr_i32(param_1, 2)
		param_2 = add_i32(loc_1, 1)
		if ge_u32(param_2, 1073741824) then goto continue_at_2 end
		loc_0 = shr_i32(param_1, 1)
		loc_0 = (lt_u32(param_1, 2147483644) and
			        (lt_u32(param_2, loc_0) and loc_0 or param_2) or 1073741823)
		if loc_0 ~= 0 then
			if ge_u32(loc_0, 1073741824) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 2))
		else
			reg_0 = 0
		end
		param_2 = reg_0
		loc_1 = add_i32(param_2, shl_i32(loc_1, 2))
		store_i32(memory_at_0, loc_1, load_i32(memory_at_0, param_0 + 312))
		param_0 = add_i32(param_2, shl_i32(loc_0, 2))
		loc_0 = add_i32(loc_1, 4)
		if param_1 > 0 then reg_0 = FUNC_LIST[1119](param_2, loc_2, param_1) end
		store_i32(memory_at_0, param_3 + 8, param_0)
		store_i32(memory_at_0, param_3 + 4, loc_0)
		store_i32(memory_at_0, param_3, param_2)
		if loc_2 ~= 0 then FUNC_LIST[1276](loc_2) end
		goto continue_at_0
		::continue_at_4::
		FUNC_LIST[113](param_1)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[115](param_3)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[117] = --[[ Luau::BytecodeBuilder::emitAux(unsigned int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local reg_0
	loc_0 = add_i32(param_0, 20)
	loc_1 = load_i32(memory_at_0, param_0 + 24)
	if loc_1 ~= load_i32(memory_at_0, param_0 + 28) then
		store_i32(memory_at_0, loc_1, param_1)
		store_i32(memory_at_0, loc_0 + 4, add_i32(loc_1, 4))
		goto continue_at_5
	end
	loc_2 = load_i32(memory_at_0, loc_0)
	loc_1 = sub_i32(loc_1, loc_2)
	loc_5 = shr_i32(loc_1, 2)
	loc_4 = add_i32(loc_5, 1)
	if ge_u32(loc_4, 1073741824) then goto continue_at_4 end
	loc_3 = shr_i32(loc_1, 1)
	loc_3 = (lt_u32(loc_1, 2147483644) and
		        (gt_u32(loc_3, loc_4) and loc_3 or loc_4) or 1073741823)
	if loc_3 ~= 0 then
		if ge_u32(loc_3, 1073741824) then goto continue_at_3 end
		reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 2))
	else
		reg_0 = 0
	end
	loc_4 = reg_0
	loc_5 = add_i32(loc_4, shl_i32(loc_5, 2))
	store_i32(memory_at_0, loc_5, param_1)
	param_1 = add_i32(loc_4, shl_i32(loc_3, 2))
	loc_3 = add_i32(loc_5, 4)
	if loc_1 > 0 then reg_0 = FUNC_LIST[1119](loc_4, loc_2, loc_1) end
	store_i32(memory_at_0, loc_0 + 8, param_1)
	store_i32(memory_at_0, loc_0 + 4, loc_3)
	store_i32(memory_at_0, loc_0, loc_4)
	if loc_2 == 0 then goto continue_at_5 end
	FUNC_LIST[1276](loc_2)
	::continue_at_5::
	loc_0 = load_i32(memory_at_0, param_0 + 36)
	if loc_0 ~= load_i32(memory_at_0, param_0 + 40) then
		store_i32(memory_at_0, loc_0, load_i32(memory_at_0, param_0 + 312))
		store_i32(memory_at_0, param_0 + 36, add_i32(loc_0, 4))
		goto continue_at_0
	end
	param_1 = add_i32(param_0, 32)
	loc_4 = load_i32(memory_at_0, param_1)
	loc_0 = sub_i32(loc_0, loc_4)
	loc_3 = shr_i32(loc_0, 2)
	loc_1 = add_i32(loc_3, 1)
	if ge_u32(loc_1, 1073741824) then goto continue_at_2 end
	loc_2 = shr_i32(loc_0, 1)
	loc_2 = (lt_u32(loc_0, 2147483644) and
		        (lt_u32(loc_1, loc_2) and loc_2 or loc_1) or 1073741823)
	if loc_2 ~= 0 then
		if ge_u32(loc_2, 1073741824) then goto continue_at_1 end
		reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 2))
	else
		reg_0 = 0
	end
	loc_1 = reg_0
	loc_3 = add_i32(loc_1, shl_i32(loc_3, 2))
	store_i32(memory_at_0, loc_3, load_i32(memory_at_0, param_0 + 312))
	param_0 = add_i32(loc_1, shl_i32(loc_2, 2))
	loc_2 = add_i32(loc_3, 4)
	if loc_0 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_4, loc_0) end
	store_i32(memory_at_0, param_1 + 8, param_0)
	store_i32(memory_at_0, param_1 + 4, loc_2)
	store_i32(memory_at_0, param_1, loc_1)
	if loc_4 ~= 0 then FUNC_LIST[1276](loc_4) end
	goto continue_at_0
	::continue_at_4::
	FUNC_LIST[113](loc_0)
	error("out of code bounds")
	::continue_at_3::
	FUNC_LIST[252](5133)
	error("out of code bounds")
	::continue_at_2::
	FUNC_LIST[115](param_1)
	error("out of code bounds")
	::continue_at_1::
	FUNC_LIST[252](5133)
	error("out of code bounds")
	::continue_at_0::
end
FUNC_LIST[118] = --[[ Luau::BytecodeBuilder::emitLabel() ]] function(param_0)
	local reg_0
	reg_0 = shr_i32(
		sub_i32(
			load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
		), 2
	)
	return reg_0
end
FUNC_LIST[119] = --[[ Luau::BytecodeBuilder::patchJumpD(unsigned long, unsigned long) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_1 = add_i32(bxor_i32(param_1, -1), param_2)
		if le_u32(add_i32(loc_1, 32768), 65535) then
			loc_0 = add_i32(load_i32(memory_at_0, param_0 + 20), shl_i32(param_1, 2))
			store_i32(
				memory_at_0, loc_0,
					bor_i32(load_i32(memory_at_0, loc_0), shl_i32(loc_1, 16))
			)
			goto continue_at_4
		end
		loc_2 = shr_i32(loc_1, 31)
		if gt_u32(sub_i32(bxor_i32(loc_1, loc_2), loc_2), 8388607) then
			goto continue_at_3
		end
		store_i32_n8(memory_at_0, param_0 + 92, 1)
		::continue_at_4::
		loc_1 = add_i32(param_0, 68)
		loc_0 = load_i32(memory_at_0, param_0 + 72)
		param_0 = load_i32(memory_at_0, param_0 + 76)
		if lt_u32(loc_0, param_0) then
			store_i64(
				memory_at_0, loc_0, bor_i64(
					extend_i64_u32(param_1), shl_i64(extend_i64_u32(param_2), 32LL )
				)
			)
			store_i32(memory_at_0, loc_1 + 4, add_i32(loc_0, 8))
			reg_0 = 1
			goto continue_at_0
		end
		loc_2 = load_i32(memory_at_0, loc_1)
		loc_4 = sub_i32(loc_0, loc_2)
		loc_3 = shr_i32(loc_4, 3)
		loc_0 = add_i32(loc_3, 1)
		if ge_u32(loc_0, 536870912) then goto continue_at_2 end
		param_0 = sub_i32(param_0, loc_2)
		loc_5 = shr_i32(param_0, 2)
		loc_0 = (lt_u32(param_0, 2147483640) and
			        (lt_u32(loc_0, loc_5) and loc_5 or loc_0) or 536870911)
		if loc_0 ~= 0 then
			if ge_u32(loc_0, 536870912) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 3))
		else
			reg_0 = 0
		end
		param_0 = reg_0
		loc_3 = add_i32(param_0, shl_i32(loc_3, 3))
		store_i64(
			memory_at_0, loc_3, bor_i64(
				extend_i64_u32(param_1), shl_i64(extend_i64_u32(param_2), 32LL )
			)
		)
		param_1 = add_i32(param_0, shl_i32(loc_0, 3))
		param_2 = add_i32(loc_3, 8)
		loc_0 = 1
		if loc_4 > 0 then reg_0 = FUNC_LIST[1119](param_0, loc_2, loc_4) end
		store_i32(memory_at_0, loc_1 + 8, param_1)
		store_i32(memory_at_0, loc_1 + 4, param_2)
		store_i32(memory_at_0, loc_1, param_0)
		if loc_2 == 0 then goto continue_at_3 end
		FUNC_LIST[1276](loc_2)
		::continue_at_3::
		reg_0 = loc_0
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[120](loc_1)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[120] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::Jump, std::__2::allocator<Luau::BytecodeBuilder::Jump> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[121] = --[[ Luau::BytecodeBuilder::patchSkipC(unsigned long, unsigned long) ]]
	function(param_0, param_1, param_2)
		local reg_0
		param_2 = add_i32(bxor_i32(param_1, -1), param_2)
		if le_u32(param_2, 255) then
			param_1 = add_i32(load_i32(memory_at_0, param_0 + 20), shl_i32(param_1, 2))
			store_i32(
				memory_at_0, param_1,
					bor_i32(load_i32(memory_at_0, param_1), shl_i32(param_2, 24))
			)
		end
		reg_0 = (lt_u32(param_2, 256) and 1 or 0)
		return reg_0
	end
FUNC_LIST[122] = --[[ Luau::BytecodeBuilder::setDebugFunctionName(Luau::BytecodeBuilder::StringRef) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0LL
		local loc_4 = 0LL
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		loc_3 = load_i64(memory_at_0, param_1)
		store_i64(memory_at_0, loc_0, loc_3)
		param_1 = add_i32(param_0, 340)
		if ge_u32(
			load_i32(memory_at_0, param_0 + 352), shr_u32(
				mul_i32(
					div_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 344),
								load_i32(memory_at_0, param_0 + 340)
						), 12
					), 3
				), 2
			)
		) then FUNC_LIST[98](param_1) end
		reg_0 = FUNC_LIST[99](param_1, loc_0)
		loc_2 = reg_0
		loc_1 = load_i32(memory_at_0, loc_2 + 8)
		if loc_1 == 0 then
			loc_1 = load_i32(memory_at_0, param_1 + 12)
			store_i32(memory_at_0, loc_2 + 8, loc_1)
		end
		store_i32(
			memory_at_0, add_i32(
				load_i32(memory_at_0, param_0),
					mul_i32(load_i32(memory_at_0, param_0 + 12), 48)
			) + 16, loc_1
		)
		if bor_i32(
			load_i32(memory_at_0, param_0 + 424),
				band_i32(load_i32(memory_at_0, param_0 + 428), 1)
		) ~= 0 then
			loc_4 = shr_u64(loc_3, 32LL )
			param_1 = wrap_i32_i64(loc_4)
			if ge_u32(param_1, -16) then goto continue_at_3 end
			if ge_u32(param_1, 11) then
				loc_2 = band_i32(add_i32(param_1, 16), -16)
				reg_0 = FUNC_LIST[1275](loc_2)
				loc_1 = reg_0
				store_i32(memory_at_0, loc_0 + 8, bor_i32(loc_2, -2147483648))
				store_i32(memory_at_0, loc_0, loc_1)
				store_i32(memory_at_0, loc_0 + 4, param_1)
				goto continue_at_6
			end
			store_i64_n8(memory_at_0, loc_0 + 11, loc_4)
			loc_1 = loc_0
			if param_1 == 0 then goto continue_at_5 end
			::continue_at_6::
			reg_0 = FUNC_LIST[1119](loc_1, wrap_i32_i64(loc_3), param_1)
			::continue_at_5::
			store_i32_n8(memory_at_0, add_i32(param_1, loc_1), 0)
			param_1 = add_i32(
				load_i32(memory_at_0, param_0),
					mul_i32(load_i32(memory_at_0, param_0 + 12), 48)
			)
			param_0 = add_i32(param_1, 36)
			if load_i32_i8(memory_at_0, param_1 + 47) < 0 then
				FUNC_LIST[1276](load_i32(memory_at_0, param_0))
			end
			store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
			store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		end
		GLOBAL_LIST[0].value = add_i32(loc_0, 16)
		goto continue_at_0
		::continue_at_3::
		FUNC_LIST[38](loc_0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[123] = --[[ Luau::BytecodeBuilder::setDebugFunctionLineDefined(int) ]]
	function(param_0, param_1)
		store_i32(
			memory_at_0, add_i32(
				load_i32(memory_at_0, param_0),
					mul_i32(load_i32(memory_at_0, param_0 + 12), 48)
			) + 20, param_1
		)
	end
FUNC_LIST[124] = --[[ Luau::BytecodeBuilder::setDebugLine(int) ]] function(
	param_0, param_1
) store_i32(memory_at_0, param_0 + 312, param_1) end
FUNC_LIST[125] = --[[ Luau::BytecodeBuilder::pushDebugLocal(Luau::BytecodeBuilder::StringRef, unsigned char, unsigned int, unsigned int) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		store_i64(memory_at_0, loc_3 + 8, load_i64(memory_at_0, param_1))
		param_1 = add_i32(param_0, 340)
		if ge_u32(
			load_i32(memory_at_0, param_0 + 352), shr_u32(
				mul_i32(
					div_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 344),
								load_i32(memory_at_0, param_0 + 340)
						), 12
					), 3
				), 2
			)
		) then FUNC_LIST[98](param_1) end
		reg_0 = FUNC_LIST[99](param_1, add_i32(loc_3, 8))
		loc_0 = reg_0
		loc_1 = load_i32(memory_at_0, loc_0 + 8)
		if loc_1 == 0 then
			loc_1 = load_i32(memory_at_0, param_1 + 12)
			store_i32(memory_at_0, loc_0 + 8, loc_1)
		end
		loc_0 = add_i32(param_0, 316)
		param_1 = load_i32(memory_at_0, param_0 + 320)
		if param_1 ~= load_i32(memory_at_0, param_0 + 324) then
			store_i32(memory_at_0, param_1 + 12, param_4)
			store_i32(memory_at_0, param_1 + 8, param_3)
			store_i32_n8(memory_at_0, param_1 + 4, param_2)
			store_i32(memory_at_0, param_1, loc_1)
			store_i32(memory_at_0, loc_0 + 4, add_i32(param_1, 16))
			goto continue_at_5
		end
		loc_4 = load_i32(memory_at_0, loc_0)
		param_1 = sub_i32(param_1, loc_4)
		loc_6 = shr_i32(param_1, 4)
		param_0 = add_i32(loc_6, 1)
		if ge_u32(param_0, 268435456) then goto continue_at_4 end
		loc_2 = shr_i32(param_1, 3)
		loc_5 = (lt_u32(param_1, 2147483632) and
			        (lt_u32(param_0, loc_2) and loc_2 or param_0) or 268435455)
		if loc_5 ~= 0 then
			if ge_u32(loc_5, 268435456) then goto continue_at_3 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 4))
		else
			reg_0 = 0
		end
		loc_2 = reg_0
		param_0 = add_i32(loc_2, shl_i32(loc_6, 4))
		store_i32(memory_at_0, param_0 + 12, param_4)
		store_i32(memory_at_0, param_0 + 8, param_3)
		store_i32_n8(memory_at_0, param_0 + 4, param_2)
		store_i32(memory_at_0, param_0, loc_1)
		loc_1 = add_i32(loc_2, shl_i32(loc_5, 4))
		param_0 = add_i32(param_0, 16)
		if param_1 > 0 then reg_0 = FUNC_LIST[1119](loc_2, loc_4, param_1) end
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		store_i32(memory_at_0, loc_0 + 4, param_0)
		store_i32(memory_at_0, loc_0, loc_2)
		if loc_4 == 0 then goto continue_at_5 end
		FUNC_LIST[1276](loc_4)
		::continue_at_5::
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		goto continue_at_0
		::continue_at_4::
		FUNC_LIST[126](loc_0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[126] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::DebugLocal, std::__2::allocator<Luau::BytecodeBuilder::DebugLocal> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[127] = --[[ Luau::BytecodeBuilder::pushDebugUpval(Luau::BytecodeBuilder::StringRef) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		store_i64(memory_at_0, loc_3 + 8, load_i64(memory_at_0, param_1))
		param_1 = add_i32(param_0, 340)
		if ge_u32(
			load_i32(memory_at_0, param_0 + 352), shr_u32(
				mul_i32(
					div_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 344),
								load_i32(memory_at_0, param_0 + 340)
						), 12
					), 3
				), 2
			)
		) then FUNC_LIST[98](param_1) end
		reg_0 = FUNC_LIST[99](param_1, add_i32(loc_3, 8))
		loc_0 = reg_0
		loc_2 = load_i32(memory_at_0, loc_0 + 8)
		if loc_2 == 0 then
			loc_2 = load_i32(memory_at_0, param_1 + 12)
			store_i32(memory_at_0, loc_0 + 8, loc_2)
		end
		param_1 = add_i32(param_0, 328)
		loc_0 = load_i32(memory_at_0, param_0 + 332)
		if loc_0 ~= load_i32(memory_at_0, param_0 + 336) then
			store_i32(memory_at_0, loc_0, loc_2)
			store_i32(memory_at_0, param_1 + 4, add_i32(loc_0, 4))
			goto continue_at_5
		end
		loc_4 = load_i32(memory_at_0, param_1)
		param_0 = sub_i32(loc_0, loc_4)
		loc_5 = shr_i32(param_0, 2)
		loc_0 = add_i32(loc_5, 1)
		if ge_u32(loc_0, 1073741824) then goto continue_at_4 end
		loc_1 = shr_i32(param_0, 1)
		loc_1 = (lt_u32(param_0, 2147483644) and
			        (lt_u32(loc_0, loc_1) and loc_1 or loc_0) or 1073741823)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 1073741824) then goto continue_at_3 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
		else
			reg_0 = 0
		end
		loc_0 = reg_0
		loc_5 = add_i32(loc_0, shl_i32(loc_5, 2))
		store_i32(memory_at_0, loc_5, loc_2)
		loc_2 = add_i32(loc_0, shl_i32(loc_1, 2))
		loc_1 = add_i32(loc_5, 4)
		if param_0 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_4, param_0) end
		store_i32(memory_at_0, param_1 + 8, loc_2)
		store_i32(memory_at_0, param_1 + 4, loc_1)
		store_i32(memory_at_0, param_1, loc_0)
		if loc_4 == 0 then goto continue_at_5 end
		FUNC_LIST[1276](loc_4)
		::continue_at_5::
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		goto continue_at_0
		::continue_at_4::
		FUNC_LIST[128](param_1)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[128] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::DebugUpval, std::__2::allocator<Luau::BytecodeBuilder::DebugUpval> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[129] = --[[ Luau::BytecodeBuilder::getDebugPC() const ]] function(
	param_0
)
	local reg_0
	reg_0 = shr_i32(
		sub_i32(
			load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
		), 2
	)
	return reg_0
end
FUNC_LIST[130] = --[[ Luau::BytecodeBuilder::addDebugRemark(char const*, ...) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_4
		if band_i32(load_i32_u8(memory_at_0, param_0 + 408), 16) == 0 then
			goto continue_at_3
		end
		loc_1 = load_i32(memory_at_0, param_0 + 384)
		loc_0 = load_i32_u8(memory_at_0, param_0 + 391)
		store_i32(memory_at_0, loc_4 + 12, param_2)
		loc_2 = add_i32(param_0, 380)
		FUNC_LIST[1098](loc_2, param_1, param_2)
		FUNC_LIST[1354](loc_2, 0)
		loc_1 = (shr_i32(shl_i32(loc_0, 24), 24) < 0 and loc_1 or loc_0)
		param_2 = add_i32(param_0, 368)
		loc_2 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
			), 2
		)
		param_1 = load_i32(memory_at_0, param_0 + 372)
		param_0 = load_i32(memory_at_0, param_0 + 376)
		if lt_u32(param_1, param_0) then
			store_i32(memory_at_0, param_1 + 4, loc_1)
			store_i32(memory_at_0, param_1, loc_2)
			store_i32(memory_at_0, param_2 + 4, add_i32(param_1, 8))
			goto continue_at_3
		end
		loc_0 = load_i32(memory_at_0, param_2)
		loc_5 = sub_i32(param_1, loc_0)
		loc_3 = shr_i32(loc_5, 3)
		param_1 = add_i32(loc_3, 1)
		if ge_u32(param_1, 536870912) then goto continue_at_2 end
		param_0 = sub_i32(param_0, loc_0)
		loc_6 = shr_i32(param_0, 2)
		param_1 = (lt_u32(param_0, 2147483640) and
			          (lt_u32(param_1, loc_6) and loc_6 or param_1) or 536870911)
		if param_1 ~= 0 then
			if ge_u32(param_1, 536870912) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(param_1, 3))
		else
			reg_0 = 0
		end
		param_0 = reg_0
		loc_3 = add_i32(param_0, shl_i32(loc_3, 3))
		store_i32(memory_at_0, loc_3 + 4, loc_1)
		store_i32(memory_at_0, loc_3, loc_2)
		param_1 = add_i32(param_0, shl_i32(param_1, 3))
		loc_1 = add_i32(loc_3, 8)
		if loc_5 > 0 then reg_0 = FUNC_LIST[1119](param_0, loc_0, loc_5) end
		store_i32(memory_at_0, param_2 + 8, param_1)
		store_i32(memory_at_0, param_2 + 4, loc_1)
		store_i32(memory_at_0, param_2, param_0)
		if loc_0 == 0 then goto continue_at_3 end
		FUNC_LIST[1276](loc_0)
		::continue_at_3::
		GLOBAL_LIST[0].value = add_i32(loc_4, 16)
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[131](param_2)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[131] = --[[ std::__2::__vector_base<std::__2::pair<unsigned int, unsigned int>, std::__2::allocator<std::__2::pair<unsigned int, unsigned int> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[132] = --[[ Luau::BytecodeBuilder::finalize() ]] function(param_0)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local reg_0
	loc_6 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_6
	loc_0 = load_i32(memory_at_0, param_0 + 344)
	loc_2 = load_i32(memory_at_0, param_0 + 340)
	loc_5 = div_i32(sub_i32(loc_0, loc_2), 12)
	if loc_0 == loc_2 then
		loc_0 = 0
		goto continue_at_1
	end
	loc_8 = (gt_u32(loc_5, 1) and loc_5 or 1)
	loc_7 = load_i32(memory_at_0, param_0 + 360)
	loc_1 = load_i32(memory_at_0, param_0 + 356)
	loc_0 = 0
	::continue_at_3::
	while true do
		loc_3 = add_i32(loc_2, mul_i32(loc_0, 12))
		loc_4 = load_i32(memory_at_0, loc_3)
		if loc_4 ~= 0 then
			if loc_1 == 0 then goto continue_at_1 end
			if load_i32(memory_at_0, loc_3 + 4) ~= loc_7 then goto continue_at_1 end
			reg_0 = FUNC_LIST[1171](loc_4, loc_1, loc_7)
			if reg_0 == 0 then goto continue_at_4 end
			goto continue_at_1
		end
		if loc_1 ~= 0 then goto continue_at_1 end
		::continue_at_4::
		loc_0 = add_i32(loc_0, 1)
		if loc_0 ~= loc_8 then goto continue_at_3 end
		break
	end
	loc_0 = loc_8
	::continue_at_1::
	loc_1 = 16
	if loc_0 == loc_5 then goto continue_at_6 end
	loc_3 = load_i32(memory_at_0, param_0 + 356)
	::continue_at_7::
	while true do
		loc_1 = add_i32(
			add_i32(
				loc_1, load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 12)) + 4)
			), 2
		)
		loc_0 = add_i32(loc_0, 1)
		if ge_u32(loc_0, loc_5) then goto continue_at_8 end
		::continue_at_9::
		while true do
			loc_4 = add_i32(loc_2, mul_i32(loc_0, 12))
			loc_7 = load_i32(memory_at_0, loc_4)
			if loc_7 ~= 0 then
				if loc_3 == 0 then goto continue_at_8 end
				loc_4 = load_i32(memory_at_0, loc_4 + 4)
				if loc_4 ~= load_i32(memory_at_0, param_0 + 360) then goto continue_at_8 end
				reg_0 = FUNC_LIST[1171](loc_7, loc_3, loc_4)
				if reg_0 ~= 0 then goto continue_at_8 end
				goto continue_at_10
			end
			if loc_3 ~= 0 then goto continue_at_8 end
			::continue_at_10::
			loc_0 = add_i32(loc_0, 1)
			if loc_5 ~= loc_0 then goto continue_at_9 end
			break
		end
		goto continue_at_6
		::continue_at_8::
		if loc_0 ~= loc_5 then goto continue_at_7 end
		break
	end
	::continue_at_6::
	loc_0 = load_i32(memory_at_0, param_0)
	loc_3 = load_i32(memory_at_0, param_0 + 4)
	if loc_0 ~= loc_3 then
		::continue_at_13::
		while true do
			loc_2 = load_i32_u8(memory_at_0, loc_0 + 11)
			loc_1 = add_i32(
				(shr_i32(shl_i32(loc_2, 24), 24) < 0 and load_i32(memory_at_0, loc_0 + 4) or
					loc_2), loc_1
			)
			loc_0 = add_i32(loc_0, 48)
			if loc_0 ~= loc_3 then goto continue_at_13 end
			break
		end
	end
	loc_2 = add_i32(param_0, 396)
	FUNC_LIST[1347](loc_2, loc_1)
	reg_0 = FUNC_LIST[1344](loc_2, 2)
	FUNC_LIST[133](param_0, loc_2)
	loc_0 = div_i32(
		sub_i32(
			load_i32(memory_at_0, param_0 + 4), load_i32(memory_at_0, param_0)
		), 48
	)
	::continue_at_14::
	while true do
		loc_1 = (gt_u32(loc_0, 127) and 1 or 0)
		store_i32_n8(
			memory_at_0, loc_6 + 14, bor_i32(band_i32(loc_0, 127), shl_i32(loc_1, 7))
		)
		reg_0 = FUNC_LIST[1350](loc_2, add_i32(loc_6, 14), 1)
		loc_0 = shr_u32(loc_0, 7)
		if loc_1 ~= 0 then goto continue_at_14 end
		break
	end
	loc_0 = load_i32(memory_at_0, param_0)
	loc_4 = load_i32(memory_at_0, param_0 + 4)
	if loc_0 ~= loc_4 then
		::continue_at_16::
		while true do
			loc_1 = load_i32_u8(memory_at_0, loc_0 + 11)
			loc_3 = (shr_i32(shl_i32(loc_1, 24), 24) < 0 and 1 or 0)
			reg_0 = FUNC_LIST[1350](
				loc_2, (loc_3 ~= 0 and load_i32(memory_at_0, loc_0) or loc_0),
					(loc_3 ~= 0 and load_i32(memory_at_0, loc_0 + 4) or loc_1)
			)
			loc_0 = add_i32(loc_0, 48)
			if loc_0 ~= loc_4 then goto continue_at_16 end
			break
		end
	end
	loc_0 = load_i32(memory_at_0, param_0 + 16)
	::continue_at_17::
	while true do
		loc_1 = (gt_u32(loc_0, 127) and 1 or 0)
		store_i32_n8(
			memory_at_0, loc_6 + 15, bor_i32(band_i32(loc_0, 127), shl_i32(loc_1, 7))
		)
		reg_0 = FUNC_LIST[1350](loc_2, add_i32(loc_6, 15), 1)
		loc_0 = shr_u32(loc_0, 7)
		if loc_1 ~= 0 then goto continue_at_17 end
		break
	end
	GLOBAL_LIST[0].value = add_i32(loc_6, 16)
end
FUNC_LIST[133] = --[[ Luau::BytecodeBuilder::writeStringTable(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >&) const ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0, reg_1
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		loc_1 = load_i32(memory_at_0, param_0 + 352)
		store_i32(memory_at_0, loc_2 + 8, 0)
		store_i64(memory_at_0, loc_2, 0LL )
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 536870912) then goto continue_at_3 end
			loc_1 = shl_i32(loc_1, 3)
			reg_1 = FUNC_LIST[1275](loc_1)
			loc_3 = reg_1
			store_i32(memory_at_0, loc_2, loc_3)
			loc_5 = add_i32(loc_1, loc_3)
			store_i32(memory_at_0, loc_2 + 8, loc_5)
			reg_0 = FUNC_LIST[1121](loc_3, 0, loc_1)
			store_i32(memory_at_0, loc_2 + 4, loc_5)
		end
		loc_1 = load_i32(memory_at_0, param_0 + 344)
		loc_6 = load_i32(memory_at_0, param_0 + 340)
		loc_7 = div_i32(sub_i32(loc_1, loc_6), 12)
		if loc_1 == loc_6 then goto continue_at_5 end
		loc_8 = (gt_u32(loc_7, 1) and loc_7 or 1)
		loc_9 = load_i32(memory_at_0, param_0 + 360)
		loc_1 = load_i32(memory_at_0, param_0 + 356)
		::continue_at_6::
		while true do
			loc_4 = add_i32(loc_6, mul_i32(loc_0, 12))
			loc_10 = load_i32(memory_at_0, loc_4)
			if loc_10 ~= 0 then
				if loc_1 == 0 then goto continue_at_5 end
				if load_i32(memory_at_0, loc_4 + 4) ~= loc_9 then goto continue_at_5 end
				reg_0 = FUNC_LIST[1171](loc_10, loc_1, loc_9)
				if reg_0 == 0 then goto continue_at_7 end
				goto continue_at_5
			end
			if loc_1 ~= 0 then goto continue_at_5 end
			::continue_at_7::
			loc_0 = add_i32(loc_0, 1)
			if loc_0 ~= loc_8 then goto continue_at_6 end
			break
		end
		loc_0 = loc_8
		::continue_at_5::
		if loc_0 == loc_7 then goto continue_at_1 end
		::continue_at_9::
		while true do
			loc_1 = add_i32(loc_6, mul_i32(loc_0, 12))
			store_i64(
				memory_at_0,
					sub_i32(add_i32(shl_i32(load_i32(memory_at_0, loc_1 + 8), 3), loc_3), 8),
					load_i64(memory_at_0, loc_1)
			)
			loc_0 = add_i32(loc_0, 1)
			loc_6 = load_i32(memory_at_0, param_0 + 340)
			loc_5 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 344), loc_6), 12)
			if ge_u32(loc_0, loc_5) then goto continue_at_10 end
			loc_1 = load_i32(memory_at_0, param_0 + 356)
			::continue_at_11::
			while true do
				loc_4 = add_i32(loc_6, mul_i32(loc_0, 12))
				loc_3 = load_i32(memory_at_0, loc_4)
				if loc_3 ~= 0 then
					if loc_1 == 0 then goto continue_at_10 end
					loc_4 = load_i32(memory_at_0, loc_4 + 4)
					if loc_4 ~= load_i32(memory_at_0, param_0 + 360) then
						goto continue_at_10
					end
					reg_0 = FUNC_LIST[1171](loc_3, loc_1, loc_4)
					if reg_0 == 0 then goto continue_at_12 end
					goto continue_at_10
				end
				if loc_1 ~= 0 then goto continue_at_10 end
				::continue_at_12::
				loc_0 = add_i32(loc_0, 1)
				if loc_0 ~= loc_5 then goto continue_at_11 end
				break
			end
			loc_0 = loc_5
			::continue_at_10::
			if loc_0 == loc_7 then goto continue_at_2 end
			loc_3 = load_i32(memory_at_0, loc_2)
			goto continue_at_9
		end
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[134](loc_2)
		error("out of code bounds")
		::continue_at_2::
		loc_3 = load_i32(memory_at_0, loc_2)
		loc_5 = load_i32(memory_at_0, loc_2 + 4)
		::continue_at_1::
		loc_0 = shr_i32(sub_i32(loc_5, loc_3), 3)
		::continue_at_14::
		while true do
			loc_1 = (gt_u32(loc_0, 127) and 1 or 0)
			store_i32_n8(
				memory_at_0, loc_2 + 14, bor_i32(band_i32(loc_0, 127), shl_i32(loc_1, 7))
			)
			reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_2, 14), 1)
			loc_0 = shr_u32(loc_0, 7)
			if loc_1 ~= 0 then goto continue_at_14 end
			break
		end
		if loc_3 ~= loc_5 then
			loc_4 = loc_3
			::continue_at_16::
			while true do
				loc_0 = load_i32(memory_at_0, loc_4 + 4)
				::continue_at_17::
				while true do
					loc_1 = (gt_u32(loc_0, 127) and 1 or 0)
					store_i32_n8(
						memory_at_0, loc_2 + 15, bor_i32(band_i32(loc_0, 127), shl_i32(loc_1, 7))
					)
					reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_2, 15), 1)
					loc_0 = shr_u32(loc_0, 7)
					if loc_1 ~= 0 then goto continue_at_17 end
					break
				end
				reg_0 = FUNC_LIST[1350](
					param_1, load_i32(memory_at_0, loc_4), load_i32(memory_at_0, loc_4 + 4)
				)
				loc_4 = add_i32(loc_4, 8)
				if loc_4 ~= loc_5 then goto continue_at_16 end
				break
			end
		end
		if loc_3 ~= 0 then FUNC_LIST[1276](loc_3) end
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
	end
FUNC_LIST[134] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::StringRef, std::__2::allocator<Luau::BytecodeBuilder::StringRef> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[135] = --[[ std::__2::vector<int, std::__2::allocator<int> >::__append(unsigned long) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_1, loc_0), 2)) then
			if param_1 ~= 0 then
				param_1 = shl_i32(param_1, 2)
				reg_0 = FUNC_LIST[1121](loc_0, 0, param_1)
				loc_0 = add_i32(reg_0, param_1)
			end
			store_i32(memory_at_0, param_0 + 4, loc_0)
			goto continue_at_0
		end
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = sub_i32(loc_0, loc_2)
		loc_5 = shr_i32(loc_3, 2)
		loc_4 = add_i32(loc_5, param_1)
		if lt_u32(loc_4, 1073741824) then
			loc_0 = 0
			loc_1 = sub_i32(loc_1, loc_2)
			loc_6 = shr_i32(loc_1, 1)
			loc_1 = (lt_u32(loc_1, 2147483644) and
				        (lt_u32(loc_4, loc_6) and loc_6 or loc_4) or 1073741823)
			if loc_1 ~= 0 then
				if ge_u32(loc_1, 1073741824) then goto continue_at_3 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
				loc_0 = reg_0
			end
			param_1 = shl_i32(param_1, 2)
			reg_0 = FUNC_LIST[1121](add_i32(loc_0, shl_i32(loc_5, 2)), 0, param_1)
			param_1 = add_i32(reg_0, param_1)
			loc_1 = add_i32(loc_0, shl_i32(loc_1, 2))
			if loc_3 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_3) end
			store_i32(memory_at_0, param_0 + 8, loc_1)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_0)
			if loc_2 ~= 0 then FUNC_LIST[1276](loc_2) end
			goto continue_at_0
		end
		FUNC_LIST[115](param_0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[136] = --[[ Luau::BytecodeBuilder::getImportId(int) ]] function(
	param_0
)
	local reg_0
	reg_0 = bor_i32(shl_i32(param_0, 20), 1073741824)
	return reg_0
end
FUNC_LIST[137] = --[[ Luau::BytecodeBuilder::getImportId(int, int) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = bor_i32(
		bor_i32(shl_i32(param_0, 20), shl_i32(param_1, 10)), -2147483648
	)
	return reg_0
end
FUNC_LIST[138] = --[[ Luau::BytecodeBuilder::getImportId(int, int, int) ]]
	function(param_0, param_1, param_2)
		local reg_0
		reg_0 = bor_i32(
			bor_i32(
				bor_i32(shl_i32(param_0, 20), shl_i32(param_1, 10)), param_2
			), -1073741824
		)
		return reg_0
	end
FUNC_LIST[139] = --[[ Luau::BytecodeBuilder::getStringHash(Luau::BytecodeBuilder::StringRef) ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if loc_0 == 0 then
			reg_0 = 0
			goto continue_at_0
		end
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = loc_0
		param_0 = loc_0
		if band_i32(param_0, 1) ~= 0 then
			loc_1 = sub_i32(loc_0, 1)
			param_0 = bxor_i32(
				add_i32(
					load_i32_u8(memory_at_0, add_i32(loc_2, loc_1)),
						add_i32(shl_i32(loc_0, 5), shr_u32(loc_0, 2))
				), loc_0
			)
		end
		if loc_0 ~= 1 then
			::continue_at_4::
			while true do
				param_0 = bxor_i32(
					add_i32(
						load_i32_u8(
							memory_at_0, sub_i32(add_i32(loc_1, loc_2), 1)
						), add_i32(shl_i32(param_0, 5), shr_u32(param_0, 2))
					), param_0
				)
				loc_1 = sub_i32(loc_1, 2)
				param_0 = bxor_i32(
					add_i32(
						add_i32(shl_i32(param_0, 5), shr_u32(param_0, 2)),
							load_i32_u8(memory_at_0, add_i32(loc_2, loc_1))
					), param_0
				)
				if loc_1 ~= 0 then goto continue_at_4 end
				break
			end
		end
		reg_0 = param_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[140] = --[[ Luau::BytecodeBuilder::foldJumps() ]] function(param_0)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	if load_i32_u8(memory_at_0, param_0 + 92) ~= 0 then goto continue_at_1 end
	loc_1 = load_i32(memory_at_0, param_0 + 68)
	loc_7 = load_i32(memory_at_0, param_0 + 72)
	if loc_1 == loc_7 then goto continue_at_1 end
	loc_3 = load_i32(memory_at_0, param_0 + 32)
	loc_2 = load_i32(memory_at_0, param_0 + 20)
	::continue_at_2::
	while true do
		loc_4 = load_i32(memory_at_0, loc_1)
		loc_8 = shl_i32(loc_4, 2)
		loc_5 = add_i32(loc_2, loc_8)
		loc_6 = load_i32(memory_at_0, loc_5)
		param_0 = add_i32(add_i32(loc_4, shr_i32(loc_6, 16)), 1)
		loc_0 = load_i32(memory_at_0, add_i32(loc_2, shl_i32(param_0, 2)))
		if band_i32(loc_0, -2147483393) == 23 then
			::continue_at_4::
			while true do
				param_0 = add_i32(add_i32(param_0, shr_u32(loc_0, 16)), 1)
				loc_0 = load_i32(memory_at_0, add_i32(loc_2, shl_i32(param_0, 2)))
				if band_i32(loc_0, -2147483393) == 23 then goto continue_at_4 end
				break
			end
		end
		if band_i32(loc_6, 255) ~= 23 then goto continue_at_6 end
		if band_i32(loc_0, 255) ~= 22 then goto continue_at_6 end
		store_i32(memory_at_0, loc_5, loc_0)
		store_i32(
			memory_at_0, add_i32(loc_3, loc_8),
				load_i32(memory_at_0, add_i32(loc_3, shl_i32(param_0, 2)))
		)
		goto continue_at_5
		::continue_at_6::
		loc_0 = add_i32(param_0, bxor_i32(loc_4, -1))
		if gt_u32(add_i32(loc_0, 32768), 65535) then goto continue_at_5 end
		store_i32(
			memory_at_0, loc_5, bor_i32(band_i32(loc_6, 65535), shl_i32(loc_0, 16))
		)
		::continue_at_5::
		store_i32(memory_at_0, loc_1 + 4, param_0)
		loc_1 = add_i32(loc_1, 8)
		if loc_1 ~= loc_7 then goto continue_at_2 end
		break
	end
	::continue_at_1::
end
FUNC_LIST[141] = --[[ Luau::BytecodeBuilder::expandJumps() ]] function(param_0)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0
	local loc_10 = 0
	local loc_11 = 0
	local loc_12 = 0
	local loc_13 = 0
	local loc_14 = 0
	local loc_15 = 0
	local loc_16 = 0
	local loc_17 = 0
	local reg_0, reg_1
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
	GLOBAL_LIST[0].value = loc_0
	if load_i32_u8(memory_at_0, param_0 + 92) == 0 then goto continue_at_1 end
	FUNC_LIST[142](
		load_i32(memory_at_0, param_0 + 68), load_i32(memory_at_0, param_0 + 72)
	)
	loc_5 = load_i32(memory_at_0, param_0 + 24)
	loc_12 = load_i32(memory_at_0, param_0 + 20)
	store_i32(memory_at_0, loc_0 + 40, 0)
	store_i64(memory_at_0, loc_0 + 32, 0LL )
	loc_1 = sub_i32(loc_5, loc_12)
	loc_3 = shr_i32(loc_1, 2)
	if loc_5 == loc_12 then
		store_i32(memory_at_0, loc_0 + 24, 0)
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i32(memory_at_0, loc_0 + 8, 0)
		store_i64(memory_at_0, loc_0, 0LL )
		goto continue_at_4
	end
	if loc_1 < 0 then goto continue_at_3 end
	reg_1 = FUNC_LIST[1275](loc_1)
	loc_15 = reg_1
	store_i32(memory_at_0, loc_0 + 32, loc_15)
	loc_13 = shl_i32(loc_3, 2)
	store_i32(memory_at_0, loc_0 + 40, add_i32(loc_15, loc_13))
	reg_1 = FUNC_LIST[1121](loc_15, 0, loc_1)
	store_i32(memory_at_0, loc_0 + 36, add_i32(reg_1, loc_1))
	store_i32(memory_at_0, loc_0 + 8, 0)
	store_i64(memory_at_0, loc_0, 0LL )
	reg_1 = FUNC_LIST[1275](loc_1)
	loc_9 = reg_1
	store_i32(memory_at_0, loc_0 + 20, loc_9)
	store_i32(memory_at_0, loc_0 + 16, loc_9)
	loc_4 = add_i32(loc_9, loc_13)
	store_i32(memory_at_0, loc_0 + 24, loc_4)
	::continue_at_4::
	loc_13 = (loc_5 == loc_12 and 1 or 0)
	if loc_13 ~= 0 then goto continue_at_7 end
	if loc_1 < 0 then goto continue_at_6 end
	reg_1 = FUNC_LIST[1275](loc_1)
	loc_10 = reg_1
	store_i32(memory_at_0, loc_0 + 4, loc_10)
	store_i32(memory_at_0, loc_0, loc_10)
	loc_8 = add_i32(loc_10, shl_i32(loc_3, 2))
	store_i32(memory_at_0, loc_0 + 8, loc_8)
	::continue_at_7::
	if loc_13 ~= 0 then
		loc_3 = loc_10
		loc_12 = loc_5
		goto continue_at_9
	end
	loc_6 = load_i32(memory_at_0, loc_0)
	loc_7 = load_i32(memory_at_0, loc_0 + 16)
	loc_3 = loc_10
	loc_1 = loc_9
	loc_13 = 0
	::continue_at_11::
	while true do
		loc_11 = shl_i32(loc_13, 2)
		loc_12 = load_i32_u8(memory_at_0, add_i32(loc_12, loc_11))
		loc_2 = load_i32(memory_at_0, param_0 + 68)
		if ge_u32(
			loc_16, shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 72), loc_2), 3)
		) then goto continue_at_24 end
		loc_2 = add_i32(loc_2, shl_i32(loc_16, 3))
		if load_i32(memory_at_0, loc_2) ~= loc_13 then goto continue_at_24 end
		loc_2 = add_i32(load_i32(memory_at_0, loc_2 + 4), bxor_i32(loc_13, -1))
		reg_0 = loc_2
		loc_2 = shr_i32(loc_2, 31)
		if lt_u32(sub_i32(bxor_i32(reg_0, loc_2), loc_2), 10923) then
			goto continue_at_25
		end
		if lt_u32(loc_1, loc_4) then
			store_i32(memory_at_0, loc_1, 65559)
			loc_1 = add_i32(loc_1, 4)
			store_i32(memory_at_0, loc_0 + 20, loc_1)
			goto continue_at_26
		end
		loc_2 = sub_i32(loc_1, loc_9)
		loc_5 = shr_i32(loc_2, 2)
		loc_1 = add_i32(loc_5, 1)
		if ge_u32(loc_1, 1073741824) then goto continue_at_23 end
		loc_7 = sub_i32(loc_4, loc_9)
		loc_14 = shr_i32(loc_7, 1)
		loc_1 = (lt_u32(loc_7, 2147483644) and
			        (lt_u32(loc_1, loc_14) and loc_14 or loc_1) or 1073741823)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 1073741824) then goto continue_at_22 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
		else
			reg_0 = 0
		end
		loc_7 = reg_0
		loc_5 = add_i32(loc_7, shl_i32(loc_5, 2))
		store_i32(memory_at_0, loc_5, 65559)
		loc_4 = shl_i32(loc_1, 2)
		loc_1 = add_i32(loc_5, 4)
		if loc_2 > 0 then reg_0 = FUNC_LIST[1119](loc_7, loc_9, loc_2) end
		loc_4 = add_i32(loc_4, loc_7)
		store_i32(memory_at_0, loc_0 + 20, loc_1)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		if loc_9 ~= 0 then FUNC_LIST[1276](loc_9) end
		loc_9 = loc_7
		::continue_at_26::
		if lt_u32(loc_1, loc_4) then
			store_i32(memory_at_0, loc_1, 67)
			loc_1 = add_i32(loc_1, 4)
			store_i32(memory_at_0, loc_0 + 20, loc_1)
			goto continue_at_32
		end
		loc_2 = sub_i32(loc_1, loc_9)
		loc_5 = shr_i32(loc_2, 2)
		loc_1 = add_i32(loc_5, 1)
		if ge_u32(loc_1, 1073741824) then goto continue_at_21 end
		loc_7 = sub_i32(loc_4, loc_9)
		loc_14 = shr_i32(loc_7, 1)
		loc_1 = (lt_u32(loc_7, 2147483644) and
			        (lt_u32(loc_1, loc_14) and loc_14 or loc_1) or 1073741823)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 1073741824) then goto continue_at_20 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
		else
			reg_0 = 0
		end
		loc_7 = reg_0
		loc_5 = add_i32(loc_7, shl_i32(loc_5, 2))
		store_i32(memory_at_0, loc_5, 67)
		loc_4 = shl_i32(loc_1, 2)
		loc_1 = add_i32(loc_5, 4)
		if loc_2 > 0 then reg_0 = FUNC_LIST[1119](loc_7, loc_9, loc_2) end
		loc_4 = add_i32(loc_4, loc_7)
		store_i32(memory_at_0, loc_0 + 20, loc_1)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		if loc_9 ~= 0 then FUNC_LIST[1276](loc_9) end
		loc_9 = loc_7
		::continue_at_32::
		loc_2 = load_i32(memory_at_0, param_0 + 32)
		loc_5 = add_i32(loc_2, loc_11)
		if loc_3 ~= loc_8 then
			store_i32(memory_at_0, loc_3, load_i32(memory_at_0, loc_5))
			loc_3 = add_i32(loc_3, 4)
			store_i32(memory_at_0, loc_0 + 4, loc_3)
			goto continue_at_38
		end
		loc_8 = sub_i32(loc_3, loc_10)
		loc_17 = shr_i32(loc_8, 2)
		loc_6 = add_i32(loc_17, 1)
		if ge_u32(loc_6, 1073741824) then
			store_i32(memory_at_0, loc_0 + 8, loc_3)
			goto continue_at_13
		end
		loc_14 = shr_i32(loc_8, 1)
		loc_14 = (lt_u32(loc_8, 2147483644) and
			         (lt_u32(loc_6, loc_14) and loc_14 or loc_6) or 1073741823)
		if loc_14 ~= 0 then
			if ge_u32(loc_14, 1073741824) then goto continue_at_19 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_14, 2))
		else
			reg_0 = 0
		end
		loc_6 = reg_0
		loc_3 = add_i32(loc_6, shl_i32(loc_17, 2))
		store_i32(memory_at_0, loc_3, load_i32(memory_at_0, loc_5))
		loc_5 = shl_i32(loc_14, 2)
		loc_3 = add_i32(loc_3, 4)
		if loc_8 > 0 then reg_0 = FUNC_LIST[1119](loc_6, loc_10, loc_8) end
		loc_8 = add_i32(loc_5, loc_6)
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		store_i32(memory_at_0, loc_0, loc_6)
		if loc_10 ~= 0 then
			FUNC_LIST[1276](loc_10)
			loc_2 = load_i32(memory_at_0, param_0 + 32)
		end
		loc_10 = loc_6
		::continue_at_38::
		loc_2 = add_i32(loc_2, loc_11)
		if loc_3 ~= loc_8 then
			store_i32(memory_at_0, loc_3, load_i32(memory_at_0, loc_2))
			loc_3 = add_i32(loc_3, 4)
			store_i32(memory_at_0, loc_0 + 4, loc_3)
			goto continue_at_25
		end
		loc_11 = sub_i32(loc_3, loc_10)
		loc_8 = shr_i32(loc_11, 2)
		loc_6 = add_i32(loc_8, 1)
		if ge_u32(loc_6, 1073741824) then
			store_i32(memory_at_0, loc_0 + 8, loc_3)
			goto continue_at_13
		end
		loc_5 = shr_i32(loc_11, 1)
		loc_5 = (lt_u32(loc_11, 2147483644) and
			        (gt_u32(loc_5, loc_6) and loc_5 or loc_6) or 1073741823)
		if loc_5 ~= 0 then
			if ge_u32(loc_5, 1073741824) then goto continue_at_18 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 2))
		else
			reg_0 = 0
		end
		loc_6 = reg_0
		loc_3 = add_i32(loc_6, shl_i32(loc_8, 2))
		store_i32(memory_at_0, loc_3, load_i32(memory_at_0, loc_2))
		loc_2 = shl_i32(loc_5, 2)
		loc_3 = add_i32(loc_3, 4)
		if loc_11 > 0 then reg_0 = FUNC_LIST[1119](loc_6, loc_10, loc_11) end
		loc_8 = add_i32(loc_2, loc_6)
		store_i32(memory_at_0, loc_0 + 4, loc_3)
		store_i32(memory_at_0, loc_0, loc_6)
		if loc_10 ~= 0 then FUNC_LIST[1276](loc_10) end
		loc_10 = loc_6
		::continue_at_25::
		loc_16 = add_i32(loc_16, 1)
		::continue_at_24::
		reg_0 = FUNC_LIST[91](loc_12)
		loc_14 = add_i32(reg_0, loc_13)
		::continue_at_51::
		while true do
			loc_12 = shl_i32(loc_13, 2)
			loc_2 = sub_i32(loc_1, loc_9)
			loc_5 = shr_i32(loc_2, 2)
			store_i32(memory_at_0, add_i32(loc_15, loc_12), loc_5)
			loc_11 = add_i32(load_i32(memory_at_0, param_0 + 20), loc_12)
			if loc_1 ~= loc_4 then
				store_i32(memory_at_0, loc_1, load_i32(memory_at_0, loc_11))
				loc_1 = add_i32(loc_1, 4)
				store_i32(memory_at_0, loc_0 + 20, loc_1)
				goto continue_at_52
			end
			loc_4 = add_i32(loc_5, 1)
			if ge_u32(loc_4, 1073741824) then goto continue_at_17 end
			loc_17 = shr_i32(loc_2, 1)
			loc_4 = (lt_u32(loc_2, 2147483644) and
				        (lt_u32(loc_4, loc_17) and loc_17 or loc_4) or 1073741823)
			if loc_4 ~= 0 then
				if ge_u32(loc_4, 1073741824) then goto continue_at_16 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_4, 2))
			else
				reg_0 = 0
			end
			loc_7 = reg_0
			loc_1 = add_i32(loc_7, shl_i32(loc_5, 2))
			store_i32(memory_at_0, loc_1, load_i32(memory_at_0, loc_11))
			loc_11 = shl_i32(loc_4, 2)
			loc_1 = add_i32(loc_1, 4)
			if loc_2 > 0 then reg_0 = FUNC_LIST[1119](loc_7, loc_9, loc_2) end
			loc_4 = add_i32(loc_7, loc_11)
			store_i32(memory_at_0, loc_0 + 20, loc_1)
			if loc_9 ~= 0 then FUNC_LIST[1276](loc_9) end
			loc_9 = loc_7
			::continue_at_52::
			loc_12 = add_i32(load_i32(memory_at_0, param_0 + 32), loc_12)
			if loc_3 ~= loc_8 then
				store_i32(memory_at_0, loc_3, load_i32(memory_at_0, loc_12))
				loc_3 = add_i32(loc_3, 4)
				store_i32(memory_at_0, loc_0 + 4, loc_3)
				goto continue_at_58
			end
			loc_2 = sub_i32(loc_3, loc_10)
			loc_5 = shr_i32(loc_2, 2)
			loc_11 = add_i32(loc_5, 1)
			if ge_u32(loc_11, 1073741824) then goto continue_at_15 end
			loc_8 = shr_i32(loc_2, 1)
			loc_11 = (lt_u32(loc_2, 2147483644) and
				         (gt_u32(loc_8, loc_11) and loc_8 or loc_11) or 1073741823)
			if loc_11 ~= 0 then
				if ge_u32(loc_11, 1073741824) then goto continue_at_14 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_11, 2))
			else
				reg_0 = 0
			end
			loc_6 = reg_0
			loc_3 = add_i32(loc_6, shl_i32(loc_5, 2))
			store_i32(memory_at_0, loc_3, load_i32(memory_at_0, loc_12))
			loc_12 = shl_i32(loc_11, 2)
			loc_3 = add_i32(loc_3, 4)
			if loc_2 > 0 then reg_0 = FUNC_LIST[1119](loc_6, loc_10, loc_2) end
			loc_8 = add_i32(loc_6, loc_12)
			store_i32(memory_at_0, loc_0 + 4, loc_3)
			if loc_10 ~= 0 then FUNC_LIST[1276](loc_10) end
			loc_10 = loc_6
			::continue_at_58::
			loc_13 = add_i32(loc_13, 1)
			if loc_14 ~= loc_13 then goto continue_at_51 end
			break
		end
		goto continue_at_12
		::continue_at_23::
		store_i32(memory_at_0, loc_0 + 8, loc_8)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[113](add_i32(loc_0, 16))
		error("out of code bounds")
		::continue_at_22::
		store_i32(memory_at_0, loc_0 + 8, loc_8)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_21::
		store_i32(memory_at_0, loc_0 + 8, loc_8)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[113](add_i32(loc_0, 16))
		error("out of code bounds")
		::continue_at_20::
		store_i32(memory_at_0, loc_0 + 8, loc_8)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_19::
		store_i32(memory_at_0, loc_0 + 8, loc_3)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_18::
		store_i32(memory_at_0, loc_0 + 8, loc_3)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_17::
		store_i32(memory_at_0, loc_0, loc_6)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		store_i32(memory_at_0, loc_0 + 24, loc_1)
		store_i32(memory_at_0, loc_0 + 8, loc_8)
		FUNC_LIST[113](add_i32(loc_0, 16))
		error("out of code bounds")
		::continue_at_16::
		store_i32(memory_at_0, loc_0, loc_6)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		store_i32(memory_at_0, loc_0 + 24, loc_1)
		store_i32(memory_at_0, loc_0 + 8, loc_8)
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_15::
		store_i32(memory_at_0, loc_0, loc_6)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		store_i32(memory_at_0, loc_0 + 8, loc_3)
		FUNC_LIST[115](loc_0)
		error("out of code bounds")
		::continue_at_14::
		store_i32(memory_at_0, loc_0, loc_6)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		store_i32(memory_at_0, loc_0 + 8, loc_3)
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_13::
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[115](loc_0)
		error("out of code bounds")
		::continue_at_12::
		store_i32(memory_at_0, loc_0, loc_6)
		store_i32(memory_at_0, loc_0 + 16, loc_7)
		loc_13 = loc_14
		loc_5 = load_i32(memory_at_0, param_0 + 24)
		loc_12 = load_i32(memory_at_0, param_0 + 20)
		if lt_u32(loc_13, shr_i32(sub_i32(loc_5, loc_12), 2)) then
			goto continue_at_11
		end
		break
	end
	::continue_at_9::
	store_i32(memory_at_0, loc_0 + 8, loc_8)
	store_i32(memory_at_0, loc_0 + 24, loc_4)
	loc_1 = load_i32(memory_at_0, param_0 + 68)
	loc_6 = load_i32(memory_at_0, param_0 + 72)
	if loc_1 == loc_6 then goto continue_at_2 end
	loc_10 = load_i32(memory_at_0, loc_0 + 16)
	loc_13 = load_i32(memory_at_0, loc_0 + 32)
	::continue_at_64::
	while true do
		loc_2 = load_i32(memory_at_0, loc_1 + 4)
		loc_9 = load_i32(memory_at_0, loc_1)
		loc_11 = load_i32(memory_at_0, add_i32(loc_13, shl_i32(loc_9, 2)))
		loc_7 = sub_i32(
			load_i32(memory_at_0, add_i32(loc_13, shl_i32(loc_2, 2))), loc_11
		)
		loc_2 = add_i32(loc_2, bxor_i32(loc_9, -1))
		reg_0 = loc_2
		loc_2 = shr_i32(loc_2, 31)
		if ge_u32(sub_i32(bxor_i32(reg_0, loc_2), loc_2), 10923) then
			loc_2 = add_i32(loc_10, shl_i32(loc_11, 2))
			store_i32_n16(memory_at_0, loc_2 + 2, 65534)
			loc_2 = sub_i32(loc_2, 4)
			store_i32(
				memory_at_0, loc_2,
					bor_i32(load_i32_u8(memory_at_0, loc_2), shl_i32(loc_7, 8))
			)
			goto continue_at_65
		end
		store_i32_n16(
			memory_at_0, add_i32(loc_10, shl_i32(loc_11, 2)) + 2,
				shr_u32(sub_i32(shl_i32(loc_7, 16), 65536), 16)
		)
		::continue_at_65::
		loc_1 = add_i32(loc_1, 8)
		if loc_1 ~= loc_6 then goto continue_at_64 end
		break
	end
	goto continue_at_2
	::continue_at_6::
	FUNC_LIST[252](5133)
	error("out of code bounds")
	::continue_at_3::
	FUNC_LIST[113](add_i32(loc_0, 32))
	error("out of code bounds")
	::continue_at_2::
	store_i32(memory_at_0, param_0 + 20, load_i32(memory_at_0, loc_0 + 16))
	store_i32(memory_at_0, param_0 + 24, load_i32(memory_at_0, loc_0 + 20))
	store_i32(memory_at_0, loc_0 + 20, loc_5)
	loc_1 = load_i32(memory_at_0, param_0 + 28)
	store_i32(memory_at_0, param_0 + 28, loc_4)
	store_i32(memory_at_0, loc_0 + 24, loc_1)
	loc_1 = load_i32(memory_at_0, param_0 + 32)
	store_i32(memory_at_0, param_0 + 32, load_i32(memory_at_0, loc_0))
	loc_13 = add_i32(param_0, 36)
	loc_2 = load_i32(memory_at_0, loc_13)
	store_i32(memory_at_0, loc_13, loc_3)
	store_i32(memory_at_0, loc_0 + 4, loc_2)
	loc_3 = add_i32(param_0, 40)
	loc_13 = load_i32(memory_at_0, loc_3)
	store_i32(memory_at_0, loc_3, loc_8)
	store_i32(memory_at_0, loc_0 + 8, loc_13)
	if loc_1 ~= 0 then
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		FUNC_LIST[1276](loc_1)
	end
	if loc_12 ~= 0 then
		store_i32(memory_at_0, loc_0 + 20, loc_12)
		FUNC_LIST[1276](loc_12)
	end
	loc_1 = load_i32(memory_at_0, loc_0 + 32)
	if loc_1 == 0 then goto continue_at_1 end
	FUNC_LIST[1276](loc_1)
	::continue_at_1::
	GLOBAL_LIST[0].value = add_i32(loc_0, 48)
end
FUNC_LIST[142] = --[[ void std::__2::__sort<Luau::BytecodeBuilder::expandJumps()::$_0&, Luau::BytecodeBuilder::Jump*>(Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::expandJumps()::$_0&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0LL
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0LL
		local reg_0
		local br_map, temp = {}, nil
		::continue_at_1::
		while true do
			loc_7 = sub_i32(param_1, 8)
			::continue_at_2::
			while true do
				loc_0 = sub_i32(param_1, param_0)
				loc_2 = shr_i32(loc_0, 3)
				if not br_map[1] then
					br_map[1] = (function() return { [0] = 5, 5, 0, 1, 2, 3 } end)()
				end
				temp = br_map[1][loc_2] or 4
				if temp < 3 then
					if temp < 1 then
						goto continue_at_8
					elseif temp > 1 then
						goto continue_at_6
					else
						goto continue_at_7
					end
				elseif temp > 3 then
					if temp < 5 then
						goto continue_at_4
					else
						goto continue_at_3
					end
				else
					goto continue_at_5
				end
				::continue_at_8::
				loc_0 = sub_i32(param_1, 8)
				if ge_u32(load_i32(memory_at_0, loc_0), load_i32(memory_at_0, param_0)) then
					goto continue_at_3
				end
				loc_1 = load_i64(memory_at_0, param_0)
				store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
				store_i64(memory_at_0, loc_0, loc_1)
				goto continue_at_0
				::continue_at_7::
				loc_0 = sub_i32(param_1, 8)
				loc_2 = load_i32(memory_at_0, loc_0)
				loc_3 = load_i32(memory_at_0, param_0 + 8)
				if ge_u32(loc_3, load_i32(memory_at_0, param_0)) then
					if ge_u32(loc_2, loc_3) then goto continue_at_3 end
					loc_1 = load_i64(memory_at_0, param_0 + 8)
					store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_0))
					store_i64(memory_at_0, loc_0, loc_1)
					if ge_u32(
						load_i32(memory_at_0, param_0 + 8), load_i32(memory_at_0, param_0)
					) then goto continue_at_3 end
					loc_1 = load_i64(memory_at_0, param_0 + 8)
					store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_0))
					store_i64(memory_at_0, param_0, loc_1)
					goto continue_at_0
				end
				loc_1 = load_i64(memory_at_0, param_0)
				if lt_u32(loc_2, loc_3) then
					store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
					store_i64(memory_at_0, loc_0, loc_1)
					goto continue_at_0
				end
				loc_8 = load_i64(memory_at_0, param_0 + 8)
				store_i64(memory_at_0, param_0 + 8, loc_1)
				store_i64(memory_at_0, param_0, loc_8)
				if ge_u32(load_i32(memory_at_0, loc_0), wrap_i32_i64(loc_1)) then
					goto continue_at_3
				end
				store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_0))
				store_i64(memory_at_0, loc_0, loc_1)
				goto continue_at_0
				::continue_at_6::
				reg_0 = FUNC_LIST[153](
					param_0, add_i32(param_0, 8), add_i32(param_0, 16), sub_i32(param_1, 8)
				)
				goto continue_at_0
				::continue_at_5::
				loc_5 = add_i32(param_0, 8)
				loc_3 = add_i32(param_0, 16)
				loc_0 = add_i32(param_0, 24)
				reg_0 = FUNC_LIST[153](param_0, loc_5, loc_3, loc_0)
				loc_2 = sub_i32(param_1, 8)
				if ge_u32(load_i32(memory_at_0, loc_2), load_i32(memory_at_0, param_0 + 24)) then
					goto continue_at_3
				end
				loc_1 = load_i64(memory_at_0, loc_0)
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_2))
				store_i64(memory_at_0, loc_2, loc_1)
				if ge_u32(load_i32(memory_at_0, loc_0), load_i32(memory_at_0, loc_3)) then
					goto continue_at_3
				end
				loc_8 = load_i64(memory_at_0, loc_3)
				loc_1 = load_i64(memory_at_0, loc_0)
				store_i64(memory_at_0, loc_3, loc_1)
				store_i64(memory_at_0, loc_0, loc_8)
				loc_0 = wrap_i32_i64(loc_1)
				if ge_u32(loc_0, load_i32(memory_at_0, loc_5)) then goto continue_at_3 end
				store_i64(memory_at_0, param_0 + 16, load_i64(memory_at_0, param_0 + 8))
				store_i64(memory_at_0, param_0 + 8, loc_1)
				if le_u32(load_i32(memory_at_0, param_0), loc_0) then goto continue_at_3 end
				store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_0))
				store_i64(memory_at_0, param_0, loc_1)
				goto continue_at_3
				::continue_at_4::
				if loc_0 <= 247 then
					loc_0 = load_i32(memory_at_0, param_0 + 16)
					loc_2 = load_i32(memory_at_0, param_0 + 8)
					loc_3 = load_i32(memory_at_0, param_0)
					if ge_u32(loc_2, loc_3) then
						if ge_u32(loc_0, loc_2) then goto continue_at_12 end
						loc_1 = load_i64(memory_at_0, param_0 + 16)
						loc_8 = load_i64(memory_at_0, param_0 + 8)
						store_i64(memory_at_0, param_0 + 16, loc_8)
						store_i64(memory_at_0, param_0 + 8, loc_1)
						loc_0 = wrap_i32_i64(loc_8)
						if le_u32(loc_3, wrap_i32_i64(loc_1)) then goto continue_at_12 end
						store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_0))
						store_i64(memory_at_0, param_0, loc_1)
						goto continue_at_12
					end
					loc_1 = load_i64(memory_at_0, param_0)
					if lt_u32(loc_0, loc_2) then
						loc_8 = load_i64(memory_at_0, param_0 + 16)
						store_i64(memory_at_0, param_0 + 16, loc_1)
						store_i64(memory_at_0, param_0, loc_8)
						loc_0 = wrap_i32_i64(loc_1)
						goto continue_at_12
					end
					loc_8 = load_i64(memory_at_0, param_0 + 8)
					store_i64(memory_at_0, param_0 + 8, loc_1)
					store_i64(memory_at_0, param_0, loc_8)
					loc_2 = wrap_i32_i64(loc_1)
					if ge_u32(loc_0, loc_2) then goto continue_at_12 end
					loc_8 = load_i64(memory_at_0, param_0 + 16)
					store_i64(memory_at_0, param_0 + 16, loc_1)
					store_i64(memory_at_0, param_0 + 8, loc_8)
					loc_0 = loc_2
					::continue_at_12::
					loc_3 = add_i32(param_0, 24)
					if loc_3 == param_1 then goto continue_at_3 end
					loc_2 = add_i32(param_0, 16)
					::continue_at_15::
					while true do
						loc_4 = loc_3
						if gt_u32(loc_0, load_i32(memory_at_0, loc_4)) then
							loc_1 = load_i64(memory_at_0, loc_4)
							loc_5 = wrap_i32_i64(loc_1)
							::continue_at_17::
							while true do
								loc_0 = loc_2
								store_i64(memory_at_0, loc_3, load_i64(memory_at_0, loc_0))
								if param_0 == loc_0 then
									loc_0 = param_0
									goto continue_at_18
								end
								loc_3 = loc_0
								loc_2 = sub_i32(loc_0, 8)
								if gt_u32(load_i32(memory_at_0, loc_2), loc_5) then
									goto continue_at_17
								end
								::continue_at_18::
								break
							end
							store_i64(memory_at_0, loc_0, loc_1)
						end
						loc_3 = add_i32(loc_4, 8)
						if loc_3 == param_1 then goto continue_at_3 end
						loc_0 = load_i32(memory_at_0, loc_4)
						loc_2 = loc_4
						goto continue_at_15
					end
					error("out of code bounds")
				end
				loc_4 = add_i32(param_0, shl_i32(div_i32(loc_2, 2), 3))
				if ge_u32(loc_0, 7993) then
					loc_0 = shl_i32(div_i32(loc_2, 4), 3)
					loc_2 = add_i32(param_0, loc_0)
					loc_0 = add_i32(loc_0, loc_4)
					reg_0 = FUNC_LIST[153](param_0, loc_2, loc_4, loc_0)
					loc_6 = reg_0
					if ge_u32(load_i32(memory_at_0, loc_7), load_i32(memory_at_0, loc_0)) then
						goto continue_at_20
					end
					loc_1 = load_i64(memory_at_0, loc_0)
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_7))
					store_i64(memory_at_0, loc_7, loc_1)
					if ge_u32(load_i32(memory_at_0, loc_0), load_i32(memory_at_0, loc_4)) then
						loc_6 = add_i32(loc_6, 1)
						goto continue_at_20
					end
					loc_1 = load_i64(memory_at_0, loc_4)
					store_i64(memory_at_0, loc_4, load_i64(memory_at_0, loc_0))
					store_i64(memory_at_0, loc_0, loc_1)
					if ge_u32(load_i32(memory_at_0, loc_4), load_i32(memory_at_0, loc_2)) then
						loc_6 = add_i32(loc_6, 2)
						goto continue_at_20
					end
					loc_1 = load_i64(memory_at_0, loc_2)
					store_i64(memory_at_0, loc_2, load_i64(memory_at_0, loc_4))
					store_i64(memory_at_0, loc_4, loc_1)
					if ge_u32(load_i32(memory_at_0, loc_2), load_i32(memory_at_0, param_0)) then
						loc_6 = add_i32(loc_6, 3)
						goto continue_at_20
					end
					loc_1 = load_i64(memory_at_0, param_0)
					store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_2))
					store_i64(memory_at_0, loc_2, loc_1)
					loc_6 = add_i32(loc_6, 4)
					goto continue_at_20
				end
				loc_0 = load_i32(memory_at_0, loc_7)
				loc_2 = load_i32(memory_at_0, loc_4)
				if ge_u32(loc_2, load_i32(memory_at_0, param_0)) then
					loc_6 = 0
					if ge_u32(loc_0, loc_2) then goto continue_at_20 end
					loc_1 = load_i64(memory_at_0, loc_4)
					store_i64(memory_at_0, loc_4, load_i64(memory_at_0, loc_7))
					store_i64(memory_at_0, loc_7, loc_1)
					loc_6 = 1
					if ge_u32(load_i32(memory_at_0, loc_4), load_i32(memory_at_0, param_0)) then
						goto continue_at_20
					end
					loc_1 = load_i64(memory_at_0, param_0)
					store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_4))
					store_i64(memory_at_0, loc_4, loc_1)
					goto continue_at_25
				end
				loc_1 = load_i64(memory_at_0, param_0)
				if lt_u32(loc_0, loc_2) then
					store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_7))
					store_i64(memory_at_0, loc_7, loc_1)
					loc_6 = 1
					goto continue_at_20
				end
				store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_4))
				store_i64(memory_at_0, loc_4, loc_1)
				loc_6 = 1
				if ge_u32(load_i32(memory_at_0, loc_7), wrap_i32_i64(loc_1)) then
					goto continue_at_20
				end
				store_i64(memory_at_0, loc_4, load_i64(memory_at_0, loc_7))
				store_i64(memory_at_0, loc_7, loc_1)
				::continue_at_25::
				loc_6 = 2
				::continue_at_20::
				loc_0 = loc_7
				loc_5 = load_i32(memory_at_0, param_0)
				loc_2 = load_i32(memory_at_0, loc_4)
				if lt_u32(loc_5, loc_2) then goto continue_at_30 end
				::continue_at_32::
				while true do
					loc_0 = sub_i32(loc_0, 8)
					if loc_0 == param_0 then
						loc_3 = add_i32(param_0, 8)
						if lt_u32(loc_5, load_i32(memory_at_0, loc_7)) then
							goto continue_at_29
						end
						if loc_3 == loc_7 then goto continue_at_3 end
						::continue_at_34::
						while true do
							if gt_u32(load_i32(memory_at_0, loc_3), loc_5) then
								loc_1 = load_i64(memory_at_0, loc_3)
								store_i64(memory_at_0, loc_3, load_i64(memory_at_0, loc_7))
								store_i64(memory_at_0, loc_7, loc_1)
								loc_3 = add_i32(loc_3, 8)
								goto continue_at_29
							end
							loc_3 = add_i32(loc_3, 8)
							if loc_7 ~= loc_3 then goto continue_at_34 end
							break
						end
						goto continue_at_3
					end
					if ge_u32(load_i32(memory_at_0, loc_0), loc_2) then goto continue_at_32 end
					break
				end
				loc_1 = load_i64(memory_at_0, param_0)
				store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
				store_i64(memory_at_0, loc_0, loc_1)
				loc_6 = add_i32(loc_6, 1)
				::continue_at_30::
				loc_5 = add_i32(param_0, 8)
				if gt_u32(loc_0, loc_5) then
					::continue_at_37::
					while true do
						loc_3 = load_i32(memory_at_0, loc_4)
						::continue_at_38::
						while true do
							loc_2 = loc_5
							loc_5 = add_i32(loc_2, 8)
							if lt_u32(load_i32(memory_at_0, loc_2), loc_3) then
								goto continue_at_38
							end
							break
						end
						::continue_at_39::
						while true do
							loc_0 = sub_i32(loc_0, 8)
							if ge_u32(load_i32(memory_at_0, loc_0), loc_3) then
								goto continue_at_39
							end
							break
						end
						if lt_u32(loc_0, loc_2) then
							reg_0 = loc_2
						else
							loc_1 = load_i64(memory_at_0, loc_2)
							store_i64(memory_at_0, loc_2, load_i64(memory_at_0, loc_0))
							store_i64(memory_at_0, loc_0, loc_1)
							loc_4 = (loc_2 == loc_4 and loc_0 or loc_4)
							loc_6 = add_i32(loc_6, 1)
							goto continue_at_37
						end
						break
					end
					loc_5 = reg_0
				end
				if loc_4 == loc_5 then goto continue_at_42 end
				if ge_u32(load_i32(memory_at_0, loc_4), load_i32(memory_at_0, loc_5)) then
					goto continue_at_42
				end
				loc_1 = load_i64(memory_at_0, loc_5)
				store_i64(memory_at_0, loc_5, load_i64(memory_at_0, loc_4))
				store_i64(memory_at_0, loc_4, loc_1)
				loc_6 = add_i32(loc_6, 1)
				::continue_at_42::
				if loc_6 == 0 then
					reg_0 = FUNC_LIST[154](param_0, loc_5)
					loc_3 = reg_0
					loc_0 = add_i32(loc_5, 8)
					reg_0 = FUNC_LIST[154](loc_0, param_1)
					if reg_0 ~= 0 then
						param_1 = loc_5
						if loc_3 == 0 then goto continue_at_1 end
						goto continue_at_3
					end
					loc_2 = 2
					reg_0 = loc_2
					if loc_3 ~= 0 then goto continue_at_28 end
				end
				if sub_i32(loc_5, param_0) < sub_i32(param_1, loc_5) then
					FUNC_LIST[142](param_0, loc_5)
					param_0 = add_i32(loc_5, 8)
					goto continue_at_2
				end
				FUNC_LIST[142](add_i32(loc_5, 8), param_1)
				param_1 = loc_5
				goto continue_at_1
				::continue_at_29::
				loc_2 = loc_7
				if loc_3 == loc_2 then goto continue_at_3 end
				::continue_at_46::
				while true do
					loc_5 = load_i32(memory_at_0, param_0)
					::continue_at_47::
					while true do
						loc_0 = loc_3
						loc_3 = add_i32(loc_0, 8)
						if ge_u32(loc_5, load_i32(memory_at_0, loc_0)) then
							goto continue_at_47
						end
						break
					end
					::continue_at_48::
					while true do
						loc_2 = sub_i32(loc_2, 8)
						if lt_u32(loc_5, load_i32(memory_at_0, loc_2)) then
							goto continue_at_48
						end
						break
					end
					if ge_u32(loc_0, loc_2) then
						reg_0 = 4
					else
						loc_1 = load_i64(memory_at_0, loc_0)
						store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_2))
						store_i64(memory_at_0, loc_2, loc_1)
						goto continue_at_46
					end
					break
				end
				::continue_at_28::
				loc_2 = reg_0
				param_0 = loc_0
				if loc_2 == 4 then goto continue_at_2 end
				if loc_2 == 2 then goto continue_at_2 end
				::continue_at_3::
				break
			end
			break
		end
		::continue_at_0::
	end
FUNC_LIST[143] = --[[ Luau::BytecodeBuilder::getError(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		store_i64(memory_at_0, param_0, 0LL )
		store_i32(memory_at_0, param_0 + 8, 0)
		FUNC_LIST[1354](param_0, 0)
		loc_0 = load_i32_u8(memory_at_0, param_1 + 11)
		loc_1 = (shr_i32(shl_i32(loc_0, 24), 24) < 0 and 1 or 0)
		reg_0 = FUNC_LIST[1350](
			param_0, (loc_1 ~= 0 and load_i32(memory_at_0, param_1) or param_1),
				(loc_1 ~= 0 and load_i32(memory_at_0, param_1 + 4) or loc_0)
		)
	end
FUNC_LIST[144] = --[[ std::__2::vector<std::__2::pair<Luau::BytecodeBuilder::ConstantKey, int>, std::__2::allocator<std::__2::pair<Luau::BytecodeBuilder::ConstantKey, int> > >::__append(unsigned long, std::__2::pair<Luau::BytecodeBuilder::ConstantKey, int> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_3 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_3), 24)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = mul_i32(param_1, 24)
			loc_0 = loc_3
			loc_5 = sub_i32(mul_i32(param_1, 24), 24)
			param_1 = band_i32(add_i32(div_u32(loc_5, 24), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2 + 16))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 24)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_3 = add_i32(loc_2, loc_3)
			if lt_u32(loc_5, 72) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 16)
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_1))
				param_1 = add_i32(param_2, 8)
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, sub_i32(loc_0, -64), load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 72, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 80, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 88, load_i64(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 96)
				if loc_0 ~= loc_3 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_3)
			goto continue_at_0
		end
		loc_4 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_3, loc_4), 24)
		loc_2 = add_i32(loc_6, param_1)
		if lt_u32(loc_2, 178956971) then
			loc_0 = div_i32(sub_i32(loc_0, loc_4), 24)
			loc_4 = shl_i32(loc_0, 1)
			loc_7 =
				(lt_u32(loc_0, 89478485) and (lt_u32(loc_2, loc_4) and loc_4 or loc_2) or
					178956970)
			if loc_7 ~= 0 then
				if ge_u32(loc_7, 178956971) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_7, 24))
				loc_5 = reg_0
			end
			loc_4 = add_i32(loc_5, mul_i32(loc_6, 24))
			loc_0 = loc_4
			loc_2 = mul_i32(param_1, 24)
			loc_6 = sub_i32(loc_2, 24)
			param_1 = band_i32(add_i32(div_u32(loc_6, 24), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_4
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2 + 16))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 24)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if ge_u32(loc_6, 72) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 16)
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_1))
					param_1 = add_i32(param_2, 8)
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, sub_i32(loc_0, -64), load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 72, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 80, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 88, load_i64(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 96)
					if loc_0 ~= loc_2 then goto continue_at_12 end
					break
				end
			end
			param_1 = add_i32(loc_5, mul_i32(loc_7, 24))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_3, loc_0)
			loc_1 = add_i32(loc_4, mul_i32(div_i32(param_2, -24), 24))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, param_1)
			store_i32(memory_at_0, param_0 + 4, loc_2)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[145](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[145] = --[[ std::__2::__vector_base<std::__2::pair<Luau::BytecodeBuilder::ConstantKey, int>, std::__2::allocator<std::__2::pair<Luau::BytecodeBuilder::ConstantKey, int> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[146] = --[[ std::__2::vector<std::__2::pair<Luau::BytecodeBuilder::TableShape, int>, std::__2::allocator<std::__2::pair<Luau::BytecodeBuilder::TableShape, int> > >::__append(unsigned long, std::__2::pair<Luau::BytecodeBuilder::TableShape, int> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_1), 136)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_4 = mul_i32(param_1, 136)
			loc_0 = loc_1
			loc_2 = sub_i32(mul_i32(param_1, 136), 136)
			param_1 = band_i32(add_i32(div_u32(loc_2, 136), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					reg_0 = FUNC_LIST[1119](loc_0, param_2, 136)
					loc_0 = add_i32(reg_0, 136)
					loc_3 = add_i32(loc_3, 1)
					if loc_3 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_1 = add_i32(loc_1, loc_4)
			if lt_u32(loc_2, 408) then goto continue_at_2 end
			::continue_at_5::
			while true do
				reg_0 = FUNC_LIST[1119](loc_0, param_2, 136)
				loc_0 = reg_0
				reg_0 = FUNC_LIST[1119](add_i32(loc_0, 136), param_2, 136)
				reg_0 = FUNC_LIST[1119](add_i32(loc_0, 272), param_2, 136)
				reg_0 = FUNC_LIST[1119](add_i32(loc_0, 408), param_2, 136)
				loc_0 = add_i32(loc_0, 544)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_1)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_1, loc_5), 136)
		loc_2 = add_i32(loc_6, param_1)
		if lt_u32(loc_2, 31580642) then
			loc_0 = div_i32(sub_i32(loc_0, loc_5), 136)
			loc_5 = shl_i32(loc_0, 1)
			loc_5 =
				(lt_u32(loc_0, 15790320) and (lt_u32(loc_2, loc_5) and loc_5 or loc_2) or
					31580641)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 31580642) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 136))
				loc_4 = reg_0
			end
			loc_2 = add_i32(loc_4, mul_i32(loc_6, 136))
			loc_0 = loc_2
			loc_6 = mul_i32(param_1, 136)
			loc_7 = sub_i32(loc_6, 136)
			param_1 = band_i32(add_i32(div_u32(loc_7, 136), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_2
				::continue_at_10::
				while true do
					reg_0 = FUNC_LIST[1119](loc_0, param_2, 136)
					loc_0 = add_i32(reg_0, 136)
					loc_3 = add_i32(loc_3, 1)
					if loc_3 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_3 = add_i32(loc_2, loc_6)
			if ge_u32(loc_7, 408) then
				::continue_at_12::
				while true do
					reg_0 = FUNC_LIST[1119](loc_0, param_2, 136)
					loc_0 = reg_0
					reg_0 = FUNC_LIST[1119](add_i32(loc_0, 136), param_2, 136)
					reg_0 = FUNC_LIST[1119](add_i32(loc_0, 272), param_2, 136)
					reg_0 = FUNC_LIST[1119](add_i32(loc_0, 408), param_2, 136)
					loc_0 = add_i32(loc_0, 544)
					if loc_0 ~= loc_3 then goto continue_at_12 end
					break
				end
			end
			loc_4 = add_i32(loc_4, mul_i32(loc_5, 136))
			param_2 = load_i32(memory_at_0, param_0)
			loc_0 = sub_i32(loc_1, param_2)
			param_1 = add_i32(loc_2, mul_i32(div_i32(loc_0, -136), 136))
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0) end
			store_i32(memory_at_0, param_0 + 8, loc_4)
			store_i32(memory_at_0, param_0 + 4, loc_3)
			store_i32(memory_at_0, param_0, param_1)
			if param_2 ~= 0 then FUNC_LIST[1276](param_2) end
			goto continue_at_0
		end
		FUNC_LIST[147](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[147] = --[[ std::__2::__vector_base<std::__2::pair<Luau::BytecodeBuilder::TableShape, int>, std::__2::allocator<std::__2::pair<Luau::BytecodeBuilder::TableShape, int> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[148] = --[[ std::__2::vector<std::__2::pair<unsigned int, short>, std::__2::allocator<std::__2::pair<unsigned int, short> > >::__append(unsigned long, std::__2::pair<unsigned int, short> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_0, loc_1), 3)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = shl_i32(param_1, 3)
			loc_3 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_0 = loc_1
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_1 = add_i32(loc_1, loc_2)
			if lt_u32(loc_3, 7) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
				loc_0 = sub_i32(loc_0, -64)
				if loc_0 ~= loc_1 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_1)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = shr_i32(sub_i32(loc_1, loc_5), 3)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 536870912) then
			loc_0 = sub_i32(loc_0, loc_5)
			loc_5 = shr_i32(loc_0, 2)
			loc_5 = (lt_u32(loc_0, 2147483640) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 536870911)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 536870912) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
				loc_2 = reg_0
			end
			loc_7 = shl_i32(param_1, 3)
			loc_8 = band_i32(sub_i32(param_1, 1), 536870911)
			loc_3 = add_i32(loc_2, shl_i32(loc_6, 3))
			loc_0 = loc_3
			param_1 = band_i32(param_1, 7)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_0 = add_i32(loc_0, 8)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_4 = add_i32(loc_3, loc_7)
			if ge_u32(loc_8, 7) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_2))
					loc_0 = sub_i32(loc_0, -64)
					if loc_0 ~= loc_4 then goto continue_at_12 end
					break
				end
			end
			loc_2 = add_i32(loc_2, shl_i32(loc_5, 3))
			param_2 = load_i32(memory_at_0, param_0)
			loc_0 = sub_i32(loc_1, param_2)
			param_1 = sub_i32(loc_3, loc_0)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0) end
			store_i32(memory_at_0, param_0 + 8, loc_2)
			store_i32(memory_at_0, param_0 + 4, loc_4)
			store_i32(memory_at_0, param_0, param_1)
			if param_2 ~= 0 then FUNC_LIST[1276](param_2) end
			goto continue_at_0
		end
		FUNC_LIST[149](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[149] = --[[ std::__2::__vector_base<std::__2::pair<unsigned int, short>, std::__2::allocator<std::__2::pair<unsigned int, short> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[150] = --[[ std::__2::vector<std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int>, std::__2::allocator<std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int> > >::__append(unsigned long, std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_2), 12)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_4 = mul_i32(param_1, 12)
			loc_0 = loc_2
			loc_3 = sub_i32(mul_i32(param_1, 12), 12)
			param_1 = band_i32(add_i32(div_u32(loc_3, 12), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if lt_u32(loc_3, 36) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 8)
				store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
				store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 48)
				if loc_0 ~= loc_2 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_2)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_2, loc_5), 12)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 357913942) then
			loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
			loc_5 = shl_i32(loc_0, 1)
			loc_5 = (lt_u32(loc_0, 178956970) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 357913941)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 357913942) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
				loc_4 = reg_0
			end
			loc_3 = add_i32(loc_4, mul_i32(loc_6, 12))
			loc_0 = loc_3
			loc_6 = mul_i32(param_1, 12)
			loc_7 = sub_i32(loc_6, 12)
			param_1 = band_i32(add_i32(div_u32(loc_7, 12), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			param_1 = add_i32(loc_3, loc_6)
			if ge_u32(loc_7, 36) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 8)
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
					store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 48)
					if loc_0 ~= param_1 then goto continue_at_12 end
					break
				end
			end
			loc_4 = add_i32(loc_4, mul_i32(loc_5, 12))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_2, loc_0)
			loc_1 = add_i32(loc_3, mul_i32(div_i32(param_2, -12), 12))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, loc_4)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[151](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[151] = --[[ std::__2::__vector_base<std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int>, std::__2::allocator<std::__2::pair<Luau::BytecodeBuilder::StringRef, unsigned int> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[152] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::Function, std::__2::allocator<Luau::BytecodeBuilder::Function> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[153] = --[[ unsigned int std::__2::__sort4<Luau::BytecodeBuilder::expandJumps()::$_0&, Luau::BytecodeBuilder::Jump*>(Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::expandJumps()::$_0&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0LL
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_2)
		loc_3 = load_i32(memory_at_0, param_1)
		if ge_u32(loc_3, load_i32(memory_at_0, param_0)) then
			reg_0 = 0
			if ge_u32(loc_1, loc_3) then goto continue_at_1 end
			loc_0 = load_i64(memory_at_0, param_1)
			store_i64(memory_at_0, param_1, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, param_2, loc_0)
			if ge_u32(load_i32(memory_at_0, param_1), load_i32(memory_at_0, param_0)) then
				loc_1 = wrap_i32_i64(loc_0)
				reg_0 = 1
				goto continue_at_1
			end
			loc_0 = load_i64(memory_at_0, param_0)
			store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_1))
			store_i64(memory_at_0, param_1, loc_0)
			loc_1 = load_i32(memory_at_0, param_2)
			reg_0 = 2
			goto continue_at_1
		end
		loc_0 = load_i64(memory_at_0, param_0)
		if lt_u32(loc_1, loc_3) then
			store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, param_2, loc_0)
			loc_1 = wrap_i32_i64(loc_0)
			reg_0 = 1
			goto continue_at_1
		end
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_1))
		store_i64(memory_at_0, param_1, loc_0)
		loc_2 = 1
		loc_1 = load_i32(memory_at_0, param_2)
		loc_3 = wrap_i32_i64(loc_0)
		reg_0 = loc_2
		if ge_u32(loc_1, loc_3) then goto continue_at_1 end
		store_i64(memory_at_0, param_1, load_i64(memory_at_0, param_2))
		store_i64(memory_at_0, param_2, loc_0)
		loc_1 = loc_3
		reg_0 = 2
		::continue_at_1::
		loc_2 = reg_0
		if gt_u32(loc_1, load_i32(memory_at_0, param_3)) then
			loc_0 = load_i64(memory_at_0, param_2)
			store_i64(memory_at_0, param_2, load_i64(memory_at_0, param_3))
			store_i64(memory_at_0, param_3, loc_0)
			if ge_u32(load_i32(memory_at_0, param_2), load_i32(memory_at_0, param_1)) then
				reg_0 = add_i32(loc_2, 1)
				goto continue_at_0
			end
			loc_0 = load_i64(memory_at_0, param_1)
			store_i64(memory_at_0, param_1, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, param_2, loc_0)
			if ge_u32(load_i32(memory_at_0, param_1), load_i32(memory_at_0, param_0)) then
				reg_0 = add_i32(loc_2, 2)
				goto continue_at_0
			end
			loc_0 = load_i64(memory_at_0, param_0)
			store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_1))
			store_i64(memory_at_0, param_1, loc_0)
			loc_2 = add_i32(loc_2, 3)
		end
		reg_0 = loc_2
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[154] = --[[ bool std::__2::__insertion_sort_incomplete<Luau::BytecodeBuilder::expandJumps()::$_0&, Luau::BytecodeBuilder::Jump*>(Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::expandJumps()::$_0&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0LL
		local loc_2 = 0
		local loc_3 = 0LL
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_6 = 1
		if not br_map[1] then
			br_map[1] = (function() return { [0] = 5, 5, 0, 1, 2, 3 } end)()
		end
		temp = br_map[1][shr_i32(sub_i32(param_1, param_0), 3)] or 4
		if temp < 3 then
			if temp < 1 then
				goto continue_at_6
			elseif temp > 1 then
				goto continue_at_4
			else
				goto continue_at_5
			end
		elseif temp > 3 then
			if temp < 5 then
				goto continue_at_2
			else
				goto continue_at_1
			end
		else
			goto continue_at_3
		end
		::continue_at_6::
		loc_0 = sub_i32(param_1, 8)
		if ge_u32(load_i32(memory_at_0, loc_0), load_i32(memory_at_0, param_0)) then
			goto continue_at_1
		end
		loc_1 = load_i64(memory_at_0, param_0)
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
		store_i64(memory_at_0, loc_0, loc_1)
		reg_0 = 1
		goto continue_at_0
		::continue_at_5::
		loc_0 = sub_i32(param_1, 8)
		loc_2 = load_i32(memory_at_0, loc_0)
		loc_4 = load_i32(memory_at_0, param_0 + 8)
		if ge_u32(loc_4, load_i32(memory_at_0, param_0)) then
			if ge_u32(loc_2, loc_4) then goto continue_at_1 end
			loc_1 = load_i64(memory_at_0, param_0 + 8)
			store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_0))
			store_i64(memory_at_0, loc_0, loc_1)
			if ge_u32(load_i32(memory_at_0, param_0 + 8), load_i32(memory_at_0, param_0)) then
				goto continue_at_1
			end
			loc_1 = load_i64(memory_at_0, param_0 + 8)
			store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_0))
			store_i64(memory_at_0, param_0, loc_1)
			reg_0 = 1
			goto continue_at_0
		end
		loc_1 = load_i64(memory_at_0, param_0)
		if lt_u32(loc_2, loc_4) then
			store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
			store_i64(memory_at_0, loc_0, loc_1)
			reg_0 = 1
			goto continue_at_0
		end
		loc_3 = load_i64(memory_at_0, param_0 + 8)
		store_i64(memory_at_0, param_0 + 8, loc_1)
		store_i64(memory_at_0, param_0, loc_3)
		if ge_u32(load_i32(memory_at_0, loc_0), wrap_i32_i64(loc_1)) then
			goto continue_at_1
		end
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, loc_0))
		store_i64(memory_at_0, loc_0, loc_1)
		reg_0 = 1
		goto continue_at_0
		::continue_at_4::
		reg_0 = FUNC_LIST[153](
			param_0, add_i32(param_0, 8), add_i32(param_0, 16), sub_i32(param_1, 8)
		)
		reg_0 = 1
		goto continue_at_0
		::continue_at_3::
		loc_5 = add_i32(param_0, 8)
		loc_2 = add_i32(param_0, 16)
		loc_0 = add_i32(param_0, 24)
		reg_0 = FUNC_LIST[153](param_0, loc_5, loc_2, loc_0)
		loc_4 = sub_i32(param_1, 8)
		if ge_u32(load_i32(memory_at_0, loc_4), load_i32(memory_at_0, param_0 + 24)) then
			goto continue_at_1
		end
		loc_1 = load_i64(memory_at_0, loc_0)
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_4))
		store_i64(memory_at_0, loc_4, loc_1)
		if ge_u32(load_i32(memory_at_0, loc_0), load_i32(memory_at_0, loc_2)) then
			goto continue_at_1
		end
		loc_3 = load_i64(memory_at_0, loc_2)
		loc_1 = load_i64(memory_at_0, loc_0)
		store_i64(memory_at_0, loc_2, loc_1)
		store_i64(memory_at_0, loc_0, loc_3)
		loc_0 = wrap_i32_i64(loc_1)
		if ge_u32(loc_0, load_i32(memory_at_0, loc_5)) then goto continue_at_1 end
		store_i64(memory_at_0, param_0 + 16, load_i64(memory_at_0, param_0 + 8))
		store_i64(memory_at_0, param_0 + 8, loc_1)
		if le_u32(load_i32(memory_at_0, param_0), loc_0) then goto continue_at_1 end
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_0))
		store_i64(memory_at_0, param_0, loc_1)
		reg_0 = 1
		goto continue_at_0
		::continue_at_2::
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		loc_4 = load_i32(memory_at_0, param_0)
		if ge_u32(loc_2, loc_4) then
			if ge_u32(loc_0, loc_2) then goto continue_at_9 end
			loc_1 = load_i64(memory_at_0, param_0 + 16)
			loc_3 = load_i64(memory_at_0, param_0 + 8)
			store_i64(memory_at_0, param_0 + 16, loc_3)
			store_i64(memory_at_0, param_0 + 8, loc_1)
			loc_0 = wrap_i32_i64(loc_3)
			if le_u32(loc_4, wrap_i32_i64(loc_1)) then goto continue_at_9 end
			store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_0))
			store_i64(memory_at_0, param_0, loc_1)
			goto continue_at_9
		end
		loc_1 = load_i64(memory_at_0, param_0)
		if lt_u32(loc_0, loc_2) then
			loc_3 = load_i64(memory_at_0, param_0 + 16)
			store_i64(memory_at_0, param_0 + 16, loc_1)
			store_i64(memory_at_0, param_0, loc_3)
			loc_0 = wrap_i32_i64(loc_1)
			goto continue_at_9
		end
		loc_3 = load_i64(memory_at_0, param_0 + 8)
		store_i64(memory_at_0, param_0 + 8, loc_1)
		store_i64(memory_at_0, param_0, loc_3)
		loc_2 = wrap_i32_i64(loc_1)
		if ge_u32(loc_0, loc_2) then goto continue_at_9 end
		loc_3 = load_i64(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, param_0 + 16, loc_1)
		store_i64(memory_at_0, param_0 + 8, loc_3)
		loc_0 = loc_2
		::continue_at_9::
		loc_2 = add_i32(param_0, 24)
		if loc_2 == param_1 then goto continue_at_1 end
		loc_6 = add_i32(param_0, 16)
		::continue_at_12::
		while true do
			loc_5 = loc_2
			if gt_u32(loc_0, load_i32(memory_at_0, loc_5)) then
				loc_1 = load_i64(memory_at_0, loc_5)
				loc_4 = wrap_i32_i64(loc_1)
				::continue_at_15::
				while true do
					loc_0 = loc_6
					store_i64(memory_at_0, loc_2, load_i64(memory_at_0, loc_0))
					if param_0 == loc_0 then
						loc_0 = param_0
						goto continue_at_16
					end
					loc_2 = loc_0
					loc_6 = sub_i32(loc_0, 8)
					if gt_u32(load_i32(memory_at_0, loc_6), loc_4) then goto continue_at_15 end
					::continue_at_16::
					break
				end
				store_i64(memory_at_0, loc_0, loc_1)
				loc_7 = add_i32(loc_7, 1)
				if loc_7 == 8 then goto continue_at_13 end
			end
			loc_2 = add_i32(loc_5, 8)
			if param_1 == loc_2 then
				reg_0 = 1
				goto continue_at_0
			else
				loc_0 = load_i32(memory_at_0, loc_5)
				loc_6 = loc_5
				goto continue_at_12
			end
			error("out of code bounds")
			::continue_at_13::
			break
		end
		loc_6 = (add_i32(loc_5, 8) == param_1 and 1 or 0)
		::continue_at_1::
		reg_0 = loc_6
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[155] = --[[ Luau::Compile::modelCost(Luau::AstNode*, Luau::AstLocal* const*, unsigned long) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0LL
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0LL
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0LL
		local loc_12 = 0
		local loc_13 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		store_i64(memory_at_0, loc_0 + 12, 0LL )
		store_i32(memory_at_0, loc_0 + 20, 0)
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 4, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		loc_9 = 11424
		store_i32(memory_at_0, loc_0, loc_9)
		if param_2 == 0 then goto continue_at_1 end
		loc_10 = bor_i32(loc_0, 4)
		param_2 = sub_i32(param_2, 1)
		loc_11 = extend_i64_u32(add_i32((lt_u32(param_2, 6) and param_2 or 6), 1))
		::continue_at_2::
		while true do
			loc_4 = add_i32(param_1, shl_i32(wrap_i32_i64(loc_1), 2))
			loc_6 = shl_i64(loc_1, 3LL )
			loc_6 = shl_i64(65280LL , loc_6)
			loc_7 = 0
			param_2 = shr_i32(sub_i32(loc_5, loc_2), 4)
			if le_u32(shr_u32(mul_i32(param_2, 3), 2), loc_3) then
				FUNC_LIST[156](loc_10)
				loc_5 = load_i32(memory_at_0, loc_0 + 8)
				loc_2 = load_i32(memory_at_0, loc_0 + 4)
				param_2 = shr_i32(sub_i32(loc_5, loc_2), 4)
			end
			loc_12 = sub_i32(param_2, 1)
			loc_4 = load_i32(memory_at_0, loc_4)
			param_2 = band_i32(loc_12, bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9)))
			loc_8 = add_i32(loc_2, shl_i32(param_2, 4))
			loc_3 = load_i32(memory_at_0, loc_8)
			loc_13 = load_i32(memory_at_0, loc_0 + 20)
			if loc_3 ~= loc_13 then
				::continue_at_6::
				while true do
					if loc_3 == loc_4 then goto continue_at_4 end
					loc_7 = add_i32(loc_7, 1)
					param_2 = band_i32(add_i32(loc_7, param_2), loc_12)
					loc_8 = add_i32(loc_2, shl_i32(param_2, 4))
					loc_3 = load_i32(memory_at_0, loc_8)
					if loc_3 ~= loc_13 then goto continue_at_6 end
					break
				end
			end
			store_i32(memory_at_0, loc_8, loc_4)
			store_i32(
				memory_at_0, loc_0 + 16, add_i32(load_i32(memory_at_0, loc_0 + 16), 1)
			)
			::continue_at_4::
			store_i64(memory_at_0, add_i32(loc_2, shl_i32(param_2, 4)) + 8, loc_6)
			loc_1 = (loc_1 + 1LL )
			if loc_1 == loc_11 then goto continue_at_1 end
			loc_3 = load_i32(memory_at_0, loc_0 + 16)
			goto continue_at_2
		end
		error("out of code bounds")
		::continue_at_1::
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_0))](
			param_0, loc_0
		)
		store_i32(memory_at_0, loc_0, loc_9)
		loc_1 = load_i64(memory_at_0, loc_0 + 32)
		param_2 = load_i32(memory_at_0, loc_0 + 4)
		if param_2 ~= 0 then
			store_i32(memory_at_0, loc_0 + 8, param_2)
			FUNC_LIST[1276](param_2)
		end
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
		reg_0 = loc_1
		return reg_0
	end
FUNC_LIST[156] = --[[ Luau::detail::DenseHashTable<Luau::AstLocal*, std::__2::pair<Luau::AstLocal*, unsigned long long>, std::__2::pair<Luau::AstLocal* const, unsigned long long>, Luau::detail::ItemInterfaceMap<Luau::AstLocal*, unsigned long long>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_4 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_4 then
			if gt_u32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 255) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 16, 0LL )
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			loc_2 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 24, loc_2)
			loc_9 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		loc_2 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 24, loc_2)
		loc_9 = add_i32(param_0, 16)
		reg_0 = shr_i32(sub_i32(loc_4, loc_1), 3)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i32(memory_at_0, loc_0 + 32, loc_2)
		FUNC_LIST[171](add_i32(loc_0, 8), loc_1, add_i32(loc_0, 32))
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_3 then goto continue_at_2 end
		loc_1 = shr_i32(sub_i32(loc_1, loc_3), 4)
		loc_13 = (gt_u32(loc_1, 1) and loc_1 or 1)
		loc_5 = load_i32(memory_at_0, loc_0 + 8)
		loc_10 = sub_i32(
			shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 12), loc_5), 4), 1
		)
		loc_11 = load_i32(memory_at_0, loc_0 + 20)
		::continue_at_6::
		while true do
			loc_12 = add_i32(loc_3, shl_i32(loc_6, 4))
			loc_2 = load_i32(memory_at_0, loc_12)
			if loc_2 ~= load_i32(memory_at_0, loc_9) then
				loc_1 = band_i32(bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9)), loc_10)
				loc_7 = add_i32(loc_5, shl_i32(loc_1, 4))
				loc_8 = load_i32(memory_at_0, loc_7)
				loc_14 = load_i32(memory_at_0, loc_0 + 24)
				if loc_8 == loc_14 then goto continue_at_9 end
				loc_4 = 0
				if loc_2 == loc_8 then goto continue_at_8 end
				::continue_at_10::
				while true do
					loc_4 = add_i32(loc_4, 1)
					loc_1 = band_i32(add_i32(loc_4, loc_1), loc_10)
					loc_7 = add_i32(loc_5, shl_i32(loc_1, 4))
					loc_8 = load_i32(memory_at_0, loc_7)
					if loc_8 == loc_14 then goto continue_at_9 end
					if loc_2 ~= loc_8 then goto continue_at_10 end
					break
				end
				goto continue_at_8
				::continue_at_9::
				store_i32(memory_at_0, loc_7, loc_2)
				loc_11 = add_i32(loc_11, 1)
				store_i32(memory_at_0, loc_0 + 20, loc_11)
				loc_2 = load_i32(memory_at_0, loc_12)
				::continue_at_8::
				store_i32(memory_at_0, loc_7, loc_2)
				store_i64(
					memory_at_0, add_i32(loc_5, shl_i32(loc_1, 4)) + 8,
						load_i64(memory_at_0, loc_12 + 8)
				)
			end
			loc_6 = add_i32(loc_6, 1)
			if loc_6 ~= loc_13 then goto continue_at_6 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		FUNC_LIST[171](param_0, 16, add_i32(loc_0, 8))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_3)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 12))
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 16))
		store_i32(memory_at_0, loc_0 + 16, loc_1)
		if loc_3 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 12, loc_3)
		FUNC_LIST[1276](loc_3)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[157] = --[[ Luau::Compile::CostVisitor::~CostVisitor() ]] function(
	param_0
)
	local loc_0 = 0
	local reg_0
	store_i32(memory_at_0, param_0, 11424)
	loc_0 = load_i32(memory_at_0, param_0 + 4)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 8, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[158] = --[[ Luau::Compile::computeCost(unsigned long long, bool const*, unsigned long) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0
		loc_0 = 127
		loc_1 = wrap_i32_i64(param_0)
		loc_2 = band_i32(loc_1, 127)
		reg_0 = loc_0
		if loc_2 == 127 then goto continue_at_1 end
		if param_2 == 0 then
			reg_0 = loc_2
			goto continue_at_0
		end
		loc_0 = sub_i32(
			loc_2,
				mul_i32(load_i32_u8(memory_at_0, param_1), band_i32(shr_u32(loc_1, 8), 127))
		)
		param_2 = sub_i32(param_2, 1)
		param_2 = (lt_u32(param_2, 6) and param_2 or 6)
		reg_0 = loc_0
		if param_2 == 0 then goto continue_at_1 end
		loc_0 = sub_i32(
			loc_0, mul_i32(
				load_i32_u8(memory_at_0, param_1 + 1), band_i32(shr_u32(loc_1, 16), 127)
			)
		)
		param_2 = add_i32(param_2, 1)
		reg_0 = loc_0
		if param_2 == 2 then goto continue_at_1 end
		loc_0 = sub_i32(
			loc_0, mul_i32(
				load_i32_u8(memory_at_0, param_1 + 2), band_i32(shr_u32(loc_1, 24), 127)
			)
		)
		reg_0 = loc_0
		if param_2 == 3 then goto continue_at_1 end
		loc_0 = sub_i32(
			loc_0, mul_i32(
				load_i32_u8(memory_at_0, param_1 + 3),
					band_i32(wrap_i32_i64(shr_u64(param_0, 32LL )), 127)
			)
		)
		reg_0 = loc_0
		if param_2 == 4 then goto continue_at_1 end
		loc_0 = sub_i32(
			loc_0, mul_i32(
				load_i32_u8(memory_at_0, param_1 + 4),
					band_i32(wrap_i32_i64(shr_u64(param_0, 40LL )), 127)
			)
		)
		reg_0 = loc_0
		if param_2 == 5 then goto continue_at_1 end
		loc_0 = sub_i32(
			loc_0, mul_i32(
				load_i32_u8(memory_at_0, param_1 + 5),
					band_i32(wrap_i32_i64(shr_u64(param_0, 48LL )), 127)
			)
		)
		reg_0 = loc_0
		if param_2 == 6 then goto continue_at_1 end
		reg_0 = sub_i32(
			loc_0, mul_i32(
				load_i32_u8(memory_at_0, param_1 + 6),
					band_i32(wrap_i32_i64(shr_u64(param_0, 56LL )), 127)
			)
		)
		::continue_at_1::
		loc_0 = reg_0
		reg_0 = loc_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[159] = --[[ Luau::Compile::getTripCount(double, double, double) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0, reg_1
		loc_2 = -2147483648
		loc_1 = -2147483648
		reg_0 = loc_1
		if (param_0 >= -3.2767e4 and 1 or 0) == 0 then goto continue_at_1 end
		reg_0 = -2147483648
		if (param_0 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_1 end
		reg_0 = -2147483648
		if abs_f64(param_0) < 2.147483648e9 then
			reg_1 = truncate_i32_f64(param_0)
			goto continue_at_2
		end
		reg_1 = -2147483648
		::continue_at_2::
		loc_0 = reg_1
		if convert_f64_i32(loc_0) ~= param_0 then goto continue_at_1 end
		reg_0 = loc_0
		::continue_at_1::
		loc_1 = reg_0
		if (param_1 >= -3.2767e4 and 1 or 0) == 0 then goto continue_at_4 end
		if (param_1 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_4 end
		if abs_f64(param_1) < 2.147483648e9 then
			reg_0 = truncate_i32_f64(param_1)
			goto continue_at_5
		end
		reg_0 = -2147483648
		::continue_at_5::
		loc_0 = reg_0
		if convert_f64_i32(loc_0) ~= param_1 then goto continue_at_4 end
		loc_2 = loc_0
		::continue_at_4::
		loc_0 = -2147483648
		reg_0 = loc_0
		if (param_2 >= -3.2767e4 and 1 or 0) == 0 then goto continue_at_7 end
		reg_0 = -2147483648
		if (param_2 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_7 end
		reg_0 = -2147483648
		if abs_f64(param_2) < 2.147483648e9 then
			reg_1 = truncate_i32_f64(param_2)
			goto continue_at_8
		end
		reg_1 = -2147483648
		::continue_at_8::
		loc_3 = reg_1
		if convert_f64_i32(loc_3) ~= param_2 then goto continue_at_7 end
		reg_0 = loc_3
		::continue_at_7::
		loc_0 = reg_0
		loc_3 = -1
		if loc_1 == -2147483648 then goto continue_at_10 end
		if loc_2 == -2147483648 then goto continue_at_10 end
		if loc_0 == -2147483648 then goto continue_at_10 end
		if loc_0 == 0 then goto continue_at_10 end
		loc_3 = 0
		if band_i32((loc_0 < 0 and 1 or 0), (loc_1 < loc_2 and 1 or 0)) ~= 0 then
			goto continue_at_10
		end
		if band_i32((loc_0 > 0 and 1 or 0), (loc_1 > loc_2 and 1 or 0)) ~= 0 then
			goto continue_at_10
		end
		loc_3 = add_i32(div_i32(sub_i32(loc_2, loc_1), loc_0), 1)
		::continue_at_10::
		reg_0 = loc_3
		return reg_0
	end
FUNC_LIST[160] = --[[ Luau::Compile::CostVisitor::~CostVisitor().1 ]] function(
	param_0
)
	local loc_0 = 0
	store_i32(memory_at_0, param_0, 11424)
	loc_0 = load_i32(memory_at_0, param_0 + 4)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 8, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	FUNC_LIST[1276](param_0)
end
FUNC_LIST[161] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0LL
		local loc_2 = 0LL
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		FUNC_LIST[162](loc_0, param_0, param_1)
		loc_1 = load_i64(memory_at_0, loc_0)
		store_i64(memory_at_0, param_0 + 40, 0LL )
		loc_1 = (loc_1 + load_i64(memory_at_0, param_0 + 32))
		loc_2 = band_i64(loc_1, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_1, 9187201950435737471LL )
			)
		)
		GLOBAL_LIST[0].value = add_i32(loc_0, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[162] = --[[ Luau::Compile::CostVisitor::model(Luau::AstExpr*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0LL
		local loc_1 = 0
		local loc_2 = 0LL
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local loc_17 = 0
		local loc_18 = 0
		local loc_19 = 0
		local loc_20 = 0LL
		local reg_0
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_1
		loc_6 = load_i32(memory_at_0, 55020)
		loc_7 = load_i32(memory_at_0, 55012)
		loc_8 = load_i32(memory_at_0, 55004)
		loc_9 = load_i32(memory_at_0, 54996)
		loc_10 = load_i32(memory_at_0, 54988)
		loc_11 = load_i32(memory_at_0, 54980)
		loc_12 = load_i32(memory_at_0, 54972)
		loc_13 = load_i32(memory_at_0, 54964)
		loc_14 = load_i32(memory_at_0, 54956)
		loc_15 = load_i32(memory_at_0, 54948)
		loc_16 = load_i32(memory_at_0, 54940)
		loc_17 = load_i32(memory_at_0, 54932)
		loc_18 = load_i32(memory_at_0, 54924)
		loc_19 = load_i32(memory_at_0, 54916)
		loc_4 = load_i32(memory_at_0, 54908)
		loc_5 = load_i32(memory_at_0, 54900)
		::continue_at_2::
		while true do
			loc_3 = load_i32(memory_at_0, param_2 + 4)
			if param_2 == 0 then goto continue_at_3 end
			if loc_3 ~= loc_5 then goto continue_at_3 end
			param_2 = load_i32(memory_at_0, param_2 + 24)
			goto continue_at_2
			::continue_at_3::
			if loc_3 == loc_4 then goto continue_at_5 end
			if loc_3 == loc_19 then goto continue_at_5 end
			if loc_3 == loc_18 then goto continue_at_5 end
			if loc_3 ~= loc_17 then goto continue_at_4 end
			::continue_at_5::
			store_i64(memory_at_0, param_0 + 8, -1LL )
			store_i64(memory_at_0, param_0, 0LL )
			goto continue_at_1
			::continue_at_4::
			if param_2 == 0 then goto continue_at_6 end
			if loc_3 ~= loc_16 then goto continue_at_6 end
			reg_0 = FUNC_LIST[173](add_i32(param_1, 4), add_i32(param_2, 24))
			param_2 = reg_0
			if param_2 ~= 0 then loc_0 = load_i64(memory_at_0, param_2) end
			store_i64(memory_at_0, param_0 + 8, loc_0)
			store_i64(memory_at_0, param_0, 0LL )
			goto continue_at_1
			::continue_at_6::
			if loc_3 == loc_15 then
				store_i64(memory_at_0, param_0 + 8, 0LL )
				store_i64(memory_at_0, param_0, 1LL )
				goto continue_at_1
			end
			if loc_3 == loc_14 then
				store_i64(memory_at_0, param_0 + 8, 0LL )
				store_i64(memory_at_0, param_0, 3LL )
				goto continue_at_1
			end
			if param_2 == 0 then goto continue_at_10 end
			if loc_3 ~= loc_13 then goto continue_at_10 end
			store_i64(memory_at_0, param_0 + 8, 0LL )
			store_i64(memory_at_0, param_0, 3LL )
			FUNC_LIST[162](
				add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24)
			)
			loc_0 = load_i64(memory_at_0, loc_1 + 32)
			store_i64(memory_at_0, param_0 + 8, 0LL )
			loc_0 = (loc_0 + load_i64(memory_at_0, param_0))
			loc_2 = band_i64(loc_0, -9187201950435737472LL )
			store_i64(
				memory_at_0, param_0, bor_i64(
					(loc_2 - shr_u64(loc_2, 7LL )),
						band_i64(loc_0, 9187201950435737471LL )
				)
			)
			if load_i32(memory_at_0, param_2 + 32) == 0 then goto continue_at_1 end
			loc_3 = 0
			::continue_at_11::
			while true do
				FUNC_LIST[162](
					add_i32(loc_1, 32), param_1, load_i32(
						memory_at_0,
							add_i32(load_i32(memory_at_0, param_2 + 28), shl_i32(loc_3, 2))
					)
				)
				loc_0 = load_i64(memory_at_0, loc_1 + 32)
				store_i64(memory_at_0, param_0 + 8, 0LL )
				loc_0 = (load_i64(memory_at_0, param_0) +
					        (loc_0 == 0LL and 1LL or loc_0))
				loc_2 = band_i64(loc_0, -9187201950435737472LL )
				store_i64(
					memory_at_0, param_0, bor_i64(
						(loc_2 - shr_u64(loc_2, 7LL )),
							band_i64(loc_0, 9187201950435737471LL )
					)
				)
				loc_3 = add_i32(loc_3, 1)
				if lt_u32(loc_3, load_i32(memory_at_0, param_2 + 32)) then
					goto continue_at_11
				end
				break
			end
			goto continue_at_1
			::continue_at_10::
			if param_2 == 0 then goto continue_at_12 end
			if loc_3 ~= loc_12 then goto continue_at_12 end
			FUNC_LIST[162](
				add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24)
			)
			store_i64(memory_at_0, param_0 + 8, 0LL )
			loc_0 = (load_i64(memory_at_0, loc_1 + 32) + 1LL )
			loc_2 = band_i64(loc_0, -9187201950435737472LL )
			store_i64(
				memory_at_0, param_0, bor_i64(
					(loc_2 - shr_u64(loc_2, 7LL )),
						band_i64(loc_0, 9187201950435737471LL )
				)
			)
			goto continue_at_1
			::continue_at_12::
			if param_2 == 0 then goto continue_at_13 end
			if loc_3 ~= loc_11 then goto continue_at_13 end
			FUNC_LIST[162](
				add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24)
			)
			FUNC_LIST[162](
				add_i32(loc_1, 16), param_1, load_i32(memory_at_0, param_2 + 28)
			)
			loc_0 = load_i64(memory_at_0, loc_1 + 16)
			loc_2 = load_i64(memory_at_0, loc_1 + 32)
			store_i64(memory_at_0, param_0 + 8, 0LL )
			loc_0 = (loc_0 + loc_2)
			loc_2 = band_i64(loc_0, -9187201950435737472LL )
			loc_0 = (bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_0, 9187201950435737471LL )
			) + 1LL )
			loc_2 = band_i64(loc_0, -9187201950435737472LL )
			store_i64(
				memory_at_0, param_0, bor_i64(
					(loc_2 - shr_u64(loc_2, 7LL )),
						band_i64(loc_0, 9187201950435737471LL )
				)
			)
			goto continue_at_1
			::continue_at_13::
			if param_2 == 0 then goto continue_at_14 end
			if loc_3 ~= loc_10 then goto continue_at_14 end
			store_i64(memory_at_0, param_0 + 8, 0LL )
			store_i64(memory_at_0, param_0, 10LL )
			goto continue_at_1
			::continue_at_14::
			if param_2 == 0 then goto continue_at_15 end
			if loc_3 ~= loc_9 then goto continue_at_15 end
			store_i64(memory_at_0, param_0 + 8, 0LL )
			store_i64(memory_at_0, param_0, 10LL )
			if load_i32(memory_at_0, param_2 + 28) == 0 then goto continue_at_1 end
			loc_3 = 0
			::continue_at_16::
			while true do
				loc_5 = add_i32(load_i32(memory_at_0, param_2 + 24), mul_i32(loc_3, 12))
				loc_4 = load_i32(memory_at_0, loc_5 + 4)
				if loc_4 ~= 0 then
					FUNC_LIST[162](add_i32(loc_1, 32), param_1, loc_4)
					loc_0 = load_i64(memory_at_0, loc_1 + 32)
					store_i64(memory_at_0, param_0 + 8, 0LL )
					loc_0 = (loc_0 + load_i64(memory_at_0, param_0))
					loc_2 = band_i64(loc_0, -9187201950435737472LL )
					store_i64(
						memory_at_0, param_0, bor_i64(
							(loc_2 - shr_u64(loc_2, 7LL )),
								band_i64(loc_0, 9187201950435737471LL )
						)
					)
				end
				FUNC_LIST[162](add_i32(loc_1, 32), param_1, load_i32(memory_at_0, loc_5 + 8))
				loc_0 = load_i64(memory_at_0, param_0)
				loc_2 = load_i64(memory_at_0, loc_1 + 32)
				store_i64(memory_at_0, param_0 + 8, 0LL )
				loc_0 = (loc_0 + loc_2)
				loc_2 = band_i64(loc_0, -9187201950435737472LL )
				loc_0 = (bor_i64(
					(loc_2 - shr_u64(loc_2, 7LL )),
						band_i64(loc_0, 9187201950435737471LL )
				) + 1LL )
				loc_2 = band_i64(loc_0, -9187201950435737472LL )
				store_i64(
					memory_at_0, param_0, bor_i64(
						(loc_2 - shr_u64(loc_2, 7LL )),
							band_i64(loc_0, 9187201950435737471LL )
					)
				)
				loc_3 = add_i32(loc_3, 1)
				if lt_u32(loc_3, load_i32(memory_at_0, param_2 + 28)) then
					goto continue_at_16
				end
				break
			end
			goto continue_at_1
			::continue_at_15::
			if param_2 == 0 then goto continue_at_18 end
			if loc_3 ~= loc_8 then goto continue_at_18 end
			FUNC_LIST[162](
				add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 28)
			)
			store_i64(memory_at_0, loc_1 + 24, -1LL )
			store_i64(memory_at_0, loc_1 + 16, 0LL )
			FUNC_LIST[174](param_0, add_i32(loc_1, 32), add_i32(loc_1, 16))
			goto continue_at_1
			::continue_at_18::
			if param_2 == 0 then goto continue_at_19 end
			if loc_3 ~= loc_7 then goto continue_at_19 end
			FUNC_LIST[162](
				add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 28)
			)
			FUNC_LIST[162](
				add_i32(loc_1, 16), param_1, load_i32(memory_at_0, param_2 + 32)
			)
			FUNC_LIST[174](param_0, add_i32(loc_1, 32), add_i32(loc_1, 16))
			goto continue_at_1
			::continue_at_19::
			if param_2 == 0 then goto continue_at_20 end
			if loc_3 ~= loc_6 then goto continue_at_20 end
			param_2 = load_i32(memory_at_0, param_2 + 24)
			goto continue_at_2
			::continue_at_20::
			break
		end
		if param_2 == 0 then goto continue_at_21 end
		if loc_3 ~= load_i32(memory_at_0, 55028) then goto continue_at_21 end
		FUNC_LIST[162](
			add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24)
		)
		FUNC_LIST[162](
			add_i32(loc_1, 16), param_1, load_i32(memory_at_0, param_2 + 32)
		)
		loc_0 = load_i64(memory_at_0, loc_1 + 16)
		loc_2 = load_i64(memory_at_0, loc_1 + 32)
		FUNC_LIST[162](loc_1, param_1, load_i32(memory_at_0, param_2 + 40))
		loc_20 = load_i64(memory_at_0, loc_1)
		store_i64(memory_at_0, param_0 + 8, 0LL )
		loc_0 = (loc_0 + loc_2)
		loc_2 = band_i64(loc_0, -9187201950435737472LL )
		loc_0 = (loc_20 + bor_i64(
			(loc_2 - shr_u64(loc_2, 7LL )),
				band_i64(loc_0, 9187201950435737471LL )
		))
		loc_2 = band_i64(loc_0, -9187201950435737472LL )
		loc_0 = (bor_i64(
			(loc_2 - shr_u64(loc_2, 7LL )),
				band_i64(loc_0, 9187201950435737471LL )
		) + 2LL )
		loc_2 = band_i64(loc_0, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0, bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_0, 9187201950435737471LL )
			)
		)
		goto continue_at_1
		::continue_at_21::
		store_i64(memory_at_0, param_0, 0LL )
		store_i64(memory_at_0, param_0 + 8, 0LL )
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_1, 48)
	end
FUNC_LIST[163] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStat*) ]]
	function(param_0, param_1)
		local loc_0 = 0LL
		local loc_1 = 0LL
		local reg_0
		loc_0 = 2LL
		param_1 = load_i32(memory_at_0, param_1 + 4)
		if param_1 == load_i32(memory_at_0, 55044) then goto continue_at_2 end
		loc_0 = 1LL
		if param_1 == load_i32(memory_at_0, 55068) then goto continue_at_2 end
		if param_1 ~= load_i32(memory_at_0, 55076) then goto continue_at_1 end
		::continue_at_2::
		store_i64(memory_at_0, param_0 + 40, 0LL )
		loc_0 = (load_i64(memory_at_0, param_0 + 32) + loc_0)
		loc_1 = band_i64(loc_0, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_1 - shr_u64(loc_1, 7LL )),
					band_i64(loc_0, 9187201950435737471LL )
			)
		)
		::continue_at_1::
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[164] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatWhile*) ]]
	function(param_0, param_1)
		local loc_0 = 0LL
		local loc_1 = 0
		local loc_2 = 0LL
		local loc_3 = 0LL
		local loc_4 = 0
		local reg_0, reg_1, reg_2
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_1
		FUNC_LIST[162](loc_1, param_0, load_i32(memory_at_0, param_1 + 28))
		param_1 = load_i32(memory_at_0, param_1 + 32)
		loc_0 = load_i64(memory_at_0, loc_1)
		loc_4 = add_i32(param_0, 40)
		store_i64(memory_at_0, loc_4, 0LL )
		loc_2 = load_i64(memory_at_0, param_0 + 32)
		store_i64(memory_at_0, param_0 + 32, 0LL )
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, param_0
		)
		store_i64(memory_at_0, loc_4, 0LL )
		loc_0 = (loc_0 + load_i64(memory_at_0, param_0 + 32))
		loc_3 = band_i64(loc_0, -9187201950435737472LL )
		loc_0 = bor_i64(
			(loc_3 - shr_u64(loc_3, 7LL )),
				band_i64(loc_0, 9187201950435737471LL )
		)
		loc_3 = band_i64(shr_u64(loc_0, 8LL ), 35747867511423103LL )
		loc_0 = (band_i64(loc_0, 35747867511423103LL ) * 3LL )
		reg_2 = bor_i64(
			band_i64((loc_3 * 768LL ), 9151454082924314368LL ),
				band_i64(loc_0, 35747867511423103LL )
		)
		loc_0 = bor_i64(
			band_i64(
				shr_u64((loc_0 + 9187483429707480960LL ), 8LL ),
					36029346783166592LL
			), band_i64(
				((loc_3 * 3LL ) + 9187483429707480960LL ),
					-9223231297218904064LL
			)
		)
		loc_0 = (loc_2 + bor_i64(reg_2, (loc_0 - shr_u64(loc_0, 7LL ))))
		loc_2 = band_i64(loc_0, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_0, 9187201950435737471LL )
			)
		)
		GLOBAL_LIST[0].value = add_i32(loc_1, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[165] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatRepeat*) ]]
	function(param_0, param_1)
		local loc_0 = 0LL
		local loc_1 = 0
		local loc_2 = 0LL
		local loc_3 = 0LL
		local loc_4 = 0
		local reg_0, reg_1, reg_2
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_1
		FUNC_LIST[162](loc_1, param_0, load_i32(memory_at_0, param_1 + 28))
		param_1 = load_i32(memory_at_0, param_1 + 32)
		loc_0 = load_i64(memory_at_0, loc_1)
		loc_4 = add_i32(param_0, 40)
		store_i64(memory_at_0, loc_4, 0LL )
		loc_2 = load_i64(memory_at_0, param_0 + 32)
		store_i64(memory_at_0, param_0 + 32, 0LL )
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, param_0
		)
		store_i64(memory_at_0, loc_4, 0LL )
		loc_0 = (loc_0 + load_i64(memory_at_0, param_0 + 32))
		loc_3 = band_i64(loc_0, -9187201950435737472LL )
		loc_0 = bor_i64(
			(loc_3 - shr_u64(loc_3, 7LL )),
				band_i64(loc_0, 9187201950435737471LL )
		)
		loc_3 = band_i64(shr_u64(loc_0, 8LL ), 35747867511423103LL )
		loc_0 = (band_i64(loc_0, 35747867511423103LL ) * 3LL )
		reg_2 = bor_i64(
			band_i64((loc_3 * 768LL ), 9151454082924314368LL ),
				band_i64(loc_0, 35747867511423103LL )
		)
		loc_0 = bor_i64(
			band_i64(
				shr_u64((loc_0 + 9187483429707480960LL ), 8LL ),
					36029346783166592LL
			), band_i64(
				((loc_3 * 3LL ) + 9187483429707480960LL ),
					-9223231297218904064LL
			)
		)
		loc_0 = (loc_2 + bor_i64(reg_2, (loc_0 - shr_u64(loc_0, 7LL ))))
		loc_2 = band_i64(loc_0, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_0, 9187201950435737471LL )
			)
		)
		GLOBAL_LIST[0].value = add_i32(loc_1, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[166] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0LL
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0LL
		local reg_0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		if load_i32(memory_at_0, param_1 + 40) ~= 0 then
			loc_0 = add_i32(param_0, 4)
			::continue_at_2::
			while true do
				loc_1 = shl_i32(loc_4, 2)
				FUNC_LIST[162](
					loc_3, param_0,
						load_i32(memory_at_0, add_i32(loc_1, load_i32(memory_at_0, param_1 + 36)))
				)
				loc_2 = load_i64(memory_at_0, loc_3 + 8)
				if loc_2 == 0LL then goto continue_at_3 end
				if ge_u32(loc_4, load_i32(memory_at_0, param_1 + 32)) then
					goto continue_at_3
				end
				loc_5 = add_i32(load_i32(memory_at_0, param_1 + 28), loc_1)
				loc_8 = 0
				loc_6 = load_i32(memory_at_0, loc_0)
				loc_1 = shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_6), 4)
				if ge_u32(load_i32(memory_at_0, loc_0 + 12), shr_u32(mul_i32(loc_1, 3), 2)) then
					FUNC_LIST[156](loc_0)
					loc_6 = load_i32(memory_at_0, loc_0)
					loc_1 = shr_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_6), 4)
				end
				loc_10 = sub_i32(loc_1, 1)
				loc_7 = load_i32(memory_at_0, loc_5)
				loc_1 = band_i32(loc_10, bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9)))
				loc_9 = add_i32(loc_6, shl_i32(loc_1, 4))
				loc_5 = load_i32(memory_at_0, loc_9)
				loc_11 = load_i32(memory_at_0, loc_0 + 16)
				if loc_5 ~= loc_11 then
					::continue_at_7::
					while true do
						if loc_5 == loc_7 then goto continue_at_5 end
						loc_8 = add_i32(loc_8, 1)
						loc_1 = band_i32(add_i32(loc_8, loc_1), loc_10)
						loc_9 = add_i32(loc_6, shl_i32(loc_1, 4))
						loc_5 = load_i32(memory_at_0, loc_9)
						if loc_5 ~= loc_11 then goto continue_at_7 end
						break
					end
				end
				store_i32(memory_at_0, loc_9, loc_7)
				store_i32(
					memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
				)
				::continue_at_5::
				store_i64(memory_at_0, add_i32(loc_6, shl_i32(loc_1, 4)) + 8, loc_2)
				::continue_at_3::
				loc_2 = load_i64(memory_at_0, loc_3)
				store_i64(memory_at_0, param_0 + 40, 0LL )
				loc_2 = (loc_2 + load_i64(memory_at_0, param_0 + 32))
				loc_12 = band_i64(loc_2, -9187201950435737472LL )
				store_i64(
					memory_at_0, param_0 + 32, bor_i64(
						(loc_12 - shr_u64(loc_12, 7LL )),
							band_i64(loc_2, 9187201950435737471LL )
					)
				)
				loc_4 = add_i32(loc_4, 1)
				if lt_u32(loc_4, load_i32(memory_at_0, param_1 + 40)) then
					goto continue_at_2
				end
				break
			end
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[167] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatFor*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0LL
		local loc_2 = 0LL
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0LL
		local loc_11 = 0
		local loc_12 = 0LL
		local reg_0, reg_1, reg_2
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_5
		FUNC_LIST[162](loc_5, param_0, load_i32(memory_at_0, param_1 + 32))
		loc_1 = load_i64(memory_at_0, loc_5)
		loc_0 = add_i32(param_0, 40)
		store_i64(memory_at_0, loc_0, 0LL )
		loc_1 = (loc_1 + load_i64(memory_at_0, param_0 + 32))
		loc_2 = band_i64(loc_1, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_1, 9187201950435737471LL )
			)
		)
		FUNC_LIST[162](loc_5, param_0, load_i32(memory_at_0, param_1 + 36))
		loc_1 = load_i64(memory_at_0, loc_5)
		store_i64(memory_at_0, loc_0, 0LL )
		loc_1 = (loc_1 + load_i64(memory_at_0, param_0 + 32))
		loc_2 = band_i64(loc_1, -9187201950435737472LL )
		loc_1 = bor_i64(
			(loc_2 - shr_u64(loc_2, 7LL )),
				band_i64(loc_1, 9187201950435737471LL )
		)
		store_i64(memory_at_0, param_0 + 32, loc_1)
		loc_0 = load_i32(memory_at_0, param_1 + 40)
		if loc_0 ~= 0 then
			FUNC_LIST[162](loc_5, param_0, loc_0)
			loc_1 = (load_i64(memory_at_0, loc_5) + load_i64(memory_at_0, param_0 + 32))
			loc_2 = band_i64(loc_1, -9187201950435737472LL )
			loc_1 = bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_1, 9187201950435737471LL )
			)
		end
		loc_11 = add_i32(param_0, 32)
		loc_3 = load_i32(memory_at_0, 54924)
		loc_0 = load_i32(memory_at_0, param_1 + 32)
		loc_4 = load_i32(memory_at_0, loc_0 + 4)
		if loc_0 == 0 then goto continue_at_6 end
		if loc_3 ~= loc_4 then goto continue_at_6 end
		reg_0 = load_f64(memory_at_0, loc_0 + 24)
		goto continue_at_5
		::continue_at_6::
		if loc_0 == 0 then goto continue_at_4 end
		if loc_4 ~= load_i32(memory_at_0, 55004) then goto continue_at_4 end
		if load_i32(memory_at_0, loc_0 + 24) ~= 1 then goto continue_at_4 end
		loc_0 = load_i32(memory_at_0, loc_0 + 28)
		if load_i32(memory_at_0, loc_0 + 4) ~= loc_3 then goto continue_at_4 end
		if loc_0 == 0 then goto continue_at_4 end
		reg_0 = neg_f64(load_f64(memory_at_0, loc_0 + 24))
		::continue_at_5::
		loc_6 = reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 36)
		loc_4 = load_i32(memory_at_0, loc_0 + 4)
		if loc_0 == 0 then goto continue_at_8 end
		if loc_3 ~= loc_4 then goto continue_at_8 end
		reg_0 = load_f64(memory_at_0, loc_0 + 24)
		goto continue_at_7
		::continue_at_8::
		if loc_0 == 0 then goto continue_at_4 end
		if loc_4 ~= load_i32(memory_at_0, 55004) then goto continue_at_4 end
		if load_i32(memory_at_0, loc_0 + 24) ~= 1 then goto continue_at_4 end
		loc_0 = load_i32(memory_at_0, loc_0 + 28)
		if load_i32(memory_at_0, loc_0 + 4) ~= loc_3 then goto continue_at_4 end
		if loc_0 == 0 then goto continue_at_4 end
		reg_0 = neg_f64(load_f64(memory_at_0, loc_0 + 24))
		::continue_at_7::
		loc_7 = reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 40)
		reg_0 = 1e0
		if loc_0 == 0 then goto continue_at_9 end
		loc_4 = load_i32(memory_at_0, loc_0 + 4)
		if loc_3 == loc_4 then
			reg_0 = load_f64(memory_at_0, loc_0 + 24)
			goto continue_at_9
		end
		if loc_4 ~= load_i32(memory_at_0, 55004) then goto continue_at_4 end
		if load_i32(memory_at_0, loc_0 + 24) ~= 1 then goto continue_at_4 end
		loc_0 = load_i32(memory_at_0, loc_0 + 28)
		if load_i32(memory_at_0, loc_0 + 4) ~= loc_3 then goto continue_at_4 end
		if loc_0 == 0 then goto continue_at_4 end
		reg_0 = neg_f64(load_f64(memory_at_0, loc_0 + 24))
		::continue_at_9::
		loc_8 = reg_0
		loc_9 = -2147483648
		loc_4 = -2147483648
		reg_0 = loc_4
		if (loc_6 >= -3.2767e4 and 1 or 0) == 0 then goto continue_at_11 end
		reg_0 = -2147483648
		if (loc_6 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_11 end
		reg_0 = -2147483648
		reg_1 = loc_6
		if abs_f64(loc_6) < 2.147483648e9 then
			reg_2 = truncate_i32_f64(loc_6)
			goto continue_at_12
		end
		reg_2 = -2147483648
		::continue_at_12::
		loc_0 = reg_2
		if reg_1 ~= convert_f64_i32(loc_0) then goto continue_at_11 end
		reg_0 = loc_0
		::continue_at_11::
		loc_4 = reg_0
		if (loc_7 >= -3.2767e4 and 1 or 0) == 0 then goto continue_at_14 end
		if (loc_7 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_14 end
		reg_0 = loc_7
		if abs_f64(loc_7) < 2.147483648e9 then
			reg_1 = truncate_i32_f64(loc_7)
			goto continue_at_15
		end
		reg_1 = -2147483648
		::continue_at_15::
		loc_0 = reg_1
		if reg_0 ~= convert_f64_i32(loc_0) then goto continue_at_14 end
		loc_9 = loc_0
		::continue_at_14::
		loc_3 = -2147483648
		reg_0 = loc_3
		if (loc_8 >= -3.2767e4 and 1 or 0) == 0 then goto continue_at_17 end
		reg_0 = -2147483648
		if (loc_8 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_17 end
		reg_0 = -2147483648
		reg_1 = loc_8
		if abs_f64(loc_8) < 2.147483648e9 then
			reg_2 = truncate_i32_f64(loc_8)
			goto continue_at_18
		end
		reg_2 = -2147483648
		::continue_at_18::
		loc_0 = reg_2
		if reg_1 ~= convert_f64_i32(loc_0) then goto continue_at_17 end
		reg_0 = loc_0
		::continue_at_17::
		loc_3 = reg_0
		if loc_4 == -2147483648 then goto continue_at_4 end
		if loc_9 == -2147483648 then goto continue_at_4 end
		if loc_3 == -2147483648 then goto continue_at_4 end
		if loc_3 == 0 then goto continue_at_4 end
		if band_i32((loc_3 < 0 and 1 or 0), (loc_4 < loc_9 and 1 or 0)) == 0 then
			if loc_3 <= 0 then goto continue_at_20 end
			if loc_4 <= loc_9 then goto continue_at_20 end
		end
		loc_0 = load_i32(memory_at_0, param_1 + 44)
		reg_0 = 0
		goto continue_at_2
		::continue_at_20::
		loc_0 = load_i32(memory_at_0, param_1 + 44)
		param_1 = div_i32(sub_i32(loc_9, loc_4), loc_3)
		if param_1 <= -2 then goto continue_at_3 end
		reg_0 = add_i32(param_1, 1)
		goto continue_at_2
		::continue_at_4::
		loc_0 = load_i32(memory_at_0, param_1 + 44)
		::continue_at_3::
		reg_0 = 3
		::continue_at_2::
		param_1 = reg_0
		store_i64(memory_at_0, loc_11, 0LL )
		store_i64(memory_at_0, loc_11 + 8, 0LL )
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_0))](
			loc_0, param_0
		)
		store_i64(memory_at_0, param_0 + 40, 0LL )
		loc_2 = (load_i64(memory_at_0, param_0 + 32) + 1LL )
		loc_10 = band_i64(loc_2, -9187201950435737472LL )
		loc_2 = bor_i64(
			(loc_10 - shr_u64(loc_10, 7LL )),
				band_i64(loc_2, 9187201950435737471LL )
		)
		loc_10 = extend_i64_u32((param_1 < 127 and param_1 or 127))
		loc_12 = (band_i64(shr_u64(loc_2, 8LL ), 35747867511423103LL ) *
			         loc_10)
		loc_2 = (band_i64(loc_2, 35747867511423103LL ) * loc_10)
		reg_1 = bor_i64(
			band_i64(shl_i64(loc_12, 8LL ), 9151454082924314368LL ),
				band_i64(loc_2, 35747867511423103LL )
		)
		loc_2 = bor_i64(
			band_i64(
				shr_u64((loc_2 + 9187483429707480960LL ), 8LL ),
					36029346783166592LL
			), band_i64(
				(loc_12 + 9187483429707480960LL ), -9223231297218904064LL
			)
		)
		loc_1 = (bor_i64(reg_1, (loc_2 - shr_u64(loc_2, 7LL ))) + loc_1)
		loc_2 = band_i64(loc_1, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_2 - shr_u64(loc_2, 7LL )),
					band_i64(loc_1, 9187201950435737471LL )
			)
		)
		GLOBAL_LIST[0].value = add_i32(loc_5, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[168] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatForIn*) ]]
	function(param_0, param_1)
		local loc_0 = 0LL
		local loc_1 = 0LL
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0LL
		local reg_0, reg_1
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		if load_i32(memory_at_0, param_1 + 40) == 0 then
			loc_1 = load_i64(memory_at_0, param_0 + 32)
			goto continue_at_1
		end
		::continue_at_3::
		while true do
			FUNC_LIST[162](
				loc_3, param_0, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 36), shl_i32(loc_2, 2))
				)
			)
			loc_1 = load_i64(memory_at_0, loc_3)
			store_i64(memory_at_0, param_0 + 40, 0LL )
			loc_1 = (loc_1 + load_i64(memory_at_0, param_0 + 32))
			loc_0 = band_i64(loc_1, -9187201950435737472LL )
			loc_1 = bor_i64(
				(loc_0 - shr_u64(loc_0, 7LL )),
					band_i64(loc_1, 9187201950435737471LL )
			)
			store_i64(memory_at_0, param_0 + 32, loc_1)
			loc_2 = add_i32(loc_2, 1)
			if lt_u32(loc_2, load_i32(memory_at_0, param_1 + 40)) then
				goto continue_at_3
			end
			break
		end
		::continue_at_1::
		loc_2 = load_i32(memory_at_0, param_1 + 44)
		param_1 = add_i32(param_0, 40)
		store_i64(memory_at_0, param_1, 0LL )
		store_i64(memory_at_0, param_0 + 32, 0LL )
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_2))](
			loc_2, param_0
		)
		store_i64(memory_at_0, param_1, 0LL )
		loc_0 = (load_i64(memory_at_0, param_0 + 32) + 1LL )
		loc_4 = band_i64(loc_0, -9187201950435737472LL )
		loc_0 = bor_i64(
			(loc_4 - shr_u64(loc_4, 7LL )),
				band_i64(loc_0, 9187201950435737471LL )
		)
		loc_4 = band_i64(shr_u64(loc_0, 8LL ), 35747867511423103LL )
		loc_0 = (band_i64(loc_0, 35747867511423103LL ) * 3LL )
		reg_1 = bor_i64(
			band_i64((loc_4 * 768LL ), 9151454082924314368LL ),
				band_i64(loc_0, 35747867511423103LL )
		)
		loc_0 = bor_i64(
			band_i64(
				shr_u64((loc_0 + 9187483429707480960LL ), 8LL ),
					36029346783166592LL
			), band_i64(
				((loc_4 * 3LL ) + 9187483429707480960LL ),
					-9223231297218904064LL
			)
		)
		loc_1 = (bor_i64(reg_1, (loc_0 - shr_u64(loc_0, 7LL ))) + loc_1)
		loc_0 = band_i64(loc_1, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_0 - shr_u64(loc_0, 7LL )),
					band_i64(loc_1, 9187201950435737471LL )
			)
		)
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[169] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatAssign*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_6 = load_i32(memory_at_0, param_1 + 32)
		if loc_6 ~= 0 then
			loc_5 = load_i32(memory_at_0, param_0 + 20)
			loc_2 = load_i32(memory_at_0, param_0 + 4)
			loc_7 = load_i32(memory_at_0, 54940)
			loc_8 = load_i32(memory_at_0, param_1 + 28)
			::continue_at_2::
			while true do
				param_1 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_3, 2)))
				if param_1 == 0 then goto continue_at_3 end
				if load_i32(memory_at_0, param_1 + 4) ~= loc_7 then goto continue_at_3 end
				loc_0 = load_i32(memory_at_0, param_0 + 8)
				if loc_2 == loc_0 then goto continue_at_3 end
				loc_4 = load_i32(memory_at_0, param_1 + 24)
				if loc_4 == loc_5 then goto continue_at_3 end
				loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_0 = sub_i32(shr_i32(sub_i32(loc_0, loc_2), 4), 1)
				param_1 = 0
				::continue_at_4::
				while true do
					loc_9 = band_i32(loc_0, loc_1)
					loc_10 = add_i32(loc_2, shl_i32(loc_9, 4))
					loc_1 = load_i32(memory_at_0, loc_10)
					if loc_4 ~= loc_1 then
						if loc_1 == loc_5 then goto continue_at_3 end
						param_1 = add_i32(param_1, 1)
						loc_1 = add_i32(param_1, loc_9)
						if le_u32(param_1, loc_0) then goto continue_at_4 end
						goto continue_at_3
					end
					break
				end
				store_i64(memory_at_0, loc_10 + 8, 0LL )
				::continue_at_3::
				loc_3 = add_i32(loc_3, 1)
				if loc_3 ~= loc_6 then goto continue_at_2 end
				break
			end
		end
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[170] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatCompoundAssign*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0LL
		local loc_9 = 0LL
		local reg_0
		loc_4 = load_i32(memory_at_0, 54940)
		param_1 = load_i32(memory_at_0, param_1 + 32)
		loc_5 = load_i32(memory_at_0, param_1 + 4)
		if param_1 == 0 then goto continue_at_1 end
		if loc_4 ~= loc_5 then goto continue_at_1 end
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		if loc_2 == loc_0 then goto continue_at_1 end
		loc_3 = load_i32(memory_at_0, param_1 + 24)
		loc_7 = load_i32(memory_at_0, param_0 + 20)
		if loc_3 == loc_7 then goto continue_at_1 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_0 = sub_i32(shr_i32(sub_i32(loc_0, loc_2), 4), 1)
		param_1 = 0
		::continue_at_2::
		while true do
			loc_6 = band_i32(loc_0, loc_1)
			loc_1 = load_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_6, 4)))
			if loc_3 ~= loc_1 then
				if loc_1 == loc_7 then goto continue_at_1 end
				param_1 = add_i32(param_1, 1)
				loc_1 = add_i32(param_1, loc_6)
				if le_u32(param_1, loc_0) then goto continue_at_2 end
				goto continue_at_1
			end
			break
		end
		store_i64(memory_at_0, add_i32(loc_2, shl_i32(loc_6, 4)) + 8, 0LL )
		::continue_at_1::
		store_i64(memory_at_0, param_0 + 40, 0LL )
		loc_8 = (load_i64(memory_at_0, param_0 + 32) +
			        (loc_4 == loc_5 and 1LL or 2LL ))
		loc_9 = band_i64(loc_8, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0 + 32, bor_i64(
				(loc_9 - shr_u64(loc_9, 7LL )),
					band_i64(loc_8, 9187201950435737471LL )
			)
		)
		reg_0 = 1
		return reg_0
	end
FUNC_LIST[171] = --[[ std::__2::vector<std::__2::pair<Luau::AstLocal*, unsigned long long>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, unsigned long long> > >::__append(unsigned long, std::__2::pair<Luau::AstLocal*, unsigned long long> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_0, loc_2), 4)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_3 = shl_i32(param_1, 4)
			loc_4 = band_i32(sub_i32(param_1, 1), 268435455)
			loc_0 = loc_2
			param_1 = band_i32(param_1, 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 16)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_3)
			if lt_u32(loc_4, 3) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 8)
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, loc_1))
				loc_0 = sub_i32(loc_0, -64)
				if loc_0 ~= loc_2 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_2)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = shr_i32(sub_i32(loc_2, loc_5), 4)
		loc_4 = add_i32(loc_6, param_1)
		if lt_u32(loc_4, 268435456) then
			loc_0 = sub_i32(loc_0, loc_5)
			loc_5 = shr_i32(loc_0, 3)
			loc_5 = (lt_u32(loc_0, 2147483632) and
				        (lt_u32(loc_4, loc_5) and loc_5 or loc_4) or 268435455)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 268435456) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 4))
				loc_3 = reg_0
			end
			loc_7 = shl_i32(param_1, 4)
			loc_8 = band_i32(sub_i32(param_1, 1), 268435455)
			loc_4 = add_i32(loc_3, shl_i32(loc_6, 4))
			loc_0 = loc_4
			param_1 = band_i32(param_1, 3)
			if param_1 ~= 0 then
				loc_0 = loc_4
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 16)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			param_1 = add_i32(loc_4, loc_7)
			if ge_u32(loc_8, 3) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 8)
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, loc_1))
					loc_0 = sub_i32(loc_0, -64)
					if loc_0 ~= param_1 then goto continue_at_12 end
					break
				end
			end
			loc_3 = add_i32(loc_3, shl_i32(loc_5, 4))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_2, loc_0)
			loc_1 = sub_i32(loc_4, param_2)
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, loc_3)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[172](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[172] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstLocal*, unsigned long long>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, unsigned long long> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[173] = --[[ Luau::DenseHashMap<Luau::AstLocal*, unsigned long long, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::find(Luau::AstLocal* const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_3 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		if loc_3 == loc_1 then goto continue_at_1 end
		loc_2 = load_i32(memory_at_0, param_1)
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		if loc_2 == loc_4 then goto continue_at_1 end
		param_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
		loc_1 = sub_i32(shr_i32(sub_i32(loc_1, loc_3), 4), 1)
		param_0 = 0
		::continue_at_2::
		while true do
			loc_5 = band_i32(param_1, loc_1)
			loc_0 = add_i32(loc_3, shl_i32(loc_5, 4))
			param_1 = load_i32(memory_at_0, loc_0)
			if param_1 == loc_2 then goto continue_at_1 end
			loc_0 = 0
			if param_1 == loc_4 then goto continue_at_1 end
			param_0 = add_i32(param_0, 1)
			param_1 = add_i32(param_0, loc_5)
			if le_u32(param_0, loc_1) then goto continue_at_2 end
			break
		end
		::continue_at_1::
		reg_0 = (loc_0 ~= 0 and add_i32(loc_0, 8) or 0)
		return reg_0
	end
FUNC_LIST[174] = --[[ Luau::Compile::Cost::fold(Luau::Compile::Cost const&, Luau::Compile::Cost const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0LL
		local loc_1 = 0LL
		local loc_2 = 0LL
		local reg_0, reg_1
		loc_1 = load_i64(memory_at_0, param_2)
		loc_2 = load_i64(memory_at_0, param_1)
		loc_0 = band_i64(
			load_i64(memory_at_0, param_2 + 8), load_i64(memory_at_0, param_1 + 8)
		)
		store_i64(memory_at_0, param_0 + 8, loc_0)
		reg_1 = (loc_0 == -1LL and 0LL or
			        bor_i64(band_i64(loc_0, 72340172838076672LL ), 1LL ))
		loc_0 = (loc_1 + loc_2)
		loc_1 = band_i64(loc_0, -9187201950435737472LL )
		loc_0 = (reg_1 + bor_i64(
			(loc_1 - shr_u64(loc_1, 7LL )),
				band_i64(loc_0, 9187201950435737471LL )
		))
		loc_1 = band_i64(loc_0, -9187201950435737472LL )
		store_i64(
			memory_at_0, param_0, bor_i64(
				(loc_1 - shr_u64(loc_1, 7LL )),
					band_i64(loc_0, 9187201950435737471LL )
			)
		)
	end
FUNC_LIST[175] = --[[ Luau::Compile::getBuiltin(Luau::AstExpr*, Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> > const&, Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Variable, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> > const&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		loc_6 = load_i32(memory_at_0, param_3 + 4)
		loc_0 = load_i32(memory_at_0, param_3)
		loc_1 = sub_i32(div_i32(sub_i32(loc_6, loc_0), 12), 1)
		loc_3 = load_i32(memory_at_0, param_3 + 16)
		loc_7 = load_i32(memory_at_0, 54940)
		::continue_at_2::
		while true do
			param_3 = load_i32(memory_at_0, param_1 + 4)
			if param_1 == 0 then goto continue_at_1 end
			if param_3 ~= loc_7 then goto continue_at_1 end
			if loc_0 == loc_6 then goto continue_at_3 end
			loc_2 = load_i32(memory_at_0, param_1 + 24)
			if loc_2 == loc_3 then goto continue_at_3 end
			param_3 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
			param_1 = 0
			::continue_at_4::
			while true do
				loc_4 = band_i32(param_3, loc_1)
				loc_5 = add_i32(loc_0, mul_i32(loc_4, 12))
				param_3 = load_i32(memory_at_0, loc_5)
				if loc_2 ~= param_3 then
					if param_3 == loc_3 then goto continue_at_3 end
					param_1 = add_i32(param_1, 1)
					param_3 = add_i32(param_1, loc_4)
					if le_u32(param_1, loc_1) then goto continue_at_4 end
					goto continue_at_3
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_5 + 8) ~= 0 then goto continue_at_3 end
			param_1 = load_i32(memory_at_0, loc_5 + 4)
			if param_1 ~= 0 then goto continue_at_2 end
			::continue_at_3::
			break
		end
		store_i64(memory_at_0, param_0, 0LL )
		goto continue_at_0
		::continue_at_1::
		if param_1 == 0 then goto continue_at_6 end
		if param_3 ~= load_i32(memory_at_0, 54972) then goto continue_at_6 end
		param_3 = load_i32(memory_at_0, param_1 + 24)
		if load_i32(memory_at_0, param_3 + 4) ~= load_i32(memory_at_0, 54948) then
			goto continue_at_7
		end
		if param_3 == 0 then goto continue_at_7 end
		loc_0 = load_i32(memory_at_0, param_3 + 24)
		loc_3 = load_i32(memory_at_0, param_2)
		param_3 = load_i32(memory_at_0, param_2 + 4)
		if loc_3 == param_3 then goto continue_at_9 end
		loc_5 = load_i32(memory_at_0, param_2 + 16)
		if loc_5 == loc_0 then goto continue_at_9 end
		loc_1 = bxor_i32(shr_u32(loc_0, 4), shr_u32(loc_0, 9))
		loc_4 = sub_i32(shr_i32(sub_i32(param_3, loc_3), 3), 1)
		param_3 = 0
		::continue_at_10::
		while true do
			loc_1 = band_i32(loc_1, loc_4)
			loc_2 = load_i32(memory_at_0, add_i32(loc_3, shl_i32(loc_1, 3)))
			if loc_0 ~= loc_2 then
				if loc_2 == loc_5 then goto continue_at_9 end
				param_3 = add_i32(param_3, 1)
				loc_1 = add_i32(param_3, loc_1)
				if le_u32(param_3, loc_4) then goto continue_at_10 end
				goto continue_at_9
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_3, shl_i32(loc_1, 3)) + 4) ~= 0 then
			goto continue_at_8
		end
		::continue_at_9::
		store_i32(memory_at_0, param_0, loc_0)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, param_1 + 28))
		goto continue_at_0
		::continue_at_8::
		store_i64(memory_at_0, param_0, 0LL )
		goto continue_at_0
		::continue_at_7::
		store_i64(memory_at_0, param_0, 0LL )
		goto continue_at_0
		::continue_at_6::
		if param_1 == 0 then goto continue_at_12 end
		if param_3 ~= load_i32(memory_at_0, 54948) then goto continue_at_12 end
		loc_2 = load_i32(memory_at_0, param_1 + 24)
		loc_0 = load_i32(memory_at_0, param_2)
		param_1 = load_i32(memory_at_0, param_2 + 4)
		if loc_0 == param_1 then goto continue_at_14 end
		loc_3 = load_i32(memory_at_0, param_2 + 16)
		if loc_3 == loc_2 then goto continue_at_14 end
		param_3 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
		loc_1 = sub_i32(shr_i32(sub_i32(param_1, loc_0), 3), 1)
		param_1 = 0
		::continue_at_15::
		while true do
			param_3 = band_i32(param_3, loc_1)
			loc_4 = load_i32(memory_at_0, add_i32(loc_0, shl_i32(param_3, 3)))
			if loc_2 ~= loc_4 then
				if loc_3 == loc_4 then goto continue_at_14 end
				param_1 = add_i32(param_1, 1)
				param_3 = add_i32(param_1, param_3)
				if le_u32(param_1, loc_1) then goto continue_at_15 end
				goto continue_at_14
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_0, shl_i32(param_3, 3)) + 4) ~= 0 then
			goto continue_at_13
		end
		::continue_at_14::
		store_i32(memory_at_0, param_0 + 4, loc_2)
		store_i32(memory_at_0, param_0, 0)
		goto continue_at_0
		::continue_at_13::
		store_i64(memory_at_0, param_0, 0LL )
		goto continue_at_0
		::continue_at_12::
		store_i64(memory_at_0, param_0, 0LL )
		::continue_at_0::
	end
FUNC_LIST[176] = --[[ Luau::Compile::getBuiltinFunctionId(Luau::Compile::Builtin const&, Luau::CompileOptions const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0
		loc_2 = -1
		loc_1 = load_i32(memory_at_0, param_0)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if bor_i32(loc_1, loc_0) == 0 then goto continue_at_2 end
		if loc_1 == 0 then
			if loc_0 == 0 then goto continue_at_3 end
			reg_0 = FUNC_LIST[1193](loc_0, 1745)
			if reg_0 == 0 then
				reg_0 = 1
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 5684)
			if reg_0 == 0 then
				reg_0 = 40
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 5010)
			if reg_0 == 0 then
				reg_0 = 44
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 2098)
			if reg_0 == 0 then
				reg_0 = 49
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 2168)
			if reg_0 == 0 then
				reg_0 = 50
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4492)
			if reg_0 == 0 then
				reg_0 = 51
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4560)
			if reg_0 == 0 then
				reg_0 = 53
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 2175)
			if reg_0 ~= 0 then goto continue_at_3 end
			reg_0 = 57
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_1, 4624)
		if reg_0 == 0 then
			if loc_0 == 0 then goto continue_at_3 end
			reg_0 = FUNC_LIST[1193](loc_0, 2799)
			if reg_0 == 0 then
				reg_0 = 2
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 2630)
			if reg_0 == 0 then
				reg_0 = 3
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4214)
			if reg_0 == 0 then
				reg_0 = 4
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 8312)
			if reg_0 == 0 then
				reg_0 = 5
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4316)
			if reg_0 == 0 then
				reg_0 = 6
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4473)
			if reg_0 == 0 then
				reg_0 = 7
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4629)
			if reg_0 == 0 then
				reg_0 = 8
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 2631)
			if reg_0 == 0 then
				reg_0 = 9
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 5006)
			if reg_0 == 0 then
				reg_0 = 10
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 3632)
			if reg_0 == 0 then
				reg_0 = 11
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 3344)
			if reg_0 == 0 then
				reg_0 = 12
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 6962)
			if reg_0 == 0 then
				reg_0 = 13
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 3624)
			if reg_0 == 0 then
				reg_0 = 14
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 3630)
			if reg_0 == 0 then
				reg_0 = 15
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 8365)
			if reg_0 == 0 then
				reg_0 = 16
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4665)
			if reg_0 == 0 then
				reg_0 = 17
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 1324)
			if reg_0 == 0 then
				reg_0 = 18
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4256)
			if reg_0 == 0 then
				reg_0 = 19
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 5048)
			if reg_0 == 0 then
				reg_0 = 20
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 1382)
			if reg_0 == 0 then
				reg_0 = 21
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 7339)
			if reg_0 == 0 then
				reg_0 = 22
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4634)
			if reg_0 == 0 then
				reg_0 = 23
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4215)
			if reg_0 == 0 then
				reg_0 = 24
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 1706)
			if reg_0 == 0 then
				reg_0 = 25
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4639)
			if reg_0 == 0 then
				reg_0 = 26
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4317)
			if reg_0 == 0 then
				reg_0 = 27
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 3735)
			if reg_0 == 0 then
				reg_0 = 46
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 4267)
			if reg_0 == 0 then
				reg_0 = 47
				goto continue_at_0
			end
			reg_0 = FUNC_LIST[1193](loc_0, 6991)
			if reg_0 ~= 0 then goto continue_at_19 end
			reg_0 = 48
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_1, 8318)
		if reg_0 ~= 0 then goto continue_at_16 end
		if loc_0 ~= 0 then goto continue_at_18 end
		goto continue_at_16
		::continue_at_19::
		reg_0 = FUNC_LIST[1193](loc_1, 8318)
		if reg_0 ~= 0 then goto continue_at_17 end
		::continue_at_18::
		reg_0 = FUNC_LIST[1193](loc_0, 2083)
		if reg_0 == 0 then
			reg_0 = 28
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 7006)
		if reg_0 == 0 then
			reg_0 = 29
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 1789)
		if reg_0 == 0 then
			reg_0 = 30
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 3354)
		if reg_0 == 0 then
			reg_0 = 31
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 3326)
		if reg_0 == 0 then
			reg_0 = 32
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 1694)
		if reg_0 == 0 then
			reg_0 = 33
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 2234)
		if reg_0 == 0 then
			reg_0 = 34
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 5464)
		if reg_0 == 0 then
			reg_0 = 35
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 2091)
		if reg_0 == 0 then
			reg_0 = 36
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 6954)
		if reg_0 == 0 then
			reg_0 = 37
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 5456)
		if reg_0 == 0 then
			reg_0 = 38
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 2084)
		if reg_0 == 0 then
			reg_0 = 39
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 1032)
		if reg_0 == 0 then
			reg_0 = 55
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 1024)
		if reg_0 ~= 0 then goto continue_at_16 end
		reg_0 = 56
		goto continue_at_0
		::continue_at_17::
		reg_0 = FUNC_LIST[1193](loc_1, 4913)
		if reg_0 == 0 then goto continue_at_15 end
		goto continue_at_14
		::continue_at_16::
		reg_0 = FUNC_LIST[1193](loc_1, 4913)
		if reg_0 ~= 0 then goto continue_at_14 end
		if loc_0 == 0 then goto continue_at_3 end
		::continue_at_15::
		reg_0 = FUNC_LIST[1193](loc_0, 5451)
		if reg_0 == 0 then
			reg_0 = 41
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 3600)
		if reg_0 == 0 then
			reg_0 = 42
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 4307)
		if reg_0 == 0 then
			reg_0 = 43
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 7737)
		if reg_0 ~= 0 then goto continue_at_13 end
		reg_0 = 45
		goto continue_at_0
		::continue_at_14::
		reg_0 = FUNC_LIST[1193](loc_1, 6559)
		if reg_0 ~= 0 then goto continue_at_3 end
		if loc_0 ~= 0 then goto continue_at_12 end
		goto continue_at_3
		::continue_at_13::
		reg_0 = FUNC_LIST[1193](loc_1, 6559)
		if reg_0 ~= 0 then goto continue_at_3 end
		::continue_at_12::
		reg_0 = FUNC_LIST[1193](loc_0, 1752)
		if reg_0 == 0 then
			reg_0 = 52
			goto continue_at_0
		end
		reg_0 = FUNC_LIST[1193](loc_0, 4560)
		if reg_0 ~= 0 then goto continue_at_3 end
		reg_0 = 53
		goto continue_at_0
		::continue_at_3::
		loc_3 = load_i32(memory_at_0, param_1 + 16)
		if loc_3 == 0 then goto continue_at_1 end
		param_1 = load_i32(memory_at_0, param_1 + 12)
		if param_1 ~= 0 then
			loc_2 = 54
			reg_0 = FUNC_LIST[177](param_0, param_1, loc_3)
			if reg_0 == 0 then goto continue_at_1 end
			goto continue_at_2
		end
		if loc_1 ~= 0 then goto continue_at_1 end
		if loc_0 == 0 then goto continue_at_1 end
		reg_0 = FUNC_LIST[1193](loc_0, loc_3)
		if reg_0 ~= 0 then goto continue_at_1 end
		loc_2 = 54
		::continue_at_2::
		reg_0 = loc_2
		goto continue_at_0
		::continue_at_1::
		reg_0 = -1
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[177] = --[[ Luau::Compile::Builtin::isMethod(char const*, char const*) const ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_1 == 0 then goto continue_at_1 end
		reg_0 = FUNC_LIST[1193](loc_1, param_1)
		if reg_0 ~= 0 then goto continue_at_1 end
		param_0 = load_i32(memory_at_0, param_0 + 4)
		if param_0 == 0 then goto continue_at_1 end
		reg_0 = FUNC_LIST[1193](param_0, param_2)
		loc_0 = (reg_0 == 0 and 1 or 0)
		::continue_at_1::
		reg_0 = loc_0
		return reg_0
	end
FUNC_LIST[178] = --[[ __cxx_global_var_init ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54904), 1) == 0 then
		store_i32_n8(memory_at_0, 54904, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54900, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[179] = --[[ __cxx_global_var_init.1 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54912), 1) == 0 then
		store_i32_n8(memory_at_0, 54912, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54908, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[180] = --[[ __cxx_global_var_init.2 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54920), 1) == 0 then
		store_i32_n8(memory_at_0, 54920, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54916, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[181] = --[[ __cxx_global_var_init.3 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54928), 1) == 0 then
		store_i32_n8(memory_at_0, 54928, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54924, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[182] = --[[ __cxx_global_var_init.4 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54936), 1) == 0 then
		store_i32_n8(memory_at_0, 54936, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54932, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[183] = --[[ __cxx_global_var_init.5 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54944), 1) == 0 then
		store_i32_n8(memory_at_0, 54944, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54940, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[184] = --[[ __cxx_global_var_init.6 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54952), 1) == 0 then
		store_i32_n8(memory_at_0, 54952, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54948, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[185] = --[[ __cxx_global_var_init.7 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54960), 1) == 0 then
		store_i32_n8(memory_at_0, 54960, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54956, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[186] = --[[ __cxx_global_var_init.8 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54968), 1) == 0 then
		store_i32_n8(memory_at_0, 54968, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54964, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[187] = --[[ __cxx_global_var_init.9 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54976), 1) == 0 then
		store_i32_n8(memory_at_0, 54976, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54972, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[188] = --[[ __cxx_global_var_init.10 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54984), 1) == 0 then
		store_i32_n8(memory_at_0, 54984, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54980, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[189] = --[[ __cxx_global_var_init.11 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 54992), 1) == 0 then
		store_i32_n8(memory_at_0, 54992, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54988, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[190] = --[[ __cxx_global_var_init.12 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55000), 1) == 0 then
		store_i32_n8(memory_at_0, 55000, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 54996, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[191] = --[[ __cxx_global_var_init.13 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55008), 1) == 0 then
		store_i32_n8(memory_at_0, 55008, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55004, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[192] = --[[ __cxx_global_var_init.14 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55016), 1) == 0 then
		store_i32_n8(memory_at_0, 55016, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55012, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[193] = --[[ __cxx_global_var_init.15 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55024), 1) == 0 then
		store_i32_n8(memory_at_0, 55024, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55020, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[194] = --[[ __cxx_global_var_init.16 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55032), 1) == 0 then
		store_i32_n8(memory_at_0, 55032, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55028, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[195] = --[[ __cxx_global_var_init.17 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55040), 1) == 0 then
		store_i32_n8(memory_at_0, 55040, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55036, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[196] = --[[ __cxx_global_var_init.18 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55048), 1) == 0 then
		store_i32_n8(memory_at_0, 55048, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55044, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[197] = --[[ __cxx_global_var_init.19 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55056), 1) == 0 then
		store_i32_n8(memory_at_0, 55056, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55052, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[198] = --[[ __cxx_global_var_init.20 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55064), 1) == 0 then
		store_i32_n8(memory_at_0, 55064, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55060, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[199] = --[[ __cxx_global_var_init.21 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55072), 1) == 0 then
		store_i32_n8(memory_at_0, 55072, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55068, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[200] = --[[ __cxx_global_var_init.22 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55080), 1) == 0 then
		store_i32_n8(memory_at_0, 55080, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55076, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[201] = --[[ __cxx_global_var_init.23 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55088), 1) == 0 then
		store_i32_n8(memory_at_0, 55088, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55084, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[202] = --[[ __cxx_global_var_init.24 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55096), 1) == 0 then
		store_i32_n8(memory_at_0, 55096, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55092, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[203] = --[[ __cxx_global_var_init.25 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55104), 1) == 0 then
		store_i32_n8(memory_at_0, 55104, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55100, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[204] = --[[ __cxx_global_var_init.26 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55112), 1) == 0 then
		store_i32_n8(memory_at_0, 55112, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55108, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[205] = --[[ __cxx_global_var_init.27 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55120), 1) == 0 then
		store_i32_n8(memory_at_0, 55120, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55116, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[206] = --[[ __cxx_global_var_init.28 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55128), 1) == 0 then
		store_i32_n8(memory_at_0, 55128, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55124, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[207] = --[[ __cxx_global_var_init.29 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55136), 1) == 0 then
		store_i32_n8(memory_at_0, 55136, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55132, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[208] = --[[ __cxx_global_var_init.30 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55144), 1) == 0 then
		store_i32_n8(memory_at_0, 55144, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55140, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[209] = --[[ __cxx_global_var_init.31 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55152), 1) == 0 then
		store_i32_n8(memory_at_0, 55152, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55148, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[210] = --[[ __cxx_global_var_init.32 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55160), 1) == 0 then
		store_i32_n8(memory_at_0, 55160, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55156, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[211] = --[[ __cxx_global_var_init.33 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55168), 1) == 0 then
		store_i32_n8(memory_at_0, 55168, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55164, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[212] = --[[ __cxx_global_var_init.34 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55176), 1) == 0 then
		store_i32_n8(memory_at_0, 55176, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55172, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[213] = --[[ __cxx_global_var_init.35 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55184), 1) == 0 then
		store_i32_n8(memory_at_0, 55184, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55180, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[214] = --[[ __cxx_global_var_init.36 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55192), 1) == 0 then
		store_i32_n8(memory_at_0, 55192, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55188, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[215] = --[[ __cxx_global_var_init.37 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55200), 1) == 0 then
		store_i32_n8(memory_at_0, 55200, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55196, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[216] = --[[ __cxx_global_var_init.38 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55208), 1) == 0 then
		store_i32_n8(memory_at_0, 55208, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55204, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[217] = --[[ __cxx_global_var_init.39 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55216), 1) == 0 then
		store_i32_n8(memory_at_0, 55216, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55212, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[218] = --[[ __cxx_global_var_init.40 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55224), 1) == 0 then
		store_i32_n8(memory_at_0, 55224, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55220, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[219] = --[[ __cxx_global_var_init.41 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55232), 1) == 0 then
		store_i32_n8(memory_at_0, 55232, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55228, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[220] = --[[ __cxx_global_var_init.42 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55240), 1) == 0 then
		store_i32_n8(memory_at_0, 55240, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55236, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[221] = --[[ __cxx_global_var_init.43 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55248), 1) == 0 then
		store_i32_n8(memory_at_0, 55248, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55244, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[222] = --[[ __cxx_global_var_init.44 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55256), 1) == 0 then
		store_i32_n8(memory_at_0, 55256, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55252, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[223] = --[[ __cxx_global_var_init.45 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55264), 1) == 0 then
		store_i32_n8(memory_at_0, 55264, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55260, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[224] = --[[ __cxx_global_var_init.46 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55272), 1) == 0 then
		store_i32_n8(memory_at_0, 55272, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55268, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[225] = --[[ __cxx_global_var_init.47 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55280), 1) == 0 then
		store_i32_n8(memory_at_0, 55280, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55276, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[226] = --[[ __cxx_global_var_init.48 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55288), 1) == 0 then
		store_i32_n8(memory_at_0, 55288, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55284, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[227] = --[[ __cxx_global_var_init.49 ]] function()
	local loc_0 = 0
	if band_i32(load_i32_u8(memory_at_0, 55296), 1) == 0 then
		store_i32_n8(memory_at_0, 55296, 1)
		loc_0 = add_i32(load_i32(memory_at_0, 60164), 1)
		store_i32(memory_at_0, 55292, loc_0)
		store_i32(memory_at_0, 60164, loc_0)
	end
end
FUNC_LIST[228] = --[[ Luau::CompileError::CompileError(Luau::Location const&, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > const&) ]]
	function(param_0, param_1, param_2)
		local reg_0
		store_i32(memory_at_0, param_0, 11704)
		store_i64(memory_at_0, param_0 + 12, load_i64(memory_at_0, param_1 + 8))
		store_i64(memory_at_0, param_0 + 4, load_i64(memory_at_0, param_1))
		param_1 = add_i32(param_0, 20)
		if load_i32_i8(memory_at_0, param_2 + 11) >= 0 then
			store_i64(memory_at_0, param_1, load_i64(memory_at_0, param_2))
			store_i32(memory_at_0, param_1 + 8, load_i32(memory_at_0, param_2 + 8))
			reg_0 = param_0
			goto continue_at_0
		end
		FUNC_LIST[1345](
			param_1, load_i32(memory_at_0, param_2), load_i32(memory_at_0, param_2 + 4)
		)
		reg_0 = param_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[229] = --[[ Luau::CompileError::~CompileError() ]] function(param_0)
	local reg_0
	store_i32(memory_at_0, param_0, 11704)
	if load_i32_i8(memory_at_0, param_0 + 31) < 0 then
		FUNC_LIST[1276](load_i32(memory_at_0, param_0 + 20))
	end
	reg_0 = FUNC_LIST[1416](param_0)
	return reg_0
end
FUNC_LIST[230] = --[[ Luau::CompileError::~CompileError().1 ]] function(param_0)
	local reg_0
	reg_0 = FUNC_LIST[229](param_0)
	FUNC_LIST[1276](param_0)
end
FUNC_LIST[231] = --[[ Luau::CompileError::what() const ]] function(param_0)
	local reg_0
	reg_0 = (load_i32_i8(memory_at_0, param_0 + 31) < 0 and
		        load_i32(memory_at_0, param_0 + 20) or add_i32(param_0, 20))
	return reg_0
end
FUNC_LIST[232] = --[[ Luau::CompileError::raise(Luau::Location const&, char const*, ...) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		store_i32(memory_at_0, loc_0 + 12, param_2)
		FUNC_LIST[1100](loc_0, param_1, param_2)
		reg_0 = FUNC_LIST[12](32)
		param_2 = reg_0
		reg_0 = FUNC_LIST[228](param_2, param_0, loc_0)
		FUNC_LIST[13](param_2, 11740, 109)
		error("out of code bounds")
	end
FUNC_LIST[233] = --[[ Luau::compileOrThrow(Luau::BytecodeBuilder&, Luau::AstStatBlock*, Luau::AstNameTable const&, Luau::CompileOptions const&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0LL
		local loc_3 = 0
		local reg_0, reg_1, reg_2
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 608)
		GLOBAL_LIST[0].value = loc_0
		store_i32(memory_at_0, loc_0 + 328, param_0)
		store_i64(memory_at_0, loc_0 + 340, load_i64(memory_at_0, param_3 + 8))
		store_i64(memory_at_0, loc_0 + 348, load_i64(memory_at_0, param_3 + 16))
		loc_2 = load_i64(memory_at_0, param_3)
		store_i64(memory_at_0, loc_0 + 364, 0LL )
		store_i32(memory_at_0, loc_0 + 372, 0)
		store_i64(memory_at_0, loc_0 + 388, 0LL )
		store_i32(memory_at_0, loc_0 + 396, 0)
		store_i64(memory_at_0, loc_0 + 412, 0LL )
		store_i32(memory_at_0, loc_0 + 420, 0)
		store_i64(memory_at_0, loc_0 + 436, 0LL )
		store_i32(memory_at_0, loc_0 + 444, 0)
		store_i32(memory_at_0, loc_0 + 468, 0)
		store_i64(memory_at_0, loc_0 + 460, 0LL )
		store_i64(memory_at_0, loc_0 + 332, loc_2)
		store_i64(memory_at_0, loc_0 + 356, 0LL )
		store_i64(memory_at_0, loc_0 + 380, 0LL )
		store_i64(memory_at_0, loc_0 + 404, 0LL )
		store_i64(memory_at_0, loc_0 + 428, 0LL )
		store_i64(memory_at_0, loc_0 + 452, 0LL )
		store_i32(memory_at_0, loc_0 + 492, 0)
		store_i64(memory_at_0, loc_0 + 484, 0LL )
		store_i64(memory_at_0, loc_0 + 508, 0LL )
		store_i32(memory_at_0, loc_0 + 516, 0)
		store_i32_n16(memory_at_0, loc_0 + 532, 0)
		store_i64(memory_at_0, loc_0 + 560, 0LL )
		store_i64(memory_at_0, loc_0 + 568, 0LL )
		store_i64(memory_at_0, loc_0 + 576, 0LL )
		store_i64(memory_at_0, loc_0 + 584, 0LL )
		store_i64(memory_at_0, loc_0 + 592, 0LL )
		store_i64(memory_at_0, loc_0 + 600, 0LL )
		store_i64(memory_at_0, loc_0 + 476, 0LL )
		store_i64(memory_at_0, loc_0 + 500, 0LL )
		store_i64(memory_at_0, loc_0 + 524, 0LL )
		reg_1 = FUNC_LIST[1275](64)
		loc_1 = reg_1
		store_i32(memory_at_0, loc_0 + 540, loc_1)
		store_i32(memory_at_0, loc_0 + 544, sub_i32(loc_1, -64))
		store_i32(memory_at_0, loc_0 + 536, loc_1)
		reg_1 = FUNC_LIST[1275](64)
		loc_1 = reg_1
		store_i32(memory_at_0, loc_0 + 552, loc_1)
		store_i32(memory_at_0, loc_0 + 556, sub_i32(loc_1, -64))
		store_i32(memory_at_0, loc_0 + 548, loc_1)
		loc_1 = add_i32(loc_0, 404)
		FUNC_LIST[39](loc_1, param_2, load_i32(memory_at_0, param_3 + 20))
		loc_3 = add_i32(loc_0, 428)
		FUNC_LIST[41](loc_1, loc_3, param_1)
		if load_i32(memory_at_0, param_3) <= 0 then goto continue_at_1 end
		FUNC_LIST[54](add_i32(loc_0, 452), loc_3, add_i32(loc_0, 476), param_1)
		FUNC_LIST[67](add_i32(loc_0, 500), param_1)
		if load_i32(memory_at_0, param_3) <= 0 then goto continue_at_1 end
		reg_0 = FUNC_LIST[973](param_2, 1521)
		if reg_0 == 0 then
			reg_0 = FUNC_LIST[973](param_2, 1513)
			if reg_0 == 0 then goto continue_at_1 end
		end
		store_i32(memory_at_0, loc_0 + 176, add_i32(loc_0, 533))
		store_i32(memory_at_0, loc_0 + 172, add_i32(loc_0, 532))
		store_i32(memory_at_0, loc_0 + 168, 11760)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, add_i32(loc_0, 168)
		)
		::continue_at_1::
		store_i32(memory_at_0, loc_0 + 296, 12068)
		store_i32(memory_at_0, loc_0 + 304, add_i32(loc_0, 312))
		store_i32(memory_at_0, loc_0 + 300, add_i32(loc_0, 328))
		reg_1 = FUNC_LIST[1275](64)
		param_3 = reg_1
		store_i32(memory_at_0, loc_0 + 316, param_3)
		store_i32(memory_at_0, loc_0 + 312, param_3)
		store_i32(memory_at_0, loc_0 + 320, sub_i32(param_3, -64))
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
			param_1, add_i32(loc_0, 296)
		)
		param_3 = load_i32(memory_at_0, loc_0 + 312)
		loc_1 = load_i32(memory_at_0, loc_0 + 316)
		if param_3 ~= loc_1 then
			::continue_at_4::
			while true do
				reg_0 = FUNC_LIST[234](add_i32(loc_0, 328), load_i32(memory_at_0, param_3))
				param_3 = add_i32(param_3, 4)
				if param_3 ~= loc_1 then goto continue_at_4 end
				break
			end
		end
		param_3 = add_i32(loc_0, 136)
		store_i32_n8(memory_at_0, param_3, 1)
		store_i64(memory_at_0, loc_0 + 128, 0LL )
		loc_1 = add_i32(loc_0, 88)
		store_i32_n8(memory_at_0, loc_1, 0)
		store_i64(memory_at_0, loc_0 + 56, 0LL )
		store_i32(memory_at_0, sub_i32(loc_0, -64), load_i32(memory_at_0, param_3))
		store_i64(memory_at_0, loc_0 + 160, 0LL )
		store_i64(memory_at_0, loc_0 + 152, 0LL )
		store_i64(memory_at_0, loc_0 + 120, 0LL )
		store_i64(memory_at_0, loc_0 + 144, 0LL )
		store_i32_n8(memory_at_0, loc_0 + 108, 0)
		store_i32_n8(memory_at_0, loc_0 + 96, 0)
		store_i32_n8(memory_at_0, loc_0 + 72, 0)
		store_i64(memory_at_0, loc_0 + 48, 0LL )
		store_i32(memory_at_0, loc_0 + 112, 0)
		store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_0 + 104))
		store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, loc_0 + 96))
		store_i32(memory_at_0, loc_0 + 24, load_i32(memory_at_0, loc_1))
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_0 + 80))
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_0 + 72))
		reg_2 = FUNC_LIST[870](
			add_i32(loc_0, 168), add_i32(param_1, 8), add_i32(loc_0, 160),
				add_i32(loc_0, 152), 0, add_i32(loc_0, 144), add_i32(loc_0, 48), param_1, 0,
				add_i32(loc_0, 112), add_i32(loc_0, 32), 0, 0, add_i32(loc_0, 8)
		)
		reg_1 = FUNC_LIST[234](add_i32(loc_0, 328), reg_2)
		FUNC_LIST[93](param_0, reg_1)
		FUNC_LIST[132](param_0)
		param_3 = load_i32(memory_at_0, loc_0 + 312)
		if param_3 ~= 0 then
			store_i32(memory_at_0, loc_0 + 316, param_3)
			FUNC_LIST[1276](param_3)
		end
		reg_0 = FUNC_LIST[235](add_i32(loc_0, 328))
		GLOBAL_LIST[0].value = add_i32(loc_0, 608)
	end
FUNC_LIST[234] = --[[ Luau::Compiler::compileFunction(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local reg_0, reg_1
		loc_1 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_1
		loc_11 = load_i32(memory_at_0, param_0 + 196)
		loc_3 = (load_i32(memory_at_0, param_1 + 40) ~= 0 and 1 or 0)
		reg_0 = FUNC_LIST[87](
			load_i32(memory_at_0, param_0),
				band_i32(add_i32(loc_3, load_i32(memory_at_0, param_1 + 48)), 255),
				load_i32_u8(memory_at_0, param_1 + 68)
		)
		loc_9 = reg_0
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
		end
		if load_i32_u8(memory_at_0, param_1 + 68) ~= 0 then
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 65,
					band_i32(add_i32(load_i32(memory_at_0, param_1 + 48), loc_3), 255), 0, 0
			)
		end
		loc_4 = load_i32(memory_at_0, param_0 + 196)
		loc_2 = load_i32(memory_at_0, param_1 + 48)
		loc_6 = add_i32(loc_2, loc_3)
		loc_0 = add_i32(loc_4, loc_6)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_6 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_6) and loc_6 or loc_0)
			)
			loc_0 = load_i32(memory_at_0, param_1 + 40)
			if loc_0 ~= 0 then
				FUNC_LIST[237](param_0, loc_0, band_i32(loc_4, 255))
				loc_2 = load_i32(memory_at_0, param_1 + 48)
			end
			if loc_2 ~= 0 then
				loc_3 = add_i32(loc_3, loc_4)
				loc_0 = 0
				::continue_at_6::
				while true do
					FUNC_LIST[237](
						param_0, load_i32(
							memory_at_0,
								add_i32(load_i32(memory_at_0, param_1 + 44), shl_i32(loc_0, 2))
						), band_i32(add_i32(loc_0, loc_3), 255)
					)
					loc_0 = add_i32(loc_0, 1)
					if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 48)) then
						goto continue_at_6
					end
					break
				end
			end
			loc_3 = load_i32(memory_at_0, param_1 + 92)
			if load_i32(memory_at_0, loc_3 + 32) ~= 0 then
				loc_0 = 0
				::continue_at_8::
				while true do
					FUNC_LIST[238](
						param_0, load_i32(
							memory_at_0,
								add_i32(load_i32(memory_at_0, loc_3 + 28), shl_i32(loc_0, 2))
						)
					)
					loc_0 = add_i32(loc_0, 1)
					if lt_u32(loc_0, load_i32(memory_at_0, loc_3 + 32)) then
						goto continue_at_8
					end
					break
				end
			end
			reg_0 = FUNC_LIST[239](param_0, loc_3)
			if reg_0 == 0 then
				if load_i32(memory_at_0, param_0 + 8) > 0 then
					FUNC_LIST[124](
						load_i32(memory_at_0, param_0),
							add_i32(load_i32(memory_at_0, loc_3 + 16), 1)
					)
				end
				FUNC_LIST[240](param_0, 0)
				FUNC_LIST[114](load_i32(memory_at_0, param_0), 22, 0, 1, 0)
			end
			if load_i32(memory_at_0, param_0 + 4) <= 0 then goto continue_at_11 end
			if load_i32(memory_at_0, param_0 + 8) < 2 then goto continue_at_11 end
			store_i32(memory_at_0, loc_1 + 56, 0)
			store_i64(memory_at_0, loc_1 + 48, 0LL )
			store_i32(memory_at_0, loc_1 + 44, param_0)
			loc_4 = 12640
			store_i32(memory_at_0, loc_1 + 40, loc_4)
			loc_0 = load_i32(memory_at_0, param_1 + 92)
			TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_0))](
				loc_0, add_i32(loc_1, 40)
			)
			loc_0 = load_i32(memory_at_0, loc_1 + 48)
			loc_2 = load_i32(memory_at_0, loc_1 + 52)
			if loc_0 ~= loc_2 then
				::continue_at_13::
				while true do
					reg_0 = FUNC_LIST[241](param_0, load_i32(memory_at_0, loc_0))
					loc_0 = add_i32(loc_0, 4)
					if loc_0 ~= loc_2 then goto continue_at_13 end
					break
				end
				loc_0 = load_i32(memory_at_0, loc_1 + 48)
			end
			store_i32(memory_at_0, loc_1 + 40, loc_4)
			if loc_0 == 0 then goto continue_at_11 end
			store_i32(memory_at_0, loc_1 + 52, loc_0)
			FUNC_LIST[1276](loc_0)
			::continue_at_11::
			FUNC_LIST[123](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			if loc_0 <= 0 then goto continue_at_14 end
			loc_2 = load_i32(memory_at_0, param_1 + 100)
			if loc_2 ~= 0 then
				loc_0 = load_i32(memory_at_0, param_0)
				store_i32(memory_at_0, loc_1 + 32, loc_2)
				reg_1 = FUNC_LIST[1197](loc_2)
				store_i32(memory_at_0, loc_1 + 36, reg_1)
				store_i64(memory_at_0, loc_1 + 16, load_i64(memory_at_0, loc_1 + 32))
				FUNC_LIST[122](loc_0, add_i32(loc_1, 16))
				loc_0 = load_i32(memory_at_0, param_0 + 8)
			end
			if loc_0 < 2 then goto continue_at_14 end
			loc_0 = load_i32(memory_at_0, param_0 + 220)
			loc_6 = load_i32(memory_at_0, param_0 + 224)
			if loc_0 == loc_6 then goto continue_at_14 end
			::continue_at_16::
			while true do
				loc_2 = load_i32(memory_at_0, param_0)
				loc_4 = load_i32(memory_at_0, load_i32(memory_at_0, loc_0))
				store_i32(memory_at_0, loc_1 + 24, loc_4)
				reg_1 = FUNC_LIST[1197](loc_4)
				store_i32(memory_at_0, loc_1 + 28, reg_1)
				store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, loc_1 + 24))
				FUNC_LIST[127](loc_2, add_i32(loc_1, 8))
				loc_0 = add_i32(loc_0, 4)
				if loc_0 ~= loc_6 then goto continue_at_16 end
				break
			end
			::continue_at_14::
			if load_i32(memory_at_0, param_0 + 4) > 0 then
				FUNC_LIST[140](load_i32(memory_at_0, param_0))
			end
			FUNC_LIST[141](load_i32(memory_at_0, param_0))
			loc_0 = 0
			FUNC_LIST[242](param_0, 0)
			FUNC_LIST[89](
				load_i32(memory_at_0, param_0), load_i32_u8(memory_at_0, param_0 + 200),
					band_i32(
						shr_u32(
							sub_i32(
								load_i32(memory_at_0, param_0 + 224),
									load_i32(memory_at_0, param_0 + 220)
							), 2
						), 255
					)
			)
			loc_7 = add_i32(param_0, 28)
			loc_8 = add_i32(param_0, 220)
			loc_2 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
			loc_10 = load_i32(memory_at_0, param_0 + 28)
			loc_4 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 32), loc_10), 40)
			if ge_u32(load_i32(memory_at_0, param_0 + 40), shr_u32(mul_i32(loc_4, 3), 2)) then
				FUNC_LIST[243](loc_7)
				loc_10 = load_i32(memory_at_0, loc_7)
				loc_4 = div_i32(sub_i32(load_i32(memory_at_0, loc_7 + 4), loc_10), 40)
			end
			loc_4 = sub_i32(loc_4, 1)
			loc_12 = load_i32(memory_at_0, loc_7 + 16)
			::continue_at_20::
			while true do
				loc_6 = band_i32(loc_2, loc_4)
				loc_5 = add_i32(loc_10, mul_i32(loc_6, 40))
				loc_2 = load_i32(memory_at_0, loc_5)
				if loc_12 == loc_2 then
					store_i32(memory_at_0, loc_5, param_1)
					store_i32(
						memory_at_0, loc_7 + 12, add_i32(load_i32(memory_at_0, loc_7 + 12), 1)
					)
					goto continue_at_19
				end
				if param_1 == loc_2 then goto continue_at_19 end
				loc_0 = add_i32(loc_0, 1)
				loc_2 = add_i32(loc_0, loc_6)
				if le_u32(loc_0, loc_4) then goto continue_at_20 end
				break
			end
			loc_5 = 0
			::continue_at_19::
			store_i32(memory_at_0, loc_5 + 8, loc_9)
			loc_0 = add_i32(loc_5, 12)
			if loc_8 ~= loc_0 then
				FUNC_LIST[244](
					loc_0, load_i32(memory_at_0, loc_8), load_i32(memory_at_0, loc_8 + 4)
				)
			end
			if load_i32(memory_at_0, param_0 + 4) < 2 then goto continue_at_23 end
			if load_i32_u8(memory_at_0, param_1 + 68) ~= 0 then goto continue_at_23 end
			if load_i32_u8(memory_at_0, param_0 + 204) ~= 0 then goto continue_at_23 end
			if load_i32_u8(memory_at_0, param_0 + 205) ~= 0 then goto continue_at_23 end
			store_i32_n8(memory_at_0, loc_5 + 36, 1)
			store_i32(memory_at_0, loc_5 + 32, load_i32(memory_at_0, param_0 + 200))
			reg_1 = FUNC_LIST[155](
				load_i32(memory_at_0, param_1 + 92), load_i32(memory_at_0, param_1 + 44),
					load_i32(memory_at_0, param_1 + 48)
			)
			store_i64(memory_at_0, loc_5 + 24, reg_1)
			reg_0 = FUNC_LIST[239](param_0, load_i32(memory_at_0, param_1 + 92))
			if reg_0 == 0 then goto continue_at_23 end
			store_i32_n8(memory_at_0, loc_1 + 48, 1)
			store_i32(memory_at_0, loc_1 + 44, param_0)
			store_i32(memory_at_0, loc_1 + 40, 12928)
			TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_3))](
				loc_3, add_i32(loc_1, 40)
			)
			store_i32_n8(memory_at_0, loc_5 + 37, load_i32_u8(memory_at_0, loc_1 + 48))
			::continue_at_23::
			store_i32(memory_at_0, param_0 + 200, 0)
			store_i32(memory_at_0, param_0 + 196, loc_11)
			store_i32(memory_at_0, param_0 + 224, load_i32(memory_at_0, param_0 + 220))
			GLOBAL_LIST[0].value = sub_i32(loc_1, -64)
			reg_0 = loc_9
			goto continue_at_0
		end
		store_i32(memory_at_0, loc_1 + 4, 255)
		store_i32(memory_at_0, loc_1, loc_6)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_1)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[235] = --[[ Luau::Compiler::~Compiler() ]] function(param_0)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 268)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 272, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_2 = load_i32(memory_at_0, param_0 + 256)
	if loc_2 ~= 0 then
		loc_1 = loc_2
		loc_0 = load_i32(memory_at_0, param_0 + 260)
		if loc_2 ~= loc_0 then
			::continue_at_4::
			while true do
				loc_1 = sub_i32(loc_0, 24)
				loc_3 = sub_i32(loc_0, 12)
				loc_0 = load_i32(memory_at_0, loc_3)
				if loc_0 ~= 0 then
					store_i32(memory_at_0, loc_3 + 4, loc_0)
					FUNC_LIST[1276](loc_0)
				end
				loc_0 = loc_1
				if loc_0 ~= loc_2 then goto continue_at_4 end
				break
			end
			loc_1 = load_i32(memory_at_0, param_0 + 256)
		end
		store_i32(memory_at_0, param_0 + 260, loc_2)
		FUNC_LIST[1276](loc_1)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 244)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 248, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 232)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 236, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 220)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 224, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 208)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 212, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 172)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 176, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 148)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 152, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 124)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 128, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 100)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 104, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 76)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 80, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 52)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 56, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_2 = load_i32(memory_at_0, param_0 + 28)
	if loc_2 ~= 0 then
		loc_1 = loc_2
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_2 ~= loc_0 then
			::continue_at_18::
			while true do
				loc_1 = sub_i32(loc_0, 40)
				loc_3 = sub_i32(loc_0, 28)
				loc_0 = load_i32(memory_at_0, loc_3)
				if loc_0 ~= 0 then
					store_i32(memory_at_0, loc_3 + 4, loc_0)
					FUNC_LIST[1276](loc_0)
				end
				loc_0 = loc_1
				if loc_0 ~= loc_2 then goto continue_at_18 end
				break
			end
			loc_1 = load_i32(memory_at_0, param_0 + 28)
		end
		store_i32(memory_at_0, param_0 + 32, loc_2)
		FUNC_LIST[1276](loc_1)
	end
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[236] = --[[ Luau::AstVisitor::~AstVisitor() ]] function(param_0)
	local reg_0
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[237] = --[[ Luau::Compiler::pushLocal(Luau::AstLocal*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0, reg_1
		loc_7 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_7
		loc_0 = load_i32(memory_at_0, param_0 + 212)
		loc_2 = load_i32(memory_at_0, param_0 + 208)
		loc_5 = sub_i32(loc_0, loc_2)
		if lt_u32(loc_5, 797) then
			if load_i32(memory_at_0, param_0 + 216) ~= loc_0 then
				store_i32(memory_at_0, loc_0, param_1)
				store_i32(memory_at_0, param_0 + 212, add_i32(loc_0, 4))
				goto continue_at_3
			end
			loc_3 = shr_u32(loc_5, 1)
			loc_4 = shr_i32(loc_5, 2)
			loc_1 = add_i32(loc_4, 1)
			loc_3 = (lt_u32(loc_1, loc_3) and loc_3 or loc_1)
			if ge_u32(loc_3, 1073741824) then goto continue_at_1 end
			loc_1 = shl_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1275](loc_1)
			loc_3 = reg_0
			loc_4 = add_i32(loc_3, shl_i32(loc_4, 2))
			store_i32(memory_at_0, loc_4, param_1)
			loc_1 = add_i32(loc_1, loc_3)
			loc_4 = add_i32(loc_4, 4)
			if loc_0 ~= loc_2 then reg_0 = FUNC_LIST[1119](loc_3, loc_2, loc_5) end
			store_i32(memory_at_0, param_0 + 216, loc_1)
			store_i32(memory_at_0, param_0 + 212, loc_4)
			store_i32(memory_at_0, param_0 + 208, loc_3)
			if loc_2 == 0 then goto continue_at_3 end
			FUNC_LIST[1276](loc_2)
			::continue_at_3::
			loc_6 = add_i32(param_0, 52)
			loc_2 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
			loc_4 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 56), loc_4), 12)
			if ge_u32(
				load_i32(memory_at_0, sub_i32(param_0, -64)), shr_u32(mul_i32(loc_0, 3), 2)
			) then
				FUNC_LIST[321](loc_6)
				loc_4 = load_i32(memory_at_0, loc_6)
				loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_6 + 4), loc_4), 12)
			end
			loc_5 = sub_i32(loc_0, 1)
			loc_8 = load_i32(memory_at_0, loc_6 + 16)
			loc_0 = 0
			::continue_at_8::
			while true do
				loc_3 = band_i32(loc_2, loc_5)
				loc_1 = add_i32(loc_4, mul_i32(loc_3, 12))
				loc_2 = load_i32(memory_at_0, loc_1)
				if loc_8 == loc_2 then
					store_i32(memory_at_0, loc_1, param_1)
					store_i32(
						memory_at_0, loc_6 + 12, add_i32(load_i32(memory_at_0, loc_6 + 12), 1)
					)
					goto continue_at_7
				end
				if param_1 == loc_2 then goto continue_at_7 end
				loc_0 = add_i32(loc_0, 1)
				loc_2 = add_i32(loc_0, loc_3)
				if le_u32(loc_0, loc_5) then goto continue_at_8 end
				break
			end
			loc_1 = 0
			::continue_at_7::
			store_i32_n8(memory_at_0, loc_1 + 4, param_2)
			store_i32_n8(memory_at_0, loc_1 + 5, 1)
			reg_1 = FUNC_LIST[129](load_i32(memory_at_0, param_0))
			store_i32(memory_at_0, loc_1 + 8, reg_1)
			GLOBAL_LIST[0].value = add_i32(loc_7, 16)
			goto continue_at_0
		end
		loc_0 = load_i32(memory_at_0, param_1)
		store_i32(memory_at_0, loc_7 + 4, 200)
		store_i32(memory_at_0, loc_7, loc_0)
		FUNC_LIST[232](add_i32(param_1, 4), 7480, loc_7)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[238] = --[[ Luau::Compiler::compileStat(Luau::AstStat*) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local reg_0, reg_1
	loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_2
	if load_i32(memory_at_0, param_0 + 8) > 0 then
		FUNC_LIST[124](
			load_i32(memory_at_0, param_0),
				add_i32(load_i32(memory_at_0, param_1 + 8), 1)
		)
	end
	if load_i32(memory_at_0, param_0 + 12) <= 0 then goto continue_at_2 end
	loc_0 = load_i32(memory_at_0, param_1 + 4)
	if loc_0 == load_i32(memory_at_0, 55036) then goto continue_at_2 end
	if loc_0 == load_i32(memory_at_0, 55156) then goto continue_at_2 end
	FUNC_LIST[114](load_i32(memory_at_0, param_0), 69, 0, 0, 0)
	::continue_at_2::
	loc_0 = load_i32(memory_at_0, param_1 + 4)
	if param_1 == 0 then goto continue_at_6 end
	if loc_0 ~= load_i32(memory_at_0, 55036) then goto continue_at_6 end
	loc_3 = shr_i32(
		sub_i32(
			load_i32(memory_at_0, param_0 + 212), load_i32(memory_at_0, param_0 + 208)
		), 2
	)
	loc_1 = load_i32(memory_at_0, param_0 + 196)
	if load_i32(memory_at_0, param_1 + 32) ~= 0 then
		loc_0 = 0
		::continue_at_8::
		while true do
			FUNC_LIST[238](
				param_0, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
				)
			)
			loc_0 = add_i32(loc_0, 1)
			if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 32)) then
				goto continue_at_8
			end
			break
		end
	end
	FUNC_LIST[240](param_0, loc_3)
	FUNC_LIST[242](param_0, loc_3)
	store_i32(memory_at_0, param_0 + 196, loc_1)
	goto continue_at_5
	::continue_at_6::
	if param_1 == 0 then goto continue_at_9 end
	if loc_0 ~= load_i32(memory_at_0, 55044) then goto continue_at_9 end
	FUNC_LIST[322](param_0, param_1)
	goto continue_at_5
	::continue_at_9::
	if param_1 == 0 then goto continue_at_10 end
	if loc_0 ~= load_i32(memory_at_0, 55052) then goto continue_at_10 end
	FUNC_LIST[323](param_0, param_1)
	goto continue_at_5
	::continue_at_10::
	if param_1 == 0 then goto continue_at_11 end
	if loc_0 ~= load_i32(memory_at_0, 55060) then goto continue_at_11 end
	FUNC_LIST[324](param_0, param_1)
	goto continue_at_5
	::continue_at_11::
	if load_i32(memory_at_0, 55068) == loc_0 then
		FUNC_LIST[240](
			param_0,
				load_i32(memory_at_0, sub_i32(load_i32(memory_at_0, param_0 + 248), 8))
		)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_3 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 23, 0, 0)
		loc_0 = add_i32(param_0, 232)
		param_1 = load_i32(memory_at_0, param_0 + 236)
		loc_1 = load_i32(memory_at_0, param_0 + 240)
		if lt_u32(param_1, loc_1) then
			store_i64(memory_at_0, param_1, shl_i64(extend_i64_u32(loc_3), 32LL ))
			store_i32(memory_at_0, loc_0 + 4, add_i32(param_1, 8))
			goto continue_at_5
		end
		param_0 = load_i32(memory_at_0, loc_0)
		loc_5 = sub_i32(param_1, param_0)
		loc_4 = shr_i32(loc_5, 3)
		param_1 = add_i32(loc_4, 1)
		if ge_u32(param_1, 536870912) then goto continue_at_4 end
		loc_1 = sub_i32(loc_1, param_0)
		loc_6 = shr_i32(loc_1, 2)
		loc_1 = (lt_u32(loc_1, 2147483640) and
			        (lt_u32(param_1, loc_6) and loc_6 or param_1) or 536870911)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 536870912) then goto continue_at_3 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
		else
			reg_0 = 0
		end
		param_1 = reg_0
		loc_4 = add_i32(param_1, shl_i32(loc_4, 3))
		store_i64(memory_at_0, loc_4, shl_i64(extend_i64_u32(loc_3), 32LL ))
		loc_3 = add_i32(param_1, shl_i32(loc_1, 3))
		loc_1 = add_i32(loc_4, 8)
		if loc_5 > 0 then reg_0 = FUNC_LIST[1119](param_1, param_0, loc_5) end
		store_i32(memory_at_0, loc_0 + 8, loc_3)
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		store_i32(memory_at_0, loc_0, param_1)
		if param_0 == 0 then goto continue_at_5 end
		FUNC_LIST[1276](param_0)
		goto continue_at_5
	end
	if param_1 == 0 then goto continue_at_17 end
	if loc_0 ~= load_i32(memory_at_0, 55076) then goto continue_at_17 end
	loc_0 = load_i32(memory_at_0, param_0 + 248)
	loc_3 = load_i32(memory_at_0, sub_i32(loc_0, 4))
	if loc_3 ~= 0 then
		FUNC_LIST[325](param_0, param_1, loc_3)
		loc_0 = load_i32(memory_at_0, param_0 + 248)
	end
	FUNC_LIST[240](param_0, load_i32(memory_at_0, sub_i32(loc_0, 8)))
	reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
	loc_0 = reg_0
	FUNC_LIST[116](load_i32(memory_at_0, param_0), 23, 0, 0)
	store_i32(memory_at_0, loc_2 + 12, loc_0)
	store_i32(memory_at_0, loc_2 + 8, 1)
	FUNC_LIST[326](add_i32(param_0, 232), add_i32(loc_2, 8))
	goto continue_at_5
	::continue_at_17::
	if param_1 == 0 then goto continue_at_19 end
	if loc_0 ~= load_i32(memory_at_0, 55084) then goto continue_at_19 end
	if load_i32(memory_at_0, param_0 + 4) < 2 then goto continue_at_20 end
	if load_i32(memory_at_0, param_0 + 256) == load_i32(memory_at_0, param_0 + 260) then
		goto continue_at_20
	end
	FUNC_LIST[327](param_0, param_1, 0)
	goto continue_at_5
	::continue_at_20::
	FUNC_LIST[328](param_0, param_1)
	goto continue_at_5
	::continue_at_19::
	if param_1 == 0 then goto continue_at_21 end
	if loc_0 ~= load_i32(memory_at_0, 55092) then goto continue_at_21 end
	loc_0 = load_i32(memory_at_0, param_1 + 28)
	if load_i32(memory_at_0, loc_0 + 4) ~= load_i32(memory_at_0, 54964) then
		goto continue_at_22
	end
	if loc_0 == 0 then goto continue_at_22 end
	FUNC_LIST[329](param_0, loc_0, load_i32_u8(memory_at_0, param_0 + 196), 0, 0, 0)
	goto continue_at_5
	::continue_at_22::
	store_i32(memory_at_0, loc_2 + 8, param_0)
	store_i32(memory_at_0, loc_2 + 12, load_i32(memory_at_0, param_0 + 196))
	reg_0 = FUNC_LIST[330](param_0, loc_0, add_i32(loc_2, 8))
	store_i32(
		memory_at_0, load_i32(memory_at_0, loc_2 + 8) + 196,
			load_i32(memory_at_0, loc_2 + 12)
	)
	goto continue_at_5
	::continue_at_21::
	if param_1 == 0 then goto continue_at_23 end
	if loc_0 ~= load_i32(memory_at_0, 55100) then goto continue_at_23 end
	FUNC_LIST[331](param_0, param_1)
	goto continue_at_5
	::continue_at_23::
	if param_1 == 0 then goto continue_at_24 end
	if loc_0 ~= load_i32(memory_at_0, 55108) then goto continue_at_24 end
	FUNC_LIST[332](param_0, param_1)
	goto continue_at_5
	::continue_at_24::
	if param_1 == 0 then goto continue_at_25 end
	if loc_0 ~= load_i32(memory_at_0, 55116) then goto continue_at_25 end
	FUNC_LIST[333](param_0, param_1)
	goto continue_at_5
	::continue_at_25::
	if param_1 == 0 then goto continue_at_26 end
	if loc_0 ~= load_i32(memory_at_0, 55124) then goto continue_at_26 end
	FUNC_LIST[334](param_0, param_1)
	goto continue_at_5
	::continue_at_26::
	if param_1 == 0 then goto continue_at_27 end
	if loc_0 ~= load_i32(memory_at_0, 55132) then goto continue_at_27 end
	FUNC_LIST[335](param_0, param_1)
	goto continue_at_5
	::continue_at_27::
	if param_1 == 0 then goto continue_at_28 end
	if loc_0 ~= load_i32(memory_at_0, 55140) then goto continue_at_28 end
	FUNC_LIST[336](param_0, param_1)
	goto continue_at_5
	::continue_at_28::
	if param_1 == 0 then goto continue_at_5 end
	if loc_0 ~= load_i32(memory_at_0, 55148) then goto continue_at_5 end
	reg_0 = FUNC_LIST[320](param_0, param_1, 1)
	loc_0 = reg_0
	FUNC_LIST[237](param_0, load_i32(memory_at_0, param_1 + 28), loc_0)
	FUNC_LIST[337](param_0, load_i32(memory_at_0, param_1 + 32), loc_0)
	reg_0 = FUNC_LIST[338](add_i32(param_0, 52), add_i32(param_1, 28))
	reg_1 = FUNC_LIST[129](load_i32(memory_at_0, param_0))
	store_i32(memory_at_0, reg_0 + 4, reg_1)
	::continue_at_5::
	GLOBAL_LIST[0].value = add_i32(loc_2, 16)
	goto continue_at_0
	::continue_at_4::
	FUNC_LIST[339](loc_0)
	error("out of code bounds")
	::continue_at_3::
	FUNC_LIST[252](5133)
	error("out of code bounds")
	::continue_at_0::
end
FUNC_LIST[239] = --[[ Luau::Compiler::allPathsEndWithReturn(Luau::AstStat*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, 55036)
		::continue_at_1::
		while true do
			loc_1 = load_i32(memory_at_0, param_1 + 4)
			if param_1 == 0 then goto continue_at_3 end
			if loc_0 ~= loc_1 then goto continue_at_3 end
			loc_1 = load_i32(memory_at_0, param_1 + 32)
			if loc_1 == 0 then
				loc_0 = 0
				goto continue_at_2
			end
			param_1 = load_i32(
				memory_at_0,
					sub_i32(add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_1, 2)), 4)
			)
			goto continue_at_1
			::continue_at_3::
			if load_i32(memory_at_0, 55084) == loc_1 then
				reg_0 = 1
				goto continue_at_0
			end
			loc_0 = 0
			if param_1 == 0 then goto continue_at_2 end
			if loc_1 ~= load_i32(memory_at_0, 55044) then goto continue_at_2 end
			if load_i32(memory_at_0, param_1 + 36) == 0 then goto continue_at_2 end
			reg_0 = FUNC_LIST[239](param_0, load_i32(memory_at_0, param_1 + 32))
			if reg_0 == 0 then goto continue_at_2 end
			loc_0 = load_i32(memory_at_0, 55036)
			param_1 = load_i32(memory_at_0, param_1 + 36)
			goto continue_at_1
			::continue_at_2::
			break
		end
		reg_0 = loc_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[240] = --[[ Luau::Compiler::closeLocals(unsigned long) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0
	local loc_10 = 0
	local loc_11 = 0
	local loc_12 = 0
	loc_9 = load_i32(memory_at_0, param_0 + 208)
	loc_10 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 212), loc_9), 2)
	if le_u32(loc_10, param_1) then goto continue_at_1 end
	loc_11 = load_i32(memory_at_0, param_0 + 56)
	loc_5 = load_i32(memory_at_0, param_0 + 52)
	loc_6 = sub_i32(div_i32(sub_i32(loc_11, loc_5), 12), 1)
	loc_7 = load_i32(memory_at_0, param_0 + 68)
	loc_2 = 255
	::continue_at_2::
	while true do
		loc_0 = 0
		if loc_5 == loc_11 then goto continue_at_3 end
		loc_4 = load_i32(memory_at_0, add_i32(loc_9, shl_i32(param_1, 2)))
		if loc_4 == loc_7 then goto continue_at_3 end
		loc_3 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_1 = 0
		::continue_at_4::
		while true do
			loc_12 = band_i32(loc_3, loc_6)
			loc_0 = add_i32(loc_5, mul_i32(loc_12, 12))
			loc_3 = load_i32(memory_at_0, loc_0)
			if loc_3 == loc_4 then goto continue_at_3 end
			loc_0 = 0
			if loc_3 == loc_7 then goto continue_at_3 end
			loc_1 = add_i32(loc_1, 1)
			loc_3 = add_i32(loc_1, loc_12)
			if le_u32(loc_1, loc_6) then goto continue_at_4 end
			break
		end
		::continue_at_3::
		loc_1 = (loc_0 ~= 0 and add_i32(loc_0, 4) or 0)
		if load_i32_u8(memory_at_0, loc_1 + 2) ~= 0 then
			loc_8 = 1
			loc_1 = load_i32_u8(memory_at_0, loc_1)
			loc_0 = band_i32(loc_2, 255)
			loc_2 = (gt_u32(loc_0, loc_1) and loc_1 or loc_0)
		end
		param_1 = add_i32(param_1, 1)
		if param_1 ~= loc_10 then goto continue_at_2 end
		break
	end
	if loc_8 == 0 then goto continue_at_1 end
	FUNC_LIST[114](load_i32(memory_at_0, param_0), 11, band_i32(loc_2, 255), 0, 0)
	::continue_at_1::
end
FUNC_LIST[241] = --[[ Luau::Compiler::getUpval(Luau::AstLocal*) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0
	local reg_0
	loc_8 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_8
	loc_5 = load_i32(memory_at_0, param_0 + 224)
	loc_2 = load_i32(memory_at_0, param_0 + 220)
	loc_3 = sub_i32(loc_5, loc_2)
	if loc_2 ~= loc_5 then
		loc_0 = shr_i32(loc_3, 2)
		loc_1 = (gt_u32(loc_0, 1) and loc_0 or 1)
		loc_0 = 0
		::continue_at_6::
		while true do
			if load_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 2))) == param_1 then
				goto continue_at_4
			end
			loc_0 = add_i32(loc_0, 1)
			if loc_0 ~= loc_1 then goto continue_at_6 end
			break
		end
	end
	if ge_u32(loc_3, 797) then goto continue_at_3 end
	loc_4 = add_i32(param_0, 220)
	loc_7 = load_i32(memory_at_0, param_0 + 100)
	loc_0 = load_i32(memory_at_0, param_0 + 104)
	if loc_7 == loc_0 then goto continue_at_7 end
	loc_6 = load_i32(memory_at_0, param_0 + 116)
	if loc_6 == param_1 then goto continue_at_7 end
	loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_7), 12), 1)
	loc_0 = 0
	loc_9 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
	loc_1 = loc_9
	::continue_at_8::
	while true do
		loc_1 = band_i32(loc_1, loc_2)
		loc_3 = load_i32(memory_at_0, add_i32(loc_7, mul_i32(loc_1, 12)))
		if param_1 ~= loc_3 then
			if loc_3 == loc_6 then goto continue_at_7 end
			loc_0 = add_i32(loc_0, 1)
			loc_1 = add_i32(loc_0, loc_1)
			if le_u32(loc_0, loc_2) then goto continue_at_8 end
			goto continue_at_7
		end
		break
	end
	if load_i32_u8(memory_at_0, add_i32(loc_7, mul_i32(loc_1, 12)) + 8) == 0 then
		goto continue_at_7
	end
	loc_6 = add_i32(param_0, 52)
	loc_3 = load_i32(memory_at_0, param_0 + 52)
	loc_0 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 56), loc_3), 12)
	if ge_u32(
		load_i32(memory_at_0, sub_i32(param_0, -64)), shr_u32(mul_i32(loc_0, 3), 2)
	) then
		FUNC_LIST[321](loc_6)
		loc_3 = load_i32(memory_at_0, loc_6)
		loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_6 + 4), loc_3), 12)
	end
	loc_7 = sub_i32(loc_0, 1)
	loc_0 = band_i32(loc_9, loc_7)
	param_0 = add_i32(loc_3, mul_i32(loc_0, 12))
	loc_2 = load_i32(memory_at_0, param_0)
	loc_5 = load_i32(memory_at_0, loc_6 + 16)
	if loc_2 ~= loc_5 then
		loc_1 = 0
		::continue_at_13::
		while true do
			if param_1 == loc_2 then goto continue_at_11 end
			loc_1 = add_i32(loc_1, 1)
			loc_0 = band_i32(add_i32(loc_1, loc_0), loc_7)
			param_0 = add_i32(loc_3, mul_i32(loc_0, 12))
			loc_2 = load_i32(memory_at_0, param_0)
			if loc_2 ~= loc_5 then goto continue_at_13 end
			break
		end
	end
	store_i32(memory_at_0, param_0, param_1)
	store_i32(
		memory_at_0, loc_6 + 12, add_i32(load_i32(memory_at_0, loc_6 + 12), 1)
	)
	::continue_at_11::
	store_i32_n8(memory_at_0, add_i32(loc_3, mul_i32(loc_0, 12)) + 6, 1)
	loc_5 = load_i32(memory_at_0, loc_4 + 4)
	::continue_at_7::
	if load_i32(memory_at_0, loc_4 + 8) ~= loc_5 then
		store_i32(memory_at_0, loc_5, param_1)
		loc_0 = add_i32(loc_5, 4)
		store_i32(memory_at_0, loc_4 + 4, loc_0)
		goto continue_at_14
	end
	loc_3 = load_i32(memory_at_0, loc_4)
	loc_2 = sub_i32(loc_5, loc_3)
	param_0 = shr_i32(loc_2, 2)
	loc_0 = add_i32(param_0, 1)
	if ge_u32(loc_0, 1073741824) then goto continue_at_2 end
	loc_1 = shr_i32(loc_2, 1)
	loc_0 = (lt_u32(loc_2, 2147483644) and
		        (lt_u32(loc_0, loc_1) and loc_1 or loc_0) or 1073741823)
	if loc_0 ~= 0 then
		if ge_u32(loc_0, 1073741824) then goto continue_at_1 end
		reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 2))
	else
		reg_0 = 0
	end
	loc_1 = reg_0
	param_0 = add_i32(loc_1, shl_i32(param_0, 2))
	store_i32(memory_at_0, param_0, param_1)
	param_1 = add_i32(loc_1, shl_i32(loc_0, 2))
	loc_0 = add_i32(param_0, 4)
	if loc_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_3, loc_2) end
	store_i32(memory_at_0, loc_4 + 8, param_1)
	store_i32(memory_at_0, loc_4 + 4, loc_0)
	store_i32(memory_at_0, loc_4, loc_1)
	if loc_3 == 0 then goto continue_at_14 end
	FUNC_LIST[1276](loc_3)
	loc_0 = load_i32(memory_at_0, loc_4 + 4)
	::continue_at_14::
	loc_0 = sub_i32(shr_u32(sub_i32(loc_0, load_i32(memory_at_0, loc_4)), 2), 1)
	::continue_at_4::
	GLOBAL_LIST[0].value = add_i32(loc_8, 16)
	reg_0 = band_i32(loc_0, 255)
	goto continue_at_0
	::continue_at_3::
	loc_0 = load_i32(memory_at_0, param_1)
	store_i32(memory_at_0, loc_8 + 4, 200)
	store_i32(memory_at_0, loc_8, loc_0)
	FUNC_LIST[232](add_i32(param_1, 4), 7549, loc_8)
	error("out of code bounds")
	::continue_at_2::
	FUNC_LIST[250](loc_4)
	error("out of code bounds")
	::continue_at_1::
	FUNC_LIST[252](5133)
	error("out of code bounds")
	::continue_at_0::
	return reg_0
end
FUNC_LIST[242] = --[[ Luau::Compiler::popLocals(unsigned long) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0
	local loc_10 = 0
	local loc_11 = 0
	local reg_0, reg_1
	loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_2
	loc_8 = load_i32(memory_at_0, param_0 + 212)
	loc_5 = load_i32(memory_at_0, param_0 + 208)
	loc_0 = shr_i32(sub_i32(loc_8, loc_5), 2)
	if lt_u32(param_1, loc_0) then
		loc_6 = param_1
		::continue_at_2::
		while true do
			loc_1 = 0
			loc_9 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_9 == loc_0 then goto continue_at_3 end
			loc_7 = load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_6, 2)))
			loc_10 = load_i32(memory_at_0, param_0 + 68)
			if loc_7 == loc_10 then goto continue_at_3 end
			loc_3 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
			loc_4 = sub_i32(div_i32(sub_i32(loc_0, loc_9), 12), 1)
			loc_0 = 0
			::continue_at_4::
			while true do
				loc_11 = band_i32(loc_3, loc_4)
				loc_1 = add_i32(loc_9, mul_i32(loc_11, 12))
				loc_3 = load_i32(memory_at_0, loc_1)
				if loc_3 == loc_7 then goto continue_at_3 end
				loc_1 = 0
				if loc_3 == loc_10 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_3 = add_i32(loc_0, loc_11)
				if le_u32(loc_0, loc_4) then goto continue_at_4 end
				break
			end
			::continue_at_3::
			loc_0 = (loc_1 ~= 0 and add_i32(loc_1, 4) or 0)
			store_i32_n8(memory_at_0, loc_0 + 1, 0)
			if load_i32(memory_at_0, param_0 + 8) >= 2 then
				reg_0 = FUNC_LIST[129](load_i32(memory_at_0, param_0))
				loc_1 = reg_0
				loc_3 = load_i32(memory_at_0, param_0)
				loc_4 = load_i32(
					memory_at_0, load_i32(
						memory_at_0,
							add_i32(load_i32(memory_at_0, param_0 + 208), shl_i32(loc_6, 2))
					)
				)
				store_i32(memory_at_0, loc_2 + 8, loc_4)
				reg_1 = FUNC_LIST[1197](loc_4)
				store_i32(memory_at_0, loc_2 + 12, reg_1)
				loc_4 = load_i32(memory_at_0, loc_0 + 4)
				loc_0 = load_i32_u8(memory_at_0, loc_0)
				store_i64(memory_at_0, loc_2, load_i64(memory_at_0, loc_2 + 8))
				FUNC_LIST[125](loc_3, loc_2, loc_0, loc_4, loc_1)
				loc_8 = load_i32(memory_at_0, param_0 + 212)
				loc_5 = load_i32(memory_at_0, param_0 + 208)
			end
			loc_6 = add_i32(loc_6, 1)
			loc_0 = shr_i32(sub_i32(loc_8, loc_5), 2)
			if lt_u32(loc_6, loc_0) then goto continue_at_2 end
			break
		end
	end
	loc_1 = add_i32(param_0, 208)
	if gt_u32(param_1, loc_0) then
		FUNC_LIST[340](loc_1, sub_i32(param_1, loc_0))
		goto continue_at_6
	end
	if ge_u32(param_1, loc_0) then goto continue_at_6 end
	store_i32(memory_at_0, loc_1 + 4, add_i32(loc_5, shl_i32(param_1, 2)))
	::continue_at_6::
	GLOBAL_LIST[0].value = add_i32(loc_2, 16)
end
FUNC_LIST[243] = --[[ Luau::detail::DenseHashTable<Luau::AstExprFunction*, std::__2::pair<Luau::AstExprFunction*, Luau::Compiler::Function>, std::__2::pair<Luau::AstExprFunction* const, Luau::Compiler::Function>, Luau::detail::ItemInterfaceMap<Luau::AstExprFunction*, Luau::Compiler::Function>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprFunction*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if le_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 40), 15) then
				store_i64(memory_at_0, loc_0 + 8, 0LL )
				store_i64(memory_at_0, loc_0, 0LL )
				loc_4 = load_i32(memory_at_0, param_0 + 16)
				store_i32(memory_at_0, loc_0 + 16, loc_4)
				loc_8 = add_i32(param_0, 16)
				reg_0 = 16
				goto continue_at_2
			end
			store_i64(memory_at_0, loc_0 + 54, 0LL )
			store_i64(memory_at_0, loc_0 + 48, 0LL )
			loc_1 = load_i32(memory_at_0, param_0 + 16)
			store_i64(memory_at_0, loc_0 + 40, 0LL )
			store_i64(memory_at_0, loc_0 + 32, 0LL )
			store_i32(memory_at_0, loc_0 + 24, loc_1)
			FUNC_LIST[249](param_0, 16, add_i32(loc_0, 24))
			loc_1 = load_i32(memory_at_0, loc_0 + 36)
			if loc_1 == 0 then goto continue_at_1 end
			store_i32(memory_at_0, loc_0 + 40, loc_1)
			FUNC_LIST[1276](loc_1)
			goto continue_at_1
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_4)
		loc_8 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_2, loc_1), 40), 1)
		::continue_at_2::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 54, 0LL )
		store_i64(memory_at_0, loc_0 + 48, 0LL )
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[249](loc_0, loc_1, add_i32(loc_0, 24))
		loc_1 = load_i32(memory_at_0, loc_0 + 36)
		if loc_1 ~= 0 then
			store_i32(memory_at_0, loc_0 + 40, loc_1)
			FUNC_LIST[1276](loc_1)
		end
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_2 = load_i32(memory_at_0, param_0)
		if loc_1 == loc_2 then
			loc_2 = loc_1
			goto continue_at_6
		end
		::continue_at_8::
		while true do
			loc_5 = add_i32(loc_2, mul_i32(loc_7, 40))
			loc_6 = load_i32(memory_at_0, loc_5)
			if loc_6 ~= load_i32(memory_at_0, loc_8) then
				loc_2 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
				loc_9 = load_i32(memory_at_0, loc_0)
				loc_4 = sub_i32(
					div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_9), 40), 1
				)
				loc_1 = 0
				loc_10 = load_i32(memory_at_0, loc_0 + 16)
				::continue_at_11::
				while true do
					loc_11 = band_i32(loc_2, loc_4)
					loc_3 = add_i32(loc_9, mul_i32(loc_11, 40))
					loc_2 = load_i32(memory_at_0, loc_3)
					if loc_10 == loc_2 then
						store_i32(memory_at_0, loc_3, loc_6)
						store_i32(
							memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
						)
						loc_6 = load_i32(memory_at_0, loc_5)
						goto continue_at_10
					end
					if loc_2 == loc_6 then goto continue_at_10 end
					loc_1 = add_i32(loc_1, 1)
					loc_2 = add_i32(loc_1, loc_11)
					if le_u32(loc_1, loc_4) then goto continue_at_11 end
					break
				end
				loc_3 = 0
				::continue_at_10::
				store_i32(memory_at_0, loc_3, loc_6)
				store_i32(memory_at_0, loc_3 + 8, load_i32(memory_at_0, loc_5 + 8))
				loc_1 = load_i32(memory_at_0, loc_3 + 12)
				if loc_1 ~= 0 then
					store_i32(memory_at_0, loc_3 + 16, loc_1)
					FUNC_LIST[1276](loc_1)
					store_i32(memory_at_0, loc_3 + 20, 0)
					store_i64(memory_at_0, loc_3 + 12, 0LL )
				end
				loc_1 = add_i32(loc_5, 12)
				store_i32(memory_at_0, loc_3 + 12, load_i32(memory_at_0, loc_1))
				store_i32(memory_at_0, loc_3 + 16, load_i32(memory_at_0, loc_5 + 16))
				loc_2 = add_i32(loc_5, 20)
				store_i32(memory_at_0, loc_3 + 20, load_i32(memory_at_0, loc_2))
				store_i32(memory_at_0, loc_2, 0)
				store_i64(memory_at_0, loc_1, 0LL )
				store_i64(memory_at_0, loc_3 + 30, load_i64(memory_at_0, loc_5 + 30))
				store_i64(memory_at_0, loc_3 + 24, load_i64(memory_at_0, loc_5 + 24))
				loc_2 = load_i32(memory_at_0, param_0)
				loc_1 = load_i32(memory_at_0, param_0 + 4)
			end
			loc_7 = add_i32(loc_7, 1)
			if lt_u32(loc_7, div_i32(sub_i32(loc_1, loc_2), 40)) then
				goto continue_at_8
			end
			break
		end
		::continue_at_6::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_2)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		loc_4 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_4)
		if loc_2 == 0 then goto continue_at_1 end
		if loc_1 ~= loc_2 then
			::continue_at_15::
			while true do
				loc_4 = sub_i32(loc_1, 40)
				loc_3 = sub_i32(loc_1, 28)
				loc_1 = load_i32(memory_at_0, loc_3)
				if loc_1 ~= 0 then
					store_i32(memory_at_0, loc_3 + 4, loc_1)
					FUNC_LIST[1276](loc_1)
				end
				loc_1 = loc_4
				if loc_1 ~= loc_2 then goto continue_at_15 end
				break
			end
			loc_1 = load_i32(memory_at_0, loc_0)
		end
		store_i32(memory_at_0, loc_0 + 4, loc_2)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = sub_i32(loc_0, -64)
	end
FUNC_LIST[244] = --[[ std::__2::enable_if<__is_cpp17_forward_iterator<Luau::AstLocal**>::value && is_constructible<Luau::AstLocal*, std::__2::iterator_traits<Luau::AstLocal**>::reference>::value, void>::type std::__2::vector<Luau::AstLocal*, std::__2::allocator<Luau::AstLocal*> >::assign<Luau::AstLocal**>(Luau::AstLocal**, Luau::AstLocal**) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local reg_0, reg_1
		loc_2 = sub_i32(param_2, param_1)
		loc_3 = shr_i32(loc_2, 2)
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		loc_0 = load_i32(memory_at_0, param_0)
		if le_u32(loc_3, shr_i32(sub_i32(loc_1, loc_0), 2)) then
			loc_1 = sub_i32(load_i32(memory_at_0, param_0 + 4), loc_0)
			loc_4 = shr_i32(loc_1, 2)
			loc_1 = (gt_u32(loc_3, loc_4) and add_i32(param_1, loc_1) or param_2)
			loc_2 = sub_i32(loc_1, param_1)
			if param_1 ~= loc_1 then reg_0 = FUNC_LIST[1120](loc_0, param_1, loc_2) end
			if gt_u32(loc_3, loc_4) then
				param_1 = load_i32(memory_at_0, param_0 + 4)
				param_2 = sub_i32(param_2, loc_1)
				if param_2 > 0 then
					reg_0 = FUNC_LIST[1119](param_1, loc_1, param_2)
					param_1 = add_i32(reg_0, param_2)
				end
				store_i32(memory_at_0, param_0 + 4, param_1)
				goto continue_at_0
			end
			store_i32(memory_at_0, param_0 + 4, add_i32(loc_0, loc_2))
			goto continue_at_0
		end
		if loc_0 ~= 0 then
			store_i32(memory_at_0, param_0 + 4, loc_0)
			FUNC_LIST[1276](loc_0)
			store_i32(memory_at_0, param_0 + 8, 0)
			store_i64(memory_at_0, param_0, 0LL )
			loc_1 = 0
		end
		if loc_2 < 0 then goto continue_at_6 end
		loc_0 = shr_i32(loc_1, 1)
		loc_0 = (lt_u32(loc_1, 2147483644) and
			        (gt_u32(loc_0, loc_3) and loc_0 or loc_3) or 1073741823)
		if ge_u32(loc_0, 1073741824) then goto continue_at_6 end
		loc_3 = shl_i32(loc_0, 2)
		reg_1 = FUNC_LIST[1275](loc_3)
		loc_0 = reg_1
		store_i32(memory_at_0, param_0, loc_0)
		store_i32(memory_at_0, param_0 + 4, loc_0)
		store_i32(memory_at_0, param_0 + 8, add_i32(loc_0, loc_3))
		if param_1 ~= param_2 then
			reg_0 = FUNC_LIST[1119](loc_0, param_1, loc_2)
			loc_0 = add_i32(reg_0, loc_2)
		end
		store_i32(memory_at_0, param_0 + 4, loc_0)
		goto continue_at_0
		::continue_at_6::
		FUNC_LIST[250](param_0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[245] = --[[ std::__2::vector<Luau::ParseError, std::__2::allocator<Luau::ParseError> >::vector(std::__2::vector<Luau::ParseError, std::__2::allocator<Luau::ParseError> > const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local reg_0, reg_1
		store_i32(memory_at_0, param_0 + 8, 0)
		store_i64(memory_at_0, param_0, 0LL )
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		loc_1 = load_i32(memory_at_0, param_1)
		if loc_0 ~= loc_1 then
			loc_1 = sub_i32(loc_0, loc_1)
			if loc_1 < 0 then goto continue_at_1 end
			reg_1 = FUNC_LIST[1275](loc_1)
			loc_0 = reg_1
			store_i32(memory_at_0, param_0, loc_0)
			store_i32(memory_at_0, param_0 + 4, loc_0)
			store_i32(
				memory_at_0, param_0 + 8, add_i32(loc_0, shl_i32(shr_i32(loc_1, 5), 5))
			)
			loc_1 = load_i32(memory_at_0, param_1)
			loc_3 = load_i32(memory_at_0, param_1 + 4)
			if loc_1 ~= loc_3 then
				loc_4 = 36316
				::continue_at_4::
				while true do
					store_i32(memory_at_0, loc_0, loc_4)
					store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, loc_1 + 12))
					store_i64(memory_at_0, loc_0 + 4, load_i64(memory_at_0, loc_1 + 4))
					param_1 = add_i32(loc_1, 20)
					loc_2 = add_i32(loc_0, 20)
					if load_i32_i8(memory_at_0, loc_1 + 31) >= 0 then
						store_i64(memory_at_0, loc_2, load_i64(memory_at_0, param_1))
						store_i32(memory_at_0, loc_2 + 8, load_i32(memory_at_0, param_1 + 8))
						goto continue_at_5
					end
					FUNC_LIST[1345](
						loc_2, load_i32(memory_at_0, param_1), load_i32(memory_at_0, param_1 + 4)
					)
					::continue_at_5::
					loc_0 = add_i32(loc_0, 32)
					loc_1 = add_i32(loc_1, 32)
					if loc_1 ~= loc_3 then goto continue_at_4 end
					break
				end
			end
			store_i32(memory_at_0, param_0 + 4, loc_0)
		end
		reg_0 = param_0
		goto continue_at_0
		::continue_at_1::
		FUNC_LIST[246](param_0)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[246] = --[[ std::__2::__vector_base<Luau::ParseError, std::__2::allocator<Luau::ParseError> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[247] = --[[ Luau::compile(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > const&, Luau::CompileOptions const&, Luau::ParseOptions const&, Luau::BytecodeEncoder*) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0, reg_1
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 544)
		GLOBAL_LIST[0].value = loc_0
		reg_1 = FUNC_LIST[956](add_i32(loc_0, 536))
		loc_3 = reg_1
		reg_0 = FUNC_LIST[965](add_i32(loc_0, 496), loc_3)
		loc_2 = reg_0
		loc_4 = load_i32(memory_at_0, param_1)
		loc_5 = load_i32(memory_at_0, param_1 + 4)
		loc_1 = load_i32_u8(memory_at_0, param_1 + 11)
		param_3 = load_i32(memory_at_0, param_3)
		store_i32(memory_at_0, loc_0 + 12, param_3)
		store_i32(memory_at_0, loc_0 + 448, param_3)
		param_3 = (shr_i32(shl_i32(loc_1, 24), 24) < 0 and 1 or 0)
		FUNC_LIST[996](
			add_i32(loc_0, 456), (param_3 ~= 0 and loc_4 or param_1),
				(param_3 ~= 0 and loc_5 or loc_1), loc_2, loc_3, add_i32(loc_0, 12)
		)
		param_1 = load_i32(memory_at_0, loc_0 + 472)
		if param_1 ~= load_i32(memory_at_0, loc_0 + 476) then
			reg_0 = FUNC_LIST[992](param_1)
			loc_1 = load_i32(memory_at_0, reg_0)
			reg_1 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_1) + 8
			)](param_1)
			store_i32(memory_at_0, loc_0 + 4, reg_1)
			store_i32(memory_at_0, loc_0, add_i32(loc_1, 1))
			FUNC_LIST[1099](add_i32(loc_0, 16), 3313, loc_0)
			FUNC_LIST[143](param_0, add_i32(loc_0, 16))
			if load_i32_i8(memory_at_0, loc_0 + 27) >= 0 then goto continue_at_1 end
			FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 16))
			goto continue_at_1
		end
		reg_0 = FUNC_LIST[85](add_i32(loc_0, 16), param_4)
		param_1 = reg_0
		FUNC_LIST[233](param_1, load_i32(memory_at_0, loc_0 + 456), loc_2, param_2)
		loc_1 = add_i32(param_1, 396)
		if load_i32_i8(memory_at_0, param_1 + 407) >= 0 then
			store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_1))
			store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_1 + 8))
			goto continue_at_3
		end
		FUNC_LIST[1345](
			param_0, load_i32(memory_at_0, loc_1), load_i32(memory_at_0, loc_1 + 4)
		)
		::continue_at_3::
		reg_0 = FUNC_LIST[248](param_1)
		::continue_at_1::
		param_1 = load_i32(memory_at_0, loc_0 + 484)
		if param_1 ~= 0 then
			store_i32(memory_at_0, loc_0 + 488, param_1)
			FUNC_LIST[1276](param_1)
		end
		loc_1 = load_i32(memory_at_0, loc_0 + 472)
		if loc_1 ~= 0 then
			param_0 = loc_1
			param_1 = load_i32(memory_at_0, loc_0 + 476)
			if loc_1 ~= param_1 then
				::continue_at_8::
				while true do
					param_1 = sub_i32(param_1, 32)
					reg_0 = TABLE_LIST[0].data[load_i32(
						memory_at_0, load_i32(memory_at_0, param_1)
					)](param_1)
					if param_1 ~= loc_1 then goto continue_at_8 end
					break
				end
				param_0 = load_i32(memory_at_0, loc_0 + 472)
			end
			store_i32(memory_at_0, loc_0 + 476, loc_1)
			FUNC_LIST[1276](param_0)
		end
		param_0 = load_i32(memory_at_0, loc_0 + 460)
		if param_0 ~= 0 then
			param_1 = load_i32(memory_at_0, loc_0 + 464)
			loc_1 = param_0
			if param_1 ~= loc_1 then
				::continue_at_11::
				while true do
					loc_1 = sub_i32(param_1, 32)
					if load_i32_i8(memory_at_0, sub_i32(param_1, 1)) < 0 then
						FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(param_1, 12)))
					end
					param_1 = loc_1
					if param_1 ~= param_0 then goto continue_at_11 end
					break
				end
				loc_1 = load_i32(memory_at_0, loc_0 + 460)
			end
			store_i32(memory_at_0, loc_0 + 464, param_0)
			FUNC_LIST[1276](loc_1)
		end
		param_1 = load_i32(memory_at_0, loc_2)
		if param_1 ~= 0 then
			store_i32(memory_at_0, loc_2 + 4, param_1)
			FUNC_LIST[1276](param_1)
		end
		reg_0 = FUNC_LIST[957](loc_3)
		GLOBAL_LIST[0].value = add_i32(loc_0, 544)
	end
FUNC_LIST[248] = --[[ Luau::BytecodeBuilder::~BytecodeBuilder() ]] function(
	param_0
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local reg_0
	loc_2 = load_i32(memory_at_0, param_0 + 412)
	if loc_2 ~= 0 then
		loc_1 = load_i32(memory_at_0, param_0 + 416)
		loc_0 = loc_2
		if loc_1 ~= loc_0 then
			::continue_at_3::
			while true do
				loc_0 = sub_i32(loc_1, 12)
				if load_i32_i8(memory_at_0, sub_i32(loc_1, 1)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
				end
				loc_1 = loc_0
				if loc_0 ~= loc_2 then goto continue_at_3 end
				break
			end
			loc_0 = load_i32(memory_at_0, param_0 + 412)
		end
		store_i32(memory_at_0, param_0 + 416, loc_2)
		FUNC_LIST[1276](loc_0)
	end
	if load_i32_i8(memory_at_0, param_0 + 407) < 0 then
		FUNC_LIST[1276](load_i32(memory_at_0, param_0 + 396))
	end
	if load_i32_i8(memory_at_0, param_0 + 391) < 0 then
		FUNC_LIST[1276](load_i32(memory_at_0, param_0 + 380))
	end
	loc_0 = load_i32(memory_at_0, param_0 + 368)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 372, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 340)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 344, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 328)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 332, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 316)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 320, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 288)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 292, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 136)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 140, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 96)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 100, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 80)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 84, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 68)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 72, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 56)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 60, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 44)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 48, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 32)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 36, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 20)
	if loc_0 ~= 0 then
		store_i32(memory_at_0, param_0 + 24, loc_0)
		FUNC_LIST[1276](loc_0)
	end
	loc_2 = load_i32(memory_at_0, param_0)
	if loc_2 ~= 0 then
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = loc_2
		if loc_0 ~= loc_1 then
			::continue_at_22::
			while true do
				if load_i32_i8(memory_at_0, sub_i32(loc_0, 1)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 12)))
				end
				loc_1 = sub_i32(loc_0, 48)
				if load_i32_i8(memory_at_0, sub_i32(loc_0, 13)) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 24)))
				end
				if load_i32_i8(memory_at_0, loc_1 + 11) < 0 then
					FUNC_LIST[1276](load_i32(memory_at_0, loc_1))
				end
				loc_0 = loc_1
				if loc_0 ~= loc_2 then goto continue_at_22 end
				break
			end
			loc_1 = load_i32(memory_at_0, param_0)
		end
		store_i32(memory_at_0, param_0 + 4, loc_2)
		FUNC_LIST[1276](loc_1)
	end
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[249] = --[[ std::__2::vector<std::__2::pair<Luau::AstExprFunction*, Luau::Compiler::Function>, std::__2::allocator<std::__2::pair<Luau::AstExprFunction*, Luau::Compiler::Function> > >::__append(unsigned long, std::__2::pair<Luau::AstExprFunction*, Luau::Compiler::Function> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0, reg_1
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_2, loc_0), 40)) then
			if param_1 ~= 0 then
				loc_3 = add_i32(loc_0, mul_i32(param_1, 40))
				loc_4 = add_i32(param_2, 24)
				loc_5 = add_i32(loc_4, 6)
				::continue_at_9::
				while true do
					store_i32(memory_at_0, loc_0, load_i32(memory_at_0, param_2))
					param_1 = load_i32(memory_at_0, param_2 + 8)
					store_i32(memory_at_0, loc_0 + 20, 0)
					loc_2 = add_i32(loc_0, 12)
					store_i64(memory_at_0, loc_2, 0LL )
					store_i32(memory_at_0, loc_0 + 8, param_1)
					param_1 = load_i32(memory_at_0, param_2 + 16)
					loc_1 = load_i32(memory_at_0, param_2 + 12)
					if param_1 ~= loc_1 then
						loc_1 = sub_i32(param_1, loc_1)
						if loc_1 < 0 then goto continue_at_6 end
						reg_1 = FUNC_LIST[1275](loc_1)
						param_1 = reg_1
						store_i32(memory_at_0, loc_2, param_1)
						store_i32(memory_at_0, loc_2 + 4, param_1)
						store_i32(
							memory_at_0, loc_2 + 8, add_i32(param_1, shl_i32(shr_i32(loc_1, 2), 2))
						)
						loc_6 = load_i32(memory_at_0, param_2 + 12)
						loc_1 = sub_i32(load_i32(memory_at_0, param_2 + 16), loc_6)
						if loc_1 > 0 then
							reg_0 = FUNC_LIST[1119](param_1, loc_6, loc_1)
							param_1 = add_i32(reg_0, loc_1)
						end
						store_i32(memory_at_0, loc_2 + 4, param_1)
					end
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, loc_4))
					store_i64(memory_at_0, loc_0 + 30, load_i64(memory_at_0, loc_5))
					loc_0 = add_i32(loc_0, 40)
					if loc_0 ~= loc_3 then goto continue_at_9 end
					break
				end
				loc_0 = loc_3
			end
			store_i32(memory_at_0, param_0 + 4, loc_0)
			goto continue_at_0
		end
		loc_3 = load_i32(memory_at_0, param_0)
		loc_4 = div_i32(sub_i32(loc_0, loc_3), 40)
		loc_1 = add_i32(loc_4, param_1)
		if ge_u32(loc_1, 107374183) then goto continue_at_5 end
		loc_0 = 0
		loc_2 = div_i32(sub_i32(loc_2, loc_3), 40)
		loc_3 = shl_i32(loc_2, 1)
		loc_1 =
			(lt_u32(loc_2, 53687091) and (lt_u32(loc_1, loc_3) and loc_3 or loc_1) or
				107374182)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 107374183) then goto continue_at_4 end
			reg_0 = FUNC_LIST[1275](mul_i32(loc_1, 40))
			loc_0 = reg_0
		end
		loc_2 = add_i32(loc_0, mul_i32(loc_4, 40))
		loc_4 = add_i32(loc_2, mul_i32(param_1, 40))
		loc_7 = add_i32(loc_0, mul_i32(loc_1, 40))
		loc_5 = add_i32(param_2, 24)
		loc_6 = add_i32(loc_5, 6)
		loc_0 = loc_2
		::continue_at_13::
		while true do
			store_i32(memory_at_0, loc_0, load_i32(memory_at_0, param_2))
			loc_1 = load_i32(memory_at_0, param_2 + 8)
			store_i32(memory_at_0, loc_0 + 20, 0)
			param_1 = add_i32(loc_0, 12)
			store_i64(memory_at_0, param_1, 0LL )
			store_i32(memory_at_0, loc_0 + 8, loc_1)
			loc_1 = load_i32(memory_at_0, param_2 + 16)
			loc_3 = load_i32(memory_at_0, param_2 + 12)
			if loc_1 ~= loc_3 then
				loc_3 = sub_i32(loc_1, loc_3)
				if loc_3 < 0 then goto continue_at_3 end
				reg_1 = FUNC_LIST[1275](loc_3)
				loc_1 = reg_1
				store_i32(memory_at_0, param_1, loc_1)
				store_i32(memory_at_0, param_1 + 4, loc_1)
				store_i32(
					memory_at_0, param_1 + 8, add_i32(loc_1, shl_i32(shr_i32(loc_3, 2), 2))
				)
				loc_8 = load_i32(memory_at_0, param_2 + 12)
				loc_3 = sub_i32(load_i32(memory_at_0, param_2 + 16), loc_8)
				if loc_3 > 0 then
					reg_0 = FUNC_LIST[1119](loc_1, loc_8, loc_3)
					loc_1 = add_i32(reg_0, loc_3)
				end
				store_i32(memory_at_0, param_1 + 4, loc_1)
			end
			store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, loc_5))
			store_i64(memory_at_0, loc_0 + 30, load_i64(memory_at_0, loc_6))
			loc_0 = add_i32(loc_0, 40)
			if loc_0 ~= loc_4 then goto continue_at_13 end
			break
		end
		param_2 = load_i32(memory_at_0, param_0 + 4)
		loc_3 = load_i32(memory_at_0, param_0)
		if param_2 == loc_3 then goto continue_at_2 end
		::continue_at_16::
		while true do
			loc_2 = sub_i32(loc_2, 40)
			param_2 = sub_i32(param_2, 40)
			store_i32(memory_at_0, loc_2, load_i32(memory_at_0, param_2))
			loc_0 = load_i32(memory_at_0, param_2 + 8)
			param_1 = add_i32(loc_2, 20)
			store_i32(memory_at_0, param_1, 0)
			loc_1 = add_i32(loc_2, 12)
			store_i64(memory_at_0, loc_1, 0LL )
			store_i32(memory_at_0, loc_2 + 8, loc_0)
			loc_0 = add_i32(param_2, 12)
			store_i32(memory_at_0, loc_1, load_i32(memory_at_0, loc_0))
			store_i32(memory_at_0, loc_2 + 16, load_i32(memory_at_0, param_2 + 16))
			loc_1 = add_i32(param_2, 20)
			store_i32(memory_at_0, param_1, load_i32(memory_at_0, loc_1))
			store_i32(memory_at_0, loc_1, 0)
			store_i64(memory_at_0, loc_0, 0LL )
			store_i64(memory_at_0, loc_2 + 24, load_i64(memory_at_0, param_2 + 24))
			store_i64(memory_at_0, loc_2 + 30, load_i64(memory_at_0, param_2 + 30))
			if param_2 ~= loc_3 then goto continue_at_16 end
			break
		end
		store_i32(memory_at_0, param_0 + 8, loc_7)
		param_2 = load_i32(memory_at_0, param_0 + 4)
		store_i32(memory_at_0, param_0 + 4, loc_4)
		loc_3 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, param_0, loc_2)
		if param_2 == loc_3 then goto continue_at_1 end
		::continue_at_17::
		while true do
			loc_0 = sub_i32(param_2, 40)
			loc_2 = sub_i32(param_2, 28)
			param_2 = load_i32(memory_at_0, loc_2)
			if param_2 ~= 0 then
				store_i32(memory_at_0, loc_2 + 4, param_2)
				FUNC_LIST[1276](param_2)
			end
			param_2 = loc_0
			if loc_3 ~= param_2 then goto continue_at_17 end
			break
		end
		goto continue_at_1
		::continue_at_6::
		FUNC_LIST[250](loc_2)
		error("out of code bounds")
		::continue_at_5::
		FUNC_LIST[251](param_0)
		error("out of code bounds")
		::continue_at_4::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[250](param_1)
		error("out of code bounds")
		::continue_at_2::
		store_i32(memory_at_0, param_0 + 8, loc_7)
		store_i32(memory_at_0, param_0 + 4, loc_4)
		store_i32(memory_at_0, param_0, loc_2)
		::continue_at_1::
		if loc_3 ~= 0 then FUNC_LIST[1276](loc_3) end
		::continue_at_0::
	end
FUNC_LIST[250] = --[[ std::__2::__vector_base<Luau::AstLocal*, std::__2::allocator<Luau::AstLocal*> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[251] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstExprFunction*, Luau::Compiler::Function>, std::__2::allocator<std::__2::pair<Luau::AstExprFunction*, Luau::Compiler::Function> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[252] = --[[ std::__2::__throw_length_error(char const*) ]] function(
	param_0
)
	local reg_0
	reg_0 = FUNC_LIST[12](8)
	reg_0 = FUNC_LIST[253](reg_0, param_0)
	FUNC_LIST[13](reg_0, 53600, 110)
	error("out of code bounds")
end
FUNC_LIST[253] = --[[ std::length_error::length_error(char const*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = FUNC_LIST[1281](param_0, param_1)
	param_0 = reg_0
	store_i32(memory_at_0, param_0, 53568)
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[254] = --[[ std::__2::vector<std::__2::pair<Luau::AstLocal*, Luau::Compiler::Local>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::Compiler::Local> > >::__append(unsigned long, std::__2::pair<Luau::AstLocal*, Luau::Compiler::Local> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_2), 12)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_4 = mul_i32(param_1, 12)
			loc_0 = loc_2
			loc_3 = sub_i32(mul_i32(param_1, 12), 12)
			param_1 = band_i32(add_i32(div_u32(loc_3, 12), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if lt_u32(loc_3, 36) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 8)
				store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
				store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 48)
				if loc_0 ~= loc_2 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_2)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_2, loc_5), 12)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 357913942) then
			loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
			loc_5 = shl_i32(loc_0, 1)
			loc_5 = (lt_u32(loc_0, 178956970) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 357913941)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 357913942) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
				loc_4 = reg_0
			end
			loc_3 = add_i32(loc_4, mul_i32(loc_6, 12))
			loc_0 = loc_3
			loc_6 = mul_i32(param_1, 12)
			loc_7 = sub_i32(loc_6, 12)
			param_1 = band_i32(add_i32(div_u32(loc_7, 12), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			param_1 = add_i32(loc_3, loc_6)
			if ge_u32(loc_7, 36) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 8)
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
					store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 48)
					if loc_0 ~= param_1 then goto continue_at_12 end
					break
				end
			end
			loc_4 = add_i32(loc_4, mul_i32(loc_5, 12))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_2, loc_0)
			loc_1 = add_i32(loc_3, mul_i32(div_i32(param_2, -12), 12))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, loc_4)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[255](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[255] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstLocal*, Luau::Compiler::Local>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::Compiler::Local> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[256] = --[[ std::__2::vector<std::__2::pair<Luau::AstLocal*, Luau::Compile::Constant>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::Compile::Constant> > >::__append(unsigned long, std::__2::pair<Luau::AstLocal*, Luau::Compile::Constant> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_3 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_3), 24)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_2 = mul_i32(param_1, 24)
			loc_0 = loc_3
			loc_5 = sub_i32(mul_i32(param_1, 24), 24)
			param_1 = band_i32(add_i32(div_u32(loc_5, 24), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2 + 16))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 24)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_3 = add_i32(loc_2, loc_3)
			if lt_u32(loc_5, 72) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 16)
				store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_1))
				param_1 = add_i32(param_2, 8)
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, sub_i32(loc_0, -64), load_i64(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 72, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 80, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 88, load_i64(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 96)
				if loc_0 ~= loc_3 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_3)
			goto continue_at_0
		end
		loc_4 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_3, loc_4), 24)
		loc_2 = add_i32(loc_6, param_1)
		if lt_u32(loc_2, 178956971) then
			loc_0 = div_i32(sub_i32(loc_0, loc_4), 24)
			loc_4 = shl_i32(loc_0, 1)
			loc_7 =
				(lt_u32(loc_0, 89478485) and (lt_u32(loc_2, loc_4) and loc_4 or loc_2) or
					178956970)
			if loc_7 ~= 0 then
				if ge_u32(loc_7, 178956971) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_7, 24))
				loc_5 = reg_0
			end
			loc_4 = add_i32(loc_5, mul_i32(loc_6, 24))
			loc_0 = loc_4
			loc_2 = mul_i32(param_1, 24)
			loc_6 = sub_i32(loc_2, 24)
			param_1 = band_i32(add_i32(div_u32(loc_6, 24), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_4
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, param_2 + 16))
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 24)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if ge_u32(loc_6, 72) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 16)
					store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_1))
					param_1 = add_i32(param_2, 8)
					store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 32, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, sub_i32(loc_0, -64), load_i64(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 56, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 72, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 80, load_i64(memory_at_0, param_1))
					store_i64(memory_at_0, loc_0 + 88, load_i64(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 96)
					if loc_0 ~= loc_2 then goto continue_at_12 end
					break
				end
			end
			param_1 = add_i32(loc_5, mul_i32(loc_7, 24))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_3, loc_0)
			loc_1 = add_i32(loc_4, mul_i32(div_i32(param_2, -24), 24))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, param_1)
			store_i32(memory_at_0, param_0 + 4, loc_2)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[257](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[257] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstLocal*, Luau::Compile::Constant>, std::__2::allocator<std::__2::pair<Luau::AstLocal*, Luau::Compile::Constant> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[258] = --[[ std::__2::vector<std::__2::pair<Luau::AstExprTable*, Luau::Compile::TableShape>, std::__2::allocator<std::__2::pair<Luau::AstExprTable*, Luau::Compile::TableShape> > >::__append(unsigned long, std::__2::pair<Luau::AstExprTable*, Luau::Compile::TableShape> const&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, div_i32(sub_i32(loc_0, loc_2), 12)) then
			if param_1 == 0 then goto continue_at_2 end
			loc_4 = mul_i32(param_1, 12)
			loc_0 = loc_2
			loc_3 = sub_i32(mul_i32(param_1, 12), 12)
			param_1 = band_i32(add_i32(div_u32(loc_3, 12), 1), 3)
			if param_1 ~= 0 then
				::continue_at_4::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_4 end
					break
				end
			end
			loc_2 = add_i32(loc_2, loc_4)
			if lt_u32(loc_3, 36) then goto continue_at_2 end
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(param_2, 8)
				store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
				store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
				store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
				store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
				store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
				loc_0 = add_i32(loc_0, 48)
				if loc_0 ~= loc_2 then goto continue_at_5 end
				break
			end
			::continue_at_2::
			store_i32(memory_at_0, param_0 + 4, loc_2)
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, param_0)
		loc_6 = div_i32(sub_i32(loc_2, loc_5), 12)
		loc_3 = add_i32(loc_6, param_1)
		if lt_u32(loc_3, 357913942) then
			loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
			loc_5 = shl_i32(loc_0, 1)
			loc_5 = (lt_u32(loc_0, 178956970) and
				        (lt_u32(loc_3, loc_5) and loc_5 or loc_3) or 357913941)
			if loc_5 ~= 0 then
				if ge_u32(loc_5, 357913942) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
				loc_4 = reg_0
			end
			loc_3 = add_i32(loc_4, mul_i32(loc_6, 12))
			loc_0 = loc_3
			loc_6 = mul_i32(param_1, 12)
			loc_7 = sub_i32(loc_6, 12)
			param_1 = band_i32(add_i32(div_u32(loc_7, 12), 1), 3)
			if param_1 ~= 0 then
				loc_0 = loc_3
				::continue_at_10::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, param_2 + 8))
					loc_0 = add_i32(loc_0, 12)
					loc_1 = add_i32(loc_1, 1)
					if loc_1 ~= param_1 then goto continue_at_10 end
					break
				end
			end
			param_1 = add_i32(loc_3, loc_6)
			if ge_u32(loc_7, 36) then
				::continue_at_12::
				while true do
					store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
					loc_1 = add_i32(param_2, 8)
					store_i32(memory_at_0, loc_0 + 8, load_i32(memory_at_0, loc_1))
					store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 12, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 32, load_i32(memory_at_0, loc_1))
					store_i64(memory_at_0, loc_0 + 24, load_i64(memory_at_0, param_2))
					store_i64(memory_at_0, loc_0 + 36, load_i64(memory_at_0, param_2))
					store_i32(memory_at_0, loc_0 + 44, load_i32(memory_at_0, loc_1))
					loc_0 = add_i32(loc_0, 48)
					if loc_0 ~= param_1 then goto continue_at_12 end
					break
				end
			end
			loc_4 = add_i32(loc_4, mul_i32(loc_5, 12))
			loc_0 = load_i32(memory_at_0, param_0)
			param_2 = sub_i32(loc_2, loc_0)
			loc_1 = add_i32(loc_3, mul_i32(div_i32(param_2, -12), 12))
			if param_2 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2) end
			store_i32(memory_at_0, param_0 + 8, loc_4)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_1)
			if loc_0 ~= 0 then FUNC_LIST[1276](loc_0) end
			goto continue_at_0
		end
		FUNC_LIST[259](param_0)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[259] = --[[ std::__2::__vector_base<std::__2::pair<Luau::AstExprTable*, Luau::Compile::TableShape>, std::__2::allocator<std::__2::pair<Luau::AstExprTable*, Luau::Compile::TableShape> > >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[260] = --[[ Luau::Compiler::FenvVisitor::~FenvVisitor() ]] function(
	param_0
) FUNC_LIST[1276](param_0) end
FUNC_LIST[261] = --[[ Luau::AstVisitor::visit(Luau::AstNode*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = 1
	return reg_0
end
FUNC_LIST[262] = --[[ Luau::AstVisitor::visit(Luau::AstExpr*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 8
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[263] = --[[ Luau::AstVisitor::visit(Luau::AstExprGroup*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[264] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantNil*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[265] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantBool*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[266] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantNumber*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[267] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantString*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[268] = --[[ Luau::AstVisitor::visit(Luau::AstExprLocal*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[269] = --[[ Luau::Compiler::FenvVisitor::visit(Luau::AstExprGlobal*) ]]
	function(param_0, param_1)
		local reg_0
		param_1 = load_i32(memory_at_0, param_1 + 24)
		if param_1 == 0 then goto continue_at_1 end
		reg_0 = FUNC_LIST[1193](param_1, 1521)
		if reg_0 == 0 then
			store_i32_n8(memory_at_0, load_i32(memory_at_0, param_0 + 4), 1)
		end
		reg_0 = FUNC_LIST[1193](param_1, 1513)
		if reg_0 ~= 0 then goto continue_at_1 end
		store_i32_n8(memory_at_0, load_i32(memory_at_0, param_0 + 8), 1)
		::continue_at_1::
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[270] = --[[ Luau::AstVisitor::visit(Luau::AstExprVarargs*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[271] = --[[ Luau::AstVisitor::visit(Luau::AstExprCall*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[272] = --[[ Luau::AstVisitor::visit(Luau::AstExprIndexName*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[273] = --[[ Luau::AstVisitor::visit(Luau::AstExprIndexExpr*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[274] = --[[ Luau::AstVisitor::visit(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[275] = --[[ Luau::AstVisitor::visit(Luau::AstExprTable*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[276] = --[[ Luau::AstVisitor::visit(Luau::AstExprUnary*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[277] = --[[ Luau::AstVisitor::visit(Luau::AstExprBinary*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[278] = --[[ Luau::AstVisitor::visit(Luau::AstExprTypeAssertion*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[279] = --[[ Luau::AstVisitor::visit(Luau::AstExprIfElse*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[280] = --[[ Luau::AstVisitor::visit(Luau::AstExprError*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[281] = --[[ Luau::AstVisitor::visit(Luau::AstStat*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 8
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[282] = --[[ Luau::AstVisitor::visit(Luau::AstStatBlock*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[283] = --[[ Luau::AstVisitor::visit(Luau::AstStatIf*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[284] = --[[ Luau::AstVisitor::visit(Luau::AstStatWhile*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[285] = --[[ Luau::AstVisitor::visit(Luau::AstStatRepeat*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[286] = --[[ Luau::AstVisitor::visit(Luau::AstStatBreak*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[287] = --[[ Luau::AstVisitor::visit(Luau::AstStatContinue*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[288] = --[[ Luau::AstVisitor::visit(Luau::AstStatReturn*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[289] = --[[ Luau::AstVisitor::visit(Luau::AstStatExpr*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[290] = --[[ Luau::AstVisitor::visit(Luau::AstStatLocal*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[291] = --[[ Luau::AstVisitor::visit(Luau::AstStatFor*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[292] = --[[ Luau::AstVisitor::visit(Luau::AstStatForIn*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[293] = --[[ Luau::AstVisitor::visit(Luau::AstStatAssign*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[294] = --[[ Luau::AstVisitor::visit(Luau::AstStatCompoundAssign*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[295] = --[[ Luau::AstVisitor::visit(Luau::AstStatFunction*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[296] = --[[ Luau::AstVisitor::visit(Luau::AstStatLocalFunction*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[297] = --[[ Luau::AstVisitor::visit(Luau::AstStatTypeAlias*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[298] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareFunction*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[299] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareGlobal*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[300] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareClass*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[301] = --[[ Luau::AstVisitor::visit(Luau::AstStatError*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 88
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[302] = --[[ Luau::AstVisitor::visit(Luau::AstType*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = 0
	return reg_0
end
FUNC_LIST[303] = --[[ Luau::AstVisitor::visit(Luau::AstTypeReference*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[304] = --[[ Luau::AstVisitor::visit(Luau::AstTypeTable*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 172
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[305] = --[[ Luau::AstVisitor::visit(Luau::AstTypeFunction*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[306] = --[[ Luau::AstVisitor::visit(Luau::AstTypeTypeof*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 172
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[307] = --[[ Luau::AstVisitor::visit(Luau::AstTypeUnion*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 172
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[308] = --[[ Luau::AstVisitor::visit(Luau::AstTypeIntersection*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[309] = --[[ Luau::AstVisitor::visit(Luau::AstTypeSingletonBool*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[310] = --[[ Luau::AstVisitor::visit(Luau::AstTypeSingletonString*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[311] = --[[ Luau::AstVisitor::visit(Luau::AstTypeError*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 172
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[312] = --[[ Luau::AstVisitor::visit(Luau::AstTypePack*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = 0
	return reg_0
end
FUNC_LIST[313] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackExplicit*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 212
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[314] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackVariadic*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 212
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[315] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackGeneric*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 212
		)](param_0, param_1)
		return reg_0
	end
FUNC_LIST[316] = --[[ Luau::AstVisitor::visit(Luau::AstExprGlobal*) ]] function(
	param_0, param_1
)
	local reg_0
	reg_0 = TABLE_LIST[0].data[load_i32(
		memory_at_0, load_i32(memory_at_0, param_0) + 12
	)](param_0, param_1)
	return reg_0
end
FUNC_LIST[317] = --[[ Luau::Compiler::FunctionVisitor::~FunctionVisitor() ]]
	function(param_0) FUNC_LIST[1276](param_0) end
FUNC_LIST[318] = --[[ Luau::Compiler::FunctionVisitor::visit(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 92)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_0))](
			loc_0, param_0
		)
		param_0 = load_i32(memory_at_0, param_0 + 8)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if loc_0 ~= load_i32(memory_at_0, param_0 + 8) then
			store_i32(memory_at_0, loc_0, param_1)
			store_i32(memory_at_0, param_0 + 4, add_i32(loc_0, 4))
			reg_0 = 0
			goto continue_at_0
		end
		loc_3 = load_i32(memory_at_0, param_0)
		loc_0 = sub_i32(loc_0, loc_3)
		loc_4 = shr_i32(loc_0, 2)
		loc_2 = add_i32(loc_4, 1)
		if lt_u32(loc_2, 1073741824) then
			loc_1 = shr_i32(loc_0, 1)
			loc_1 = (lt_u32(loc_0, 2147483644) and
				        (gt_u32(loc_1, loc_2) and loc_1 or loc_2) or 1073741823)
			if loc_1 ~= 0 then
				if ge_u32(loc_1, 1073741824) then goto continue_at_2 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
			else
				reg_0 = 0
			end
			loc_2 = reg_0
			loc_4 = add_i32(loc_2, shl_i32(loc_4, 2))
			store_i32(memory_at_0, loc_4, param_1)
			param_1 = add_i32(loc_2, shl_i32(loc_1, 2))
			loc_1 = add_i32(loc_4, 4)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](loc_2, loc_3, loc_0) end
			store_i32(memory_at_0, param_0 + 8, param_1)
			store_i32(memory_at_0, param_0 + 4, loc_1)
			store_i32(memory_at_0, param_0, loc_2)
			if loc_3 ~= 0 then FUNC_LIST[1276](loc_3) end
			reg_0 = 0
			goto continue_at_0
		end
		FUNC_LIST[319](param_0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[319] = --[[ std::__2::__vector_base<Luau::AstExprFunction*, std::__2::allocator<Luau::AstExprFunction*> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[320] = --[[ Luau::Compiler::allocReg(Luau::AstNode*, unsigned int) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		loc_2 = load_i32(memory_at_0, param_0 + 196)
		loc_1 = add_i32(loc_2, param_2)
		if ge_u32(loc_1, 256) then
			store_i32(memory_at_0, loc_0 + 4, 255)
			store_i32(memory_at_0, loc_0, param_2)
			FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_0)
			error("out of code bounds")
		end
		store_i32(memory_at_0, param_0 + 196, loc_1)
		param_2 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (gt_u32(param_2, loc_1) and param_2 or loc_1)
		)
		GLOBAL_LIST[0].value = add_i32(loc_0, 16)
		reg_0 = band_i32(loc_2, 255)
		return reg_0
	end
FUNC_LIST[321] = --[[ Luau::detail::DenseHashTable<Luau::AstLocal*, std::__2::pair<Luau::AstLocal*, Luau::Compiler::Local>, std::__2::pair<Luau::AstLocal* const, Luau::Compiler::Local>, Luau::detail::ItemInterfaceMap<Luau::AstLocal*, Luau::Compiler::Local>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 12), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 16, 0LL )
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			loc_3 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 24, loc_3)
			loc_8 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		loc_3 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 24, loc_3)
		loc_8 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_2, loc_1), 12), 1)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 36, 0LL )
		store_i32(memory_at_0, loc_0 + 32, loc_3)
		FUNC_LIST[254](add_i32(loc_0, 8), loc_1, add_i32(loc_0, 32))
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_2 == loc_1 then
			loc_1 = loc_2
			goto continue_at_2
		end
		::continue_at_7::
		while true do
			loc_9 = add_i32(loc_1, mul_i32(loc_4, 12))
			loc_3 = load_i32(memory_at_0, loc_9)
			if loc_3 ~= load_i32(memory_at_0, loc_8) then
				loc_5 = load_i32(memory_at_0, loc_0 + 8)
				loc_10 = sub_i32(
					div_i32(
						sub_i32(load_i32(memory_at_0, loc_0 + 12), loc_5), 12
					), 1
				)
				loc_1 = band_i32(loc_10, bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9)))
				loc_6 = add_i32(loc_5, mul_i32(loc_1, 12))
				loc_7 = load_i32(memory_at_0, loc_6)
				loc_11 = load_i32(memory_at_0, loc_0 + 24)
				if loc_7 == loc_11 then goto continue_at_10 end
				loc_2 = 0
				if loc_3 == loc_7 then goto continue_at_9 end
				::continue_at_11::
				while true do
					loc_2 = add_i32(loc_2, 1)
					loc_1 = band_i32(add_i32(loc_2, loc_1), loc_10)
					loc_6 = add_i32(loc_5, mul_i32(loc_1, 12))
					loc_7 = load_i32(memory_at_0, loc_6)
					if loc_7 == loc_11 then goto continue_at_10 end
					if loc_3 ~= loc_7 then goto continue_at_11 end
					break
				end
				goto continue_at_9
				::continue_at_10::
				store_i32(memory_at_0, loc_6, loc_3)
				store_i32(
					memory_at_0, loc_0 + 20, add_i32(load_i32(memory_at_0, loc_0 + 20), 1)
				)
				loc_3 = load_i32(memory_at_0, loc_9)
				::continue_at_9::
				store_i32(memory_at_0, loc_6, loc_3)
				store_i64(
					memory_at_0, add_i32(loc_5, mul_i32(loc_1, 12)) + 4,
						load_i64(memory_at_0, loc_9 + 4)
				)
				loc_2 = load_i32(memory_at_0, param_0 + 4)
				loc_1 = load_i32(memory_at_0, param_0)
			end
			loc_4 = add_i32(loc_4, 1)
			if lt_u32(loc_4, div_i32(sub_i32(loc_2, loc_1), 12)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 12, 0LL )
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		FUNC_LIST[254](param_0, 16, add_i32(loc_0, 8))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 12))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 16))
		store_i32(memory_at_0, loc_0 + 16, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 12, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[322] = --[[ Luau::Compiler::compileStatIf(Luau::AstStatIf*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		loc_7 = load_i32(memory_at_0, param_1 + 28)
		loc_3 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_3 == loc_0 then goto continue_at_2 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		if loc_6 == loc_7 then goto continue_at_2 end
		loc_1 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
		loc_4 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 24), 1)
		loc_0 = 0
		::continue_at_3::
		while true do
			loc_1 = band_i32(loc_1, loc_4)
			loc_5 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 24)))
			if loc_7 ~= loc_5 then
				if loc_5 == loc_6 then goto continue_at_2 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_4) then goto continue_at_3 end
				goto continue_at_2
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 24))
		if not br_map[1] then br_map[1] = (function() return { [0] = 1, 0 } end)() end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, loc_0 + 8), 1)] or 2
		if temp < 1 then
			goto continue_at_6
		elseif temp > 1 then
			goto continue_at_2
		else
			goto continue_at_5
		end
		::continue_at_6::
		if load_i32_u8(memory_at_0, loc_0 + 16) ~= 0 then goto continue_at_2 end
		::continue_at_5::
		loc_0 = load_i32(memory_at_0, param_1 + 36)
		if loc_0 == 0 then goto continue_at_1 end
		FUNC_LIST[238](param_0, loc_0)
		goto continue_at_1
		::continue_at_2::
		loc_9 = load_i32(memory_at_0, param_1 + 32)
		loc_14 = load_i32(memory_at_0, param_1 + 36)
		if loc_14 ~= 0 then goto continue_at_16 end
		loc_0 = load_i32(memory_at_0, loc_9 + 4)
		if loc_9 == 0 then goto continue_at_18 end
		if loc_0 ~= load_i32(memory_at_0, 55036) then goto continue_at_18 end
		if load_i32(memory_at_0, loc_9 + 32) ~= 1 then goto continue_at_16 end
		if load_i32(
			memory_at_0, load_i32(memory_at_0, load_i32(memory_at_0, loc_9 + 28)) + 4
		) ~= load_i32(memory_at_0, 55068) then goto continue_at_16 end
		goto continue_at_17
		::continue_at_18::
		if loc_0 ~= load_i32(memory_at_0, 55068) then goto continue_at_16 end
		::continue_at_17::
		loc_15 = load_i32(memory_at_0, param_0 + 208)
		loc_12 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 212), loc_15), 2)
		loc_10 =
			load_i32(memory_at_0, sub_i32(load_i32(memory_at_0, param_0 + 248), 8))
		if gt_u32(loc_12, loc_10) then
			loc_16 = load_i32(memory_at_0, param_0 + 56)
			loc_11 = load_i32(memory_at_0, param_0 + 52)
			loc_5 = sub_i32(div_i32(sub_i32(loc_16, loc_11), 12), 1)
			loc_8 = load_i32(memory_at_0, param_0 + 68)
			loc_13 = 1
			::continue_at_20::
			while true do
				loc_1 = 0
				if loc_11 == loc_16 then goto continue_at_21 end
				loc_6 = load_i32(memory_at_0, add_i32(loc_15, shl_i32(loc_10, 2)))
				if loc_6 == loc_8 then goto continue_at_21 end
				loc_4 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
				loc_0 = 0
				::continue_at_22::
				while true do
					loc_3 = band_i32(loc_4, loc_5)
					loc_1 = add_i32(loc_11, mul_i32(loc_3, 12))
					loc_4 = load_i32(memory_at_0, loc_1)
					if loc_4 == loc_6 then goto continue_at_21 end
					loc_1 = 0
					if loc_4 == loc_8 then goto continue_at_21 end
					loc_0 = add_i32(loc_0, 1)
					loc_4 = add_i32(loc_0, loc_3)
					if le_u32(loc_0, loc_5) then goto continue_at_22 end
					break
				end
				::continue_at_21::
				if load_i32_u8(memory_at_0, (loc_1 ~= 0 and add_i32(loc_1, 4) or 0) + 2) ==
					0 then
					loc_10 = add_i32(loc_10, 1)
					loc_13 = (lt_u32(loc_10, loc_12) and 1 or 0)
					if loc_10 ~= loc_12 then goto continue_at_20 end
				end
				break
			end
			if band_i32(loc_13, 1) ~= 0 then goto continue_at_16 end
		end
		store_i32(memory_at_0, loc_2 + 24, 0)
		store_i64(memory_at_0, loc_2 + 16, 0LL )
		FUNC_LIST[341](param_0, loc_7, 0, add_i32(loc_2, 16), 1)
		loc_1 = load_i32(memory_at_0, loc_2 + 16)
		loc_11 = load_i32(memory_at_0, loc_2 + 20)
		if loc_1 == loc_11 then goto continue_at_7 end
		loc_0 = add_i32(param_0, 232)
		::continue_at_24::
		while true do
			loc_5 = load_i32(memory_at_0, loc_1)
			param_0 = load_i32(memory_at_0, loc_0 + 4)
			loc_3 = load_i32(memory_at_0, loc_0 + 8)
			if lt_u32(param_0, loc_3) then
				store_i64(memory_at_0, param_0, shl_i64(extend_i64_u32(loc_5), 32LL ))
				store_i32(memory_at_0, loc_0 + 4, add_i32(param_0, 8))
				goto continue_at_25
			end
			loc_4 = load_i32(memory_at_0, loc_0)
			loc_6 = sub_i32(param_0, loc_4)
			loc_8 = shr_i32(loc_6, 3)
			param_0 = add_i32(loc_8, 1)
			if ge_u32(param_0, 536870912) then goto continue_at_15 end
			loc_3 = sub_i32(loc_3, loc_4)
			loc_7 = shr_i32(loc_3, 2)
			loc_3 = (lt_u32(loc_3, 2147483640) and
				        (lt_u32(param_0, loc_7) and loc_7 or param_0) or 536870911)
			if loc_3 ~= 0 then
				if ge_u32(loc_3, 536870912) then goto continue_at_14 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 3))
			else
				reg_0 = 0
			end
			param_0 = reg_0
			loc_8 = add_i32(param_0, shl_i32(loc_8, 3))
			store_i64(memory_at_0, loc_8, shl_i64(extend_i64_u32(loc_5), 32LL ))
			loc_5 = add_i32(param_0, shl_i32(loc_3, 3))
			loc_3 = add_i32(loc_8, 8)
			if loc_6 > 0 then reg_0 = FUNC_LIST[1119](param_0, loc_4, loc_6) end
			store_i32(memory_at_0, loc_0 + 8, loc_5)
			store_i32(memory_at_0, loc_0 + 4, loc_3)
			store_i32(memory_at_0, loc_0, param_0)
			if loc_4 == 0 then goto continue_at_25 end
			FUNC_LIST[1276](loc_4)
			::continue_at_25::
			loc_1 = add_i32(loc_1, 4)
			if loc_11 ~= loc_1 then goto continue_at_24 end
			break
		end
		goto continue_at_8
		::continue_at_16::
		if load_i32(memory_at_0, loc_9 + 32) ~= 1 then goto continue_at_30 end
		if loc_14 ~= 0 then goto continue_at_30 end
		loc_0 = load_i32(memory_at_0, load_i32(memory_at_0, loc_9 + 28))
		loc_15 = (load_i32(memory_at_0, loc_0 + 4) == load_i32(memory_at_0, 55076) and
			         loc_0 or 0)
		if loc_15 == 0 then goto continue_at_30 end
		loc_13 = load_i32(memory_at_0, param_0 + 208)
		loc_9 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 212), loc_13), 2)
		loc_16 = load_i32(memory_at_0, param_0 + 248)
		loc_10 = load_i32(memory_at_0, sub_i32(loc_16, 8))
		if gt_u32(loc_9, loc_10) then
			loc_14 = load_i32(memory_at_0, param_0 + 56)
			loc_11 = load_i32(memory_at_0, param_0 + 52)
			loc_5 = sub_i32(div_i32(sub_i32(loc_14, loc_11), 12), 1)
			loc_8 = load_i32(memory_at_0, param_0 + 68)
			loc_12 = 1
			::continue_at_32::
			while true do
				loc_1 = 0
				if loc_11 == loc_14 then goto continue_at_33 end
				loc_6 = load_i32(memory_at_0, add_i32(loc_13, shl_i32(loc_10, 2)))
				if loc_6 == loc_8 then goto continue_at_33 end
				loc_4 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
				loc_0 = 0
				::continue_at_34::
				while true do
					loc_3 = band_i32(loc_4, loc_5)
					loc_1 = add_i32(loc_11, mul_i32(loc_3, 12))
					loc_4 = load_i32(memory_at_0, loc_1)
					if loc_4 == loc_6 then goto continue_at_33 end
					loc_1 = 0
					if loc_4 == loc_8 then goto continue_at_33 end
					loc_0 = add_i32(loc_0, 1)
					loc_4 = add_i32(loc_0, loc_3)
					if le_u32(loc_0, loc_5) then goto continue_at_34 end
					break
				end
				::continue_at_33::
				if load_i32_u8(memory_at_0, (loc_1 ~= 0 and add_i32(loc_1, 4) or 0) + 2) ==
					0 then
					loc_10 = add_i32(loc_10, 1)
					loc_12 = (lt_u32(loc_10, loc_9) and 1 or 0)
					if loc_9 ~= loc_10 then goto continue_at_32 end
				end
				break
			end
			if band_i32(loc_12, 1) ~= 0 then goto continue_at_30 end
		end
		loc_0 = load_i32(memory_at_0, sub_i32(loc_16, 4))
		if loc_0 ~= 0 then
			store_i32(memory_at_0, loc_2 + 24, 0)
			store_i32(memory_at_0, loc_2 + 20, param_0)
			store_i32(memory_at_0, loc_2 + 16, 12352)
			TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, loc_0))](
				loc_0, add_i32(loc_2, 16)
			)
			loc_1 = load_i32(memory_at_0, loc_2 + 24)
			if loc_1 ~= 0 then goto continue_at_13 end
			loc_7 = load_i32(memory_at_0, param_1 + 28)
		end
		store_i32(memory_at_0, loc_2 + 24, 0)
		store_i64(memory_at_0, loc_2 + 16, 0LL )
		FUNC_LIST[341](param_0, loc_7, 0, add_i32(loc_2, 16), 1)
		loc_1 = load_i32(memory_at_0, loc_2 + 16)
		loc_11 = load_i32(memory_at_0, loc_2 + 20)
		if loc_1 == loc_11 then goto continue_at_9 end
		loc_0 = add_i32(param_0, 232)
		::continue_at_37::
		while true do
			loc_5 = load_i32(memory_at_0, loc_1)
			param_0 = load_i32(memory_at_0, loc_0 + 4)
			loc_3 = load_i32(memory_at_0, loc_0 + 8)
			if lt_u32(param_0, loc_3) then
				store_i64(
					memory_at_0, param_0,
						bor_i64(shl_i64(extend_i64_u32(loc_5), 32LL ), 1LL )
				)
				store_i32(memory_at_0, loc_0 + 4, add_i32(param_0, 8))
				goto continue_at_38
			end
			loc_4 = load_i32(memory_at_0, loc_0)
			loc_6 = sub_i32(param_0, loc_4)
			loc_8 = shr_i32(loc_6, 3)
			param_0 = add_i32(loc_8, 1)
			if ge_u32(param_0, 536870912) then goto continue_at_12 end
			loc_3 = sub_i32(loc_3, loc_4)
			loc_7 = shr_i32(loc_3, 2)
			loc_3 = (lt_u32(loc_3, 2147483640) and
				        (lt_u32(param_0, loc_7) and loc_7 or param_0) or 536870911)
			if loc_3 ~= 0 then
				if ge_u32(loc_3, 536870912) then goto continue_at_11 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 3))
			else
				reg_0 = 0
			end
			param_0 = reg_0
			loc_8 = add_i32(param_0, shl_i32(loc_8, 3))
			store_i64(
				memory_at_0, loc_8,
					bor_i64(shl_i64(extend_i64_u32(loc_5), 32LL ), 1LL )
			)
			loc_5 = add_i32(param_0, shl_i32(loc_3, 3))
			loc_3 = add_i32(loc_8, 8)
			if loc_6 > 0 then reg_0 = FUNC_LIST[1119](param_0, loc_4, loc_6) end
			store_i32(memory_at_0, loc_0 + 8, loc_5)
			store_i32(memory_at_0, loc_0 + 4, loc_3)
			store_i32(memory_at_0, loc_0, param_0)
			if loc_4 == 0 then goto continue_at_38 end
			FUNC_LIST[1276](loc_4)
			::continue_at_38::
			loc_1 = add_i32(loc_1, 4)
			if loc_11 ~= loc_1 then goto continue_at_37 end
			break
		end
		goto continue_at_10
		::continue_at_30::
		store_i32(memory_at_0, loc_2 + 24, 0)
		store_i64(memory_at_0, loc_2 + 16, 0LL )
		FUNC_LIST[341](param_0, loc_7, 0, add_i32(loc_2, 16), 0)
		FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 32))
		if load_i32(memory_at_0, param_1 + 36) == 0 then goto continue_at_45 end
		if load_i32(memory_at_0, loc_2 + 20) == load_i32(memory_at_0, loc_2 + 16) then
			goto continue_at_45
		end
		reg_0 = FUNC_LIST[239](param_0, load_i32(memory_at_0, param_1 + 32))
		loc_0 = reg_0
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		if loc_0 ~= 0 then
			FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 36))
			loc_0 = load_i32(memory_at_0, loc_2 + 16)
			loc_4 = load_i32(memory_at_0, loc_2 + 20)
			if loc_0 == loc_4 then goto continue_at_43 end
			::continue_at_47::
			while true do
				reg_0 = FUNC_LIST[119](
					load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_1
				)
				if reg_0 ~= 0 then
					loc_0 = add_i32(loc_0, 4)
					if loc_4 ~= loc_0 then goto continue_at_47 end
					goto continue_at_44
				end
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
		end
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 23, 0, 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_4 = reg_0
		FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 36))
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_3 = reg_0
		loc_0 = load_i32(memory_at_0, loc_2 + 16)
		loc_5 = load_i32(memory_at_0, loc_2 + 20)
		if loc_0 == loc_5 then goto continue_at_49 end
		::continue_at_50::
		while true do
			reg_0 = FUNC_LIST[119](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_4
			)
			if reg_0 ~= 0 then
				loc_0 = add_i32(loc_0, 4)
				if loc_5 ~= loc_0 then goto continue_at_50 end
				goto continue_at_49
			end
			break
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_49::
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_1, loc_3)
		if reg_0 ~= 0 then goto continue_at_44 end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_45::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		loc_0 = load_i32(memory_at_0, loc_2 + 16)
		loc_4 = load_i32(memory_at_0, loc_2 + 20)
		if loc_0 == loc_4 then goto continue_at_43 end
		::continue_at_52::
		while true do
			reg_0 = FUNC_LIST[119](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_1
			)
			if reg_0 ~= 0 then
				loc_0 = add_i32(loc_0, 4)
				if loc_4 ~= loc_0 then goto continue_at_52 end
				goto continue_at_44
			end
			break
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_44::
		loc_0 = load_i32(memory_at_0, loc_2 + 16)
		::continue_at_43::
		if loc_0 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_2 + 20, loc_0)
		FUNC_LIST[1276](loc_0)
		goto continue_at_1
		::continue_at_15::
		FUNC_LIST[339](loc_0)
		error("out of code bounds")
		::continue_at_14::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_13::
		param_0 = load_i32(memory_at_0, loc_15 + 8)
		store_i32(memory_at_0, loc_2, load_i32(memory_at_0, loc_1))
		store_i32(memory_at_0, loc_2 + 4, add_i32(param_0, 1))
		FUNC_LIST[232](add_i32(loc_0, 8), 1973, loc_2)
		error("out of code bounds")
		::continue_at_12::
		FUNC_LIST[339](loc_0)
		error("out of code bounds")
		::continue_at_11::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_10::
		loc_1 = load_i32(memory_at_0, loc_2 + 16)
		::continue_at_9::
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_2 + 20, loc_1)
		FUNC_LIST[1276](loc_1)
		goto continue_at_1
		::continue_at_8::
		loc_1 = load_i32(memory_at_0, loc_2 + 16)
		::continue_at_7::
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_2 + 20, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
	end
FUNC_LIST[323] = --[[ Luau::Compiler::compileStatWhile(Luau::AstStatWhile*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_5
		loc_6 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_6 == loc_0 then goto continue_at_5 end
		loc_3 = load_i32(memory_at_0, param_0 + 140)
		loc_7 = load_i32(memory_at_0, param_1 + 28)
		if loc_3 == loc_7 then goto continue_at_5 end
		loc_1 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 24), 1)
		loc_0 = 0
		::continue_at_6::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_1, 24)))
			if loc_7 ~= loc_4 then
				if loc_3 == loc_4 then goto continue_at_5 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_6 end
				goto continue_at_5
			end
			break
		end
		loc_0 = add_i32(loc_6, mul_i32(loc_1, 24))
		if not br_map[1] then br_map[1] = (function() return { [0] = 2, 0 } end)() end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, loc_0 + 8), 1)] or 1
		if temp < 1 then
			goto continue_at_8
		elseif temp > 1 then
			goto continue_at_4
		else
			goto continue_at_5
		end
		::continue_at_8::
		if load_i32_u8(memory_at_0, loc_0 + 16) == 0 then goto continue_at_4 end
		::continue_at_5::
		loc_4 = add_i32(param_0, 244)
		loc_2 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 212), load_i32(memory_at_0, param_0 + 208)
			), 2
		)
		loc_6 = load_i32(memory_at_0, param_0 + 236)
		loc_7 = load_i32(memory_at_0, param_0 + 232)
		loc_0 = load_i32(memory_at_0, param_0 + 248)
		loc_3 = load_i32(memory_at_0, param_0 + 252)
		if lt_u32(loc_0, loc_3) then
			store_i32(memory_at_0, loc_0 + 4, 0)
			store_i32(memory_at_0, loc_0, loc_2)
			store_i32(memory_at_0, loc_4 + 4, add_i32(loc_0, 8))
			goto continue_at_9
		end
		loc_1 = load_i32(memory_at_0, loc_4)
		loc_9 = sub_i32(loc_0, loc_1)
		loc_10 = shr_i32(loc_9, 3)
		loc_8 = add_i32(loc_10, 1)
		if ge_u32(loc_8, 536870912) then goto continue_at_3 end
		loc_0 = 0
		loc_3 = sub_i32(loc_3, loc_1)
		loc_11 = shr_i32(loc_3, 2)
		loc_3 = (lt_u32(loc_3, 2147483640) and
			        (lt_u32(loc_8, loc_11) and loc_11 or loc_8) or 536870911)
		if loc_3 ~= 0 then
			if ge_u32(loc_3, 536870912) then goto continue_at_2 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 3))
			loc_0 = reg_0
		end
		loc_8 = add_i32(loc_0, shl_i32(loc_10, 3))
		store_i32(memory_at_0, loc_8 + 4, 0)
		store_i32(memory_at_0, loc_8, loc_2)
		loc_2 = add_i32(loc_0, shl_i32(loc_3, 3))
		loc_3 = add_i32(loc_8, 8)
		if loc_9 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_9) end
		store_i32(memory_at_0, loc_4 + 8, loc_2)
		store_i32(memory_at_0, loc_4 + 4, loc_3)
		store_i32(memory_at_0, loc_4, loc_0)
		if loc_1 == 0 then goto continue_at_9 end
		FUNC_LIST[1276](loc_1)
		::continue_at_9::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		store_i32(memory_at_0, loc_5 + 8, 0)
		store_i64(memory_at_0, loc_5, 0LL )
		FUNC_LIST[341](param_0, load_i32(memory_at_0, param_1 + 28), 0, loc_5, 0)
		FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 32))
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_3 = reg_0
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28) + 8), 1)
			)
		end
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 24, 0, 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_2, loc_0)
		if reg_0 == 0 then goto continue_at_1 end
		loc_0 = load_i32(memory_at_0, loc_5)
		loc_2 = load_i32(memory_at_0, loc_5 + 4)
		if loc_0 == loc_2 then goto continue_at_14 end
		::continue_at_15::
		while true do
			reg_0 = FUNC_LIST[119](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_1
			)
			if reg_0 ~= 0 then
				loc_0 = add_i32(loc_0, 4)
				if loc_2 ~= loc_0 then goto continue_at_15 end
				goto continue_at_14
			end
			break
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_14::
		loc_2 = add_i32(param_0, 232)
		loc_0 = shr_i32(sub_i32(loc_6, loc_7), 3)
		FUNC_LIST[342](param_0, param_1, loc_0, loc_1, loc_3)
		loc_1 = load_i32(memory_at_0, param_0 + 232)
		param_0 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 236), loc_1), 3)
		if lt_u32(param_0, loc_0) then
			FUNC_LIST[343](loc_2, sub_i32(loc_0, param_0))
			goto continue_at_17
		end
		if le_u32(param_0, loc_0) then goto continue_at_17 end
		store_i32(memory_at_0, loc_2 + 4, add_i32(loc_1, shl_i32(loc_0, 3)))
		::continue_at_17::
		store_i32(memory_at_0, loc_4 + 4, sub_i32(load_i32(memory_at_0, loc_4 + 4), 8))
		loc_0 = load_i32(memory_at_0, loc_5)
		if loc_0 == 0 then goto continue_at_4 end
		store_i32(memory_at_0, loc_5 + 4, loc_0)
		FUNC_LIST[1276](loc_0)
		::continue_at_4::
		GLOBAL_LIST[0].value = add_i32(loc_5, 16)
		goto continue_at_0
		::continue_at_3::
		FUNC_LIST[344](loc_4)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[324] = --[[ Luau::Compiler::compileStatRepeat(Luau::AstStatRepeat*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_5
		loc_0 = add_i32(param_0, 244)
		loc_7 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 212), load_i32(memory_at_0, param_0 + 208)
			), 2
		)
		loc_10 = load_i32(memory_at_0, param_0 + 236)
		loc_11 = load_i32(memory_at_0, param_0 + 232)
		loc_4 = load_i32(memory_at_0, param_1 + 28)
		loc_1 = load_i32(memory_at_0, param_0 + 248)
		loc_2 = load_i32(memory_at_0, param_0 + 252)
		if lt_u32(loc_1, loc_2) then
			store_i32(memory_at_0, loc_1 + 4, loc_4)
			store_i32(memory_at_0, loc_1, loc_7)
			store_i32(memory_at_0, loc_0 + 4, add_i32(loc_1, 8))
			goto continue_at_6
		end
		loc_3 = load_i32(memory_at_0, loc_0)
		loc_8 = sub_i32(loc_1, loc_3)
		loc_6 = shr_i32(loc_8, 3)
		loc_1 = add_i32(loc_6, 1)
		if ge_u32(loc_1, 536870912) then goto continue_at_5 end
		loc_2 = sub_i32(loc_2, loc_3)
		loc_9 = shr_i32(loc_2, 2)
		loc_2 = (lt_u32(loc_2, 2147483640) and
			        (lt_u32(loc_1, loc_9) and loc_9 or loc_1) or 536870911)
		if loc_2 ~= 0 then
			if ge_u32(loc_2, 536870912) then goto continue_at_4 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
		else
			reg_0 = 0
		end
		loc_1 = reg_0
		loc_6 = add_i32(loc_1, shl_i32(loc_6, 3))
		store_i32(memory_at_0, loc_6 + 4, loc_4)
		store_i32(memory_at_0, loc_6, loc_7)
		loc_4 = add_i32(loc_1, shl_i32(loc_2, 3))
		loc_2 = add_i32(loc_6, 8)
		if loc_8 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_3, loc_8) end
		store_i32(memory_at_0, loc_0 + 8, loc_4)
		store_i32(memory_at_0, loc_0 + 4, loc_2)
		store_i32(memory_at_0, loc_0, loc_1)
		if loc_3 == 0 then goto continue_at_6 end
		FUNC_LIST[1276](loc_3)
		::continue_at_6::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_12 = reg_0
		loc_9 = load_i32(memory_at_0, param_0 + 196)
		loc_1 = load_i32(memory_at_0, param_1 + 32)
		if load_i32(memory_at_0, loc_1 + 32) ~= 0 then
			loc_0 = 0
			::continue_at_12::
			while true do
				FUNC_LIST[238](
					param_0, load_i32(
						memory_at_0, add_i32(load_i32(memory_at_0, loc_1 + 28), shl_i32(loc_0, 2))
					)
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, loc_1 + 32)) then
					goto continue_at_12
				end
				break
			end
		end
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_13 = reg_0
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28) + 8), 1)
			)
		end
		loc_2 = load_i32(memory_at_0, param_1 + 28)
		loc_6 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_6 == loc_0 then goto continue_at_14 end
		loc_8 = load_i32(memory_at_0, param_0 + 140)
		if loc_8 == loc_2 then goto continue_at_14 end
		loc_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 24), 1)
		loc_0 = 0
		::continue_at_15::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_4 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_1, 24)))
			if loc_2 ~= loc_4 then
				if loc_4 == loc_8 then goto continue_at_14 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_15 end
				goto continue_at_14
			end
			break
		end
		loc_0 = add_i32(loc_6, mul_i32(loc_1, 24))
		if not br_map[1] then br_map[1] = (function() return { [0] = 1, 1, 0 } end)() end
		temp = br_map[1][load_i32(memory_at_0, loc_0 + 8)] or 5
		if temp < 1 then
			goto continue_at_17
		elseif temp > 1 then
			goto continue_at_2
		else
			goto continue_at_14
		end
		::continue_at_17::
		if load_i32_u8(memory_at_0, loc_0 + 16) ~= 0 then goto continue_at_2 end
		::continue_at_14::
		store_i32(memory_at_0, loc_5 + 8, 0)
		store_i64(memory_at_0, loc_5, 0LL )
		FUNC_LIST[341](param_0, loc_2, 0, loc_5, 1)
		FUNC_LIST[240](param_0, loc_7)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 24, 0, 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		FUNC_LIST[240](param_0, loc_7)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_4 = reg_0
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_0, loc_12)
		if reg_0 == 0 then goto continue_at_3 end
		loc_0 = load_i32(memory_at_0, loc_5)
		loc_3 = load_i32(memory_at_0, loc_5 + 4)
		if loc_0 ~= loc_3 then
			::continue_at_20::
			while true do
				reg_0 = FUNC_LIST[119](
					load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_1
				)
				if reg_0 ~= 0 then
					loc_0 = add_i32(loc_0, 4)
					if loc_3 ~= loc_0 then goto continue_at_20 end
					goto continue_at_19
				end
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
			::continue_at_19::
			loc_0 = load_i32(memory_at_0, loc_5)
		end
		if loc_0 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_5 + 4, loc_0)
		FUNC_LIST[1276](loc_0)
		goto continue_at_1
		::continue_at_5::
		FUNC_LIST[344](loc_0)
		error("out of code bounds")
		::continue_at_4::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[240](param_0, loc_7)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_4 = reg_0
		::continue_at_1::
		loc_3 = add_i32(param_0, 232)
		FUNC_LIST[242](param_0, loc_7)
		loc_0 = shr_i32(sub_i32(loc_10, loc_11), 3)
		FUNC_LIST[342](param_0, param_1, loc_0, loc_4, loc_13)
		loc_4 = load_i32(memory_at_0, param_0 + 232)
		loc_1 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 236), loc_4), 3)
		if lt_u32(loc_1, loc_0) then
			FUNC_LIST[343](loc_3, sub_i32(loc_0, loc_1))
			goto continue_at_22
		end
		if ge_u32(loc_0, loc_1) then goto continue_at_22 end
		store_i32(memory_at_0, loc_3 + 4, add_i32(loc_4, shl_i32(loc_0, 3)))
		::continue_at_22::
		store_i32(memory_at_0, param_0 + 196, loc_9)
		store_i32(
			memory_at_0, param_0 + 248, sub_i32(load_i32(memory_at_0, param_0 + 248), 8)
		)
		GLOBAL_LIST[0].value = add_i32(loc_5, 16)
	end
FUNC_LIST[325] = --[[ Luau::Compiler::validateContinueUntil(Luau::AstStat*, Luau::AstExpr*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		store_i32(memory_at_0, loc_0 + 24, 0)
		store_i32(memory_at_0, loc_0 + 20, param_0)
		store_i32(memory_at_0, loc_0 + 16, 12352)
		TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_2))](
			param_2, add_i32(loc_0, 16)
		)
		param_0 = load_i32(memory_at_0, loc_0 + 24)
		if param_0 ~= 0 then
			param_1 = load_i32(memory_at_0, param_1 + 8)
			store_i32(memory_at_0, loc_0, load_i32(memory_at_0, param_0))
			store_i32(memory_at_0, loc_0 + 4, add_i32(param_1, 1))
			FUNC_LIST[232](add_i32(param_2, 8), 1973, loc_0)
			error("out of code bounds")
		end
		GLOBAL_LIST[0].value = add_i32(loc_0, 32)
	end
FUNC_LIST[326] = --[[ std::__2::vector<Luau::Compiler::LoopJump, std::__2::allocator<Luau::Compiler::LoopJump> >::push_back(Luau::Compiler::LoopJump&&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		if lt_u32(loc_0, loc_1) then
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
			store_i32(memory_at_0, param_0 + 4, add_i32(loc_0, 8))
			goto continue_at_0
		end
		loc_2 = load_i32(memory_at_0, param_0)
		loc_4 = sub_i32(loc_0, loc_2)
		loc_3 = shr_i32(loc_4, 3)
		loc_0 = add_i32(loc_3, 1)
		if lt_u32(loc_0, 536870912) then
			loc_1 = sub_i32(loc_1, loc_2)
			loc_5 = shr_i32(loc_1, 2)
			loc_1 = (lt_u32(loc_1, 2147483640) and
				        (lt_u32(loc_0, loc_5) and loc_5 or loc_0) or 536870911)
			if loc_1 ~= 0 then
				if ge_u32(loc_1, 536870912) then goto continue_at_2 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
			else
				reg_0 = 0
			end
			loc_0 = reg_0
			loc_3 = add_i32(loc_0, shl_i32(loc_3, 3))
			store_i64(memory_at_0, loc_3, load_i64(memory_at_0, param_1))
			param_1 = add_i32(loc_0, shl_i32(loc_1, 3))
			loc_1 = add_i32(loc_3, 8)
			if loc_4 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_4) end
			store_i32(memory_at_0, param_0 + 8, param_1)
			store_i32(memory_at_0, param_0 + 4, loc_1)
			store_i32(memory_at_0, param_0, loc_0)
			if loc_2 ~= 0 then FUNC_LIST[1276](loc_2) end
			goto continue_at_0
		end
		FUNC_LIST[339](param_0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[327] = --[[ Luau::Compiler::compileInlineReturn(Luau::AstStatReturn*, bool) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0LL
		local reg_0, reg_1
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
		end
		loc_1 = sub_i32(load_i32(memory_at_0, param_0 + 260), 24)
		loc_5 = load_i64(memory_at_0, loc_1)
		loc_0 = load_i32_u16(memory_at_0, loc_1 + 8)
		store_i32(memory_at_0, loc_2 + 28, 0)
		store_i32_n16(memory_at_0, loc_2 + 16, loc_0)
		store_i64(memory_at_0, loc_2 + 8, loc_5)
		store_i64(memory_at_0, loc_2 + 20, 0LL )
		loc_0 = load_i32(memory_at_0, loc_1 + 16)
		loc_3 = load_i32(memory_at_0, loc_1 + 12)
		if loc_0 ~= loc_3 then
			loc_3 = sub_i32(loc_0, loc_3)
			if loc_3 < 0 then goto continue_at_4 end
			reg_1 = FUNC_LIST[1275](loc_3)
			loc_0 = reg_1
			store_i32(memory_at_0, loc_2 + 20, loc_0)
			store_i32(memory_at_0, loc_2 + 24, loc_0)
			store_i32(
				memory_at_0, loc_2 + 28, add_i32(loc_0, shl_i32(shr_i32(loc_3, 2), 2))
			)
			loc_1 = add_i32(loc_1, 12)
			loc_3 = load_i32(memory_at_0, loc_1)
			loc_1 = sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_3)
			if loc_1 > 0 then
				reg_0 = FUNC_LIST[1119](loc_0, loc_3, loc_1)
				loc_0 = add_i32(reg_0, loc_1)
			end
			store_i32(memory_at_0, loc_2 + 24, loc_0)
		end
		FUNC_LIST[345](
			param_0, add_i32(param_1, 28), load_i32_u8(memory_at_0, loc_2 + 16),
				load_i32_u8(memory_at_0, loc_2 + 17), 0
		)
		FUNC_LIST[240](param_0, load_i32(memory_at_0, loc_2 + 12))
		if param_2 ~= 0 then goto continue_at_7 end
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		param_1 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 23, 0, 0)
		loc_1 = load_i32(memory_at_0, param_0 + 260)
		param_0 = sub_i32(loc_1, 12)
		loc_0 = load_i32(memory_at_0, sub_i32(loc_1, 8))
		if loc_0 ~= load_i32(memory_at_0, sub_i32(loc_1, 4)) then
			store_i32(memory_at_0, loc_0, param_1)
			store_i32(memory_at_0, param_0 + 4, add_i32(loc_0, 4))
			goto continue_at_7
		end
		param_2 = load_i32(memory_at_0, param_0)
		loc_1 = sub_i32(loc_0, param_2)
		loc_4 = shr_i32(loc_1, 2)
		loc_0 = add_i32(loc_4, 1)
		if ge_u32(loc_0, 1073741824) then goto continue_at_3 end
		loc_3 = shr_i32(loc_1, 1)
		loc_3 = (lt_u32(loc_1, 2147483644) and
			        (lt_u32(loc_0, loc_3) and loc_3 or loc_0) or 1073741823)
		if loc_3 ~= 0 then
			if ge_u32(loc_3, 1073741824) then goto continue_at_2 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 2))
		else
			reg_0 = 0
		end
		loc_0 = reg_0
		loc_4 = add_i32(loc_0, shl_i32(loc_4, 2))
		store_i32(memory_at_0, loc_4, param_1)
		param_1 = add_i32(loc_0, shl_i32(loc_3, 2))
		loc_3 = add_i32(loc_4, 4)
		if loc_1 > 0 then reg_0 = FUNC_LIST[1119](loc_0, param_2, loc_1) end
		store_i32(memory_at_0, param_0 + 8, param_1)
		store_i32(memory_at_0, param_0 + 4, loc_3)
		store_i32(memory_at_0, param_0, loc_0)
		if param_2 == 0 then goto continue_at_7 end
		FUNC_LIST[1276](param_2)
		::continue_at_7::
		param_0 = load_i32(memory_at_0, loc_2 + 20)
		if param_0 ~= 0 then
			store_i32(memory_at_0, loc_2 + 24, param_0)
			FUNC_LIST[1276](param_0)
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		goto continue_at_0
		::continue_at_4::
		FUNC_LIST[346](add_i32(loc_2, 20))
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[346](param_0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[328] = --[[ Luau::Compiler::compileStatReturn(Luau::AstStatReturn*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local loc_17 = 0
		local loc_18 = 0
		local loc_19 = 0
		local reg_0
		loc_8 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_8
		loc_9 = load_i32(memory_at_0, param_0 + 196)
		loc_2 = load_i32(memory_at_0, param_1 + 32)
		if loc_2 == 0 then goto continue_at_5 end
		loc_11 = load_i32(memory_at_0, 54940)
		loc_18 = load_i32(memory_at_0, param_1 + 28)
		loc_4 = load_i32(memory_at_0, loc_18)
		loc_0 = load_i32(memory_at_0, loc_4 + 4)
		if loc_4 ~= 0 then
			loc_1 = loc_4
			if loc_0 == loc_11 then goto continue_at_7 end
		end
		loc_5 = load_i32(memory_at_0, 55020)
		loc_3 = load_i32(memory_at_0, 54900)
		loc_1 = loc_4
		::continue_at_9::
		while true do
			if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_5 and 1 or 0)) ~= 0 then
				goto continue_at_6
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_9 end
			if loc_0 ~= loc_11 then goto continue_at_9 end
			break
		end
		::continue_at_7::
		loc_5 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_5 == loc_0 then goto continue_at_6 end
		loc_6 = load_i32(memory_at_0, loc_1 + 24)
		loc_12 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_12 then goto continue_at_6 end
		loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 12), 1)
		loc_0 = 0
		::continue_at_10::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_13 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 12)))
			if loc_6 ~= loc_13 then
				if loc_12 == loc_13 then goto continue_at_6 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_10 end
				goto continue_at_6
			end
			break
		end
		loc_0 = add_i32(loc_5, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) == 0 then goto continue_at_6 end
		loc_10 = load_i32_u8(memory_at_0, loc_0 + 4)
		if lt_u32(loc_2, 2) then goto continue_at_5 end
		loc_19 = load_i32(memory_at_0, 55020)
		loc_6 = load_i32(memory_at_0, 54900)
		loc_16 = 1
		loc_7 = 1
		::continue_at_12::
		while true do
			loc_0 = load_i32(memory_at_0, add_i32(loc_18, shl_i32(loc_7, 2)))
			loc_1 = load_i32(memory_at_0, loc_0 + 4)
			if (loc_1 == loc_11 and loc_0 or 0) == 0 then
				::continue_at_15::
				while true do
					if loc_1 == loc_6 then goto continue_at_16 end
					if loc_1 == loc_19 then goto continue_at_16 end
					loc_14 = -1
					goto continue_at_13
					::continue_at_16::
					loc_0 = load_i32(memory_at_0, loc_0 + 24)
					loc_1 = load_i32(memory_at_0, loc_0 + 4)
					if loc_0 == 0 then goto continue_at_15 end
					if loc_1 ~= loc_11 then goto continue_at_15 end
					break
				end
			end
			loc_14 = -1
			loc_15 = load_i32(memory_at_0, loc_0 + 24)
			if loc_15 == loc_12 then goto continue_at_13 end
			loc_1 = bxor_i32(shr_u32(loc_15, 4), shr_u32(loc_15, 9))
			loc_0 = 0
			::continue_at_17::
			while true do
				loc_13 = band_i32(loc_1, loc_3)
				loc_17 = add_i32(loc_5, mul_i32(loc_13, 12))
				loc_1 = load_i32(memory_at_0, loc_17)
				if loc_15 ~= loc_1 then
					if loc_1 == loc_12 then goto continue_at_13 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_13)
					if le_u32(loc_0, loc_3) then goto continue_at_17 end
					goto continue_at_13
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_17 + 5) == 0 then goto continue_at_13 end
			loc_14 = load_i32_u8(memory_at_0, loc_17 + 4)
			::continue_at_13::
			if add_i32(loc_7, loc_10) == loc_14 then
				loc_7 = add_i32(loc_7, 1)
				loc_16 = (lt_u32(loc_7, loc_2) and 1 or 0)
				if loc_2 == loc_7 then goto continue_at_5 end
				goto continue_at_12
			end
			break
		end
		if loc_16 == 0 then goto continue_at_5 end
		::continue_at_6::
		loc_0 = add_i32(loc_2, loc_9)
		if ge_u32(loc_0, 256) then goto continue_at_1 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_1 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
		)
		loc_0 = 0
		loc_3 = 0
		::continue_at_20::
		while true do
			loc_1 = add_i32(loc_0, loc_9)
			loc_0 = add_i32(loc_0, 1)
			if loc_2 == loc_0 then
				reg_0 = FUNC_LIST[347](param_0, loc_4, band_i32(loc_1, 255))
				loc_3 = reg_0
				goto continue_at_21
			end
			loc_2 = load_i32(memory_at_0, param_0 + 196)
			loc_1 = band_i32(loc_1, 255)
			store_i32(memory_at_0, param_0 + 196, add_i32(loc_1, 1))
			FUNC_LIST[348](param_0, loc_4, loc_1, 1)
			store_i32(memory_at_0, param_0 + 196, loc_2)
			::continue_at_21::
			loc_2 = load_i32(memory_at_0, param_1 + 32)
			if ge_u32(loc_0, loc_2) then goto continue_at_4 end
			loc_4 = load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
			)
			goto continue_at_20
		end
		error("out of code bounds")
		::continue_at_5::
		FUNC_LIST[240](param_0, 0)
		loc_2 = load_i32(memory_at_0, param_0)
		goto continue_at_3
		::continue_at_4::
		FUNC_LIST[240](param_0, 0)
		loc_2 = load_i32(memory_at_0, param_0)
		loc_10 = loc_9
		loc_0 = 0
		reg_0 = loc_0
		if band_i32(loc_3, 1) ~= 0 then goto continue_at_2 end
		::continue_at_3::
		reg_0 = add_i32(load_i32_u8(memory_at_0, param_1 + 32), 1)
		::continue_at_2::
		loc_0 = reg_0
		FUNC_LIST[114](loc_2, 22, band_i32(loc_10, 255), band_i32(loc_0, 255), 0)
		store_i32(memory_at_0, param_0 + 196, loc_9)
		GLOBAL_LIST[0].value = add_i32(loc_8, 16)
		goto continue_at_0
		::continue_at_1::
		store_i32(memory_at_0, loc_8 + 4, 255)
		store_i32(memory_at_0, loc_8, loc_2)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_8)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[329] = --[[ Luau::Compiler::compileExprCall(Luau::AstExprCall*, unsigned char, unsigned char, bool, bool) ]]
	function(param_0, param_1, param_2, param_3, param_4, param_5)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local reg_0, reg_1, reg_2, reg_3, reg_4
		loc_3 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_3
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
		end
		if load_i32(memory_at_0, param_0 + 4) < 2 then goto continue_at_5 end
		if load_i32_u8(memory_at_0, param_1 + 36) ~= 0 then goto continue_at_5 end
		loc_10 = load_i32(memory_at_0, param_0 + 104)
		loc_4 = load_i32(memory_at_0, param_0 + 100)
		loc_2 = sub_i32(div_i32(sub_i32(loc_10, loc_4), 12), 1)
		loc_7 = load_i32(memory_at_0, param_0 + 116)
		loc_12 = load_i32(memory_at_0, 55020)
		loc_9 = load_i32(memory_at_0, 54900)
		loc_11 = load_i32(memory_at_0, 54940)
		loc_0 = load_i32(memory_at_0, param_1 + 24)
		::continue_at_6::
		while true do
			loc_1 = load_i32(memory_at_0, loc_0 + 4)
			if loc_0 == 0 then goto continue_at_7 end
			if loc_1 ~= loc_11 then goto continue_at_7 end
			if loc_4 == loc_10 then goto continue_at_5 end
			loc_5 = load_i32(memory_at_0, loc_0 + 24)
			if loc_5 == loc_7 then goto continue_at_5 end
			loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
			loc_0 = 0
			::continue_at_8::
			while true do
				loc_6 = band_i32(loc_1, loc_2)
				loc_8 = add_i32(loc_4, mul_i32(loc_6, 12))
				loc_1 = load_i32(memory_at_0, loc_8)
				if loc_5 ~= loc_1 then
					if loc_1 == loc_7 then goto continue_at_5 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_6)
					if le_u32(loc_0, loc_2) then goto continue_at_8 end
					goto continue_at_5
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_8 + 8) ~= 0 then goto continue_at_5 end
			loc_0 = load_i32(memory_at_0, loc_8 + 4)
			if loc_0 ~= 0 then goto continue_at_6 end
			goto continue_at_5
			::continue_at_7::
			if loc_0 == 0 then goto continue_at_10 end
			if loc_1 ~= loc_9 then goto continue_at_10 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			goto continue_at_6
			::continue_at_10::
			if loc_0 == 0 then goto continue_at_11 end
			if loc_1 ~= loc_12 then goto continue_at_11 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			goto continue_at_6
			::continue_at_11::
			break
		end
		if loc_1 ~= load_i32(memory_at_0, 54988) then goto continue_at_5 end
		loc_4 = load_i32(memory_at_0, param_0 + 28)
		loc_1 = load_i32(memory_at_0, param_0 + 32)
		if loc_4 == loc_1 then goto continue_at_14 end
		loc_7 = load_i32(memory_at_0, param_0 + 44)
		if loc_0 == loc_7 then goto continue_at_14 end
		loc_2 = bxor_i32(shr_u32(loc_0, 4), shr_u32(loc_0, 9))
		loc_6 = sub_i32(div_i32(sub_i32(loc_1, loc_4), 40), 1)
		loc_1 = 0
		::continue_at_15::
		while true do
			loc_2 = band_i32(loc_2, loc_6)
			loc_5 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_2, 40)))
			if loc_5 == loc_0 then goto continue_at_13 end
			if loc_5 == loc_7 then goto continue_at_14 end
			loc_1 = add_i32(loc_1, 1)
			loc_2 = add_i32(loc_1, loc_2)
			if le_u32(loc_1, loc_6) then goto continue_at_15 end
			break
		end
		::continue_at_14::
		loc_1 = (load_i32_u8(memory_at_0, loc_0 + 68) ~= 0 and 7685 or 2635)
		goto continue_at_12
		::continue_at_13::
		loc_1 = add_i32(add_i32(loc_4, mul_i32(loc_2, 40)), 36)
		if load_i32_u8(memory_at_0, loc_1) ~= 0 then
			reg_0 = FUNC_LIST[349](
				param_0, param_1, loc_0, param_2, param_3, param_5,
					load_i32(memory_at_0, 55344), load_i32(memory_at_0, 55360),
					load_i32(memory_at_0, 55376)
			)
			if reg_0 ~= 0 then goto continue_at_4 end
			if load_i32_u8(memory_at_0, loc_1) ~= 0 then goto continue_at_5 end
		end
		loc_1 = 7685
		if load_i32_u8(memory_at_0, loc_0 + 68) ~= 0 then goto continue_at_12 end
		loc_1 = 1476
		if bor_i32(
			load_i32_u8(memory_at_0, param_0 + 204),
				load_i32_u8(memory_at_0, param_0 + 205)
		) == 0 then goto continue_at_5 end
		::continue_at_12::
		FUNC_LIST[130](load_i32(memory_at_0, param_0), loc_1, 0)
		::continue_at_5::
		loc_0 = add_i32(
			load_i32(memory_at_0, param_1 + 32),
				band_i32(add_i32(load_i32_u8(memory_at_0, param_1 + 36), 1), 255)
		)
		loc_0 = (lt_u32(param_3, loc_0) and loc_0 or param_3)
		loc_10 = load_i32(memory_at_0, param_0 + 196)
		if param_4 ~= 0 then
			loc_1 = sub_i32(loc_0, param_3)
			loc_0 = add_i32(loc_1, loc_10)
			if ge_u32(loc_0, 256) then goto continue_at_22 end
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			reg_0 = sub_i32(loc_10, param_3)
			goto continue_at_24
		end
		loc_1 = add_i32(loc_0, loc_10)
		if ge_u32(loc_1, 256) then goto continue_at_23 end
		store_i32(memory_at_0, param_0 + 196, loc_1)
		loc_0 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (gt_u32(loc_0, loc_1) and loc_0 or loc_1)
		)
		reg_0 = loc_10
		::continue_at_24::
		loc_4 = reg_0
		loc_0 = add_i32(param_0, 4)
		if load_i32(memory_at_0, loc_0) <= 0 then goto continue_at_28 end
		FUNC_LIST[175](
			add_i32(loc_3, 56), load_i32(memory_at_0, param_1 + 24),
				add_i32(param_0, 76), add_i32(param_0, 100)
		)
		reg_0 = FUNC_LIST[176](add_i32(loc_3, 56), loc_0)
		loc_9 = reg_0
		if loc_9 ~= 57 then goto continue_at_27 end
		if param_3 ~= 1 then goto continue_at_28 end
		if param_5 ~= 0 then goto continue_at_28 end
		if load_i32(memory_at_0, param_1 + 32) ~= 2 then goto continue_at_28 end
		if load_i32(
			memory_at_0,
				load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28) + 4) + 4
		) ~= load_i32(memory_at_0, 54956) then goto continue_at_28 end
		FUNC_LIST[350](param_0, param_1, param_2, 1, param_4, 0, band_i32(loc_4, 255))
		goto continue_at_17
		::continue_at_28::
		loc_9 = -1
		if load_i32_u8(memory_at_0, param_1 + 36) ~= 0 then goto continue_at_26 end
		goto continue_at_20
		::continue_at_27::
		loc_0 = load_i32_u8(memory_at_0, param_1 + 36)
		if loc_9 < 0 then goto continue_at_29 end
		if band_i32(loc_0, 255) ~= 0 then goto continue_at_29 end
		loc_1 = sub_i32(load_i32(memory_at_0, param_1 + 32), 1)
		if gt_u32(loc_1, 1) then goto continue_at_29 end
		loc_1 = load_i32(
			memory_at_0, load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_1, 2))
			) + 4
		)
		if loc_1 == load_i32(memory_at_0, 54964) then goto continue_at_29 end
		if loc_1 == load_i32(memory_at_0, 54956) then goto continue_at_29 end
		FUNC_LIST[351](
			param_0, param_1, param_2, param_3, param_4, param_5, band_i32(loc_4, 255),
				loc_9
		)
		goto continue_at_17
		::continue_at_29::
		loc_13 = (loc_9 >= 0 and 1 or 0)
		if band_i32(loc_0, 255) == 0 then goto continue_at_21 end
		::continue_at_26::
		loc_0 = load_i32(memory_at_0, param_1 + 24)
		loc_8 = load_i32(
			memory_at_0,
				(load_i32(memory_at_0, loc_0 + 4) == load_i32(memory_at_0, 54972) and loc_0 or
					0) + 24
		)
		loc_0 = load_i32(memory_at_0, loc_8 + 4)
		loc_6 = load_i32(memory_at_0, 54940)
		if loc_8 ~= 0 then
			loc_1 = loc_8
			if loc_0 == loc_6 then goto continue_at_31 end
		end
		loc_5 = load_i32(memory_at_0, 55020)
		loc_2 = load_i32(memory_at_0, 54900)
		loc_1 = loc_8
		::continue_at_33::
		while true do
			if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_5 and 1 or 0)) ~= 0 then
				goto continue_at_30
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_33 end
			if loc_0 ~= loc_6 then goto continue_at_33 end
			break
		end
		::continue_at_31::
		loc_5 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_5 == loc_0 then goto continue_at_30 end
		loc_7 = load_i32(memory_at_0, loc_1 + 24)
		loc_11 = load_i32(memory_at_0, param_0 + 68)
		if loc_7 == loc_11 then goto continue_at_30 end
		loc_1 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 12), 1)
		loc_0 = 0
		::continue_at_34::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_6 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 12)))
			if loc_7 ~= loc_6 then
				if loc_6 == loc_11 then goto continue_at_30 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_34 end
				goto continue_at_30
			end
			break
		end
		loc_0 = add_i32(loc_5, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_19 end
		::continue_at_30::
		loc_0 = load_i32(memory_at_0, param_0 + 196)
		loc_1 = band_i32(loc_4, 255)
		store_i32(memory_at_0, param_0 + 196, add_i32(loc_1, 1))
		FUNC_LIST[348](param_0, loc_8, loc_1, 1)
		store_i32(memory_at_0, param_0 + 196, loc_0)
		reg_0 = loc_4
		goto continue_at_18
		::continue_at_23::
		store_i32(memory_at_0, loc_3 + 36, 255)
		store_i32(memory_at_0, loc_3 + 32, loc_0)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_3, 32))
		error("out of code bounds")
		::continue_at_22::
		store_i32(memory_at_0, loc_3 + 4, 255)
		store_i32(memory_at_0, loc_3, loc_1)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_3)
		error("out of code bounds")
		::continue_at_21::
		loc_12 = 0
		reg_0 = loc_12
		if loc_9 >= 0 then goto continue_at_18 end
		::continue_at_20::
		loc_0 = load_i32(memory_at_0, param_0 + 196)
		loc_1 = load_i32(memory_at_0, param_1 + 24)
		loc_2 = band_i32(loc_4, 255)
		store_i32(memory_at_0, param_0 + 196, add_i32(loc_2, 1))
		FUNC_LIST[348](param_0, loc_1, loc_2, 1)
		store_i32(memory_at_0, param_0 + 196, loc_0)
		reg_0 = 0
		goto continue_at_18
		::continue_at_19::
		reg_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_18::
		loc_12 = reg_0
		loc_2 = load_i32(memory_at_0, param_1 + 32)
		if loc_2 == 0 then
			loc_7 = 0
			goto continue_at_36
		end
		loc_8 = add_i32(loc_4, 1)
		loc_11 = band_i32(loc_4, 255)
		loc_7 = 0
		loc_0 = 0
		::continue_at_38::
		while true do
			loc_6 = load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
			)
			loc_5 = load_i32_u8(memory_at_0, param_1 + 36)
			loc_1 = add_i32(loc_0, 1)
			if loc_2 == loc_1 then
				reg_0 = FUNC_LIST[347](
					param_0, loc_6, band_i32(add_i32(add_i32(loc_0, loc_8), loc_5), 255)
				)
				loc_7 = reg_0
				goto continue_at_39
			end
			loc_0 = load_i32(memory_at_0, param_0 + 196)
			loc_2 = band_i32(add_i32(add_i32(loc_1, loc_11), loc_5), 255)
			store_i32(memory_at_0, param_0 + 196, add_i32(loc_2, 1))
			FUNC_LIST[348](param_0, loc_6, loc_2, 1)
			store_i32(memory_at_0, param_0 + 196, loc_0)
			::continue_at_39::
			loc_2 = load_i32(memory_at_0, param_1 + 32)
			loc_0 = loc_1
			if gt_u32(loc_2, loc_0) then goto continue_at_38 end
			break
		end
		::continue_at_36::
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 24) + 16), 1)
			)
		end
		if load_i32_u8(memory_at_0, param_1 + 36) ~= 0 then
			loc_0 = load_i32(memory_at_0, param_1 + 24)
			loc_1 = (load_i32(memory_at_0, loc_0 + 4) == load_i32(memory_at_0, 54972) and
				        loc_0 or 0)
			if load_i32(memory_at_0, param_0 + 8) > 0 then
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, loc_1 + 32), 1)
				)
			end
			loc_2 = load_i32(memory_at_0, param_0)
			loc_0 = load_i32(memory_at_0, loc_1 + 28)
			reg_1 = FUNC_LIST[1197](loc_0)
			loc_6 = reg_1
			store_i32(memory_at_0, loc_3 + 52, loc_6)
			store_i32(memory_at_0, loc_3 + 48, loc_0)
			store_i64(memory_at_0, loc_3 + 24, load_i64(memory_at_0, loc_3 + 48))
			reg_0 = FUNC_LIST[103](loc_2, add_i32(loc_3, 24))
			loc_2 = reg_0
			if loc_2 < 0 then goto continue_at_3 end
			loc_1 = load_i32(memory_at_0, param_0)
			store_i32(memory_at_0, loc_3 + 44, loc_6)
			store_i32(memory_at_0, loc_3 + 40, loc_0)
			store_i64(memory_at_0, loc_3 + 16, load_i64(memory_at_0, loc_3 + 40))
			reg_4 = FUNC_LIST[139](add_i32(loc_3, 16))
			FUNC_LIST[114](
				loc_1, 20, band_i32(loc_4, 255), band_i32(loc_12, 255), band_i32(reg_4, 255)
			)
			FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_2)
			goto continue_at_42
		end
		if loc_13 == 0 then goto continue_at_42 end
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		FUNC_LIST[114](load_i32(memory_at_0, param_0), 68, band_i32(loc_9, 255), 0, 0)
		FUNC_LIST[348](
			param_0, load_i32(memory_at_0, param_1 + 24), band_i32(loc_4, 255), 1
		)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		reg_0 = FUNC_LIST[121](load_i32(memory_at_0, param_0), loc_0, loc_1)
		if reg_0 == 0 then goto continue_at_2 end
		::continue_at_42::
		loc_0 = 0
		loc_1 = 0
		if band_i32(loc_7, 1) == 0 then
			loc_1 = add_i32(
				add_i32(
					load_i32_u8(memory_at_0, param_1 + 36),
						load_i32_u8(memory_at_0, param_1 + 32)
				), 1
			)
		end
		loc_2 = load_i32(memory_at_0, param_0)
		FUNC_LIST[114](
			loc_2, 21, band_i32(loc_4, 255), band_i32(loc_1, 255),
				band_i32((param_5 ~= 0 and 0 or add_i32(param_3, 1)), 255)
		)
		if param_3 == 0 then goto continue_at_17 end
		if param_4 ~= 0 then goto continue_at_17 end
		::continue_at_46::
		while true do
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 6, band_i32(add_i32(param_2, loc_0), 255),
					band_i32(add_i32(loc_0, loc_4), 255), 0
			)
			loc_0 = add_i32(loc_0, 1)
			if loc_0 ~= param_3 then goto continue_at_46 end
			break
		end
		::continue_at_17::
		store_i32(memory_at_0, param_0 + 196, loc_10)
		::continue_at_4::
		GLOBAL_LIST[0].value = sub_i32(loc_3, -64)
		goto continue_at_0
		::continue_at_3::
		FUNC_LIST[232](add_i32(loc_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[232](add_i32(load_i32(memory_at_0, param_1 + 24), 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[330] = --[[ Luau::Compiler::compileExprAuto(Luau::AstExpr*, Luau::Compiler::RegScope&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_5
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		loc_4 = load_i32(memory_at_0, 54940)
		if param_1 ~= 0 then
			loc_1 = param_1
			if loc_0 == loc_4 then goto continue_at_4 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_2 = load_i32(memory_at_0, 54900)
		loc_1 = param_1
		::continue_at_6::
		while true do
			if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_3
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_6 end
			if loc_0 ~= loc_4 then goto continue_at_6 end
			break
		end
		::continue_at_4::
		loc_3 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_3 == loc_0 then goto continue_at_3 end
		loc_6 = load_i32(memory_at_0, loc_1 + 24)
		loc_7 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_7 then goto continue_at_3 end
		loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 12), 1)
		loc_0 = 0
		::continue_at_7::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 12)))
			if loc_6 ~= loc_4 then
				if loc_4 == loc_7 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_7 end
				goto continue_at_3
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_2 end
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_0, param_1, band_i32(loc_1, 255), 1)
			goto continue_at_1
		end
		store_i64(memory_at_0, loc_5, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_5)
		error("out of code bounds")
		::continue_at_2::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_5, 16)
		reg_0 = band_i32(loc_1, 255)
		return reg_0
	end
FUNC_LIST[331] = --[[ Luau::Compiler::compileStatLocal(Luau::AstStatLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		if load_i32(memory_at_0, param_0 + 4) > 0 then
			if load_i32(memory_at_0, param_0 + 8) < 2 then goto continue_at_4 end
		end
		loc_2 = load_i32(memory_at_0, param_1 + 32)
		goto continue_at_3
		::continue_at_4::
		loc_2 = load_i32(memory_at_0, param_1 + 32)
		if lt_u32(loc_2, load_i32(memory_at_0, param_1 + 40)) then goto continue_at_3 end
		if loc_2 == 0 then goto continue_at_2 end
		loc_0 = load_i32(memory_at_0, param_0 + 104)
		loc_7 = load_i32(memory_at_0, param_0 + 100)
		loc_1 = div_i32(sub_i32(loc_0, loc_7), 12)
		if loc_0 == loc_7 then goto continue_at_3 end
		loc_5 = load_i32(memory_at_0, param_1 + 28)
		loc_9 = add_i32(loc_5, shl_i32(loc_2, 2))
		loc_4 = sub_i32(loc_1, 1)
		loc_8 = load_i32(memory_at_0, param_0 + 116)
		::continue_at_6::
		while true do
			loc_6 = load_i32(memory_at_0, loc_5)
			if loc_6 == loc_8 then goto continue_at_3 end
			loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
			loc_0 = 0
			::continue_at_7::
			while true do
				loc_10 = band_i32(loc_1, loc_4)
				loc_11 = add_i32(loc_7, mul_i32(loc_10, 12))
				loc_1 = load_i32(memory_at_0, loc_11)
				if loc_6 ~= loc_1 then
					if loc_1 == loc_8 then goto continue_at_3 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_10)
					if le_u32(loc_0, loc_4) then goto continue_at_7 end
					goto continue_at_3
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_11 + 9) == 0 then goto continue_at_3 end
			loc_5 = add_i32(loc_5, 4)
			if loc_9 ~= loc_5 then goto continue_at_6 end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_1, loc_2)
		if ge_u32(loc_0, 256) then goto continue_at_1 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_4 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_4) and loc_4 or loc_0)
		)
		FUNC_LIST[345](
			param_0, add_i32(param_1, 36), band_i32(loc_1, 255), band_i32(loc_2, 255), 1
		)
		if load_i32(memory_at_0, param_1 + 32) == 0 then goto continue_at_2 end
		loc_0 = 0
		::continue_at_9::
		while true do
			FUNC_LIST[237](
				param_0, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
				), band_i32(add_i32(loc_0, loc_1), 255)
			)
			loc_0 = add_i32(loc_0, 1)
			if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 32)) then
				goto continue_at_9
			end
			break
		end
		::continue_at_2::
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		goto continue_at_0
		::continue_at_1::
		store_i32(memory_at_0, loc_3 + 4, 255)
		store_i32(memory_at_0, loc_3, loc_2)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_3)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[332] = --[[ Luau::Compiler::compileStatFor(Luau::AstStatFor*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local loc_17 = 0
		local reg_0
		loc_9 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_9
		loc_13 = load_i32(memory_at_0, param_0 + 196)
		if load_i32(memory_at_0, param_0 + 4) < 2 then goto continue_at_8 end
		loc_5 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_5 == loc_0 then goto continue_at_8 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		loc_3 = load_i32(memory_at_0, param_1 + 36)
		if loc_6 == loc_3 then goto continue_at_8 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 24), 1)
		loc_0 = 0
		::continue_at_9::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)))
			if loc_3 ~= loc_4 then
				if loc_4 == loc_6 then goto continue_at_8 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_9 end
				goto continue_at_8
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) == 0 then
			goto continue_at_8
		end
		loc_3 = load_i32(memory_at_0, param_1 + 32)
		if loc_6 == loc_3 then goto continue_at_8 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_0 = 0
		::continue_at_11::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)))
			if loc_3 ~= loc_4 then
				if loc_4 == loc_6 then goto continue_at_8 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_11 end
				goto continue_at_8
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) == 0 then
			goto continue_at_8
		end
		loc_3 = load_i32(memory_at_0, param_1 + 40)
		if loc_3 ~= 0 then
			if loc_3 == loc_6 then goto continue_at_8 end
			loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
			loc_0 = 0
			::continue_at_14::
			while true do
				loc_1 = band_i32(loc_1, loc_2)
				loc_4 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)))
				if loc_3 ~= loc_4 then
					if loc_4 == loc_6 then goto continue_at_8 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_1)
					if le_u32(loc_0, loc_2) then goto continue_at_14 end
					goto continue_at_8
				end
				break
			end
			if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) == 0 then
				goto continue_at_8
			end
		end
		reg_0 = FUNC_LIST[352](
			param_0, param_1, load_i32(memory_at_0, 55312), load_i32(memory_at_0, 55328)
		)
		if reg_0 ~= 0 then goto continue_at_7 end
		::continue_at_8::
		loc_6 = add_i32(param_0, 244)
		loc_14 = load_i32(memory_at_0, param_0 + 236)
		loc_15 = load_i32(memory_at_0, param_0 + 232)
		loc_10 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 212), load_i32(memory_at_0, param_0 + 208)
			), 2
		)
		loc_0 = load_i32(memory_at_0, param_0 + 248)
		loc_1 = load_i32(memory_at_0, param_0 + 252)
		if lt_u32(loc_0, loc_1) then
			store_i32(memory_at_0, loc_0 + 4, 0)
			store_i32(memory_at_0, loc_0, loc_10)
			store_i32(memory_at_0, loc_6 + 4, add_i32(loc_0, 8))
			goto continue_at_16
		end
		loc_2 = load_i32(memory_at_0, loc_6)
		loc_5 = sub_i32(loc_0, loc_2)
		loc_3 = shr_i32(loc_5, 3)
		loc_4 = add_i32(loc_3, 1)
		if ge_u32(loc_4, 536870912) then goto continue_at_6 end
		loc_0 = 0
		loc_1 = sub_i32(loc_1, loc_2)
		loc_7 = shr_i32(loc_1, 2)
		loc_1 = (lt_u32(loc_1, 2147483640) and
			        (lt_u32(loc_4, loc_7) and loc_7 or loc_4) or 536870911)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 536870912) then goto continue_at_5 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
			loc_0 = reg_0
		end
		loc_4 = add_i32(loc_0, shl_i32(loc_3, 3))
		store_i32(memory_at_0, loc_4 + 4, 0)
		store_i32(memory_at_0, loc_4, loc_10)
		loc_1 = add_i32(loc_0, shl_i32(loc_1, 3))
		loc_4 = add_i32(loc_4, 8)
		if loc_5 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_5) end
		store_i32(memory_at_0, loc_6 + 8, loc_1)
		store_i32(memory_at_0, loc_6 + 4, loc_4)
		store_i32(memory_at_0, loc_6, loc_0)
		if loc_2 == 0 then goto continue_at_16 end
		FUNC_LIST[1276](loc_2)
		::continue_at_16::
		loc_7 = load_i32(memory_at_0, param_0 + 196)
		loc_11 = add_i32(loc_7, 3)
		if ge_u32(loc_11, 256) then goto continue_at_4 end
		store_i32(memory_at_0, param_0 + 196, loc_11)
		loc_0 = load_i32(memory_at_0, param_0 + 200)
		loc_12 = (gt_u32(loc_0, loc_11) and loc_0 or loc_11)
		store_i32(memory_at_0, param_0 + 200, loc_12)
		loc_16 = band_i32(loc_7, 255)
		loc_8 = add_i32(loc_16, 2)
		loc_0 = loc_8
		loc_5 = load_i32(memory_at_0, param_0 + 100)
		loc_1 = load_i32(memory_at_0, param_0 + 104)
		reg_0 = loc_0
		if loc_5 == loc_1 then goto continue_at_20 end
		loc_3 = load_i32(memory_at_0, param_1 + 28)
		loc_17 = load_i32(memory_at_0, param_0 + 116)
		reg_0 = loc_8
		if loc_3 == loc_17 then goto continue_at_20 end
		loc_2 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_1 = sub_i32(div_i32(sub_i32(loc_1, loc_5), 12), 1)
		loc_0 = 0
		::continue_at_22::
		while true do
			loc_2 = band_i32(loc_1, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_2, 12)))
			if loc_4 == loc_3 then goto continue_at_21 end
			reg_0 = loc_8
			if loc_4 == loc_17 then goto continue_at_20 end
			loc_0 = add_i32(loc_0, 1)
			loc_2 = add_i32(loc_0, loc_2)
			if le_u32(loc_0, loc_1) then goto continue_at_22 end
			break
		end
		reg_0 = loc_8
		goto continue_at_20
		::continue_at_21::
		reg_0 = loc_8
		if load_i32_u8(memory_at_0, add_i32(loc_5, mul_i32(loc_2, 12)) + 8) == 0 then
			goto continue_at_20
		end
		loc_0 = add_i32(loc_7, 4)
		if ge_u32(loc_0, 256) then goto continue_at_3 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_12) and loc_12 or loc_0)
		)
		reg_0 = loc_11
		::continue_at_20::
		loc_0 = reg_0
		FUNC_LIST[348](
			param_0, load_i32(memory_at_0, param_1 + 32), band_i32(loc_8, 255), 1
		)
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 36), loc_16, 1)
		loc_2 = load_i32(memory_at_0, param_1 + 40)
		if loc_2 ~= 0 then
			FUNC_LIST[348](param_0, loc_2, band_i32(add_i32(loc_7, 1), 255), 1)
			goto continue_at_23
		end
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 4, band_i32(add_i32(loc_7, 1), 255), 1, 0
		)
		::continue_at_23::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 56, band_i32(loc_7, 255), 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_4 = reg_0
		loc_0 = band_i32(loc_0, 255)
		if loc_0 ~= loc_8 then
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 6, loc_0, band_i32(loc_8, 255), 0
			)
		end
		FUNC_LIST[237](param_0, load_i32(memory_at_0, param_1 + 28), loc_0)
		FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 44))
		FUNC_LIST[240](param_0, loc_10)
		FUNC_LIST[242](param_0, loc_10)
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
		end
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_5 = reg_0
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 57, band_i32(loc_7, 255), 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_1, loc_2)
		if reg_0 == 0 then goto continue_at_2 end
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_0, loc_4)
		if reg_0 == 0 then goto continue_at_1 end
		loc_1 = add_i32(param_0, 232)
		loc_0 = shr_i32(sub_i32(loc_14, loc_15), 3)
		FUNC_LIST[342](param_0, param_1, loc_0, loc_2, loc_5)
		param_1 = load_i32(memory_at_0, param_0 + 232)
		loc_2 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 236), param_1), 3)
		if lt_u32(loc_2, loc_0) then
			FUNC_LIST[343](loc_1, sub_i32(loc_0, loc_2))
			goto continue_at_27
		end
		if ge_u32(loc_0, loc_2) then goto continue_at_27 end
		store_i32(memory_at_0, loc_1 + 4, add_i32(param_1, shl_i32(loc_0, 3)))
		::continue_at_27::
		store_i32(memory_at_0, loc_6 + 4, sub_i32(load_i32(memory_at_0, loc_6 + 4), 8))
		::continue_at_7::
		store_i32(memory_at_0, param_0 + 196, loc_13)
		GLOBAL_LIST[0].value = add_i32(loc_9, 32)
		goto continue_at_0
		::continue_at_6::
		FUNC_LIST[344](loc_6)
		error("out of code bounds")
		::continue_at_5::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_4::
		store_i64(memory_at_0, loc_9, 1095216660483LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_9)
		error("out of code bounds")
		::continue_at_3::
		store_i64(memory_at_0, loc_9 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_9, 16))
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[333] = --[[ Luau::Compiler::compileStatForIn(Luau::AstStatForIn*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_3
		loc_0 = add_i32(param_0, 244)
		loc_9 = load_i32(memory_at_0, param_0 + 236)
		loc_10 = load_i32(memory_at_0, param_0 + 232)
		loc_7 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 212), load_i32(memory_at_0, param_0 + 208)
			), 2
		)
		loc_11 = load_i32(memory_at_0, param_0 + 196)
		loc_2 = load_i32(memory_at_0, param_0 + 248)
		loc_1 = load_i32(memory_at_0, param_0 + 252)
		if lt_u32(loc_2, loc_1) then
			store_i32(memory_at_0, loc_2 + 4, 0)
			store_i32(memory_at_0, loc_2, loc_7)
			store_i32(memory_at_0, loc_0 + 4, add_i32(loc_2, 8))
			goto continue_at_7
		end
		loc_5 = load_i32(memory_at_0, loc_0)
		loc_6 = sub_i32(loc_2, loc_5)
		loc_8 = shr_i32(loc_6, 3)
		loc_4 = add_i32(loc_8, 1)
		if ge_u32(loc_4, 536870912) then goto continue_at_6 end
		loc_2 = 0
		loc_1 = sub_i32(loc_1, loc_5)
		loc_12 = shr_i32(loc_1, 2)
		loc_1 = (lt_u32(loc_1, 2147483640) and
			        (lt_u32(loc_4, loc_12) and loc_12 or loc_4) or 536870911)
		if loc_1 ~= 0 then
			if ge_u32(loc_1, 536870912) then goto continue_at_5 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
			loc_2 = reg_0
		end
		loc_4 = add_i32(loc_2, shl_i32(loc_8, 3))
		store_i32(memory_at_0, loc_4 + 4, 0)
		store_i32(memory_at_0, loc_4, loc_7)
		loc_1 = add_i32(loc_2, shl_i32(loc_1, 3))
		loc_4 = add_i32(loc_4, 8)
		if loc_6 > 0 then reg_0 = FUNC_LIST[1119](loc_2, loc_5, loc_6) end
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		store_i32(memory_at_0, loc_0 + 4, loc_4)
		store_i32(memory_at_0, loc_0, loc_2)
		if loc_5 == 0 then goto continue_at_7 end
		FUNC_LIST[1276](loc_5)
		::continue_at_7::
		loc_5 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_5, 3)
		if ge_u32(loc_0, 256) then goto continue_at_4 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_2 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
		)
		loc_8 = add_i32(param_1, 36)
		FUNC_LIST[345](param_0, loc_8, band_i32(loc_5, 255), 3, 1)
		loc_2 = load_i32(memory_at_0, param_0 + 196)
		loc_4 = load_i32(memory_at_0, param_1 + 32)
		loc_1 = (gt_u32(loc_4, 2) and loc_4 or 2)
		loc_0 = add_i32(loc_2, loc_1)
		if ge_u32(loc_0, 256) then goto continue_at_3 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_1 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
		)
		loc_6 = 76
		loc_1 = 58
		if load_i32(memory_at_0, param_0 + 4) <= 0 then goto continue_at_11 end
		if gt_u32(loc_4, 2) then goto continue_at_11 end
		if not br_map[1] then br_map[1] = (function() return { [0] = 0, 1 } end)() end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, param_1 + 40), 1)] or 3
		if temp < 1 then
			goto continue_at_14
		elseif temp > 1 then
			goto continue_at_11
		else
			goto continue_at_13
		end
		::continue_at_14::
		loc_0 = load_i32(memory_at_0, load_i32(memory_at_0, loc_8))
		if load_i32(memory_at_0, loc_0 + 4) ~= load_i32(memory_at_0, 54964) then
			goto continue_at_11
		end
		FUNC_LIST[175](
			add_i32(loc_3, 24), load_i32(memory_at_0, loc_0 + 24), add_i32(param_0, 76),
				add_i32(param_0, 100)
		)
		if load_i32(memory_at_0, loc_3 + 24) ~= 0 then goto continue_at_11 end
		loc_0 = load_i32(memory_at_0, loc_3 + 28)
		if loc_0 == 0 then goto continue_at_11 end
		reg_0 = FUNC_LIST[1193](loc_0, 2558)
		if reg_0 == 0 then
			loc_6 = 59
			loc_1 = 60
			goto continue_at_11
		end
		reg_0 = FUNC_LIST[1193](loc_0, 2559)
		if reg_0 ~= 0 then goto continue_at_11 end
		reg_0 = (load_i32_u8(memory_at_0, 55300) ~= 0 and 58 or 62)
		goto continue_at_12
		::continue_at_13::
		FUNC_LIST[175](
			add_i32(loc_3, 24), load_i32(memory_at_0, load_i32(memory_at_0, loc_8)),
				add_i32(param_0, 76), add_i32(param_0, 100)
		)
		if load_i32(memory_at_0, loc_3 + 24) ~= 0 then goto continue_at_11 end
		loc_0 = load_i32(memory_at_0, loc_3 + 28)
		if loc_0 == 0 then goto continue_at_11 end
		reg_0 = FUNC_LIST[1193](loc_0, 1615)
		if reg_0 ~= 0 then goto continue_at_11 end
		reg_0 = (load_i32_u8(memory_at_0, 55300) ~= 0 and 58 or 62)
		::continue_at_12::
		loc_1 = reg_0
		loc_6 = 61
		::continue_at_11::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_4 = reg_0
		loc_0 = 0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), loc_6, band_i32(loc_5, 255), 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_6 = reg_0
		if load_i32(memory_at_0, param_1 + 32) ~= 0 then
			::continue_at_17::
			while true do
				FUNC_LIST[237](
					param_0, load_i32(
						memory_at_0,
							add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
					), band_i32(add_i32(loc_0, loc_2), 255)
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 32)) then
					goto continue_at_17
				end
				break
			end
		end
		FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 44))
		FUNC_LIST[240](param_0, loc_7)
		FUNC_LIST[242](param_0, loc_7)
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
		end
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), loc_1, band_i32(loc_5, 255), 0)
		if loc_1 == 58 then
			FUNC_LIST[117](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, param_1 + 32)
			)
		end
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_7 = reg_0
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_4, loc_0)
		if reg_0 == 0 then goto continue_at_2 end
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_0, loc_6)
		if reg_0 == 0 then goto continue_at_1 end
		loc_5 = add_i32(param_0, 232)
		loc_0 = shr_i32(sub_i32(loc_9, loc_10), 3)
		FUNC_LIST[342](param_0, param_1, loc_0, loc_7, loc_2)
		loc_2 = load_i32(memory_at_0, param_0 + 232)
		param_1 = shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 236), loc_2), 3)
		if lt_u32(param_1, loc_0) then
			FUNC_LIST[343](loc_5, sub_i32(loc_0, param_1))
			goto continue_at_20
		end
		if le_u32(param_1, loc_0) then goto continue_at_20 end
		store_i32(memory_at_0, loc_5 + 4, add_i32(loc_2, shl_i32(loc_0, 3)))
		::continue_at_20::
		store_i32(memory_at_0, param_0 + 196, loc_11)
		store_i32(
			memory_at_0, param_0 + 248, sub_i32(load_i32(memory_at_0, param_0 + 248), 8)
		)
		GLOBAL_LIST[0].value = add_i32(loc_3, 32)
		goto continue_at_0
		::continue_at_6::
		FUNC_LIST[344](loc_0)
		error("out of code bounds")
		::continue_at_5::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_4::
		store_i64(memory_at_0, loc_3, 1095216660483LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_3)
		error("out of code bounds")
		::continue_at_3::
		store_i32(memory_at_0, loc_3 + 20, 255)
		store_i32(memory_at_0, loc_3 + 16, loc_1)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_3, 16))
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[334] = --[[ Luau::Compiler::compileStatAssign(Luau::AstStatAssign*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0, reg_1
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_1
		store_i32(memory_at_0, loc_1 + 72, param_0)
		store_i32(memory_at_0, loc_1 + 76, load_i32(memory_at_0, param_0 + 196))
		loc_0 = load_i32(memory_at_0, param_1 + 32)
		if loc_0 == 1 then
			if load_i32(memory_at_0, param_1 + 40) ~= 1 then
				store_i64(memory_at_0, loc_1 + 28, 0LL )
				goto continue_at_7
			end
			FUNC_LIST[353](
				add_i32(loc_1, 40), param_0,
					load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28)),
					add_i32(loc_1, 72)
			)
			loc_5 = load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 36))
			if load_i32(memory_at_0, loc_1 + 40) == 0 then
				FUNC_LIST[348](param_0, loc_5, load_i32_u8(memory_at_0, loc_1 + 44), 0)
				goto continue_at_1
			end
			loc_0 = load_i32(memory_at_0, loc_5 + 4)
			loc_4 = load_i32(memory_at_0, 54940)
			if loc_5 ~= 0 then
				loc_2 = loc_5
				if loc_0 == loc_4 then goto continue_at_12 end
			end
			loc_6 = load_i32(memory_at_0, 55020)
			loc_3 = load_i32(memory_at_0, 54900)
			loc_2 = loc_5
			::continue_at_14::
			while true do
				if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_6 and 1 or 0)) ~= 0 then
					goto continue_at_11
				end
				loc_2 = load_i32(memory_at_0, loc_2 + 24)
				loc_0 = load_i32(memory_at_0, loc_2 + 4)
				if loc_2 == 0 then goto continue_at_14 end
				if loc_0 ~= loc_4 then goto continue_at_14 end
				break
			end
			::continue_at_12::
			loc_6 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_6 == loc_0 then goto continue_at_11 end
			loc_7 = load_i32(memory_at_0, loc_2 + 24)
			loc_8 = load_i32(memory_at_0, param_0 + 68)
			if loc_7 == loc_8 then goto continue_at_11 end
			loc_2 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 12), 1)
			loc_0 = 0
			::continue_at_15::
			while true do
				loc_2 = band_i32(loc_2, loc_3)
				loc_4 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_2, 12)))
				if loc_7 ~= loc_4 then
					if loc_4 == loc_8 then goto continue_at_11 end
					loc_0 = add_i32(loc_0, 1)
					loc_2 = add_i32(loc_0, loc_2)
					if le_u32(loc_0, loc_3) then goto continue_at_15 end
					goto continue_at_11
				end
				break
			end
			loc_0 = add_i32(loc_6, mul_i32(loc_2, 12))
			if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_3 end
			::continue_at_11::
			loc_2 = load_i32(memory_at_0, param_0 + 196)
			loc_0 = add_i32(loc_2, 1)
			if lt_u32(loc_0, 256) then
				store_i32(memory_at_0, param_0 + 196, loc_0)
				loc_3 = load_i32(memory_at_0, param_0 + 200)
				store_i32(
					memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
				)
				FUNC_LIST[348](param_0, loc_5, band_i32(loc_2, 255), 1)
				goto continue_at_2
			end
			store_i64(memory_at_0, loc_1, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_5, 8), 7407, loc_1)
			error("out of code bounds")
		end
		store_i32(memory_at_0, loc_1 + 32, 0)
		store_i64(memory_at_0, loc_1 + 24, 0LL )
		if loc_0 == 0 then goto continue_at_6 end
		if ge_u32(loc_0, 134217728) then goto continue_at_5 end
		::continue_at_7::
		loc_2 = shl_i32(loc_0, 5)
		reg_1 = FUNC_LIST[1275](loc_2)
		loc_3 = reg_1
		store_i32(memory_at_0, loc_1 + 24, loc_3)
		loc_4 = add_i32(loc_2, loc_3)
		store_i32(memory_at_0, loc_1 + 32, loc_4)
		loc_0 = 0
		reg_0 = FUNC_LIST[1121](loc_3, 0, loc_2)
		loc_3 = reg_0
		store_i32(memory_at_0, loc_1 + 28, loc_4)
		::continue_at_18::
		while true do
			FUNC_LIST[353](
				add_i32(loc_1, 40), param_0, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
				), add_i32(loc_1, 72)
			)
			loc_2 = add_i32(loc_3, shl_i32(loc_0, 5))
			store_i64(memory_at_0, loc_2 + 24, load_i64(memory_at_0, sub_i32(loc_1, -64)))
			store_i64(memory_at_0, loc_2 + 16, load_i64(memory_at_0, loc_1 + 56))
			store_i64(memory_at_0, loc_2 + 8, load_i64(memory_at_0, loc_1 + 48))
			store_i64(memory_at_0, loc_2, load_i64(memory_at_0, loc_1 + 40))
			loc_0 = add_i32(loc_0, 1)
			if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 32)) then
				goto continue_at_18
			end
			break
		end
		::continue_at_6::
		FUNC_LIST[354](param_0, param_1, add_i32(loc_1, 24))
		loc_2 = load_i32(memory_at_0, param_0 + 196)
		loc_3 = load_i32(memory_at_0, param_1 + 32)
		loc_0 = add_i32(loc_2, loc_3)
		if ge_u32(loc_0, 256) then goto continue_at_4 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_4 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_4) and loc_4 or loc_0)
		)
		FUNC_LIST[345](
			param_0, add_i32(param_1, 36), band_i32(loc_2, 255), band_i32(loc_3, 255), 1
		)
		if load_i32(memory_at_0, param_1 + 32) ~= 0 then
			loc_0 = 0
			::continue_at_20::
			while true do
				if load_i32(memory_at_0, param_0 + 8) > 0 then
					FUNC_LIST[124](
						load_i32(memory_at_0, param_0), add_i32(
							load_i32(
								memory_at_0, load_i32(
									memory_at_0,
										add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
								) + 8
							), 1
						)
					)
				end
				FUNC_LIST[355](
					param_0, add_i32(load_i32(memory_at_0, loc_1 + 24), shl_i32(loc_0, 5)),
						band_i32(add_i32(loc_0, loc_2), 255), 1
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 32)) then
					goto continue_at_20
				end
				break
			end
		end
		loc_0 = load_i32(memory_at_0, loc_1 + 24)
		if loc_0 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_1 + 28, loc_0)
		FUNC_LIST[1276](loc_0)
		goto continue_at_1
		::continue_at_5::
		FUNC_LIST[356](add_i32(loc_1, 24))
		error("out of code bounds")
		::continue_at_4::
		store_i32(memory_at_0, loc_1 + 20, 255)
		store_i32(memory_at_0, loc_1 + 16, loc_3)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_1, 16))
		error("out of code bounds")
		::continue_at_3::
		loc_2 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_2::
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0), add_i32(
					load_i32(
						memory_at_0,
							load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28)) + 8
					), 1
				)
			)
		end
		FUNC_LIST[355](param_0, add_i32(loc_1, 40), band_i32(loc_2, 255), 1)
		::continue_at_1::
		store_i32(
			memory_at_0, load_i32(memory_at_0, loc_1 + 72) + 196,
				load_i32(memory_at_0, loc_1 + 76)
		)
		GLOBAL_LIST[0].value = add_i32(loc_1, 80)
	end
FUNC_LIST[335] = --[[ Luau::Compiler::compileStatCompoundAssign(Luau::AstStatCompoundAssign*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local reg_0, reg_1
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 96)
		GLOBAL_LIST[0].value = loc_2
		store_i32(memory_at_0, loc_2 + 88, param_0)
		store_i32(memory_at_0, loc_2 + 92, load_i32(memory_at_0, param_0 + 196))
		FUNC_LIST[353](
			add_i32(loc_2, 56), param_0, load_i32(memory_at_0, param_1 + 32),
				add_i32(loc_2, 88)
		)
		loc_1 = load_i32(memory_at_0, loc_2 + 56)
		if loc_1 == 0 then
			loc_7 = load_i32_u8(memory_at_0, loc_2 + 60)
			goto continue_at_8
		end
		loc_7 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_7, 1)
		if ge_u32(loc_0, 256) then goto continue_at_7 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_3 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
		)
		::continue_at_8::
		loc_0 = load_i32(memory_at_0, param_1 + 28)
		if ge_u32(loc_0, 6) then
			if loc_0 ~= 6 then goto continue_at_1 end
			loc_1 = load_i32(memory_at_0, param_1 + 36)
			reg_1 = FUNC_LIST[1275](4)
			loc_0 = reg_1
			store_i32(memory_at_0, loc_2 + 40, loc_0)
			loc_3 = add_i32(loc_0, 4)
			store_i32(memory_at_0, loc_2 + 48, loc_3)
			store_i32(memory_at_0, loc_0, loc_1)
			store_i32(memory_at_0, loc_2 + 44, loc_3)
			FUNC_LIST[357](add_i32(loc_2, 40))
			loc_1 = add_i32(
				shr_i32(
					sub_i32(
						load_i32(memory_at_0, loc_2 + 44), load_i32(memory_at_0, loc_2 + 40)
					), 2
				), 1
			)
			loc_4 = load_i32(memory_at_0, param_0 + 196)
			loc_0 = add_i32(loc_1, loc_4)
			if ge_u32(loc_0, 256) then goto continue_at_11 end
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			loc_0 = 0
			param_1 = band_i32(loc_4, 255)
			FUNC_LIST[355](param_0, add_i32(loc_2, 56), param_1, 0)
			loc_1 = load_i32(memory_at_0, loc_2 + 44)
			loc_3 = load_i32(memory_at_0, loc_2 + 40)
			if loc_1 ~= loc_3 then goto continue_at_5 end
			loc_5 = shr_i32(sub_i32(loc_1, loc_3), 2)
			goto continue_at_2
		end
		if loc_1 ~= 0 then
			FUNC_LIST[355](param_0, add_i32(loc_2, 56), band_i32(loc_7, 255), 0)
		end
		loc_4 = load_i32(memory_at_0, param_1 + 36)
		loc_6 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_6 == loc_0 then goto continue_at_14 end
		loc_8 = load_i32(memory_at_0, param_0 + 140)
		if loc_8 == loc_4 then goto continue_at_14 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 24), 1)
		loc_0 = 0
		::continue_at_15::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_5 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_1, 24)))
			if loc_4 ~= loc_5 then
				if loc_5 == loc_8 then goto continue_at_14 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_15 end
				goto continue_at_14
			end
			break
		end
		loc_0 = add_i32(loc_6, mul_i32(loc_1, 24))
		if load_i32(memory_at_0, loc_0 + 8) ~= 3 then goto continue_at_14 end
		reg_0 = FUNC_LIST[102](
			load_i32(memory_at_0, param_0), load_f64(memory_at_0, loc_0 + 16)
		)
		loc_0 = reg_0
		if loc_0 < 0 then goto continue_at_10 end
		if lt_u32(loc_0, 256) then goto continue_at_6 end
		loc_4 = load_i32(memory_at_0, param_1 + 36)
		::continue_at_14::
		loc_0 = load_i32(memory_at_0, loc_4 + 4)
		loc_5 = load_i32(memory_at_0, 54940)
		if loc_4 ~= 0 then
			loc_1 = loc_4
			if loc_0 == loc_5 then goto continue_at_18 end
		end
		loc_6 = load_i32(memory_at_0, 55020)
		loc_3 = load_i32(memory_at_0, 54900)
		loc_1 = loc_4
		::continue_at_20::
		while true do
			if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_6 and 1 or 0)) ~= 0 then
				goto continue_at_17
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_20 end
			if loc_0 ~= loc_5 then goto continue_at_20 end
			break
		end
		::continue_at_18::
		loc_6 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_6 == loc_0 then goto continue_at_17 end
		loc_8 = load_i32(memory_at_0, loc_1 + 24)
		loc_9 = load_i32(memory_at_0, param_0 + 68)
		if loc_8 == loc_9 then goto continue_at_17 end
		loc_1 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 12), 1)
		loc_0 = 0
		::continue_at_21::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_5 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_1, 12)))
			if loc_8 ~= loc_5 then
				if loc_5 == loc_9 then goto continue_at_17 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_21 end
				goto continue_at_17
			end
			break
		end
		loc_0 = add_i32(loc_6, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_4 end
		::continue_at_17::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_3 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_4, band_i32(loc_1, 255), 1)
			goto continue_at_3
		end
		store_i64(memory_at_0, loc_2, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_4, 8), 7407, loc_2)
		error("out of code bounds")
		::continue_at_11::
		store_i32(memory_at_0, loc_2 + 20, 255)
		store_i32(memory_at_0, loc_2 + 16, loc_1)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_2, 16))
		error("out of code bounds")
		::continue_at_10::
		FUNC_LIST[232](add_i32(loc_4, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_7::
		store_i64(memory_at_0, loc_2 + 32, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_2, 32))
		error("out of code bounds")
		::continue_at_6::
		loc_1 = load_i32(memory_at_0, param_1 + 28)
		reg_1 = (lt_u32(loc_1, 6) and add_i32(loc_1, 39) or 0)
		loc_1 = band_i32(loc_7, 255)
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), reg_1, loc_1, loc_1, band_i32(loc_0, 255)
		)
		goto continue_at_1
		::continue_at_5::
		::continue_at_24::
		while true do
			loc_1 = add_i32(loc_0, 1)
			FUNC_LIST[348](
				param_0, load_i32(memory_at_0, add_i32(loc_3, shl_i32(loc_0, 2))),
					band_i32(add_i32(loc_1, loc_4), 255), 1
			)
			loc_3 = load_i32(memory_at_0, loc_2 + 40)
			loc_5 = shr_i32(sub_i32(load_i32(memory_at_0, loc_2 + 44), loc_3), 2)
			loc_0 = loc_1
			if gt_u32(loc_5, loc_0) then goto continue_at_24 end
			break
		end
		goto continue_at_2
		::continue_at_4::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_3::
		loc_0 = load_i32(memory_at_0, param_1 + 28)
		reg_1 = (lt_u32(loc_0, 6) and add_i32(loc_0, 33) or 0)
		loc_0 = band_i32(loc_7, 255)
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), reg_1, loc_0, loc_0, band_i32(loc_1, 255)
		)
		goto continue_at_1
		::continue_at_2::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 49, band_i32(loc_7, 255), param_1,
				band_i32(add_i32(loc_4, loc_5), 255)
		)
		loc_0 = load_i32(memory_at_0, loc_2 + 40)
		if loc_0 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_2 + 44, loc_0)
		FUNC_LIST[1276](loc_0)
		::continue_at_1::
		if load_i32(memory_at_0, loc_2 + 56) ~= 0 then
			FUNC_LIST[355](param_0, add_i32(loc_2, 56), band_i32(loc_7, 255), 1)
		end
		store_i32(
			memory_at_0, load_i32(memory_at_0, loc_2 + 88) + 196,
				load_i32(memory_at_0, loc_2 + 92)
		)
		GLOBAL_LIST[0].value = add_i32(loc_2, 96)
	end
FUNC_LIST[336] = --[[ Luau::Compiler::compileStatFunction(Luau::AstStatFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_2
		loc_0 = load_i32(memory_at_0, param_1 + 28)
		loc_1 = load_i32(memory_at_0, loc_0 + 4)
		loc_5 = load_i32(memory_at_0, 54940)
		if (loc_1 == loc_5 and loc_0 or 0) == 0 then
			loc_4 = load_i32(memory_at_0, 55020)
			loc_3 = load_i32(memory_at_0, 54900)
			::continue_at_5::
			while true do
				if band_i32((loc_1 ~= loc_3 and 1 or 0), (loc_1 ~= loc_4 and 1 or 0)) ~= 0 then
					goto continue_at_3
				end
				loc_0 = load_i32(memory_at_0, loc_0 + 24)
				loc_1 = load_i32(memory_at_0, loc_0 + 4)
				if loc_0 == 0 then goto continue_at_5 end
				if loc_1 ~= loc_5 then goto continue_at_5 end
				break
			end
		end
		loc_4 = load_i32(memory_at_0, param_0 + 52)
		loc_3 = load_i32(memory_at_0, param_0 + 56)
		if loc_4 == loc_3 then goto continue_at_3 end
		loc_6 = load_i32(memory_at_0, loc_0 + 24)
		loc_7 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_7 then goto continue_at_3 end
		loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_3, loc_4), 12), 1)
		loc_0 = 0
		::continue_at_6::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_5 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_1, 12)))
			if loc_6 ~= loc_5 then
				if loc_5 == loc_7 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_6 end
				goto continue_at_3
			end
			break
		end
		loc_0 = add_i32(loc_4, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_2 end
		::continue_at_3::
		store_i32(memory_at_0, loc_2 + 40, param_0)
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		store_i32(memory_at_0, loc_2 + 44, loc_1)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_3 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
			)
			loc_0 = band_i32(loc_1, 255)
			FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 32), loc_0, 1)
			FUNC_LIST[353](
				add_i32(loc_2, 8), param_0, load_i32(memory_at_0, param_1 + 28),
					add_i32(loc_2, 40)
			)
			FUNC_LIST[355](param_0, add_i32(loc_2, 8), loc_0, 1)
			store_i32(
				memory_at_0, load_i32(memory_at_0, loc_2 + 40) + 196,
					load_i32(memory_at_0, loc_2 + 44)
			)
			goto continue_at_1
		end
		store_i64(memory_at_0, loc_2, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_2)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[348](
			param_0, load_i32(memory_at_0, param_1 + 32),
				load_i32_u8(memory_at_0, loc_0 + 4), 0
		)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_2, 48)
	end
FUNC_LIST[337] = --[[ Luau::Compiler::compileExprFunction(Luau::AstExprFunction*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0LL
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local reg_0, reg_1
		loc_10 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_10
		loc_14 = load_i32(memory_at_0, param_0 + 196)
		loc_4 = load_i32(memory_at_0, param_0 + 28)
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_4 == loc_0 then goto continue_at_1 end
		loc_7 = load_i32(memory_at_0, param_0 + 44)
		if loc_7 == param_1 then goto continue_at_1 end
		loc_3 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_4), 40), 1)
		loc_0 = 0
		::continue_at_2::
		while true do
			loc_6 = band_i32(loc_2, loc_3)
			loc_1 = add_i32(loc_4, mul_i32(loc_6, 40))
			loc_3 = load_i32(memory_at_0, loc_1)
			if loc_3 == param_1 then goto continue_at_1 end
			loc_1 = 0
			if loc_3 == loc_7 then goto continue_at_1 end
			loc_0 = add_i32(loc_0, 1)
			loc_3 = add_i32(loc_0, loc_6)
			if le_u32(loc_0, loc_2) then goto continue_at_2 end
			break
		end
		::continue_at_1::
		loc_9 = (loc_1 ~= 0 and add_i32(loc_1, 8) or 0)
		reg_0 = FUNC_LIST[111](
			load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_9)
		)
		loc_15 = reg_0
		if loc_15 >= 0 then
			loc_0 = load_i32(memory_at_0, param_0 + 268)
			store_i32(memory_at_0, param_0 + 272, loc_0)
			loc_5 = add_i32(param_0, 268)
			loc_1 = sub_i32(
				load_i32(memory_at_0, loc_9 + 8), load_i32(memory_at_0, loc_9 + 4)
			)
			loc_3 = shr_i32(loc_1, 2)
			if le_u32(
				loc_3, shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 276), loc_0), 3)
			) then goto continue_at_5 end
			if ge_u32(loc_1, 2147483645) then goto continue_at_4 end
			reg_1 = FUNC_LIST[1275](shl_i32(loc_1, 1))
			loc_1 = reg_1
			store_i32(memory_at_0, loc_5 + 4, loc_1)
			store_i32(memory_at_0, loc_5, loc_1)
			store_i32(memory_at_0, loc_5 + 8, add_i32(loc_1, shl_i32(loc_3, 3)))
			if loc_0 == 0 then goto continue_at_5 end
			FUNC_LIST[1276](loc_0)
			::continue_at_5::
			loc_11 = load_i32(memory_at_0, loc_9 + 4)
			loc_16 = load_i32(memory_at_0, loc_9 + 8)
			if loc_11 ~= loc_16 then
				::continue_at_9::
				while true do
					loc_0 = load_i32(memory_at_0, loc_11)
					loc_4 = load_i32(memory_at_0, param_0 + 52)
					loc_1 = load_i32(memory_at_0, param_0 + 56)
					if loc_4 == loc_1 then goto continue_at_11 end
					loc_7 = load_i32(memory_at_0, param_0 + 68)
					if loc_7 == loc_0 then goto continue_at_11 end
					loc_3 = sub_i32(div_i32(sub_i32(loc_1, loc_4), 12), 1)
					loc_1 = 0
					loc_12 = bxor_i32(shr_u32(loc_0, 4), shr_u32(loc_0, 9))
					loc_2 = loc_12
					::continue_at_12::
					while true do
						loc_6 = band_i32(loc_2, loc_3)
						loc_8 = add_i32(loc_4, mul_i32(loc_6, 12))
						loc_2 = load_i32(memory_at_0, loc_8)
						if loc_0 ~= loc_2 then
							if loc_2 == loc_7 then goto continue_at_11 end
							loc_1 = add_i32(loc_1, 1)
							loc_2 = add_i32(loc_1, loc_6)
							if le_u32(loc_1, loc_3) then goto continue_at_12 end
							goto continue_at_11
						end
						break
					end
					if load_i32_u8(memory_at_0, loc_8 + 5) == 0 then goto continue_at_11 end
					loc_13 = load_i64_u8(memory_at_0, loc_8 + 4)
					loc_4 = load_i32(memory_at_0, param_0 + 100)
					loc_1 = load_i32(memory_at_0, param_0 + 104)
					if loc_4 == loc_1 then
						loc_2 = 1
						goto continue_at_14
					end
					loc_7 = load_i32(memory_at_0, param_0 + 116)
					if loc_7 == loc_0 then
						loc_2 = 1
						goto continue_at_14
					end
					loc_3 = sub_i32(div_i32(sub_i32(loc_1, loc_4), 12), 1)
					loc_1 = 0
					::continue_at_17::
					while true do
						loc_6 = band_i32(loc_3, loc_12)
						loc_8 = add_i32(loc_4, mul_i32(loc_6, 12))
						loc_2 = load_i32(memory_at_0, loc_8)
						if loc_0 ~= loc_2 then
							if loc_2 == loc_7 then
								loc_2 = 1
								goto continue_at_14
							end
							loc_2 = 1
							loc_1 = add_i32(loc_1, 1)
							loc_12 = add_i32(loc_1, loc_6)
							if le_u32(loc_1, loc_3) then goto continue_at_17 end
							goto continue_at_14
						end
						break
					end
					loc_2 = bxor_i32(load_i32_u8(memory_at_0, loc_8 + 8), 1)
					::continue_at_14::
					loc_3 = band_i32(bxor_i32(loc_2, -1), 1)
					loc_0 = load_i32(memory_at_0, loc_5 + 4)
					loc_2 = load_i32(memory_at_0, loc_5 + 8)
					if lt_u32(loc_0, loc_2) then
						store_i64(
							memory_at_0, loc_0,
								bor_i64(extend_i64_u32(loc_3), shl_i64(loc_13, 32LL ))
						)
						store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, 8))
						goto continue_at_10
					end
					loc_1 = load_i32(memory_at_0, loc_5)
					loc_6 = sub_i32(loc_0, loc_1)
					loc_4 = shr_i32(loc_6, 3)
					loc_0 = add_i32(loc_4, 1)
					if ge_u32(loc_0, 536870912) then goto continue_at_7 end
					loc_2 = sub_i32(loc_2, loc_1)
					loc_7 = shr_i32(loc_2, 2)
					loc_2 = (lt_u32(loc_2, 2147483640) and
						        (lt_u32(loc_0, loc_7) and loc_7 or loc_0) or 536870911)
					if loc_2 ~= 0 then
						if ge_u32(loc_2, 536870912) then goto continue_at_21 end
						reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
					else
						reg_0 = 0
					end
					loc_0 = reg_0
					loc_4 = add_i32(loc_0, shl_i32(loc_4, 3))
					store_i64(
						memory_at_0, loc_4,
							bor_i64(extend_i64_u32(loc_3), shl_i64(loc_13, 32LL ))
					)
					loc_3 = add_i32(loc_0, shl_i32(loc_2, 3))
					loc_2 = add_i32(loc_4, 8)
					if loc_6 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_6) end
					store_i32(memory_at_0, loc_5 + 8, loc_3)
					store_i32(memory_at_0, loc_5 + 4, loc_2)
					store_i32(memory_at_0, loc_5, loc_0)
					if loc_1 == 0 then goto continue_at_10 end
					FUNC_LIST[1276](loc_1)
					goto continue_at_10
					::continue_at_21::
					FUNC_LIST[252](5133)
					error("out of code bounds")
					::continue_at_11::
					loc_4 = load_i32(memory_at_0, param_0 + 148)
					loc_1 = load_i32(memory_at_0, param_0 + 152)
					if loc_4 == loc_1 then goto continue_at_25 end
					loc_7 = load_i32(memory_at_0, param_0 + 164)
					if loc_0 == loc_7 then goto continue_at_25 end
					loc_3 = bxor_i32(shr_u32(loc_0, 4), shr_u32(loc_0, 9))
					loc_2 = sub_i32(div_i32(sub_i32(loc_1, loc_4), 24), 1)
					loc_1 = 0
					::continue_at_26::
					while true do
						loc_6 = band_i32(loc_2, loc_3)
						loc_8 = add_i32(loc_4, mul_i32(loc_6, 24))
						loc_3 = load_i32(memory_at_0, loc_8)
						if loc_0 ~= loc_3 then
							if loc_3 == loc_7 then goto continue_at_25 end
							loc_1 = add_i32(loc_1, 1)
							loc_3 = add_i32(loc_1, loc_6)
							if le_u32(loc_1, loc_2) then goto continue_at_26 end
							goto continue_at_25
						end
						break
					end
					if load_i32(memory_at_0, loc_8 + 8) == 0 then goto continue_at_25 end
					loc_1 = load_i32(memory_at_0, param_0 + 196)
					loc_0 = add_i32(loc_1, 1)
					if lt_u32(loc_0, 256) then
						store_i32(memory_at_0, param_0 + 196, loc_0)
						loc_3 = load_i32(memory_at_0, param_0 + 200)
						store_i32(
							memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
						)
						loc_3 = band_i32(loc_1, 255)
						FUNC_LIST[358](param_0, param_1, add_i32(loc_8, 8), loc_3)
						loc_0 = load_i32(memory_at_0, param_0 + 272)
						loc_2 = load_i32(memory_at_0, param_0 + 276)
						if lt_u32(loc_0, loc_2) then
							store_i64(
								memory_at_0, loc_0, shl_i64(extend_i64_u32(loc_3), 32LL )
							)
							store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, 8))
							goto continue_at_10
						end
						loc_1 = load_i32(memory_at_0, loc_5)
						loc_6 = sub_i32(loc_0, loc_1)
						loc_4 = shr_i32(loc_6, 3)
						loc_0 = add_i32(loc_4, 1)
						if ge_u32(loc_0, 536870912) then goto continue_at_7 end
						loc_2 = sub_i32(loc_2, loc_1)
						loc_7 = shr_i32(loc_2, 2)
						loc_2 = (lt_u32(loc_2, 2147483640) and
							        (lt_u32(loc_0, loc_7) and loc_7 or loc_0) or 536870911)
						if loc_2 ~= 0 then
							if ge_u32(loc_2, 536870912) then goto continue_at_28 end
							reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
						else
							reg_0 = 0
						end
						loc_0 = reg_0
						loc_4 = add_i32(loc_0, shl_i32(loc_4, 3))
						store_i64(memory_at_0, loc_4, shl_i64(extend_i64_u32(loc_3), 32LL ))
						loc_3 = add_i32(loc_0, shl_i32(loc_2, 3))
						loc_2 = add_i32(loc_4, 8)
						if loc_6 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_6) end
						store_i32(memory_at_0, loc_5 + 8, loc_3)
						store_i32(memory_at_0, loc_5 + 4, loc_2)
						store_i32(memory_at_0, loc_5, loc_0)
						if loc_1 == 0 then goto continue_at_10 end
						FUNC_LIST[1276](loc_1)
						goto continue_at_10
					end
					store_i64(memory_at_0, loc_10, 1095216660481LL )
					FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_10)
					error("out of code bounds")
					::continue_at_28::
					FUNC_LIST[252](5133)
					error("out of code bounds")
					::continue_at_25::
					reg_0 = FUNC_LIST[241](param_0, loc_0)
					loc_3 = reg_0
					loc_0 = load_i32(memory_at_0, param_0 + 272)
					loc_2 = load_i32(memory_at_0, param_0 + 276)
					if lt_u32(loc_0, loc_2) then
						store_i64(
							memory_at_0, loc_0,
								bor_i64(shl_i64(extend_i64_u32(loc_3), 32LL ), 2LL )
						)
						store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, 8))
						goto continue_at_10
					end
					loc_1 = load_i32(memory_at_0, loc_5)
					loc_6 = sub_i32(loc_0, loc_1)
					loc_4 = shr_i32(loc_6, 3)
					loc_0 = add_i32(loc_4, 1)
					if ge_u32(loc_0, 536870912) then goto continue_at_7 end
					loc_2 = sub_i32(loc_2, loc_1)
					loc_7 = shr_i32(loc_2, 2)
					loc_2 = (lt_u32(loc_2, 2147483640) and
						        (lt_u32(loc_0, loc_7) and loc_7 or loc_0) or 536870911)
					if loc_2 ~= 0 then
						if ge_u32(loc_2, 536870912) then goto continue_at_6 end
						reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
					else
						reg_0 = 0
					end
					loc_0 = reg_0
					loc_4 = add_i32(loc_0, shl_i32(loc_4, 3))
					store_i64(
						memory_at_0, loc_4,
							bor_i64(shl_i64(extend_i64_u32(loc_3), 32LL ), 2LL )
					)
					loc_3 = add_i32(loc_0, shl_i32(loc_2, 3))
					loc_2 = add_i32(loc_4, 8)
					if loc_6 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_6) end
					store_i32(memory_at_0, loc_5 + 8, loc_3)
					store_i32(memory_at_0, loc_5 + 4, loc_2)
					store_i32(memory_at_0, loc_5, loc_0)
					if loc_1 == 0 then goto continue_at_10 end
					FUNC_LIST[1276](loc_1)
					::continue_at_10::
					loc_11 = add_i32(loc_11, 4)
					if loc_11 ~= loc_16 then goto continue_at_9 end
					break
				end
			end
			if load_i32(memory_at_0, param_0 + 4) <= 0 then goto continue_at_39 end
			reg_0 = FUNC_LIST[359](param_0, param_1)
			if reg_0 == 0 then goto continue_at_39 end
			if load_i32_u8(memory_at_0, param_0 + 205) ~= 0 then goto continue_at_39 end
			reg_0 = FUNC_LIST[110](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_9)
			)
			loc_0 = reg_0
			if gt_u32(loc_0, 32767) then goto continue_at_39 end
			FUNC_LIST[116](
				load_i32(memory_at_0, param_0), 64, param_2, shr_i32(shl_i32(loc_0, 16), 16)
			)
			goto continue_at_38
			::continue_at_39::
			FUNC_LIST[116](load_i32(memory_at_0, param_0), 19, param_2, loc_15)
			::continue_at_38::
			loc_0 = load_i32(memory_at_0, loc_5)
			loc_1 = load_i32(memory_at_0, loc_5 + 4)
			if loc_0 ~= loc_1 then
				::continue_at_41::
				while true do
					FUNC_LIST[114](
						load_i32(memory_at_0, param_0), 70, load_i32_u8(memory_at_0, loc_0),
							load_i32_u8(memory_at_0, loc_0 + 4), 0
					)
					loc_0 = add_i32(loc_0, 8)
					if loc_0 ~= loc_1 then goto continue_at_41 end
					break
				end
			end
			store_i32(memory_at_0, param_0 + 196, loc_14)
			GLOBAL_LIST[0].value = add_i32(loc_10, 16)
			goto continue_at_0
			::continue_at_7::
			FUNC_LIST[360](loc_5)
			error("out of code bounds")
			::continue_at_6::
			FUNC_LIST[252](5133)
			error("out of code bounds")
			::continue_at_4::
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6128, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[338] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::Compiler::Local, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::operator[](Luau::AstLocal* const&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_3 = load_i32(memory_at_0, param_0)
		loc_0 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_3), 12)
		if ge_u32(load_i32(memory_at_0, param_0 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
			FUNC_LIST[321](param_0)
			loc_3 = load_i32(memory_at_0, param_0)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_3), 12)
		end
		loc_1 = load_i32(memory_at_0, param_1)
		param_1 = bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9))
		loc_4 = sub_i32(loc_0, 1)
		loc_5 = load_i32(memory_at_0, param_0 + 16)
		loc_0 = 0
		::continue_at_3::
		while true do
			loc_6 = band_i32(param_1, loc_4)
			loc_2 = add_i32(loc_3, mul_i32(loc_6, 12))
			param_1 = load_i32(memory_at_0, loc_2)
			if loc_5 == param_1 then
				store_i32(memory_at_0, loc_2, loc_1)
				store_i32(
					memory_at_0, param_0 + 12, add_i32(load_i32(memory_at_0, param_0 + 12), 1)
				)
				goto continue_at_2
			end
			if param_1 == loc_1 then goto continue_at_2 end
			loc_0 = add_i32(loc_0, 1)
			param_1 = add_i32(loc_0, loc_6)
			if le_u32(loc_0, loc_4) then goto continue_at_3 end
			break
		end
		loc_2 = 0
		::continue_at_2::
		reg_0 = add_i32(loc_2, 4)
		return reg_0
	end
FUNC_LIST[339] = --[[ std::__2::__vector_base<Luau::Compiler::LoopJump, std::__2::allocator<Luau::Compiler::LoopJump> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[340] = --[[ std::__2::vector<Luau::AstLocal*, std::__2::allocator<Luau::AstLocal*> >::__append(unsigned long) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_1, loc_0), 2)) then
			if param_1 ~= 0 then
				param_1 = shl_i32(param_1, 2)
				reg_0 = FUNC_LIST[1121](loc_0, 0, param_1)
				loc_0 = add_i32(reg_0, param_1)
			end
			store_i32(memory_at_0, param_0 + 4, loc_0)
			goto continue_at_0
		end
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = sub_i32(loc_0, loc_2)
		loc_5 = shr_i32(loc_3, 2)
		loc_4 = add_i32(loc_5, param_1)
		if lt_u32(loc_4, 1073741824) then
			loc_0 = 0
			loc_1 = sub_i32(loc_1, loc_2)
			loc_6 = shr_i32(loc_1, 1)
			loc_1 = (lt_u32(loc_1, 2147483644) and
				        (lt_u32(loc_4, loc_6) and loc_6 or loc_4) or 1073741823)
			if loc_1 ~= 0 then
				if ge_u32(loc_1, 1073741824) then goto continue_at_3 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
				loc_0 = reg_0
			end
			param_1 = shl_i32(param_1, 2)
			reg_0 = FUNC_LIST[1121](add_i32(loc_0, shl_i32(loc_5, 2)), 0, param_1)
			param_1 = add_i32(reg_0, param_1)
			loc_1 = add_i32(loc_0, shl_i32(loc_1, 2))
			if loc_3 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_3) end
			store_i32(memory_at_0, param_0 + 8, loc_1)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_0)
			if loc_2 ~= 0 then FUNC_LIST[1276](loc_2) end
			goto continue_at_0
		end
		FUNC_LIST[250](param_0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[341] = --[[ Luau::Compiler::compileConditionValue(Luau::AstExpr*, unsigned char const*, std::__2::vector<unsigned long, std::__2::allocator<unsigned long> >&, bool) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_6 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_6
		::continue_at_7::
		while true do
			loc_3 = load_i32(memory_at_0, param_0 + 124)
			loc_0 = load_i32(memory_at_0, param_0 + 128)
			if loc_3 == loc_0 then goto continue_at_8 end
			loc_5 = load_i32(memory_at_0, param_0 + 140)
			if loc_5 == param_1 then goto continue_at_8 end
			loc_1 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
			loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 24), 1)
			loc_0 = 0
			::continue_at_9::
			while true do
				loc_4 = band_i32(loc_1, loc_2)
				loc_7 = add_i32(loc_3, mul_i32(loc_4, 24))
				loc_1 = load_i32(memory_at_0, loc_7)
				if param_1 ~= loc_1 then
					if loc_1 == loc_5 then goto continue_at_8 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_4)
					if le_u32(loc_0, loc_2) then goto continue_at_9 end
					goto continue_at_8
				end
				break
			end
			loc_0 = load_i32(memory_at_0, loc_7 + 8)
			if loc_0 == 0 then goto continue_at_8 end
			if not br_map[1] then br_map[1] = (function() return { [0] = 1, 2 } end)() end
			temp = br_map[1][sub_i32(loc_0, 1)] or 0
			if temp < 1 then
				goto continue_at_14
			elseif temp > 1 then
				goto continue_at_12
			else
				goto continue_at_13
			end
			::continue_at_14::
			if band_i32(param_4, 1) ~= 0 then goto continue_at_11 end
			goto continue_at_3
			::continue_at_13::
			if band_i32(param_4, 1) == 0 then goto continue_at_11 end
			goto continue_at_3
			::continue_at_12::
			if band_i32(
				bxor_i32(
					param_4,
						(load_i32_u8(memory_at_0, add_i32(loc_3, mul_i32(loc_4, 24)) + 16) ~= 0 and
							1 or 0)
				), 1
			) ~= 0 then goto continue_at_3 end
			::continue_at_11::
			if param_2 ~= 0 then
				FUNC_LIST[348](param_0, param_1, load_i32_u8(memory_at_0, param_2), 1)
			end
			reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
			loc_1 = reg_0
			loc_0 = load_i32(memory_at_0, param_3 + 4)
			loc_2 = load_i32(memory_at_0, param_3 + 8)
			if lt_u32(loc_0, loc_2) then
				store_i32(memory_at_0, loc_0, loc_1)
				store_i32(memory_at_0, param_3 + 4, add_i32(loc_0, 4))
				goto continue_at_17
			end
			param_1 = load_i32(memory_at_0, param_3)
			loc_4 = sub_i32(loc_0, param_1)
			loc_3 = shr_i32(loc_4, 2)
			loc_0 = add_i32(loc_3, 1)
			if ge_u32(loc_0, 1073741824) then goto continue_at_2 end
			loc_2 = sub_i32(loc_2, param_1)
			loc_5 = shr_i32(loc_2, 1)
			loc_2 = (lt_u32(loc_2, 2147483644) and
				        (lt_u32(loc_0, loc_5) and loc_5 or loc_0) or 1073741823)
			if loc_2 ~= 0 then
				if ge_u32(loc_2, 1073741824) then goto continue_at_16 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 2))
			else
				reg_0 = 0
			end
			loc_0 = reg_0
			loc_3 = add_i32(loc_0, shl_i32(loc_3, 2))
			store_i32(memory_at_0, loc_3, loc_1)
			loc_1 = add_i32(loc_0, shl_i32(loc_2, 2))
			loc_2 = add_i32(loc_3, 4)
			if loc_4 > 0 then reg_0 = FUNC_LIST[1119](loc_0, param_1, loc_4) end
			store_i32(memory_at_0, param_3 + 8, loc_1)
			store_i32(memory_at_0, param_3 + 4, loc_2)
			store_i32(memory_at_0, param_3, loc_0)
			if param_1 == 0 then goto continue_at_17 end
			FUNC_LIST[1276](param_1)
			::continue_at_17::
			FUNC_LIST[116](load_i32(memory_at_0, param_0), 23, 0, 0)
			goto continue_at_3
			::continue_at_16::
			FUNC_LIST[252](5133)
			error("out of code bounds")
			::continue_at_8::
			loc_0 = load_i32(memory_at_0, param_1 + 4)
			if param_1 == 0 then goto continue_at_22 end
			if loc_0 ~= load_i32(memory_at_0, 55012) then goto continue_at_22 end
			loc_1 = load_i32(memory_at_0, param_1 + 24)
			if not br_map[2] then
				br_map[2] = (function() return { [0] = 1, 1, 1, 1, 1, 1, 0, 0 } end)()
			end
			temp = br_map[2][sub_i32(loc_1, 7)] or 2
			if temp < 1 then
				goto continue_at_24
			elseif temp > 1 then
				goto continue_at_22
			else
				goto continue_at_23
			end
			::continue_at_24::
			loc_0 = band_i32(param_4, 1)
			if loc_0 ~= (loc_1 ~= 13 and 1 or 0) then
				store_i32(memory_at_0, loc_6 + 24, 0)
				store_i64(memory_at_0, loc_6 + 16, 0LL )
				FUNC_LIST[341](
					param_0, load_i32(memory_at_0, param_1 + 28), 0, add_i32(loc_6, 16),
						band_i32(bxor_i32(param_4, -1), 1)
				)
				FUNC_LIST[341](
					param_0, load_i32(memory_at_0, param_1 + 32), param_2, param_3,
						band_i32(param_4, 1)
				)
				reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
				loc_1 = reg_0
				loc_0 = load_i32(memory_at_0, loc_6 + 16)
				loc_2 = load_i32(memory_at_0, loc_6 + 20)
				if loc_0 ~= loc_2 then
					::continue_at_28::
					while true do
						reg_0 = FUNC_LIST[119](
							load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_1
						)
						if reg_0 ~= 0 then
							loc_0 = add_i32(loc_0, 4)
							if loc_2 ~= loc_0 then goto continue_at_28 end
							goto continue_at_27
						end
						break
					end
					FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
					error("out of code bounds")
					::continue_at_27::
					loc_0 = load_i32(memory_at_0, loc_6 + 16)
				end
				if loc_0 == 0 then goto continue_at_3 end
				store_i32(memory_at_0, loc_6 + 20, loc_0)
				FUNC_LIST[1276](loc_0)
				goto continue_at_3
			end
			FUNC_LIST[341](
				param_0, load_i32(memory_at_0, param_1 + 28), param_2, param_3, loc_0
			)
			param_1 = load_i32(memory_at_0, param_1 + 32)
			goto continue_at_7
			::continue_at_23::
			if param_2 ~= 0 then
				FUNC_LIST[114](
					load_i32(memory_at_0, param_0), 3, load_i32_u8(memory_at_0, param_2),
						band_i32(param_4, 1), 0
				)
			end
			reg_0 = FUNC_LIST[361](param_0, param_1, band_i32(bxor_i32(param_4, -1), 1))
			param_1 = reg_0
			loc_0 = load_i32(memory_at_0, param_3 + 4)
			if loc_0 ~= load_i32(memory_at_0, param_3 + 8) then
				store_i32(memory_at_0, loc_0, param_1)
				store_i32(memory_at_0, param_3 + 4, add_i32(loc_0, 4))
				goto continue_at_3
			end
			loc_2 = load_i32(memory_at_0, param_3)
			loc_0 = sub_i32(loc_0, loc_2)
			loc_3 = shr_i32(loc_0, 2)
			loc_1 = add_i32(loc_3, 1)
			if ge_u32(loc_1, 1073741824) then goto continue_at_2 end
			loc_4 = shr_i32(loc_0, 1)
			loc_4 = (lt_u32(loc_0, 2147483644) and
				        (lt_u32(loc_1, loc_4) and loc_4 or loc_1) or 1073741823)
			if loc_4 ~= 0 then
				if ge_u32(loc_4, 1073741824) then goto continue_at_6 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_4, 2))
			else
				reg_0 = 0
			end
			loc_1 = reg_0
			loc_3 = add_i32(loc_1, shl_i32(loc_3, 2))
			store_i32(memory_at_0, loc_3, param_1)
			param_1 = add_i32(loc_1, shl_i32(loc_4, 2))
			loc_4 = add_i32(loc_3, 4)
			if loc_0 > 0 then reg_0 = FUNC_LIST[1119](loc_1, loc_2, loc_0) end
			store_i32(memory_at_0, param_3 + 8, param_1)
			store_i32(memory_at_0, param_3 + 4, loc_4)
			store_i32(memory_at_0, param_3, loc_1)
			if loc_2 == 0 then goto continue_at_3 end
			FUNC_LIST[1276](loc_2)
			goto continue_at_3
			::continue_at_22::
			if param_2 ~= 0 then goto continue_at_35 end
			loc_1 = (loc_0 == load_i32(memory_at_0, 55004) and param_1 or 0)
			if loc_1 == 0 then goto continue_at_35 end
			if load_i32(memory_at_0, loc_1 + 24) ~= 0 then goto continue_at_35 end
			param_4 = bxor_i32(param_4, 1)
			param_1 = load_i32(memory_at_0, loc_1 + 28)
			param_2 = 0
			goto continue_at_7
			::continue_at_35::
			loc_1 = load_i32(memory_at_0, 54900)
			if param_1 == 0 then goto continue_at_36 end
			if loc_0 ~= loc_1 then goto continue_at_36 end
			param_1 = load_i32(memory_at_0, param_1 + 24)
			goto continue_at_7
			::continue_at_36::
			break
		end
		loc_4 = load_i32(memory_at_0, param_0 + 196)
		if param_2 ~= 0 then
			loc_1 = load_i32_u8(memory_at_0, param_2)
			FUNC_LIST[348](param_0, param_1, loc_1, 1)
			goto continue_at_4
		end
		loc_2 = param_1
		loc_3 = load_i32(memory_at_0, 54940)
		if loc_3 ~= loc_0 then
			loc_5 = load_i32(memory_at_0, 55020)
			::continue_at_40::
			while true do
				if band_i32((loc_0 ~= loc_1 and 1 or 0), (loc_0 ~= loc_5 and 1 or 0)) ~= 0 then
					goto continue_at_38
				end
				loc_2 = load_i32(memory_at_0, loc_2 + 24)
				loc_0 = load_i32(memory_at_0, loc_2 + 4)
				if loc_2 == 0 then goto continue_at_40 end
				if loc_0 ~= loc_3 then goto continue_at_40 end
				break
			end
		end
		loc_5 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_5 == loc_0 then goto continue_at_38 end
		loc_7 = load_i32(memory_at_0, loc_2 + 24)
		param_2 = load_i32(memory_at_0, param_0 + 68)
		if loc_7 == param_2 then goto continue_at_38 end
		loc_1 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 12), 1)
		loc_0 = 0
		::continue_at_41::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_3 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 12)))
			if loc_7 ~= loc_3 then
				if param_2 == loc_3 then goto continue_at_38 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_41 end
				goto continue_at_38
			end
			break
		end
		loc_0 = add_i32(loc_5, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_5 end
		::continue_at_38::
		loc_0 = add_i32(loc_4, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			FUNC_LIST[348](param_0, param_1, band_i32(loc_4, 255), 1)
			loc_1 = loc_4
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_6, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_6)
		error("out of code bounds")
		::continue_at_6::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_5::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_4::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		loc_0 = load_i32(memory_at_0, param_3 + 4)
		loc_3 = load_i32(memory_at_0, param_3 + 8)
		if lt_u32(loc_0, loc_3) then
			store_i32(memory_at_0, loc_0, loc_2)
			store_i32(memory_at_0, param_3 + 4, add_i32(loc_0, 4))
			goto continue_at_44
		end
		param_1 = load_i32(memory_at_0, param_3)
		loc_5 = sub_i32(loc_0, param_1)
		loc_7 = shr_i32(loc_5, 2)
		loc_0 = add_i32(loc_7, 1)
		if ge_u32(loc_0, 1073741824) then goto continue_at_2 end
		loc_3 = sub_i32(loc_3, param_1)
		param_2 = shr_i32(loc_3, 1)
		loc_3 = (lt_u32(loc_3, 2147483644) and
			        (gt_u32(param_2, loc_0) and param_2 or loc_0) or 1073741823)
		if loc_3 ~= 0 then
			if ge_u32(loc_3, 1073741824) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 2))
		else
			reg_0 = 0
		end
		loc_0 = reg_0
		loc_7 = add_i32(loc_0, shl_i32(loc_7, 2))
		store_i32(memory_at_0, loc_7, loc_2)
		loc_2 = add_i32(loc_0, shl_i32(loc_3, 2))
		loc_3 = add_i32(loc_7, 4)
		if loc_5 > 0 then reg_0 = FUNC_LIST[1119](loc_0, param_1, loc_5) end
		store_i32(memory_at_0, param_3 + 8, loc_2)
		store_i32(memory_at_0, param_3 + 4, loc_3)
		store_i32(memory_at_0, param_3, loc_0)
		if param_1 == 0 then goto continue_at_44 end
		FUNC_LIST[1276](param_1)
		::continue_at_44::
		FUNC_LIST[116](
			load_i32(memory_at_0, param_0), (band_i32(param_4, 1) ~= 0 and 25 or 26),
				band_i32(loc_1, 255), 0
		)
		store_i32(memory_at_0, param_0 + 196, loc_4)
		::continue_at_3::
		GLOBAL_LIST[0].value = add_i32(loc_6, 32)
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[346](param_3)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[342] = --[[ Luau::Compiler::patchLoopJumps(Luau::AstNode*, unsigned long, unsigned long, unsigned long) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_0 = load_i32(memory_at_0, param_0 + 232)
		if lt_u32(
			param_2, shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 236), loc_0), 3)
		) then
			::continue_at_3::
			while true do
				loc_0 = add_i32(loc_0, shl_i32(param_2, 3))
				if not br_map[1] then
					br_map[1] = (function() return { [0] = 0, 1 } end)()
				end
				temp = br_map[1][load_i32(memory_at_0, loc_0)] or 2
				if temp < 1 then
					goto continue_at_6
				elseif temp > 1 then
					goto continue_at_4
				else
					goto continue_at_5
				end
				::continue_at_6::
				reg_0 = FUNC_LIST[119](
					load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0 + 4), param_3
				)
				if reg_0 ~= 0 then goto continue_at_4 end
				FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
				error("out of code bounds")
				::continue_at_5::
				reg_0 = FUNC_LIST[119](
					load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0 + 4), param_4
				)
				if reg_0 == 0 then goto continue_at_1 end
				::continue_at_4::
				param_2 = add_i32(param_2, 1)
				loc_0 = load_i32(memory_at_0, param_0 + 232)
				if lt_u32(
					param_2, shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 236), loc_0), 3)
				) then goto continue_at_3 end
				break
			end
		end
		goto continue_at_0
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[343] = --[[ std::__2::vector<Luau::Compiler::LoopJump, std::__2::allocator<Luau::Compiler::LoopJump> >::__append(unsigned long) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if le_u32(param_1, shr_i32(sub_i32(loc_1, loc_0), 3)) then
			if param_1 ~= 0 then
				param_1 = shl_i32(param_1, 3)
				reg_0 = FUNC_LIST[1121](loc_0, 0, param_1)
				loc_0 = add_i32(reg_0, param_1)
			end
			store_i32(memory_at_0, param_0 + 4, loc_0)
			goto continue_at_0
		end
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = sub_i32(loc_0, loc_2)
		loc_5 = shr_i32(loc_3, 3)
		loc_4 = add_i32(loc_5, param_1)
		if lt_u32(loc_4, 536870912) then
			loc_0 = 0
			loc_1 = sub_i32(loc_1, loc_2)
			loc_6 = shr_i32(loc_1, 2)
			loc_1 = (lt_u32(loc_1, 2147483640) and
				        (lt_u32(loc_4, loc_6) and loc_6 or loc_4) or 536870911)
			if loc_1 ~= 0 then
				if ge_u32(loc_1, 536870912) then goto continue_at_3 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
				loc_0 = reg_0
			end
			param_1 = shl_i32(param_1, 3)
			reg_0 = FUNC_LIST[1121](add_i32(loc_0, shl_i32(loc_5, 3)), 0, param_1)
			param_1 = add_i32(reg_0, param_1)
			loc_1 = add_i32(loc_0, shl_i32(loc_1, 3))
			if loc_3 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_3) end
			store_i32(memory_at_0, param_0 + 8, loc_1)
			store_i32(memory_at_0, param_0 + 4, param_1)
			store_i32(memory_at_0, param_0, loc_0)
			if loc_2 ~= 0 then FUNC_LIST[1276](loc_2) end
			goto continue_at_0
		end
		FUNC_LIST[339](param_0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[344] = --[[ std::__2::__vector_base<Luau::Compiler::Loop, std::__2::allocator<Luau::Compiler::Loop> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[345] = --[[ Luau::Compiler::compileExprListTemp(Luau::AstArray<Luau::AstExpr*> const&, unsigned char, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local br_map, temp = {}, nil
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_5
		loc_3 = load_i32(memory_at_0, param_1 + 4)
		if param_3 == loc_3 then
			if loc_3 == 0 then goto continue_at_1 end
			::continue_at_3::
			while true do
				FUNC_LIST[348](
					param_0, load_i32(
						memory_at_0, add_i32(load_i32(memory_at_0, param_1), shl_i32(loc_0, 2))
					), band_i32(add_i32(param_2, loc_0), 255), 1
				)
				loc_0 = add_i32(loc_0, 1)
				if lt_u32(loc_0, load_i32(memory_at_0, param_1 + 4)) then
					goto continue_at_3
				end
				break
			end
			goto continue_at_1
		end
		if lt_u32(param_3, loc_3) then
			if param_3 ~= 0 then
				::continue_at_6::
				while true do
					FUNC_LIST[348](
						param_0, load_i32(
							memory_at_0, add_i32(load_i32(memory_at_0, param_1), shl_i32(loc_0, 2))
						), band_i32(add_i32(param_2, loc_0), 255), 1
					)
					loc_0 = add_i32(loc_0, 1)
					if loc_0 ~= param_3 then goto continue_at_6 end
					break
				end
				loc_3 = load_i32(memory_at_0, param_1 + 4)
			end
			if ge_u32(param_3, loc_3) then goto continue_at_1 end
			loc_2 = load_i32(memory_at_0, 54940)
			loc_8 = load_i32(memory_at_0, param_0 + 196)
			loc_6 = add_i32(loc_8, 1)
			loc_10 = (lt_u32(loc_6, 256) and 1 or 0)
			loc_11 = band_i32(loc_8, 255)
			::continue_at_7::
			while true do
				loc_4 = load_i32(
					memory_at_0, add_i32(load_i32(memory_at_0, param_1), shl_i32(param_3, 2))
				)
				loc_0 = load_i32(memory_at_0, loc_4 + 4)
				if loc_4 ~= 0 then
					param_2 = loc_4
					if loc_0 == loc_2 then goto continue_at_11 end
				end
				param_4 = load_i32(memory_at_0, 55020)
				loc_1 = load_i32(memory_at_0, 54900)
				param_2 = loc_4
				::continue_at_13::
				while true do
					if band_i32((loc_0 ~= loc_1 and 1 or 0), (param_4 ~= loc_0 and 1 or 0)) ~=
						0 then goto continue_at_10 end
					param_2 = load_i32(memory_at_0, param_2 + 24)
					loc_0 = load_i32(memory_at_0, param_2 + 4)
					if param_2 == 0 then goto continue_at_13 end
					if loc_0 ~= loc_2 then goto continue_at_13 end
					break
				end
				::continue_at_11::
				loc_9 = load_i32(memory_at_0, param_0 + 52)
				loc_0 = load_i32(memory_at_0, param_0 + 56)
				if loc_9 == loc_0 then goto continue_at_10 end
				loc_7 = load_i32(memory_at_0, param_2 + 24)
				loc_12 = load_i32(memory_at_0, param_0 + 68)
				if loc_7 == loc_12 then goto continue_at_10 end
				param_2 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
				loc_1 = sub_i32(div_i32(sub_i32(loc_0, loc_9), 12), 1)
				loc_0 = 0
				::continue_at_14::
				while true do
					param_4 = band_i32(param_2, loc_1)
					loc_13 = add_i32(loc_9, mul_i32(param_4, 12))
					param_2 = load_i32(memory_at_0, loc_13)
					if loc_7 ~= param_2 then
						if param_2 == loc_12 then goto continue_at_10 end
						loc_0 = add_i32(loc_0, 1)
						param_2 = add_i32(loc_0, param_4)
						if le_u32(loc_0, loc_1) then goto continue_at_14 end
						goto continue_at_10
					end
					break
				end
				if load_i32_u8(memory_at_0, loc_13 + 5) ~= 0 then goto continue_at_9 end
				::continue_at_10::
				if loc_10 == 0 then goto continue_at_8 end
				store_i32(memory_at_0, param_0 + 196, loc_6)
				loc_0 = load_i32(memory_at_0, param_0 + 200)
				store_i32(
					memory_at_0, param_0 + 200, (gt_u32(loc_0, loc_6) and loc_0 or loc_6)
				)
				FUNC_LIST[348](param_0, loc_4, loc_11, 1)
				loc_3 = load_i32(memory_at_0, param_1 + 4)
				loc_2 = load_i32(memory_at_0, 54940)
				::continue_at_9::
				store_i32(memory_at_0, param_0 + 196, loc_8)
				param_3 = add_i32(param_3, 1)
				if lt_u32(param_3, loc_3) then goto continue_at_7 end
				goto continue_at_1
				::continue_at_8::
				break
			end
			store_i64(memory_at_0, loc_5, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_4, 8), 7407, loc_5)
			error("out of code bounds")
		end
		loc_1 = 1
		if not br_map[1] then br_map[1] = (function() return { [0] = 0, 2 } end)() end
		temp = br_map[1][loc_3] or 1
		if temp < 1 then
			goto continue_at_18
		elseif temp > 1 then
			goto continue_at_16
		else
			goto continue_at_17
		end
		::continue_at_18::
		if param_3 == 0 then goto continue_at_1 end
		::continue_at_19::
		while true do
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 2, band_i32(add_i32(param_2, loc_0), 255),
					0, 0
			)
			loc_0 = add_i32(loc_0, 1)
			if loc_0 ~= param_3 then goto continue_at_19 end
			break
		end
		goto continue_at_1
		::continue_at_17::
		::continue_at_20::
		while true do
			FUNC_LIST[348](
				param_0, load_i32(
					memory_at_0, add_i32(load_i32(memory_at_0, param_1), shl_i32(loc_0, 2))
				), band_i32(add_i32(param_2, loc_0), 255), 1
			)
			loc_0 = add_i32(loc_0, 1)
			loc_1 = load_i32(memory_at_0, param_1 + 4)
			loc_2 = sub_i32(loc_1, 1)
			if lt_u32(loc_0, loc_2) then goto continue_at_20 end
			break
		end
		::continue_at_16::
		loc_0 = load_i32(
			memory_at_0, add_i32(load_i32(memory_at_0, param_1), shl_i32(loc_2, 2))
		)
		loc_2 = load_i32(memory_at_0, loc_0 + 4)
		if loc_2 ~= load_i32(memory_at_0, 54964) then goto continue_at_21 end
		if loc_0 == 0 then goto continue_at_21 end
		FUNC_LIST[329](
			param_0, loc_0, band_i32(sub_i32(add_i32(param_2, loc_1), 1), 255),
				band_i32(add_i32(sub_i32(param_3, loc_1), 1), 255), param_4, 0
		)
		goto continue_at_1
		::continue_at_21::
		param_4 = sub_i32(add_i32(param_2, loc_1), 1)
		if loc_2 ~= load_i32(memory_at_0, 54956) then goto continue_at_22 end
		if loc_0 == 0 then goto continue_at_22 end
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0), add_i32(load_i32(memory_at_0, loc_0 + 8), 1)
			)
		end
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 63, band_i32(param_4, 255),
				band_i32(add_i32(sub_i32(param_3, loc_1), 2), 255), 0
		)
		goto continue_at_1
		::continue_at_22::
		FUNC_LIST[348](param_0, loc_0, band_i32(param_4, 255), 1)
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		if ge_u32(loc_0, param_3) then goto continue_at_1 end
		::continue_at_24::
		while true do
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 2, band_i32(add_i32(param_2, loc_0), 255),
					0, 0
			)
			loc_0 = add_i32(loc_0, 1)
			if loc_0 ~= param_3 then goto continue_at_24 end
			break
		end
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_5, 16)
	end
FUNC_LIST[346] = --[[ std::__2::__vector_base<unsigned long, std::__2::allocator<unsigned long> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[347] = --[[ Luau::Compiler::compileExprTempMultRet(Luau::AstExpr*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		if param_1 == 0 then goto continue_at_2 end
		if loc_0 ~= load_i32(memory_at_0, 54964) then goto continue_at_2 end
		if load_i32(memory_at_0, param_0 + 4) < 2 then goto continue_at_1 end
		loc_8 = load_i32(memory_at_0, param_0 + 104)
		loc_3 = load_i32(memory_at_0, param_0 + 100)
		loc_2 = sub_i32(div_i32(sub_i32(loc_8, loc_3), 12), 1)
		loc_5 = load_i32(memory_at_0, param_0 + 116)
		loc_9 = load_i32(memory_at_0, 55020)
		loc_10 = load_i32(memory_at_0, 54900)
		loc_11 = load_i32(memory_at_0, 54940)
		loc_0 = load_i32(memory_at_0, param_1 + 24)
		::continue_at_3::
		while true do
			loc_1 = load_i32(memory_at_0, loc_0 + 4)
			if loc_0 == 0 then goto continue_at_4 end
			if loc_1 ~= loc_11 then goto continue_at_4 end
			if loc_3 == loc_8 then goto continue_at_1 end
			loc_4 = load_i32(memory_at_0, loc_0 + 24)
			if loc_4 == loc_5 then goto continue_at_1 end
			loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
			loc_0 = 0
			::continue_at_5::
			while true do
				loc_6 = band_i32(loc_1, loc_2)
				loc_7 = add_i32(loc_3, mul_i32(loc_6, 12))
				loc_1 = load_i32(memory_at_0, loc_7)
				if loc_4 ~= loc_1 then
					if loc_1 == loc_5 then goto continue_at_1 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_6)
					if le_u32(loc_0, loc_2) then goto continue_at_5 end
					goto continue_at_1
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_7 + 8) ~= 0 then goto continue_at_1 end
			loc_0 = load_i32(memory_at_0, loc_7 + 4)
			if loc_0 ~= 0 then goto continue_at_3 end
			goto continue_at_1
			::continue_at_4::
			if loc_0 == 0 then goto continue_at_7 end
			if loc_1 ~= loc_10 then goto continue_at_7 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			goto continue_at_3
			::continue_at_7::
			if loc_0 == 0 then goto continue_at_8 end
			if loc_1 ~= loc_9 then goto continue_at_8 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			goto continue_at_3
			::continue_at_8::
			break
		end
		if loc_1 ~= load_i32(memory_at_0, 54988) then goto continue_at_1 end
		loc_3 = load_i32(memory_at_0, param_0 + 28)
		loc_1 = load_i32(memory_at_0, param_0 + 32)
		if loc_3 == loc_1 then goto continue_at_1 end
		loc_5 = load_i32(memory_at_0, param_0 + 44)
		if loc_0 == loc_5 then goto continue_at_1 end
		loc_2 = bxor_i32(shr_u32(loc_0, 4), shr_u32(loc_0, 9))
		loc_6 = sub_i32(div_i32(sub_i32(loc_1, loc_3), 40), 1)
		loc_1 = 0
		::continue_at_9::
		while true do
			loc_2 = band_i32(loc_2, loc_6)
			loc_4 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_2, 40)))
			if loc_0 ~= loc_4 then
				if loc_4 == loc_5 then goto continue_at_1 end
				loc_1 = add_i32(loc_1, 1)
				loc_2 = add_i32(loc_1, loc_2)
				if le_u32(loc_1, loc_6) then goto continue_at_9 end
				goto continue_at_1
			end
			break
		end
		if load_i32_u8(memory_at_0, add_i32(loc_3, mul_i32(loc_2, 40)) + 37) == 0 then
			goto continue_at_1
		end
		FUNC_LIST[348](param_0, param_1, param_2, 1)
		reg_0 = 0
		goto continue_at_0
		::continue_at_2::
		loc_0 = bor_i32(
			(param_1 == 0 and 1 or 0), (loc_0 ~= load_i32(memory_at_0, 54956) and 1 or 0)
		)
		if loc_0 == 0 then
			loc_1 = load_i32(memory_at_0, param_0 + 196)
			store_i32(memory_at_0, param_0 + 196, param_2)
			if load_i32(memory_at_0, param_0 + 8) > 0 then
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, param_1 + 8), 1)
				)
			end
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 63, param_2, 0, 0)
			store_i32(memory_at_0, param_0 + 196, loc_1)
			goto continue_at_11
		end
		FUNC_LIST[348](param_0, param_1, param_2, 1)
		::continue_at_11::
		reg_0 = bxor_i32(loc_0, 1)
		goto continue_at_0
		::continue_at_1::
		loc_0 = load_i32(memory_at_0, param_0 + 196)
		store_i32(memory_at_0, param_0 + 196, param_2)
		FUNC_LIST[329](param_0, param_1, param_2, 0, 1, 1)
		store_i32(memory_at_0, param_0 + 196, loc_0)
		reg_0 = 1
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[348] = --[[ Luau::Compiler::compileExpr(Luau::AstExpr*, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0LL
		local reg_0
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_4
		::continue_at_5::
		while true do
			if load_i32(memory_at_0, param_0 + 8) > 0 then
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, param_1 + 8), 1)
				)
			end
			if load_i32(memory_at_0, param_0 + 12) < 2 then goto continue_at_7 end
			loc_0 = load_i32(memory_at_0, param_1 + 4)
			if loc_0 == load_i32(memory_at_0, 55036) then goto continue_at_7 end
			if loc_0 == load_i32(memory_at_0, 55156) then goto continue_at_7 end
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 69, 0, 0, 0)
			::continue_at_7::
			loc_3 = load_i32(memory_at_0, param_0 + 124)
			loc_0 = load_i32(memory_at_0, param_0 + 128)
			if loc_3 == loc_0 then goto continue_at_8 end
			loc_6 = load_i32(memory_at_0, param_0 + 140)
			if loc_6 == param_1 then goto continue_at_8 end
			loc_1 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
			loc_5 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 24), 1)
			loc_0 = 0
			::continue_at_9::
			while true do
				loc_2 = band_i32(loc_1, loc_5)
				loc_7 = add_i32(loc_3, mul_i32(loc_2, 24))
				loc_1 = load_i32(memory_at_0, loc_7)
				if param_1 ~= loc_1 then
					if loc_1 == loc_6 then goto continue_at_8 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_2)
					if le_u32(loc_0, loc_5) then goto continue_at_9 end
					goto continue_at_8
				end
				break
			end
			if load_i32(memory_at_0, loc_7 + 8) == 0 then goto continue_at_8 end
			FUNC_LIST[358](param_0, param_1, add_i32(loc_7, 8), param_2)
			goto continue_at_1
			::continue_at_8::
			loc_0 = load_i32(memory_at_0, param_1 + 4)
			if param_1 == 0 then goto continue_at_11 end
			if loc_0 ~= load_i32(memory_at_0, 54900) then goto continue_at_11 end
			param_1 = load_i32(memory_at_0, param_1 + 24)
			goto continue_at_5
			::continue_at_11::
			if load_i32(memory_at_0, 54908) == loc_0 then
				FUNC_LIST[114](load_i32(memory_at_0, param_0), 2, param_2, 0, 0)
				goto continue_at_1
			end
			if param_1 == 0 then goto continue_at_13 end
			if loc_0 ~= load_i32(memory_at_0, 54916) then goto continue_at_13 end
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 3, param_2,
					load_i32_u8(memory_at_0, param_1 + 24), 0
			)
			goto continue_at_1
			::continue_at_13::
			if param_1 == 0 then goto continue_at_14 end
			if loc_0 ~= load_i32(memory_at_0, 54924) then goto continue_at_14 end
			reg_0 = FUNC_LIST[102](
				load_i32(memory_at_0, param_0), load_f64(memory_at_0, param_1 + 24)
			)
			loc_0 = reg_0
			if loc_0 < 0 then goto continue_at_4 end
			param_1 = load_i32(memory_at_0, param_0)
			if le_u32(loc_0, 32767) then
				FUNC_LIST[116](param_1, 5, param_2, shr_i32(shl_i32(loc_0, 16), 16))
				goto continue_at_1
			end
			FUNC_LIST[116](param_1, 66, param_2, 0)
			FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_0)
			goto continue_at_1
			::continue_at_14::
			if param_1 == 0 then goto continue_at_16 end
			if loc_0 ~= load_i32(memory_at_0, 54932) then goto continue_at_16 end
			loc_0 = load_i32(memory_at_0, param_0)
			loc_8 = load_i64(memory_at_0, param_1 + 24)
			store_i64(memory_at_0, loc_4, loc_8)
			store_i64(memory_at_0, loc_4 + 8, loc_8)
			reg_0 = FUNC_LIST[103](loc_0, loc_4)
			loc_0 = reg_0
			if loc_0 < 0 then goto continue_at_3 end
			param_1 = load_i32(memory_at_0, param_0)
			if le_u32(loc_0, 32767) then
				FUNC_LIST[116](param_1, 5, param_2, shr_i32(shl_i32(loc_0, 16), 16))
				goto continue_at_1
			end
			FUNC_LIST[116](param_1, 66, param_2, 0)
			FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_0)
			goto continue_at_1
			::continue_at_16::
			if param_1 == 0 then goto continue_at_18 end
			if loc_0 ~= load_i32(memory_at_0, 54940) then goto continue_at_18 end
			loc_3 = load_i32(memory_at_0, param_0 + 52)
			loc_1 = load_i32(memory_at_0, param_0 + 56)
			if loc_3 == loc_1 then
				loc_2 = load_i32(memory_at_0, param_1 + 24)
				goto continue_at_2
			end
			loc_2 = load_i32(memory_at_0, param_1 + 24)
			loc_6 = load_i32(memory_at_0, param_0 + 68)
			if loc_2 == loc_6 then goto continue_at_2 end
			loc_0 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
			loc_1 = sub_i32(div_i32(sub_i32(loc_1, loc_3), 12), 1)
			param_1 = 0
			::continue_at_20::
			while true do
				loc_0 = band_i32(loc_0, loc_1)
				loc_5 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_0, 12)))
				if loc_2 ~= loc_5 then
					if loc_5 == loc_6 then goto continue_at_2 end
					param_1 = add_i32(param_1, 1)
					loc_0 = add_i32(param_1, loc_0)
					if le_u32(param_1, loc_1) then goto continue_at_20 end
					goto continue_at_2
				end
				break
			end
			param_1 = add_i32(loc_3, mul_i32(loc_0, 12))
			if load_i32_u8(memory_at_0, param_1 + 5) == 0 then goto continue_at_2 end
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 6, param_2,
					load_i32_u8(memory_at_0, param_1 + 4), 0
			)
			goto continue_at_1
			::continue_at_18::
			if param_1 == 0 then goto continue_at_22 end
			if loc_0 ~= load_i32(memory_at_0, 54948) then goto continue_at_22 end
			FUNC_LIST[363](param_0, param_1, param_2)
			goto continue_at_1
			::continue_at_22::
			if param_1 == 0 then goto continue_at_23 end
			if loc_0 ~= load_i32(memory_at_0, 54956) then goto continue_at_23 end
			if load_i32(memory_at_0, param_0 + 8) > 0 then
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, param_1 + 8), 1)
				)
			end
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 63, param_2, 2, 0)
			goto continue_at_1
			::continue_at_23::
			if param_1 == 0 then goto continue_at_25 end
			if loc_0 ~= load_i32(memory_at_0, 54964) then goto continue_at_25 end
			if param_3 == 0 then goto continue_at_26 end
			if sub_i32(load_i32(memory_at_0, param_0 + 196), 1) ~= param_2 then
				goto continue_at_26
			end
			FUNC_LIST[329](param_0, param_1, param_2, 1, 1, 0)
			goto continue_at_1
			::continue_at_26::
			FUNC_LIST[329](param_0, param_1, param_2, 1, 0, 0)
			goto continue_at_1
			::continue_at_25::
			if param_1 == 0 then goto continue_at_27 end
			if loc_0 ~= load_i32(memory_at_0, 54972) then goto continue_at_27 end
			FUNC_LIST[364](param_0, param_1, param_2)
			goto continue_at_1
			::continue_at_27::
			if param_1 == 0 then goto continue_at_28 end
			if loc_0 ~= load_i32(memory_at_0, 54980) then goto continue_at_28 end
			FUNC_LIST[365](param_0, param_1, param_2)
			goto continue_at_1
			::continue_at_28::
			if param_1 == 0 then goto continue_at_29 end
			if loc_0 ~= load_i32(memory_at_0, 54988) then goto continue_at_29 end
			FUNC_LIST[337](param_0, param_1, param_2)
			goto continue_at_1
			::continue_at_29::
			if param_1 == 0 then goto continue_at_30 end
			if loc_0 ~= load_i32(memory_at_0, 54996) then goto continue_at_30 end
			FUNC_LIST[366](param_0, param_1, param_2, param_3)
			goto continue_at_1
			::continue_at_30::
			if param_1 == 0 then goto continue_at_31 end
			if loc_0 ~= load_i32(memory_at_0, 55004) then goto continue_at_31 end
			FUNC_LIST[367](param_0, param_1, param_2)
			goto continue_at_1
			::continue_at_31::
			if param_1 == 0 then goto continue_at_32 end
			if loc_0 ~= load_i32(memory_at_0, 55012) then goto continue_at_32 end
			FUNC_LIST[368](param_0, param_1, param_2, param_3)
			goto continue_at_1
			::continue_at_32::
			if param_1 == 0 then goto continue_at_33 end
			if loc_0 ~= load_i32(memory_at_0, 55020) then goto continue_at_33 end
			param_1 = load_i32(memory_at_0, param_1 + 24)
			goto continue_at_5
			::continue_at_33::
			break
		end
		if param_1 == 0 then goto continue_at_1 end
		if loc_0 ~= load_i32(memory_at_0, 55028) then goto continue_at_1 end
		FUNC_LIST[369](param_0, param_1, param_2, param_3)
		goto continue_at_1
		::continue_at_4::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_2::
		reg_0 = FUNC_LIST[241](param_0, loc_2)
		param_1 = reg_0
		FUNC_LIST[114](load_i32(memory_at_0, param_0), 9, param_2, param_1, 0)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_4, 16)
	end
FUNC_LIST[349] = --[[ Luau::Compiler::tryCompileInlinedCall(Luau::AstExprCall*, Luau::AstExprFunction*, unsigned char, unsigned char, bool, int, int, int) ]]
	function(
		param_0, param_1, param_2, param_3, param_4, param_5, param_6, param_7,
		param_8
	)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local reg_0
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_2
		loc_6 = load_i32(memory_at_0, param_0 + 28)
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_6 == loc_0 then goto continue_at_1 end
		loc_8 = load_i32(memory_at_0, param_0 + 44)
		if loc_8 == param_2 then goto continue_at_1 end
		loc_3 = bxor_i32(shr_u32(param_2, 4), shr_u32(param_2, 9))
		loc_9 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 40), 1)
		loc_0 = 0
		::continue_at_2::
		while true do
			loc_5 = band_i32(loc_3, loc_9)
			loc_1 = add_i32(loc_6, mul_i32(loc_5, 40))
			loc_3 = load_i32(memory_at_0, loc_1)
			if loc_3 == param_2 then goto continue_at_1 end
			loc_1 = 0
			if loc_3 == loc_8 then goto continue_at_1 end
			loc_0 = add_i32(loc_0, 1)
			loc_3 = add_i32(loc_0, loc_5)
			if le_u32(loc_0, loc_9) then goto continue_at_2 end
			break
		end
		::continue_at_1::
		if le_u32(load_i32(memory_at_0, param_0 + 196), 128) then
			loc_10 = (loc_1 ~= 0 and add_i32(loc_1, 8) or 0)
			if lt_u32(load_i32(memory_at_0, loc_10 + 24), 33) then goto continue_at_4 end
		end
		loc_0 = 0
		FUNC_LIST[130](load_i32(memory_at_0, param_0), 5558, 0)
		goto continue_at_3
		::continue_at_4::
		loc_1 = load_i32(memory_at_0, param_0 + 260)
		loc_0 = load_i32(memory_at_0, param_0 + 256)
		if param_8 > div_i32(sub_i32(loc_1, loc_0), 24) then
			if loc_0 == loc_1 then goto continue_at_6 end
			goto continue_at_7
		end
		loc_0 = 0
		FUNC_LIST[130](load_i32(memory_at_0, param_0), 2744, 0)
		goto continue_at_3
		::continue_at_7::
		::continue_at_9::
		while true do
			if param_2 ~= load_i32(memory_at_0, loc_0) then
				loc_0 = add_i32(loc_0, 24)
				if loc_1 ~= loc_0 then goto continue_at_9 end
				goto continue_at_6
			end
			break
		end
		loc_0 = 0
		FUNC_LIST[130](load_i32(memory_at_0, param_0), 2635, 0)
		goto continue_at_3
		::continue_at_6::
		if param_5 ~= 0 then
			loc_0 = 0
			FUNC_LIST[130](load_i32(memory_at_0, param_0), 2112, 0)
			goto continue_at_3
		end
		store_i64(memory_at_0, loc_2 + 40, 0LL )
		loc_4 = load_i32(memory_at_0, param_1 + 32)
		loc_7 = load_i32(memory_at_0, param_2 + 48)
		if loc_7 == 0 then goto continue_at_12 end
		loc_12 = (lt_u32(loc_4, 8) and loc_4 or 8)
		loc_13 = load_i32(memory_at_0, param_0 + 128)
		loc_8 = load_i32(memory_at_0, param_0 + 124)
		loc_3 = sub_i32(div_i32(sub_i32(loc_13, loc_8), 24), 1)
		param_8 = load_i32(memory_at_0, param_0 + 140)
		param_5 = 0
		::continue_at_13::
		while true do
			if param_5 == loc_12 then goto continue_at_12 end
			loc_5 = 0
			if loc_8 == loc_13 then goto continue_at_14 end
			loc_6 = load_i32(
				memory_at_0,
					add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(param_5, 2))
			)
			if param_8 == loc_6 then goto continue_at_14 end
			loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
			loc_0 = 0
			::continue_at_15::
			while true do
				loc_9 = band_i32(loc_1, loc_3)
				loc_5 = add_i32(loc_8, mul_i32(loc_9, 24))
				loc_1 = load_i32(memory_at_0, loc_5)
				if loc_6 ~= loc_1 then
					loc_5 = 0
					if param_8 == loc_1 then goto continue_at_14 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_9)
					if le_u32(loc_0, loc_3) then goto continue_at_15 end
					goto continue_at_14
				end
				break
			end
			loc_5 = (load_i32(memory_at_0, loc_5 + 8) ~= 0 and 1 or 0)
			::continue_at_14::
			store_i32_n8(memory_at_0, add_i32(add_i32(loc_2, 40), param_5), loc_5)
			param_5 = add_i32(param_5, 1)
			if param_5 ~= loc_7 then goto continue_at_13 end
			break
		end
		::continue_at_12::
		if loc_4 == 0 then goto continue_at_17 end
		loc_0 = load_i32(
			memory_at_0, load_i32(
				memory_at_0,
					sub_i32(add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_4, 2)), 4)
			) + 4
		)
		if loc_0 == load_i32(memory_at_0, 54964) then goto continue_at_17 end
		if loc_0 == load_i32(memory_at_0, 54956) then goto continue_at_17 end
		if ge_u32(loc_4, loc_7) then goto continue_at_17 end
		if gt_u32(loc_4, 7) then goto continue_at_17 end
		loc_0 = add_i32(loc_7, bxor_i32(loc_4, -1))
		loc_1 = sub_i32(7, loc_4)
		reg_0 = FUNC_LIST[1121](
			add_i32(add_i32(loc_2, 40), loc_4), 1,
				add_i32((lt_u32(loc_0, loc_1) and loc_0 or loc_1), 1)
		)
		::continue_at_17::
		reg_0 = FUNC_LIST[158](
			load_i64(memory_at_0, loc_10 + 16), add_i32(loc_2, 40),
				(loc_7 < 8 and loc_7 or 8)
		)
		loc_1 = reg_0
		reg_0 = FUNC_LIST[158](load_i64(memory_at_0, loc_10 + 16), 0, 0)
		loc_0 = reg_0
		if loc_1 ~= 0 then
			loc_0 = div_i32(add_i32(mul_i32(loc_0, 100), 300), loc_1)
			param_7 = (param_7 > loc_0 and loc_0 or param_7)
		end
		loc_11 = (convert_f64_i32(param_7) / 1e2)
		loc_3 = load_i32(memory_at_0, param_0)
		loc_0 = (loc_1 <= div_i32(mul_i32(param_6, param_7), 100) and 1 or 0)
		if loc_0 == 0 then
			store_f64(memory_at_0, loc_2 + 8, loc_11)
			store_i32(memory_at_0, loc_2, loc_1)
			FUNC_LIST[130](loc_3, 8524, loc_2)
			goto continue_at_3
		end
		store_i32(
			memory_at_0, loc_2 + 32, div_i32(
				sub_i32(
					load_i32(memory_at_0, param_0 + 260), load_i32(memory_at_0, param_0 + 256)
				), 24
			)
		)
		store_f64(memory_at_0, loc_2 + 24, loc_11)
		store_i32(memory_at_0, loc_2 + 16, loc_1)
		FUNC_LIST[130](loc_3, 9388, add_i32(loc_2, 16))
		FUNC_LIST[379](param_0, param_1, param_2, param_3, param_4)
		::continue_at_3::
		GLOBAL_LIST[0].value = add_i32(loc_2, 48)
		reg_0 = loc_0
		return reg_0
	end
FUNC_LIST[350] = --[[ Luau::Compiler::compileExprSelectVararg(Luau::AstExprCall*, unsigned char, unsigned char, bool, bool, unsigned char) ]]
	function(param_0, param_1, param_2, param_3, param_4, param_5, param_6)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		loc_3 = load_i32(memory_at_0, 54940)
		loc_5 = load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28))
		loc_0 = load_i32(memory_at_0, loc_5 + 4)
		if loc_5 ~= 0 then
			loc_1 = loc_5
			if loc_0 == loc_3 then goto continue_at_4 end
		end
		loc_4 = load_i32(memory_at_0, 55020)
		loc_2 = load_i32(memory_at_0, 54900)
		loc_1 = loc_5
		::continue_at_6::
		while true do
			if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_4 and 1 or 0)) ~= 0 then
				goto continue_at_3
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_6 end
			if loc_0 ~= loc_3 then goto continue_at_6 end
			break
		end
		::continue_at_4::
		loc_4 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_4 == loc_0 then goto continue_at_3 end
		loc_6 = load_i32(memory_at_0, loc_1 + 24)
		loc_7 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_7 then goto continue_at_3 end
		loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_4), 12), 1)
		loc_0 = 0
		::continue_at_7::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_3 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_1, 12)))
			if loc_6 ~= loc_3 then
				if loc_3 == loc_7 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_7 end
				goto continue_at_3
			end
			break
		end
		loc_0 = add_i32(loc_4, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_2 end
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_2 = add_i32(param_6, 1)
		loc_0 = band_i32(loc_2, 255)
		store_i32(memory_at_0, param_0 + 196, add_i32(loc_0, 1))
		FUNC_LIST[348](param_0, loc_5, loc_0, 1)
		store_i32(memory_at_0, param_0 + 196, loc_1)
		goto continue_at_1
		::continue_at_2::
		loc_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		loc_2 = loc_0
		::continue_at_1::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		loc_2 = band_i32(loc_2, 255)
		FUNC_LIST[114](load_i32(memory_at_0, param_0), 73, 57, loc_2, 0)
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 24), param_6, 1)
		loc_3 = add_i32(param_6, 1)
		if loc_0 ~= loc_3 then
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 6, band_i32(loc_3, 255), loc_2, 0
			)
		end
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 63, band_i32(add_i32(param_6, 2), 255), 0, 0
		)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		reg_0 = FUNC_LIST[121](load_i32(memory_at_0, param_0), loc_1, loc_0)
		if reg_0 ~= 0 then
			loc_0 = 0
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 21, param_6, 0,
					band_i32((param_5 ~= 0 and 0 or add_i32(param_3, 1)), 255)
			)
			if param_3 == 0 then goto continue_at_11 end
			if param_4 ~= 0 then goto continue_at_11 end
			::continue_at_12::
			while true do
				FUNC_LIST[114](
					load_i32(memory_at_0, param_0), 6, band_i32(add_i32(param_2, loc_0), 255),
						band_i32(add_i32(param_6, loc_0), 255), 0
				)
				loc_0 = add_i32(loc_0, 1)
				if loc_0 ~= param_3 then goto continue_at_12 end
				break
			end
			::continue_at_11::
			goto continue_at_0
		end
		FUNC_LIST[232](add_i32(load_i32(memory_at_0, param_1 + 24), 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[351] = --[[ Luau::Compiler::compileExprFastcallN(Luau::AstExprCall*, unsigned char, unsigned char, bool, bool, unsigned char, int) ]]
	function(
		param_0, param_1, param_2, param_3, param_4, param_5, param_6, param_7
	)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local reg_0
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_4
		loc_0 = load_i32(memory_at_0, param_1 + 32)
		store_i64(memory_at_0, loc_4 + 8, 0LL )
		loc_7 = (loc_0 == 1 and 73 or 74)
		if loc_0 == 0 then goto continue_at_1 end
		::continue_at_2::
		while true do
			if loc_2 == 0 then goto continue_at_3 end
			reg_0 = FUNC_LIST[362](
				param_0, load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_2, 2))
				)
			)
			loc_0 = reg_0
			if loc_0 < 0 then goto continue_at_3 end
			store_i32(memory_at_0, add_i32(add_i32(loc_4, 8), shl_i32(loc_2, 2)), loc_0)
			loc_7 = 75
			goto continue_at_1
			::continue_at_3::
			loc_9 = shl_i32(loc_2, 2)
			loc_8 = load_i32(
				memory_at_0, add_i32(loc_9, load_i32(memory_at_0, param_1 + 28))
			)
			loc_0 = load_i32(memory_at_0, loc_8 + 4)
			loc_6 = load_i32(memory_at_0, 54940)
			if loc_8 ~= 0 then
				loc_1 = loc_8
				if loc_0 == loc_6 then goto continue_at_7 end
			end
			loc_5 = load_i32(memory_at_0, 55020)
			loc_3 = load_i32(memory_at_0, 54900)
			loc_1 = loc_8
			::continue_at_9::
			while true do
				if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_5 and 1 or 0)) ~= 0 then
					goto continue_at_6
				end
				loc_1 = load_i32(memory_at_0, loc_1 + 24)
				loc_0 = load_i32(memory_at_0, loc_1 + 4)
				if loc_1 == 0 then goto continue_at_9 end
				if loc_0 ~= loc_6 then goto continue_at_9 end
				break
			end
			::continue_at_7::
			loc_10 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_10 == loc_0 then goto continue_at_6 end
			loc_5 = load_i32(memory_at_0, loc_1 + 24)
			loc_12 = load_i32(memory_at_0, param_0 + 68)
			if loc_5 == loc_12 then goto continue_at_6 end
			loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_10), 12), 1)
			loc_0 = 0
			::continue_at_10::
			while true do
				loc_6 = band_i32(loc_1, loc_3)
				loc_11 = add_i32(loc_10, mul_i32(loc_6, 12))
				loc_1 = load_i32(memory_at_0, loc_11)
				if loc_5 ~= loc_1 then
					if loc_1 == loc_12 then goto continue_at_6 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_6)
					if le_u32(loc_0, loc_3) then goto continue_at_10 end
					goto continue_at_6
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_11 + 5) ~= 0 then goto continue_at_5 end
			::continue_at_6::
			loc_2 = add_i32(loc_2, 1)
			loc_0 = band_i32(add_i32(loc_2, param_6), 255)
			store_i32(memory_at_0, add_i32(add_i32(loc_4, 8), loc_9), loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 196)
			store_i32(memory_at_0, param_0 + 196, add_i32(loc_0, 1))
			FUNC_LIST[348](param_0, loc_8, loc_0, 1)
			store_i32(memory_at_0, param_0 + 196, loc_1)
			goto continue_at_4
			::continue_at_5::
			store_i32(
				memory_at_0, add_i32(add_i32(loc_4, 8), loc_9),
					load_i32_u8(memory_at_0, loc_11 + 4)
			)
			loc_2 = add_i32(loc_2, 1)
			::continue_at_4::
			if lt_u32(loc_2, load_i32(memory_at_0, param_1 + 32)) then
				goto continue_at_2
			end
			break
		end
		::continue_at_1::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), loc_7, band_i32(param_7, 255),
				load_i32_u8(memory_at_0, loc_4 + 8), 0
		)
		if loc_7 ~= 73 then
			FUNC_LIST[117](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_4 + 12)
			)
		end
		loc_3 = load_i32(memory_at_0, param_1 + 32)
		if loc_3 == 0 then goto continue_at_13 end
		loc_5 = (loc_7 ~= 75 and 1 or 0)
		loc_0 = 0
		::continue_at_14::
		while true do
			if loc_0 == 0 then goto continue_at_15 end
			if loc_5 ~= 0 then goto continue_at_15 end
			loc_1 = add_i32(add_i32(param_6, loc_0), 1)
			loc_3 = load_i32(memory_at_0, param_0)
			loc_0 = load_i32(memory_at_0, add_i32(add_i32(loc_4, 8), shl_i32(loc_0, 2)))
			if loc_0 <= 32767 then
				FUNC_LIST[116](
					loc_3, 5, band_i32(loc_1, 255), shr_i32(shl_i32(loc_0, 16), 16)
				)
				goto continue_at_13
			end
			FUNC_LIST[116](loc_3, 66, band_i32(loc_1, 255), 0)
			FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_0)
			goto continue_at_13
			::continue_at_15::
			loc_6 = load_i32(memory_at_0, add_i32(add_i32(loc_4, 8), shl_i32(loc_0, 2)))
			loc_1 = add_i32(loc_0, 1)
			loc_0 = add_i32(loc_1, param_6)
			if loc_6 ~= loc_0 then
				FUNC_LIST[114](
					load_i32(memory_at_0, param_0), 6, band_i32(loc_0, 255),
						band_i32(loc_6, 255), 0
				)
				loc_3 = load_i32(memory_at_0, param_1 + 32)
			end
			loc_0 = loc_1
			if gt_u32(loc_3, loc_0) then goto continue_at_14 end
			break
		end
		::continue_at_13::
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 24), param_6, 1)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		reg_0 = FUNC_LIST[121](load_i32(memory_at_0, param_0), loc_2, loc_0)
		if reg_0 ~= 0 then
			loc_0 = 0
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 21, param_6,
					band_i32(add_i32(load_i32_u8(memory_at_0, param_1 + 32), 1), 255),
					band_i32((param_5 ~= 0 and 0 or add_i32(param_3, 1)), 255)
			)
			if param_3 == 0 then goto continue_at_19 end
			if param_4 ~= 0 then goto continue_at_19 end
			::continue_at_20::
			while true do
				FUNC_LIST[114](
					load_i32(memory_at_0, param_0), 6, band_i32(add_i32(param_2, loc_0), 255),
						band_i32(add_i32(param_6, loc_0), 255), 0
				)
				loc_0 = add_i32(loc_0, 1)
				if loc_0 ~= param_3 then goto continue_at_20 end
				break
			end
			::continue_at_19::
			GLOBAL_LIST[0].value = add_i32(loc_4, 16)
			goto continue_at_0
		end
		FUNC_LIST[232](add_i32(load_i32(memory_at_0, param_1 + 24), 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[352] = --[[ Luau::Compiler::tryCompileUnrolledFor(Luau::AstStatFor*, int, int) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0LL
		local loc_14 = 0
		local loc_15 = 0
		local reg_0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_3
		loc_0 = load_i32(memory_at_0, param_0 + 124)
		loc_9 = load_i32(memory_at_0, param_0 + 128)
		loc_8 = (loc_0 == loc_9 and 1 or 0)
		if loc_8 ~= 0 then goto continue_at_3 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		loc_4 = load_i32(memory_at_0, param_1 + 32)
		if loc_6 == loc_4 then goto continue_at_3 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_5 = sub_i32(div_i32(sub_i32(loc_9, loc_0), 24), 1)
		::continue_at_4::
		while true do
			loc_1 = band_i32(loc_1, loc_5)
			loc_7 = load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)))
			if loc_7 == loc_4 then goto continue_at_2 end
			if loc_6 == loc_7 then goto continue_at_3 end
			loc_2 = add_i32(loc_2, 1)
			loc_1 = add_i32(loc_2, loc_1)
			if le_u32(loc_2, loc_5) then goto continue_at_4 end
			break
		end
		::continue_at_3::
		store_i32(memory_at_0, loc_3 + 72, 0)
		goto continue_at_1
		::continue_at_2::
		loc_2 = add_i32(loc_0, mul_i32(loc_1, 24))
		loc_10 = load_i32(memory_at_0, loc_2 + 8)
		store_f64(memory_at_0, loc_3 + 72, load_f64(memory_at_0, loc_2 + 16))
		::continue_at_1::
		if loc_8 ~= 0 then goto continue_at_7 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		loc_4 = load_i32(memory_at_0, param_1 + 36)
		if loc_6 == loc_4 then goto continue_at_7 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_5 = sub_i32(div_i32(sub_i32(loc_9, loc_0), 24), 1)
		loc_2 = 0
		::continue_at_8::
		while true do
			loc_1 = band_i32(loc_1, loc_5)
			loc_7 = load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)))
			if loc_7 == loc_4 then goto continue_at_6 end
			if loc_6 == loc_7 then goto continue_at_7 end
			loc_2 = add_i32(loc_2, 1)
			loc_1 = add_i32(loc_2, loc_1)
			if le_u32(loc_2, loc_5) then goto continue_at_8 end
			break
		end
		::continue_at_7::
		store_i32(memory_at_0, loc_3 + 64, 0)
		goto continue_at_5
		::continue_at_6::
		loc_2 = add_i32(loc_0, mul_i32(loc_1, 24))
		loc_11 = load_i32(memory_at_0, loc_2 + 8)
		store_f64(memory_at_0, loc_3 + 64, load_f64(memory_at_0, loc_2 + 16))
		::continue_at_5::
		loc_4 = load_i32(memory_at_0, param_1 + 40)
		if loc_4 == 0 then
			loc_0 = 1
			reg_0 = 1e0
			goto continue_at_12
		end
		if loc_8 ~= 0 then goto continue_at_11 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		if loc_6 == loc_4 then goto continue_at_11 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_5 = sub_i32(div_i32(sub_i32(loc_9, loc_0), 24), 1)
		loc_2 = 0
		::continue_at_14::
		while true do
			loc_1 = band_i32(loc_1, loc_5)
			loc_7 = load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)))
			if loc_4 ~= loc_7 then
				if loc_6 == loc_7 then goto continue_at_11 end
				loc_2 = add_i32(loc_2, 1)
				loc_1 = add_i32(loc_2, loc_1)
				if le_u32(loc_2, loc_5) then goto continue_at_14 end
				goto continue_at_11
			end
			break
		end
		loc_2 = add_i32(loc_0, mul_i32(loc_1, 24))
		loc_0 = (load_i32(memory_at_0, loc_2 + 8) == 3 and 1 or 0)
		reg_0 = load_f64(memory_at_0, loc_2 + 16)
		::continue_at_12::
		loc_12 = reg_0
		if loc_10 ~= 3 then goto continue_at_11 end
		if loc_11 ~= 3 then goto continue_at_11 end
		if loc_0 == 0 then goto continue_at_11 end
		loc_15 = load_f64(memory_at_0, loc_3 + 72)
		reg_0 = FUNC_LIST[159](loc_15, load_f64(memory_at_0, loc_3 + 64), loc_12)
		loc_2 = reg_0
		if loc_2 >= 0 then goto continue_at_10 end
		::continue_at_11::
		loc_0 = 0
		FUNC_LIST[130](load_i32(memory_at_0, param_0), 1794, 0)
		goto continue_at_9
		::continue_at_10::
		if param_2 < loc_2 then
			loc_0 = load_i32(memory_at_0, param_0)
			store_i32(memory_at_0, loc_3, loc_2)
			FUNC_LIST[130](loc_0, 9291, loc_3)
			loc_0 = 0
			goto continue_at_9
		end
		loc_6 = load_i32(memory_at_0, param_0 + 100)
		loc_0 = load_i32(memory_at_0, param_0 + 104)
		if loc_6 == loc_0 then
			loc_4 = load_i32(memory_at_0, param_1 + 28)
			goto continue_at_17
		end
		loc_4 = load_i32(memory_at_0, param_1 + 28)
		loc_8 = load_i32(memory_at_0, param_0 + 116)
		if loc_4 == loc_8 then goto continue_at_17 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_5 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 12), 1)
		loc_0 = 0
		::continue_at_19::
		while true do
			loc_7 = band_i32(loc_1, loc_5)
			loc_1 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_7, 12)))
			if loc_4 ~= loc_1 then
				if loc_1 == loc_8 then goto continue_at_17 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_7)
				if le_u32(loc_0, loc_5) then goto continue_at_19 end
				goto continue_at_17
			end
			break
		end
		if load_i32_u8(memory_at_0, add_i32(loc_6, mul_i32(loc_7, 12)) + 8) == 0 then
			goto continue_at_17
		end
		loc_0 = 0
		FUNC_LIST[130](load_i32(memory_at_0, param_0), 6565, 0)
		goto continue_at_9
		::continue_at_17::
		store_i32(memory_at_0, loc_3 + 60, loc_4)
		reg_0 = FUNC_LIST[155](
			load_i32(memory_at_0, param_1 + 44), add_i32(loc_3, 60), 1
		)
		loc_13 = reg_0
		store_i32_n8(memory_at_0, loc_3 + 59, 1)
		reg_0 = FUNC_LIST[158](loc_13, add_i32(loc_3, 59), 1)
		loc_0 = reg_0
		reg_0 = FUNC_LIST[158](loc_13, 0, 0)
		loc_5 = reg_0
		loc_1 = mul_i32(loc_0, loc_2)
		if loc_1 ~= 0 then
			loc_0 = div_i32(mul_i32(mul_i32(loc_2, add_i32(loc_5, 1)), 100), loc_1)
			param_3 = (param_3 > loc_0 and loc_0 or param_3)
		end
		loc_14 = (convert_f64_i32(param_3) / 1e2)
		loc_5 = load_i32(memory_at_0, param_0)
		loc_0 = (loc_1 <= div_i32(mul_i32(param_2, param_3), 100) and 1 or 0)
		if loc_0 == 0 then
			store_f64(memory_at_0, loc_3 + 24, loc_14)
			store_i32(memory_at_0, loc_3 + 20, loc_1)
			store_i32(memory_at_0, loc_3 + 16, loc_2)
			FUNC_LIST[130](loc_5, 8579, add_i32(loc_3, 16))
			goto continue_at_9
		end
		store_f64(memory_at_0, loc_3 + 40, loc_14)
		store_i32(memory_at_0, loc_3 + 36, loc_1)
		store_i32(memory_at_0, loc_3 + 32, loc_2)
		FUNC_LIST[130](loc_5, 8652, add_i32(loc_3, 32))
		FUNC_LIST[383](param_0, param_1, loc_2, loc_15, loc_12)
		::continue_at_9::
		GLOBAL_LIST[0].value = add_i32(loc_3, 80)
		reg_0 = loc_0
		return reg_0
	end
FUNC_LIST[353] = --[[ Luau::Compiler::compileLValue(Luau::AstExpr*, Luau::Compiler::RegScope&) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0, reg_1
		loc_7 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_7
		if load_i32(memory_at_0, param_1 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_1),
					add_i32(load_i32(memory_at_0, param_2 + 8), 1)
			)
		end
		loc_2 = load_i32(memory_at_0, 54940)
		loc_0 = load_i32(memory_at_0, param_2 + 4)
		if param_2 == 0 then goto continue_at_4 end
		if loc_0 ~= loc_2 then goto continue_at_4 end
		loc_4 = load_i32(memory_at_0, param_1 + 52)
		loc_0 = load_i32(memory_at_0, param_1 + 56)
		if loc_4 == loc_0 then
			loc_3 = load_i32(memory_at_0, param_2 + 24)
			goto continue_at_3
		end
		loc_3 = load_i32(memory_at_0, param_2 + 24)
		loc_5 = load_i32(memory_at_0, param_1 + 68)
		if loc_3 == loc_5 then goto continue_at_3 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_4), 12), 1)
		loc_0 = 0
		::continue_at_6::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			param_3 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_1, 12)))
			if loc_3 ~= param_3 then
				if param_3 == loc_5 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_6 end
				goto continue_at_3
			end
			break
		end
		loc_0 = add_i32(loc_4, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) == 0 then goto continue_at_3 end
		loc_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		store_i64(memory_at_0, param_0, 0LL )
		store_i64(memory_at_0, param_0 + 8, 0LL )
		store_i32_n8(memory_at_0, param_0 + 4, loc_0)
		store_i64(memory_at_0, param_0 + 16, load_i64(memory_at_0, param_2 + 8))
		store_i64(memory_at_0, param_0 + 24, load_i64(memory_at_0, param_2 + 16))
		goto continue_at_2
		::continue_at_4::
		if param_2 == 0 then goto continue_at_8 end
		if loc_0 ~= load_i32(memory_at_0, 54948) then goto continue_at_8 end
		store_i64(memory_at_0, param_0, 2LL )
		loc_0 = load_i32(memory_at_0, param_2 + 24)
		reg_1 = FUNC_LIST[1197](loc_0)
		store_i32(memory_at_0, param_0 + 12, reg_1)
		store_i32(memory_at_0, param_0 + 8, loc_0)
		store_i64(memory_at_0, param_0 + 16, load_i64(memory_at_0, param_2 + 8))
		store_i64(memory_at_0, param_0 + 24, load_i64(memory_at_0, param_2 + 16))
		goto continue_at_2
		::continue_at_8::
		if param_2 == 0 then goto continue_at_11 end
		if loc_0 ~= load_i32(memory_at_0, 54972) then goto continue_at_11 end
		store_i64(memory_at_0, param_0 + 4, 0LL )
		store_i32(memory_at_0, param_0, 3)
		store_i64(memory_at_0, param_0 + 12, 0LL )
		store_i64(memory_at_0, param_0 + 20, 0LL )
		store_i32(memory_at_0, param_0 + 28, 0)
		loc_5 = load_i32(memory_at_0, param_2 + 24)
		loc_0 = load_i32(memory_at_0, loc_5 + 4)
		if loc_5 ~= 0 then
			loc_1 = loc_5
			if loc_0 == loc_2 then goto continue_at_13 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		param_3 = load_i32(memory_at_0, 54900)
		loc_1 = loc_5
		::continue_at_15::
		while true do
			if band_i32((param_3 ~= loc_0 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_12
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_15 end
			if loc_0 ~= loc_2 then goto continue_at_15 end
			break
		end
		::continue_at_13::
		loc_3 = load_i32(memory_at_0, param_1 + 52)
		loc_0 = load_i32(memory_at_0, param_1 + 56)
		if loc_3 == loc_0 then goto continue_at_12 end
		loc_4 = load_i32(memory_at_0, loc_1 + 24)
		loc_6 = load_i32(memory_at_0, param_1 + 68)
		if loc_4 == loc_6 then goto continue_at_12 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 12), 1)
		loc_0 = 0
		::continue_at_16::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			param_3 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 12)))
			if loc_4 ~= param_3 then
				if param_3 == loc_6 then goto continue_at_12 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_16 end
				goto continue_at_12
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_10 end
		::continue_at_12::
		loc_1 = load_i32(memory_at_0, param_1 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_1 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_1 + 200)
			store_i32(
				memory_at_0, param_1 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_1, loc_5, band_i32(loc_1, 255), 1)
			goto continue_at_9
		end
		store_i64(memory_at_0, loc_7 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_5, 8), 7407, add_i32(loc_7, 16))
		error("out of code bounds")
		::continue_at_11::
		if param_2 == 0 then goto continue_at_21 end
		if loc_0 ~= load_i32(memory_at_0, 54980) then goto continue_at_21 end
		loc_6 = load_i32(memory_at_0, param_2 + 24)
		loc_0 = load_i32(memory_at_0, loc_6 + 4)
		if loc_6 ~= 0 then
			loc_1 = loc_6
			if loc_0 == loc_2 then goto continue_at_23 end
		end
		loc_4 = load_i32(memory_at_0, 55020)
		loc_3 = load_i32(memory_at_0, 54900)
		loc_1 = loc_6
		::continue_at_25::
		while true do
			if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_4 and 1 or 0)) ~= 0 then
				goto continue_at_22
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_25 end
			if loc_0 ~= loc_2 then goto continue_at_25 end
			break
		end
		::continue_at_23::
		loc_4 = load_i32(memory_at_0, param_1 + 52)
		loc_0 = load_i32(memory_at_0, param_1 + 56)
		if loc_4 == loc_0 then goto continue_at_22 end
		loc_5 = load_i32(memory_at_0, loc_1 + 24)
		loc_8 = load_i32(memory_at_0, param_1 + 68)
		if loc_5 == loc_8 then goto continue_at_22 end
		loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_4), 12), 1)
		loc_0 = 0
		::continue_at_26::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_3 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_1, 12)))
			if loc_5 ~= loc_3 then
				if loc_3 == loc_8 then goto continue_at_22 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_26 end
				goto continue_at_22
			end
			break
		end
		loc_0 = add_i32(loc_4, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_20 end
		::continue_at_22::
		loc_1 = load_i32(memory_at_0, param_1 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_1 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_1 + 200)
			store_i32(
				memory_at_0, param_1 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_1, loc_6, band_i32(loc_1, 255), 1)
			goto continue_at_19
		end
		store_i64(memory_at_0, loc_7, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_6, 8), 7407, loc_7)
		error("out of code bounds")
		::continue_at_21::
		store_i64(memory_at_0, param_0, 0LL )
		store_i64(memory_at_0, param_0 + 24, 0LL )
		store_i64(memory_at_0, param_0 + 16, 0LL )
		store_i64(memory_at_0, param_0 + 8, 0LL )
		goto continue_at_2
		::continue_at_20::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_19::
		FUNC_LIST[371](
			param_0, param_1, band_i32(loc_1, 255), load_i32(memory_at_0, param_2 + 28),
				param_3
		)
		goto continue_at_2
		::continue_at_10::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_9::
		store_i32_n8(memory_at_0, param_0 + 4, loc_1)
		loc_0 = load_i32(memory_at_0, param_2 + 28)
		reg_1 = FUNC_LIST[1197](loc_0)
		store_i32(memory_at_0, param_0 + 12, reg_1)
		store_i32(memory_at_0, param_0 + 8, loc_0)
		param_0 = add_i32(param_0, 16)
		store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_2 + 16))
		store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_2 + 8))
		goto continue_at_2
		::continue_at_3::
		store_i64(memory_at_0, param_0 + 4, 0LL )
		store_i32(memory_at_0, param_0, 1)
		store_i64(memory_at_0, param_0 + 12, 0LL )
		store_i64(memory_at_0, param_0 + 20, 0LL )
		store_i32(memory_at_0, param_0 + 28, 0)
		reg_1 = FUNC_LIST[241](param_1, loc_3)
		store_i32_n8(memory_at_0, param_0 + 5, reg_1)
		store_i64(memory_at_0, param_0 + 16, load_i64(memory_at_0, param_2 + 8))
		store_i64(memory_at_0, param_0 + 24, load_i64(memory_at_0, param_2 + 16))
		::continue_at_2::
		GLOBAL_LIST[0].value = add_i32(loc_7, 32)
	end
FUNC_LIST[354] = --[[ Luau::Compiler::resolveAssignConflicts(Luau::AstStat*, std::__2::vector<Luau::Compiler::LValue, std::__2::allocator<Luau::Compiler::LValue> >&) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local br_map, temp = {}, nil
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 320)
		GLOBAL_LIST[0].value = loc_1
		store_i64(memory_at_0, loc_1 + 312, 0LL )
		store_i64(memory_at_0, loc_1 + 304, 0LL )
		store_i64(memory_at_0, loc_1 + 296, 0LL )
		store_i64(memory_at_0, loc_1 + 288, 0LL )
		loc_0 = load_i32(memory_at_0, param_2)
		if loc_0 ~= load_i32(memory_at_0, param_2 + 4) then
			::continue_at_4::
			while true do
				loc_0 = add_i32(loc_0, shl_i32(loc_6, 5))
				loc_2 = load_i32(memory_at_0, loc_0)
				if not br_map[1] then
					br_map[1] = (function() return { [0] = 0, 2, 2, 1, 1, 1 } end)()
				end
				temp = br_map[1][loc_2] or 2
				if temp < 1 then
					goto continue_at_7
				elseif temp > 1 then
					goto continue_at_5
				else
					goto continue_at_6
				end
				::continue_at_7::
				loc_0 = load_i32_u8(memory_at_0, loc_0 + 4)
				loc_3 = shl_i32(1, loc_0)
				loc_2 = add_i32(add_i32(loc_1, 288), band_i32(shr_u32(loc_0, 3), 28))
				loc_4 = load_i32(memory_at_0, loc_2)
				if band_i32(loc_3, loc_4) ~= 0 then goto continue_at_5 end
				store_i32(memory_at_0, loc_2, bor_i32(loc_3, loc_4))
				store_i32_n8(memory_at_0, add_i32(add_i32(loc_1, 32), loc_0), loc_0)
				goto continue_at_5
				::continue_at_6::
				loc_3 = load_i32_u8(memory_at_0, loc_0 + 4)
				if band_i32(
					shr_u32(
						load_i32(
							memory_at_0,
								add_i32(add_i32(loc_1, 288), band_i32(shr_u32(loc_3, 3), 28))
						), loc_3
					), 1
				) ~= 0 then
					loc_5 = add_i32(loc_0, 4)
					loc_4 = load_i32_u8(memory_at_0, add_i32(add_i32(loc_1, 32), loc_3))
					if loc_3 == loc_4 then
						loc_4 = load_i32(memory_at_0, param_0 + 196)
						loc_2 = add_i32(loc_4, 1)
						if ge_u32(loc_2, 256) then goto continue_at_2 end
						store_i32(memory_at_0, param_0 + 196, loc_2)
						loc_7 = load_i32(memory_at_0, param_0 + 200)
						store_i32(
							memory_at_0, param_0 + 200, (lt_u32(loc_2, loc_7) and loc_7 or loc_2)
						)
						FUNC_LIST[114](
							load_i32(memory_at_0, param_0), 6, band_i32(loc_4, 255), loc_3, 0
						)
						store_i32_n8(
							memory_at_0,
								add_i32(load_i32_u8(memory_at_0, loc_5), add_i32(loc_1, 32)), loc_4
						)
						loc_2 = load_i32(memory_at_0, loc_0)
					end
					store_i32_n8(memory_at_0, loc_5, loc_4)
				end
				if loc_2 ~= 5 then goto continue_at_5 end
				loc_3 = load_i32_u8(memory_at_0, loc_0 + 6)
				if band_i32(
					shr_u32(
						load_i32(
							memory_at_0,
								add_i32(add_i32(loc_1, 288), band_i32(shr_u32(loc_3, 3), 28))
						), loc_3
					), 1
				) == 0 then goto continue_at_5 end
				loc_2 = add_i32(loc_0, 6)
				loc_0 = load_i32_u8(memory_at_0, add_i32(add_i32(loc_1, 32), loc_3))
				if loc_3 == loc_0 then
					loc_0 = load_i32(memory_at_0, param_0 + 196)
					loc_4 = add_i32(loc_0, 1)
					if ge_u32(loc_4, 256) then goto continue_at_1 end
					store_i32(memory_at_0, param_0 + 196, loc_4)
					loc_5 = load_i32(memory_at_0, param_0 + 200)
					store_i32(
						memory_at_0, param_0 + 200, (lt_u32(loc_4, loc_5) and loc_5 or loc_4)
					)
					FUNC_LIST[114](
						load_i32(memory_at_0, param_0), 6, band_i32(loc_0, 255), loc_3, 0
					)
					store_i32_n8(
						memory_at_0, add_i32(load_i32_u8(memory_at_0, loc_2), add_i32(loc_1, 32)),
							loc_0
					)
				end
				store_i32_n8(memory_at_0, loc_2, loc_0)
				::continue_at_5::
				loc_6 = add_i32(loc_6, 1)
				loc_0 = load_i32(memory_at_0, param_2)
				if lt_u32(
					loc_6, shr_i32(sub_i32(load_i32(memory_at_0, param_2 + 4), loc_0), 5)
				) then goto continue_at_4 end
				break
			end
		end
		GLOBAL_LIST[0].value = add_i32(loc_1, 320)
		goto continue_at_0
		::continue_at_2::
		store_i64(memory_at_0, loc_1 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_1, 16))
		error("out of code bounds")
		::continue_at_1::
		store_i64(memory_at_0, loc_1, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_1)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[355] = --[[ Luau::Compiler::compileLValueUse(Luau::Compiler::LValue const&, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0LL
		local loc_4 = 0
		local reg_0, reg_1, reg_2, reg_3, reg_4
		local br_map, temp = {}, nil
		loc_0 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = add_i32(param_1, 16)
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0), add_i32(load_i32(memory_at_0, loc_1), 1)
			)
		end
		if not br_map[1] then
			br_map[1] = (function() return { [0] = 0, 1, 2, 3, 4, 5 } end)()
		end
		temp = br_map[1][load_i32(memory_at_0, param_1)] or 6
		if temp < 3 then
			if temp < 1 then
				goto continue_at_10
			elseif temp > 1 then
				goto continue_at_8
			else
				goto continue_at_9
			end
		elseif temp > 3 then
			if temp < 5 then
				goto continue_at_6
			elseif temp > 5 then
				goto continue_at_4
			else
				goto continue_at_5
			end
		else
			goto continue_at_7
		end
		::continue_at_10::
		param_1 = load_i32_u8(memory_at_0, param_1 + 4)
		param_0 = load_i32(memory_at_0, param_0)
		if param_3 ~= 0 then
			FUNC_LIST[114](param_0, 6, band_i32(param_1, 255), param_2, 0)
			goto continue_at_4
		end
		FUNC_LIST[114](param_0, 6, param_2, band_i32(param_1, 255), 0)
		goto continue_at_4
		::continue_at_9::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), (param_3 ~= 0 and 10 or 9), param_2,
				load_i32_u8(memory_at_0, param_1 + 5), 0
		)
		goto continue_at_4
		::continue_at_8::
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = load_i64(memory_at_0, param_1 + 8)
		store_i64(memory_at_0, loc_0 + 8, loc_3)
		store_i64(memory_at_0, loc_0 + 56, loc_3)
		reg_0 = FUNC_LIST[103](loc_2, add_i32(loc_0, 8))
		loc_2 = reg_0
		if loc_2 < 0 then goto continue_at_3 end
		loc_1 = load_i32(memory_at_0, param_0)
		loc_3 = load_i64(memory_at_0, param_1 + 8)
		store_i64(memory_at_0, loc_0, loc_3)
		store_i64(memory_at_0, loc_0 + 48, loc_3)
		reg_4 = FUNC_LIST[139](loc_0)
		FUNC_LIST[114](
			loc_1, (param_3 ~= 0 and 8 or 7), param_2, 0, band_i32(reg_4, 255)
		)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_2)
		goto continue_at_4
		::continue_at_7::
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = load_i64(memory_at_0, param_1 + 8)
		store_i64(memory_at_0, loc_0 + 24, loc_3)
		store_i64(memory_at_0, loc_0 + 40, loc_3)
		reg_0 = FUNC_LIST[103](loc_2, add_i32(loc_0, 24))
		loc_2 = reg_0
		if loc_2 < 0 then goto continue_at_2 end
		loc_1 = load_i32_u8(memory_at_0, param_1 + 4)
		loc_4 = load_i32(memory_at_0, param_0)
		loc_3 = load_i64(memory_at_0, param_1 + 8)
		store_i64(memory_at_0, loc_0 + 16, loc_3)
		store_i64(memory_at_0, loc_0 + 32, loc_3)
		reg_4 = FUNC_LIST[139](add_i32(loc_0, 16))
		FUNC_LIST[114](
			loc_4, (param_3 ~= 0 and 16 or 15), param_2, loc_1, band_i32(reg_4, 255)
		)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_2)
		goto continue_at_4
		::continue_at_6::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), (param_3 ~= 0 and 18 or 17), param_2,
				load_i32_u8(memory_at_0, param_1 + 4), load_i32_u8(memory_at_0, param_1 + 7)
		)
		goto continue_at_4
		::continue_at_5::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), (param_3 ~= 0 and 14 or 13), param_2,
				load_i32_u8(memory_at_0, param_1 + 4), load_i32_u8(memory_at_0, param_1 + 6)
		)
		::continue_at_4::
		GLOBAL_LIST[0].value = sub_i32(loc_0, -64)
		goto continue_at_0
		::continue_at_3::
		FUNC_LIST[232](loc_1, 6074, 0)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[232](loc_1, 6074, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[356] = --[[ std::__2::__vector_base<Luau::Compiler::LValue, std::__2::allocator<Luau::Compiler::LValue> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[357] = --[[ Luau::Compiler::unrollConcats(std::__2::vector<Luau::AstExpr*, std::__2::allocator<Luau::AstExpr*> >&) ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_1 = sub_i32(load_i32(memory_at_0, param_0 + 4), 4)
		loc_0 = load_i32(memory_at_0, loc_1)
		loc_6 = load_i32(memory_at_0, loc_0 + 4)
		if loc_6 ~= load_i32(memory_at_0, 55012) then goto continue_at_3 end
		if loc_0 == 0 then goto continue_at_3 end
		::continue_at_4::
		while true do
			if load_i32(memory_at_0, loc_0 + 24) ~= 6 then goto continue_at_3 end
			store_i32(memory_at_0, loc_1, load_i32(memory_at_0, loc_0 + 28))
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if loc_1 ~= load_i32(memory_at_0, param_0 + 8) then
				store_i32(memory_at_0, loc_1, load_i32(memory_at_0, loc_0 + 32))
				loc_0 = add_i32(loc_1, 4)
				store_i32(memory_at_0, param_0 + 4, loc_0)
				goto continue_at_5
			end
			loc_4 = load_i32(memory_at_0, param_0)
			loc_1 = sub_i32(loc_1, loc_4)
			loc_5 = shr_i32(loc_1, 2)
			loc_3 = add_i32(loc_5, 1)
			if ge_u32(loc_3, 1073741824) then goto continue_at_2 end
			loc_2 = shr_i32(loc_1, 1)
			loc_2 = (lt_u32(loc_1, 2147483644) and
				        (gt_u32(loc_2, loc_3) and loc_2 or loc_3) or 1073741823)
			if loc_2 ~= 0 then
				if ge_u32(loc_2, 1073741824) then goto continue_at_1 end
				reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 2))
			else
				reg_0 = 0
			end
			loc_3 = reg_0
			loc_5 = add_i32(loc_3, shl_i32(loc_5, 2))
			store_i32(memory_at_0, loc_5, load_i32(memory_at_0, loc_0 + 32))
			loc_2 = add_i32(loc_3, shl_i32(loc_2, 2))
			loc_0 = add_i32(loc_5, 4)
			if loc_1 > 0 then reg_0 = FUNC_LIST[1119](loc_3, loc_4, loc_1) end
			store_i32(memory_at_0, param_0 + 8, loc_2)
			store_i32(memory_at_0, param_0 + 4, loc_0)
			store_i32(memory_at_0, param_0, loc_3)
			if loc_4 == 0 then goto continue_at_5 end
			FUNC_LIST[1276](loc_4)
			loc_6 = load_i32(memory_at_0, 55012)
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			::continue_at_5::
			loc_1 = sub_i32(loc_0, 4)
			loc_0 = load_i32(memory_at_0, loc_1)
			if load_i32(memory_at_0, loc_0 + 4) ~= loc_6 then goto continue_at_3 end
			if loc_0 ~= 0 then goto continue_at_4 end
			break
		end
		::continue_at_3::
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[373](param_0)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[358] = --[[ Luau::Compiler::compileExprConstant(Luau::AstExpr*, Luau::Compile::Constant const*, unsigned char) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0LL
		local reg_0, reg_1
		local br_map, temp = {}, nil
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_1
		if not br_map[1] then
			br_map[1] = (function() return { [0] = 0, 1, 2, 3 } end)()
		end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, param_2), 1)] or 4
		if temp < 2 then
			if temp < 1 then
				goto continue_at_7
			else
				goto continue_at_6
			end
		elseif temp > 2 then
			if temp < 4 then
				goto continue_at_4
			else
				goto continue_at_3
			end
		else
			goto continue_at_5
		end
		::continue_at_7::
		FUNC_LIST[114](load_i32(memory_at_0, param_0), 2, param_3, 0, 0)
		goto continue_at_3
		::continue_at_6::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 3, param_3,
				load_i32_u8(memory_at_0, param_2 + 8), 0
		)
		goto continue_at_3
		::continue_at_5::
		loc_0 = load_f64(memory_at_0, param_2 + 8)
		if (loc_0 >= -3.2768e4 and 1 or 0) == 0 then goto continue_at_8 end
		if (loc_0 <= 3.2767e4 and 1 or 0) == 0 then goto continue_at_8 end
		reg_0 = loc_0
		if abs_f64(loc_0) < 2.147483648e9 then
			reg_1 = truncate_i32_f64(loc_0)
			goto continue_at_9
		end
		reg_1 = -2147483648
		::continue_at_9::
		param_2 = reg_1
		if reg_0 ~= convert_f64_i32(param_2) then goto continue_at_8 end
		if band_i32(
			(reinterpret_i64_f64(loc_0) < 0LL and 1 or 0),
				(loc_0 == 0e0 and 1 or 0)
		) ~= 0 then goto continue_at_8 end
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 4, param_3, param_2)
		goto continue_at_3
		::continue_at_8::
		reg_0 = FUNC_LIST[102](load_i32(memory_at_0, param_0), loc_0)
		param_2 = reg_0
		if param_2 < 0 then goto continue_at_2 end
		param_1 = load_i32(memory_at_0, param_0)
		if le_u32(param_2, 32767) then
			FUNC_LIST[116](param_1, 5, param_3, shr_i32(shl_i32(param_2, 16), 16))
			goto continue_at_3
		end
		FUNC_LIST[116](param_1, 66, param_3, 0)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), param_2)
		goto continue_at_3
		::continue_at_4::
		loc_2 = load_i32(memory_at_0, param_0)
		loc_3 = rotl_i64(load_i64(memory_at_0, param_2 + 4), 32LL )
		store_i64(memory_at_0, loc_1 + 8, loc_3)
		store_i64(memory_at_0, loc_1, loc_3)
		reg_0 = FUNC_LIST[103](loc_2, loc_1)
		param_2 = reg_0
		if param_2 < 0 then goto continue_at_1 end
		param_1 = load_i32(memory_at_0, param_0)
		if le_u32(param_2, 32767) then
			FUNC_LIST[116](param_1, 5, param_3, shr_i32(shl_i32(param_2, 16), 16))
			goto continue_at_3
		end
		FUNC_LIST[116](param_1, 66, param_3, 0)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), param_2)
		::continue_at_3::
		GLOBAL_LIST[0].value = add_i32(loc_1, 16)
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[359] = --[[ Luau::Compiler::shouldShareClosure(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		loc_2 = load_i32(memory_at_0, param_0 + 28)
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_2 == loc_0 then goto continue_at_1 end
		loc_5 = load_i32(memory_at_0, param_0 + 44)
		if loc_5 == param_1 then goto continue_at_1 end
		loc_1 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_4 = sub_i32(div_i32(sub_i32(loc_0, loc_2), 40), 1)
		loc_0 = 0
		::continue_at_2::
		while true do
			loc_1 = band_i32(loc_1, loc_4)
			loc_6 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 40)))
			if param_1 ~= loc_6 then
				if loc_5 == loc_6 then goto continue_at_1 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_4) then goto continue_at_2 end
				goto continue_at_1
			end
			break
		end
		loc_0 = add_i32(loc_2, mul_i32(loc_1, 40))
		loc_7 = load_i32(memory_at_0, loc_0 + 12)
		loc_9 = load_i32(memory_at_0, loc_0 + 16)
		if loc_7 == loc_9 then
			reg_0 = 1
			goto continue_at_0
		end
		::continue_at_5::
		while true do
			loc_3 = 0
			loc_5 = load_i32(memory_at_0, param_0 + 100)
			loc_0 = load_i32(memory_at_0, param_0 + 104)
			if loc_5 == loc_0 then goto continue_at_1 end
			loc_2 = load_i32(memory_at_0, loc_7)
			loc_10 = load_i32(memory_at_0, param_0 + 116)
			if loc_2 == loc_10 then goto continue_at_1 end
			loc_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
			loc_4 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 12), 1)
			loc_0 = 0
			::continue_at_6::
			while true do
				loc_6 = band_i32(loc_1, loc_4)
				loc_8 = add_i32(loc_5, mul_i32(loc_6, 12))
				loc_1 = load_i32(memory_at_0, loc_8)
				if loc_2 ~= loc_1 then
					if loc_1 == loc_10 then goto continue_at_1 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_6)
					if le_u32(loc_0, loc_4) then goto continue_at_6 end
					goto continue_at_1
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_8 + 8) ~= 0 then goto continue_at_1 end
			if load_i32(memory_at_0, loc_2 + 24) == 0 then
				if load_i32(memory_at_0, loc_2 + 28) == 0 then goto continue_at_8 end
			end
			loc_0 = load_i32(memory_at_0, loc_8 + 4)
			if loc_0 == 0 then goto continue_at_1 end
			if load_i32(memory_at_0, loc_0 + 4) ~= load_i32(memory_at_0, 54988) then
				goto continue_at_1
			end
			if param_1 == loc_0 then goto continue_at_8 end
			reg_0 = FUNC_LIST[359](param_0, loc_0)
			if reg_0 == 0 then goto continue_at_1 end
			::continue_at_8::
			loc_3 = 1
			loc_7 = add_i32(loc_7, 4)
			if loc_7 ~= loc_9 then goto continue_at_5 end
			break
		end
		::continue_at_1::
		reg_0 = loc_3
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[360] = --[[ std::__2::__vector_base<Luau::Compiler::Capture, std::__2::allocator<Luau::Compiler::Capture> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[361] = --[[ Luau::Compiler::compileCompareJump(Luau::AstExprBinary*, bool) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_9 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_9
		if not br_map[1] then
			br_map[1] = (function() return { [0] = 0, 1, 2, 3, 2, 3 } end)()
		end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, param_1 + 24), 7)] or 4
		if temp < 2 then
			if temp < 1 then
				goto continue_at_5
			else
				goto continue_at_4
			end
		elseif temp > 2 then
			if temp < 4 then
				goto continue_at_2
			else
				goto continue_at_1
			end
		else
			goto continue_at_3
		end
		::continue_at_5::
		loc_7 = (param_2 ~= 0 and 27 or 30)
		goto continue_at_1
		::continue_at_4::
		loc_7 = (param_2 ~= 0 and 30 or 27)
		goto continue_at_1
		::continue_at_3::
		loc_7 = (param_2 ~= 0 and 32 or 29)
		goto continue_at_1
		::continue_at_2::
		loc_7 = (param_2 ~= 0 and 31 or 28)
		::continue_at_1::
		loc_10 = load_i32(memory_at_0, param_0 + 196)
		loc_5 = load_i32(memory_at_0, param_1 + 32)
		loc_3 = load_i32(memory_at_0, param_1 + 28)
		loc_0 = load_i32(memory_at_0, param_0 + 124)
		loc_12 = load_i32(memory_at_0, param_0 + 128)
		loc_11 = (loc_0 == loc_12 and 1 or 0)
		if loc_11 ~= 0 then goto continue_at_6 end
		loc_8 = load_i32(memory_at_0, param_0 + 140)
		if loc_8 == loc_5 then goto continue_at_6 end
		loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
		loc_4 = sub_i32(div_i32(sub_i32(loc_12, loc_0), 24), 1)
		param_2 = 0
		::continue_at_7::
		while true do
			loc_1 = band_i32(loc_1, loc_4)
			loc_2 = load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)))
			if loc_5 ~= loc_2 then
				if loc_2 == loc_8 then goto continue_at_6 end
				param_2 = add_i32(param_2, 1)
				loc_1 = add_i32(param_2, loc_1)
				if le_u32(param_2, loc_4) then goto continue_at_7 end
				goto continue_at_6
			end
			break
		end
		loc_6 =
			(load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)) + 8) ~= 0 and 1 or
				0)
		::continue_at_6::
		loc_2 = loc_3
		if not br_map[2] then
			br_map[2] = (function() return { [0] = 0, 1, 1, 0 } end)()
		end
		temp = br_map[2][sub_i32(loc_7, 27)] or 1
		if temp < 1 then
			goto continue_at_10
		else
			goto continue_at_9
		end
		::continue_at_10::
		if bor_i32(loc_6, loc_11) ~= 0 then goto continue_at_9 end
		loc_8 = load_i32(memory_at_0, param_0 + 140)
		if loc_8 == loc_3 then goto continue_at_12 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_4 = sub_i32(div_i32(sub_i32(loc_12, loc_0), 24), 1)
		param_2 = 0
		::continue_at_14::
		while true do
			loc_1 = band_i32(loc_1, loc_4)
			loc_2 = load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)))
			if loc_2 == loc_3 then goto continue_at_13 end
			loc_6 = 0
			if loc_2 == loc_8 then
				loc_2 = loc_3
				goto continue_at_9
			end
			param_2 = add_i32(param_2, 1)
			loc_1 = add_i32(param_2, loc_1)
			if le_u32(param_2, loc_4) then goto continue_at_14 end
			break
		end
		loc_2 = loc_3
		goto continue_at_9
		::continue_at_13::
		if load_i32(memory_at_0, add_i32(loc_0, mul_i32(loc_1, 24)) + 8) == 0 then
			goto continue_at_12
		end
		loc_6 = 1
		loc_2 = loc_5
		loc_5 = loc_3
		goto continue_at_9
		::continue_at_12::
		loc_6 = 0
		loc_2 = loc_3
		::continue_at_9::
		param_2 = load_i32(memory_at_0, loc_2 + 4)
		loc_4 = load_i32(memory_at_0, 54940)
		if loc_2 ~= 0 then
			loc_0 = loc_2
			if param_2 == loc_4 then goto continue_at_19 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_1 = load_i32(memory_at_0, 54900)
		loc_0 = loc_2
		::continue_at_21::
		while true do
			if band_i32((param_2 ~= loc_1 and 1 or 0), (param_2 ~= loc_3 and 1 or 0)) ~=
				0 then goto continue_at_18 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			param_2 = load_i32(memory_at_0, loc_0 + 4)
			if loc_0 == 0 then goto continue_at_21 end
			if param_2 ~= loc_4 then goto continue_at_21 end
			break
		end
		::continue_at_19::
		loc_3 = load_i32(memory_at_0, param_0 + 52)
		param_2 = load_i32(memory_at_0, param_0 + 56)
		if loc_3 == param_2 then goto continue_at_18 end
		loc_8 = load_i32(memory_at_0, loc_0 + 24)
		loc_11 = load_i32(memory_at_0, param_0 + 68)
		if loc_8 == loc_11 then goto continue_at_18 end
		loc_0 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
		loc_1 = sub_i32(div_i32(sub_i32(param_2, loc_3), 12), 1)
		param_2 = 0
		::continue_at_22::
		while true do
			loc_0 = band_i32(loc_0, loc_1)
			loc_4 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_0, 12)))
			if loc_8 ~= loc_4 then
				if loc_4 == loc_11 then goto continue_at_18 end
				param_2 = add_i32(param_2, 1)
				loc_0 = add_i32(param_2, loc_0)
				if le_u32(param_2, loc_1) then goto continue_at_22 end
				goto continue_at_18
			end
			break
		end
		param_2 = add_i32(loc_3, mul_i32(loc_0, 12))
		if load_i32_u8(memory_at_0, param_2 + 5) ~= 0 then goto continue_at_17 end
		::continue_at_18::
		param_2 = add_i32(loc_10, 1)
		if lt_u32(param_2, 256) then
			store_i32(memory_at_0, param_0 + 196, param_2)
			loc_0 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(param_2, loc_0) and loc_0 or param_2)
			)
			FUNC_LIST[348](param_0, loc_2, band_i32(loc_10, 255), 1)
			reg_0 = loc_10
			goto continue_at_16
		end
		store_i64(memory_at_0, loc_9, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_2, 8), 7407, loc_9)
		error("out of code bounds")
		::continue_at_17::
		reg_0 = load_i32_u8(memory_at_0, param_2 + 4)
		::continue_at_16::
		loc_8 = reg_0
		if not br_map[3] then
			br_map[3] = (function() return { [0] = 0, 1, 1, 0 } end)()
		end
		temp = br_map[3][sub_i32(loc_7, 27)] or 1
		if temp < 1 then
			goto continue_at_27
		else
			goto continue_at_26
		end
		::continue_at_27::
		if loc_6 == 0 then goto continue_at_26 end
		loc_7 = (loc_7 == 27 and 71 or (loc_7 == 30 and 72 or loc_7))
		reg_0 = FUNC_LIST[362](param_0, loc_5)
		goto continue_at_25
		::continue_at_26::
		param_2 = load_i32(memory_at_0, loc_5 + 4)
		loc_6 = load_i32(memory_at_0, 54940)
		if loc_5 ~= 0 then
			loc_0 = loc_5
			if param_2 == loc_6 then goto continue_at_31 end
		end
		loc_4 = load_i32(memory_at_0, 55020)
		loc_1 = load_i32(memory_at_0, 54900)
		loc_0 = loc_5
		::continue_at_33::
		while true do
			if band_i32((param_2 ~= loc_1 and 1 or 0), (param_2 ~= loc_4 and 1 or 0)) ~=
				0 then goto continue_at_30 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			param_2 = load_i32(memory_at_0, loc_0 + 4)
			if loc_0 == 0 then goto continue_at_33 end
			if param_2 ~= loc_6 then goto continue_at_33 end
			break
		end
		::continue_at_31::
		loc_4 = load_i32(memory_at_0, param_0 + 52)
		param_2 = load_i32(memory_at_0, param_0 + 56)
		if loc_4 == param_2 then goto continue_at_30 end
		loc_2 = load_i32(memory_at_0, loc_0 + 24)
		loc_3 = load_i32(memory_at_0, param_0 + 68)
		if loc_2 == loc_3 then goto continue_at_30 end
		loc_0 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
		loc_1 = sub_i32(div_i32(sub_i32(param_2, loc_4), 12), 1)
		param_2 = 0
		::continue_at_34::
		while true do
			loc_0 = band_i32(loc_0, loc_1)
			loc_6 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_0, 12)))
			if loc_2 ~= loc_6 then
				if loc_3 == loc_6 then goto continue_at_30 end
				param_2 = add_i32(param_2, 1)
				loc_0 = add_i32(param_2, loc_0)
				if le_u32(param_2, loc_1) then goto continue_at_34 end
				goto continue_at_30
			end
			break
		end
		param_2 = add_i32(loc_4, mul_i32(loc_0, 12))
		if load_i32_u8(memory_at_0, param_2 + 5) ~= 0 then goto continue_at_29 end
		::continue_at_30::
		loc_0 = load_i32(memory_at_0, param_0 + 196)
		param_2 = add_i32(loc_0, 1)
		if lt_u32(param_2, 256) then
			store_i32(memory_at_0, param_0 + 196, param_2)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(param_2, loc_1) and loc_1 or param_2)
			)
			FUNC_LIST[348](param_0, loc_5, band_i32(loc_0, 255), 1)
			goto continue_at_28
		end
		store_i64(memory_at_0, loc_9 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_5, 8), 7407, add_i32(loc_9, 16))
		error("out of code bounds")
		::continue_at_29::
		loc_0 = load_i32_u8(memory_at_0, param_2 + 4)
		::continue_at_28::
		reg_0 = band_i32(loc_0, 255)
		::continue_at_25::
		param_2 = reg_0
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		loc_1 = load_i32(memory_at_0, param_0)
		if le_u32(sub_i32(load_i32(memory_at_0, param_1 + 24), 11), 1) then
			FUNC_LIST[116](loc_1, loc_7, band_i32(param_2, 255), 0)
			FUNC_LIST[117](load_i32(memory_at_0, param_0), band_i32(loc_8, 255))
			goto continue_at_37
		end
		FUNC_LIST[116](loc_1, loc_7, band_i32(loc_8, 255), 0)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), param_2)
		::continue_at_37::
		store_i32(memory_at_0, param_0 + 196, loc_10)
		GLOBAL_LIST[0].value = add_i32(loc_9, 32)
		reg_0 = loc_0
		return reg_0
	end
FUNC_LIST[362] = --[[ Luau::Compiler::getConstantIndex(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0LL
		local reg_0
		local br_map, temp = {}, nil
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = -1
		loc_4 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_4 == loc_0 then goto continue_at_1 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		if loc_6 == param_1 then goto continue_at_1 end
		loc_1 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_5 = sub_i32(div_i32(sub_i32(loc_0, loc_4), 24), 1)
		loc_0 = 0
		::continue_at_2::
		while true do
			loc_1 = band_i32(loc_1, loc_5)
			loc_7 = load_i32(memory_at_0, add_i32(loc_4, mul_i32(loc_1, 24)))
			if param_1 ~= loc_7 then
				if loc_6 == loc_7 then goto continue_at_1 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_5) then goto continue_at_2 end
				goto continue_at_1
			end
			break
		end
		loc_0 = add_i32(loc_4, mul_i32(loc_1, 24))
		if not br_map[1] then
			br_map[1] = (function() return { [0] = 0, 1, 2, 3 } end)()
		end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, loc_0 + 8), 1)] or 5
		if temp < 2 then
			if temp < 1 then
				goto continue_at_8
			else
				goto continue_at_7
			end
		elseif temp > 2 then
			if temp < 5 then
				goto continue_at_5
			else
				goto continue_at_1
			end
		else
			goto continue_at_6
		end
		::continue_at_8::
		reg_0 = FUNC_LIST[100](load_i32(memory_at_0, param_0))
		goto continue_at_4
		::continue_at_7::
		reg_0 = FUNC_LIST[101](
			load_i32(memory_at_0, param_0), load_i32_u8(memory_at_0, loc_0 + 16)
		)
		goto continue_at_4
		::continue_at_6::
		reg_0 = FUNC_LIST[102](
			load_i32(memory_at_0, param_0), load_f64(memory_at_0, loc_0 + 16)
		)
		goto continue_at_4
		::continue_at_5::
		loc_1 = load_i32(memory_at_0, param_0)
		loc_8 = rotl_i64(load_i64(memory_at_0, loc_0 + 12), 32LL )
		store_i64(memory_at_0, loc_2 + 8, loc_8)
		store_i64(memory_at_0, loc_2, loc_8)
		reg_0 = FUNC_LIST[103](loc_1, loc_2)
		::continue_at_4::
		loc_3 = reg_0
		if loc_3 >= 0 then goto continue_at_1 end
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = loc_3
		return reg_0
	end
FUNC_LIST[363] = --[[ Luau::Compiler::compileExprGlobal(Luau::AstExprGlobal*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0, reg_1, reg_2, reg_3, reg_4
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		if load_i32(memory_at_0, param_0 + 4) <= 0 then goto continue_at_4 end
		loc_3 = load_i32(memory_at_0, param_1 + 24)
		loc_5 = load_i32(memory_at_0, param_0 + 76)
		loc_1 = load_i32(memory_at_0, param_0 + 80)
		if loc_5 == loc_1 then goto continue_at_5 end
		loc_6 = load_i32(memory_at_0, param_0 + 92)
		if loc_6 == loc_3 then goto continue_at_5 end
		loc_2 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_4 = sub_i32(shr_i32(sub_i32(loc_1, loc_5), 3), 1)
		loc_1 = 0
		::continue_at_6::
		while true do
			loc_2 = band_i32(loc_2, loc_4)
			loc_7 = load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_2, 3)))
			if loc_3 ~= loc_7 then
				if loc_6 == loc_7 then goto continue_at_5 end
				loc_1 = add_i32(loc_1, 1)
				loc_2 = add_i32(loc_1, loc_2)
				if le_u32(loc_1, loc_4) then goto continue_at_6 end
				goto continue_at_5
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_2, 3)) + 4) == 2 then
			goto continue_at_4
		end
		::continue_at_5::
		loc_1 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, loc_0 + 40, loc_3)
		reg_1 = FUNC_LIST[1197](loc_3)
		store_i32(memory_at_0, loc_0 + 44, reg_1)
		store_i64(memory_at_0, loc_0 + 16, load_i64(memory_at_0, loc_0 + 40))
		reg_0 = FUNC_LIST[103](loc_1, add_i32(loc_0, 16))
		loc_1 = reg_0
		if loc_1 < 0 then goto continue_at_2 end
		if gt_u32(loc_1, 1023) then goto continue_at_4 end
		reg_0 = FUNC_LIST[136](loc_1)
		loc_2 = reg_0
		reg_0 = FUNC_LIST[104](load_i32(memory_at_0, param_0), loc_2)
		loc_1 = reg_0
		if gt_u32(loc_1, 32767) then goto continue_at_4 end
		FUNC_LIST[116](
			load_i32(memory_at_0, param_0), 12, param_2, shr_i32(shl_i32(loc_1, 16), 16)
		)
		goto continue_at_3
		::continue_at_4::
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, param_1 + 24)
		reg_1 = FUNC_LIST[1197](loc_1)
		loc_4 = reg_1
		store_i32(memory_at_0, loc_0 + 36, loc_4)
		store_i32(memory_at_0, loc_0 + 32, loc_1)
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_0 + 32))
		reg_0 = FUNC_LIST[103](loc_2, add_i32(loc_0, 8))
		loc_2 = reg_0
		if loc_2 < 0 then goto continue_at_1 end
		loc_3 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, loc_0 + 28, loc_4)
		store_i32(memory_at_0, loc_0 + 24, loc_1)
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_0 + 24))
		reg_4 = FUNC_LIST[139](loc_0)
		FUNC_LIST[114](loc_3, 7, param_2, 0, band_i32(reg_4, 255))
		::continue_at_3::
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_2)
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[364] = --[[ Luau::Compiler::compileExprIndexName(Luau::AstExprIndexName*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local reg_0, reg_1, reg_2, reg_3, reg_4
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 96)
		GLOBAL_LIST[0].value = loc_2
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 8), 1)
			)
		end
		loc_0 = load_i32(memory_at_0, param_1 + 24)
		loc_1 = load_i32(memory_at_0, loc_0 + 4)
		if loc_1 ~= load_i32(memory_at_0, 54972) then goto continue_at_6 end
		if loc_0 == 0 then goto continue_at_6 end
		loc_5 = param_1
		loc_9 = loc_0
		loc_1 = load_i32(memory_at_0, loc_0 + 24)
		loc_0 = loc_1
		if load_i32(memory_at_0, loc_1 + 4) == load_i32(memory_at_0, 54948) then
			goto continue_at_5
		end
		goto continue_at_4
		::continue_at_6::
		loc_9 = param_1
		if loc_1 ~= load_i32(memory_at_0, 54948) then goto continue_at_4 end
		::continue_at_5::
		if load_i32(memory_at_0, param_0 + 4) <= 0 then goto continue_at_4 end
		loc_4 = load_i32(memory_at_0, loc_0 + 24)
		loc_6 = load_i32(memory_at_0, param_0 + 76)
		loc_0 = load_i32(memory_at_0, param_0 + 80)
		if loc_6 == loc_0 then goto continue_at_7 end
		loc_7 = load_i32(memory_at_0, param_0 + 92)
		if loc_7 == loc_4 then goto continue_at_7 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_3 = sub_i32(shr_i32(sub_i32(loc_0, loc_6), 3), 1)
		loc_0 = 0
		::continue_at_8::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_8 = load_i32(memory_at_0, add_i32(loc_6, shl_i32(loc_1, 3)))
			if loc_4 ~= loc_8 then
				if loc_7 == loc_8 then goto continue_at_7 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_8 end
				goto continue_at_7
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_6, shl_i32(loc_1, 3)) + 4) ~= 0 then
			goto continue_at_4
		end
		::continue_at_7::
		loc_0 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, loc_2 + 88, loc_4)
		reg_1 = FUNC_LIST[1197](loc_4)
		store_i32(memory_at_0, loc_2 + 92, reg_1)
		store_i64(memory_at_0, loc_2 + 48, load_i64(memory_at_0, loc_2 + 88))
		reg_0 = FUNC_LIST[103](loc_0, add_i32(loc_2, 48))
		loc_0 = reg_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_3 = load_i32(memory_at_0, loc_9 + 28)
		store_i32(memory_at_0, loc_2 + 80, loc_3)
		reg_1 = FUNC_LIST[1197](loc_3)
		store_i32(memory_at_0, loc_2 + 84, reg_1)
		store_i64(memory_at_0, loc_2 + 40, load_i64(memory_at_0, loc_2 + 80))
		reg_0 = FUNC_LIST[103](loc_1, add_i32(loc_2, 40))
		loc_1 = reg_0
		if loc_5 ~= 0 then
			loc_3 = load_i32(memory_at_0, param_0)
			loc_4 = load_i32(memory_at_0, loc_5 + 28)
			store_i32(memory_at_0, loc_2 + 72, loc_4)
			reg_1 = FUNC_LIST[1197](loc_4)
			store_i32(memory_at_0, loc_2 + 76, reg_1)
			store_i64(memory_at_0, loc_2 + 32, load_i64(memory_at_0, loc_2 + 72))
			reg_0 = FUNC_LIST[103](loc_3, add_i32(loc_2, 32))
		else
			reg_0 = -1
		end
		loc_3 = reg_0
		if bor_i32(loc_0, loc_1) < 0 then goto continue_at_12 end
		if band_i32((loc_5 ~= 0 and 1 or 0), (loc_3 < 0 and 1 or 0)) ~= 0 then
			goto continue_at_12
		end
		if loc_0 > 1023 then goto continue_at_4 end
		if loc_1 > 1023 then goto continue_at_4 end
		if loc_3 > 1023 then goto continue_at_4 end
		if loc_5 ~= 0 then
			reg_0 = FUNC_LIST[138](loc_0, loc_1, loc_3)
			goto continue_at_13
		end
		reg_0 = FUNC_LIST[137](loc_0, loc_1)
		::continue_at_13::
		loc_0 = reg_0
		reg_0 = FUNC_LIST[104](load_i32(memory_at_0, param_0), loc_0)
		loc_1 = reg_0
		if gt_u32(loc_1, 32767) then goto continue_at_4 end
		FUNC_LIST[116](
			load_i32(memory_at_0, param_0), 12, param_2, shr_i32(shl_i32(loc_1, 16), 16)
		)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_0)
		goto continue_at_3
		::continue_at_12::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_4::
		loc_4 = load_i32(memory_at_0, 54940)
		loc_5 = load_i32(memory_at_0, param_0 + 196)
		loc_7 = load_i32(memory_at_0, param_1 + 24)
		loc_0 = load_i32(memory_at_0, loc_7 + 4)
		if loc_7 ~= 0 then
			loc_1 = loc_7
			if loc_0 == loc_4 then goto continue_at_18 end
		end
		loc_8 = load_i32(memory_at_0, 55020)
		loc_3 = load_i32(memory_at_0, 54900)
		loc_1 = loc_7
		::continue_at_20::
		while true do
			if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_8 and 1 or 0)) ~= 0 then
				goto continue_at_17
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_20 end
			if loc_0 ~= loc_4 then goto continue_at_20 end
			break
		end
		::continue_at_18::
		loc_8 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_8 == loc_0 then goto continue_at_17 end
		loc_6 = load_i32(memory_at_0, loc_1 + 24)
		loc_9 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_9 then goto continue_at_17 end
		loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_8), 12), 1)
		loc_0 = 0
		::continue_at_21::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_4 = load_i32(memory_at_0, add_i32(loc_8, mul_i32(loc_1, 12)))
			if loc_6 ~= loc_4 then
				if loc_4 == loc_9 then goto continue_at_17 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_21 end
				goto continue_at_17
			end
			break
		end
		loc_0 = add_i32(loc_8, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_16 end
		::continue_at_17::
		loc_0 = add_i32(loc_5, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_7, band_i32(loc_5, 255), 1)
			reg_0 = loc_5
			goto continue_at_15
		end
		store_i64(memory_at_0, loc_2, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_7, 8), 7407, loc_2)
		error("out of code bounds")
		::continue_at_16::
		reg_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_15::
		loc_3 = reg_0
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, param_1 + 32), 1)
			)
		end
		loc_1 = load_i32(memory_at_0, param_0)
		loc_0 = load_i32(memory_at_0, param_1 + 28)
		reg_1 = FUNC_LIST[1197](loc_0)
		loc_4 = reg_1
		store_i32(memory_at_0, loc_2 + 68, loc_4)
		store_i32(memory_at_0, loc_2 + 64, loc_0)
		store_i64(memory_at_0, loc_2 + 24, load_i64(memory_at_0, loc_2 + 64))
		reg_0 = FUNC_LIST[103](loc_1, add_i32(loc_2, 24))
		loc_1 = reg_0
		if loc_1 < 0 then goto continue_at_2 end
		param_1 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, loc_2 + 60, loc_4)
		store_i32(memory_at_0, loc_2 + 56, loc_0)
		store_i64(memory_at_0, loc_2 + 16, load_i64(memory_at_0, loc_2 + 56))
		reg_4 = FUNC_LIST[139](add_i32(loc_2, 16))
		FUNC_LIST[114](
			param_1, 15, param_2, band_i32(loc_3, 255), band_i32(reg_4, 255)
		)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_1)
		store_i32(memory_at_0, param_0 + 196, loc_5)
		::continue_at_3::
		GLOBAL_LIST[0].value = add_i32(loc_2, 96)
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[365] = --[[ Luau::Compiler::compileExprIndexExpr(Luau::AstExprIndexExpr*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local reg_0, reg_1, reg_2, reg_3, reg_4
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 96)
		GLOBAL_LIST[0].value = loc_5
		loc_4 = load_i32(memory_at_0, param_1 + 28)
		loc_10 = load_i32(memory_at_0, param_0 + 196)
		loc_3 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_3 == loc_0 then goto continue_at_2 end
		loc_8 = load_i32(memory_at_0, param_0 + 140)
		if loc_8 == loc_4 then goto continue_at_2 end
		loc_1 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 24), 1)
		loc_0 = 0
		::continue_at_3::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_6 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 24)))
			if loc_4 ~= loc_6 then
				if loc_6 == loc_8 then goto continue_at_2 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_3 end
				goto continue_at_2
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 24))
		loc_6 = load_i32(memory_at_0, loc_0 + 12)
		loc_11 = load_f64(memory_at_0, loc_0 + 16)
		loc_0 = load_i32(memory_at_0, loc_0 + 8)
		if loc_0 ~= 3 then goto continue_at_7 end
		if (loc_11 >= 1e0 and 1 or 0) == 0 then goto continue_at_7 end
		if (loc_11 <= 2.56e2 and 1 or 0) == 0 then goto continue_at_7 end
		reg_0 = loc_11
		if abs_f64(loc_11) < 2.147483648e9 then
			reg_1 = truncate_i32_f64(loc_11)
			goto continue_at_8
		end
		reg_1 = -2147483648
		::continue_at_8::
		loc_8 = reg_1
		if reg_0 ~= convert_f64_i32(loc_8) then goto continue_at_2 end
		loc_4 = load_i32(memory_at_0, 54940)
		loc_7 = load_i32(memory_at_0, param_1 + 24)
		loc_0 = load_i32(memory_at_0, loc_7 + 4)
		if loc_7 ~= 0 then
			loc_1 = loc_7
			if loc_0 == loc_4 then goto continue_at_11 end
		end
		loc_6 = load_i32(memory_at_0, 55020)
		loc_2 = load_i32(memory_at_0, 54900)
		loc_1 = loc_7
		::continue_at_13::
		while true do
			if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_6 and 1 or 0)) ~= 0 then
				goto continue_at_10
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_13 end
			if loc_0 ~= loc_4 then goto continue_at_13 end
			break
		end
		::continue_at_11::
		loc_6 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_6 == loc_0 then goto continue_at_10 end
		loc_3 = load_i32(memory_at_0, loc_1 + 24)
		loc_9 = load_i32(memory_at_0, param_0 + 68)
		if loc_3 == loc_9 then goto continue_at_10 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_6), 12), 1)
		loc_0 = 0
		::continue_at_14::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_4 = load_i32(memory_at_0, add_i32(loc_6, mul_i32(loc_1, 12)))
			if loc_3 ~= loc_4 then
				if loc_4 == loc_9 then goto continue_at_10 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_14 end
				goto continue_at_10
			end
			break
		end
		loc_0 = add_i32(loc_6, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_6 end
		::continue_at_10::
		loc_0 = add_i32(loc_10, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_7, band_i32(loc_10, 255), 1)
			reg_0 = loc_10
			goto continue_at_5
		end
		store_i64(memory_at_0, loc_5 + 32, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_7, 8), 7407, add_i32(loc_5, 32))
		error("out of code bounds")
		::continue_at_7::
		if loc_0 ~= 4 then goto continue_at_2 end
		loc_0 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, loc_5 + 92, loc_6)
		loc_12 = wrap_i32_i64(reinterpret_i64_f64(loc_11))
		store_i32(memory_at_0, loc_5 + 88, loc_12)
		store_i64(memory_at_0, loc_5 + 72, load_i64(memory_at_0, loc_5 + 88))
		reg_0 = FUNC_LIST[103](loc_0, add_i32(loc_5, 72))
		loc_13 = reg_0
		if loc_13 >= 0 then
			loc_4 = load_i32(memory_at_0, 54940)
			loc_7 = load_i32(memory_at_0, param_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_7 + 4)
			if loc_7 ~= 0 then
				loc_1 = loc_7
				if loc_0 == loc_4 then goto continue_at_21 end
			end
			loc_3 = load_i32(memory_at_0, 55020)
			loc_2 = load_i32(memory_at_0, 54900)
			loc_1 = loc_7
			::continue_at_23::
			while true do
				if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
					goto continue_at_20
				end
				loc_1 = load_i32(memory_at_0, loc_1 + 24)
				loc_0 = load_i32(memory_at_0, loc_1 + 4)
				if loc_1 == 0 then goto continue_at_23 end
				if loc_0 ~= loc_4 then goto continue_at_23 end
				break
			end
			::continue_at_21::
			loc_3 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_3 == loc_0 then goto continue_at_20 end
			loc_8 = load_i32(memory_at_0, loc_1 + 24)
			loc_9 = load_i32(memory_at_0, param_0 + 68)
			if loc_8 == loc_9 then goto continue_at_20 end
			loc_1 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
			loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 12), 1)
			loc_0 = 0
			::continue_at_24::
			while true do
				loc_1 = band_i32(loc_1, loc_2)
				loc_4 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 12)))
				if loc_8 ~= loc_4 then
					if loc_4 == loc_9 then goto continue_at_20 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_1)
					if le_u32(loc_0, loc_2) then goto continue_at_24 end
					goto continue_at_20
				end
				break
			end
			loc_0 = add_i32(loc_3, mul_i32(loc_1, 12))
			if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_18 end
			::continue_at_20::
			loc_1 = load_i32(memory_at_0, param_0 + 196)
			loc_0 = add_i32(loc_1, 1)
			if lt_u32(loc_0, 256) then
				store_i32(memory_at_0, param_0 + 196, loc_0)
				loc_2 = load_i32(memory_at_0, param_0 + 200)
				store_i32(
					memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
				)
				FUNC_LIST[348](param_0, loc_7, band_i32(loc_1, 255), 1)
				goto continue_at_17
			end
			store_i64(memory_at_0, loc_5 + 48, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_7, 8), 7407, add_i32(loc_5, 48))
			error("out of code bounds")
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_18::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_17::
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28) + 8), 1)
			)
		end
		loc_0 = load_i32(memory_at_0, param_0)
		store_i32(memory_at_0, loc_5 + 84, loc_6)
		store_i32(memory_at_0, loc_5 + 80, loc_12)
		store_i64(memory_at_0, loc_5 + 64, load_i64(memory_at_0, loc_5 + 80))
		reg_4 = FUNC_LIST[139](sub_i32(loc_5, -64))
		FUNC_LIST[114](loc_0, 15, param_2, band_i32(loc_1, 255), band_i32(reg_4, 255))
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_13)
		goto continue_at_1
		::continue_at_6::
		reg_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_5::
		loc_0 = reg_0
		loc_1 = sub_i32(loc_8, 1)
		if load_i32(memory_at_0, param_0 + 8) > 0 then
			FUNC_LIST[124](
				load_i32(memory_at_0, param_0),
					add_i32(load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28) + 8), 1)
			)
		end
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 17, param_2, band_i32(loc_0, 255),
				band_i32(loc_1, 255)
		)
		goto continue_at_1
		::continue_at_2::
		loc_2 = load_i32(memory_at_0, 54940)
		loc_9 = load_i32(memory_at_0, param_1 + 24)
		loc_0 = load_i32(memory_at_0, loc_9 + 4)
		if loc_9 ~= 0 then
			loc_1 = loc_9
			if loc_0 == loc_2 then goto continue_at_32 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_6 = load_i32(memory_at_0, 54900)
		loc_1 = loc_9
		::continue_at_34::
		while true do
			if band_i32((loc_0 ~= loc_6 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_31
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_34 end
			if loc_0 ~= loc_2 then goto continue_at_34 end
			break
		end
		::continue_at_32::
		loc_8 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_8 == loc_0 then goto continue_at_31 end
		loc_7 = load_i32(memory_at_0, loc_1 + 24)
		loc_12 = load_i32(memory_at_0, param_0 + 68)
		if loc_7 == loc_12 then goto continue_at_31 end
		loc_1 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
		loc_6 = sub_i32(div_i32(sub_i32(loc_0, loc_8), 12), 1)
		loc_0 = 0
		::continue_at_35::
		while true do
			loc_1 = band_i32(loc_1, loc_6)
			loc_3 = load_i32(memory_at_0, add_i32(loc_8, mul_i32(loc_1, 12)))
			if loc_7 ~= loc_3 then
				if loc_3 == loc_12 then goto continue_at_31 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_6) then goto continue_at_35 end
				goto continue_at_31
			end
			break
		end
		loc_0 = add_i32(loc_8, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_30 end
		::continue_at_31::
		loc_0 = add_i32(loc_10, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_9, band_i32(loc_10, 255), 1)
			loc_2 = load_i32(memory_at_0, 54940)
			loc_4 = load_i32(memory_at_0, param_1 + 28)
			reg_0 = loc_10
			goto continue_at_29
		end
		store_i64(memory_at_0, loc_5, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_9, 8), 7407, loc_5)
		error("out of code bounds")
		::continue_at_30::
		reg_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_29::
		param_1 = reg_0
		loc_0 = load_i32(memory_at_0, loc_4 + 4)
		if loc_4 ~= 0 then
			loc_1 = loc_4
			if loc_0 == loc_2 then goto continue_at_41 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_6 = load_i32(memory_at_0, 54900)
		loc_1 = loc_4
		::continue_at_43::
		while true do
			if band_i32((loc_0 ~= loc_6 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_40
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_43 end
			if loc_0 ~= loc_2 then goto continue_at_43 end
			break
		end
		::continue_at_41::
		loc_3 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_3 == loc_0 then goto continue_at_40 end
		loc_8 = load_i32(memory_at_0, loc_1 + 24)
		loc_7 = load_i32(memory_at_0, param_0 + 68)
		if loc_8 == loc_7 then goto continue_at_40 end
		loc_1 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 12), 1)
		loc_0 = 0
		::continue_at_44::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_6 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 12)))
			if loc_8 ~= loc_6 then
				if loc_6 == loc_7 then goto continue_at_40 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_44 end
				goto continue_at_40
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_39 end
		::continue_at_40::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_4, band_i32(loc_1, 255), 1)
			goto continue_at_38
		end
		store_i64(memory_at_0, loc_5 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_4, 8), 7407, add_i32(loc_5, 16))
		error("out of code bounds")
		::continue_at_39::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_38::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 13, param_2, band_i32(param_1, 255),
				band_i32(loc_1, 255)
		)
		::continue_at_1::
		store_i32(memory_at_0, param_0 + 196, loc_10)
		GLOBAL_LIST[0].value = add_i32(loc_5, 96)
	end
FUNC_LIST[366] = --[[ Luau::Compiler::compileExprTable(Luau::AstExprTable*, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local loc_17 = 0
		local loc_18 = 0
		local loc_19 = 0LL
		local loc_20 = 0
		local reg_0
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 208)
		GLOBAL_LIST[0].value = loc_3
		loc_16 = load_i32(memory_at_0, param_1 + 28)
		if loc_16 ~= 0 then
			loc_8 = band_i32(loc_16, 1)
			loc_12 = load_i32(memory_at_0, param_1 + 24)
			if loc_16 ~= 1 then goto continue_at_6 end
			goto continue_at_5
		end
		loc_11 = add_i32(param_0, 172)
		loc_5 = load_i32(memory_at_0, param_0 + 172)
		loc_0 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 176), loc_5), 12)
		if ge_u32(load_i32(memory_at_0, param_0 + 184), shr_u32(mul_i32(loc_0, 3), 2)) then
			FUNC_LIST[370](loc_11)
			loc_5 = load_i32(memory_at_0, loc_11)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_11 + 4), loc_5), 12)
		end
		loc_8 = sub_i32(loc_0, 1)
		loc_0 = band_i32(loc_8, bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9)))
		loc_4 = add_i32(loc_5, mul_i32(loc_0, 12))
		loc_1 = load_i32(memory_at_0, loc_4)
		loc_14 = load_i32(memory_at_0, loc_11 + 16)
		if loc_1 ~= loc_14 then
			::continue_at_11::
			while true do
				if param_1 == loc_1 then goto continue_at_9 end
				loc_2 = add_i32(loc_2, 1)
				loc_0 = band_i32(add_i32(loc_2, loc_0), loc_8)
				loc_4 = add_i32(loc_5, mul_i32(loc_0, 12))
				loc_1 = load_i32(memory_at_0, loc_4)
				if loc_1 ~= loc_14 then goto continue_at_11 end
				break
			end
		end
		store_i32(memory_at_0, loc_4, param_1)
		store_i32(
			memory_at_0, loc_11 + 12, add_i32(load_i32(memory_at_0, loc_11 + 12), 1)
		)
		::continue_at_9::
		loc_0 = add_i32(loc_5, mul_i32(loc_0, 12))
		loc_5 = load_i32(memory_at_0, loc_0 + 4)
		loc_2 = load_i32(memory_at_0, loc_0 + 8)
		loc_4 = load_i32(memory_at_0, param_0)
		loc_0 = 0
		::continue_at_12::
		while true do
			loc_1 = loc_0
			loc_0 = add_i32(loc_1, 1)
			if lt_u32(shl_i32(1, loc_1), loc_2) then goto continue_at_12 end
			break
		end
		FUNC_LIST[114](
			loc_4, 53, param_2, band_i32((loc_2 ~= 0 and add_i32(loc_1, 1) or 0), 255), 0
		)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_5)
		goto continue_at_4
		::continue_at_6::
		loc_4 = band_i32(loc_16, -2)
		::continue_at_13::
		while true do
			loc_1 = load_i32(memory_at_0, add_i32(loc_12, mul_i32(loc_0, 12)))
			loc_2 =
				load_i32(memory_at_0, add_i32(loc_12, mul_i32(bor_i32(loc_0, 1), 12)))
			loc_10 = add_i32(
				add_i32(loc_10, (loc_1 == 1 and 1 or 0)), (loc_2 == 1 and 1 or 0)
			)
			loc_6 = add_i32(
				add_i32(loc_6, (loc_1 ~= 0 and 1 or 0)), (loc_2 ~= 0 and 1 or 0)
			)
			loc_9 = add_i32(
				(loc_2 == 0 and 1 or 0), add_i32(loc_9, (loc_1 == 0 and 1 or 0))
			)
			loc_0 = add_i32(loc_0, 2)
			loc_5 = add_i32(loc_5, 2)
			if loc_5 ~= loc_4 then goto continue_at_13 end
			break
		end
		::continue_at_5::
		if loc_8 ~= 0 then
			loc_0 = load_i32(memory_at_0, add_i32(loc_12, mul_i32(loc_0, 12)))
			loc_10 = add_i32(loc_10, (loc_0 == 1 and 1 or 0))
			loc_9 = add_i32(loc_9, (loc_0 == 0 and 1 or 0))
			loc_6 = add_i32(loc_6, (loc_0 ~= 0 and 1 or 0))
		end
		reg_0 = 0
		if loc_9 ~= 0 then goto continue_at_15 end
		reg_0 = 0
		if loc_6 == 0 then goto continue_at_15 end
		loc_17 = (gt_u32(loc_16, 1) and loc_16 or 1)
		loc_20 = load_i32(memory_at_0, param_0 + 128)
		loc_14 = load_i32(memory_at_0, param_0 + 124)
		loc_2 = sub_i32(div_i32(sub_i32(loc_20, loc_14), 24), 1)
		loc_11 = load_i32(memory_at_0, param_0 + 140)
		::continue_at_16::
		while true do
			loc_4 = 0
			if loc_14 == loc_20 then goto continue_at_17 end
			loc_8 = load_i32(memory_at_0, add_i32(loc_12, mul_i32(loc_15, 12)) + 4)
			if loc_8 == loc_11 then goto continue_at_17 end
			loc_1 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
			loc_0 = 0
			::continue_at_18::
			while true do
				loc_5 = band_i32(loc_1, loc_2)
				loc_18 = add_i32(loc_14, mul_i32(loc_5, 24))
				loc_1 = load_i32(memory_at_0, loc_18)
				if loc_8 ~= loc_1 then
					if loc_1 == loc_11 then goto continue_at_17 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_5)
					if le_u32(loc_0, loc_2) then goto continue_at_18 end
					goto continue_at_17
				end
				break
			end
			if load_i32(memory_at_0, loc_18 + 8) ~= 3 then goto continue_at_17 end
			loc_4 = (load_f64(memory_at_0, loc_18 + 16) ==
				        convert_f64_u32(add_i32(loc_7, 1)) and 1 or 0)
			::continue_at_17::
			loc_7 = add_i32(loc_4, loc_7)
			loc_15 = add_i32(loc_15, 1)
			if loc_15 ~= loc_17 then goto continue_at_16 end
			break
		end
		loc_0 = (loc_6 == add_i32(loc_7, loc_10) and 1 or 0)
		loc_6 = (loc_0 ~= 0 and loc_10 or loc_6)
		reg_0 = (loc_0 ~= 0 and loc_7 or 0)
		::continue_at_15::
		loc_1 = reg_0
		::continue_at_20::
		while true do
			loc_0 = loc_13
			loc_13 = add_i32(loc_0, 1)
			if lt_u32(shl_i32(1, loc_0), loc_6) then goto continue_at_20 end
			break
		end
		loc_17 = load_i32(memory_at_0, param_0 + 196)
		loc_7 = param_2
		if param_3 == 0 then
			loc_2 = add_i32(loc_17, 1)
			if ge_u32(loc_2, 256) then goto continue_at_2 end
			store_i32(memory_at_0, param_0 + 196, loc_2)
			loc_5 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_2, loc_5) and loc_5 or loc_2)
			)
			loc_7 = loc_17
		end
		loc_5 = (loc_6 ~= 0 and add_i32(loc_0, 1) or 0)
		if bor_i32(loc_1, loc_9) ~= 0 then goto continue_at_23 end
		if gt_u32(sub_i32(loc_10, 1), 31) then goto continue_at_23 end
		if loc_6 ~= loc_10 then goto continue_at_23 end
		loc_0 = 0
		store_i32(memory_at_0, loc_3 + 200, 0)
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = load_i32(memory_at_0, loc_12 + 4)
		loc_19 = load_i64(
			memory_at_0,
				(load_i32(memory_at_0, loc_1 + 4) == load_i32(memory_at_0, 54932) and loc_1 or
					0) + 24
		)
		store_i64(memory_at_0, loc_3 + 64, loc_19)
		store_i64(memory_at_0, loc_3 + 40, loc_19)
		reg_0 = FUNC_LIST[103](loc_2, add_i32(loc_3, 40))
		loc_2 = reg_0
		if loc_2 >= 0 then
			::continue_at_26::
			while true do
				loc_1 = load_i32(memory_at_0, loc_3 + 200)
				store_i32(memory_at_0, loc_3 + 200, add_i32(loc_1, 1))
				store_i32(
					memory_at_0, add_i32(add_i32(loc_3, 72), shl_i32(loc_1, 2)),
						shr_i32(shl_i32(loc_2, 16), 16)
				)
				loc_0 = add_i32(loc_0, 1)
				if ge_u32(loc_0, load_i32(memory_at_0, param_1 + 28)) then
					goto continue_at_24
				end
				loc_2 = load_i32(memory_at_0, param_0)
				loc_1 = load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_1 + 24), mul_i32(loc_0, 12)) + 4
				)
				loc_19 = load_i64(
					memory_at_0,
						(load_i32(memory_at_0, loc_1 + 4) == load_i32(memory_at_0, 54932) and
							loc_1 or 0) + 24
				)
				store_i64(memory_at_0, loc_3 + 64, loc_19)
				store_i64(memory_at_0, loc_3 + 8, loc_19)
				reg_0 = FUNC_LIST[103](loc_2, add_i32(loc_3, 8))
				loc_2 = reg_0
				if loc_2 >= 0 then goto continue_at_26 end
				break
			end
		end
		FUNC_LIST[232](add_i32(loc_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_24::
		reg_0 = FUNC_LIST[105](load_i32(memory_at_0, param_0), add_i32(loc_3, 72))
		loc_0 = reg_0
		if loc_0 < 0 then goto continue_at_1 end
		loc_1 = load_i32(memory_at_0, param_0)
		if le_u32(loc_0, 32767) then
			FUNC_LIST[116](
				loc_1, 54, band_i32(loc_7, 255), shr_i32(shl_i32(loc_0, 16), 16)
			)
			goto continue_at_22
		end
		FUNC_LIST[114](loc_1, 53, band_i32(loc_7, 255), band_i32(loc_5, 255), 0)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), 0)
		goto continue_at_22
		::continue_at_23::
		loc_0 = 0
		reg_0 = loc_0
		if loc_12 == 0 then goto continue_at_28 end
		loc_2 = add_i32(loc_12, mul_i32(sub_i32(loc_16, 1), 12))
		reg_0 = 0
		if load_i32(memory_at_0, loc_2) ~= 0 then goto continue_at_28 end
		reg_0 = (load_i32(memory_at_0, load_i32(memory_at_0, loc_2 + 8) + 4) ==
			        load_i32(memory_at_0, 54956) and -1 or 0)
		::continue_at_28::
		loc_0 = reg_0
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 53, band_i32(loc_7, 255),
				band_i32(loc_5, 255), 0
		)
		FUNC_LIST[117](
			load_i32(memory_at_0, param_0), add_i32(add_i32(loc_1, loc_9), loc_0)
		)
		::continue_at_22::
		loc_15 = load_i32(memory_at_0, param_0 + 196)
		loc_9 = (lt_u32(loc_9, 16) and loc_9 or 16)
		loc_0 = add_i32(loc_15, loc_9)
		if ge_u32(loc_0, 256) then goto continue_at_3 end
		store_i32(memory_at_0, param_0 + 196, loc_0)
		loc_1 = load_i32(memory_at_0, param_0 + 200)
		store_i32(
			memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
		)
		if load_i32(memory_at_0, param_1 + 28) == 0 then goto continue_at_29 end
		loc_12 = band_i32(loc_7, 255)
		loc_6 = 0
		loc_10 = 0
		loc_13 = 1
		loc_0 = 0
		::continue_at_30::
		while true do
			loc_1 = add_i32(load_i32(memory_at_0, param_1 + 24), mul_i32(loc_6, 12))
			loc_4 = load_i32(memory_at_0, loc_1 + 8)
			loc_1 = load_i32(memory_at_0, loc_1 + 4)
			if load_i32(memory_at_0, param_0 + 8) > 0 then
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, loc_4 + 8), 1)
				)
			end
			if load_i32(memory_at_0, param_0 + 12) >= 2 then
				FUNC_LIST[114](load_i32(memory_at_0, param_0), 69, 0, 0, 0)
			end
			if loc_0 ~= 0 then
				if band_i32((loc_1 == 0 and 1 or 0), (loc_0 ~= loc_9 and 1 or 0)) ~= 0 then
					goto continue_at_36
				end
				FUNC_LIST[114](
					load_i32(memory_at_0, param_0), 55, loc_12, band_i32(loc_15, 255),
						band_i32(add_i32(loc_0, 1), 255)
				)
				FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_13)
				loc_13 = add_i32(loc_0, loc_13)
			end
			if loc_1 ~= 0 then goto continue_at_35 end
			loc_0 = 0
			::continue_at_36::
			loc_1 = add_i32(loc_0, loc_15)
			loc_6 = add_i32(loc_6, 1)
			if loc_6 ~= load_i32(memory_at_0, param_1 + 28) then goto continue_at_34 end
			reg_0 = FUNC_LIST[347](param_0, loc_4, band_i32(loc_1, 255))
			loc_10 = reg_0
			goto continue_at_33
			::continue_at_35::
			store_i32(memory_at_0, loc_3 + 56, param_0)
			store_i32(memory_at_0, loc_3 + 60, load_i32(memory_at_0, param_0 + 196))
			FUNC_LIST[371](add_i32(loc_3, 72), param_0, loc_12, loc_1, add_i32(loc_3, 56))
			loc_0 = load_i32(memory_at_0, loc_4 + 4)
			loc_5 = load_i32(memory_at_0, 54940)
			if loc_4 ~= 0 then
				loc_1 = loc_4
				if loc_0 == loc_5 then goto continue_at_42 end
			end
			loc_8 = load_i32(memory_at_0, 55020)
			loc_2 = load_i32(memory_at_0, 54900)
			loc_1 = loc_4
			::continue_at_44::
			while true do
				if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_8 and 1 or 0)) ~= 0 then
					goto continue_at_41
				end
				loc_1 = load_i32(memory_at_0, loc_1 + 24)
				loc_0 = load_i32(memory_at_0, loc_1 + 4)
				if loc_1 == 0 then goto continue_at_44 end
				if loc_0 ~= loc_5 then goto continue_at_44 end
				break
			end
			::continue_at_42::
			loc_14 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_14 == loc_0 then goto continue_at_41 end
			loc_8 = load_i32(memory_at_0, loc_1 + 24)
			loc_11 = load_i32(memory_at_0, param_0 + 68)
			if loc_8 == loc_11 then goto continue_at_41 end
			loc_1 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
			loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_14), 12), 1)
			loc_0 = 0
			::continue_at_45::
			while true do
				loc_5 = band_i32(loc_1, loc_2)
				loc_18 = add_i32(loc_14, mul_i32(loc_5, 12))
				loc_1 = load_i32(memory_at_0, loc_18)
				if loc_8 ~= loc_1 then
					if loc_1 == loc_11 then goto continue_at_41 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_5)
					if le_u32(loc_0, loc_2) then goto continue_at_45 end
					goto continue_at_41
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_18 + 5) ~= 0 then goto continue_at_40 end
			::continue_at_41::
			loc_1 = load_i32(memory_at_0, param_0 + 196)
			loc_0 = add_i32(loc_1, 1)
			if ge_u32(loc_0, 256) then goto continue_at_38 end
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_4, band_i32(loc_1, 255), 1)
			goto continue_at_39
			::continue_at_40::
			loc_1 = load_i32_u8(memory_at_0, loc_18 + 4)
			::continue_at_39::
			FUNC_LIST[355](param_0, add_i32(loc_3, 72), band_i32(loc_1, 255), 1)
			store_i32(
				memory_at_0, load_i32(memory_at_0, loc_3 + 56) + 196,
					load_i32(memory_at_0, loc_3 + 60)
			)
			loc_0 = 0
			loc_6 = add_i32(loc_6, 1)
			if lt_u32(loc_6, load_i32(memory_at_0, param_1 + 28)) then
				goto continue_at_30
			end
			goto continue_at_29
			::continue_at_38::
			store_i64(memory_at_0, loc_3 + 32, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_4, 8), 7407, add_i32(loc_3, 32))
			error("out of code bounds")
			::continue_at_34::
			loc_2 = load_i32(memory_at_0, param_0 + 196)
			loc_1 = band_i32(loc_1, 255)
			store_i32(memory_at_0, param_0 + 196, add_i32(loc_1, 1))
			FUNC_LIST[348](param_0, loc_4, loc_1, 1)
			store_i32(memory_at_0, param_0 + 196, loc_2)
			::continue_at_33::
			loc_0 = add_i32(loc_0, 1)
			if lt_u32(loc_6, load_i32(memory_at_0, param_1 + 28)) then
				goto continue_at_30
			end
			break
		end
		if loc_0 == 0 then goto continue_at_29 end
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), 55, band_i32(loc_7, 255),
				band_i32(loc_15, 255),
				band_i32((band_i32(loc_10, 1) ~= 0 and 0 or add_i32(loc_0, 1)), 255)
		)
		FUNC_LIST[117](load_i32(memory_at_0, param_0), loc_13)
		::continue_at_29::
		loc_0 = band_i32(loc_7, 255)
		if param_2 ~= loc_0 then
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 6, param_2, loc_0, 0)
		end
		store_i32(memory_at_0, param_0 + 196, loc_17)
		::continue_at_4::
		GLOBAL_LIST[0].value = add_i32(loc_3, 208)
		goto continue_at_0
		::continue_at_3::
		store_i32(memory_at_0, loc_3 + 20, 255)
		store_i32(memory_at_0, loc_3 + 16, loc_9)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_3, 16))
		error("out of code bounds")
		::continue_at_2::
		store_i64(memory_at_0, loc_3 + 48, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_3, 48))
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[367] = --[[ Luau::Compiler::compileExprUnary(Luau::AstExprUnary*, unsigned char) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local reg_0
		loc_7 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_7
		loc_4 = load_i32(memory_at_0, 54940)
		loc_5 = load_i32(memory_at_0, param_0 + 196)
		loc_2 = load_i32(memory_at_0, param_1 + 28)
		loc_0 = load_i32(memory_at_0, loc_2 + 4)
		if loc_2 ~= 0 then
			loc_1 = loc_2
			if loc_0 == loc_4 then goto continue_at_4 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_6 = load_i32(memory_at_0, 54900)
		loc_1 = loc_2
		::continue_at_6::
		while true do
			if band_i32((loc_0 ~= loc_6 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_3
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_6 end
			if loc_0 ~= loc_4 then goto continue_at_6 end
			break
		end
		::continue_at_4::
		loc_3 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_3 == loc_0 then goto continue_at_3 end
		loc_8 = load_i32(memory_at_0, loc_1 + 24)
		loc_9 = load_i32(memory_at_0, param_0 + 68)
		if loc_8 == loc_9 then goto continue_at_3 end
		loc_1 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
		loc_6 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 12), 1)
		loc_0 = 0
		::continue_at_7::
		while true do
			loc_1 = band_i32(loc_1, loc_6)
			loc_4 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 12)))
			if loc_8 ~= loc_4 then
				if loc_4 == loc_9 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_6) then goto continue_at_7 end
				goto continue_at_3
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_2 end
		::continue_at_3::
		loc_0 = add_i32(loc_5, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_1) and loc_1 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_2, band_i32(loc_5, 255), 1)
			reg_0 = loc_5
			goto continue_at_1
		end
		store_i64(memory_at_0, loc_7, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_2, 8), 7407, loc_7)
		error("out of code bounds")
		::continue_at_2::
		reg_0 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_1::
		loc_1 = reg_0
		loc_0 = load_i32(memory_at_0, param_1 + 24)
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0),
				(lt_u32(loc_0, 3) and add_i32(loc_0, 50) or 0), param_2,
				band_i32(loc_1, 255), 0
		)
		store_i32(memory_at_0, param_0 + 196, loc_5)
		GLOBAL_LIST[0].value = add_i32(loc_7, 16)
	end
FUNC_LIST[368] = --[[ Luau::Compiler::compileExprBinary(Luau::AstExprBinary*, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0LL
		local reg_0, reg_1
		local br_map, temp = {}, nil
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_3
		loc_9 = load_i32(memory_at_0, param_0 + 196)
		if not br_map[1] then
			br_map[1] = (function()
				return { [0] = 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 2, 2, 2, 1, 1 }
			end)()
		end
		temp = br_map[1][load_i32(memory_at_0, param_1 + 24)] or 7
		if temp < 2 then
			if temp < 1 then
				goto continue_at_8
			else
				goto continue_at_7
			end
		elseif temp > 2 then
			if temp < 7 then
				goto continue_at_5
			else
				goto continue_at_1
			end
		else
			goto continue_at_6
		end
		::continue_at_8::
		loc_2 = load_i32(memory_at_0, param_0 + 124)
		param_3 = load_i32(memory_at_0, param_0 + 128)
		if loc_2 == param_3 then goto continue_at_2 end
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		loc_5 = load_i32(memory_at_0, param_1 + 32)
		if loc_6 == loc_5 then goto continue_at_2 end
		loc_0 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
		loc_1 = sub_i32(div_i32(sub_i32(param_3, loc_2), 24), 1)
		param_3 = 0
		::continue_at_9::
		while true do
			loc_0 = band_i32(loc_0, loc_1)
			loc_4 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 24)))
			if loc_5 ~= loc_4 then
				if loc_4 == loc_6 then goto continue_at_2 end
				param_3 = add_i32(param_3, 1)
				loc_0 = add_i32(param_3, loc_0)
				if le_u32(param_3, loc_1) then goto continue_at_9 end
				goto continue_at_2
			end
			break
		end
		param_3 = add_i32(loc_2, mul_i32(loc_0, 24))
		if load_i32(memory_at_0, param_3 + 8) ~= 3 then goto continue_at_2 end
		reg_0 = FUNC_LIST[102](
			load_i32(memory_at_0, param_0), load_f64(memory_at_0, param_3 + 16)
		)
		loc_6 = reg_0
		if loc_6 >= 0 then
			if gt_u32(loc_6, 255) then goto continue_at_2 end
			loc_4 = load_i32(memory_at_0, 54940)
			loc_7 = load_i32(memory_at_0, param_1 + 28)
			param_3 = load_i32(memory_at_0, loc_7 + 4)
			if loc_7 ~= 0 then
				loc_0 = loc_7
				if param_3 == loc_4 then goto continue_at_13 end
			end
			loc_2 = load_i32(memory_at_0, 55020)
			loc_1 = load_i32(memory_at_0, 54900)
			loc_0 = loc_7
			::continue_at_15::
			while true do
				if band_i32((param_3 ~= loc_1 and 1 or 0), (param_3 ~= loc_2 and 1 or 0)) ~=
					0 then goto continue_at_12 end
				loc_0 = load_i32(memory_at_0, loc_0 + 24)
				param_3 = load_i32(memory_at_0, loc_0 + 4)
				if loc_0 == 0 then goto continue_at_15 end
				if param_3 ~= loc_4 then goto continue_at_15 end
				break
			end
			::continue_at_13::
			loc_2 = load_i32(memory_at_0, param_0 + 52)
			param_3 = load_i32(memory_at_0, param_0 + 56)
			if loc_2 == param_3 then goto continue_at_12 end
			loc_5 = load_i32(memory_at_0, loc_0 + 24)
			loc_8 = load_i32(memory_at_0, param_0 + 68)
			if loc_5 == loc_8 then goto continue_at_12 end
			loc_0 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
			loc_1 = sub_i32(div_i32(sub_i32(param_3, loc_2), 12), 1)
			param_3 = 0
			::continue_at_16::
			while true do
				loc_0 = band_i32(loc_0, loc_1)
				loc_4 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 12)))
				if loc_5 ~= loc_4 then
					if loc_4 == loc_8 then goto continue_at_12 end
					param_3 = add_i32(param_3, 1)
					loc_0 = add_i32(param_3, loc_0)
					if le_u32(param_3, loc_1) then goto continue_at_16 end
					goto continue_at_12
				end
				break
			end
			param_3 = add_i32(loc_2, mul_i32(loc_0, 12))
			if load_i32_u8(memory_at_0, param_3 + 5) ~= 0 then goto continue_at_4 end
			::continue_at_12::
			loc_0 = load_i32(memory_at_0, param_0 + 196)
			param_3 = add_i32(loc_0, 1)
			if lt_u32(param_3, 256) then
				store_i32(memory_at_0, param_0 + 196, param_3)
				loc_1 = load_i32(memory_at_0, param_0 + 200)
				store_i32(
					memory_at_0, param_0 + 200, (lt_u32(param_3, loc_1) and loc_1 or param_3)
				)
				FUNC_LIST[348](param_0, loc_7, band_i32(loc_0, 255), 1)
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_3 + 32, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_7, 8), 7407, add_i32(loc_3, 32))
			error("out of code bounds")
		end
		FUNC_LIST[232](add_i32(loc_5, 8), 6074, 0)
		error("out of code bounds")
		::continue_at_7::
		FUNC_LIST[372](param_0, param_1, param_2, param_3)
		goto continue_at_1
		::continue_at_6::
		reg_0 = FUNC_LIST[361](param_0, param_1, 0)
		param_3 = reg_0
		FUNC_LIST[114](load_i32(memory_at_0, param_0), 3, param_2, 0, 1)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_0 = reg_0
		FUNC_LIST[114](load_i32(memory_at_0, param_0), 3, param_2, 1, 0)
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), param_3, loc_0)
		if reg_0 ~= 0 then goto continue_at_1 end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_5::
		loc_10 = load_i64(memory_at_0, param_1 + 28)
		reg_1 = FUNC_LIST[1275](8)
		param_3 = reg_1
		store_i32(memory_at_0, loc_3 + 64, param_3)
		loc_0 = add_i32(param_3, 8)
		store_i32(memory_at_0, loc_3 + 72, loc_0)
		store_i64(memory_at_0, param_3, loc_10)
		store_i32(memory_at_0, loc_3 + 68, loc_0)
		FUNC_LIST[357](sub_i32(loc_3, -64))
		loc_2 = load_i32(memory_at_0, loc_3 + 68)
		loc_0 = load_i32(memory_at_0, loc_3 + 64)
		loc_4 = shr_i32(sub_i32(loc_2, loc_0), 2)
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		param_3 = add_i32(loc_4, loc_1)
		if lt_u32(param_3, 256) then
			store_i32(memory_at_0, param_0 + 196, param_3)
			param_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200,
					(gt_u32(param_1, param_3) and param_1 or param_3)
			)
			if loc_0 ~= loc_2 then
				param_3 = 0
				::continue_at_21::
				while true do
					FUNC_LIST[348](
						param_0, load_i32(memory_at_0, add_i32(loc_0, shl_i32(param_3, 2))),
							band_i32(add_i32(param_3, loc_1), 255), 1
					)
					param_3 = add_i32(param_3, 1)
					loc_0 = load_i32(memory_at_0, loc_3 + 64)
					loc_4 = shr_i32(sub_i32(load_i32(memory_at_0, loc_3 + 68), loc_0), 2)
					if lt_u32(param_3, loc_4) then goto continue_at_21 end
					break
				end
			end
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 49, param_2, band_i32(loc_1, 255),
					band_i32(sub_i32(add_i32(loc_1, loc_4), 1), 255)
			)
			param_3 = load_i32(memory_at_0, loc_3 + 64)
			if param_3 == 0 then goto continue_at_1 end
			store_i32(memory_at_0, loc_3 + 68, param_3)
			FUNC_LIST[1276](param_3)
			goto continue_at_1
		end
		store_i32(memory_at_0, loc_3 + 52, 255)
		store_i32(memory_at_0, loc_3 + 48, loc_4)
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_3, 48))
		error("out of code bounds")
		::continue_at_4::
		loc_0 = load_i32_u8(memory_at_0, param_3 + 4)
		::continue_at_3::
		param_3 = load_i32(memory_at_0, param_1 + 24)
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0),
				(lt_u32(param_3, 6) and add_i32(param_3, 39) or 0), param_2,
				band_i32(loc_0, 255), band_i32(loc_6, 255)
		)
		goto continue_at_1
		::continue_at_2::
		loc_1 = load_i32(memory_at_0, 54940)
		loc_7 = load_i32(memory_at_0, param_1 + 28)
		param_3 = load_i32(memory_at_0, loc_7 + 4)
		if loc_7 ~= 0 then
			loc_0 = loc_7
			if param_3 == loc_1 then goto continue_at_25 end
		end
		loc_2 = load_i32(memory_at_0, 55020)
		loc_4 = load_i32(memory_at_0, 54900)
		loc_0 = loc_7
		::continue_at_27::
		while true do
			if band_i32((param_3 ~= loc_4 and 1 or 0), (param_3 ~= loc_2 and 1 or 0)) ~=
				0 then goto continue_at_24 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			param_3 = load_i32(memory_at_0, loc_0 + 4)
			if loc_0 == 0 then goto continue_at_27 end
			if param_3 ~= loc_1 then goto continue_at_27 end
			break
		end
		::continue_at_25::
		loc_5 = load_i32(memory_at_0, param_0 + 52)
		param_3 = load_i32(memory_at_0, param_0 + 56)
		if loc_5 == param_3 then goto continue_at_24 end
		loc_6 = load_i32(memory_at_0, loc_0 + 24)
		loc_8 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_8 then goto continue_at_24 end
		loc_0 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_4 = sub_i32(div_i32(sub_i32(param_3, loc_5), 12), 1)
		param_3 = 0
		::continue_at_28::
		while true do
			loc_0 = band_i32(loc_0, loc_4)
			loc_2 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_0, 12)))
			if loc_6 ~= loc_2 then
				if loc_2 == loc_8 then goto continue_at_24 end
				param_3 = add_i32(param_3, 1)
				loc_0 = add_i32(param_3, loc_0)
				if le_u32(param_3, loc_4) then goto continue_at_28 end
				goto continue_at_24
			end
			break
		end
		param_3 = add_i32(loc_5, mul_i32(loc_0, 12))
		if load_i32_u8(memory_at_0, param_3 + 5) ~= 0 then goto continue_at_23 end
		::continue_at_24::
		loc_8 = load_i32(memory_at_0, param_0 + 196)
		param_3 = add_i32(loc_8, 1)
		if lt_u32(param_3, 256) then
			store_i32(memory_at_0, param_0 + 196, param_3)
			loc_0 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(param_3, loc_0) and loc_0 or param_3)
			)
			FUNC_LIST[348](param_0, loc_7, band_i32(loc_8, 255), 1)
			loc_1 = load_i32(memory_at_0, 54940)
			goto continue_at_22
		end
		store_i64(memory_at_0, loc_3, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_7, 8), 7407, loc_3)
		error("out of code bounds")
		::continue_at_23::
		loc_8 = load_i32_u8(memory_at_0, param_3 + 4)
		::continue_at_22::
		loc_6 = load_i32(memory_at_0, param_1 + 32)
		param_3 = load_i32(memory_at_0, loc_6 + 4)
		if loc_6 ~= 0 then
			loc_0 = loc_6
			if param_3 == loc_1 then goto continue_at_34 end
		end
		loc_2 = load_i32(memory_at_0, 55020)
		loc_4 = load_i32(memory_at_0, 54900)
		loc_0 = loc_6
		::continue_at_36::
		while true do
			if band_i32((param_3 ~= loc_4 and 1 or 0), (param_3 ~= loc_2 and 1 or 0)) ~=
				0 then goto continue_at_33 end
			loc_0 = load_i32(memory_at_0, loc_0 + 24)
			param_3 = load_i32(memory_at_0, loc_0 + 4)
			if loc_0 == 0 then goto continue_at_36 end
			if param_3 ~= loc_1 then goto continue_at_36 end
			break
		end
		::continue_at_34::
		loc_2 = load_i32(memory_at_0, param_0 + 52)
		param_3 = load_i32(memory_at_0, param_0 + 56)
		if loc_2 == param_3 then goto continue_at_33 end
		loc_5 = load_i32(memory_at_0, loc_0 + 24)
		loc_7 = load_i32(memory_at_0, param_0 + 68)
		if loc_5 == loc_7 then goto continue_at_33 end
		loc_0 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
		loc_1 = sub_i32(div_i32(sub_i32(param_3, loc_2), 12), 1)
		param_3 = 0
		::continue_at_37::
		while true do
			loc_0 = band_i32(loc_0, loc_1)
			loc_4 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 12)))
			if loc_5 ~= loc_4 then
				if loc_4 == loc_7 then goto continue_at_33 end
				param_3 = add_i32(param_3, 1)
				loc_0 = add_i32(param_3, loc_0)
				if le_u32(param_3, loc_1) then goto continue_at_37 end
				goto continue_at_33
			end
			break
		end
		param_3 = add_i32(loc_2, mul_i32(loc_0, 12))
		if load_i32_u8(memory_at_0, param_3 + 5) ~= 0 then goto continue_at_32 end
		::continue_at_33::
		loc_0 = load_i32(memory_at_0, param_0 + 196)
		param_3 = add_i32(loc_0, 1)
		if lt_u32(param_3, 256) then
			store_i32(memory_at_0, param_0 + 196, param_3)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(param_3, loc_1) and loc_1 or param_3)
			)
			FUNC_LIST[348](param_0, loc_6, band_i32(loc_0, 255), 1)
			goto continue_at_31
		end
		store_i64(memory_at_0, loc_3 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_6, 8), 7407, add_i32(loc_3, 16))
		error("out of code bounds")
		::continue_at_32::
		loc_0 = load_i32_u8(memory_at_0, param_3 + 4)
		::continue_at_31::
		param_3 = load_i32(memory_at_0, param_1 + 24)
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0),
				(lt_u32(param_3, 6) and add_i32(param_3, 33) or 0), param_2,
				band_i32(loc_8, 255), band_i32(loc_0, 255)
		)
		::continue_at_1::
		store_i32(memory_at_0, param_0 + 196, loc_9)
		GLOBAL_LIST[0].value = add_i32(loc_3, 80)
	end
FUNC_LIST[369] = --[[ Luau::Compiler::compileExprIfElse(Luau::AstExprIfElse*, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i32(memory_at_0, param_1 + 24)
		loc_5 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_5 == loc_0 then goto continue_at_3 end
		loc_7 = load_i32(memory_at_0, param_0 + 140)
		if loc_7 == loc_3 then goto continue_at_3 end
		loc_4 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 24), 1)
		loc_0 = 0
		loc_8 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_1 = loc_8
		::continue_at_4::
		while true do
			loc_1 = band_i32(loc_1, loc_4)
			loc_6 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)))
			if loc_3 ~= loc_6 then
				if loc_6 == loc_7 then goto continue_at_3 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_4) then goto continue_at_4 end
				goto continue_at_3
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) == 0 then
			goto continue_at_3
		end
		loc_0 = 0
		::continue_at_7::
		while true do
			loc_1 = band_i32(loc_4, loc_8)
			loc_6 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)))
			if loc_3 ~= loc_6 then
				if loc_6 == loc_7 then goto continue_at_6 end
				loc_0 = add_i32(loc_0, 1)
				loc_8 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_4) then goto continue_at_7 end
				goto continue_at_6
			end
			break
		end
		loc_0 = add_i32(loc_5, mul_i32(loc_1, 24))
		if not br_map[1] then br_map[1] = (function() return { [0] = 2, 2, 0 } end)() end
		temp = br_map[1][load_i32(memory_at_0, loc_0 + 8)] or 1
		if temp < 1 then
			goto continue_at_10
		elseif temp > 1 then
			goto continue_at_6
		else
			goto continue_at_9
		end
		::continue_at_10::
		if load_i32_u8(memory_at_0, loc_0 + 16) == 0 then goto continue_at_6 end
		::continue_at_9::
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 32), param_2, param_3)
		goto continue_at_2
		::continue_at_6::
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 40), param_2, param_3)
		goto continue_at_2
		::continue_at_3::
		store_i32(memory_at_0, loc_2 + 8, 0)
		store_i64(memory_at_0, loc_2, 0LL )
		FUNC_LIST[341](param_0, loc_3, 0, loc_2, 0)
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 32), param_2, param_3)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_3 = reg_0
		FUNC_LIST[116](load_i32(memory_at_0, param_0), 23, 0, 0)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_4 = reg_0
		FUNC_LIST[348](param_0, load_i32(memory_at_0, param_1 + 40), param_2, param_3)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_6 = reg_0
		loc_0 = load_i32(memory_at_0, loc_2)
		loc_1 = load_i32(memory_at_0, loc_2 + 4)
		if loc_0 == loc_1 then goto continue_at_11 end
		::continue_at_12::
		while true do
			reg_0 = FUNC_LIST[119](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_4
			)
			if reg_0 ~= 0 then
				loc_0 = add_i32(loc_0, 4)
				if loc_1 ~= loc_0 then goto continue_at_12 end
				goto continue_at_11
			end
			break
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_11::
		reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_3, loc_6)
		if reg_0 == 0 then goto continue_at_1 end
		loc_0 = load_i32(memory_at_0, loc_2)
		if loc_0 == 0 then goto continue_at_2 end
		store_i32(memory_at_0, loc_2 + 4, loc_0)
		FUNC_LIST[1276](loc_0)
		::continue_at_2::
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		goto continue_at_0
		::continue_at_1::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[370] = --[[ Luau::detail::DenseHashTable<Luau::AstExprTable*, std::__2::pair<Luau::AstExprTable*, Luau::Compile::TableShape>, std::__2::pair<Luau::AstExprTable* const, Luau::Compile::TableShape>, Luau::detail::ItemInterfaceMap<Luau::AstExprTable*, Luau::Compile::TableShape>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprTable*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 12), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 16, 0LL )
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			loc_3 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 24, loc_3)
			loc_8 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 16, 0LL )
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		loc_3 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 24, loc_3)
		loc_8 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_2, loc_1), 12), 1)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 36, 0LL )
		store_i32(memory_at_0, loc_0 + 32, loc_3)
		FUNC_LIST[258](add_i32(loc_0, 8), loc_1, add_i32(loc_0, 32))
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_2 == loc_1 then
			loc_1 = loc_2
			goto continue_at_2
		end
		::continue_at_7::
		while true do
			loc_9 = add_i32(loc_1, mul_i32(loc_4, 12))
			loc_3 = load_i32(memory_at_0, loc_9)
			if loc_3 ~= load_i32(memory_at_0, loc_8) then
				loc_5 = load_i32(memory_at_0, loc_0 + 8)
				loc_10 = sub_i32(
					div_i32(
						sub_i32(load_i32(memory_at_0, loc_0 + 12), loc_5), 12
					), 1
				)
				loc_1 = band_i32(loc_10, bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9)))
				loc_6 = add_i32(loc_5, mul_i32(loc_1, 12))
				loc_7 = load_i32(memory_at_0, loc_6)
				loc_11 = load_i32(memory_at_0, loc_0 + 24)
				if loc_7 == loc_11 then goto continue_at_10 end
				loc_2 = 0
				if loc_3 == loc_7 then goto continue_at_9 end
				::continue_at_11::
				while true do
					loc_2 = add_i32(loc_2, 1)
					loc_1 = band_i32(add_i32(loc_2, loc_1), loc_10)
					loc_6 = add_i32(loc_5, mul_i32(loc_1, 12))
					loc_7 = load_i32(memory_at_0, loc_6)
					if loc_7 == loc_11 then goto continue_at_10 end
					if loc_3 ~= loc_7 then goto continue_at_11 end
					break
				end
				goto continue_at_9
				::continue_at_10::
				store_i32(memory_at_0, loc_6, loc_3)
				store_i32(
					memory_at_0, loc_0 + 20, add_i32(load_i32(memory_at_0, loc_0 + 20), 1)
				)
				loc_3 = load_i32(memory_at_0, loc_9)
				::continue_at_9::
				store_i32(memory_at_0, loc_6, loc_3)
				store_i64(
					memory_at_0, add_i32(loc_5, mul_i32(loc_1, 12)) + 4,
						load_i64(memory_at_0, loc_9 + 4)
				)
				loc_2 = load_i32(memory_at_0, param_0 + 4)
				loc_1 = load_i32(memory_at_0, param_0)
			end
			loc_4 = add_i32(loc_4, 1)
			if lt_u32(loc_4, div_i32(sub_i32(loc_2, loc_1), 12)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 12, 0LL )
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		FUNC_LIST[258](param_0, 16, add_i32(loc_0, 8))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 12))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 16))
		store_i32(memory_at_0, loc_0 + 16, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 12, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[371] = --[[ Luau::Compiler::compileLValueIndex(unsigned char, Luau::AstExpr*, Luau::Compiler::RegScope&) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0, reg_1
		loc_7 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_7
		loc_2 = load_i32(memory_at_0, param_1 + 124)
		loc_0 = load_i32(memory_at_0, param_1 + 128)
		if loc_2 == loc_0 then goto continue_at_2 end
		loc_6 = load_i32(memory_at_0, param_1 + 140)
		if loc_6 == param_3 then goto continue_at_2 end
		loc_1 = bxor_i32(shr_u32(param_3, 4), shr_u32(param_3, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_2), 24), 1)
		loc_0 = 0
		::continue_at_3::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_4 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 24)))
			if param_3 ~= loc_4 then
				if loc_4 == loc_6 then goto continue_at_2 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_3 end
				goto continue_at_2
			end
			break
		end
		loc_0 = add_i32(loc_2, mul_i32(loc_1, 24))
		loc_1 = load_i32(memory_at_0, loc_0 + 12)
		loc_5 = load_f64(memory_at_0, loc_0 + 16)
		loc_0 = load_i32(memory_at_0, loc_0 + 8)
		if loc_0 ~= 3 then goto continue_at_5 end
		if (loc_5 >= 1e0 and 1 or 0) == 0 then goto continue_at_5 end
		if (loc_5 <= 2.56e2 and 1 or 0) == 0 then goto continue_at_5 end
		reg_0 = loc_5
		if abs_f64(loc_5) < 2.147483648e9 then
			reg_1 = truncate_i32_f64(loc_5)
			goto continue_at_6
		end
		reg_1 = -2147483648
		::continue_at_6::
		loc_0 = reg_1
		if reg_0 ~= convert_f64_i32(loc_0) then goto continue_at_2 end
		store_i64(memory_at_0, param_0 + 4, 0LL )
		store_i32(memory_at_0, param_0, 4)
		store_i32_n8(memory_at_0, param_0 + 7, sub_i32(loc_0, 1))
		store_i32_n8(memory_at_0, param_0 + 4, param_2)
		store_i32(memory_at_0, param_0 + 12, 0)
		goto continue_at_1
		::continue_at_5::
		if loc_0 ~= 4 then goto continue_at_2 end
		store_i64(memory_at_0, param_0, 3LL )
		store_i64_n32(memory_at_0, param_0 + 8, reinterpret_i64_f64(loc_5))
		store_i32(memory_at_0, param_0 + 12, loc_1)
		store_i32_n8(memory_at_0, param_0 + 4, param_2)
		goto continue_at_1
		::continue_at_2::
		store_i64(memory_at_0, param_0 + 4, 0LL )
		store_i32(memory_at_0, param_0, 5)
		store_i32_n8(memory_at_0, param_0 + 4, param_2)
		store_i64(memory_at_0, param_0 + 12, 0LL )
		store_i64(memory_at_0, param_0 + 20, 0LL )
		store_i32(memory_at_0, param_0 + 28, 0)
		loc_0 = load_i32(memory_at_0, param_3 + 4)
		loc_4 = load_i32(memory_at_0, 54940)
		if param_3 ~= 0 then
			loc_1 = param_3
			if loc_0 == loc_4 then goto continue_at_11 end
		end
		loc_2 = load_i32(memory_at_0, 55020)
		loc_3 = load_i32(memory_at_0, 54900)
		loc_1 = param_3
		::continue_at_13::
		while true do
			if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_2 and 1 or 0)) ~= 0 then
				goto continue_at_10
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_13 end
			if loc_0 ~= loc_4 then goto continue_at_13 end
			break
		end
		::continue_at_11::
		loc_2 = load_i32(memory_at_0, param_1 + 52)
		loc_0 = load_i32(memory_at_0, param_1 + 56)
		if loc_2 == loc_0 then goto continue_at_10 end
		loc_6 = load_i32(memory_at_0, loc_1 + 24)
		param_2 = load_i32(memory_at_0, param_1 + 68)
		if loc_6 == param_2 then goto continue_at_10 end
		loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_2), 12), 1)
		loc_0 = 0
		::continue_at_14::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_4 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 12)))
			if loc_6 ~= loc_4 then
				if param_2 == loc_4 then goto continue_at_10 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_14 end
				goto continue_at_10
			end
			break
		end
		loc_0 = add_i32(loc_2, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_9 end
		::continue_at_10::
		loc_1 = load_i32(memory_at_0, param_1 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_1 + 196, loc_0)
			loc_3 = load_i32(memory_at_0, param_1 + 200)
			store_i32(
				memory_at_0, param_1 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
			)
			FUNC_LIST[348](param_1, param_3, band_i32(loc_1, 255), 1)
			goto continue_at_8
		end
		store_i64(memory_at_0, loc_7, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_3, 8), 7407, loc_7)
		error("out of code bounds")
		::continue_at_9::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_8::
		store_i32_n8(memory_at_0, param_0 + 6, loc_1)
		::continue_at_1::
		store_i64(memory_at_0, param_0 + 16, load_i64(memory_at_0, param_3 + 8))
		store_i64(memory_at_0, param_0 + 24, load_i64(memory_at_0, param_3 + 16))
		GLOBAL_LIST[0].value = add_i32(loc_7, 16)
	end
FUNC_LIST[372] = --[[ Luau::Compiler::compileExprAndOr(Luau::AstExprBinary*, unsigned char, bool) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		local br_map, temp = {}, nil
		loc_4 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_4
		loc_11 = load_i32(memory_at_0, param_0 + 196)
		loc_10 = load_i32(memory_at_0, param_1 + 24)
		loc_5 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_5 == loc_0 then
			loc_3 = load_i32(memory_at_0, param_1 + 28)
			goto continue_at_2
		end
		loc_3 = load_i32(memory_at_0, param_1 + 28)
		loc_6 = load_i32(memory_at_0, param_0 + 140)
		if loc_3 == loc_6 then goto continue_at_2 end
		loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 24), 1)
		loc_0 = 0
		::continue_at_4::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_7 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)))
			if loc_3 ~= loc_7 then
				if loc_6 == loc_7 then goto continue_at_2 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_4 end
				goto continue_at_2
			end
			break
		end
		loc_0 = 0
		loc_2 = 1
		loc_1 = add_i32(loc_5, mul_i32(loc_1, 24))
		if not br_map[1] then br_map[1] = (function() return { [0] = 3, 2, 0 } end)() end
		temp = br_map[1][load_i32(memory_at_0, loc_1 + 8)] or 1
		if temp < 2 then
			if temp < 1 then
				goto continue_at_8
			else
				goto continue_at_7
			end
		elseif temp > 2 then
			goto continue_at_2
		else
			goto continue_at_6
		end
		::continue_at_8::
		loc_2 = (load_i32_u8(memory_at_0, loc_1 + 16) ~= 0 and 1 or 0)
		::continue_at_7::
		loc_0 = loc_2
		::continue_at_6::
		FUNC_LIST[348](
			param_0, load_i32(
				memory_at_0, add_i32(
					param_1, (bxor_i32((loc_10 == 13 and 1 or 0), loc_0) ~= 0 and 28 or 32)
				)
			), param_2, param_3
		)
		goto continue_at_1
		::continue_at_2::
		reg_0 = FUNC_LIST[374](param_0, loc_3)
		if reg_0 ~= 0 then goto continue_at_12 end
		loc_7 = load_i32(memory_at_0, 54940)
		loc_8 = load_i32(memory_at_0, param_1 + 32)
		loc_0 = load_i32(memory_at_0, loc_8 + 4)
		if loc_8 ~= 0 then
			loc_1 = loc_8
			if loc_0 == loc_7 then goto continue_at_14 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_2 = load_i32(memory_at_0, 54900)
		loc_1 = loc_8
		::continue_at_16::
		while true do
			if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_13
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_16 end
			if loc_0 ~= loc_7 then goto continue_at_16 end
			break
		end
		::continue_at_14::
		loc_5 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_5 == loc_0 then goto continue_at_13 end
		loc_6 = load_i32(memory_at_0, loc_1 + 24)
		loc_9 = load_i32(memory_at_0, param_0 + 68)
		if loc_6 == loc_9 then goto continue_at_13 end
		loc_2 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
		loc_1 = sub_i32(div_i32(sub_i32(loc_0, loc_5), 12), 1)
		loc_0 = 0
		::continue_at_17::
		while true do
			loc_2 = band_i32(loc_1, loc_2)
			loc_3 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_2, 12)))
			if loc_6 ~= loc_3 then
				if loc_3 == loc_9 then goto continue_at_13 end
				loc_0 = add_i32(loc_0, 1)
				loc_2 = add_i32(loc_0, loc_2)
				if le_u32(loc_0, loc_1) then goto continue_at_17 end
				goto continue_at_13
			end
			break
		end
		loc_0 = add_i32(loc_5, mul_i32(loc_2, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_9 end
		::continue_at_13::
		reg_0 = FUNC_LIST[362](param_0, loc_8)
		loc_9 = reg_0
		if gt_u32(loc_9, 255) then goto continue_at_12 end
		loc_7 = load_i32(memory_at_0, 54940)
		param_1 = load_i32(memory_at_0, param_1 + 28)
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		if param_1 ~= 0 then
			loc_1 = param_1
			if loc_0 == loc_7 then goto continue_at_20 end
		end
		loc_3 = load_i32(memory_at_0, 55020)
		loc_2 = load_i32(memory_at_0, 54900)
		loc_1 = param_1
		::continue_at_22::
		while true do
			if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_19
			end
			loc_1 = load_i32(memory_at_0, loc_1 + 24)
			loc_0 = load_i32(memory_at_0, loc_1 + 4)
			if loc_1 == 0 then goto continue_at_22 end
			if loc_0 ~= loc_7 then goto continue_at_22 end
			break
		end
		::continue_at_20::
		loc_3 = load_i32(memory_at_0, param_0 + 52)
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_3 == loc_0 then goto continue_at_19 end
		loc_5 = load_i32(memory_at_0, loc_1 + 24)
		loc_6 = load_i32(memory_at_0, param_0 + 68)
		if loc_5 == loc_6 then goto continue_at_19 end
		loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
		loc_2 = sub_i32(div_i32(sub_i32(loc_0, loc_3), 12), 1)
		loc_0 = 0
		::continue_at_23::
		while true do
			loc_1 = band_i32(loc_1, loc_2)
			loc_7 = load_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 12)))
			if loc_5 ~= loc_7 then
				if loc_6 == loc_7 then goto continue_at_19 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_2) then goto continue_at_23 end
				goto continue_at_19
			end
			break
		end
		loc_0 = add_i32(loc_3, mul_i32(loc_1, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_11 end
		::continue_at_19::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_0, param_1, band_i32(loc_1, 255), 1)
			goto continue_at_10
		end
		store_i64(memory_at_0, loc_4 + 16, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_4, 16))
		error("out of code bounds")
		::continue_at_12::
		loc_0 = param_2
		if param_3 == 0 then
			loc_0 = load_i32(memory_at_0, param_0 + 196)
			loc_1 = add_i32(loc_0, 1)
			if ge_u32(loc_1, 256) then goto continue_at_26 end
			store_i32(memory_at_0, param_0 + 196, loc_1)
			loc_2 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_1, loc_2) and loc_2 or loc_1)
			)
		end
		store_i32_n8(memory_at_0, loc_4 + 63, loc_0)
		store_i32(memory_at_0, loc_4 + 56, 0)
		store_i64(memory_at_0, loc_4 + 48, 0LL )
		FUNC_LIST[341](
			param_0, load_i32(memory_at_0, param_1 + 28), add_i32(loc_4, 63),
				add_i32(loc_4, 48), (loc_10 ~= 13 and 1 or 0)
		)
		FUNC_LIST[348](
			param_0, load_i32(memory_at_0, param_1 + 32),
				load_i32_u8(memory_at_0, loc_4 + 63), 1
		)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_1 = reg_0
		loc_0 = load_i32(memory_at_0, loc_4 + 48)
		loc_2 = load_i32(memory_at_0, loc_4 + 52)
		if loc_0 == loc_2 then goto continue_at_28 end
		::continue_at_29::
		while true do
			reg_0 = FUNC_LIST[119](
				load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_1
			)
			if reg_0 ~= 0 then
				loc_0 = add_i32(loc_0, 4)
				if loc_2 ~= loc_0 then goto continue_at_29 end
				goto continue_at_28
			end
			break
		end
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_28::
		loc_0 = load_i32_u8(memory_at_0, loc_4 + 63)
		if param_2 ~= loc_0 then
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 6, param_2, loc_0, 0)
		end
		loc_0 = load_i32(memory_at_0, loc_4 + 48)
		if loc_0 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_4 + 52, loc_0)
		FUNC_LIST[1276](loc_0)
		goto continue_at_1
		::continue_at_26::
		store_i64(memory_at_0, loc_4, 1095216660481LL )
		FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_4)
		error("out of code bounds")
		::continue_at_11::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_10::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), (loc_10 == 13 and 47 or 48), param_2,
				band_i32(loc_1, 255), band_i32(loc_9, 255)
		)
		goto continue_at_1
		::continue_at_9::
		loc_8 = load_i32_u8(memory_at_0, loc_0 + 4)
		loc_6 = load_i32(memory_at_0, param_1 + 28)
		loc_0 = load_i32(memory_at_0, loc_6 + 4)
		if loc_6 ~= 0 then
			loc_2 = loc_6
			if loc_0 == loc_7 then goto continue_at_35 end
		end
		param_1 = load_i32(memory_at_0, 55020)
		loc_3 = load_i32(memory_at_0, 54900)
		loc_2 = loc_6
		::continue_at_37::
		while true do
			if band_i32((loc_0 ~= loc_3 and 1 or 0), (param_1 ~= loc_0 and 1 or 0)) ~= 0 then
				goto continue_at_34
			end
			loc_2 = load_i32(memory_at_0, loc_2 + 24)
			loc_0 = load_i32(memory_at_0, loc_2 + 4)
			if loc_2 == 0 then goto continue_at_37 end
			if loc_0 ~= loc_7 then goto continue_at_37 end
			break
		end
		::continue_at_35::
		loc_3 = load_i32(memory_at_0, loc_2 + 24)
		if loc_3 == loc_9 then goto continue_at_34 end
		loc_2 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
		loc_0 = 0
		::continue_at_38::
		while true do
			loc_2 = band_i32(loc_1, loc_2)
			loc_7 = load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_2, 12)))
			if loc_3 ~= loc_7 then
				if loc_7 == loc_9 then goto continue_at_34 end
				loc_0 = add_i32(loc_0, 1)
				loc_2 = add_i32(loc_0, loc_2)
				if le_u32(loc_0, loc_1) then goto continue_at_38 end
				goto continue_at_34
			end
			break
		end
		loc_0 = add_i32(loc_5, mul_i32(loc_2, 12))
		if load_i32_u8(memory_at_0, loc_0 + 5) ~= 0 then goto continue_at_33 end
		::continue_at_34::
		loc_1 = load_i32(memory_at_0, param_0 + 196)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 256) then
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_2 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_2) and loc_2 or loc_0)
			)
			FUNC_LIST[348](param_0, loc_6, band_i32(loc_1, 255), 1)
			goto continue_at_32
		end
		store_i64(memory_at_0, loc_4 + 32, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_6, 8), 7407, add_i32(loc_4, 32))
		error("out of code bounds")
		::continue_at_33::
		loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
		::continue_at_32::
		FUNC_LIST[114](
			load_i32(memory_at_0, param_0), (loc_10 == 13 and 45 or 46), param_2,
				band_i32(loc_1, 255), band_i32(loc_8, 255)
		)
		::continue_at_1::
		store_i32(memory_at_0, param_0 + 196, loc_11)
		GLOBAL_LIST[0].value = sub_i32(loc_4, -64)
	end
FUNC_LIST[373] = --[[ std::__2::__vector_base<Luau::AstExpr*, std::__2::allocator<Luau::AstExpr*> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[374] = --[[ Luau::Compiler::isConditionFast(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		loc_2 = load_i32(memory_at_0, param_0 + 124)
		loc_0 = load_i32(memory_at_0, param_0 + 128)
		if loc_2 == loc_0 then goto continue_at_2 end
		loc_4 = load_i32(memory_at_0, param_0 + 140)
		if loc_4 == param_1 then goto continue_at_2 end
		loc_1 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_2), 24), 1)
		loc_0 = 0
		::continue_at_3::
		while true do
			loc_1 = band_i32(loc_1, loc_3)
			loc_5 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 24)))
			if param_1 ~= loc_5 then
				if loc_4 == loc_5 then goto continue_at_2 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_1)
				if le_u32(loc_0, loc_3) then goto continue_at_3 end
				goto continue_at_2
			end
			break
		end
		loc_0 = 1
		reg_0 = loc_0
		if load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 24)) + 8) ~= 0 then
			goto continue_at_1
		end
		::continue_at_2::
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		if param_1 == 0 then goto continue_at_5 end
		if loc_0 ~= load_i32(memory_at_0, 55012) then goto continue_at_5 end
		reg_0 =
			(lt_u32(sub_i32(load_i32(memory_at_0, param_1 + 24), 7), 8) and 1 or 0)
		goto continue_at_0
		::continue_at_5::
		loc_0 = bor_i32(
			(param_1 == 0 and 1 or 0), (loc_0 ~= load_i32(memory_at_0, 54900) and 1 or 0)
		)
		if loc_0 == 0 then
			reg_0 = FUNC_LIST[374](param_0, load_i32(memory_at_0, param_1 + 24))
			loc_1 = reg_0
		end
		reg_0 = band_i32(bxor_i32(loc_0, 1), loc_1)
		::continue_at_1::
		loc_0 = reg_0
		reg_0 = loc_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[375] = --[[ Luau::Compiler::UndefinedLocalVisitor::~UndefinedLocalVisitor() ]]
	function(param_0) FUNC_LIST[1276](param_0) end
FUNC_LIST[376] = --[[ Luau::Compiler::UndefinedLocalVisitor::visit(Luau::AstExprLocal*) ]]
	function(param_0, param_1)
		local reg_0
		if load_i32_u8(memory_at_0, param_1 + 28) == 0 then
			FUNC_LIST[377](param_0, load_i32(memory_at_0, param_1 + 24))
		end
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[377] = --[[ Luau::Compiler::UndefinedLocalVisitor::check(Luau::AstLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = add_i32(loc_0, 52)
		loc_2 = load_i32(memory_at_0, loc_0 + 52)
		loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 56), loc_2), 12)
		if ge_u32(
			load_i32(memory_at_0, sub_i32(loc_0, -64)), shr_u32(mul_i32(loc_0, 3), 2)
		) then
			FUNC_LIST[321](loc_1)
			loc_2 = load_i32(memory_at_0, loc_1)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_2), 12)
		end
		loc_6 = sub_i32(loc_0, 1)
		loc_0 = band_i32(loc_6, bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9)))
		loc_3 = add_i32(loc_2, mul_i32(loc_0, 12))
		loc_4 = load_i32(memory_at_0, loc_3)
		loc_7 = load_i32(memory_at_0, loc_1 + 16)
		if loc_4 ~= loc_7 then
			::continue_at_4::
			while true do
				if param_1 == loc_4 then goto continue_at_2 end
				loc_5 = add_i32(loc_5, 1)
				loc_0 = band_i32(add_i32(loc_5, loc_0), loc_6)
				loc_3 = add_i32(loc_2, mul_i32(loc_0, 12))
				loc_4 = load_i32(memory_at_0, loc_3)
				if loc_4 ~= loc_7 then goto continue_at_4 end
				break
			end
		end
		store_i32(memory_at_0, loc_3, param_1)
		store_i32(
			memory_at_0, loc_1 + 12, add_i32(load_i32(memory_at_0, loc_1 + 12), 1)
		)
		::continue_at_2::
		if load_i32_u8(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 12)) + 5) ~= 0 then
			goto continue_at_5
		end
		if load_i32(memory_at_0, param_0 + 8) ~= 0 then goto continue_at_5 end
		store_i32(memory_at_0, param_0 + 8, param_1)
		::continue_at_5::
	end
FUNC_LIST[378] = --[[ Luau::Compiler::UndefinedLocalVisitor::visit(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		loc_4 = load_i32(memory_at_0, loc_0 + 28)
		loc_3 = load_i32(memory_at_0, loc_0 + 32)
		if loc_4 == loc_3 then goto continue_at_1 end
		loc_5 = load_i32(memory_at_0, loc_0 + 44)
		if loc_5 == param_1 then goto continue_at_1 end
		loc_2 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_3, loc_4), 40), 1)
		loc_0 = 0
		::continue_at_2::
		while true do
			loc_6 = band_i32(loc_2, loc_3)
			loc_1 = add_i32(loc_4, mul_i32(loc_6, 40))
			loc_2 = load_i32(memory_at_0, loc_1)
			if loc_2 == param_1 then goto continue_at_1 end
			loc_1 = 0
			if loc_2 == loc_5 then goto continue_at_1 end
			loc_0 = add_i32(loc_0, 1)
			loc_2 = add_i32(loc_0, loc_6)
			if le_u32(loc_0, loc_3) then goto continue_at_2 end
			break
		end
		::continue_at_1::
		loc_1 = (loc_1 ~= 0 and add_i32(loc_1, 8) or 0)
		loc_0 = load_i32(memory_at_0, loc_1 + 4)
		loc_2 = load_i32(memory_at_0, loc_1 + 8)
		if loc_0 ~= loc_2 then
			::continue_at_4::
			while true do
				loc_1 = load_i32(memory_at_0, loc_0)
				if load_i32(memory_at_0, loc_1 + 24) ==
					sub_i32(load_i32(memory_at_0, param_1 + 96), 1) then
					FUNC_LIST[377](param_0, loc_1)
				end
				loc_0 = add_i32(loc_0, 4)
				if loc_0 ~= loc_2 then goto continue_at_4 end
				break
			end
		end
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[379] = --[[ Luau::Compiler::compileInlinedCall(Luau::AstExprCall*, Luau::AstExprFunction*, unsigned char, unsigned char) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local loc_17 = 0
		local loc_18 = 0
		local loc_19 = 0
		local loc_20 = 0LL
		local reg_0, reg_1
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_4
		loc_0 = load_i32(memory_at_0, param_0 + 212)
		loc_18 = load_i32(memory_at_0, param_0 + 196)
		loc_2 = load_i32(memory_at_0, param_0 + 208)
		store_i32(memory_at_0, loc_4 + 76, 0)
		store_i64(memory_at_0, loc_4 + 68, 0LL )
		store_i32_n8(memory_at_0, loc_4 + 65, param_4)
		store_i32_n8(memory_at_0, loc_4 + 64, param_3)
		store_i32(memory_at_0, loc_4 + 56, param_2)
		loc_17 = shr_i32(sub_i32(loc_0, loc_2), 2)
		store_i32(memory_at_0, loc_4 + 60, loc_17)
		loc_15 = add_i32(param_0, 256)
		loc_0 = load_i32(memory_at_0, param_0 + 260)
		if lt_u32(loc_0, load_i32(memory_at_0, param_0 + 264)) then
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_4 + 56))
			store_i32_n16(
				memory_at_0, loc_0 + 8, load_i32_u16(memory_at_0, sub_i32(loc_4, -64))
			)
			store_i32(memory_at_0, loc_0 + 12, load_i32(memory_at_0, loc_4 + 68))
			store_i32(memory_at_0, loc_0 + 16, load_i32(memory_at_0, loc_4 + 72))
			store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_4 + 76))
			store_i32(memory_at_0, loc_15 + 4, add_i32(loc_0, 24))
			goto continue_at_1
		end
		FUNC_LIST[380](loc_15, add_i32(loc_4, 56))
		loc_0 = load_i32(memory_at_0, loc_4 + 68)
		if loc_0 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_4 + 72, loc_0)
		FUNC_LIST[1276](loc_0)
		::continue_at_1::
		loc_6 = load_i32(memory_at_0, param_2 + 48)
		if loc_6 == 0 then
			loc_6 = 0
			goto continue_at_3
		end
		loc_9 = add_i32(param_0, 148)
		::continue_at_5::
		while true do
			loc_0 = loc_12
			loc_3 = shl_i32(loc_0, 2)
			loc_2 = add_i32(loc_3, load_i32(memory_at_0, param_2 + 44))
			loc_5 = 0
			loc_1 = load_i32(memory_at_0, param_1 + 32)
			if gt_u32(loc_1, loc_0) then
				loc_5 = load_i32(
					memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), loc_3)
				)
			end
			loc_2 = load_i32(memory_at_0, loc_2)
			loc_12 = add_i32(loc_0, 1)
			if loc_12 ~= loc_1 then goto continue_at_11 end
			if ge_u32(loc_1, loc_6) then goto continue_at_11 end
			loc_3 = load_i32(memory_at_0, loc_5 + 4)
			loc_10 = load_i32(memory_at_0, 54964)
			loc_7 = load_i32(memory_at_0, 54956)
			if band_i32((loc_3 ~= loc_10 and 1 or 0), (loc_7 ~= loc_3 and 1 or 0)) ~= 0 then
				goto continue_at_11
			end
			loc_8 = load_i32(memory_at_0, param_0 + 196)
			loc_6 = add_i32(sub_i32(loc_6, loc_1), 1)
			loc_2 = add_i32(loc_8, loc_6)
			if ge_u32(loc_2, 256) then goto continue_at_10 end
			store_i32(memory_at_0, param_0 + 196, loc_2)
			loc_1 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (gt_u32(loc_1, loc_2) and loc_1 or loc_2)
			)
			if loc_3 == loc_10 then
				FUNC_LIST[329](
					param_0, loc_5, band_i32(loc_8, 255), band_i32(loc_6, 255), 1, 0
				)
				goto continue_at_12
			end
			if loc_3 ~= loc_7 then goto continue_at_12 end
			if load_i32(memory_at_0, param_0 + 8) > 0 then
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, loc_5 + 8), 1)
				)
			end
			FUNC_LIST[114](
				load_i32(memory_at_0, param_0), 63, band_i32(loc_8, 255),
					band_i32(add_i32(loc_6, 1), 255), 0
			)
			::continue_at_12::
			loc_6 = load_i32(memory_at_0, param_2 + 48)
			if ge_u32(loc_0, loc_6) then goto continue_at_3 end
			loc_2 = loc_0
			::continue_at_15::
			while true do
				FUNC_LIST[237](
					param_0, load_i32(
						memory_at_0,
							add_i32(load_i32(memory_at_0, param_2 + 44), shl_i32(loc_2, 2))
					), band_i32(add_i32(sub_i32(loc_2, loc_0), loc_8), 255)
				)
				loc_2 = add_i32(loc_2, 1)
				loc_6 = load_i32(memory_at_0, param_2 + 48)
				if lt_u32(loc_2, loc_6) then goto continue_at_15 end
				break
			end
			goto continue_at_3
			::continue_at_11::
			loc_6 = load_i32(memory_at_0, param_0 + 100)
			loc_13 = load_i32(memory_at_0, param_0 + 104)
			loc_14 = (loc_6 == loc_13 and 1 or 0)
			if loc_14 ~= 0 then goto continue_at_8 end
			loc_10 = load_i32(memory_at_0, param_0 + 116)
			if loc_2 == loc_10 then goto continue_at_8 end
			loc_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_13, loc_6), 12), 1)
			loc_0 = 0
			::continue_at_16::
			while true do
				loc_7 = band_i32(loc_1, loc_3)
				loc_8 = add_i32(loc_6, mul_i32(loc_7, 12))
				loc_1 = load_i32(memory_at_0, loc_8)
				if loc_2 ~= loc_1 then
					if loc_1 == loc_10 then goto continue_at_8 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_7)
					if le_u32(loc_0, loc_3) then goto continue_at_16 end
					goto continue_at_8
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_8 + 8) == 0 then goto continue_at_8 end
			loc_1 = load_i32(memory_at_0, param_0 + 196)
			loc_0 = add_i32(loc_1, 1)
			if ge_u32(loc_0, 256) then goto continue_at_9 end
			store_i32(memory_at_0, param_0 + 196, loc_0)
			loc_3 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
			)
			if loc_5 ~= 0 then
				FUNC_LIST[348](param_0, loc_5, band_i32(loc_1, 255), 1)
				goto continue_at_18
			end
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 2, band_i32(loc_1, 255), 0, 0)
			::continue_at_18::
			FUNC_LIST[237](param_0, loc_2, band_i32(loc_1, 255))
			goto continue_at_7
			::continue_at_10::
			store_i32(memory_at_0, loc_4 + 20, 255)
			store_i32(memory_at_0, loc_4 + 16, loc_6)
			FUNC_LIST[232](add_i32(loc_5, 8), 7407, add_i32(loc_4, 16))
			error("out of code bounds")
			::continue_at_9::
			store_i64(memory_at_0, loc_4 + 48, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_5, 8), 7407, add_i32(loc_4, 48))
			error("out of code bounds")
			::continue_at_8::
			if loc_5 == 0 then
				loc_3 = 0
				loc_7 = load_i32(memory_at_0, loc_9)
				loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_9 + 4), loc_7), 24)
				if ge_u32(load_i32(memory_at_0, loc_9 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
					FUNC_LIST[381](loc_9)
					loc_7 = load_i32(memory_at_0, loc_9)
					loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_9 + 4), loc_7), 24)
				end
				loc_6 = sub_i32(loc_0, 1)
				loc_0 = band_i32(loc_6, bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9)))
				loc_5 = add_i32(loc_7, mul_i32(loc_0, 24))
				loc_1 = load_i32(memory_at_0, loc_5)
				loc_10 = load_i32(memory_at_0, loc_9 + 16)
				if loc_1 == loc_10 then goto continue_at_21 end
				::continue_at_24::
				while true do
					if loc_1 == loc_2 then goto continue_at_20 end
					loc_3 = add_i32(loc_3, 1)
					loc_0 = band_i32(add_i32(loc_3, loc_0), loc_6)
					loc_5 = add_i32(loc_7, mul_i32(loc_0, 24))
					loc_1 = load_i32(memory_at_0, loc_5)
					if loc_10 ~= loc_1 then goto continue_at_24 end
					break
				end
				goto continue_at_21
			end
			loc_10 = load_i32(memory_at_0, param_0 + 124)
			loc_0 = load_i32(memory_at_0, param_0 + 128)
			if loc_10 == loc_0 then goto continue_at_25 end
			loc_8 = load_i32(memory_at_0, param_0 + 140)
			if loc_5 == loc_8 then goto continue_at_25 end
			loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_10), 24), 1)
			loc_0 = 0
			::continue_at_26::
			while true do
				loc_7 = band_i32(loc_1, loc_3)
				loc_11 = add_i32(loc_10, mul_i32(loc_7, 24))
				loc_1 = load_i32(memory_at_0, loc_11)
				if loc_5 ~= loc_1 then
					if loc_1 == loc_8 then goto continue_at_25 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_7)
					if le_u32(loc_0, loc_3) then goto continue_at_26 end
					goto continue_at_25
				end
				break
			end
			if load_i32(memory_at_0, loc_11 + 8) == 0 then goto continue_at_25 end
			loc_8 = add_i32(loc_11, 8)
			loc_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
			loc_6 = load_i32(memory_at_0, loc_9)
			loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_9 + 4), loc_6), 24)
			if ge_u32(load_i32(memory_at_0, loc_9 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
				FUNC_LIST[381](loc_9)
				loc_6 = load_i32(memory_at_0, loc_9)
				loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_9 + 4), loc_6), 24)
			end
			loc_3 = sub_i32(loc_0, 1)
			loc_10 = load_i32(memory_at_0, loc_9 + 16)
			loc_0 = 0
			::continue_at_30::
			while true do
				loc_7 = band_i32(loc_1, loc_3)
				loc_5 = add_i32(loc_6, mul_i32(loc_7, 24))
				loc_1 = load_i32(memory_at_0, loc_5)
				if loc_10 == loc_1 then
					store_i32(memory_at_0, loc_5, loc_2)
					store_i32(
						memory_at_0, loc_9 + 12, add_i32(load_i32(memory_at_0, loc_9 + 12), 1)
					)
					goto continue_at_29
				end
				if loc_1 == loc_2 then goto continue_at_29 end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_7)
				if le_u32(loc_0, loc_3) then goto continue_at_30 end
				break
			end
			loc_5 = 0
			::continue_at_29::
			store_i64(memory_at_0, loc_5 + 8, load_i64(memory_at_0, loc_8))
			store_i64(memory_at_0, loc_5 + 16, load_i64(memory_at_0, loc_8 + 8))
			goto continue_at_7
			::continue_at_25::
			if load_i32(memory_at_0, loc_5 + 4) ~= load_i32(memory_at_0, 54940) then
				goto continue_at_32
			end
			loc_16 = 0
			if loc_14 ~= 0 then goto continue_at_33 end
			loc_8 = load_i32(memory_at_0, loc_5 + 24)
			loc_11 = load_i32(memory_at_0, param_0 + 116)
			if loc_8 == loc_11 then goto continue_at_33 end
			loc_3 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
			loc_7 = sub_i32(div_i32(sub_i32(loc_13, loc_6), 12), 1)
			loc_0 = 0
			::continue_at_34::
			while true do
				loc_10 = band_i32(loc_3, loc_7)
				loc_1 = add_i32(loc_6, mul_i32(loc_10, 12))
				loc_3 = load_i32(memory_at_0, loc_1)
				if loc_3 == loc_8 then goto continue_at_35 end
				loc_1 = 0
				if loc_3 == loc_11 then goto continue_at_35 end
				loc_0 = add_i32(loc_0, 1)
				loc_3 = add_i32(loc_0, loc_10)
				if le_u32(loc_0, loc_7) then goto continue_at_34 end
				::continue_at_35::
				break
			end
			loc_16 = (loc_1 ~= 0 and add_i32(loc_1, 4) or 0)
			::continue_at_33::
			loc_10 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_10 == loc_0 then goto continue_at_32 end
			loc_6 = load_i32(memory_at_0, loc_5 + 24)
			loc_8 = load_i32(memory_at_0, param_0 + 68)
			if loc_6 == loc_8 then goto continue_at_32 end
			loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
			loc_3 = sub_i32(div_i32(sub_i32(loc_0, loc_10), 12), 1)
			loc_0 = 0
			::continue_at_36::
			while true do
				loc_7 = band_i32(loc_1, loc_3)
				loc_11 = add_i32(loc_10, mul_i32(loc_7, 12))
				loc_1 = load_i32(memory_at_0, loc_11)
				if loc_6 ~= loc_1 then
					if loc_1 == loc_8 then goto continue_at_32 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_7)
					if le_u32(loc_0, loc_3) then goto continue_at_36 end
					goto continue_at_32
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_11 + 5) == 0 then goto continue_at_32 end
			loc_0 = load_i32_u8(memory_at_0, loc_11 + 4)
			if loc_16 ~= 0 then
				if load_i32_u8(memory_at_0, loc_16 + 4) ~= 0 then goto continue_at_32 end
			end
			FUNC_LIST[237](param_0, loc_2, band_i32(loc_0, 255))
			goto continue_at_7
			::continue_at_32::
			loc_1 = load_i32(memory_at_0, param_0 + 196)
			loc_0 = add_i32(loc_1, 1)
			if lt_u32(loc_0, 256) then
				store_i32(memory_at_0, param_0 + 196, loc_0)
				loc_3 = load_i32(memory_at_0, param_0 + 200)
				store_i32(
					memory_at_0, param_0 + 200, (lt_u32(loc_0, loc_3) and loc_3 or loc_0)
				)
				loc_0 = band_i32(loc_1, 255)
				FUNC_LIST[348](param_0, loc_5, loc_0, 1)
				FUNC_LIST[237](param_0, loc_2, loc_0)
				goto continue_at_7
			end
			store_i64(memory_at_0, loc_4 + 32, 1095216660481LL )
			FUNC_LIST[232](add_i32(loc_5, 8), 7407, add_i32(loc_4, 32))
			error("out of code bounds")
			::continue_at_21::
			store_i32(memory_at_0, loc_5, loc_2)
			store_i32(
				memory_at_0, loc_9 + 12, add_i32(load_i32(memory_at_0, loc_9 + 12), 1)
			)
			::continue_at_20::
			loc_0 = add_i32(loc_7, mul_i32(loc_0, 24))
			store_i64(memory_at_0, loc_0 + 8, 1LL )
			store_i32(memory_at_0, loc_0 + 16, 0)
			::continue_at_7::
			loc_6 = load_i32(memory_at_0, param_2 + 48)
			if lt_u32(loc_12, loc_6) then goto continue_at_5 end
			break
		end
		::continue_at_3::
		loc_13 = load_i32(memory_at_0, param_1 + 32)
		if ge_u32(loc_6, loc_13) then goto continue_at_40 end
		loc_3 = load_i32(memory_at_0, 54940)
		loc_14 = load_i32(memory_at_0, param_0 + 196)
		loc_11 = add_i32(loc_14, 1)
		loc_16 = (lt_u32(loc_11, 256) and 1 or 0)
		loc_19 = band_i32(loc_14, 255)
		::continue_at_41::
		while true do
			loc_8 = load_i32(
				memory_at_0, add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_6, 2))
			)
			loc_0 = load_i32(memory_at_0, loc_8 + 4)
			if loc_8 ~= 0 then
				loc_2 = loc_8
				if loc_0 == loc_3 then goto continue_at_45 end
			end
			loc_7 = load_i32(memory_at_0, 55020)
			loc_1 = load_i32(memory_at_0, 54900)
			loc_2 = loc_8
			::continue_at_47::
			while true do
				if band_i32((loc_0 ~= loc_1 and 1 or 0), (loc_0 ~= loc_7 and 1 or 0)) ~= 0 then
					goto continue_at_44
				end
				loc_2 = load_i32(memory_at_0, loc_2 + 24)
				loc_0 = load_i32(memory_at_0, loc_2 + 4)
				if loc_2 == 0 then goto continue_at_47 end
				if loc_0 ~= loc_3 then goto continue_at_47 end
				break
			end
			::continue_at_45::
			loc_10 = load_i32(memory_at_0, param_0 + 52)
			loc_0 = load_i32(memory_at_0, param_0 + 56)
			if loc_10 == loc_0 then goto continue_at_44 end
			loc_5 = load_i32(memory_at_0, loc_2 + 24)
			loc_12 = load_i32(memory_at_0, param_0 + 68)
			if loc_5 == loc_12 then goto continue_at_44 end
			loc_2 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
			loc_1 = sub_i32(div_i32(sub_i32(loc_0, loc_10), 12), 1)
			loc_0 = 0
			::continue_at_48::
			while true do
				loc_7 = band_i32(loc_1, loc_2)
				loc_9 = add_i32(loc_10, mul_i32(loc_7, 12))
				loc_2 = load_i32(memory_at_0, loc_9)
				if loc_5 ~= loc_2 then
					if loc_2 == loc_12 then goto continue_at_44 end
					loc_0 = add_i32(loc_0, 1)
					loc_2 = add_i32(loc_0, loc_7)
					if le_u32(loc_0, loc_1) then goto continue_at_48 end
					goto continue_at_44
				end
				break
			end
			if load_i32_u8(memory_at_0, loc_9 + 5) ~= 0 then goto continue_at_43 end
			::continue_at_44::
			if loc_16 == 0 then goto continue_at_42 end
			store_i32(memory_at_0, param_0 + 196, loc_11)
			loc_0 = load_i32(memory_at_0, param_0 + 200)
			store_i32(
				memory_at_0, param_0 + 200, (gt_u32(loc_0, loc_11) and loc_0 or loc_11)
			)
			FUNC_LIST[348](param_0, loc_8, loc_19, 1)
			loc_13 = load_i32(memory_at_0, param_1 + 32)
			loc_3 = load_i32(memory_at_0, 54940)
			::continue_at_43::
			store_i32(memory_at_0, param_0 + 196, loc_14)
			loc_6 = add_i32(loc_6, 1)
			if lt_u32(loc_6, loc_13) then goto continue_at_41 end
			goto continue_at_40
			::continue_at_42::
			break
		end
		store_i64(memory_at_0, loc_4, 1095216660481LL )
		FUNC_LIST[232](add_i32(loc_8, 8), 7407, loc_4)
		error("out of code bounds")
		::continue_at_40::
		loc_13 = add_i32(param_0, 124)
		loc_14 = add_i32(param_0, 100)
		loc_11 = add_i32(param_0, 148)
		FUNC_LIST[54](loc_13, loc_14, loc_11, load_i32(memory_at_0, param_2 + 92))
		loc_2 = load_i32(memory_at_0, param_2 + 92)
		if load_i32(memory_at_0, loc_2 + 32) ~= 0 then
			loc_0 = 0
			::continue_at_53::
			while true do
				loc_2 = load_i32(
					memory_at_0, add_i32(load_i32(memory_at_0, loc_2 + 28), shl_i32(loc_0, 2))
				)
				if load_i32(memory_at_0, loc_2 + 4) ~= load_i32(memory_at_0, 55084) then
					goto continue_at_54
				end
				if loc_2 == 0 then goto continue_at_54 end
				if load_i32(memory_at_0, param_0 + 8) > 0 then
					FUNC_LIST[124](
						load_i32(memory_at_0, param_0),
							add_i32(load_i32(memory_at_0, loc_2 + 8), 1)
					)
				end
				loc_1 = sub_i32(load_i32(memory_at_0, loc_15 + 4), 24)
				loc_20 = load_i64(memory_at_0, loc_1)
				loc_0 = load_i32_u16(memory_at_0, loc_1 + 8)
				store_i32(memory_at_0, loc_4 + 76, 0)
				store_i32_n16(memory_at_0, sub_i32(loc_4, -64), loc_0)
				store_i64(memory_at_0, loc_4 + 56, loc_20)
				store_i64(memory_at_0, loc_4 + 68, 0LL )
				loc_0 = 0
				loc_3 = load_i32(memory_at_0, loc_1 + 16)
				loc_7 = load_i32(memory_at_0, loc_1 + 12)
				if loc_3 ~= loc_7 then
					loc_3 = sub_i32(loc_3, loc_7)
					if loc_3 < 0 then goto continue_at_50 end
					reg_1 = FUNC_LIST[1275](loc_3)
					loc_0 = reg_1
					store_i32(memory_at_0, loc_4 + 72, loc_0)
					store_i32(
						memory_at_0, loc_4 + 76, add_i32(loc_0, shl_i32(shr_i32(loc_3, 2), 2))
					)
					loc_3 = loc_0
					loc_1 = add_i32(loc_1, 12)
					loc_7 = load_i32(memory_at_0, loc_1)
					loc_1 = sub_i32(load_i32(memory_at_0, loc_1 + 4), loc_7)
					if loc_1 > 0 then
						reg_0 = FUNC_LIST[1119](loc_0, loc_7, loc_1)
						loc_3 = add_i32(reg_0, loc_1)
					end
					store_i32(memory_at_0, loc_4 + 72, loc_3)
				end
				FUNC_LIST[345](
					param_0, add_i32(loc_2, 28), load_i32_u8(memory_at_0, loc_4 + 64),
						load_i32_u8(memory_at_0, loc_4 + 65), 0
				)
				FUNC_LIST[240](param_0, load_i32(memory_at_0, loc_4 + 60))
				if loc_0 == 0 then goto continue_at_51 end
				store_i32(memory_at_0, loc_4 + 72, loc_0)
				FUNC_LIST[1276](loc_0)
				goto continue_at_51
				::continue_at_54::
				FUNC_LIST[238](param_0, loc_2)
				loc_0 = add_i32(loc_0, 1)
				loc_2 = load_i32(memory_at_0, param_2 + 92)
				if lt_u32(loc_0, load_i32(memory_at_0, loc_2 + 32)) then
					goto continue_at_53
				end
				break
			end
		end
		reg_0 = FUNC_LIST[239](param_0, loc_2)
		if reg_0 ~= 0 then goto continue_at_51 end
		if param_4 ~= 0 then
			loc_0 = 0
			::continue_at_59::
			while true do
				FUNC_LIST[114](
					load_i32(memory_at_0, param_0), 2, band_i32(add_i32(param_3, loc_0), 255),
						0, 0
				)
				loc_0 = add_i32(loc_0, 1)
				if loc_0 ~= param_4 then goto continue_at_59 end
				break
			end
		end
		FUNC_LIST[240](param_0, loc_17)
		::continue_at_51::
		FUNC_LIST[242](param_0, loc_17)
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		loc_3 = load_i32(memory_at_0, param_0 + 260)
		loc_0 = load_i32(memory_at_0, sub_i32(loc_3, 12))
		loc_1 = load_i32(memory_at_0, sub_i32(loc_3, 8))
		if loc_0 ~= loc_1 then
			::continue_at_62::
			while true do
				reg_0 = FUNC_LIST[119](
					load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_0), loc_2
				)
				if reg_0 ~= 0 then
					loc_0 = add_i32(loc_0, 4)
					if loc_1 ~= loc_0 then goto continue_at_62 end
					goto continue_at_61
				end
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
			::continue_at_61::
			loc_3 = load_i32(memory_at_0, loc_15 + 4)
			loc_0 = load_i32(memory_at_0, sub_i32(loc_3, 12))
		end
		if loc_0 ~= 0 then
			store_i32(memory_at_0, sub_i32(loc_3, 8), loc_0)
			FUNC_LIST[1276](loc_0)
		end
		store_i32(memory_at_0, loc_15 + 4, sub_i32(loc_3, 24))
		loc_12 = load_i32(memory_at_0, param_2 + 48)
		if loc_12 ~= 0 then
			loc_9 = load_i32(memory_at_0, loc_11 + 4)
			loc_5 = load_i32(memory_at_0, loc_11)
			loc_1 = sub_i32(div_i32(sub_i32(loc_9, loc_5), 24), 1)
			loc_6 = load_i32(memory_at_0, loc_11 + 16)
			loc_8 = 0
			::continue_at_66::
			while true do
				if loc_5 == loc_9 then goto continue_at_67 end
				loc_7 = load_i32(
					memory_at_0,
						add_i32(load_i32(memory_at_0, param_2 + 44), shl_i32(loc_8, 2))
				)
				if loc_7 == loc_6 then goto continue_at_67 end
				loc_2 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
				loc_0 = 0
				::continue_at_68::
				while true do
					loc_3 = band_i32(loc_1, loc_2)
					loc_10 = add_i32(loc_5, mul_i32(loc_3, 24))
					loc_2 = load_i32(memory_at_0, loc_10)
					if loc_7 ~= loc_2 then
						if loc_2 == loc_6 then goto continue_at_67 end
						loc_0 = add_i32(loc_0, 1)
						loc_2 = add_i32(loc_0, loc_3)
						if le_u32(loc_0, loc_1) then goto continue_at_68 end
						goto continue_at_67
					end
					break
				end
				store_i32(memory_at_0, loc_10 + 8, 0)
				::continue_at_67::
				loc_8 = add_i32(loc_8, 1)
				if loc_8 ~= loc_12 then goto continue_at_66 end
				break
			end
		end
		FUNC_LIST[54](loc_13, loc_14, loc_11, load_i32(memory_at_0, param_2 + 92))
		store_i32(memory_at_0, param_0 + 196, loc_18)
		GLOBAL_LIST[0].value = add_i32(loc_4, 80)
		goto continue_at_0
		::continue_at_50::
		FUNC_LIST[346](add_i32(loc_4, 68))
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[380] = --[[ void std::__2::vector<Luau::Compiler::InlineFrame, std::__2::allocator<Luau::Compiler::InlineFrame> >::__push_back_slow_path<Luau::Compiler::InlineFrame>(Luau::Compiler::InlineFrame&&) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local reg_0
		loc_2 = load_i32(memory_at_0, param_0)
		loc_1 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 4), loc_2), 24)
		loc_0 = add_i32(loc_1, 1)
		if lt_u32(loc_0, 178956971) then
			loc_2 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 24)
			loc_3 = shl_i32(loc_2, 1)
			loc_0 =
				(lt_u32(loc_2, 89478485) and (lt_u32(loc_0, loc_3) and loc_3 or loc_0) or
					178956970)
			if ge_u32(loc_0, 178956971) then goto continue_at_3 end
			loc_2 = mul_i32(loc_0, 24)
			reg_0 = FUNC_LIST[1275](loc_2)
			loc_3 = reg_0
			loc_0 = add_i32(loc_3, mul_i32(loc_1, 24))
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
			store_i32_n16(memory_at_0, loc_0 + 8, load_i32_u16(memory_at_0, param_1 + 8))
			store_i32(memory_at_0, loc_0 + 12, load_i32(memory_at_0, param_1 + 12))
			store_i32(memory_at_0, loc_0 + 16, load_i32(memory_at_0, param_1 + 16))
			loc_1 = add_i32(param_1, 20)
			store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_1))
			store_i32(memory_at_0, loc_1, 0)
			store_i64(memory_at_0, param_1 + 12, 0LL )
			loc_3 = add_i32(loc_2, loc_3)
			loc_4 = add_i32(loc_0, 24)
			param_1 = load_i32(memory_at_0, param_0 + 4)
			loc_1 = load_i32(memory_at_0, param_0)
			if param_1 == loc_1 then goto continue_at_2 end
			::continue_at_5::
			while true do
				loc_0 = sub_i32(loc_0, 24)
				param_1 = sub_i32(param_1, 24)
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
				store_i32_n16(memory_at_0, loc_0 + 8, load_i32_u16(memory_at_0, param_1 + 8))
				store_i32(memory_at_0, loc_0 + 12, load_i32(memory_at_0, param_1 + 12))
				store_i32(memory_at_0, loc_0 + 16, load_i32(memory_at_0, param_1 + 16))
				loc_2 = add_i32(param_1, 20)
				store_i32(memory_at_0, loc_0 + 20, load_i32(memory_at_0, loc_2))
				store_i32(memory_at_0, loc_2, 0)
				store_i64(memory_at_0, param_1 + 12, 0LL )
				if param_1 ~= loc_1 then goto continue_at_5 end
				break
			end
			store_i32(memory_at_0, param_0 + 8, loc_3)
			param_1 = load_i32(memory_at_0, param_0 + 4)
			store_i32(memory_at_0, param_0 + 4, loc_4)
			loc_1 = load_i32(memory_at_0, param_0)
			store_i32(memory_at_0, param_0, loc_0)
			if param_1 == loc_1 then goto continue_at_1 end
			::continue_at_6::
			while true do
				loc_0 = sub_i32(param_1, 24)
				loc_2 = sub_i32(param_1, 12)
				param_1 = load_i32(memory_at_0, loc_2)
				if param_1 ~= 0 then
					store_i32(memory_at_0, loc_2 + 4, param_1)
					FUNC_LIST[1276](param_1)
				end
				param_1 = loc_0
				if param_1 ~= loc_1 then goto continue_at_6 end
				break
			end
			goto continue_at_1
		end
		FUNC_LIST[382](param_0)
		error("out of code bounds")
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_2::
		store_i32(memory_at_0, param_0 + 8, loc_3)
		store_i32(memory_at_0, param_0 + 4, loc_4)
		store_i32(memory_at_0, param_0, loc_0)
		::continue_at_1::
		if loc_1 ~= 0 then FUNC_LIST[1276](loc_1) end
	end
FUNC_LIST[381] = --[[ Luau::detail::DenseHashTable<Luau::AstLocal*, std::__2::pair<Luau::AstLocal*, Luau::Compile::Constant>, std::__2::pair<Luau::AstLocal* const, Luau::Compile::Constant>, Luau::detail::ItemInterfaceMap<Luau::AstLocal*, Luau::Compile::Constant>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::rehash() ]]
	function(param_0)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0)
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		if loc_1 == loc_2 then
			if gt_u32(div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 24), 15) then
				goto continue_at_3
			end
			store_i64(memory_at_0, loc_0 + 8, 0LL )
			store_i64(memory_at_0, loc_0, 0LL )
			loc_4 = load_i32(memory_at_0, param_0 + 16)
			store_i32(memory_at_0, loc_0 + 16, loc_4)
			loc_8 = add_i32(param_0, 16)
			reg_0 = 16
			goto continue_at_4
		end
		store_i64(memory_at_0, loc_0 + 8, 0LL )
		store_i64(memory_at_0, loc_0, 0LL )
		loc_4 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, loc_0 + 16, loc_4)
		loc_8 = add_i32(param_0, 16)
		reg_0 = shl_i32(div_i32(sub_i32(loc_2, loc_1), 24), 1)
		::continue_at_4::
		loc_1 = reg_0
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		store_i32(memory_at_0, loc_0 + 24, loc_4)
		FUNC_LIST[256](loc_0, loc_1, add_i32(loc_0, 24))
		loc_2 = load_i32(memory_at_0, param_0 + 4)
		loc_1 = load_i32(memory_at_0, param_0)
		if loc_2 == loc_1 then
			loc_1 = loc_2
			goto continue_at_2
		end
		loc_9 = load_i32(memory_at_0, loc_0)
		loc_4 = sub_i32(
			div_i32(sub_i32(load_i32(memory_at_0, loc_0 + 4), loc_9), 24), 1
		)
		::continue_at_7::
		while true do
			loc_7 = add_i32(loc_1, mul_i32(loc_6, 24))
			loc_3 = load_i32(memory_at_0, loc_7)
			if loc_3 ~= load_i32(memory_at_0, loc_8) then
				loc_2 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
				loc_1 = 0
				loc_10 = load_i32(memory_at_0, loc_0 + 16)
				::continue_at_10::
				while true do
					loc_11 = band_i32(loc_2, loc_4)
					loc_5 = add_i32(loc_9, mul_i32(loc_11, 24))
					loc_2 = load_i32(memory_at_0, loc_5)
					if loc_10 == loc_2 then
						store_i32(memory_at_0, loc_5, loc_3)
						store_i32(
							memory_at_0, loc_0 + 12, add_i32(load_i32(memory_at_0, loc_0 + 12), 1)
						)
						loc_3 = load_i32(memory_at_0, loc_7)
						goto continue_at_9
					end
					if loc_2 == loc_3 then goto continue_at_9 end
					loc_1 = add_i32(loc_1, 1)
					loc_2 = add_i32(loc_1, loc_11)
					if le_u32(loc_1, loc_4) then goto continue_at_10 end
					break
				end
				loc_5 = 0
				::continue_at_9::
				store_i32(memory_at_0, loc_5, loc_3)
				store_i64(memory_at_0, loc_5 + 8, load_i64(memory_at_0, loc_7 + 8))
				store_i64(memory_at_0, loc_5 + 16, load_i64(memory_at_0, loc_7 + 16))
				loc_2 = load_i32(memory_at_0, param_0 + 4)
				loc_1 = load_i32(memory_at_0, param_0)
			end
			loc_6 = add_i32(loc_6, 1)
			if lt_u32(loc_6, div_i32(sub_i32(loc_2, loc_1), 24)) then
				goto continue_at_7
			end
			break
		end
		goto continue_at_2
		::continue_at_3::
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		store_i64(memory_at_0, loc_0 + 40, 0LL )
		store_i64(memory_at_0, loc_0 + 32, 0LL )
		store_i32(memory_at_0, loc_0 + 24, loc_1)
		FUNC_LIST[256](param_0, 16, add_i32(loc_0, 24))
		goto continue_at_1
		::continue_at_2::
		store_i32(memory_at_0, param_0, load_i32(memory_at_0, loc_0))
		store_i32(memory_at_0, loc_0, loc_1)
		store_i32(memory_at_0, param_0 + 4, load_i32(memory_at_0, loc_0 + 4))
		loc_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_0 + 8, load_i32(memory_at_0, loc_0 + 8))
		store_i32(memory_at_0, loc_0 + 8, loc_2)
		if loc_1 == 0 then goto continue_at_1 end
		store_i32(memory_at_0, loc_0 + 4, loc_1)
		FUNC_LIST[1276](loc_1)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
	end
FUNC_LIST[382] = --[[ std::__2::__vector_base<Luau::Compiler::InlineFrame, std::__2::allocator<Luau::Compiler::InlineFrame> >::__throw_length_error() const ]]
	function(param_0)
		FUNC_LIST[1388](param_0)
		error("out of code bounds")
	end
FUNC_LIST[383] = --[[ Luau::Compiler::compileUnrolledFor(Luau::AstStatFor*, int, double, double) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local loc_13 = 0
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local loc_17 = 0
		local reg_0
		loc_1 = add_i32(param_0, 244)
		loc_14 = load_i32(memory_at_0, param_0 + 236)
		loc_15 = load_i32(memory_at_0, param_0 + 232)
		loc_3 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 212), load_i32(memory_at_0, param_0 + 208)
			), 2
		)
		loc_8 = load_i32(memory_at_0, param_1 + 28)
		loc_0 = load_i32(memory_at_0, param_0 + 248)
		loc_5 = load_i32(memory_at_0, param_0 + 252)
		if lt_u32(loc_0, loc_5) then
			store_i32(memory_at_0, loc_0 + 4, 0)
			store_i32(memory_at_0, loc_0, loc_3)
			store_i32(memory_at_0, loc_1 + 4, add_i32(loc_0, 8))
			goto continue_at_4
		end
		loc_4 = load_i32(memory_at_0, loc_1)
		loc_6 = sub_i32(loc_0, loc_4)
		loc_7 = shr_i32(loc_6, 3)
		loc_2 = add_i32(loc_7, 1)
		if ge_u32(loc_2, 536870912) then goto continue_at_2 end
		loc_0 = 0
		loc_5 = sub_i32(loc_5, loc_4)
		loc_9 = shr_i32(loc_5, 2)
		loc_5 = (lt_u32(loc_5, 2147483640) and
			        (lt_u32(loc_2, loc_9) and loc_9 or loc_2) or 536870911)
		if loc_5 ~= 0 then
			if ge_u32(loc_5, 536870912) then goto continue_at_3 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
			loc_0 = reg_0
		end
		loc_2 = add_i32(loc_0, shl_i32(loc_7, 3))
		store_i32(memory_at_0, loc_2 + 4, 0)
		store_i32(memory_at_0, loc_2, loc_3)
		loc_3 = add_i32(loc_0, shl_i32(loc_5, 3))
		loc_5 = add_i32(loc_2, 8)
		if loc_6 > 0 then reg_0 = FUNC_LIST[1119](loc_0, loc_4, loc_6) end
		store_i32(memory_at_0, loc_1 + 8, loc_3)
		store_i32(memory_at_0, loc_1 + 4, loc_5)
		store_i32(memory_at_0, loc_1, loc_0)
		if loc_4 == 0 then goto continue_at_4 end
		FUNC_LIST[1276](loc_4)
		::continue_at_4::
		loc_5 = add_i32(param_0, 232)
		if param_2 <= 0 then goto continue_at_1 end
		loc_11 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
		loc_16 = add_i32(param_0, 100)
		loc_17 = add_i32(param_0, 124)
		loc_2 = add_i32(param_0, 148)
		::continue_at_8::
		while true do
			loc_3 = 0
			loc_12 = load_i32(memory_at_0, loc_2 + 4)
			loc_1 = load_i32(memory_at_0, loc_2)
			loc_0 = div_i32(sub_i32(loc_12, loc_1), 24)
			if ge_u32(load_i32(memory_at_0, loc_2 + 12), shr_u32(mul_i32(loc_0, 3), 2)) then
				FUNC_LIST[381](loc_2)
				loc_12 = load_i32(memory_at_0, loc_2 + 4)
				loc_1 = load_i32(memory_at_0, loc_2)
				loc_0 = div_i32(sub_i32(loc_12, loc_1), 24)
			end
			loc_7 = sub_i32(loc_0, 1)
			loc_0 = band_i32(loc_7, loc_11)
			loc_6 = add_i32(loc_1, mul_i32(loc_0, 24))
			loc_4 = load_i32(memory_at_0, loc_6)
			loc_9 = load_i32(memory_at_0, loc_2 + 16)
			if loc_4 == loc_9 then goto continue_at_11 end
			::continue_at_12::
			while true do
				if loc_4 ~= loc_8 then
					loc_3 = add_i32(loc_3, 1)
					loc_0 = band_i32(add_i32(loc_3, loc_0), loc_7)
					loc_6 = add_i32(loc_1, mul_i32(loc_0, 24))
					loc_4 = load_i32(memory_at_0, loc_6)
					if loc_9 ~= loc_4 then goto continue_at_12 end
					goto continue_at_11
				end
				break
			end
			loc_4 = load_i32(memory_at_0, loc_2 + 12)
			goto continue_at_10
			::continue_at_11::
			store_i32(memory_at_0, loc_6, loc_8)
			loc_4 = add_i32(load_i32(memory_at_0, loc_2 + 12), 1)
			store_i32(memory_at_0, loc_2 + 12, loc_4)
			::continue_at_10::
			store_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)) + 8, 3)
			loc_13 = (convert_f64_i32(loc_10) * param_4)
			loc_13 = (loc_13 + param_3)
			loc_3 = 0
			loc_0 = div_i32(sub_i32(loc_12, loc_1), 24)
			if le_u32(shr_u32(mul_i32(loc_0, 3), 2), loc_4) then
				FUNC_LIST[381](loc_2)
				loc_1 = load_i32(memory_at_0, loc_2)
				loc_0 = div_i32(sub_i32(load_i32(memory_at_0, loc_2 + 4), loc_1), 24)
			end
			loc_7 = sub_i32(loc_0, 1)
			loc_0 = band_i32(loc_7, loc_11)
			loc_6 = add_i32(loc_1, mul_i32(loc_0, 24))
			loc_4 = load_i32(memory_at_0, loc_6)
			loc_9 = load_i32(memory_at_0, loc_2 + 16)
			if loc_4 ~= loc_9 then
				::continue_at_17::
				while true do
					if loc_4 == loc_8 then goto continue_at_15 end
					loc_3 = add_i32(loc_3, 1)
					loc_0 = band_i32(add_i32(loc_3, loc_0), loc_7)
					loc_6 = add_i32(loc_1, mul_i32(loc_0, 24))
					loc_4 = load_i32(memory_at_0, loc_6)
					if loc_4 ~= loc_9 then goto continue_at_17 end
					break
				end
			end
			store_i32(memory_at_0, loc_6, loc_8)
			store_i32(
				memory_at_0, loc_2 + 12, add_i32(load_i32(memory_at_0, loc_2 + 12), 1)
			)
			::continue_at_15::
			store_f64(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)) + 16, loc_13)
			FUNC_LIST[54](loc_17, loc_16, loc_2, param_1)
			loc_1 = load_i32(memory_at_0, param_0 + 232)
			loc_0 = load_i32(memory_at_0, param_0 + 236)
			FUNC_LIST[238](param_0, load_i32(memory_at_0, param_1 + 44))
			reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
			loc_6 = reg_0
			loc_1 = shr_i32(sub_i32(loc_0, loc_1), 3)
			loc_4 = load_i32(memory_at_0, param_0 + 236)
			loc_0 = load_i32(memory_at_0, param_0 + 232)
			if ge_u32(loc_1, shr_i32(sub_i32(loc_4, loc_0), 3)) then
				goto continue_at_18
			end
			::continue_at_19::
			while true do
				loc_3 = add_i32(loc_0, shl_i32(loc_1, 3))
				if load_i32(memory_at_0, loc_3) == 1 then
					reg_0 = FUNC_LIST[119](
						load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_3 + 4), loc_6
					)
					if reg_0 == 0 then goto continue_at_20 end
					loc_4 = load_i32(memory_at_0, loc_5 + 4)
					loc_0 = load_i32(memory_at_0, loc_5)
				end
				loc_1 = add_i32(loc_1, 1)
				if lt_u32(loc_1, shr_i32(sub_i32(loc_4, loc_0), 3)) then
					goto continue_at_19
				end
				goto continue_at_18
				::continue_at_20::
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
			::continue_at_18::
			loc_10 = add_i32(loc_10, 1)
			if loc_10 ~= param_2 then goto continue_at_8 end
			break
		end
		goto continue_at_1
		::continue_at_3::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_2::
		FUNC_LIST[344](loc_1)
		error("out of code bounds")
		::continue_at_1::
		reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
		loc_2 = reg_0
		loc_6 = shr_i32(sub_i32(loc_14, loc_15), 3)
		loc_4 = load_i32(memory_at_0, param_0 + 236)
		loc_0 = load_i32(memory_at_0, param_0 + 232)
		loc_3 = shr_i32(sub_i32(loc_4, loc_0), 3)
		if lt_u32(loc_6, loc_3) then
			loc_1 = loc_6
			::continue_at_24::
			while true do
				loc_3 = add_i32(loc_0, shl_i32(loc_1, 3))
				if load_i32(memory_at_0, loc_3) == 0 then
					reg_0 = FUNC_LIST[119](
						load_i32(memory_at_0, param_0), load_i32(memory_at_0, loc_3 + 4), loc_2
					)
					if reg_0 == 0 then goto continue_at_22 end
					loc_4 = load_i32(memory_at_0, loc_5 + 4)
					loc_0 = load_i32(memory_at_0, loc_5)
				end
				loc_1 = add_i32(loc_1, 1)
				loc_3 = shr_i32(sub_i32(loc_4, loc_0), 3)
				if lt_u32(loc_1, loc_3) then goto continue_at_24 end
				break
			end
		end
		if lt_u32(loc_3, loc_6) then
			FUNC_LIST[343](loc_5, sub_i32(loc_6, loc_3))
			goto continue_at_26
		end
		if le_u32(loc_3, loc_6) then goto continue_at_26 end
		store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, shl_i32(loc_6, 3)))
		::continue_at_26::
		store_i32(
			memory_at_0, param_0 + 248, sub_i32(load_i32(memory_at_0, param_0 + 248), 8)
		)
		loc_7 = add_i32(param_0, 148)
		loc_3 = load_i32(memory_at_0, param_0 + 148)
		loc_1 = div_i32(sub_i32(load_i32(memory_at_0, param_0 + 152), loc_3), 24)
		if ge_u32(load_i32(memory_at_0, param_0 + 160), shr_u32(mul_i32(loc_1, 3), 2)) then
			FUNC_LIST[381](loc_7)
			loc_3 = load_i32(memory_at_0, loc_7)
			loc_1 = div_i32(sub_i32(load_i32(memory_at_0, loc_7 + 4), loc_3), 24)
		end
		loc_2 = sub_i32(loc_1, 1)
		loc_1 = band_i32(loc_2, bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9)))
		loc_5 = add_i32(loc_3, mul_i32(loc_1, 24))
		loc_0 = load_i32(memory_at_0, loc_5)
		loc_6 = load_i32(memory_at_0, loc_7 + 16)
		if loc_0 ~= loc_6 then
			loc_4 = 0
			::continue_at_31::
			while true do
				if loc_0 == loc_8 then goto continue_at_29 end
				loc_4 = add_i32(loc_4, 1)
				loc_1 = band_i32(add_i32(loc_4, loc_1), loc_2)
				loc_5 = add_i32(loc_3, mul_i32(loc_1, 24))
				loc_0 = load_i32(memory_at_0, loc_5)
				if loc_0 ~= loc_6 then goto continue_at_31 end
				break
			end
		end
		store_i32(memory_at_0, loc_5, loc_8)
		store_i32(
			memory_at_0, loc_7 + 12, add_i32(load_i32(memory_at_0, loc_7 + 12), 1)
		)
		::continue_at_29::
		store_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_1, 24)) + 8, 0)
		FUNC_LIST[54](add_i32(param_0, 124), add_i32(param_0, 100), loc_7, param_1)
		goto continue_at_0
		::continue_at_22::
		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[384] = --[[ Luau::Compiler::ConstUpvalueVisitor::~ConstUpvalueVisitor() ]]
	function(param_0)
		local loc_0 = 0
		local reg_0
		store_i32(memory_at_0, param_0, 12640)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		if loc_0 ~= 0 then
			store_i32(memory_at_0, param_0 + 12, loc_0)
			FUNC_LIST[1276](loc_0)
		end
		reg_0 = param_0
		return reg_0
	end
FUNC_LIST[385] = --[[ Luau::Compiler::ConstUpvalueVisitor::~ConstUpvalueVisitor().1 ]]
	function(param_0)
		local loc_0 = 0
		store_i32(memory_at_0, param_0, 12640)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		if loc_0 ~= 0 then
			store_i32(memory_at_0, param_0 + 12, loc_0)
			FUNC_LIST[1276](loc_0)
		end
		FUNC_LIST[1276](param_0)
	end
FUNC_LIST[386] = --[[ Luau::Compiler::ConstUpvalueVisitor::visit(Luau::AstExprLocal*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local reg_0
		if load_i32_u8(memory_at_0, param_1 + 28) == 0 then goto continue_at_3 end
		loc_1 = load_i32(memory_at_0, param_0 + 4)
		loc_2 = load_i32(memory_at_0, loc_1 + 124)
		loc_3 = load_i32(memory_at_0, loc_1 + 128)
		if loc_2 == loc_3 then goto continue_at_3 end
		loc_4 = load_i32(memory_at_0, loc_1 + 140)
		if loc_4 == param_1 then goto continue_at_3 end
		loc_0 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
		loc_3 = sub_i32(div_i32(sub_i32(loc_3, loc_2), 24), 1)
		loc_1 = 0
		::continue_at_4::
		while true do
			loc_0 = band_i32(loc_0, loc_3)
			loc_5 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 24)))
			if param_1 ~= loc_5 then
				if loc_4 == loc_5 then goto continue_at_3 end
				loc_1 = add_i32(loc_1, 1)
				loc_0 = add_i32(loc_1, loc_0)
				if le_u32(loc_1, loc_3) then goto continue_at_4 end
				goto continue_at_3
			end
			break
		end
		if load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_0, 24)) + 8) == 0 then
			goto continue_at_3
		end
		loc_1 = add_i32(param_0, 8)
		loc_0 = load_i32(memory_at_0, param_0 + 12)
		if loc_0 ~= load_i32(memory_at_0, param_0 + 16) then
			store_i32(memory_at_0, loc_0, load_i32(memory_at_0, param_1 + 24))
			store_i32(memory_at_0, loc_1 + 4, add_i32(loc_0, 4))
			reg_0 = 0
			goto continue_at_0
		end
		loc_5 = load_i32(memory_at_0, loc_1)
		loc_0 = sub_i32(loc_0, loc_5)
		loc_4 = shr_i32(loc_0, 2)
		loc_3 = add_i32(loc_4, 1)
		if ge_u32(loc_3, 1073741824) then goto continue_at_2 end
		loc_2 = shr_i32(loc_0, 1)
		loc_2 = (lt_u32(loc_0, 2147483644) and
			        (gt_u32(loc_2, loc_3) and loc_2 or loc_3) or 1073741823)
		if loc_2 ~= 0 then
			if ge_u32(loc_2, 1073741824) then goto continue_at_1 end
			reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 2))
		else
			reg_0 = 0
		end
		loc_3 = reg_0
		loc_4 = add_i32(loc_3, shl_i32(loc_4, 2))
		store_i32(memory_at_0, loc_4, load_i32(memory_at_0, param_1 + 24))
		param_1 = add_i32(loc_3, shl_i32(loc_2, 2))
		loc_2 = add_i32(loc_4, 4)
		if loc_0 > 0 then reg_0 = FUNC_LIST[1119](loc_3, loc_5, loc_0) end
		store_i32(memory_at_0, loc_1 + 8, param_1)
		store_i32(memory_at_0, loc_1 + 4, loc_2)
		store_i32(memory_at_0, loc_1, loc_3)
		if loc_5 == 0 then goto continue_at_3 end
		FUNC_LIST[1276](loc_5)
		::continue_at_3::
		reg_0 = 0
		goto continue_at_0
		::continue_at_2::
		FUNC_LIST[250](loc_1)
		error("out of code bounds")
		::continue_at_1::
		FUNC_LIST[252](5133)
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[387] = --[[ Luau::Compiler::ConstUpvalueVisitor::visit(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[388] = --[[ Luau::Compiler::ReturnVisitor::~ReturnVisitor() ]]
	function(param_0) FUNC_LIST[1276](param_0) end
FUNC_LIST[389] = --[[ Luau::Compiler::ReturnVisitor::visit(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local reg_0
		reg_0 = 0
		return reg_0
	end
FUNC_LIST[390] = --[[ Luau::Compiler::ReturnVisitor::visit(Luau::AstStatReturn*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = 0
		local loc_12 = 0
		local reg_0
		if load_i32(memory_at_0, param_1 + 32) == 1 then
			param_1 = load_i32(memory_at_0, load_i32(memory_at_0, param_1 + 28))
			loc_0 = load_i32(memory_at_0, param_1 + 4)
			if loc_0 ~= load_i32(memory_at_0, 54964) then goto continue_at_3 end
			if param_1 == 0 then goto continue_at_3 end
			loc_4 = load_i32(memory_at_0, param_0 + 4)
			loc_9 = load_i32(memory_at_0, loc_4 + 104)
			loc_2 = load_i32(memory_at_0, loc_4 + 100)
			loc_1 = sub_i32(div_i32(sub_i32(loc_9, loc_2), 12), 1)
			loc_6 = load_i32(memory_at_0, loc_4 + 116)
			loc_10 = load_i32(memory_at_0, 55020)
			loc_11 = load_i32(memory_at_0, 54900)
			loc_12 = load_i32(memory_at_0, 54940)
			param_1 = load_i32(memory_at_0, param_1 + 24)
			::continue_at_5::
			while true do
				loc_0 = load_i32(memory_at_0, param_1 + 4)
				if param_1 == 0 then goto continue_at_6 end
				if loc_0 ~= loc_12 then goto continue_at_6 end
				if loc_2 == loc_9 then goto continue_at_4 end
				loc_5 = load_i32(memory_at_0, param_1 + 24)
				if loc_5 == loc_6 then goto continue_at_4 end
				loc_0 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
				param_1 = 0
				::continue_at_7::
				while true do
					loc_7 = band_i32(loc_0, loc_1)
					loc_8 = add_i32(loc_2, mul_i32(loc_7, 12))
					loc_0 = load_i32(memory_at_0, loc_8)
					if loc_5 ~= loc_0 then
						if loc_0 == loc_6 then goto continue_at_4 end
						param_1 = add_i32(param_1, 1)
						loc_0 = add_i32(param_1, loc_7)
						if le_u32(param_1, loc_1) then goto continue_at_7 end
						goto continue_at_4
					end
					break
				end
				if load_i32_u8(memory_at_0, loc_8 + 8) ~= 0 then goto continue_at_4 end
				param_1 = load_i32(memory_at_0, loc_8 + 4)
				if param_1 ~= 0 then goto continue_at_5 end
				goto continue_at_4
				::continue_at_6::
				if param_1 == 0 then goto continue_at_9 end
				if loc_0 ~= loc_11 then goto continue_at_9 end
				param_1 = load_i32(memory_at_0, param_1 + 24)
				goto continue_at_5
				::continue_at_9::
				if param_1 == 0 then goto continue_at_10 end
				if loc_0 ~= loc_10 then goto continue_at_10 end
				param_1 = load_i32(memory_at_0, param_1 + 24)
				goto continue_at_5
				::continue_at_10::
				break
			end
			if loc_0 ~= load_i32(memory_at_0, 54988) then goto continue_at_4 end
			loc_2 = load_i32(memory_at_0, loc_4 + 28)
			loc_0 = load_i32(memory_at_0, loc_4 + 32)
			if loc_2 == loc_0 then goto continue_at_4 end
			loc_6 = load_i32(memory_at_0, loc_4 + 44)
			if param_1 == loc_6 then goto continue_at_4 end
			loc_1 = bxor_i32(shr_u32(param_1, 4), shr_u32(param_1, 9))
			loc_7 = sub_i32(div_i32(sub_i32(loc_0, loc_2), 40), 1)
			loc_0 = 0
			::continue_at_11::
			while true do
				loc_1 = band_i32(loc_1, loc_7)
				loc_5 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 40)))
				if param_1 ~= loc_5 then
					if loc_5 == loc_6 then goto continue_at_4 end
					loc_0 = add_i32(loc_0, 1)
					loc_1 = add_i32(loc_0, loc_1)
					if le_u32(loc_0, loc_7) then goto continue_at_11 end
					goto continue_at_4
				end
				break
			end
			loc_3 = load_i32_u8(memory_at_0, add_i32(loc_2, mul_i32(loc_1, 40)) + 37)
			::continue_at_4::
			store_i32_n8(
				memory_at_0, param_0 + 8,
					band_i32(load_i32_u8(memory_at_0, param_0 + 8), loc_3)
			)
			reg_0 = 0
			goto continue_at_0
			::continue_at_3::
			if loc_0 ~= load_i32(memory_at_0, 54956) then goto continue_at_1 end
			store_i32_n8(memory_at_0, param_0 + 8, 0)
			reg_0 = 0
			goto continue_at_0
		end
		store_i32_n8(memory_at_0, param_0 + 8, 0)
		::continue_at_1::
		reg_0 = 0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[391] = --[[ _GLOBAL__sub_I_Compiler.cpp ]] function()
	local loc_0 = 0
	store_i32(memory_at_0, 55304, 2565)
	store_i32(memory_at_0, 55320, 7011)
	store_i32_n8(memory_at_0, 55316, 0)
	store_i32(memory_at_0, 55312, 25)
	store_i32(memory_at_0, 55340, 55312)
	store_i32(memory_at_0, 55336, 1620)
	store_i32_n8(memory_at_0, 55332, 0)
	store_i32(memory_at_0, 55328, 300)
	store_i32(memory_at_0, 55356, 55328)
	store_i32(memory_at_0, 55352, 7042)
	store_i32_n8(memory_at_0, 55348, 0)
	store_i32(memory_at_0, 55344, 25)
	loc_0 = load_i32(memory_at_0, 54880)
	store_i32(memory_at_0, 54880, 55300)
	store_i32(memory_at_0, 55308, loc_0)
	store_i32(memory_at_0, 55324, load_i32(memory_at_0, 55392))
	store_i32(memory_at_0, 55392, 55376)
	store_i32_n16(memory_at_0, 55300, 0)
	store_i32(memory_at_0, 55372, 55344)
	store_i32(memory_at_0, 55368, 1659)
	store_i32_n8(memory_at_0, 55364, 0)
	store_i32(memory_at_0, 55360, 300)
	store_i32(memory_at_0, 55376, 5)
	store_i32(memory_at_0, 55384, 4595)
	store_i32(memory_at_0, 55388, 55360)
	store_i32_n8(memory_at_0, 55380, 0)
end
FUNC_LIST[392] = --[[ luau_compile(char const*, unsigned long, lua_CompileOptions*, unsigned long*) ]]
	function(param_0, param_1, param_2, param_3)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = add_i32(GLOBAL_LIST[0].value, -64)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = add_i32(loc_0, 56)
		store_i64(memory_at_0, loc_1, 0LL )
		store_i64(memory_at_0, loc_0 + 48, 0LL )
		store_i64(memory_at_0, loc_0 + 40, 4294967297LL )
		if param_2 ~= 0 then
			store_i64(memory_at_0, loc_1, load_i64(memory_at_0, param_2 + 16))
			store_i64(memory_at_0, loc_0 + 48, load_i64(memory_at_0, param_2 + 8))
			store_i64(memory_at_0, loc_0 + 40, load_i64(memory_at_0, param_2))
		end
		if lt_u32(param_1, -16) then
			if ge_u32(param_1, 11) then
				loc_1 = band_i32(add_i32(param_1, 16), -16)
				reg_0 = FUNC_LIST[1275](loc_1)
				param_2 = reg_0
				store_i32(memory_at_0, loc_0 + 16, bor_i32(loc_1, -2147483648))
				store_i32(memory_at_0, loc_0 + 8, param_2)
				store_i32(memory_at_0, loc_0 + 12, param_1)
				goto continue_at_4
			end
			store_i32_n8(memory_at_0, loc_0 + 19, param_1)
			param_2 = add_i32(loc_0, 8)
			if param_1 == 0 then goto continue_at_3 end
			::continue_at_4::
			reg_0 = FUNC_LIST[1119](param_2, param_0, param_1)
			::continue_at_3::
			store_i32_n8(memory_at_0, add_i32(param_1, param_2), 0)
			store_i32(memory_at_0, loc_0, 257)
			FUNC_LIST[247](
				add_i32(loc_0, 24), add_i32(loc_0, 8), add_i32(loc_0, 40), loc_0, 0
			)
			if load_i32_i8(memory_at_0, loc_0 + 19) < 0 then
				FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 8))
			end
			param_1 = load_i32_i8(memory_at_0, loc_0 + 35)
			param_0 = (param_1 < 0 and load_i32(memory_at_0, loc_0 + 28) or
				          band_i32(param_1, 255))
			reg_0 = FUNC_LIST[1251](param_0)
			param_2 = reg_0
			if param_2 ~= 0 then
				reg_0 = FUNC_LIST[1119](
					param_2,
						(param_1 < 0 and load_i32(memory_at_0, loc_0 + 24) or add_i32(loc_0, 24)),
						param_0
				)
				store_i32(memory_at_0, param_3, param_0)
			end
			if param_1 < 0 then FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 24)) end
			GLOBAL_LIST[0].value = sub_i32(loc_0, -64)
			reg_0 = param_2
			goto continue_at_0
		end
		FUNC_LIST[38](add_i32(loc_0, 8))
		error("out of code bounds")
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[393] = --[[ luaA_toobject(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0, reg_1
	reg_0 = 0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_1 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_1 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_1 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_1
	reg_0 = (param_1 == 15728 and reg_0 or param_1)
	return reg_0
end
FUNC_LIST[394] = --[[ pseudo2addr(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		local br_map, temp = {}, nil
		if not br_map[1] then br_map[1] = (function() return { [0] = 2, 1, 0 } end)() end
		temp = br_map[1][add_i32(param_1, 10002)] or 3
		if temp < 2 then
			if temp < 1 then
				goto continue_at_4
			else
				goto continue_at_3
			end
		elseif temp > 2 then
			goto continue_at_1
		else
			goto continue_at_2
		end
		::continue_at_4::
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 16), 1552)
		goto continue_at_0
		::continue_at_3::
		param_1 = load_i32(memory_at_0, param_0 + 16)
		loc_0 = load_i32(memory_at_0, param_0 + 20)
		if loc_0 == load_i32(memory_at_0, param_0 + 36) then
			reg_0 = add_i32(param_0, 56)
		else
			reg_0 = add_i32(load_i32(memory_at_0, load_i32(memory_at_0, loc_0 + 4)), 12)
		end
		loc_0 = reg_0
		loc_0 = load_i32(memory_at_0, loc_0)
		store_i32(memory_at_0, add_i32(param_1, 1548), 6)
		store_i32(memory_at_0, param_1 + 1536, loc_0)
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 16), 1536)
		goto continue_at_0
		::continue_at_2::
		param_1 = load_i32(memory_at_0, param_0 + 16)
		store_i32(memory_at_0, param_1 + 1536, load_i32(memory_at_0, param_0 + 56))
		store_i32(memory_at_0, add_i32(param_1, 1548), 6)
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 16), 1536)
		goto continue_at_0
		::continue_at_1::
		param_0 = load_i32(
			memory_at_0, load_i32(memory_at_0, load_i32(memory_at_0, param_0 + 20) + 4)
		)
		reg_0 = (load_i32_u8(memory_at_0, param_0 + 4) < sub_i32(-10002, param_1) and
			        15728 or
			        sub_i32(add_i32(param_0, shl_i32(sub_i32(0, param_1), 4)), 160016))
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[395] = --[[ luaA_pushobject(lua_State*, lua_TValue const*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1 + 8))
		store_i32(
			memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
	end
FUNC_LIST[396] = --[[ lua_checkstack(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local reg_0
	if param_1 > 8000 then goto continue_at_1 end
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	if add_i32(
		shr_i32(sub_i32(loc_0, load_i32(memory_at_0, param_0 + 12)), 4), param_1
	) > 8000 then goto continue_at_1 end
	loc_1 = 1
	if param_1 <= 0 then goto continue_at_1 end
	loc_2 = shl_i32(param_1, 4)
	if loc_2 >= sub_i32(load_i32(memory_at_0, param_0 + 24), loc_0) then
		FUNC_LIST[505](param_0, param_1)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
	end
	param_1 = load_i32(memory_at_0, param_0 + 20)
	param_0 = add_i32(loc_0, loc_2)
	if ge_u32(load_i32(memory_at_0, param_1 + 8), param_0) then goto continue_at_1 end
	store_i32(memory_at_0, param_1 + 8, param_0)
	::continue_at_1::
	reg_0 = loc_1
	return reg_0
end
FUNC_LIST[397] = --[[ lua_rawcheckstack(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	loc_1 = shl_i32(param_1, 4)
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	if loc_1 >= sub_i32(load_i32(memory_at_0, param_0 + 24), loc_0) then
		FUNC_LIST[505](param_0, param_1)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
	end
	param_1 = add_i32(loc_0, loc_1)
	param_0 = load_i32(memory_at_0, param_0 + 20)
	if gt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) then
		store_i32(memory_at_0, param_0 + 8, param_1)
	end
end
FUNC_LIST[398] = --[[ lua_xmove(lua_State*, lua_State*, int) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0
	if param_0 ~= param_1 then
		if band_i32(load_i32_u8(memory_at_0, param_1 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_1)
		end
		loc_8 = shl_i32(param_2, 4)
		loc_2 = sub_i32(load_i32(memory_at_0, param_0 + 8), loc_8)
		loc_3 = load_i32(memory_at_0, param_1 + 8)
		if param_2 <= 0 then goto continue_at_3 end
		loc_6 = band_i32(param_2, 3)
		if ge_u32(sub_i32(param_2, 1), 3) then
			loc_9 = band_i32(param_2, -4)
			::continue_at_5::
			while true do
				param_2 = shl_i32(loc_1, 4)
				loc_0 = add_i32(loc_3, param_2)
				loc_4 = add_i32(param_2, loc_2)
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_4))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_4 + 8))
				loc_0 = bor_i32(param_2, 16)
				loc_4 = add_i32(loc_3, loc_0)
				loc_0 = add_i32(loc_0, loc_2)
				store_i64(memory_at_0, loc_4 + 8, load_i64(memory_at_0, loc_0 + 8))
				store_i64(memory_at_0, loc_4, load_i64(memory_at_0, loc_0))
				loc_0 = bor_i32(param_2, 32)
				loc_4 = add_i32(loc_3, loc_0)
				loc_0 = add_i32(loc_0, loc_2)
				store_i64(memory_at_0, loc_4 + 8, load_i64(memory_at_0, loc_0 + 8))
				store_i64(memory_at_0, loc_4, load_i64(memory_at_0, loc_0))
				param_2 = bor_i32(param_2, 48)
				loc_0 = add_i32(loc_3, param_2)
				param_2 = add_i32(param_2, loc_2)
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
				loc_1 = add_i32(loc_1, 4)
				loc_5 = add_i32(loc_5, 4)
				if loc_5 ~= loc_9 then goto continue_at_5 end
				break
			end
		end
		if loc_6 == 0 then goto continue_at_3 end
		::continue_at_6::
		while true do
			param_2 = shl_i32(loc_1, 4)
			loc_5 = add_i32(loc_3, param_2)
			param_2 = add_i32(param_2, loc_2)
			store_i64(memory_at_0, loc_5, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, loc_5 + 8, load_i64(memory_at_0, param_2 + 8))
			loc_1 = add_i32(loc_1, 1)
			loc_7 = add_i32(loc_7, 1)
			if loc_7 ~= loc_6 then goto continue_at_6 end
			break
		end
		::continue_at_3::
		store_i32(memory_at_0, param_0 + 8, loc_2)
		store_i32(memory_at_0, param_1 + 8, add_i32(loc_3, loc_8))
	end
end
FUNC_LIST[399] = --[[ lua_xpush(lua_State*, lua_State*, int) ]] function(
	param_0, param_1, param_2
)
	local reg_0
	if band_i32(load_i32_u8(memory_at_0, param_1 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_1)
	end
	if param_2 > 0 then
		param_2 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_2, 4)
			), 16
		)
		reg_0 = (lt_u32(param_2, load_i32(memory_at_0, param_0 + 8)) and param_2 or
			        15728)
		goto continue_at_2
	end
	if param_2 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_2, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_2)
	::continue_at_2::
	param_2 = reg_0
	param_0 = load_i32(memory_at_0, param_1 + 8)
	store_i64(memory_at_0, param_0, load_i64(memory_at_0, param_2))
	store_i64(memory_at_0, param_0 + 8, load_i64(memory_at_0, param_2 + 8))
	store_i32(
		memory_at_0, param_1 + 8, add_i32(load_i32(memory_at_0, param_1 + 8), 16)
	)
end
FUNC_LIST[400] = --[[ lua_newthread(lua_State*) ]] function(param_0)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 16)
	if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
		reg_0 = FUNC_LIST[532](param_0, 1)
	end
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	reg_0 = FUNC_LIST[670](param_0)
	loc_0 = reg_0
	loc_1 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_1 + 12, 9)
	store_i32(memory_at_0, loc_1, loc_0)
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
	loc_1 = load_i32(
		memory_at_0, add_i32(load_i32(memory_at_0, param_0 + 16), 2140)
	)
	if loc_1 ~= 0 then TABLE_LIST[0].data[loc_1](param_0, loc_0) end
	reg_0 = loc_0
	return reg_0
end
FUNC_LIST[401] = --[[ lua_gettop(lua_State*) ]] function(param_0)
	local reg_0
	reg_0 = shr_i32(
		sub_i32(
			load_i32(memory_at_0, param_0 + 8), load_i32(memory_at_0, param_0 + 12)
		), 4
	)
	return reg_0
end
FUNC_LIST[402] = --[[ lua_settop(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		if param_1 >= 0 then
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			param_1 = add_i32(load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4))
			if lt_u32(loc_0, param_1) then
				::continue_at_3::
				while true do
					store_i32(memory_at_0, loc_0 + 12, 0)
					loc_0 = add_i32(loc_0, 16)
					if lt_u32(loc_0, param_1) then goto continue_at_3 end
					break
				end
			end
			store_i32(memory_at_0, param_0 + 8, param_1)
			goto continue_at_0
		end
		store_i32(
			memory_at_0, param_0 + 8, add_i32(
				add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4)), 16
			)
		)
		::continue_at_0::
	end
FUNC_LIST[403] = --[[ lua_remove(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			loc_0 = (lt_u32(param_1, loc_1) and param_1 or 15728)
			goto continue_at_1
		end
		if param_1 >= -9999 then
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			loc_0 = add_i32(loc_1, shl_i32(param_1, 4))
			goto continue_at_1
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		loc_0 = reg_0
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		::continue_at_1::
		param_1 = add_i32(loc_0, 16)
		if gt_u32(loc_1, param_1) then
			::continue_at_5::
			while true do
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1 + 8))
				loc_0 = param_1
				param_1 = add_i32(param_1, 16)
				loc_1 = load_i32(memory_at_0, param_0 + 8)
				if lt_u32(param_1, loc_1) then goto continue_at_5 end
				break
			end
		end
		store_i32(memory_at_0, param_0 + 8, sub_i32(loc_1, 16))
	end
FUNC_LIST[404] = --[[ lua_insert(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
			goto continue_at_2
		end
		if param_1 >= -9999 then
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = add_i32(loc_0, shl_i32(param_1, 4))
			goto continue_at_2
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		loc_1 = reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		::continue_at_2::
		if gt_u32(loc_0, loc_1) then
			::continue_at_6::
			while true do
				param_1 = sub_i32(loc_0, 16)
				store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
				store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1 + 8))
				loc_0 = param_1
				if gt_u32(param_1, loc_1) then goto continue_at_6 end
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i64(memory_at_0, loc_1, load_i64(memory_at_0, loc_0))
		store_i64(memory_at_0, loc_1 + 8, load_i64(memory_at_0, loc_0 + 8))
	end
FUNC_LIST[405] = --[[ lua_replace(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		local br_map, temp = {}, nil
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		if param_1 > 0 then
			loc_0 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			reg_0 =
				(lt_u32(loc_0, load_i32(memory_at_0, param_0 + 8)) and loc_0 or 15728)
			goto continue_at_2
		end
		if param_1 >= -9999 then
			reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_2
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		::continue_at_2::
		loc_0 = reg_0
		if not br_map[1] then br_map[1] = (function() return { [0] = 1, 0 } end)() end
		temp = br_map[1][add_i32(param_1, 10002)] or 2
		if temp < 1 then
			goto continue_at_8
		elseif temp > 1 then
			goto continue_at_6
		else
			goto continue_at_7
		end
		::continue_at_8::
		loc_0 = load_i32(
			memory_at_0, load_i32(memory_at_0, load_i32(memory_at_0, param_0 + 20) + 4)
		)
		param_1 = sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
		store_i32(memory_at_0, loc_0 + 12, load_i32(memory_at_0, param_1))
		if load_i32(memory_at_0, param_1 + 12) < 5 then goto continue_at_5 end
		if band_i32(load_i32_u8(memory_at_0, loc_0 + 1), 4) == 0 then
			goto continue_at_5
		end
		param_1 = load_i32(memory_at_0, param_1)
		if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 3) == 0 then
			goto continue_at_5
		end
		FUNC_LIST[541](param_0, loc_0, param_1)
		goto continue_at_5
		::continue_at_7::
		store_i32(
			memory_at_0, param_0 + 56,
				load_i32(memory_at_0, sub_i32(load_i32(memory_at_0, param_0 + 8), 16))
		)
		goto continue_at_5
		::continue_at_6::
		loc_1 = sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_1))
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_1 + 8))
		if param_1 > -10003 then goto continue_at_5 end
		param_1 = load_i32(memory_at_0, param_0 + 8)
		if load_i32(memory_at_0, sub_i32(param_1, 4)) < 5 then goto continue_at_5 end
		loc_0 = load_i32(
			memory_at_0, load_i32(memory_at_0, load_i32(memory_at_0, param_0 + 20) + 4)
		)
		if band_i32(load_i32_u8(memory_at_0, loc_0 + 1), 4) == 0 then
			goto continue_at_5
		end
		param_1 = load_i32(memory_at_0, sub_i32(param_1, 16))
		if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 3) == 0 then
			goto continue_at_5
		end
		FUNC_LIST[541](param_0, loc_0, param_1)
		::continue_at_5::
		store_i32(
			memory_at_0, param_0 + 8, sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
	end
FUNC_LIST[406] = --[[ lua_pushvalue(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local reg_0
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
		goto continue_at_2
	end
	if param_1 >= -9999 then
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = add_i32(loc_0, shl_i32(param_1, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	param_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	::continue_at_2::
	store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
	store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1 + 8))
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
end
FUNC_LIST[407] = --[[ lua_type(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		if param_1 > 0 then
			loc_0 = -1
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			if lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) then
				goto continue_at_2
			end
			goto continue_at_1
		end
		if param_1 >= -9999 then
			param_1 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_2
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		param_1 = reg_0
		::continue_at_2::
		if param_1 == 15728 then
			reg_0 = -1
			goto continue_at_0
		end
		loc_0 = load_i32(memory_at_0, param_1 + 12)
		::continue_at_1::
		reg_0 = loc_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[408] = --[[ lua_typename(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	if param_1 == -1 then
		reg_0 = 5379
		goto continue_at_0
	end
	reg_0 = load_i32(memory_at_0, add_i32(shl_i32(param_1, 2), 16368))
	::continue_at_0::
	return reg_0
end
FUNC_LIST[409] = --[[ lua_iscfunction(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	param_0 = 0
	if load_i32(memory_at_0, param_1 + 12) == 7 then
		param_0 =
			(load_i32_u8(memory_at_0, load_i32(memory_at_0, param_1) + 3) ~= 0 and 1 or 0)
	end
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[410] = --[[ lua_isnumber(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	param_0 = 1
	if load_i32(memory_at_0, param_1 + 12) ~= 3 then
		reg_0 = FUNC_LIST[835](param_1, loc_0)
		param_0 = (reg_0 ~= 0 and 1 or 0)
	end
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[411] = --[[ lua_isstring(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local reg_0
	if param_1 > 0 then
		loc_0 = -1
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		if lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) then
			goto continue_at_2
		end
		goto continue_at_1
	end
	if param_1 >= -9999 then
		param_1 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	param_1 = reg_0
	::continue_at_2::
	if param_1 == 15728 then
		loc_0 = -1
		goto continue_at_1
	end
	loc_0 = load_i32(memory_at_0, param_1 + 12)
	::continue_at_1::
	reg_0 = bor_i32((loc_0 == 5 and 1 or 0), (loc_0 == 3 and 1 or 0))
	return reg_0
end
FUNC_LIST[412] = --[[ lua_rawequal(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	if param_2 > 0 then
		param_2 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_2, 4)
			), 16
		)
		reg_0 = (lt_u32(param_2, load_i32(memory_at_0, param_0 + 8)) and param_2 or
			        15728)
		goto continue_at_4
	end
	if param_2 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_2, 4))
		goto continue_at_4
	end
	reg_0 = FUNC_LIST[394](param_0, param_2)
	::continue_at_4::
	param_2 = reg_0
	param_0 = 0
	if param_1 == 15728 then goto continue_at_7 end
	if param_2 == 15728 then goto continue_at_7 end
	reg_0 = FUNC_LIST[658](param_1, param_2)
	param_0 = reg_0
	::continue_at_7::
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[413] = --[[ lua_lessthan(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	if param_2 > 0 then
		param_2 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_2, 4)
			), 16
		)
		reg_0 = (lt_u32(param_2, load_i32(memory_at_0, param_0 + 8)) and param_2 or
			        15728)
		goto continue_at_4
	end
	if param_2 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_2, 4))
		goto continue_at_4
	end
	reg_0 = FUNC_LIST[394](param_0, param_2)
	::continue_at_4::
	loc_0 = reg_0
	param_2 = 0
	if param_1 == 15728 then goto continue_at_7 end
	if loc_0 == 15728 then goto continue_at_7 end
	reg_0 = FUNC_LIST[840](param_0, param_1, loc_0)
	param_2 = reg_0
	::continue_at_7::
	reg_0 = param_2
	return reg_0
end
FUNC_LIST[414] = --[[ lua_tonumberx(lua_State*, int, int*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_3
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_3
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_3::
	param_1 = reg_0
	if load_i32(memory_at_0, param_1 + 12) ~= 3 then
		reg_0 = FUNC_LIST[835](param_1, loc_0)
		param_1 = reg_0
		if param_1 == 0 then goto continue_at_2 end
	end
	if param_2 ~= 0 then store_i32(memory_at_0, param_2, 1) end
	loc_1 = load_f64(memory_at_0, param_1)
	goto continue_at_1
	::continue_at_2::
	if param_2 == 0 then goto continue_at_1 end
	store_i32(memory_at_0, param_2, 0)
	::continue_at_1::
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	reg_0 = loc_1
	return reg_0
end
FUNC_LIST[415] = --[[ lua_tointegerx(lua_State*, int, int*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_4
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_4
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_4::
	param_1 = reg_0
	if load_i32(memory_at_0, param_1 + 12) ~= 3 then
		reg_0 = FUNC_LIST[835](param_1, loc_0)
		param_1 = reg_0
		if param_1 == 0 then goto continue_at_3 end
	end
	loc_1 = load_f64(memory_at_0, param_1)
	if abs_f64(loc_1) < 2.147483648e9 then
		reg_0 = truncate_i32_f64(loc_1)
		goto continue_at_8
	end
	reg_0 = -2147483648
	::continue_at_8::
	param_1 = reg_0
	param_0 = 1
	if param_2 ~= 0 then goto continue_at_2 end
	goto continue_at_1
	::continue_at_3::
	param_0 = 0
	param_1 = 0
	if param_2 == 0 then goto continue_at_1 end
	::continue_at_2::
	store_i32(memory_at_0, param_2, param_0)
	::continue_at_1::
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	reg_0 = param_1
	return reg_0
end
FUNC_LIST[416] = --[[ lua_tounsignedx(lua_State*, int, int*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_4
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_4
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_4::
	param_1 = reg_0
	if load_i32(memory_at_0, param_1 + 12) ~= 3 then
		reg_0 = FUNC_LIST[835](param_1, loc_0)
		param_1 = reg_0
		if param_1 == 0 then goto continue_at_3 end
	end
	loc_1 = load_f64(memory_at_0, param_1)
	if abs_f64(loc_1) < 9.223372036854776e18 then
		reg_0 = truncate_i64_f64(loc_1)
		goto continue_at_8
	end
	reg_0 = -9223372036854775808LL
	::continue_at_8::
	param_1 = wrap_i32_i64(reg_0)
	param_0 = 1
	if param_2 ~= 0 then goto continue_at_2 end
	goto continue_at_1
	::continue_at_3::
	param_0 = 0
	param_1 = 0
	if param_2 == 0 then goto continue_at_1 end
	::continue_at_2::
	store_i32(memory_at_0, param_2, param_0)
	::continue_at_1::
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	reg_0 = param_1
	return reg_0
end
FUNC_LIST[417] = --[[ lua_toboolean(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	local br_map, temp = {}, nil
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_4
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_4
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_4::
	param_1 = reg_0
	param_0 = load_i32(memory_at_0, param_1 + 12)
	if not br_map[1] then br_map[1] = (function() return { [0] = 2, 0 } end)() end
	temp = br_map[1][param_0] or 1
	if temp < 1 then
		goto continue_at_3
	elseif temp > 1 then
		goto continue_at_1
	else
		goto continue_at_2
	end
	::continue_at_3::
	reg_0 = (load_i32(memory_at_0, param_1) ~= 0 and 1 or 0)
	goto continue_at_0
	::continue_at_2::
	param_0 = 1
	::continue_at_1::
	reg_0 = param_0
	::continue_at_0::
	return reg_0
end
FUNC_LIST[418] = --[[ lua_tolstring(lua_State*, int, unsigned long*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local reg_0
		if param_1 > 0 then
			loc_0 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			reg_0 =
				(lt_u32(loc_0, load_i32(memory_at_0, param_0 + 8)) and loc_0 or 15728)
			goto continue_at_3
		end
		if param_1 >= -9999 then
			reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_3
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		::continue_at_3::
		loc_0 = reg_0
		if load_i32(memory_at_0, loc_0 + 12) == 5 then goto continue_at_2 end
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		reg_0 = FUNC_LIST[836](param_0, loc_0)
		if reg_0 == 0 then
			param_0 = 0
			reg_0 = param_0
			if param_2 == 0 then goto continue_at_1 end
			store_i32(memory_at_0, param_2, 0)
			reg_0 = 0
			goto continue_at_0
		end
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
			reg_0 = FUNC_LIST[532](param_0, 1)
		end
		if param_1 > 0 then
			loc_0 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			loc_0 =
				(lt_u32(loc_0, load_i32(memory_at_0, param_0 + 8)) and loc_0 or 15728)
			goto continue_at_2
		end
		if param_1 >= -9999 then
			loc_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_2
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		loc_0 = reg_0
		::continue_at_2::
		if param_2 ~= 0 then
			store_i32(
				memory_at_0, param_2,
					load_i32(memory_at_0, load_i32(memory_at_0, loc_0) + 16)
			)
		end
		reg_0 = add_i32(load_i32(memory_at_0, loc_0), 20)
		::continue_at_1::
		param_0 = reg_0
		reg_0 = param_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[419] = --[[ lua_tovector(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	reg_0 = (load_i32(memory_at_0, param_1 + 12) == 4 and param_1 or 0)
	return reg_0
end
FUNC_LIST[420] = --[[ lua_objlen(lua_State*, int) ]]
	function(param_0, param_1)
		local reg_0
		local br_map, temp = {}, nil
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
				        15728)
			goto continue_at_1
		end
		if param_1 >= -9999 then
			reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_1
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		::continue_at_1::
		param_1 = reg_0
		param_0 = 0
		if not br_map[1] then
			br_map[1] = (function() return { [0] = 0, 2, 3, 1 } end)()
		end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, param_1 + 12), 5)] or 3
		if temp < 2 then
			if temp < 1 then
				goto continue_at_7
			else
				goto continue_at_6
			end
		elseif temp > 2 then
			goto continue_at_4
		else
			goto continue_at_5
		end
		::continue_at_7::
		reg_0 = load_i32(memory_at_0, load_i32(memory_at_0, param_1) + 16)
		goto continue_at_0
		::continue_at_6::
		reg_0 = load_i32(memory_at_0, load_i32(memory_at_0, param_1) + 4)
		goto continue_at_0
		::continue_at_5::
		reg_0 = FUNC_LIST[725](load_i32(memory_at_0, param_1))
		param_0 = reg_0
		::continue_at_4::
		reg_0 = param_0
		::continue_at_0::
		return reg_0
	end
FUNC_LIST[421] = --[[ lua_tothread(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	param_0 = 0
	if load_i32(memory_at_0, param_1 + 12) == 9 then
		param_0 = load_i32(memory_at_0, param_1)
	end
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[422] = --[[ lua_topointer(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	local br_map, temp = {}, nil
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	param_0 = 0
	if not br_map[1] then
		br_map[1] = (function() return { [0] = 1, 2, 2, 2, 1, 1, 0, 1 } end)()
	end
	temp = br_map[1][sub_i32(load_i32(memory_at_0, param_1 + 12), 2)] or 2
	if temp < 1 then
		goto continue_at_6
	elseif temp > 1 then
		goto continue_at_4
	else
		goto continue_at_5
	end
	::continue_at_6::
	reg_0 = add_i32(load_i32(memory_at_0, param_1), 16)
	goto continue_at_0
	::continue_at_5::
	param_0 = load_i32(memory_at_0, param_1)
	::continue_at_4::
	reg_0 = param_0
	::continue_at_0::
	return reg_0
end
FUNC_LIST[423] = --[[ lua_pushnil(lua_State*) ]] function(param_0)
	local loc_0 = 0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, 0)
	store_i32(memory_at_0, param_0 + 8, add_i32(loc_0, 16))
end
FUNC_LIST[424] = --[[ lua_pushnumber(lua_State*, double) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, 3)
	store_f64(memory_at_0, loc_0, param_1)
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
end
FUNC_LIST[425] = --[[ lua_pushinteger(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, 3)
	store_f64(memory_at_0, loc_0, convert_f64_i32(param_1))
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
end
FUNC_LIST[426] = --[[ lua_pushunsigned(lua_State*, unsigned int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, 3)
	store_f64(memory_at_0, loc_0, convert_f64_u32(param_1))
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
end
FUNC_LIST[427] = --[[ lua_pushlstring(lua_State*, char const*, unsigned long) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
			reg_0 = FUNC_LIST[532](param_0, 1)
		end
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		reg_0 = FUNC_LIST[680](param_0, param_1, param_2)
		param_1 = reg_0
		store_i32(memory_at_0, loc_0 + 12, 5)
		store_i32(memory_at_0, loc_0, param_1)
		store_i32(
			memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
	end
FUNC_LIST[428] = --[[ lua_pushstring(lua_State*, char const*) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	if param_1 == 0 then
		param_1 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_1 + 12, 0)
		reg_0 = add_i32(param_0, 8)
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[1197](param_1)
	loc_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 16)
	if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
		reg_0 = FUNC_LIST[532](param_0, 1)
	end
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	reg_0 = FUNC_LIST[680](param_0, param_1, loc_1)
	param_1 = reg_0
	store_i32(memory_at_0, loc_0 + 12, 5)
	store_i32(memory_at_0, loc_0, param_1)
	param_1 = load_i32(memory_at_0, param_0 + 8)
	reg_0 = add_i32(param_0, 8)
	::continue_at_1::
	loc_0 = reg_0
	store_i32(memory_at_0, loc_0, add_i32(param_1, 16))
end
FUNC_LIST[429] = --[[ lua_pushvfstring(lua_State*, char const*, void*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
			reg_0 = FUNC_LIST[532](param_0, 1)
		end
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		reg_0 = FUNC_LIST[661](param_0, param_1, param_2)
		return reg_0
	end
FUNC_LIST[430] = --[[ lua_pushfstringL(lua_State*, char const*, ...) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_0
		loc_1 = load_i32(memory_at_0, param_0 + 16)
		if ge_u32(load_i32(memory_at_0, loc_1 + 44), load_i32(memory_at_0, loc_1 + 40)) then
			reg_0 = FUNC_LIST[532](param_0, 1)
		end
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		store_i32(memory_at_0, loc_0 + 12, param_2)
		reg_0 = FUNC_LIST[661](param_0, param_1, param_2)
		param_0 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_0, 16)
		reg_0 = param_0
		return reg_0
	end
FUNC_LIST[431] = --[[ lua_pushcclosurek(lua_State*, int (*)(lua_State*), char const*, int, int (*)(lua_State*, int)) ]]
	function(param_0, param_1, param_2, param_3, param_4)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0, reg_1, reg_2
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
			reg_0 = FUNC_LIST[532](param_0, 1)
		end
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		loc_0 = load_i32(memory_at_0, param_0 + 20)
		reg_0 = param_0
		reg_1 = param_3
		if loc_0 == load_i32(memory_at_0, param_0 + 36) then
			reg_2 = add_i32(param_0, 56)
		else
			reg_2 = add_i32(load_i32(memory_at_0, load_i32(memory_at_0, loc_0 + 4)), 12)
		end
		loc_0 = reg_2
		reg_0 = FUNC_LIST[522](reg_0, reg_1, load_i32(memory_at_0, loc_0))
		loc_1 = reg_0
		store_i32(memory_at_0, loc_1 + 16, param_1)
		store_i32(memory_at_0, loc_1 + 24, param_2)
		store_i32(memory_at_0, loc_1 + 20, param_4)
		param_4 = load_i32(memory_at_0, param_0 + 8)
		param_2 = sub_i32(param_4, shl_i32(param_3, 4))
		store_i32(memory_at_0, param_0 + 8, param_2)
		if param_3 == 0 then goto continue_at_5 end
		loc_0 = add_i32(loc_1, 16)
		param_1 = param_3
		if band_i32(param_3, 1) ~= 0 then
			param_1 = sub_i32(param_3, 1)
			param_2 = add_i32(loc_0, shl_i32(param_1, 4))
			param_4 = sub_i32(param_4, 16)
			store_i64(memory_at_0, param_2 + 24, load_i64(memory_at_0, param_4 + 8))
			store_i64(memory_at_0, param_2 + 16, load_i64(memory_at_0, param_4))
			param_2 = load_i32(memory_at_0, param_0 + 8)
		end
		if param_3 == 1 then goto continue_at_5 end
		param_3 = add_i32(loc_0, 16)
		::continue_at_7::
		while true do
			param_4 = sub_i32(shl_i32(param_1, 4), 16)
			loc_0 = add_i32(param_3, param_4)
			param_2 = add_i32(param_2, param_4)
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_2 + 8))
			param_1 = sub_i32(param_1, 2)
			param_2 = shl_i32(param_1, 4)
			param_4 = add_i32(param_3, param_2)
			param_2 = add_i32(load_i32(memory_at_0, param_0 + 8), param_2)
			store_i64(memory_at_0, param_4, load_i64(memory_at_0, param_2))
			store_i64(memory_at_0, param_4 + 8, load_i64(memory_at_0, param_2 + 8))
			param_2 = load_i32(memory_at_0, param_0 + 8)
			if param_1 ~= 0 then goto continue_at_7 end
			break
		end
		::continue_at_5::
		store_i32(memory_at_0, param_2 + 12, 7)
		store_i32(memory_at_0, param_2, loc_1)
		store_i32(
			memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
	end
FUNC_LIST[432] = --[[ lua_pushboolean(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, 1)
	store_i32(memory_at_0, loc_0, (param_1 ~= 0 and 1 or 0))
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
end
FUNC_LIST[433] = --[[ lua_pushthread(lua_State*) ]] function(param_0)
	local loc_0 = 0
	local reg_0
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, 9)
	store_i32(memory_at_0, loc_0, param_0)
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
	reg_0 = (load_i32(memory_at_0, load_i32(memory_at_0, param_0 + 16) + 1348) ==
		        param_0 and 1 or 0)
	return reg_0
end
FUNC_LIST[434] = --[[ lua_gettable(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local reg_0
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
		goto continue_at_2
	end
	if param_1 >= -9999 then
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = add_i32(loc_0, shl_i32(param_1, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	param_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	::continue_at_2::
	loc_0 = sub_i32(loc_0, 16)
	FUNC_LIST[837](param_0, param_1, loc_0, loc_0)
	reg_0 = load_i32(memory_at_0, sub_i32(load_i32(memory_at_0, param_0 + 8), 4))
	return reg_0
end
FUNC_LIST[435] = --[[ lua_getfield(lua_State*, int, char const*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local reg_0, reg_1, reg_2
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_2
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_2::
	param_1 = reg_0
	reg_2 = FUNC_LIST[1197](param_2)
	reg_0 = FUNC_LIST[680](param_0, param_2, reg_2)
	param_2 = reg_0
	store_i32(memory_at_0, loc_0 + 12, 5)
	store_i32(memory_at_0, loc_0, param_2)
	FUNC_LIST[837](param_0, param_1, loc_0, load_i32(memory_at_0, param_0 + 8))
	param_1 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, param_0 + 8, add_i32(param_1, 16))
	param_0 = load_i32(memory_at_0, param_1 + 12)
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	reg_0 = param_0
	return reg_0
end
FUNC_LIST[436] = --[[ lua_rawgetfield(lua_State*, int, char const*) ]] function(
	param_0, param_1, param_2
)
	local reg_0, reg_1, reg_2
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_2
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_2::
	param_1 = reg_0
	reg_2 = FUNC_LIST[1197](param_2)
	reg_0 = FUNC_LIST[680](param_0, param_2, reg_2)
	param_2 = reg_0
	reg_0 = FUNC_LIST[719](load_i32(memory_at_0, param_1), param_2)
	param_1 = reg_0
	param_2 = load_i32(memory_at_0, param_0 + 8)
	store_i64(memory_at_0, param_2, load_i64(memory_at_0, param_1))
	store_i64(memory_at_0, param_2 + 8, load_i64(memory_at_0, param_1 + 8))
	param_1 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, param_0 + 8, add_i32(param_1, 16))
	reg_0 = load_i32(memory_at_0, param_1 + 12)
	return reg_0
end
FUNC_LIST[437] = --[[ lua_rawget(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			param_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
			goto continue_at_2
		end
		if param_1 >= -9999 then
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			param_1 = add_i32(loc_0, shl_i32(param_1, 4))
			goto continue_at_2
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		param_1 = reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		::continue_at_2::
		reg_0 = FUNC_LIST[720](load_i32(memory_at_0, param_1), sub_i32(loc_0, 16))
		param_1 = reg_0
		loc_0 = sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
		store_i64(memory_at_0, loc_0, load_i64(memory_at_0, param_1))
		store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, param_1 + 8))
		reg_0 = load_i32(memory_at_0, sub_i32(load_i32(memory_at_0, param_0 + 8), 4))
		return reg_0
	end
FUNC_LIST[438] = --[[ lua_rawgeti(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local reg_0
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_2
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_2
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_2::
	param_1 = reg_0
	reg_0 = FUNC_LIST[718](load_i32(memory_at_0, param_1), param_2)
	param_1 = reg_0
	param_2 = load_i32(memory_at_0, param_0 + 8)
	store_i64(memory_at_0, param_2, load_i64(memory_at_0, param_1))
	store_i64(memory_at_0, param_2 + 8, load_i64(memory_at_0, param_1 + 8))
	param_1 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, param_0 + 8, add_i32(param_1, 16))
	reg_0 = load_i32(memory_at_0, param_1 + 12)
	return reg_0
end
FUNC_LIST[439] = --[[ lua_createtable(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 16)
	if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
		reg_0 = FUNC_LIST[532](param_0, 1)
	end
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	reg_0 = FUNC_LIST[716](param_0, param_1, param_2)
	param_1 = reg_0
	store_i32(memory_at_0, loc_0 + 12, 6)
	store_i32(memory_at_0, loc_0, param_1)
	store_i32(
		memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
end
FUNC_LIST[440] = --[[ lua_setreadonly(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	store_i32_n8(
		memory_at_0, load_i32(memory_at_0, param_1) + 4, (param_2 ~= 0 and 1 or 0)
	)
end
FUNC_LIST[441] = --[[ lua_getreadonly(lua_State*, int) ]] function(
	param_0, param_1
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	reg_0 = load_i32_u8(memory_at_0, load_i32(memory_at_0, param_1) + 4)
	return reg_0
end
FUNC_LIST[442] = --[[ lua_setsafeenv(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	store_i32_n8(
		memory_at_0, load_i32(memory_at_0, param_1) + 5, (param_2 ~= 0 and 1 or 0)
	)
end
FUNC_LIST[443] = --[[ lua_getmetatable(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local reg_0
	local br_map, temp = {}, nil
	if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
		FUNC_LIST[546](param_0)
	end
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_6
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_6
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_6::
	param_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_1 + 12)
	if not br_map[1] then br_map[1] = (function() return { [0] = 0, 2, 1 } end)() end
	temp = br_map[1][sub_i32(loc_0, 6)] or 2
	if temp < 1 then
		goto continue_at_5
	elseif temp > 1 then
		goto continue_at_3
	else
		goto continue_at_4
	end
	::continue_at_5::
	reg_0 = add_i32(load_i32(memory_at_0, param_1), 16)
	goto continue_at_2
	::continue_at_4::
	reg_0 = add_i32(load_i32(memory_at_0, param_1), 8)
	goto continue_at_2
	::continue_at_3::
	reg_0 = add_i32(
		add_i32(load_i32(memory_at_0, param_0 + 16), shl_i32(loc_0, 2)), 1376
	)
	::continue_at_2::
	param_1 = reg_0
	param_1 = load_i32(memory_at_0, param_1)
	if param_1 ~= 0 then
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, loc_0 + 12, 6)
		store_i32(memory_at_0, loc_0, param_1)
		store_i32(
			memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
	end
	reg_0 = (param_1 ~= 0 and 1 or 0)
	return reg_0
end
FUNC_LIST[444] = --[[ lua_getfenv(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		local br_map, temp = {}, nil
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
				        15728)
			goto continue_at_6
		end
		if param_1 >= -9999 then
			reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_6
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		::continue_at_6::
		param_1 = reg_0
		if not br_map[1] then br_map[1] = (function() return { [0] = 0, 2, 1 } end)() end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, param_1 + 12), 7)] or 2
		if temp < 1 then
			goto continue_at_5
		elseif temp > 1 then
			goto continue_at_3
		else
			goto continue_at_4
		end
		::continue_at_5::
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i32(
			memory_at_0, loc_0,
				load_i32(memory_at_0, load_i32(memory_at_0, param_1) + 12)
		)
		reg_0 = 6
		goto continue_at_2
		::continue_at_4::
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i32(
			memory_at_0, loc_0,
				load_i32(memory_at_0, load_i32(memory_at_0, param_1) + 56)
		)
		reg_0 = 6
		goto continue_at_2
		::continue_at_3::
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		reg_0 = 0
		::continue_at_2::
		param_1 = reg_0
		store_i32(memory_at_0, loc_0 + 12, param_1)
		store_i32(
			memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
	end
FUNC_LIST[445] = --[[ lua_settable(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = add_i32(loc_0, shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	param_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	::continue_at_1::
	FUNC_LIST[838](param_0, param_1, sub_i32(loc_0, 32), sub_i32(loc_0, 16))
	store_i32(
		memory_at_0, param_0 + 8, sub_i32(load_i32(memory_at_0, param_0 + 8), 32)
	)
end
FUNC_LIST[446] = --[[ lua_setfield(lua_State*, int, char const*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local reg_0, reg_1, reg_2
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	reg_2 = FUNC_LIST[1197](param_2)
	reg_0 = FUNC_LIST[680](param_0, param_2, reg_2)
	param_2 = reg_0
	store_i32(memory_at_0, loc_0 + 12, 5)
	store_i32(memory_at_0, loc_0, param_2)
	FUNC_LIST[838](
		param_0, param_1, loc_0, sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
	store_i32(
		memory_at_0, param_0 + 8, sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
end
FUNC_LIST[447] = --[[ lua_rawset(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
				        15728)
			goto continue_at_1
		end
		if param_1 >= -9999 then
			reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_1
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		::continue_at_1::
		param_1 = reg_0
		loc_0 = load_i32(memory_at_0, param_1)
		if load_i32_u8(memory_at_0, loc_0 + 4) == 0 then
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			reg_0 = FUNC_LIST[721](param_0, loc_0, sub_i32(loc_1, 32))
			loc_0 = reg_0
			loc_1 = sub_i32(loc_1, 16)
			store_i64(memory_at_0, loc_0 + 8, load_i64(memory_at_0, loc_1 + 8))
			store_i64(memory_at_0, loc_0, load_i64(memory_at_0, loc_1))
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			if load_i32(memory_at_0, sub_i32(loc_0, 4)) < 5 then goto continue_at_5 end
			param_1 = load_i32(memory_at_0, param_1)
			if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 4) == 0 then
				goto continue_at_5
			end
			loc_1 = load_i32(memory_at_0, sub_i32(loc_0, 16))
			if band_i32(load_i32_u8(memory_at_0, loc_1 + 1), 3) == 0 then
				goto continue_at_5
			end
			FUNC_LIST[542](param_0, param_1, loc_1)
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			::continue_at_5::
			store_i32(memory_at_0, param_0 + 8, sub_i32(loc_0, 32))
			goto continue_at_0
		end
		FUNC_LIST[491](param_0, 6484, 0)
		error("out of code bounds")
		::continue_at_0::
	end
FUNC_LIST[448] = --[[ lua_rawseti(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
			        15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	::continue_at_1::
	param_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_1)
	if load_i32_u8(memory_at_0, loc_0 + 4) == 0 then
		loc_1 = load_i32(memory_at_0, param_0 + 8)
		reg_0 = FUNC_LIST[723](param_0, loc_0, param_2)
		param_2 = reg_0
		loc_0 = sub_i32(loc_1, 16)
		store_i64(memory_at_0, param_2, load_i64(memory_at_0, loc_0))
		store_i64(memory_at_0, param_2 + 8, load_i64(memory_at_0, loc_0 + 8))
		param_2 = load_i32(memory_at_0, param_0 + 8)
		if load_i32(memory_at_0, sub_i32(param_2, 4)) < 5 then goto continue_at_5 end
		param_1 = load_i32(memory_at_0, param_1)
		if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 4) == 0 then
			goto continue_at_5
		end
		loc_0 = load_i32(memory_at_0, sub_i32(param_2, 16))
		if band_i32(load_i32_u8(memory_at_0, loc_0 + 1), 3) == 0 then
			goto continue_at_5
		end
		FUNC_LIST[542](param_0, param_1, loc_0)
		param_2 = load_i32(memory_at_0, param_0 + 8)
		::continue_at_5::
		store_i32(memory_at_0, param_0 + 8, sub_i32(param_2, 16))
		goto continue_at_0
	end
	FUNC_LIST[491](param_0, 6484, 0)
	error("out of code bounds")
	::continue_at_0::
end
FUNC_LIST[449] = --[[ lua_setmetatable(lua_State*, int) ]] function(
	param_0, param_1
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	local br_map, temp = {}, nil
	if param_1 > 0 then
		param_1 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
			), 16
		)
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
		goto continue_at_1
	end
	if param_1 >= -9999 then
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		param_1 = add_i32(loc_0, shl_i32(param_1, 4))
		goto continue_at_1
	end
	reg_0 = FUNC_LIST[394](param_0, param_1)
	param_1 = reg_0
	loc_0 = load_i32(memory_at_0, param_0 + 8)
	::continue_at_1::
	if load_i32(memory_at_0, sub_i32(loc_0, 4)) ~= 0 then
		reg_0 = load_i32(memory_at_0, sub_i32(loc_0, 16))
	else
		reg_0 = 0
	end
	loc_0 = reg_0
	loc_1 = load_i32(memory_at_0, param_1 + 12)
	if not br_map[1] then br_map[1] = (function() return { [0] = 0, 2, 1 } end)() end
	temp = br_map[1][sub_i32(loc_1, 6)] or 2
	if temp < 1 then
		goto continue_at_10
	elseif temp > 1 then
		goto continue_at_8
	else
		goto continue_at_9
	end
	::continue_at_10::
	loc_1 = load_i32(memory_at_0, param_1)
	if load_i32_u8(memory_at_0, loc_1 + 4) ~= 0 then goto continue_at_6 end
	store_i32(memory_at_0, loc_1 + 16, loc_0)
	if loc_0 == 0 then goto continue_at_7 end
	param_1 = load_i32(memory_at_0, param_1)
	if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 4) == 0 then
		goto continue_at_7
	end
	if band_i32(load_i32_u8(memory_at_0, loc_0 + 1), 3) == 0 then
		goto continue_at_7
	end
	FUNC_LIST[541](param_0, param_1, loc_0)
	goto continue_at_7
	::continue_at_9::
	store_i32(memory_at_0, load_i32(memory_at_0, param_1) + 8, loc_0)
	if loc_0 == 0 then goto continue_at_7 end
	param_1 = load_i32(memory_at_0, param_1)
	if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 4) == 0 then
		goto continue_at_7
	end
	if band_i32(load_i32_u8(memory_at_0, loc_0 + 1), 3) == 0 then
		goto continue_at_7
	end
	FUNC_LIST[541](param_0, param_1, loc_0)
	goto continue_at_7
	::continue_at_8::
	store_i32(
		memory_at_0, add_i32(
			add_i32(load_i32(memory_at_0, param_0 + 16), shl_i32(loc_1, 2)), 1376
		), loc_0
	)
	::continue_at_7::
	store_i32(
		memory_at_0, param_0 + 8, sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
	)
	reg_0 = 1
	goto continue_at_0
	::continue_at_6::
	FUNC_LIST[491](param_0, 6484, 0)
	error("out of code bounds")
	::continue_at_0::
	return reg_0
end
FUNC_LIST[450] = --[[ lua_setfenv(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = 0
		local reg_0
		local br_map, temp = {}, nil
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			reg_0 = (lt_u32(param_1, load_i32(memory_at_0, param_0 + 8)) and param_1 or
				        15728)
			goto continue_at_5
		end
		if param_1 >= -9999 then
			reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_1, 4))
			goto continue_at_5
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		::continue_at_5::
		param_1 = reg_0
		if not br_map[1] then br_map[1] = (function() return { [0] = 0, 3, 1 } end)() end
		temp = br_map[1][sub_i32(load_i32(memory_at_0, param_1 + 12), 7)] or 3
		if temp < 1 then
			goto continue_at_4
		elseif temp > 1 then
			goto continue_at_1
		else
			goto continue_at_3
		end
		::continue_at_4::
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i32(
			memory_at_0, load_i32(memory_at_0, param_1) + 12,
				load_i32(memory_at_0, sub_i32(loc_0, 16))
		)
		goto continue_at_2
		::continue_at_3::
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		store_i32(
			memory_at_0, load_i32(memory_at_0, param_1) + 56,
				load_i32(memory_at_0, sub_i32(loc_0, 16))
		)
		::continue_at_2::
		loc_1 = 1
		param_1 = load_i32(memory_at_0, param_1)
		if band_i32(load_i32_u8(memory_at_0, param_1 + 1), 4) == 0 then
			goto continue_at_1
		end
		loc_0 = load_i32(memory_at_0, sub_i32(loc_0, 16))
		if band_i32(load_i32_u8(memory_at_0, loc_0 + 1), 3) == 0 then
			goto continue_at_1
		end
		FUNC_LIST[541](param_0, param_1, loc_0)
		::continue_at_1::
		store_i32(
			memory_at_0, param_0 + 8, sub_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
		reg_0 = loc_1
		return reg_0
	end
FUNC_LIST[451] = --[[ lua_call(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	FUNC_LIST[508](
		param_0, add_i32(
			load_i32(memory_at_0, param_0 + 8), shl_i32(bxor_i32(param_1, -1), 4)
		), param_2
	)
	if param_2 ~= -1 then goto continue_at_1 end
	param_2 = load_i32(memory_at_0, param_0 + 8)
	param_0 = load_i32(memory_at_0, param_0 + 20)
	if lt_u32(param_2, load_i32(memory_at_0, param_0 + 8)) then goto continue_at_1 end
	store_i32(memory_at_0, param_0 + 8, param_2)
	::continue_at_1::
end
FUNC_LIST[452] = --[[ lua_pcall(lua_State*, int, int, int) ]] function(
	param_0, param_1, param_2, param_3
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	if param_3 == 0 then
		loc_1 = load_i32(memory_at_0, param_0 + 28)
		reg_0 = 0
		goto continue_at_1
	end
	if param_3 > 0 then
		param_3 = sub_i32(
			add_i32(
				load_i32(memory_at_0, param_0 + 12), shl_i32(param_3, 4)
			), 16
		)
		reg_0 = (lt_u32(param_3, load_i32(memory_at_0, param_0 + 8)) and param_3 or
			        15728)
		goto continue_at_3
	end
	if ge_u32(param_3, -9999) then
		reg_0 = add_i32(load_i32(memory_at_0, param_0 + 8), shl_i32(param_3, 4))
		goto continue_at_3
	end
	reg_0 = FUNC_LIST[394](param_0, param_3)
	::continue_at_3::
	param_3 = reg_0
	loc_1 = load_i32(memory_at_0, param_0 + 28)
	reg_0 = sub_i32(param_3, loc_1)
	::continue_at_1::
	loc_2 = reg_0
	param_3 = load_i32(memory_at_0, param_0 + 8)
	store_i32(memory_at_0, loc_0 + 12, param_2)
	param_3 = add_i32(param_3, shl_i32(bxor_i32(param_1, -1), 4))
	store_i32(memory_at_0, loc_0 + 8, param_3)
	reg_0 = FUNC_LIST[516](
		param_0, 128, add_i32(loc_0, 8), sub_i32(param_3, loc_1), loc_2
	)
	param_3 = reg_0
	if param_2 ~= -1 then goto continue_at_6 end
	param_2 = load_i32(memory_at_0, param_0 + 8)
	param_0 = load_i32(memory_at_0, param_0 + 20)
	if lt_u32(param_2, load_i32(memory_at_0, param_0 + 8)) then goto continue_at_6 end
	store_i32(memory_at_0, param_0 + 8, param_2)
	::continue_at_6::
	GLOBAL_LIST[0].value = add_i32(loc_0, 16)
	reg_0 = param_3
	return reg_0
end
FUNC_LIST[453] = --[[ f_call(lua_State*, void*) ]]
	function(param_0, param_1)
		FUNC_LIST[508](
			param_0, load_i32(memory_at_0, param_1), load_i32(memory_at_0, param_1 + 4)
		)
	end
FUNC_LIST[454] = --[[ lua_gc(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local br_map, temp = {}, nil
	loc_0 = load_i32(memory_at_0, param_0 + 16)
	loc_1 = -1
	if not br_map[1] then
		br_map[1] = (function() return { [0] = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } end)()
	end
	temp = br_map[1][param_1] or 10
	if temp < 5 then
		if temp < 2 then
			if temp < 1 then
				goto continue_at_11
			else
				goto continue_at_10
			end
		elseif temp > 2 then
			if temp < 4 then
				goto continue_at_8
			else
				goto continue_at_7
			end
		else
			goto continue_at_9
		end
	elseif temp > 5 then
		if temp < 8 then
			if temp < 7 then
				goto continue_at_5
			else
				goto continue_at_4
			end
		elseif temp > 8 then
			if temp < 10 then
				goto continue_at_2
			else
				goto continue_at_1
			end
		else
			goto continue_at_3
		end
	else
		goto continue_at_6
	end
	::continue_at_11::
	store_i32(memory_at_0, loc_0 + 40, -1)
	reg_0 = 0
	goto continue_at_0
	::continue_at_10::
	store_i32(memory_at_0, loc_0 + 40, load_i32(memory_at_0, loc_0 + 44))
	reg_0 = 0
	goto continue_at_0
	::continue_at_9::
	FUNC_LIST[539](param_0)
	reg_0 = 0
	goto continue_at_0
	::continue_at_8::
	reg_0 = shr_u32(load_i32(memory_at_0, loc_0 + 44), 10)
	goto continue_at_0
	::continue_at_7::
	reg_0 = band_i32(load_i32(memory_at_0, loc_0 + 44), 1023)
	goto continue_at_0
	::continue_at_6::
	reg_0 = (load_i32(memory_at_0, loc_0 + 40) ~= -1 and 1 or 0)
	goto continue_at_0
	::continue_at_5::
	param_1 = shl_i32(param_2, 10)
	loc_2 = load_i32_u8(memory_at_0, loc_0 + 21)
	if loc_2 == 0 then
		param_2 = load_i32(memory_at_0, loc_0 + 44)
		reg_0 = 0
		goto continue_at_12
	end
	param_2 = load_i32(memory_at_0, loc_0 + 44)
	reg_0 = sub_i32(load_i32(memory_at_0, loc_0 + 40), param_2)
	::continue_at_12::
	loc_3 = reg_0
	loc_1 = 0
	param_1 = sub_i32(param_2, param_1)
	loc_4 = (gt_u32(param_1, param_2) and 0 or param_1)
	store_i32(memory_at_0, loc_0 + 40, loc_4)
	param_1 = 0
	if ge_u32(param_2, loc_4) then
		::continue_at_15::
		while true do
			reg_0 = FUNC_LIST[532](param_0, 0)
			param_2 = reg_0
			if load_i32_u8(memory_at_0, loc_0 + 21) == 0 then
				reg_0 = 1
				goto continue_at_0
			end
			param_1 = add_i32(param_1, param_2)
			param_2 = load_i32(memory_at_0, loc_0 + 44)
			if ge_u32(param_2, load_i32(memory_at_0, loc_0 + 40)) then
				goto continue_at_15
			end
			break
		end
		loc_2 = 1
	end
	if loc_2 == 0 then goto continue_at_1 end
	param_0 = add_i32(add_i32(param_1, loc_3), param_2)
	store_i32(memory_at_0, loc_0 + 40, (param_0 > 0 and param_0 or 0))
	reg_0 = 0
	goto continue_at_0
	::continue_at_4::
	param_0 = load_i32(memory_at_0, loc_0 + 48)
	store_i32(memory_at_0, loc_0 + 48, param_2)
	reg_0 = param_0
	goto continue_at_0
	::continue_at_3::
	param_0 = load_i32(memory_at_0, loc_0 + 52)
	store_i32(memory_at_0, loc_0 + 52, param_2)
	reg_0 = param_0
	goto continue_at_0
	::continue_at_2::
	param_0 = load_i32(memory_at_0, loc_0 + 56)
	store_i32(memory_at_0, loc_0 + 56, shl_i32(param_2, 10))
	loc_1 = shr_i32(param_0, 10)
	::continue_at_1::
	reg_0 = loc_1
	::continue_at_0::
	return reg_0
end
FUNC_LIST[455] = --[[ lua_error(lua_State*) ]] function(param_0)
	FUNC_LIST[502](param_0, 2)
	error("out of code bounds")
end
FUNC_LIST[456] = --[[ lua_next(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		if param_1 > 0 then
			param_1 = sub_i32(
				add_i32(
					load_i32(memory_at_0, param_0 + 12), shl_i32(param_1, 4)
				), 16
			)
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			param_1 = (lt_u32(param_1, loc_0) and param_1 or 15728)
			goto continue_at_2
		end
		if param_1 >= -9999 then
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			param_1 = add_i32(loc_0, shl_i32(param_1, 4))
			goto continue_at_2
		end
		reg_0 = FUNC_LIST[394](param_0, param_1)
		param_1 = reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		::continue_at_2::
		reg_0 = FUNC_LIST[708](
			param_0, load_i32(memory_at_0, param_1), sub_i32(loc_0, 16)
		)
		param_1 = reg_0
		store_i32(
			memory_at_0, param_0 + 8,
				add_i32(load_i32(memory_at_0, param_0 + 8), (param_1 ~= 0 and 16 or -16))
		)
		reg_0 = param_1
		return reg_0
	end
FUNC_LIST[457] = --[[ lua_concat(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		if param_1 >= 2 then
			loc_0 = load_i32(memory_at_0, param_0 + 16)
			if ge_u32(
				load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)
			) then reg_0 = FUNC_LIST[532](param_0, 1) end
			if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
				FUNC_LIST[546](param_0)
			end
			FUNC_LIST[844](
				param_0, param_1, sub_i32(
					shr_i32(
						sub_i32(
							load_i32(memory_at_0, param_0 + 8), load_i32(memory_at_0, param_0 + 12)
						), 4
					), 1
				)
			)
			store_i32(
				memory_at_0, param_0 + 8, add_i32(
					load_i32(memory_at_0, param_0 + 8), shl_i32(sub_i32(1, param_1), 4)
				)
			)
			goto continue_at_0
		end
		if param_1 == 0 then
			if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
				FUNC_LIST[546](param_0)
			end
			param_1 = load_i32(memory_at_0, param_0 + 8)
			reg_0 = FUNC_LIST[680](param_0, 10506, 0)
			loc_0 = reg_0
			store_i32(memory_at_0, param_1 + 12, 5)
			store_i32(memory_at_0, param_1, loc_0)
			store_i32(
				memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
			)
		end
		::continue_at_0::
	end
FUNC_LIST[458] = --[[ lua_newuserdatatagged(lua_State*, unsigned long, int) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		local reg_0
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		if ge_u32(load_i32(memory_at_0, loc_0 + 44), load_i32(memory_at_0, loc_0 + 40)) then
			reg_0 = FUNC_LIST[532](param_0, 1)
		end
		if band_i32(load_i32_u8(memory_at_0, param_0 + 5), 2) ~= 0 then
			FUNC_LIST[546](param_0)
		end
		reg_0 = FUNC_LIST[754](param_0, param_1, param_2)
		param_1 = reg_0
		param_2 = load_i32(memory_at_0, param_0 + 8)
		store_i32(memory_at_0, param_2 + 12, 8)
		store_i32(memory_at_0, param_2, param_1)
		store_i32(
			memory_at_0, param_0 + 8, add_i32(load_i32(memory_at_0, param_0 + 8), 16)
		)
		reg_0 = add_i32(param_1, 16)
		return reg_0
	end
FUNC_LIST[459] = --[[ lua_encodepointer(lua_State*, unsigned long) ]] function(
	param_0, param_1
)
	local loc_0 = 0LL
	local reg_0
	loc_0 = extend_i64_u32(param_1)
	param_0 = load_i32(memory_at_0, param_0 + 16)
	reg_0 = wrap_i32_i64(
		bxor_i64(
			((loc_0 * load_i64(memory_at_0, add_i32(param_0, 1592))) +
				load_i64(memory_at_0, add_i32(param_0, 1608))),
				(load_i64(memory_at_0, add_i32(param_0, 1600)) +
					(load_i64(memory_at_0, param_0 + 1584) * loc_0))
		)
	)
	return reg_0
end
FUNC_LIST[460] = --[[ luaL_argerrorL(lua_State*, int, char const*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local reg_0
	loc_1 = sub_i32(GLOBAL_LIST[0].value, 32)
	GLOBAL_LIST[0].value = loc_1
	loc_0 = load_i32(memory_at_0, param_0 + 20)
	if le_u32(loc_0, load_i32(memory_at_0, param_0 + 36)) then goto continue_at_1 end
	loc_0 = load_i32(memory_at_0, load_i32(memory_at_0, loc_0 + 4))
	if loc_0 == 0 then goto continue_at_1 end
	if load_i32_u8(memory_at_0, loc_0 + 3) == 0 then goto continue_at_1 end
	loc_0 = load_i32(memory_at_0, loc_0 + 24)
	if loc_0 == 0 then goto continue_at_1 end
	reg_0 = FUNC_LIST[1193](loc_0, 4369)
	if reg_0 == 0 then
		loc_0 = load_i32(memory_at_0, param_0 + 68)
		if loc_0 == 0 then goto continue_at_1 end
		loc_0 = add_i32(loc_0, 20)
	end
	store_i32(memory_at_0, loc_1 + 24, param_2)
	store_i32(memory_at_0, loc_1 + 20, loc_0)
	store_i32(memory_at_0, loc_1 + 16, param_1)
	FUNC_LIST[461](param_0, 8791, add_i32(loc_1, 16))
	error("out of code bounds")
	::continue_at_1::
	store_i32(memory_at_0, loc_1 + 4, param_2)
	store_i32(memory_at_0, loc_1, param_1)
	FUNC_LIST[461](param_0, 8765, loc_1)
	error("out of code bounds")
end
FUNC_LIST[461] = --[[ luaL_errorL(lua_State*, char const*, ...) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = loc_0
	store_i32(memory_at_0, loc_0 + 12, param_2)
	FUNC_LIST[462](param_0, 1)
	reg_0 = FUNC_LIST[429](param_0, param_1, load_i32(memory_at_0, loc_0 + 12))
	FUNC_LIST[457](param_0, 2)
	FUNC_LIST[455](param_0)
	error("out of code bounds")
end
FUNC_LIST[462] = --[[ luaL_where(lua_State*, int) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 304)
		GLOBAL_LIST[0].value = loc_0
		reg_0 = FUNC_LIST[489](param_0, param_1, 4359, add_i32(loc_0, 16))
		if reg_0 == 0 then goto continue_at_2 end
		param_1 = load_i32(memory_at_0, loc_0 + 32)
		if param_1 <= 0 then goto continue_at_2 end
		store_i32(memory_at_0, loc_0 + 4, param_1)
		store_i32(memory_at_0, loc_0, add_i32(loc_0, 39))
		reg_0 = FUNC_LIST[430](param_0, 10459, loc_0)
		goto continue_at_1
		::continue_at_2::
		FUNC_LIST[427](param_0, 10506, 0)
		::continue_at_1::
		GLOBAL_LIST[0].value = add_i32(loc_0, 304)
	end
FUNC_LIST[463] = --[[ luaL_typeerrorL(lua_State*, int, char const*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local loc_1 = 0
	local loc_2 = 0
	local reg_0
	loc_0 = add_i32(GLOBAL_LIST[0].value, -64)
	GLOBAL_LIST[0].value = loc_0
	loc_1 = load_i32(memory_at_0, param_0 + 20)
	if le_u32(loc_1, load_i32(memory_at_0, param_0 + 36)) then goto continue_at_1 end
	loc_1 = load_i32(memory_at_0, load_i32(memory_at_0, loc_1 + 4))
	if loc_1 == 0 then goto continue_at_1 end
	if load_i32_u8(memory_at_0, loc_1 + 3) == 0 then goto continue_at_1 end
	loc_1 = load_i32(memory_at_0, loc_1 + 24)
	if loc_1 == 0 then goto continue_at_1 end
	loc_2 = loc_1
	reg_0 = FUNC_LIST[1193](loc_1, 4369)
	if reg_0 ~= 0 then goto continue_at_1 end
	loc_2 = load_i32(memory_at_0, param_0 + 68)
	loc_2 = (loc_2 ~= 0 and add_i32(loc_2, 20) or 0)
	::continue_at_1::
	reg_0 = FUNC_LIST[393](param_0, param_1)
	loc_1 = reg_0
	if loc_1 ~= 0 then
		reg_0 = FUNC_LIST[753](param_0, loc_1)
		loc_1 = reg_0
		if loc_2 ~= 0 then goto continue_at_3 end
		store_i32(memory_at_0, loc_0 + 40, loc_1)
		store_i32(memory_at_0, loc_0 + 36, param_2)
		store_i32(memory_at_0, loc_0 + 32, param_1)
		FUNC_LIST[461](param_0, 8825, add_i32(loc_0, 32))
		error("out of code bounds")
	end
	if loc_2 ~= 0 then goto continue_at_2 end
	store_i32(memory_at_0, loc_0 + 4, param_2)
	store_i32(memory_at_0, loc_0, param_1)
	FUNC_LIST[461](param_0, 9188, loc_0)
	error("out of code bounds")
	::continue_at_3::
	store_i32(memory_at_0, loc_0 + 60, loc_1)
	store_i32(memory_at_0, loc_0 + 56, param_2)
	store_i32(memory_at_0, loc_0 + 52, loc_2)
	store_i32(memory_at_0, loc_0 + 48, param_1)
	FUNC_LIST[461](param_0, 8868, add_i32(loc_0, 48))
	error("out of code bounds")
	::continue_at_2::
	store_i32(memory_at_0, loc_0 + 24, param_2)
	store_i32(memory_at_0, loc_0 + 20, loc_2)
	store_i32(memory_at_0, loc_0 + 16, param_1)
	FUNC_LIST[461](param_0, 9223, add_i32(loc_0, 16))
	error("out of code bounds")
end
FUNC_LIST[464] = --[[ tag_error(lua_State*, int, int) ]] function(
	param_0, param_1, param_2
)
	local reg_0, reg_1, reg_2
	reg_2 = FUNC_LIST[408](param_0, param_2)
	FUNC_LIST[463](param_0, param_1, reg_2)
	error("out of code bounds")
end
FUNC_LIST[465] = --[[ luaL_optlstring(lua_State*, int, char const*, unsigned long*) ]]
	function(param_0, param_1, param_2, param_3)
		local reg_0, reg_1
		reg_0 = FUNC_LIST[407](param_0, param_1)
		if reg_0 <= 0 then
			if param_3 == 0 then goto continue_at_1 end
			reg_0 = param_3
			if param_2 ~= 0 then
				reg_1 = FUNC_LIST[1197](param_2)
			else
				reg_1 = 0
			end
			param_0 = reg_1
			store_i32(memory_at_0, reg_0, param_0)
			goto continue_at_1
		end
		reg_0 = FUNC_LIST[418](param_0, param_1, param_3)
		param_2 = reg_0
		if param_2 ~= 0 then goto continue_at_1 end
		FUNC_LIST[464](param_0, param_1, 5)
		error("out of code bounds")
		::continue_at_1::
		reg_0 = param_2
		return reg_0
	end
FUNC_LIST[466] = --[[ luaL_checklstring(lua_State*, int, unsigned long*) ]]
	function(param_0, param_1, param_2)
		local reg_0
		reg_0 = FUNC_LIST[418](param_0, param_1, param_2)
		param_2 = reg_0
		if param_2 == 0 then
			FUNC_LIST[464](param_0, param_1, 5)
			error("out of code bounds")
		end
		reg_0 = param_2
		return reg_0
	end
FUNC_LIST[467] = --[[ luaL_checkstack(lua_State*, int, char const*) ]] function(
	param_0, param_1, param_2
)
	local loc_0 = 0
	local reg_0
	loc_0 = sub_i32(GLOBAL_LIST[0].value, 16)
	GLOBAL_LIST[0].value = lo