Luau translated to Luau, as a Studio compatible script

luau_in_luau.lua

-- Roblox's Luau as a Luau script
-- Translated using https://github.com/Rerumu/Wasynth
local luau_script = [[
	print("Hello, World!")
]]

local Integer = (function()
	local Numeric = {}

	local NUM_ZERO, NUM_ONE, NUM_SIX_FOUR
	local NUM_BIT_26, NUM_BIT_52

	local bit_lshift = bit32.lshift
	local bit_rshift = bit32.rshift
	local bit_arshift = bit32.arshift

	local bit_and = bit32.band
	local bit_or = bit32.bor
	local bit_xor = bit32.bxor
	local bit_not = bit32.bnot

	local bit_extract = bit32.extract
	local bit_replace = bit32.replace

	local from_u32, from_u64, into_u64
	local num_subtract, num_divide_unsigned, num_negate
	local num_or, num_shift_left, num_shift_right_unsigned
	local num_is_negative, num_is_zero, num_is_less_unsigned

	-- X: a[0 ..21]
	-- Y: a[22..31]
	--  | b[0 ..11]
	-- Z: b[12..31]
	local constructor = Vector3.new

	function Numeric.from_u32(data_1, data_2)
		local x = bit_and(data_1, 0x3FFFFF)
		local y = bit_and(data_2, 0x3FFFFF)
		local z = bit_replace(bit_rshift(data_1, 22), bit_rshift(data_2, 22), 10, 10)

		return constructor(x, y, z)
	end

	local function load_d1(value)
		return bit_replace(bit_and(value.X, 0x3FFFFF), value.Z, 22, 10)
	end

	local function load_d2(value)
		return
			bit_replace(bit_and(value.Y, 0x3FFFFF), bit_rshift(value.Z, 10), 22, 10)
	end

	function Numeric.into_u32(value) return load_d1(value), load_d2(value) end

	function Numeric.from_u64(value)
		return from_u32(bit_and(value % 0x100000000), bit_and(value / 0x100000000))
	end

	function Numeric.into_u64(value)
		return load_d1(value) + load_d2(value) * 0x100000000
	end

	function Numeric.add(lhs, rhs)
		local data_1 = load_d1(lhs) + load_d1(rhs)
		local data_2 = load_d2(lhs) + load_d2(rhs)

		if data_1 >= 0x100000000 then
			data_1 = data_1 - 0x100000000
			data_2 = data_2 + 1
		end

		if data_2 >= 0x100000000 then data_2 = data_2 - 0x100000000 end

		return from_u32(data_1, data_2)
	end

	function Numeric.subtract(lhs, rhs)
		local data_1 = load_d1(lhs) - load_d1(rhs)
		local data_2 = load_d2(lhs) - load_d2(rhs)

		if data_1 < 0 then
			data_1 = data_1 + 0x100000000
			data_2 = data_2 - 1
		end

		if data_2 < 0 then data_2 = data_2 + 0x100000000 end

		return from_u32(data_1, data_2)
	end

	function Numeric.multiply(lhs, rhs)
		if num_is_zero(lhs) or num_is_zero(rhs) then
			return NUM_ZERO
		elseif num_is_less_unsigned(lhs, NUM_BIT_26) and
			num_is_less_unsigned(rhs, NUM_BIT_26) then
			return from_u64(load_d1(lhs) * load_d1(rhs))
		end

		-- Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
		-- We can skip products that would overflow.
		local lhs_1, lhs_2 = load_d1(lhs), load_d2(lhs)
		local rhs_1, rhs_2 = load_d1(rhs), load_d2(rhs)

		local a48 = bit_rshift(lhs_2, 16)
		local a32 = bit_and(lhs_2, 0xFFFF)
		local a16 = bit_rshift(lhs_1, 16)
		local a00 = bit_and(lhs_1, 0xFFFF)

		local b48 = bit_rshift(rhs_2, 16)
		local b32 = bit_and(rhs_2, 0xFFFF)
		local b16 = bit_rshift(rhs_1, 16)
		local b00 = bit_and(rhs_1, 0xFFFF)

		local c00 = a00 * b00
		local c16 = bit_rshift(c00, 16)

		c00 = bit_and(c00, 0xFFFF)
		c16 = c16 + a16 * b00

		local c32 = bit_rshift(c16, 16)

		c16 = bit_and(c16, 0xFFFF)
		c16 = c16 + a00 * b16
		c32 = c32 + bit_rshift(c16, 16)
		c16 = bit_and(c16, 0xFFFF)
		c32 = c32 + a32 * b00

		local c48 = bit_rshift(c32, 16)

		c32 = bit_and(c32, 0xFFFF)
		c32 = c32 + a16 * b16
		c48 = c48 + bit_rshift(c32, 16)
		c32 = bit_and(c32, 0xFFFF)
		c32 = c32 + a00 * b32
		c48 = c48 + bit_rshift(c32, 16)
		c32 = bit_and(c32, 0xFFFF)
		c48 = c48 + a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48
		c48 = bit_and(c48, 0xFFFF)

		local data_1 = bit_replace(c00, c16, 16, 16)
		local data_2 = bit_replace(c32, c48, 16, 16)

		return from_u32(data_1, data_2)
	end

	function Numeric.divide_unsigned(lhs, rhs)
		if num_is_zero(rhs) then
			error("division by zero")
		elseif num_is_zero(lhs) then
			return NUM_ZERO, NUM_ZERO
		elseif num_is_less_unsigned(lhs, NUM_BIT_52) and
			num_is_less_unsigned(rhs, NUM_BIT_52) then
			local lhs_u = into_u64(lhs)
			local rhs_u = into_u64(rhs)

			return from_u64(lhs_u / rhs_u), from_u64(lhs_u % rhs_u)
		end

		local quotient = NUM_ZERO
		local remainder = NUM_ZERO

		local num_1, num_2 = load_d1(lhs), load_d2(lhs)

		for i = 63, 0, -1 do
			local temp = num_shift_left(remainder, NUM_ONE)
			local rem_1, rem_2 = load_d1(temp), load_d2(temp)

			if i > 31 then
				rem_1 = bit_or(rem_1, bit_extract(num_2, i - 32, 1))
			else
				rem_1 = bit_or(rem_1, bit_extract(num_1, i, 1))
			end

			remainder = from_u32(rem_1, rem_2)

			if not num_is_less_unsigned(remainder, rhs) then
				remainder = num_subtract(remainder, rhs)
				quotient = num_or(quotient, num_shift_left(NUM_ONE, from_u32(i, 0)))
			end
		end

		return quotient, remainder
	end

	function Numeric.divide_signed(lhs, rhs)
		local left_negative = num_is_negative(lhs)
		local right_negative = num_is_negative(rhs)

		if left_negative then lhs = num_negate(lhs) end

		if right_negative then rhs = num_negate(rhs) end

		local quotient, remainder = num_divide_unsigned(lhs, rhs)

		if left_negative ~= right_negative then quotient = num_negate(quotient) end

		if left_negative then remainder = num_negate(remainder) end

		return quotient, remainder
	end

	function Numeric.negate(value)
		local data_1 = bit_not(load_d1(value)) + 1
		local data_2 = bit_not(load_d2(value))

		if data_1 >= 0x100000000 then
			data_1 = data_1 - 0x100000000
			data_2 = data_2 + 1
		end

		if data_2 >= 0x100000000 then data_2 = data_2 - 0x100000000 end

		return from_u32(data_1, data_2)
	end

	function Numeric.bit_and(lhs, rhs)
		local x = bit_and(lhs.X, rhs.X)
		local y = bit_and(lhs.Y, rhs.Y)
		local z = bit_and(lhs.Z, rhs.Z)

		return constructor(x, y, z)
	end

	function Numeric.bit_not(value)
		local x = bit_and(bit_not(value.X), 0xFFFFFF)
		local y = bit_and(bit_not(value.Y), 0xFFFFFF)
		local z = bit_and(bit_not(value.Z), 0xFFFFFF)

		return constructor(x, y, z)
	end

	function Numeric.bit_or(lhs, rhs)
		local x = bit_or(lhs.X, rhs.X)
		local y = bit_or(lhs.Y, rhs.Y)
		local z = bit_or(lhs.Z, rhs.Z)

		return constructor(x, y, z)
	end

	function Numeric.bit_xor(lhs, rhs)
		local x = bit_xor(lhs.X, rhs.X)
		local y = bit_xor(lhs.Y, rhs.Y)
		local z = bit_xor(lhs.Z, rhs.Z)

		return constructor(x, y, z)
	end

	function Numeric.shift_left(lhs, rhs)
		local count = rhs.X % 64

		if count == 0 then
			return lhs
		elseif count < 32 then
			local pad = 32 - count
			local lhs_1, lhs_2 = load_d1(lhs), load_d2(lhs)

			local data_1 = bit_lshift(lhs_1, count)
			local data_2 = bit_replace(bit_rshift(lhs_1, pad), lhs_2, count, pad)

			return from_u32(data_1, data_2)
		else
			local lhs_1 = load_d1(lhs)

			return from_u32(0, bit_lshift(lhs_1, count - 32))
		end
	end

	function Numeric.shift_right_unsigned(lhs, rhs)
		local count = rhs.X % 64

		if count == 0 then
			return lhs
		elseif count < 32 then
			local lhs_1, lhs_2 = load_d1(lhs), load_d2(lhs)

			local data_1 =
				bit_replace(bit_rshift(lhs_1, count), lhs_2, 32 - count, count)
			local data_2 = bit_rshift(lhs_2, count)

			return from_u32(data_1, data_2)
		else
			local lhs_2 = load_d2(lhs)

			return from_u32(bit_rshift(lhs_2, count - 32), 0)
		end
	end

	function Numeric.shift_right_signed(lhs, rhs)
		local count = rhs.X % 64

		if count == 0 then
			return lhs
		elseif count < 32 then
			local lhs_1, lhs_2 = load_d1(lhs), load_d2(lhs)

			local data_1 =
				bit_replace(bit_rshift(lhs_1, count), lhs_2, 32 - count, count)
			local data_2 = bit_arshift(lhs_2, count)

			return from_u32(data_1, data_2)
		else
			local lhs_2 = load_d2(lhs)

			local data_1 = bit_arshift(lhs_2, count - 32)
			local data_2 = lhs_2 >= 0x80000000 and 0xFFFFFFFF or 0

			return from_u32(data_1, data_2)
		end
	end

	function Numeric.rotate_left(lhs, rhs)
		if num_is_zero(rhs) then
			return lhs
		else
			local data_1 = num_shift_left(lhs, rhs)
			local data_2 = num_shift_right_unsigned(lhs, num_subtract(NUM_SIX_FOUR, rhs))

			return num_or(data_1, data_2)
		end
	end

	function Numeric.rotate_right(lhs, rhs)
		if num_is_zero(rhs) then
			return lhs
		else
			local data_1 = num_shift_right_unsigned(lhs, rhs)
			local data_2 = num_shift_left(lhs, num_subtract(NUM_SIX_FOUR, rhs))

			return num_or(data_1, data_2)
		end
	end

	function Numeric.is_negative(value) return value.Z >= 0x80000 end

	function Numeric.is_zero(value)
		return value.X == 0 and value.Y == 0 and value.Z == 0
	end

	function Numeric.is_equal(lhs, rhs)
		return lhs.X == rhs.X and lhs.Y == rhs.Y and lhs.Z == rhs.Z
	end

	function Numeric.is_less_unsigned(lhs, rhs)
		local data_l_2 = load_d2(lhs)
		local data_r_2 = load_d2(rhs)

		return data_l_2 < data_r_2 or
			       (data_l_2 == data_r_2 and load_d1(lhs) < load_d1(rhs))
	end

	function Numeric.is_greater_unsigned(lhs, rhs)
		local data_l_2 = load_d2(lhs)
		local data_r_2 = load_d2(rhs)

		return data_l_2 > data_r_2 or
			       (data_l_2 == data_r_2 and load_d1(lhs) > load_d1(rhs))
	end

	function Numeric.is_less_signed(lhs, rhs)
		local neg_a = num_is_negative(lhs)
		local neg_b = num_is_negative(rhs)

		if neg_a and not neg_b then
			return true
		elseif not neg_a and neg_b then
			return false
		else
			return num_is_negative(num_subtract(lhs, rhs))
		end
	end

	function Numeric.is_greater_signed(lhs, rhs)
		local neg_a = num_is_negative(lhs)
		local neg_b = num_is_negative(rhs)

		if neg_a and not neg_b then
			return false
		elseif not neg_a and neg_b then
			return true
		else
			return num_is_negative(num_subtract(rhs, lhs))
		end
	end

	from_u32 = Numeric.from_u32
	from_u64 = Numeric.from_u64
	into_u64 = Numeric.into_u64

	num_subtract = Numeric.subtract
	num_divide_unsigned = Numeric.divide_unsigned
	num_negate = Numeric.negate

	num_or = Numeric.bit_or
	num_shift_left = Numeric.shift_left
	num_shift_right_unsigned = Numeric.shift_right_unsigned

	num_is_negative = Numeric.is_negative
	num_is_zero = Numeric.is_zero
	num_is_less_unsigned = Numeric.is_less_unsigned

	NUM_ZERO = from_u64(0)
	NUM_ONE = from_u64(1)
	NUM_SIX_FOUR = from_u64(64)
	NUM_BIT_26 = from_u64(0x4000000)
	NUM_BIT_52 = from_u64(0x10000000000000)

	Numeric.ZERO = NUM_ZERO
	Numeric.ONE = NUM_ONE

	return table.freeze(Numeric)
end)()
local rt = (function()
	local module = {}

	local to_u32 = bit32.band

	local bit_or = bit32.bor
	local bit_and = bit32.band
	local bit_lshift = bit32.lshift
	local bit_rshift = bit32.rshift

	local num_from_u32 = Integer.from_u32
	local num_into_u32 = Integer.into_u32

	local function to_i32(num)
		if num >= 0x80000000 then
			return num - 0x100000000
		else
			return num
		end
	end

	local function no_op(num) return num end

	module.i64 = Integer

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

		local assert = assert

		local math_abs = math.abs
		local math_fmod = math.fmod
		local math_round = math.round
		local math_sign = math.sign
		local math_min = math.min
		local math_max = math.max

		local string_byte = string.byte
		local string_pack = string.pack

		local num_divide_signed = Integer.divide_signed
		local num_divide_unsigned = Integer.divide_unsigned

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

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

		function mul.i32(lhs, rhs)
			if (lhs + rhs) < 0x8000000 then
				return to_u32(lhs * rhs)
			else
				local a16 = bit_rshift(lhs, 16)
				local a00 = bit_and(lhs, 0xFFFF)
				local b16 = bit_rshift(rhs, 16)
				local b00 = bit_and(rhs, 0xFFFF)

				local c00 = a00 * b00
				local c16 = a16 * b00 + a00 * b16

				return to_u32(c00 + bit_lshift(c16, 16))
			end
		end

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

			lhs = to_i32(lhs)
			rhs = to_i32(rhs)

			return to_u32(lhs / rhs)
		end

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

			return to_u32(lhs / rhs)
		end

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

			lhs = to_i32(lhs)
			rhs = to_i32(rhs)

			return to_u32(math_fmod(lhs, rhs))
		end

		add.i64 = Integer.add
		sub.i64 = Integer.subtract
		mul.i64 = Integer.multiply
		div.i64 = num_divide_signed

		function rem.i64(lhs, rhs)
			local _, remainder = num_divide_signed(lhs, rhs)

			return remainder
		end

		div.u64 = num_divide_unsigned

		function rem.u64(lhs, rhs)
			local _, remainder = num_divide_unsigned(lhs, rhs)

			return remainder
		end

		function neg.f32(num) return -num end

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

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

		function copysign.f32(lhs, rhs)
			local packed = string_pack("<d", rhs)
			local sign = string_byte(packed, 8)

			if sign >= 0x80 then
				return -math_abs(lhs)
			else
				return math_abs(lhs)
			end
		end

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

			if (math_abs(num) + 0.5) % 2 == 1 then result = result - math_sign(result) 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.neg = neg
		module.min = min
		module.max = max
		module.copysign = copysign
		module.nearest = nearest
	end

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

		local bit_countlz = bit32.countlz
		local bit_countrz = bit32.countrz

		local function popcnt_i32(num)
			local count = 0

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

			return count
		end

		popcnt.i32 = popcnt_i32

		function clz.i64(num)
			local data_1, data_2 = num_into_u32(num)
			local temp

			if data_2 == 0 then
				temp = bit_countlz(data_1) + 32
			else
				temp = bit_countlz(data_2)
			end

			return num_from_u32(temp, 0)
		end

		function ctz.i64(num)
			local data_1, data_2 = num_into_u32(num)
			local temp

			if data_1 == 0 then
				temp = bit_countrz(data_2) + 32
			else
				temp = bit_countrz(data_1)
			end

			return num_from_u32(temp, 0)
		end

		function popcnt.i64(num)
			local data_1, data_2 = num_into_u32(num)
			local temp = popcnt_i32(data_1) + popcnt_i32(data_2)

			return num_from_u32(temp, 0)
		end

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

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

		local num_is_equal = Integer.is_equal
		local num_is_less_signed = Integer.is_less_signed
		local num_is_less_unsigned = Integer.is_less_unsigned
		local num_is_greater_signed = Integer.is_greater_signed
		local num_is_greater_unsigned = Integer.is_greater_unsigned

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

		function lt.i32(lhs, rhs) return to_i32(lhs) < to_i32(rhs) end

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

		function gt.i32(lhs, rhs) return to_i32(lhs) > to_i32(rhs) end

		eq.i64 = num_is_equal

		function ne.i64(lhs, rhs) return not num_is_equal(lhs, rhs) end

		function le.i64(lhs, rhs)
			return num_is_less_signed(lhs, rhs) or num_is_equal(lhs, rhs)
		end

		function le.u64(lhs, rhs)
			return num_is_less_unsigned(lhs, rhs) or num_is_equal(lhs, rhs)
		end

		lt.i64 = num_is_less_signed
		lt.u64 = num_is_less_unsigned

		function ge.i64(lhs, rhs)
			return num_is_greater_signed(lhs, rhs) or num_is_equal(lhs, rhs)
		end

		function ge.u64(lhs, rhs)
			return num_is_greater_unsigned(lhs, rhs) or num_is_equal(lhs, rhs)
		end

		gt.i64 = num_is_greater_signed
		gt.u64 = num_is_greater_unsigned

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

	do
		local band = {}
		local bor = {}
		local bxor = {}
		local bnot = {}

		band.i64 = Integer.bit_and
		bor.i64 = Integer.bit_or
		bxor.i64 = Integer.bit_xor
		bnot.i64 = Integer.bit_not

		module.band = band
		module.bor = bor
		module.bxor = bxor
		module.bnot = bnot
	end

	do
		local shl = {}
		local shr = {}
		local rotl = {}
		local rotr = {}

		local bit_arshift = bit32.arshift
		local bit_lrotate = bit32.lrotate
		local bit_rrotate = bit32.rrotate

		function shl.i32(lhs, rhs) return bit_lshift(lhs, rhs % 32) end

		function shr.u32(lhs, rhs) return bit_rshift(lhs, rhs % 32) end

		function shr.i32(lhs, rhs) return bit_arshift(lhs, rhs % 32) end

		function rotl.i32(lhs, rhs) return bit_lrotate(lhs, rhs % 32) end

		function rotr.i32(lhs, rhs) return bit_rrotate(lhs, rhs % 32) end

		shl.i64 = Integer.shift_left
		shr.i64 = Integer.shift_right_signed
		shr.u64 = Integer.shift_right_unsigned
		rotl.i64 = Integer.rotate_left
		rotr.i64 = Integer.rotate_right

		module.shl = shl
		module.shr = shr
		module.rotl = rotl
		module.rotr = rotr
	end

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

		local math_ceil = math.ceil
		local math_floor = math.floor
		local math_clamp = math.clamp

		local string_pack = string.pack
		local string_unpack = string.unpack

		local NUM_ZERO = Integer.ZERO
		local NUM_MIN_I64 = num_from_u32(0, 0x80000000)
		local NUM_MAX_I64 = num_from_u32(0xFFFFFFFF, 0x7FFFFFFF)
		local NUM_MAX_U64 = num_from_u32(0xFFFFFFFF, 0xFFFFFFFF)

		local num_from_u64 = Integer.from_u64
		local num_into_u64 = Integer.into_u64

		local num_negate = Integer.negate
		local num_is_negative = Integer.is_negative

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

		function wrap.i32_i64(num)
			local data_1, _ = num_into_u32(num)

			return data_1
		end

		function truncate.i32_f32(num) return to_u32(truncate_f64(num)) end

		truncate.i32_f64 = to_u32
		truncate.u32_f32 = truncate_f64
		truncate.u32_f64 = truncate_f64

		function truncate.i64_f32(num)
			if num < 0 then
				local temp = num_from_u64(-num)

				return num_negate(temp)
			else
				return num_from_u64(num)
			end
		end

		truncate.i64_f64 = truncate.i64_f32

		function truncate.u64_f32(num)
			if num <= 0 then
				return NUM_ZERO
			else
				return num_from_u64(math_floor(num))
			end
		end

		truncate.u64_f64 = truncate.u64_f32

		truncate.f32 = truncate_f64
		truncate.f64 = truncate_f64

		function saturate.i32_f32(num)
			local temp = math_clamp(truncate_f64(num), -0x80000000, 0x7FFFFFFF)

			return to_u32(temp)
		end

		saturate.i32_f64 = saturate.i32_f32

		function saturate.u32_f32(num)
			local temp = math_clamp(truncate_f64(num), 0, 0xFFFFFFFF)

			return to_u32(temp)
		end

		saturate.u32_f64 = saturate.u32_f32

		local truncate_i64_f64 = truncate.i64_f64

		function saturate.i64_f32(num)
			if num >= 2 ^ 63 - 1 then
				return NUM_MAX_I64
			elseif num <= -2 ^ 63 then
				return NUM_MIN_I64
			else
				return truncate_i64_f64(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 then
				return NUM_ZERO
			else
				return truncate_i64_f64(num)
			end
		end

		saturate.u64_f64 = saturate.u64_f32

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

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

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

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

		function extend.i64_n8(num)
			local data_1, _ = num_into_u32(num)

			data_1 = bit_and(data_1, 0xFF)

			if data_1 >= 0x80 then
				local temp = num_from_u32(-data_1 + 0x100, 0)

				return num_negate(temp)
			else
				return num_from_u32(data_1, 0)
			end
		end

		function extend.i64_n16(num)
			local data_1, _ = num_into_u32(num)

			data_1 = bit_and(data_1, 0xFFFF)

			if data_1 >= 0x8000 then
				local temp = num_from_u32(-data_1 + 0x10000, 0)

				return num_negate(temp)
			else
				return num_from_u32(data_1, 0)
			end
		end

		function extend.i64_n32(num)
			local data_1, _ = num_into_u32(num)

			if data_1 >= 0x80000000 then
				local temp = num_from_u32(-data_1 + 0x100000000, 0)

				return num_negate(temp)
			else
				return num_from_u32(data_1, 0)
			end
		end

		function extend.i64_i32(num)
			if num >= 0x80000000 then
				local temp = num_from_u32(-num + 0x100000000, 0)

				return num_negate(temp)
			else
				return num_from_u32(num, 0)
			end
		end

		function extend.i64_u32(num) return num_from_u32(num, 0) end

		convert.f32_i32 = to_i32
		convert.f32_u32 = no_op

		function convert.f32_i64(num)
			if num_is_negative(num) then
				local temp = num_negate(num)

				return -num_into_u64(temp)
			else
				return num_into_u64(num)
			end
		end

		convert.f32_u64 = num_into_u64
		convert.f64_i32 = to_i32
		convert.f64_u32 = no_op
		convert.f64_i64 = convert.f32_i64
		convert.f64_u64 = num_into_u64

		demote.f32_f64 = no_op

		promote.f64_f32 = no_op

		function reinterpret.i32_f32(num)
			local packed = string_pack("f", num)

			return string_unpack("I4", packed)
		end

		function reinterpret.i64_f64(num)
			local packed = string_pack("d", num)
			local data_1, data_2 = string_unpack("I4I4", packed)

			return num_from_u32(data_1, data_2)
		end

		function reinterpret.f32_i32(num)
			local packed = string_pack("I4", num)

			return string_unpack("f", packed)
		end

		function reinterpret.f64_i64(num)
			local data_1, data_2 = num_into_u32(num)
			local packed = string_pack("I4I4", data_1, data_2)

			return string_unpack("d", packed)
		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 = {}

		local bit_extract = bit32.extract
		local bit_replace = bit32.replace

		local math_floor = math.floor

		local string_byte = string.byte
		local string_unpack = string.unpack

		local reinterpret_f32_i32 = module.reinterpret.f32_i32
		local reinterpret_f64_i64 = module.reinterpret.f64_i64
		local reinterpret_i32_f32 = module.reinterpret.i32_f32
		local reinterpret_i64_f64 = module.reinterpret.i64_f64

		local function load_byte(data, addr)
			local value = data[math_floor(addr / 4)] or 0

			return bit_extract(value, addr % 4 * 8, 8)
		end

		local function store_byte(data, addr, value)
			local adjust = math_floor(addr / 4)

			data[adjust] = bit_replace(data[adjust] or 0, value, addr % 4 * 8, 8)
		end

		function load.i32_i8(memory, addr)
			local temp = load_byte(memory.data, addr)

			if temp >= 0x80 then
				return to_u32(temp - 0x100)
			else
				return temp
			end
		end

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

		function load.i32_i16(memory, addr)
			local data = memory.data
			local temp

			if addr % 4 == 0 then
				temp = bit_and(data[addr / 4] or 0, 0xFFFF)
			else
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)

				temp = bit_or(b1, b2)
			end

			if temp >= 0x8000 then
				return to_u32(temp - 0x10000)
			else
				return temp
			end
		end

		function load.i32_u16(memory, addr)
			local data = memory.data

			if addr % 4 == 0 then
				return bit_and(data[addr / 4] or 0, 0xFFFF)
			else
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)

				return bit_or(b1, b2)
			end
		end

		function load.i32(memory, addr)
			local data = memory.data

			if addr % 4 == 0 then
				-- aligned read
				return data[addr / 4] or 0
			else
				-- unaligned read
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)
				local b3 = bit_lshift(load_byte(data, addr + 2), 16)
				local b4 = bit_lshift(load_byte(data, addr + 3), 24)

				return bit_or(b1, b2, b3, b4)
			end
		end

		function load.i64_i8(memory, addr)
			local data_1 = load_byte(memory.data, addr)
			local data_2

			if data_1 >= 0x80 then
				data_1 = to_u32(data_1 - 0x100)
				data_2 = 0xFFFFFFFF
			else
				data_2 = 0
			end

			return num_from_u32(data_1, data_2)
		end

		function load.i64_u8(memory, addr)
			local temp = load_byte(memory.data, addr)

			return num_from_u32(temp, 0)
		end

		function load.i64_i16(memory, addr)
			local data = memory.data
			local data_1, data_2

			if addr % 4 == 0 then
				data_1 = bit_and(data[addr / 4] or 0, 0xFFFF)
			else
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)

				data_1 = bit_or(b1, b2)
			end

			if data_1 >= 0x8000 then
				data_1 = to_u32(data_1 - 0x10000)
				data_2 = 0xFFFFFFFF
			else
				data_2 = 0
			end

			return num_from_u32(data_1, data_2)
		end

		function load.i64_u16(memory, addr)
			local data = memory.data
			local temp

			if addr % 4 == 0 then
				temp = bit_and(data[addr / 4] or 0, 0xFFFF)
			else
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)

				temp = bit_or(b1, b2)
			end

			return num_from_u32(temp, 0)
		end

		function load.i64_i32(memory, addr)
			local data = memory.data
			local data_1, data_2

			if addr % 4 == 0 then
				data_1 = data[addr / 4] or 0
			else
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)
				local b3 = bit_lshift(load_byte(data, addr + 2), 16)
				local b4 = bit_lshift(load_byte(data, addr + 3), 24)

				data_1 = bit_or(b1, b2, b3, b4)
			end

			if data_1 >= 0x80000000 then
				data_1 = to_u32(data_1 - 0x100000000)
				data_2 = 0xFFFFFFFF
			else
				data_2 = 0
			end

			return num_from_u32(data_1, data_2)
		end

		function load.i64_u32(memory, addr)
			local data = memory.data
			local temp

			if addr % 4 == 0 then
				temp = data[addr / 4] or 0
			else
				local b1 = load_byte(data, addr)
				local b2 = bit_lshift(load_byte(data, addr + 1), 8)
				local b3 = bit_lshift(load_byte(data, addr + 2), 16)
				local b4 = bit_lshift(load_byte(data, addr + 3), 24)

				temp = bit_or(b1, b2, b3, b4)
			end

			return num_from_u32(temp, 0)
		end

		local load_i32 = load.i32

		function load.i64(memory, addr)
			local data_1 = load_i32(memory, addr)
			local data_2 = load_i32(memory, addr + 4)

			return num_from_u32(data_1, data_2)
		end

		local load_i64 = load.i64

		function load.f32(memory, addr)
			local raw = load_i32(memory, addr)

			return reinterpret_f32_i32(raw)
		end

		function load.f64(memory, addr)
			local raw = load_i64(memory, addr)

			return reinterpret_f64_i64(raw)
		end

		function load.string(memory, addr, len)
			local buffer = table.create(len)

			for i = 1, len do
				local raw = load_byte(memory.data, addr + i - 1)

				buffer[i] = string.char(raw)
			end

			return table.concat(buffer)
		end

		function store.i32_n8(memory, addr, value)
			store_byte(memory.data, addr, value)
		end

		local store_i8 = store.i32_n8

		function store.i32_n16(memory, addr, value)
			store_byte(memory.data, addr, value)
			store_byte(memory.data, addr + 1, bit_rshift(value, 8))
		end

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

			if addr % 4 == 0 then
				-- aligned write
				data[addr / 4] = value
			else
				-- unaligned write
				store_byte(data, addr, value)
				store_byte(data, addr + 1, bit_rshift(value, 8))
				store_byte(data, addr + 2, bit_rshift(value, 16))
				store_byte(data, addr + 3, bit_rshift(value, 24))
			end
		end

		local store_i32 = store.i32
		local store_i32_n8 = store.i32_n8
		local store_i32_n16 = store.i32_n16

		function store.i64_n8(memory, addr, value)
			local data_1, _ = num_into_u32(value)

			store_i32_n8(memory, addr, data_1)
		end

		function store.i64_n16(memory, addr, value)
			local data_1, _ = num_into_u32(value)

			store_i32_n16(memory, addr, data_1)
		end

		function store.i64_n32(memory, addr, value)
			local data_1, _ = num_into_u32(value)

			store_i32(memory, addr, data_1)
		end

		function store.i64(memory, addr, value)
			local data_1, data_2 = num_into_u32(value)

			store_i32(memory, addr, data_1)
			store_i32(memory, addr + 4, data_2)
		end

		local store_i64 = store.i64

		function store.f32(memory, addr, value)
			store_i32(memory, addr, reinterpret_i32_f32(value))
		end

		function store.f64(memory, addr, value)
			store_i64(memory, addr, reinterpret_i64_f64(value))
		end

		function store.string(memory, addr, data, len)
			len = len or #data

			local rem = len % 4

			for i = 1, len - rem, 4 do
				local v = string_unpack("<I4", data, i)

				store_i32(memory, addr + i - 1, v)
			end

			for i = len - rem + 1, len do
				local v = string_byte(data, i)

				store_i8(memory, addr + i - 1, v)
			end
		end

		function allocator.new(min, max) return { min = min, max = max, data = {} } end

		function allocator.grow(memory, num)
			local old = memory.min
			local new = old + num

			if new > memory.max then
				return to_u32(-1)
			else
				memory.min = new

				return old
			end
		end

		function allocator.copy(memory, destination, source, size)
			for i = 1, size do
				store_byte(memory.data, destination + i - 1, load_byte(memory.data, source + i - 1))
			end
		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 add_i64 = rt.add.i64
local band_i32 = bit32.band
local band_i64 = rt.band.i64
local bor_i32 = bit32.bor
local bor_i64 = rt.bor.i64
local bxor_i32 = bit32.bxor
local bxor_i64 = rt.bxor.i64
local ceil_f64 = math.ceil
local clz_i32 = bit32.countlz
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 = rt.convert.f64_i64
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 = bit32.countrz
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 eq_i64 = rt.eq.i64
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_i32 = rt.ge.i32
local ge_i64 = rt.ge.i64
local ge_u64 = rt.ge.u64
local gt_i32 = rt.gt.i32
local gt_i64 = rt.gt.i64
local gt_u64 = rt.gt.u64
local i64_ONE = rt.i64.ONE
local i64_ZERO = rt.i64.ZERO
local i64_from_u32 = rt.i64.from_u32
local le_i32 = rt.le.i32
local le_i64 = rt.le.i64
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_i32 = rt.lt.i32
local lt_i64 = rt.lt.i64
local lt_u64 = rt.lt.u64
local mul_i32 = rt.mul.i32
local mul_i64 = rt.mul.i64
local ne_i64 = rt.ne.i64
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 = rt.rem.i32
local rotl_i32 = rt.rotl.i32
local rotl_i64 = rt.rotl.i64
local rotr_i32 = rt.rotr.i32
local shl_i32 = rt.shl.i32
local shl_i64 = rt.shl.i64
local shr_i32 = rt.shr.i32
local shr_i64 = rt.shr.i64
local shr_u32 = rt.shr.u32
local shr_u64 = rt.shr.u64
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 sub_i64 = rt.sub.i64
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 FUNC_LIST = table.create(1436)
local TABLE_LIST = table.create(0)
local MEMORY_LIST = table.create(0)
local GLOBAL_LIST = table.create(0)
FUNC_LIST[35] = --[[ __wasm_call_ctors ]] function()
	while true do
		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]()
		break
	end
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
	local desired
	while true do
		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
			while true do
				while true do
					reg_0 = FUNC_LIST[1199](load_i32(memory_at_0, loc_3 + 4), 1535, 4)
					if reg_0 == 0 then
						while true do
							store_i32_n8(memory_at_0, loc_3, 1)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					loc_3 = load_i32(memory_at_0, loc_3 + 8)
					if loc_3 ~= 0 then continue end
					break
				end
				if desired then break end
				break
			end
			if desired then
				if desired == 0 then desired = nil 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)
		while true do
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										while true do
											while true do
												if loc_0 == 1 then break 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 break 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 break end
												if load_i32_u8(memory_at_0, 54896) == 0 then
													while true do
														store_i64(memory_at_0, 54884, i64_ZERO)
														store_i32(memory_at_0, 54892, 0)
														reg_0 = FUNC_LIST[1102](4, 0, 1024)
														store_i32_n8(memory_at_0, 54896, 1)
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1197](param_0)
												loc_0 = reg_0
												if loc_0 >= 4294967280 then
													while true do
														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
															desired = 9
															break
														end
														desired = 1
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
												end
												while true do
													while true do
														if loc_0 >= 11 then
															while true do
																store_i32(memory_at_0, 61960, 0)
																loc_5 = band_i32(add_i32(loc_0, 16), 4294967280)
																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
																	desired = 9
																	break
																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))
																desired = 12
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
														end
														store_i32_n8(memory_at_0, loc_1 + 11, loc_0)
														loc_2 = loc_1
														if loc_0 == 0 then
															desired = 11
															break
														end
														break
													end
													if desired then
														if desired == 11 then desired = nil end
														break
													end
													reg_0 = FUNC_LIST[1119](loc_2, param_0, loc_0)
													break
												end
												if desired then
													if desired == 10 then desired = nil end
													break
												end
												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 = (lt_i32(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
													desired = 4
													break
												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
													desired = 4
													break
												end
												FUNC_LIST[1252](loc_0)
												if param_0 ~= 0 then
													while true do
														store_i32(memory_at_0, 61960, 0)
														reg_0 = FUNC_LIST[4](9, loc_3, 4294967295, 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
															desired = 4
															break
														end
														loc_0 = load_i32(memory_at_0, loc_1 + 48)
														if loc_0 >= 4294967280 then
															while true do
																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
																	desired = 1
																	break
																end
																desired = 4
																break
															end
															if desired then break end
														end
														while true do
															while true do
																if loc_0 >= 11 then
																	while true do
																		store_i32(memory_at_0, 61960, 0)
																		loc_5 = band_i32(add_i32(loc_0, 16), 4294967280)
																		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
																			desired = 4
																			break
																		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))
																		desired = 13
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																end
																store_i32_n8(memory_at_0, loc_1 + 27, loc_0)
																loc_2 = add_i32(loc_1, 16)
																if loc_0 == 0 then
																	desired = 12
																	break
																end
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															reg_0 = FUNC_LIST[1119](loc_2, param_0, loc_0)
															break
														end
														if desired then break end
														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, 4294967294)
														loc_0 = load_i32(memory_at_0, 61960)
														store_i32(memory_at_0, 61960, 0)
														if loc_0 ~= 1 then
															desired = 5
															break
														end
														reg_0 = FUNC_LIST[6]()
														loc_0 = reg_0
														reg_0 = FUNC_LIST[7]()
														if ge_i32(load_i32_i8(memory_at_0, loc_1 + 27), 0) then
															desired = 3
															break
														end
														FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 16))
														desired = 3
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
												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
													desired = 4
													break
												end
												store_i32(memory_at_0, 61960, 0)
												FUNC_LIST[406](loc_3, 4294967294)
												loc_2 = load_i32(memory_at_0, 61960)
												store_i32(memory_at_0, 61960, 0)
												if loc_2 == 1 then
													desired = 4
													break
												end
												store_i32(memory_at_0, 61960, 0)
												FUNC_LIST[403](loc_3, 4294967293)
												loc_2 = load_i32(memory_at_0, 61960)
												store_i32(memory_at_0, 61960, 0)
												if loc_2 == 1 then
													desired = 4
													break
												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
													desired = 4
													break
												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
													desired = 4
													break
												end
												if loc_2 == 0 then
													while true do
														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
															desired = 4
															break
														end
														if loc_2 ~= 0 then
															while true do
																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
																	desired = 4
																	break
																end
																store_i32(memory_at_0, 61960, 0)
																reg_0 = FUNC_LIST[4](18, loc_0, 4294957294, 1858)
																param_0 = load_i32(memory_at_0, 61960)
																store_i32(memory_at_0, 61960, 0)
																if param_0 == 1 then
																	desired = 4
																	break
																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
																	desired = 4
																	break
																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
																	desired = 4
																	break
																end
																break
															end
															if desired then break end
														end
														store_i32(memory_at_0, 61960, 0)
														FUNC_LIST[402](loc_3, 4294967294)
														loc_0 = load_i32(memory_at_0, 61960)
														store_i32(memory_at_0, 61960, 0)
														if loc_0 == 1 then
															desired = 4
															break
														end
														store_i32(memory_at_0, loc_1 + 24, 0)
														store_i64(memory_at_0, loc_1 + 16, i64_ZERO)
														desired = 5
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
												end
												store_i32(memory_at_0, loc_1 + 24, 0)
												store_i64(memory_at_0, loc_1 + 16, i64_ZERO)
												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
													desired = 7
													break
												end
												while true do
													if loc_4 == 0 then break 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
														desired = 7
														break
													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
														desired = 7
														break
													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)
													while true do
														if param_0 ~= 1 then
															while true do
																store_i32(memory_at_0, 61960, 0)
																param_0 = load_i32_u8(memory_at_0, loc_1 + 43)
																loc_4 =
																	(lt_i32(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
																	desired = 12
																	break
																end
																if lt_i32(load_i32_i8(memory_at_0, loc_1 + 43), 0) then
																	while true do
																		FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 32))
																		break
																	end
																	if desired then break end
																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
																	desired = 11
																	break
																end
																desired = 7
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
														end
														reg_0 = FUNC_LIST[6]()
														loc_0 = reg_0
														reg_0 = FUNC_LIST[7]()
														desired = 6
														break
													end
													if desired then
														if desired == 11 then desired = nil end
														break
													end
													reg_0 = FUNC_LIST[6]()
													loc_0 = reg_0
													reg_0 = FUNC_LIST[7]()
													if ge_i32(load_i32_i8(memory_at_0, loc_1 + 43), 0) then
														desired = 6
														break
													end
													FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 32))
													desired = 6
													break
												end
												if desired then
													if desired == 10 then desired = nil end
													break
												end
												if loc_2 == 1 then
													while true do
														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
															desired = 7
															break
														end
														desired = 8
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
												end
												store_i32(memory_at_0, 61960, 0)
												reg_0 = FUNC_LIST[4](9, loc_0, 4294967295, 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
													while true do
														if loc_2 == 0 then
															desired = 8
															break
														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
															desired = 8
															break
														end
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[6]()
												loc_0 = reg_0
												reg_0 = FUNC_LIST[7]()
												desired = 6
												break
											end
											if desired then
												if desired == 9 then desired = nil end
												break
											end
											reg_0 = FUNC_LIST[6]()
											loc_0 = reg_0
											reg_0 = FUNC_LIST[7]()
											desired = 2
											break
										end
										if desired then
											if desired == 8 then desired = nil end
											break
										end
										reg_0 = FUNC_LIST[6]()
										loc_0 = reg_0
										reg_0 = FUNC_LIST[7]()
										desired = 2
										break
									end
									if desired then
										if desired == 7 then desired = nil end
										break
									end
									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 break 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 break 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 break end
									store_i32(memory_at_0, 61960, 0)
									FUNC_LIST[402](loc_3, 4294967294)
									loc_0 = load_i32(memory_at_0, 61960)
									store_i32(memory_at_0, 61960, 0)
									if loc_0 ~= 1 then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 6 then desired = nil end
									break
								end
								reg_0 = FUNC_LIST[6]()
								loc_0 = reg_0
								reg_0 = FUNC_LIST[7]()
								break
							end
							if desired then
								if desired == 5 then desired = nil end
								break
							end
							if ge_i32(load_i32_i8(memory_at_0, loc_1 + 27), 0) then
								desired = 3
								break
							end
							FUNC_LIST[1276](load_i32(memory_at_0, loc_1 + 16))
							desired = 3
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						if lt_i32(load_i32_i8(memory_at_0, 54895), 0) then
							while true do
								FUNC_LIST[1276](load_i32(memory_at_0, 54884))
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						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 lt_i32(load_i32_i8(memory_at_0, loc_1 + 11), 0) then
							while true do
								FUNC_LIST[1276](load_i32(memory_at_0, loc_1))
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						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)
						while true do
							if loc_3 == 0 then break 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 break end
							reg_0 = FUNC_LIST[10](0)
							reg_0 = FUNC_LIST[7]()
							FUNC_LIST[1391]()
							error("out of code bounds")
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						GLOBAL_LIST[0].value = add_i32(loc_1, 336)
						loc_3 = (lt_i32(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)
						desired = 0
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					reg_0 = FUNC_LIST[6]()
					loc_0 = reg_0
					reg_0 = FUNC_LIST[7]()
					break
				end
				if desired then
					if desired == 2 then desired = nil end
					break
				end
				if ge_i32(load_i32_i8(memory_at_0, loc_1 + 11), 0) then break end
				FUNC_LIST[1276](load_i32(memory_at_0, loc_1))
				break
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			while true do
				if loc_3 == 0 then break 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 break end
				reg_0 = FUNC_LIST[10](0)
				reg_0 = FUNC_LIST[7]()
				FUNC_LIST[1391]()
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			FUNC_LIST[11](loc_0)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then desired = nil end
			break
		end
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[37] = --[[ __cxx_global_array_dtor ]] function(param_0)
	while true do
		if lt_i32(load_i32_i8(memory_at_0, 54895), 0) then
			while true do
				FUNC_LIST[1276](load_i32(memory_at_0, 54884))
				break
			end
		end
		break
	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)
		while true do
			FUNC_LIST[1299](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			reg_0 = FUNC_LIST[973](param_1, 7863)
			loc_1 = reg_0
			if loc_1 ~= 0 then
				while true do
					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 load_i32(memory_at_0, param_0 + 12) >= shr_u32(mul_i32(loc_0, 3), 2) then
						while true do
							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)
							break
						end
					end
					while true do
						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
							while true do
								while true do
									if loc_1 == loc_4 then
										desired = 2
										break
									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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil 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)
						)
						break
					end
					store_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 3)) + 4, 1)
					break
				end
			end
			while true do
				if param_2 == 0 then break end
				loc_0 = load_i32(memory_at_0, param_2)
				if loc_0 == 0 then break end
				while true do
					reg_0 = FUNC_LIST[973](param_1, loc_0)
					loc_1 = reg_0
					if loc_1 ~= 0 then
						while true do
							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 load_i32(memory_at_0, param_0 + 12) >= shr_u32(mul_i32(loc_0, 3), 2) then
								while true do
									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)
									break
								end
								if desired then break end
							end
							while true do
								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
									while true do
										while true do
											if loc_1 == loc_4 then
												desired = 4
												break
											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 continue end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 4 then desired = nil 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)
								)
								break
							end
							if desired then break end
							store_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 3)) + 4, 1)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					loc_0 = load_i32(memory_at_0, param_2 + 4)
					param_2 = add_i32(param_2, 4)
					if loc_0 ~= 0 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			break
		end
	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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1) > 127 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							while true do
								loc_3 = loc_1
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						loc_10 = load_i32(memory_at_0, loc_0 + 12)
						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
								while true do
									while true do
										while true do
											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 break end
											loc_4 = 0
											if loc_2 == loc_8 then
												desired = 6
												break
											end
											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
													desired = 7
													break
												end
												if loc_2 ~= loc_8 then continue end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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))
										break
									end
									if desired then break end
									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)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_5 = add_i32(loc_5, 1)
							if loc_5 < shr_i32(sub_i32(loc_1, loc_3), 3) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_3)
				FUNC_LIST[1276](loc_3)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 32)
			break
		end
	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
		while true do
			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)
			break
		end
	end
FUNC_LIST[42] = --[[ Luau::Compile::ValueVisitor::~ValueVisitor() ]] function(
	param_0
)
	while true do
		FUNC_LIST[1276](param_0)
		break
	end
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
		local desired
		while true do
			while true do
				loc_0 = load_i32(memory_at_0, param_1 + 32)
				if loc_0 == 0 then break end
				while true do
					if load_i32(memory_at_0, param_1 + 40) == 0 then break end
					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 load_i32(memory_at_0, loc_1 + 12) >= shr_u32(mul_i32(loc_0, 3), 2) then
							while true do
								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)
								break
							end
							if desired then
								if desired == 3 then
									desired = nil
									continue
								end
								break
							end
						end
						while true do
							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
								while true do
									while true do
										if loc_2 == loc_5 then
											desired = 4
											break
										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 continue end
										break
									end
									if desired then break end
									break
								end
								if desired then
									if desired == 4 then desired = nil 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)
							)
							break
						end
						if desired then
							if desired == 3 then
								desired = nil
								continue
							end
							break
						end
						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 loc_4 >= loc_0 then
							desired = 2
							break
						end
						if loc_4 < load_i32(memory_at_0, param_1 + 40) then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_4 = load_i32(memory_at_0, param_1 + 40)
				if loc_4 >= loc_0 then break end
				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 load_i32(memory_at_0, loc_1 + 12) >= shr_u32(mul_i32(loc_0, 3), 2) then
						while true do
							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)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					while true do
						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
							while true do
								while true do
									if loc_2 == loc_5 then
										desired = 3
										break
									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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 3 then desired = nil 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)
						)
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					store_i32(memory_at_0, add_i32(loc_3, mul_i32(loc_0, 12)) + 4, 0)
					loc_4 = add_i32(loc_4, 1)
					if loc_4 < load_i32(memory_at_0, param_1 + 32) then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			reg_0 = 1
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 12) > 15 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_1 = reg_0
						store_i64(memory_at_0, loc_0 + 36, i64_ZERO)
						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
							while true do
								loc_1 = loc_2
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						loc_9 = load_i32(memory_at_0, loc_0 + 8)
						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
								while true do
									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)
									while true do
										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
												while true do
													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)
													desired = 6
													break
												end
												if desired then
													if desired == 7 then
														desired = nil
														continue
													end
													break
												end
											end
											if loc_2 == loc_3 then
												desired = 6
												break
											end
											loc_1 = add_i32(loc_1, 1)
											loc_2 = add_i32(loc_1, loc_11)
											if loc_1 <= loc_4 then continue end
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										loc_5 = 0
										break
									end
									if desired then break end
									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)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_6 = add_i32(loc_6, 1)
							if loc_6 < div_i32(sub_i32(loc_2, loc_1), 12) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, param_0 + 16)
					store_i64(memory_at_0, loc_0 + 12, i64_ZERO)
					store_i32(memory_at_0, loc_0 + 8, loc_1)
					FUNC_LIST[50](param_0, 16, add_i32(loc_0, 8))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 12, loc_1)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			break
		end
	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
		local desired
		while true do
			if load_i32(memory_at_0, param_1 + 32) ~= 0 then
				while true do
					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 loc_0 < load_i32(memory_at_0, param_1 + 32) then continue end
						break
					end
					break
				end
			end
			if load_i32(memory_at_0, param_1 + 40) ~= 0 then
				while true do
					loc_0 = 0
					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 loc_0 < load_i32(memory_at_0, param_1 + 40) then continue end
						break
					end
					break
				end
			end
			reg_0 = 0
			break
		end
		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
		local desired
		while true do
			loc_1 = load_i32(memory_at_0, param_1 + 4)
			while true do
				if param_1 == 0 then break end
				if loc_1 ~= load_i32(memory_at_0, 54940) then break 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 load_i32(memory_at_0, loc_0 + 12) >= shr_u32(mul_i32(loc_1, 3), 2) then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							param_0 = 0
							while true do
								if loc_1 == loc_3 then
									desired = 2
									break
								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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i32_n8(memory_at_0, add_i32(loc_2, mul_i32(param_1, 12)) + 8, 1)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			while true do
				if param_1 == 0 then break end
				if loc_1 ~= load_i32(memory_at_0, 54948) then break 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 load_i32(memory_at_0, loc_0 + 12) >= shr_u32(mul_i32(loc_1, 3), 2) then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							param_0 = 0
							while true do
								if loc_1 == loc_3 then
									desired = 2
									break
								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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i32(memory_at_0, add_i32(loc_2, shl_i32(param_1, 3)) + 4, 2)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			TABLE_LIST[0].data[load_i32(memory_at_0, load_i32(memory_at_0, param_1))](
				param_1, param_0
			)
			break
		end
	end
FUNC_LIST[47] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatCompoundAssign*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			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
			break
		end
		return reg_0
	end
FUNC_LIST[48] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatFunction*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			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
			break
		end
		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
		local desired
		while true do
			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 load_i32(memory_at_0, loc_0 + 12) >= shr_u32(mul_i32(param_0, 3), 2) then
				while true do
					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)
					break
				end
			end
			while true do
				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
					while true do
						while true do
							if param_0 == loc_2 then
								desired = 1
								break
							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 continue end
							break
						end
						if desired then break end
						break
					end
					if desired then
						if desired == 1 then desired = nil 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)
				)
				break
			end
			store_i32(memory_at_0, add_i32(loc_1, mul_i32(param_1, 12)) + 4, loc_5)
			reg_0 = 1
			break
		end
		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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_2 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_2), 12) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_3 < 36 then break end
						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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_2)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 357913942 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
						loc_5 = shl_i32(loc_0, 1)
						loc_5 = (loc_0 < 178956970 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        357913941)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 357913942 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
								loc_4 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						param_1 = add_i32(loc_3, loc_6)
						if loc_7 >= 36 then
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967284), 12))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[51](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_0, loc_1), 3) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_1 = add_i32(loc_1, loc_2)
						if loc_3 < 7 then break end
						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, 4294967232)
							if loc_0 ~= loc_1 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_1)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 536870912 then
					while true do
						loc_0 = sub_i32(loc_0, loc_5)
						loc_5 = shr_i32(loc_0, 2)
						loc_5 = (loc_0 < 2147483640 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        536870911)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
								loc_2 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_4 = add_i32(loc_3, loc_7)
						if loc_8 >= 7 then
							while true do
								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, 4294967232)
									if loc_0 ~= loc_4 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](param_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[53](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		while true do
			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)
			break
		end
	end
FUNC_LIST[55] = --[[ Luau::Compile::ConstantVisitor::~ConstantVisitor() ]]
	function(param_0)
		while true do
			FUNC_LIST[1276](param_0)
			break
		end
	end
FUNC_LIST[56] = --[[ Luau::Compile::ConstantVisitor::visit(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		while true do
			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
			break
		end
		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 desired
		local br_map = {}
		while true do
			loc_1 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_1
			store_i64(memory_at_0, param_0, i64_ZERO)
			store_i32(memory_at_0, param_0 + 8, 0)
			loc_0 = load_i32(memory_at_0, param_2 + 4)
			while true do
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54900) then break 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))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if load_i32(memory_at_0, 54908) == loc_0 then
					while true do
						store_i32(memory_at_0, param_0, 1)
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54916) then break 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)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54924) then break 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))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54932) then break 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))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54940) then break 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
						desired = 1
						break
					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))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if loc_0 == load_i32(memory_at_0, 54948) then break end
				if loc_0 == load_i32(memory_at_0, 54956) then break end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54964) then break 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
						desired = 1
						break
					end
					loc_0 = 0
					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 loc_0 < load_i32(memory_at_0, param_2 + 32) then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54972) then break end
					FUNC_LIST[57](
						add_i32(loc_1, 32), param_1, load_i32(memory_at_0, param_2 + 24)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54980) then break 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)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 54988) then break 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
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if loc_0 ~= load_i32(memory_at_0, 54996) then break end
					if param_2 == 0 then break end
					if load_i32(memory_at_0, param_2 + 28) == 0 then
						desired = 1
						break
					end
					loc_0 = 0
					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
							while true do
								FUNC_LIST[57](add_i32(loc_1, 32), param_1, loc_3)
								break
							end
							if desired then
								if desired == 3 then
									desired = nil
									continue
								end
								break
							end
						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 loc_0 < load_i32(memory_at_0, param_2 + 28) then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 55004) then break 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
						desired = 1
						break
					end
					FUNC_LIST[61](
						param_0, load_i32(memory_at_0, param_2 + 24), add_i32(loc_1, 32)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 55012) then break 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
						desired = 1
						break
					end
					FUNC_LIST[62](
						param_0, load_i32(memory_at_0, param_2 + 24), add_i32(loc_1, 32),
							add_i32(loc_1, 16)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 55020) then break 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))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if param_2 == 0 then break end
				if loc_0 ~= load_i32(memory_at_0, 55028) then break 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
				while true do
					while true do
						while true do
							if not br_map[1] then
								br_map[1] = (function() return { [0] = 3, 2, 0 } end)()
							end
							local temp = br_map[1][load_i32(memory_at_0, loc_1 + 32)] or 1
							if temp < 2 then
								if temp < 1 then
									break
								else
									desired = 3
									break
								end
							elseif temp > 2 then
								desired = 1
								break
							else
								desired = 2
								break
							end
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32_u8(memory_at_0, loc_1 + 40) == 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_0 = add_i32(loc_1, 16)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				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))
				break
			end
			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)
			break
		end
	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
		local desired
		while true do
			loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
			GLOBAL_LIST[0].value = loc_5
			while true do
				while true do
					while true do
						loc_1 = load_i32(memory_at_0, param_1 + 32)
						if loc_1 == 0 then
							while true do
								loc_0 = load_i32(memory_at_0, param_1 + 40)
								loc_1 = 0
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						while true do
							loc_0 = load_i32(memory_at_0, param_1 + 40)
							if loc_0 == 0 then break end
							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
								while true do
									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 break end
									loc_9 = load_i32(memory_at_0, loc_0 + 16)
									if loc_9 == loc_1 then break 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
									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
											desired = 6
											break
										end
										loc_2 = 0
										if loc_4 == loc_9 then
											desired = 6
											break
										end
										loc_0 = add_i32(loc_0, 1)
										loc_4 = add_i32(loc_0, loc_10)
										if loc_0 <= loc_3 then continue end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								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
									while true do
										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
										)
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
								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 loc_7 >= loc_1 then
									desired = 4
									break
								end
								if loc_0 > loc_7 then continue end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if loc_0 < loc_1 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					if loc_0 <= loc_1 then
						desired = 1
						break
					end
					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 loc_1 < load_i32(memory_at_0, param_1 + 40) then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if loc_0 == 0 then break 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
						while true do
							loc_8 = loc_0
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					loc_2 = load_i32(memory_at_0, loc_2 + 4)
					if loc_2 == load_i32(memory_at_0, 54964) then
						desired = 1
						break
					end
					loc_8 = loc_0
					if loc_2 == load_i32(memory_at_0, 54956) then
						desired = 1
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					loc_2 = 0
					store_i32(memory_at_0, loc_5 + 8, 0)
					store_i64(memory_at_0, loc_5, i64_ONE)
					loc_6 = load_i32(
						memory_at_0,
							add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_8, 2))
					)
					while true do
						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 break end
						loc_7 = load_i32(memory_at_0, loc_0 + 16)
						if loc_7 == loc_6 then break 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
						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
								desired = 3
								break
							end
							loc_2 = 0
							if loc_4 == loc_7 then
								desired = 3
								break
							end
							loc_0 = add_i32(loc_0, 1)
							loc_4 = add_i32(loc_0, loc_10)
							if loc_0 <= loc_3 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					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
						while true do
							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)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					loc_8 = add_i32(loc_8, 1)
					if loc_8 < loc_1 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_5, 16)
			reg_0 = 0
			break
		end
		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
		local desired
		while true do
			if load_i32(memory_at_0, param_3) ~= 0 then
				while true do
					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 load_i32(memory_at_0, param_1 + 12) >= shr_u32(mul_i32(param_0, 3), 2) then
						while true do
							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)
							break
						end
						if desired then break end
					end
					loc_2 = sub_i32(param_0, 1)
					loc_5 = load_i32(memory_at_0, param_1 + 16)
					param_0 = 0
					while true do
						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
								while true do
									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)
									)
									desired = 2
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							if param_2 == loc_0 then
								desired = 2
								break
							end
							param_0 = add_i32(param_0, 1)
							loc_0 = add_i32(param_0, loc_4)
							if param_0 <= loc_2 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						loc_1 = 0
						break
					end
					if desired then break end
					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))
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				if load_i32_u8(memory_at_0, param_0 + 16) ~= 0 then break 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 break end
				loc_3 = load_i32(memory_at_0, param_1 + 16)
				if loc_3 == param_2 then break 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
				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
						while true do
							if loc_3 == loc_4 then
								desired = 1
								break
							end
							param_0 = add_i32(param_0, 1)
							loc_0 = add_i32(param_0, loc_0)
							if param_0 <= loc_2 then
								desired = 2
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)) + 8, 0)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			break
		end
	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
		local desired
		while true do
			while true do
				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 break 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 break 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
				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
						desired = 1
						break
					end
					loc_0 = 0
					if param_1 == loc_4 then
						desired = 1
						break
					end
					param_0 = add_i32(param_0, 1)
					param_1 = add_i32(param_0, loc_5)
					if param_0 <= loc_1 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			reg_0 = (loc_0 ~= 0 and add_i32(loc_0, 8) or 0)
			break
		end
		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 desired
		local br_map = {}
		while true do
			while true do
				while true do
					while true do
						while true do
							if not br_map[1] then
								br_map[1] = (function() return { [0] = 0, 1, 2 } end)()
							end
							local temp = br_map[1][param_1] or 3
							if temp < 2 then
								if temp < 1 then
									break
								else
									desired = 3
									break
								end
							elseif temp > 2 then
								desired = 1
								break
							else
								desired = 2
								break
							end
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32(memory_at_0, param_2) == 0 then
							desired = 1
							break
						end
						store_i32(memory_at_0, param_0, 2)
						loc_0 = 1
						param_1 = 0
						while true do
							while true do
								while true do
									if not br_map[2] then
										br_map[2] = (function() return { [0] = 2, 0 } end)()
									end
									local temp = br_map[2][sub_i32(load_i32(memory_at_0, param_2), 1)] or 1
									if temp < 1 then
										break
									elseif temp > 1 then
										desired = 4
										break
									else
										desired = 5
										break
									end
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								loc_0 = (load_i32_u8(memory_at_0, param_2 + 8) ~= 0 and 1 or 0)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							param_1 = loc_0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						store_i32_n8(memory_at_0, param_0 + 8, bxor_i32(param_1, 1))
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					if load_i32(memory_at_0, param_2) ~= 3 then
						desired = 1
						break
					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))
					)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if load_i32(memory_at_0, param_2) ~= 4 then break 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))
				)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			break
		end
	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 desired
		local br_map = {}
		while true do
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										while true do
											while true do
												while true do
													while true do
														while true do
															while true do
																while true do
																	while true do
																		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
																		local temp = br_map[1][param_1] or 14
																		if temp < 7 then
																			if temp < 3 then
																				if temp < 1 then
																					break
																				elseif temp > 1 then
																					desired = 13
																					break
																				else
																					desired = 14
																					break
																				end
																			elseif temp > 3 then
																				if temp < 5 then
																					desired = 11
																					break
																				elseif temp > 5 then
																					desired = 9
																					break
																				else
																					desired = 10
																					break
																				end
																			else
																				desired = 12
																				break
																			end
																		elseif temp > 7 then
																			if temp < 11 then
																				if temp < 9 then
																					desired = 7
																					break
																				elseif temp > 9 then
																					desired = 5
																					break
																				else
																					desired = 6
																					break
																				end
																			elseif temp > 11 then
																				if temp < 13 then
																					desired = 3
																					break
																				elseif temp > 13 then
																					desired = 1
																					break
																				else
																					desired = 2
																					break
																				end
																			else
																				desired = 4
																				break
																			end
																		else
																			desired = 8
																			break
																		end
																	end
																	if desired then
																		if desired == 14 then desired = nil end
																		break
																	end
																	if load_i32(memory_at_0, param_2) ~= 3 then
																		desired = 1
																		break
																	end
																	if load_i32(memory_at_0, param_3) ~= 3 then
																		desired = 1
																		break
																	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))
																	)
																	desired = 0
																	break
																end
																if desired then
																	if desired == 13 then desired = nil end
																	break
																end
																if load_i32(memory_at_0, param_2) ~= 3 then
																	desired = 1
																	break
																end
																if load_i32(memory_at_0, param_3) ~= 3 then
																	desired = 1
																	break
																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))
																)
																desired = 0
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															if load_i32(memory_at_0, param_2) ~= 3 then
																desired = 1
																break
															end
															if load_i32(memory_at_0, param_3) ~= 3 then
																desired = 1
																break
															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))
															)
															desired = 0
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														if load_i32(memory_at_0, param_2) ~= 3 then
															desired = 1
															break
														end
														if load_i32(memory_at_0, param_3) ~= 3 then
															desired = 1
															break
														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))
														)
														desired = 0
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													if load_i32(memory_at_0, param_2) ~= 3 then
														desired = 1
														break
													end
													if load_i32(memory_at_0, param_3) ~= 3 then
														desired = 1
														break
													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))
													)
													desired = 0
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												if load_i32(memory_at_0, param_2) ~= 3 then
													desired = 1
													break
												end
												if load_i32(memory_at_0, param_3) ~= 3 then
													desired = 1
													break
												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)
												desired = 0
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											if load_i32(memory_at_0, param_2) == 0 then
												desired = 1
												break
											end
											if load_i32(memory_at_0, param_3) == 0 then
												desired = 1
												break
											end
											store_i32(memory_at_0, param_0, 2)
											param_1 = 0
											while true do
												while true do
													while true do
														while true do
															while true do
																if not br_map[2] then
																	br_map[2] = (function()
																		return { [0] = 0, 1, 2, 3 }
																	end)()
																end
																local temp =
																	br_map[2][sub_i32(load_i32(memory_at_0, param_2), 1)] or 4
																if temp < 2 then
																	if temp < 1 then
																		break
																	else
																		desired = 12
																		break
																	end
																elseif temp > 2 then
																	if temp < 4 then
																		desired = 10
																		break
																	else
																		desired = 9
																		break
																	end
																else
																	desired = 11
																	break
																end
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															param_1 = (load_i32(memory_at_0, param_3) == 1 and 1 or 0)
															desired = 9
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														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)
														)
														desired = 9
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													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)
													)
													desired = 9
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												if load_i32(memory_at_0, param_3) ~= 4 then break end
												loc_0 = load_i32(memory_at_0, param_2 + 4)
												if loc_0 ~= load_i32(memory_at_0, param_3 + 4) then break 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)
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											store_i32_n8(memory_at_0, param_0 + 8, bxor_i32(param_1, 1))
											desired = 0
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										if load_i32(memory_at_0, param_2) == 0 then
											desired = 1
											break
										end
										if load_i32(memory_at_0, param_3) == 0 then
											desired = 1
											break
										end
										store_i32(memory_at_0, param_0, 2)
										param_1 = 0
										while true do
											while true do
												while true do
													while true do
														while true do
															if not br_map[3] then
																br_map[3] = (function()
																	return { [0] = 0, 1, 2, 3 }
																end)()
															end
															local temp =
																br_map[3][sub_i32(load_i32(memory_at_0, param_2), 1)] or 4
															if temp < 2 then
																if temp < 1 then
																	break
																else
																	desired = 11
																	break
																end
															elseif temp > 2 then
																if temp < 4 then
																	desired = 9
																	break
																else
																	desired = 8
																	break
																end
															else
																desired = 10
																break
															end
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														store_i32_n8(
															memory_at_0, param_0 + 8,
																(load_i32(memory_at_0, param_3) == 1 and 1 or 0)
														)
														desired = 0
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													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)
														)
													)
													desired = 0
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												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)
													)
												)
												desired = 0
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											if load_i32(memory_at_0, param_3) ~= 4 then break end
											loc_0 = load_i32(memory_at_0, param_2 + 4)
											if loc_0 ~= load_i32(memory_at_0, param_3 + 4) then break 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)
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										store_i32_n8(memory_at_0, param_0 + 8, param_1)
										desired = 0
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									if load_i32(memory_at_0, param_2) ~= 3 then
										desired = 1
										break
									end
									if load_i32(memory_at_0, param_3) ~= 3 then
										desired = 1
										break
									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)
									)
									desired = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								if load_i32(memory_at_0, param_2) ~= 3 then
									desired = 1
									break
								end
								if load_i32(memory_at_0, param_3) ~= 3 then
									desired = 1
									break
								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)
								)
								desired = 0
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if load_i32(memory_at_0, param_2) ~= 3 then
								desired = 1
								break
							end
							if load_i32(memory_at_0, param_3) ~= 3 then
								desired = 1
								break
							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)
							)
							desired = 0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32(memory_at_0, param_2) ~= 3 then
							desired = 1
							break
						end
						if load_i32(memory_at_0, param_3) ~= 3 then
							desired = 1
							break
						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)
						)
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					while true do
						while true do
							while true do
								if not br_map[4] then
									br_map[4] = (function() return { [0] = 4, 2, 0 } end)()
								end
								local temp = br_map[4][load_i32(memory_at_0, param_2)] or 1
								if temp < 2 then
									if temp < 1 then
										break
									else
										desired = 4
										break
									end
								elseif temp > 2 then
									desired = 1
									break
								else
									desired = 3
									break
								end
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if load_i32_u8(memory_at_0, param_2 + 8) == 0 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						param_2 = param_3
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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))
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					while true do
						while true do
							if not br_map[5] then
								br_map[5] = (function() return { [0] = 3, 2, 0 } end)()
							end
							local temp = br_map[5][load_i32(memory_at_0, param_2)] or 1
							if temp < 2 then
								if temp < 1 then
									break
								else
									desired = 3
									break
								end
							elseif temp > 2 then
								desired = 1
								break
							else
								desired = 2
								break
							end
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32_u8(memory_at_0, param_2 + 8) == 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					param_3 = param_2
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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))
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			break
		end
	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
		local desired
		while true do
			if load_i32(memory_at_0, param_3) ~= 0 then
				while true do
					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 load_i32(memory_at_0, param_1 + 12) >= shr_u32(mul_i32(param_0, 3), 2) then
						while true do
							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)
							break
						end
						if desired then break end
					end
					loc_2 = sub_i32(param_0, 1)
					loc_5 = load_i32(memory_at_0, param_1 + 16)
					param_0 = 0
					while true do
						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
								while true do
									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)
									)
									desired = 2
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							if param_2 == loc_0 then
								desired = 2
								break
							end
							param_0 = add_i32(param_0, 1)
							loc_0 = add_i32(param_0, loc_4)
							if param_0 <= loc_2 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						loc_1 = 0
						break
					end
					if desired then break end
					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))
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				if load_i32_u8(memory_at_0, param_0 + 16) ~= 0 then break 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 break end
				loc_3 = load_i32(memory_at_0, param_1 + 16)
				if loc_3 == param_2 then break 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
				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
						while true do
							if loc_3 == loc_4 then
								desired = 1
								break
							end
							param_0 = add_i32(param_0, 1)
							loc_0 = add_i32(param_0, loc_0)
							if param_0 <= loc_2 then
								desired = 2
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i32(memory_at_0, add_i32(loc_1, mul_i32(loc_0, 24)) + 8, 0)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			break
		end
	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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 24) > 15 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_1 = reg_0
						store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
						store_i64(memory_at_0, loc_0 + 32, i64_ZERO)
						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
							while true do
								loc_1 = loc_2
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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
						)
						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
								while true do
									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)
									while true do
										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
												while true do
													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)
													desired = 6
													break
												end
												if desired then
													if desired == 7 then
														desired = nil
														continue
													end
													break
												end
											end
											if loc_2 == loc_3 then
												desired = 6
												break
											end
											loc_1 = add_i32(loc_1, 1)
											loc_2 = add_i32(loc_1, loc_11)
											if loc_1 <= loc_4 then continue end
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										loc_5 = 0
										break
									end
									if desired then break end
									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)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_6 = add_i32(loc_6, 1)
							if loc_6 < div_i32(sub_i32(loc_2, loc_1), 24) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, param_0 + 16)
					store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
					store_i64(memory_at_0, loc_0 + 32, i64_ZERO)
					store_i32(memory_at_0, loc_0 + 24, loc_1)
					FUNC_LIST[65](param_0, 16, add_i32(loc_0, 24))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_1)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			break
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_3 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_3), 24) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_3 = add_i32(loc_2, loc_3)
						if loc_5 < 72 then break end
						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, 4294967232), 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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_3)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_2 < 178956971 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_4), 24)
						loc_4 = shl_i32(loc_0, 1)
						loc_7 = (loc_0 < 89478485 and (loc_2 < loc_4 and loc_4 or loc_2) or
							        178956970)
						if loc_7 ~= 0 then
							while true do
								if loc_7 >= 178956971 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_7, 24))
								loc_5 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_6 >= 72 then
							while true do
								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, 4294967232), 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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967272), 24))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[66](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 96)
			GLOBAL_LIST[0].value = loc_0
			store_i64(memory_at_0, loc_0 + 24, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 32, 0)
			store_i64(memory_at_0, loc_0 + 48, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 56, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 76, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 84, 0)
			store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 12, param_0)
			store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 68, i64_ZERO)
			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
				while true do
					store_i32(memory_at_0, loc_0 + 72, param_1)
					FUNC_LIST[1276](param_1)
					break
				end
			end
			param_1 = load_i32(memory_at_0, loc_0 + 40)
			if param_1 ~= 0 then
				while true do
					store_i32(memory_at_0, loc_0 + 44, param_1)
					FUNC_LIST[1276](param_1)
					break
				end
			end
			param_1 = load_i32(memory_at_0, loc_0 + 16)
			if param_1 ~= 0 then
				while true do
					store_i32(memory_at_0, loc_0 + 20, param_1)
					FUNC_LIST[1276](param_1)
					break
				end
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 96)
			break
		end
	end
FUNC_LIST[68] = --[[ Luau::Compile::ShapeVisitor::~ShapeVisitor() ]] function(
	param_0
)
	local loc_0 = 0
	local reg_0
	while true do
		store_i32(memory_at_0, param_0, 11080)
		loc_0 = load_i32(memory_at_0, param_0 + 60)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 64, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 36, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 12, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		reg_0 = param_0
		break
	end
	return reg_0
end
FUNC_LIST[69] = --[[ Luau::Compile::ShapeVisitor::~ShapeVisitor().1 ]] function(
	param_0
)
	local loc_0 = 0
	while true do
		store_i32(memory_at_0, param_0, 11080)
		loc_0 = load_i32(memory_at_0, param_0 + 60)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 64, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 36, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 8)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 12, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		FUNC_LIST[1276](param_0)
		break
	end
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
		local desired
		while true do
			while true do
				if load_i32(memory_at_0, param_1 + 32) ~= 1 then break end
				if load_i32(memory_at_0, param_1 + 40) ~= 1 then break 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
					while true do
						if loc_1 == 0 then
							desired = 1
							break
						end
						if loc_0 ~= load_i32(memory_at_0, 54964) then
							desired = 1
							break
						end
						if load_i32_u8(memory_at_0, loc_1 + 36) ~= 0 then
							desired = 1
							break
						end
						if load_i32(memory_at_0, loc_1 + 32) ~= 2 then
							desired = 1
							break
						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
							desired = 1
							break
						end
						if loc_0 == 0 then
							desired = 1
							break
						end
						loc_0 = load_i32(memory_at_0, loc_0 + 24)
						if loc_0 == 0 then
							desired = 1
							break
						end
						reg_0 = FUNC_LIST[1193](loc_0, 6356)
						if reg_0 ~= 0 then
							desired = 1
							break
						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
							desired = 1
							break
						end
						if loc_1 == 0 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				if load_i32(memory_at_0, loc_1 + 28) ~= 0 then break 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 load_i32(memory_at_0, param_0 + 20) >= shr_u32(mul_i32(param_1, 3), 2) then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							loc_0 = 0
							while true do
								if param_0 == loc_4 then
									desired = 2
									break
								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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i32(memory_at_0, add_i32(loc_2, shl_i32(param_1, 3)) + 4, loc_1)
				break
			end
			reg_0 = 1
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1) > 127 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							desired = 2
							break
						end
						loc_1 = shr_i32(sub_i32(loc_1, loc_3), 3)
						loc_13 = (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)
						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
								while true do
									while true do
										while true do
											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 break end
											loc_4 = 0
											if loc_2 == loc_8 then
												desired = 6
												break
											end
											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
													desired = 7
													break
												end
												if loc_2 ~= loc_8 then continue end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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)
										break
									end
									if desired then break end
									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)
									)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_5 = add_i32(loc_5, 1)
							if loc_5 ~= loc_13 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_3)
				FUNC_LIST[1276](loc_3)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 32)
			break
		end
	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
		local desired
		while true do
			while true do
				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 break 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 break end
				if load_f64(memory_at_0, loc_1 + 24) ~= 1e0 then break end
				loc_4 = load_f64(memory_at_0, loc_0 + 24)
				if (loc_4 >= 1e0 and 1 or 0) == 0 then break end
				if (loc_4 <= 1.6e1 and 1 or 0) == 0 then break end
				if load_i32(memory_at_0, param_1 + 40) ~= 0 then break 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, 4294967232)), loc_2
					), 3
				)
				loc_1 =
					(load_i32(memory_at_0, param_0 + 72) < shr_u32(mul_i32(loc_0, 3), 2) and 1 or
						0)
				while true do
					if band_i32((loc_4 < 4.294967296e9 and 1 or 0), (loc_4 >= 0e0 and 1 or 0)) ~=
						0 then
						while true do
							reg_0 = truncate_u32_f64(loc_4)
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					reg_0 = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_6 = reg_0
				loc_3 = add_i32(param_0, 60)
				if loc_1 == 0 then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							loc_1 = 0
							while true do
								if param_0 == loc_0 then
									desired = 2
									break
								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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i32(memory_at_0, add_i32(loc_2, shl_i32(param_1, 3)) + 4, loc_6)
				break
			end
			reg_0 = 1
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1) > 127 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							desired = 2
							break
						end
						loc_1 = shr_i32(sub_i32(loc_1, loc_3), 3)
						loc_13 = (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)
						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
								while true do
									while true do
										while true do
											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 break end
											loc_4 = 0
											if loc_2 == loc_8 then
												desired = 6
												break
											end
											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
													desired = 7
													break
												end
												if loc_2 ~= loc_8 then continue end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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)
										break
									end
									if desired then break end
									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)
									)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_5 = add_i32(loc_5, 1)
							if loc_5 ~= loc_13 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_3)
				FUNC_LIST[1276](loc_3)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 32)
			break
		end
	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
		local desired
		while true do
			if load_i32(memory_at_0, param_1 + 32) ~= 0 then
				while true do
					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)
						while true do
							while true do
								if loc_0 == 0 then break end
								if loc_2 ~= load_i32(memory_at_0, 54972) then break end
								FUNC_LIST[75](
									param_0, load_i32(memory_at_0, loc_0 + 24),
										load_i32(memory_at_0, loc_0 + 28)
								)
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							if loc_0 == 0 then break end
							if loc_2 ~= load_i32(memory_at_0, 54980) then break end
							FUNC_LIST[76](
								param_0, load_i32(memory_at_0, loc_0 + 24),
									load_i32(memory_at_0, loc_0 + 28)
							)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						loc_1 = add_i32(loc_1, 1)
						if loc_1 < load_i32(memory_at_0, param_1 + 32) then continue end
						break
					end
					break
				end
			end
			if load_i32(memory_at_0, param_1 + 40) ~= 0 then
				while true do
					loc_0 = 0
					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 loc_0 < load_i32(memory_at_0, param_1 + 40) then continue end
						break
					end
					break
				end
			end
			reg_0 = 0
			break
		end
		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
		local desired
		while true do
			while true do
				if param_1 == 0 then break end
				if load_i32(memory_at_0, param_1 + 4) ~= load_i32(memory_at_0, 54940) then
					break
				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 break 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 break 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
				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
						while true do
							if loc_2 == loc_5 then
								desired = 1
								break
							end
							param_1 = add_i32(param_1, 1)
							loc_0 = add_i32(param_1, loc_0)
							if param_1 <= loc_1 then
								desired = 2
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil 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)
				while true do
					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 break 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 break 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
					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
							desired = 1
							break
						end
						if band_i32((loc_2 == loc_4 and 1 or 0), (loc_0 == loc_10 and 1 or 0)) ~=
							0 then
							desired = 2
							break
						end
						param_1 = add_i32(param_1, 1)
						loc_0 = add_i32(param_1, loc_3)
						if param_1 <= loc_1 then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 load_i32(memory_at_0, loc_6 + 12) >= shr_u32(mul_i32(param_1, 3), 2) then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				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
				while true do
					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)
						while true do
							loc_3 = load_i32(memory_at_0, loc_0)
							if loc_3 ~= loc_10 then break end
							if loc_2 ~= loc_8 then break 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)
							)
							desired = 3
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if band_i32((loc_3 == loc_5 and 1 or 0), (param_2 == loc_2 and 1 or 0)) ~=
							0 then break end
						param_1 = add_i32(param_1, 1)
						loc_0 = add_i32(param_1, loc_4)
						if param_1 <= loc_1 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					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 load_i32(memory_at_0, param_2 + 12) >= shr_u32(mul_i32(param_1, 3), 2) then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							loc_1 = 0
							while true do
								if loc_0 == loc_3 then
									desired = 2
									break
								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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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))
				break
			end
			break
		end
	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
		local desired
		while true do
			while true do
				if param_1 == 0 then break end
				loc_3 = load_i32(memory_at_0, param_1 + 4)
				if loc_3 ~= load_i32(memory_at_0, 54940) then break 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 break 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 break 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
				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
						while true do
							if loc_4 == loc_6 then
								desired = 1
								break
							end
							param_1 = add_i32(param_1, 1)
							loc_0 = add_i32(param_1, loc_0)
							if param_1 <= loc_2 then
								desired = 2
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil 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)
				while true do
					if param_2 == 0 then break end
					if param_1 ~= load_i32(memory_at_0, 54924) then break 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 load_i32(memory_at_0, loc_3 + 12) >= shr_u32(mul_i32(param_1, 3), 2) then
						while true do
							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)
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					while true do
						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
							while true do
								loc_2 = 0
								while true do
									if loc_0 == loc_1 then
										desired = 3
										break
									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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 3 then desired = nil 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)
						)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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
						desired = 1
						break
					end
					store_i32(memory_at_0, param_1 + 4, loc_0)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if param_2 == 0 then break end
				if param_1 ~= loc_3 then break end
				loc_5 = load_i32(memory_at_0, param_0 + 60)
				param_1 = load_i32(memory_at_0, sub_i32(param_0, 4294967232))
				if loc_5 == param_1 then break 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 break 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
				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
						while true do
							if param_2 == loc_0 then
								desired = 1
								break
							end
							param_1 = add_i32(param_1, 1)
							loc_0 = add_i32(param_1, loc_6)
							if param_1 <= loc_2 then
								desired = 2
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil 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 load_i32(memory_at_0, loc_7 + 12) >= shr_u32(mul_i32(param_1, 3), 2) then
					while true do
						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)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							loc_2 = 0
							while true do
								if loc_0 == loc_1 then
									desired = 2
									break
								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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				param_1 = add_i32(loc_4, mul_i32(param_1, 12))
				if load_i32(memory_at_0, param_1 + 4) ~= 0 then break end
				store_i32(
					memory_at_0, param_1 + 4,
						load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_6, 3)) + 4)
				)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			break
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_1 + 28)
			loc_1 = load_i32(memory_at_0, loc_0 + 4)
			while true do
				while true do
					if loc_0 == 0 then break end
					if loc_1 ~= load_i32(memory_at_0, 54972) then break end
					FUNC_LIST[75](
						param_0, load_i32(memory_at_0, loc_0 + 24),
							load_i32(memory_at_0, loc_0 + 28)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if loc_0 == 0 then break end
				if loc_1 ~= load_i32(memory_at_0, 54980) then break end
				FUNC_LIST[76](
					param_0, load_i32(memory_at_0, loc_0 + 24),
						load_i32(memory_at_0, loc_0 + 28)
				)
				break
			end
			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
			break
		end
		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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_0, loc_1), 3) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_1 = add_i32(loc_1, loc_2)
						if loc_3 < 7 then break end
						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, 4294967232)
							if loc_0 ~= loc_1 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_1)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 536870912 then
					while true do
						loc_0 = sub_i32(loc_0, loc_5)
						loc_5 = shr_i32(loc_0, 2)
						loc_5 = (loc_0 < 2147483640 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        536870911)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
								loc_2 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_4 = add_i32(loc_3, loc_7)
						if loc_8 >= 7 then
							while true do
								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, 4294967232)
									if loc_0 ~= loc_4 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](param_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[79](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_0, loc_1), 3) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_1 = add_i32(loc_1, loc_2)
						if loc_3 < 7 then break end
						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, 4294967232)
							if loc_0 ~= loc_1 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_1)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 536870912 then
					while true do
						loc_0 = sub_i32(loc_0, loc_5)
						loc_5 = shr_i32(loc_0, 2)
						loc_5 = (loc_0 < 2147483640 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        536870911)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
								loc_2 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_4 = add_i32(loc_3, loc_7)
						if loc_8 >= 7 then
							while true do
								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, 4294967232)
									if loc_0 ~= loc_4 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](param_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[81](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_0, loc_1), 3) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_1 = add_i32(loc_1, loc_2)
						if loc_3 < 7 then break end
						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, 4294967232)
							if loc_0 ~= loc_1 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_1)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 536870912 then
					while true do
						loc_0 = sub_i32(loc_0, loc_5)
						loc_5 = shr_i32(loc_0, 2)
						loc_5 = (loc_0 < 2147483640 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        536870911)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
								loc_2 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_4 = add_i32(loc_3, loc_7)
						if loc_8 >= 7 then
							while true do
								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, 4294967232)
									if loc_0 ~= loc_4 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](param_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[83](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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 = i64_ZERO
		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 desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1) > 127 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									loc_10 = load_i64(memory_at_0, param_0 + 16)
									store_i64(memory_at_0, loc_0 + 24, loc_10)
									reg_0 = 16
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							while true do
								loc_2 = loc_1
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						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)
							while true do
								loc_3 = load_i32(memory_at_0, loc_12)
								if loc_3 == load_i32(memory_at_0, param_0 + 16) then
									while true do
										if loc_6 == load_i32(memory_at_0, param_0 + 20) then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									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)
								while true do
									while true do
										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 break 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
											desired = 6
											break
										end
										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
												desired = 7
												break
											end
											if loc_3 ~= loc_9 then continue end
											if loc_5 ~= loc_6 then continue end
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										desired = 6
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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))
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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)
								break
							end
							if desired then
								if desired == 4 then
									desired = nil
									continue
								end
								break
							end
							loc_7 = add_i32(loc_7, 1)
							if loc_7 < shr_i32(sub_i32(loc_1, loc_2), 3) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 12, loc_2)
				FUNC_LIST[1276](loc_2)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			break
		end
	end
FUNC_LIST[85] = --[[ Luau::BytecodeBuilder::BytecodeBuilder(Luau::BytecodeEncoder*) ]]
	function(param_0, param_1)
		local reg_0, reg_1
		while true do
			store_i32(memory_at_0, param_0 + 16, 4294967295)
			store_i64(memory_at_0, param_0 + 8, i64_from_u32(0, 4294967295))
			store_i64(memory_at_0, param_0, i64_ZERO)
			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, i64_ZERO)
			store_i64(memory_at_0, param_0 + 96, i64_ZERO)
			store_i64(memory_at_0, param_0 + 120, i64_from_u32(4294967295, 4294967295))
			reg_0 = FUNC_LIST[1121](add_i32(param_0, 136), 0, 148)
			store_i64(memory_at_0, param_0 + 296, i64_ZERO)
			store_i64(memory_at_0, param_0 + 288, i64_ZERO)
			store_i64(memory_at_0, param_0 + 312, i64_ZERO)
			store_i32(memory_at_0, param_0 + 304, 4294967295)
			store_i64(memory_at_0, param_0 + 320, i64_ZERO)
			store_i64(memory_at_0, param_0 + 328, i64_ZERO)
			store_i64(memory_at_0, param_0 + 336, i64_ZERO)
			store_i64(memory_at_0, param_0 + 344, i64_ZERO)
			store_i64(memory_at_0, param_0 + 352, i64_ZERO)
			store_i32(memory_at_0, param_0 + 360, 0)
			store_i64(memory_at_0, param_0 + 368, i64_ZERO)
			store_i64(memory_at_0, param_0 + 376, i64_ZERO)
			store_i64(memory_at_0, param_0 + 384, i64_ZERO)
			store_i64(memory_at_0, param_0 + 396, i64_ZERO)
			store_i32(memory_at_0, param_0 + 392, param_1)
			store_i64(memory_at_0, param_0 + 404, i64_ZERO)
			store_i64(memory_at_0, param_0 + 412, i64_ZERO)
			store_i64(memory_at_0, param_0 + 420, i64_ZERO)
			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, 4294967232), sub_i32(param_1, 4294967232)
			)
			FUNC_LIST[86](param_0, 8)
			reg_0 = param_0
			break
		end
		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
		local desired
		while true do
			while true do
				loc_1 = load_i32(memory_at_0, param_0)
				if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 48) >=
					param_1 then break end
				while true do
					while true do
						if param_1 < 89478486 then
							while true do
								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
									desired = 3
									break
								end
								param_1 = loc_3
								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, i64_ZERO)
									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, i64_ZERO)
									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, i64_ZERO)
									store_i32(memory_at_0, loc_2, 0)
									if loc_0 ~= loc_1 then continue end
									break
								end
								if desired then 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
									desired = 2
									break
								end
								while true do
									if lt_i32(load_i32_i8(memory_at_0, sub_i32(loc_0, 1)), 0) then
										while true do
											FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 12)))
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									param_1 = sub_i32(loc_0, 48)
									if lt_i32(load_i32_i8(memory_at_0, sub_i32(loc_0, 13)), 0) then
										while true do
											FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 24)))
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									if lt_i32(load_i32_i8(memory_at_0, param_1 + 11), 0) then
										while true do
											FUNC_LIST[1276](load_i32(memory_at_0, param_1))
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									loc_0 = param_1
									if loc_1 ~= loc_0 then continue end
									break
								end
								if desired then break end
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						FUNC_LIST[252](5133)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					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, loc_3)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if loc_1 == 0 then break end
				FUNC_LIST[1276](loc_1)
				break
			end
			break
		end
	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
		local desired
		while true do
			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, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 32, i64_ZERO)
			loc_3 = add_i32(loc_0, 24)
			store_i64(memory_at_0, loc_3, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
			store_i64(memory_at_0, loc_0, i64_ZERO)
			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)
			while true do
				if load_i32(memory_at_0, param_0 + 8) ~= loc_1 then
					while true do
						store_i64(memory_at_0, loc_1, i64_ZERO)
						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)
						while true do
							if ge_i32(load_i32_i8(memory_at_0, loc_0 + 35), 0) then
								while true do
									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))
									desired = 3
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							end
							FUNC_LIST[1345](
								param_2, load_i32(memory_at_0, loc_0 + 24),
									load_i32(memory_at_0, loc_0 + 28)
							)
							break
						end
						if desired then break end
						param_2 = add_i32(loc_1, 36)
						while true do
							if ge_i32(load_i32_i8(memory_at_0, loc_0 + 47), 0) then
								while true do
									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))
									desired = 3
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							end
							FUNC_LIST[1345](
								param_2, load_i32(memory_at_0, loc_0 + 36),
									load_i32(memory_at_0, loc_0 + 40)
							)
							break
						end
						if desired then break end
						store_i32(memory_at_0, param_0 + 4, add_i32(loc_1, 48))
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[88](param_0, loc_0)
				break
			end
			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 lt_i32(load_i32_i8(memory_at_0, loc_0 + 47), 0) then
				while true do
					FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 36))
					break
				end
			end
			if lt_i32(load_i32_i8(memory_at_0, loc_0 + 35), 0) then
				while true do
					FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 24))
					break
				end
			end
			if lt_i32(load_i32_i8(memory_at_0, loc_0 + 11), 0) then
				while true do
					FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
					break
				end
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			reg_0 = param_1
			break
		end
		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
		local desired
		while true do
			while true do
				while true do
					while true do
						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 loc_0 < 89478486 then
							while true do
								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 = (loc_1 < 44739242 and (loc_0 < loc_3 and loc_3 or loc_0) or
									        89478485)
								if loc_1 ~= 0 then
									while true do
										if loc_1 >= 89478486 then
											desired = 3
											break
										end
										reg_0 = FUNC_LIST[1275](mul_i32(loc_1, 48))
										loc_4 = reg_0
										break
									end
									if desired then break end
								end
								loc_0 = add_i32(loc_4, mul_i32(loc_2, 48))
								while true do
									if ge_i32(load_i32_i8(memory_at_0, param_1 + 11), 0) then
										while true do
											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))
											desired = 5
											break
										end
										if desired then
											if desired == 5 then desired = nil end
											break
										end
									end
									FUNC_LIST[1345](
										loc_0, load_i32(memory_at_0, param_1),
											load_i32(memory_at_0, param_1 + 4)
									)
									break
								end
								if desired then break end
								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)
								while true do
									if ge_i32(load_i32_i8(memory_at_0, param_1 + 35), 0) then
										while true do
											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))
											desired = 5
											break
										end
										if desired then
											if desired == 5 then desired = nil end
											break
										end
									end
									FUNC_LIST[1345](
										loc_3, load_i32(memory_at_0, loc_5), load_i32(memory_at_0, loc_5 + 4)
									)
									break
								end
								if desired then break end
								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)
								while true do
									if ge_i32(load_i32_i8(memory_at_0, param_1 + 47), 0) then
										while true do
											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))
											desired = 5
											break
										end
										if desired then
											if desired == 5 then desired = nil end
											break
										end
									end
									FUNC_LIST[1345](
										loc_2, load_i32(memory_at_0, loc_1), load_i32(memory_at_0, loc_1 + 4)
									)
									break
								end
								if desired then break end
								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
									desired = 2
									break
								end
								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, i64_ZERO)
									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, i64_ZERO)
									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, i64_ZERO)
									store_i32(memory_at_0, loc_4, 0)
									if param_1 ~= loc_2 then continue end
									break
								end
								if desired then 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
									desired = 1
									break
								end
								while true do
									if lt_i32(load_i32_i8(memory_at_0, sub_i32(param_1, 1)), 0) then
										while true do
											FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(param_1, 12)))
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									loc_0 = sub_i32(param_1, 48)
									if lt_i32(load_i32_i8(memory_at_0, sub_i32(param_1, 13)), 0) then
										while true do
											FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(param_1, 24)))
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									if lt_i32(load_i32_i8(memory_at_0, loc_0 + 11), 0) then
										while true do
											FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									param_1 = loc_0
									if param_1 ~= loc_2 then continue end
									break
								end
								if desired then break end
								desired = 1
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						FUNC_LIST[152](param_0)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[252](5133)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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)
				break
			end
			if loc_2 ~= 0 then
				while true do
					FUNC_LIST[1276](loc_2)
					break
				end
			end
			break
		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
		local desired
		while true do
			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, 4294967295)
			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
				while true do
					param_1 = add_i32(param_0, shr_i32(param_1, 1))
					reg_0 = loc_1
					reg_1 = param_1
					while true do
						if param_2 ~= 0 then
							while true do
								loc_0 = load_i32(
									memory_at_0, add_i32(load_i32(memory_at_0, param_1), loc_0)
								)
								break
							end
						end
						reg_2 = loc_0
						break
					end
					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 lt_i32(load_i32_i8(memory_at_0, param_1 + 35), 0) then
						while true do
							FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
							break
						end
					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))
					break
				end
			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))
			while true do
				if lt_i32(load_i32_i8(memory_at_0, param_0 + 391), 0) then
					while true do
						store_i32_n8(memory_at_0, load_i32(memory_at_0, param_0 + 380), 0)
						store_i32(memory_at_0, param_0 + 384, 0)
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				store_i32_n8(memory_at_0, param_0 + 391, 0)
				store_i32_n8(memory_at_0, param_0 + 380, 0)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_1, 16)
			break
		end
	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 desired
		local br_map = {}
		while true do
			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
			)
			while true do
				loc_2 = (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 continue 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
				while true do
					loc_0 = 0
					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
						while true do
							loc_4 = load_i32(memory_at_0, param_0 + 392)
							if loc_4 == 0 then
								while true do
									loc_4 = loc_2
									desired = 3
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							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)
							)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						store_i32(
							memory_at_0, loc_1 + 8,
								bor_i32(band_i32(loc_2, 4294967040), band_i32(loc_4, 255))
						)
						reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 4)
						if loc_3 >= 2 then
							while true do
								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)
								break
							end
							if desired then
								if desired == 2 then
									desired = nil
									continue
								end
								break
							end
						end
						loc_0 = add_i32(loc_0, loc_3)
						loc_2 = load_i32(memory_at_0, param_0 + 20)
						if loc_0 < shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 24), loc_2), 2) then
							continue
						end
						break
					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
			)
			while true do
				loc_2 = (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 continue 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
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										while true do
											while true do
												while true do
													while true do
														if not br_map[1] then
															br_map[1] = (function()
																return { [0] = 0, 1, 2, 3, 4, 5, 6 }
															end)()
														end
														local 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
																	break
																else
																	desired = 9
																	break
																end
															elseif temp > 2 then
																desired = 7
																break
															else
																desired = 8
																break
															end
														elseif temp > 4 then
															if temp < 6 then
																desired = 5
																break
															elseif temp > 6 then
																desired = 3
																break
															else
																desired = 4
																break
															end
														else
															desired = 6
															break
														end
													end
													if desired then
														if desired == 9 then desired = nil 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)
													desired = 3
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
												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)
												desired = 3
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											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)
											desired = 3
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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)
										while true do
											store_i32_n8(
												memory_at_0, loc_1 + 8,
													bor_i32(band_i32(loc_0, 127), shl_i32((loc_0 > 127 and 1 or 0), 7))
											)
											reg_0 = FUNC_LIST[1350](param_1, add_i32(loc_1, 8), 1)
											loc_2 = (loc_0 < 128 and 1 or 0)
											loc_0 = shr_u32(loc_0, 7)
											if loc_2 == 0 then continue end
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										desired = 3
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
									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)
									desired = 3
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
								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)
								while true do
									loc_2 = (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 continue end
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
								loc_3 = 0
								if load_i32(memory_at_0, loc_6) == 0 then
									desired = 3
									break
								end
								while true do
									loc_0 = load_i32(memory_at_0, add_i32(loc_5, shl_i32(loc_3, 2)))
									while true do
										loc_2 = (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 continue end
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
									loc_3 = add_i32(loc_3, 1)
									if loc_3 < load_i32(memory_at_0, loc_6) then continue end
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							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)
							while true do
								loc_2 = (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 continue end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						loc_4 = add_i32(loc_4, 16)
						if loc_4 ~= loc_8 then continue end
						break
					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
			)
			while true do
				loc_2 = (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 continue 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
				while true do
					while true do
						loc_0 = load_i32(memory_at_0, loc_3)
						while true do
							loc_2 = (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 continue end
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = add_i32(loc_3, 4)
						if loc_3 ~= loc_4 then continue end
						break
					end
					break
				end
			end
			loc_0 = load_i32(memory_at_0, add_i32(loc_7, mul_i32(param_2, 48)) + 20)
			while true do
				loc_2 = (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 continue end
				break
			end
			loc_0 = load_i32(memory_at_0, add_i32(loc_7, mul_i32(param_2, 48)) + 16)
			while true do
				loc_2 = (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 continue end
				break
			end
			while true do
				while true do
					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 break end
					while true do
						if load_i32(memory_at_0, loc_0) ~= 0 then
							while true do
								loc_0 = add_i32(loc_0, 4)
								if loc_2 ~= loc_0 then
									desired = 3
									break
								end
								desired = 2
								break
							end
							if desired then
								if desired == 3 then
									desired = nil
									continue
								end
								break
							end
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil 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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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)
				break
			end
			while true do
				while true do
					if load_i32(memory_at_0, param_0 + 316) ==
						load_i32(memory_at_0, param_0 + 320) then
						while true do
							if load_i32(memory_at_0, param_0 + 328) ==
								load_i32(memory_at_0, param_0 + 332) then
								desired = 2
								break
							end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						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
					)
					while true do
						loc_2 = (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 continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil 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
						while true do
							while true do
								loc_0 = load_i32(memory_at_0, loc_3)
								while true do
									loc_2 = (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 continue end
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
								loc_0 = load_i32(memory_at_0, loc_3 + 8)
								while true do
									loc_2 = (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 continue end
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
								loc_0 = load_i32(memory_at_0, loc_3 + 12)
								while true do
									loc_2 = (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 continue end
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									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 continue end
								break
							end
							if desired then break end
							break
						end
						if desired then
							if desired == 2 then desired = nil 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
					)
					while true do
						loc_2 = (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 continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil 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
						desired = 1
						break
					end
					while true do
						loc_0 = load_i32(memory_at_0, loc_3)
						while true do
							loc_2 = (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 continue end
							break
						end
						if desired then
							if desired == 3 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = add_i32(loc_3, 4)
						if loc_3 ~= param_0 then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil 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)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_1, 16)
			break
		end
	end
FUNC_LIST[91] = --[[ Luau::getOpLength(LuauOpcode) ]] function(param_0)
	local loc_0 = 0
	local reg_0
	local desired
	local br_map = {}
	while true do
		loc_0 = 2
		while true do
			while true do
				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
				local temp = br_map[1][sub_i32(param_0, 7)] or 0
				if temp < 1 then
					break
				else
					desired = 1
					break
				end
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			loc_0 = 1
			break
		end
		reg_0 = loc_0
		break
	end
	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
		local desired
		while true do
			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
				while true do
					while true do
						while true do
							loc_4 = loc_6
							loc_6 = add_i32(loc_4, loc_9)
							if loc_4 >= loc_6 then
								while true do
									loc_1 = (loc_2 > loc_4 and 1 or 0)
									loc_0 = loc_4
									desired = 3
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							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
							while true do
								loc_0 = add_i32(loc_0, 1)
								loc_1 = (loc_0 < loc_2 and 1 or 0)
								if loc_0 >= loc_2 then
									desired = 3
									break
								end
								if loc_0 >= loc_6 then
									desired = 3
									break
								end
								loc_1 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_0, 2)))
								loc_5 = (lt_i32(loc_1, loc_5) and loc_5 or loc_1)
								loc_7 = (lt_i32(loc_1, loc_7) and loc_1 or loc_7)
								if lt_i32(sub_i32(loc_5, loc_7), 256) then continue end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							loc_1 = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						while true do
							if loc_1 == 0 then break end
							loc_1 = 0
							loc_5 = sub_i32(loc_0, loc_4)
							if loc_5 >= loc_9 then break end
							while true do
								loc_0 = loc_1
								loc_1 = add_i32(loc_0, 1)
								if le_i32(shl_i32(2, loc_0), loc_5) then continue end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							loc_9 = shl_i32(1, loc_0)
							loc_6 = add_i32(loc_9, loc_4)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						if loc_2 > loc_6 then continue end
						break
					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, i64_ZERO)
			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 loc_11 > 1 then
				while true do
					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)
					break
				end
			end
			if loc_8 ~= loc_10 then
				while true do
					while true do
						loc_6 = loc_7
						loc_1 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_6, 2)))
						while true do
							loc_7 = add_i32(loc_6, loc_9)
							if loc_6 >= loc_7 then break end
							loc_0 = add_i32(loc_6, 1)
							if loc_0 >= loc_2 then break end
							if loc_0 >= loc_7 then break end
							while true do
								loc_5 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_0, 2)))
								loc_1 = (gt_i32(loc_1, loc_5) and loc_5 or loc_1)
								loc_0 = add_i32(loc_0, 1)
								if loc_0 >= loc_2 then
									desired = 3
									break
								end
								if loc_0 < loc_7 then continue end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						store_i32(
							memory_at_0, add_i32(loc_4, shl_i32(div_u32(loc_6, loc_9), 2)), loc_1
						)
						if loc_2 > loc_7 then continue end
						break
					end
					break
				end
			end
			loc_1 = 0
			while true do
				loc_0 = loc_1
				loc_1 = add_i32(loc_0, 1)
				if le_i32(shl_i32(2, loc_0), loc_9) then continue 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
				while true do
					loc_1 = 0
					loc_5 = 0
					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 loc_1 < shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 36), loc_2), 2) then
							continue
						end
						break
					end
					break
				end
			end
			if loc_11 ~= 0 then
				while true do
					loc_0 = 0
					loc_1 = 0
					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 continue end
						break
					end
					break
				end
			end
			loc_0 = load_i32(memory_at_0, loc_3 + 8)
			if loc_0 ~= 0 then
				while true do
					store_i32(memory_at_0, loc_3 + 12, loc_0)
					FUNC_LIST[1276](loc_0)
					break
				end
			end
			GLOBAL_LIST[0].value = add_i32(loc_3, 32)
			break
		end
	end
FUNC_LIST[93] = --[[ Luau::BytecodeBuilder::setMainFunction(unsigned int) ]]
	function(param_0, param_1)
		while true do
			store_i32(memory_at_0, param_0 + 16, param_1)
			break
		end
	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 = i64_ZERO
		local loc_8 = i64_ZERO
		local loc_9 = 0
		local loc_10 = i64_ZERO
		local reg_0
		local desired
		while true do
			loc_6 = add_i32(param_0, 96)
			while true do
				while true do
					while true do
						while true do
							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 break 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), (eq_i64(loc_10, loc_7) and 1 or 0)
							) ~= 0 then break end
							loc_0 = bxor_i32(
								wrap_i32_i64(shr_u64(loc_7, i64_from_u32(32, 0))),
									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
							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), (eq_i64(loc_7, loc_8) and 1 or 0)
								) ~= 0 then
									desired = 3
									break
								end
								if band_i32(
									(loc_0 == loc_9 and 1 or 0), (eq_i64(loc_8, loc_10) and 1 or 0)
								) ~= 0 then
									desired = 4
									break
								end
								loc_3 = add_i32(loc_3, 1)
								loc_0 = add_i32(loc_3, loc_5)
								if loc_1 >= loc_3 then continue end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_3 = 4294967295
						while true do
							loc_0 = sub_i32(
								load_i32(memory_at_0, param_0 + 48), load_i32(memory_at_0, param_0 + 44)
							)
							if loc_0 > 134217712 then break 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
								while true do
									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
									desired = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 loc_5 >= 268435456 then
								desired = 2
								break
							end
							loc_2 = shr_i32(loc_1, 3)
							loc_2 = (loc_1 < 2147483632 and (loc_2 > loc_5 and loc_2 or loc_5) or
								        268435455)
							if loc_2 ~= 0 then
								while true do
									if loc_2 >= 268435456 then
										desired = 1
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 4))
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 gt_i32(loc_1, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](loc_5, param_0, loc_1)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 break end
							FUNC_LIST[1276](param_0)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						reg_0 = loc_3
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					reg_0 = load_i32(memory_at_0, add_i32(loc_2, mul_i32(loc_5, 24)) + 16)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[96](loc_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
		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 = i64_ZERO
		local loc_5 = i64_ZERO
		local loc_6 = 0
		local loc_7 = i64_ZERO
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local reg_0
		local desired
		while true do
			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 load_i32(memory_at_0, param_0 + 12) >= shr_u32(mul_i32(loc_1, 3), 2) then
				while true do
					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)
					break
				end
			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, i64_from_u32(32, 0))),
					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
			while true do
				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)
					while true do
						loc_10 = load_i32(memory_at_0, loc_0)
						if loc_10 ~= loc_8 then break end
						if ne_i64(loc_5, loc_7) then break 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)
						)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					if band_i32((loc_6 == loc_10 and 1 or 0), (eq_i64(loc_4, loc_5) and 1 or 0)) ~=
						0 then
						desired = 1
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_0 = add_i32(loc_1, loc_9)
					if loc_1 <= loc_2 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_0 = 0
				break
			end
			reg_0 = add_i32(loc_0, 16)
			break
		end
		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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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 = i64_ZERO
		local loc_6 = i64_ZERO
		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 = i64_ZERO
		local reg_0, reg_1
		local desired
		while true do
			loc_0 = add_i32(GLOBAL_LIST[0].value, 4294967232)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						reg_0 = loc_0
						while true do
							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
								while true do
									if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 24) > 15 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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)
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							while true do
								loc_3 = loc_1
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						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)
							while true do
								loc_9 = load_i32(memory_at_0, loc_8)
								if loc_9 == load_i32(memory_at_0, param_0 + 16) then
									while true do
										if eq_i64(loc_5, load_i64(memory_at_0, param_0 + 24)) then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									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, i64_from_u32(32, 0))),
										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)
								while true do
									while true do
										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), (eq_i64(loc_15, loc_6) and 1 or 0)
										) ~= 0 then break end
										loc_4 = 0
										if band_i32(
											(loc_9 == loc_11 and 1 or 0), (eq_i64(loc_5, loc_6) and 1 or 0)
										) ~= 0 then
											desired = 6
											break
										end
										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), (eq_i64(loc_6, loc_15) and 1 or 0)
											) ~= 0 then
												desired = 7
												break
											end
											if loc_9 ~= loc_11 then continue end
											if ne_i64(loc_5, loc_6) then continue end
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										desired = 6
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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)
								break
							end
							if desired then
								if desired == 4 then
									desired = nil
									continue
								end
								break
							end
							loc_7 = add_i32(loc_7, 1)
							if loc_7 < div_i32(sub_i32(loc_1, loc_3), 24) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_3)
				FUNC_LIST[1276](loc_3)
				break
			end
			GLOBAL_LIST[0].value = sub_i32(loc_0, 4294967232)
			break
		end
	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 = i64_ZERO
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 12) > 15 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							while true do
								loc_1 = loc_5
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						while true do
							loc_3 = load_i32(memory_at_0, loc_6)
							while true do
								while true do
									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
										while true do
											if loc_3 == 0 then
												desired = 6
												break
											end
											loc_10 = load_i32(memory_at_0, loc_7 + 4)
											if loc_10 ~= load_i32(memory_at_0, param_0 + 20) then
												desired = 6
												break
											end
											reg_0 = FUNC_LIST[1171](loc_9, loc_3, loc_10)
											if reg_0 == 0 then
												desired = 5
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									if loc_3 == 0 then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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)
								break
							end
							if desired then
								if desired == 4 then
									desired = nil
									continue
								end
								break
							end
							loc_2 = add_i32(loc_2, 1)
							if loc_2 < div_i32(sub_i32(loc_5, loc_1), 12) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_1)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			break
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						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
								while true do
									while true do
										if loc_3 == 0 then break end
										if load_i32(memory_at_0, loc_0 + 4) ~= loc_6 then break end
										reg_0 = FUNC_LIST[1171](loc_8, loc_3, loc_6)
										if reg_0 == 0 then
											desired = 1
											break
										end
										break
									end
									if desired then break end
									if loc_2 == 0 then
										desired = 4
										break
									end
									if load_i32(memory_at_0, loc_0 + 4) ~= loc_7 then
										desired = 4
										break
									end
									reg_0 = FUNC_LIST[1171](loc_8, loc_2, loc_7)
									if reg_0 ~= 0 then
										desired = 4
										break
									end
									desired = 2
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							if loc_3 == 0 then
								desired = 1
								break
							end
							if loc_2 == 0 then
								desired = 2
								break
							end
							break
						end
						if desired then
							if desired == 3 then
								desired = nil
								continue
							end
							break
						end
						loc_4 = add_i32(loc_4, 1)
						loc_1 = add_i32(loc_4, loc_1)
						if loc_4 <= loc_5 then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_0 = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				reg_0 = loc_0
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			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
			break
		end
		return reg_0
	end
FUNC_LIST[100] = --[[ Luau::BytecodeBuilder::addConstantNil() ]] function(
	param_0
)
	local loc_0 = 0
	local reg_0
	while true do
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_0
		store_i64(memory_at_0, loc_0 + 24, i64_ZERO)
		store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
		store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
		store_i64(memory_at_0, loc_0, i64_ZERO)
		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
		break
	end
	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
		while true do
			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
			break
		end
		return reg_0
	end
FUNC_LIST[102] = --[[ Luau::BytecodeBuilder::addConstantNumber(double) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local reg_0
		while true do
			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, i64_from_u32(2, 0))
			store_f64(memory_at_0, loc_0 + 8, param_1)
			store_i64(memory_at_0, loc_0, i64_from_u32(2, 0))
			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
			break
		end
		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
		while true do
			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 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
				while true do
					FUNC_LIST[98](loc_1)
					break
				end
			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
				while true do
					param_1 = load_i32(memory_at_0, loc_1 + 12)
					store_i32(memory_at_0, loc_2 + 8, param_1)
					break
				end
			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
			break
		end
		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
		while true do
			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
			break
		end
		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
		local desired
		while true do
			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
				while true do
					reg_0 = load_i32(memory_at_0, loc_5 + 132)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			loc_5 = 4294967295
			while true do
				while true do
					while true do
						while true do
							while true do
								loc_0 = sub_i32(
									load_i32(memory_at_0, param_0 + 48),
										load_i32(memory_at_0, param_0 + 44)
								)
								if loc_0 > 134217712 then break 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 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
									while true do
										FUNC_LIST[107](loc_1)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								reg_0 = FUNC_LIST[108](loc_1, param_1)
								store_i32(memory_at_0, reg_0 + 132, loc_5)
								while true do
									loc_1 = load_i32(memory_at_0, loc_0 + 4)
									if loc_1 ~= load_i32(memory_at_0, loc_0 + 8) then
										while true do
											reg_1 = FUNC_LIST[1119](loc_1, param_1, 132)
											store_i32(memory_at_0, loc_0 + 4, add_i32(reg_1, 132))
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 loc_2 >= 32537632 then
										desired = 4
										break
									end
									loc_7 = shl_i32(loc_1, 1)
									loc_2 = (loc_1 < 16268815 and (loc_2 < loc_7 and loc_7 or loc_2) or
										        32537631)
									if loc_2 ~= 0 then
										while true do
											if loc_2 >= 32537632 then
												desired = 3
												break
											end
											reg_0 = FUNC_LIST[1275](mul_i32(loc_2, 132))
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									else
										while true do
											reg_0 = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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, 4294967164), 132))
									loc_2 = add_i32(loc_7, mul_i32(loc_2, 132))
									loc_1 = add_i32(loc_1, 132)
									if gt_i32(loc_4, 0) then
										while true do
											reg_0 = FUNC_LIST[1119](param_1, loc_3, loc_4)
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 break end
									FUNC_LIST[1276](loc_3)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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
									while true do
										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, i64_from_u32(5, 0))
										store_i32(memory_at_0, param_0 + 4, add_i32(param_1, 16))
										reg_0 = loc_5
										desired = 0
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 loc_0 >= 268435456 then
									desired = 2
									break
								end
								param_1 = 0
								loc_3 = shr_i32(loc_1, 3)
								loc_3 = (loc_1 < 2147483632 and (loc_0 < loc_3 and loc_3 or loc_0) or
									        268435455)
								if loc_3 ~= 0 then
									while true do
										if loc_3 >= 268435456 then
											desired = 1
											break
										end
										reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 4))
										param_1 = reg_0
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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, i64_from_u32(5, 0))
								loc_6 = add_i32(param_1, shl_i32(loc_3, 4))
								loc_0 = add_i32(loc_0, 16)
								if gt_i32(loc_1, 0) then
									while true do
										reg_0 = FUNC_LIST[1119](param_1, loc_4, loc_1)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 break end
								FUNC_LIST[1276](loc_4)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							reg_0 = loc_5
							desired = 0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						FUNC_LIST[109](loc_0)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[252](5133)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[96](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
		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
		local desired
		while true do
			while true do
				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 break 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
					while true do
						reg_0 = FUNC_LIST[1171](param_1, loc_8, shl_i32(loc_2, 2))
						if reg_0 == 0 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				loc_10 = div_i32(sub_i32(loc_1, loc_7), 136)
				while true do
					if loc_2 == 0 then
						while true do
							loc_0 = 2166136261
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					loc_3 = band_i32(loc_2, 3)
					while true do
						if sub_i32(loc_2, 1) < 3 then
							while true do
								loc_0 = 2166136261
								param_0 = 0
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						loc_6 = band_i32(loc_2, 4294967292)
						loc_0 = 2166136261
						param_0 = 0
						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 continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					if loc_3 == 0 then break end
					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 continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_1 = sub_i32(loc_10, 1)
				loc_6 = shl_i32(loc_9, 2)
				loc_3 = shl_i32(loc_2, 2)
				param_0 = 0
				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
						while true do
							reg_0 = FUNC_LIST[1171](loc_0, param_1, loc_3)
							if reg_0 == 0 then
								desired = 1
								break
							end
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					while true do
						if loc_4 == loc_9 then
							while true do
								reg_0 = FUNC_LIST[1171](loc_0, loc_8, loc_6)
								if reg_0 == 0 then
									desired = 3
									break
								end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						param_0 = add_i32(param_0, 1)
						loc_0 = add_i32(param_0, loc_5)
						if param_0 <= loc_1 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_0 = 0
				break
			end
			reg_0 = loc_0
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 288)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_2), 136) >
										15 then
										desired = 3
										break
									end
									reg_0 = 16
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							reg_0 = shl_i32(div_i32(sub_i32(loc_1, loc_2), 136), 1)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_1 = reg_0
						store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
						store_i64(memory_at_0, loc_0, i64_ZERO)
						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
							while true do
								loc_1 = loc_3
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						while true do
							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
									while true do
										reg_0 = FUNC_LIST[1171](loc_5, loc_4, shl_i32(loc_7, 2))
										if reg_0 == 0 then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									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)
								break
							end
							if desired then
								if desired == 4 then
									desired = nil
									continue
								end
								break
							end
							loc_2 = add_i32(loc_2, 1)
							if loc_2 < div_i32(sub_i32(loc_3, loc_1), 136) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_1)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 288)
			break
		end
	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
		local desired
		while true do
			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)
			while true do
				loc_3 = load_i32(memory_at_0, param_1 + 128)
				if loc_3 == 0 then
					while true do
						loc_0 = 2166136261
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				loc_4 = band_i32(loc_3, 3)
				while true do
					if sub_i32(loc_3, 1) < 3 then
						while true do
							loc_0 = 2166136261
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					loc_8 = band_i32(loc_3, 4294967292)
					loc_0 = 2166136261
					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 continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if loc_4 == 0 then break end
				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 continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			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
			while true do
				while true do
					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 break end
						reg_0 = FUNC_LIST[1171](loc_0, loc_8, loc_7)
						if reg_0 ~= 0 then break 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
						desired = 0
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					if loc_3 == loc_5 then
						while true do
							reg_0 = FUNC_LIST[1171](loc_0, param_1, loc_10)
							if reg_0 == 0 then
								desired = 1
								break
							end
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					loc_1 = add_i32(loc_1, 1)
					loc_0 = add_i32(loc_1, loc_6)
					if loc_1 <= loc_2 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_0 = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			reg_0 = loc_0
			break
		end
		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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		while true do
			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
			break
		end
		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
		local desired
		while true do
			loc_5 = add_i32(param_0, 288)
			while true do
				while true do
					while true do
						while true do
							while true do
								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 break end
								loc_8 = load_i32(memory_at_0, loc_5 + 16)
								if loc_8 == param_1 then break end
								loc_3 = sub_i32(shr_i32(sub_i32(loc_4, loc_2), 3), 1)
								loc_1 = param_1
								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
										desired = 4
										break
									end
									if loc_6 == loc_8 then
										desired = 5
										break
									end
									loc_0 = add_i32(loc_0, 1)
									loc_1 = add_i32(loc_0, loc_1)
									if loc_0 <= loc_3 then continue end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_7 = 65535
							loc_0 = sub_i32(
								load_i32(memory_at_0, param_0 + 60), load_i32(memory_at_0, param_0 + 56)
							)
							if loc_0 > 131068 then
								desired = 1
								break
							end
							loc_3 = shr_i32(sub_i32(loc_4, loc_2), 3)
							if load_i32(memory_at_0, loc_5 + 12) >= shr_u32(mul_i32(loc_3, 3), 2) then
								while true do
									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)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_4 = add_i32(param_0, 56)
							loc_7 = shr_u32(loc_0, 2)
							while true do
								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
									while true do
										loc_1 = 0
										while true do
											if param_1 == loc_3 then
												desired = 5
												break
											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 continue end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 5 then desired = nil 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)
								)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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
								while true do
									store_i32(memory_at_0, loc_0, param_1)
									store_i32(memory_at_0, loc_4 + 4, add_i32(loc_0, 4))
									desired = 1
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 loc_2 >= 1073741824 then
								desired = 3
								break
							end
							loc_1 = shr_i32(loc_0, 1)
							loc_1 = (loc_0 < 2147483644 and (loc_1 > loc_2 and loc_1 or loc_2) or
								        1073741823)
							if loc_1 ~= 0 then
								while true do
									if loc_1 >= 1073741824 then
										desired = 2
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 gt_i32(loc_0, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](loc_2, loc_3, loc_0)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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
								desired = 1
								break
							end
							FUNC_LIST[1276](loc_3)
							desired = 1
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_7 = load_i32_u16(memory_at_0, add_i32(loc_2, shl_i32(loc_1, 3)) + 4)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[113](loc_4)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[252](5133)
				error("out of code bounds")
			end
			reg_0 = shr_i32(shl_i32(loc_7, 16), 16)
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 32)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1) > 127 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							store_i64(memory_at_0, loc_0, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							while true do
								loc_10 = load_i32(memory_at_0, loc_0 + 4)
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						loc_1 = shr_i32(sub_i32(loc_1, loc_3), 3)
						loc_14 = (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)
						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
								while true do
									while true do
										while true do
											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 break end
											loc_4 = 0
											if loc_2 == loc_8 then
												desired = 6
												break
											end
											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
													desired = 7
													break
												end
												if loc_2 ~= loc_8 then continue end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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)
										break
									end
									if desired then break end
									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)
									)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_5 = add_i32(loc_5, 1)
							if loc_14 ~= loc_5 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 4, loc_3)
				FUNC_LIST[1276](loc_3)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 32)
			break
		end
	end
FUNC_LIST[113] = --[[ std::__2::__vector_base<unsigned int, std::__2::allocator<unsigned int> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								param_1 = load_i32(memory_at_0, param_0 + 24)
								if param_1 ~= load_i32(memory_at_0, param_0 + 28) then
									while true do
										store_i32(memory_at_0, param_1, param_2)
										store_i32(memory_at_0, param_4 + 4, add_i32(param_1, 4))
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 param_3 >= 1073741824 then
									desired = 4
									break
								end
								loc_1 = shr_i32(param_1, 1)
								loc_1 =
									(param_1 < 2147483644 and (param_3 < loc_1 and loc_1 or param_3) or
										1073741823)
								if loc_1 ~= 0 then
									while true do
										if loc_1 >= 1073741824 then
											desired = 3
											break
										end
										reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								else
									while true do
										reg_0 = 0
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 gt_i32(param_1, 0) then
									while true do
										reg_0 = FUNC_LIST[1119](param_3, loc_0, param_1)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 break end
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							param_4 = load_i32(memory_at_0, param_0 + 36)
							if param_4 ~= load_i32(memory_at_0, param_0 + 40) then
								while true do
									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))
									desired = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 param_1 >= 1073741824 then
								desired = 2
								break
							end
							loc_0 = shr_i32(param_4, 1)
							loc_0 =
								(param_4 < 2147483644 and (param_1 < loc_0 and loc_0 or param_1) or
									1073741823)
							if loc_0 ~= 0 then
								while true do
									if loc_0 >= 1073741824 then
										desired = 1
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 2))
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 gt_i32(param_4, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](param_1, param_3, param_4)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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
								while true do
									FUNC_LIST[1276](param_3)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							desired = 0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						FUNC_LIST[113](param_4)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[252](5133)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[115](param_2)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	end
FUNC_LIST[115] = --[[ std::__2::__vector_base<int, std::__2::allocator<int> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								param_2 = load_i32(memory_at_0, param_0 + 24)
								if param_2 ~= load_i32(memory_at_0, param_0 + 28) then
									while true do
										store_i32(memory_at_0, param_2, param_3)
										store_i32(memory_at_0, param_1 + 4, add_i32(param_2, 4))
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 loc_2 >= 1073741824 then
									desired = 4
									break
								end
								loc_1 = shr_i32(param_2, 1)
								loc_1 = (param_2 < 2147483644 and (loc_1 > loc_2 and loc_1 or loc_2) or
									        1073741823)
								if loc_1 ~= 0 then
									while true do
										if loc_1 >= 1073741824 then
											desired = 3
											break
										end
										reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								else
									while true do
										reg_0 = 0
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 gt_i32(param_2, 0) then
									while true do
										reg_0 = FUNC_LIST[1119](loc_2, loc_0, param_2)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 break end
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							param_1 = load_i32(memory_at_0, param_0 + 36)
							if param_1 ~= load_i32(memory_at_0, param_0 + 40) then
								while true do
									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))
									desired = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 param_2 >= 1073741824 then
								desired = 2
								break
							end
							loc_0 = shr_i32(param_1, 1)
							loc_0 =
								(param_1 < 2147483644 and (param_2 < loc_0 and loc_0 or param_2) or
									1073741823)
							if loc_0 ~= 0 then
								while true do
									if loc_0 >= 1073741824 then
										desired = 1
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 2))
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 gt_i32(param_1, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](param_2, loc_2, param_1)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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
								while true do
									FUNC_LIST[1276](loc_2)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							desired = 0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						FUNC_LIST[113](param_1)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[252](5133)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[115](param_3)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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
	local desired
	while true do
		loc_0 = add_i32(param_0, 20)
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_1 = load_i32(memory_at_0, param_0 + 24)
							if loc_1 ~= load_i32(memory_at_0, param_0 + 28) then
								while true do
									store_i32(memory_at_0, loc_1, param_1)
									store_i32(memory_at_0, loc_0 + 4, add_i32(loc_1, 4))
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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 loc_4 >= 1073741824 then
								desired = 4
								break
							end
							loc_3 = shr_i32(loc_1, 1)
							loc_3 = (loc_1 < 2147483644 and (loc_3 > loc_4 and loc_3 or loc_4) or
								        1073741823)
							if loc_3 ~= 0 then
								while true do
									if loc_3 >= 1073741824 then
										desired = 3
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 2))
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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 gt_i32(loc_1, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](loc_4, loc_2, loc_1)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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 break end
							FUNC_LIST[1276](loc_2)
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						loc_0 = load_i32(memory_at_0, param_0 + 36)
						if loc_0 ~= load_i32(memory_at_0, param_0 + 40) then
							while true do
								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))
								desired = 0
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						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 loc_1 >= 1073741824 then
							desired = 2
							break
						end
						loc_2 = shr_i32(loc_0, 1)
						loc_2 = (loc_0 < 2147483644 and (loc_1 < loc_2 and loc_2 or loc_1) or
							        1073741823)
						if loc_2 ~= 0 then
							while true do
								if loc_2 >= 1073741824 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 2))
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_4, loc_0)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						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
							while true do
								FUNC_LIST[1276](loc_4)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					FUNC_LIST[113](loc_0)
					error("out of code bounds")
				end
				if desired then
					if desired == 2 then desired = nil end
					break
				end
				FUNC_LIST[252](5133)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			FUNC_LIST[115](param_1)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then desired = nil end
			break
		end
		FUNC_LIST[252](5133)
		error("out of code bounds")
	end
end
FUNC_LIST[118] = --[[ Luau::BytecodeBuilder::emitLabel() ]] function(param_0)
	local reg_0
	while true do
		reg_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
			), 2
		)
		break
	end
	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
		local desired
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_1 = add_i32(bxor_i32(param_1, 4294967295), param_2)
							if add_i32(loc_1, 32768) <= 65535 then
								while true do
									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))
									)
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_2 = shr_i32(loc_1, 31)
							if sub_i32(bxor_i32(loc_1, loc_2), loc_2) > 8388607 then
								desired = 3
								break
							end
							store_i32_n8(memory_at_0, param_0 + 92, 1)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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 loc_0 < param_0 then
							while true do
								store_i64(
									memory_at_0, loc_0, bor_i64(
										extend_i64_u32(param_1),
											shl_i64(extend_i64_u32(param_2), i64_from_u32(32, 0))
									)
								)
								store_i32(memory_at_0, loc_1 + 4, add_i32(loc_0, 8))
								reg_0 = 1
								desired = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 loc_0 >= 536870912 then
							desired = 2
							break
						end
						param_0 = sub_i32(param_0, loc_2)
						loc_5 = shr_i32(param_0, 2)
						loc_0 = (param_0 < 2147483640 and (loc_0 < loc_5 and loc_5 or loc_0) or
							        536870911)
						if loc_0 ~= 0 then
							while true do
								if loc_0 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 3))
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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), i64_from_u32(32, 0))
							)
						)
						param_1 = add_i32(param_0, shl_i32(loc_0, 3))
						param_2 = add_i32(loc_3, 8)
						loc_0 = 1
						if gt_i32(loc_4, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_0, loc_2, loc_4)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 break end
						FUNC_LIST[1276](loc_2)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					reg_0 = loc_0
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[120](loc_1)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
		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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	end
FUNC_LIST[121] = --[[ Luau::BytecodeBuilder::patchSkipC(unsigned long, unsigned long) ]]
	function(param_0, param_1, param_2)
		local reg_0
		while true do
			param_2 = add_i32(bxor_i32(param_1, 4294967295), param_2)
			if param_2 <= 255 then
				while true do
					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))
					)
					break
				end
			end
			reg_0 = (param_2 < 256 and 1 or 0)
			break
		end
		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 = i64_ZERO
		local loc_4 = i64_ZERO
		local reg_0
		local desired
		while true do
			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 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
				while true do
					FUNC_LIST[98](param_1)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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
				while true do
					loc_1 = load_i32(memory_at_0, param_1 + 12)
					store_i32(memory_at_0, loc_2 + 8, loc_1)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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
			)
			while true do
				if bor_i32(
					load_i32(memory_at_0, param_0 + 424),
						band_i32(load_i32(memory_at_0, param_0 + 428), 1)
				) ~= 0 then
					while true do
						loc_4 = shr_u64(loc_3, i64_from_u32(32, 0))
						param_1 = wrap_i32_i64(loc_4)
						if param_1 >= 4294967280 then
							desired = 1
							break
						end
						while true do
							while true do
								if param_1 >= 11 then
									while true do
										loc_2 = band_i32(add_i32(param_1, 16), 4294967280)
										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)
										desired = 4
										break
									end
									if desired then
										if desired == 4 then desired = nil end
										break
									end
								end
								store_i64_n8(memory_at_0, loc_0 + 11, loc_4)
								loc_1 = loc_0
								if param_1 == 0 then
									desired = 3
									break
								end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							reg_0 = FUNC_LIST[1119](loc_1, wrap_i32_i64(loc_3), param_1)
							break
						end
						if desired then break end
						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 lt_i32(load_i32_i8(memory_at_0, param_1 + 47), 0) then
							while true do
								FUNC_LIST[1276](load_i32(memory_at_0, param_0))
								break
							end
							if desired then break end
						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))
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				GLOBAL_LIST[0].value = add_i32(loc_0, 16)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[38](loc_0)
			error("out of code bounds")
		end
	end
FUNC_LIST[123] = --[[ Luau::BytecodeBuilder::setDebugFunctionLineDefined(int) ]]
	function(param_0, param_1)
		while true do
			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
			)
			break
		end
	end
FUNC_LIST[124] = --[[ Luau::BytecodeBuilder::setDebugLine(int) ]] function(
	param_0, param_1
)
	while true do
		store_i32(memory_at_0, param_0 + 312, param_1)
		break
	end
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
		local desired
		while true do
			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 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
				while true do
					FUNC_LIST[98](param_1)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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
				while true do
					loc_1 = load_i32(memory_at_0, param_1 + 12)
					store_i32(memory_at_0, loc_0 + 8, loc_1)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			loc_0 = add_i32(param_0, 316)
			while true do
				while true do
					while true do
						param_1 = load_i32(memory_at_0, param_0 + 320)
						if param_1 ~= load_i32(memory_at_0, param_0 + 324) then
							while true do
								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))
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 param_0 >= 268435456 then
							desired = 2
							break
						end
						loc_2 = shr_i32(param_1, 3)
						loc_5 =
							(param_1 < 2147483632 and (param_0 < loc_2 and loc_2 or param_0) or
								268435455)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 268435456 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 4))
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 gt_i32(param_1, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_2, loc_4, param_1)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 break end
						FUNC_LIST[1276](loc_4)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_3, 16)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[126](loc_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	end
FUNC_LIST[126] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::DebugLocal, std::__2::allocator<Luau::BytecodeBuilder::DebugLocal> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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 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
				while true do
					FUNC_LIST[98](param_1)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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
				while true do
					loc_2 = load_i32(memory_at_0, param_1 + 12)
					store_i32(memory_at_0, loc_0 + 8, loc_2)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			param_1 = add_i32(param_0, 328)
			while true do
				while true do
					while true do
						loc_0 = load_i32(memory_at_0, param_0 + 332)
						if loc_0 ~= load_i32(memory_at_0, param_0 + 336) then
							while true do
								store_i32(memory_at_0, loc_0, loc_2)
								store_i32(memory_at_0, param_1 + 4, add_i32(loc_0, 4))
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 loc_0 >= 1073741824 then
							desired = 2
							break
						end
						loc_1 = shr_i32(param_0, 1)
						loc_1 = (param_0 < 2147483644 and (loc_0 < loc_1 and loc_1 or loc_0) or
							        1073741823)
						if loc_1 ~= 0 then
							while true do
								if loc_1 >= 1073741824 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 gt_i32(param_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_0, loc_4, param_0)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 break end
						FUNC_LIST[1276](loc_4)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_3, 16)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[128](param_1)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	end
FUNC_LIST[128] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::DebugUpval, std::__2::allocator<Luau::BytecodeBuilder::DebugUpval> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	end
FUNC_LIST[129] = --[[ Luau::BytecodeBuilder::getDebugPC() const ]] function(
	param_0
)
	local reg_0
	while true do
		reg_0 = shr_i32(
			sub_i32(
				load_i32(memory_at_0, param_0 + 24), load_i32(memory_at_0, param_0 + 20)
			), 2
		)
		break
	end
	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
		local desired
		while true do
			loc_4 = sub_i32(GLOBAL_LIST[0].value, 16)
			GLOBAL_LIST[0].value = loc_4
			while true do
				while true do
					while true do
						if band_i32(load_i32_u8(memory_at_0, param_0 + 408), 16) == 0 then
							break
						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 = (lt_i32(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 param_1 < param_0 then
							while true do
								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))
								desired = 3
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 param_1 >= 536870912 then
							desired = 2
							break
						end
						param_0 = sub_i32(param_0, loc_0)
						loc_6 = shr_i32(param_0, 2)
						param_1 =
							(param_0 < 2147483640 and (param_1 < loc_6 and loc_6 or param_1) or
								536870911)
						if param_1 ~= 0 then
							while true do
								if param_1 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(param_1, 3))
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 gt_i32(loc_5, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_0, loc_0, loc_5)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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 break end
						FUNC_LIST[1276](loc_0)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_4, 16)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[131](param_2)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
	local desired
	while true do
		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)
		while true do
			if loc_0 == loc_2 then
				while true do
					loc_0 = 0
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
			end
			loc_8 = (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
			while true do
				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
						while true do
							if loc_1 == 0 then
								desired = 1
								break
							end
							if load_i32(memory_at_0, loc_3 + 4) ~= loc_7 then
								desired = 1
								break
							end
							reg_0 = FUNC_LIST[1171](loc_4, loc_1, loc_7)
							if reg_0 == 0 then
								desired = 3
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
					end
					if loc_1 ~= 0 then
						desired = 1
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_0 = add_i32(loc_0, 1)
				if loc_0 ~= loc_8 then continue end
				break
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			loc_0 = loc_8
			break
		end
		loc_1 = 16
		while true do
			if loc_0 == loc_5 then break end
			loc_3 = load_i32(memory_at_0, param_0 + 356)
			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
				)
				while true do
					loc_0 = add_i32(loc_0, 1)
					if loc_0 >= loc_5 then break end
					while true do
						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
								while true do
									if loc_3 == 0 then
										desired = 3
										break
									end
									loc_4 = load_i32(memory_at_0, loc_4 + 4)
									if loc_4 ~= load_i32(memory_at_0, param_0 + 360) then
										desired = 3
										break
									end
									reg_0 = FUNC_LIST[1171](loc_7, loc_3, loc_4)
									if reg_0 ~= 0 then
										desired = 3
										break
									end
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							end
							if loc_3 ~= 0 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_0 = add_i32(loc_0, 1)
						if loc_5 ~= loc_0 then continue end
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_0 ~= loc_5 then continue end
				break
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			break
		end
		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
			while true do
				while true do
					loc_2 = load_i32_u8(memory_at_0, loc_0 + 11)
					loc_1 = add_i32(
						(lt_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 continue end
					break
				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
		)
		while true do
			loc_1 = (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 continue 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
			while true do
				while true do
					loc_1 = load_i32_u8(memory_at_0, loc_0 + 11)
					loc_3 = (lt_i32(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 continue end
					break
				end
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 16)
		while true do
			loc_1 = (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 continue end
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_6, 16)
		break
	end
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
		local desired
		while true do
			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, i64_ZERO)
			while true do
				while true do
					while true do
						if loc_1 ~= 0 then
							while true do
								if loc_1 >= 536870912 then
									desired = 3
									break
								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)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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)
						while true do
							if loc_1 == loc_6 then break end
							loc_8 = (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)
							while true do
								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
										while true do
											if loc_1 == 0 then
												desired = 4
												break
											end
											if load_i32(memory_at_0, loc_4 + 4) ~= loc_9 then
												desired = 4
												break
											end
											reg_0 = FUNC_LIST[1171](loc_10, loc_1, loc_9)
											if reg_0 == 0 then
												desired = 6
												break
											end
											desired = 4
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									if loc_1 ~= 0 then
										desired = 4
										break
									end
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								loc_0 = add_i32(loc_0, 1)
								if loc_0 ~= loc_8 then continue end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_0 = loc_8
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if loc_0 == loc_7 then
							desired = 1
							break
						end
						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)
							)
							while true do
								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 loc_0 >= loc_5 then break end
								loc_1 = load_i32(memory_at_0, param_0 + 356)
								while true do
									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
											while true do
												if loc_1 == 0 then
													desired = 5
													break
												end
												loc_4 = load_i32(memory_at_0, loc_4 + 4)
												if loc_4 ~= load_i32(memory_at_0, param_0 + 360) then
													desired = 5
													break
												end
												reg_0 = FUNC_LIST[1171](loc_3, loc_1, loc_4)
												if reg_0 == 0 then
													desired = 7
													break
												end
												desired = 5
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										end
										if loc_1 ~= 0 then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 6 then
											desired = nil
											continue
										end
										break
									end
									loc_0 = add_i32(loc_0, 1)
									if loc_0 ~= loc_5 then continue end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								loc_0 = loc_5
								break
							end
							if desired then
								if desired == 4 then
									desired = nil
									continue
								end
								break
							end
							if loc_0 == loc_7 then
								desired = 2
								break
							end
							loc_3 = load_i32(memory_at_0, loc_2)
							continue
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[134](loc_2)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_3 = load_i32(memory_at_0, loc_2)
				loc_5 = load_i32(memory_at_0, loc_2 + 4)
				break
			end
			loc_0 = shr_i32(sub_i32(loc_5, loc_3), 3)
			while true do
				loc_1 = (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 continue end
				break
			end
			if loc_3 ~= loc_5 then
				while true do
					loc_4 = loc_3
					while true do
						loc_0 = load_i32(memory_at_0, loc_4 + 4)
						while true do
							loc_1 = (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 continue end
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							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 continue end
						break
					end
					break
				end
			end
			if loc_3 ~= 0 then
				while true do
					FUNC_LIST[1276](loc_3)
					break
				end
			end
			GLOBAL_LIST[0].value = add_i32(loc_2, 16)
			break
		end
	end
FUNC_LIST[134] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::StringRef, std::__2::allocator<Luau::BytecodeBuilder::StringRef> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_1, loc_0), 2) then
				while true do
					if param_1 ~= 0 then
						while true do
							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)
							break
						end
						if desired then break end
					end
					store_i32(memory_at_0, param_0 + 4, loc_0)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_4 < 1073741824 then
					while true do
						loc_0 = 0
						loc_1 = sub_i32(loc_1, loc_2)
						loc_6 = shr_i32(loc_1, 1)
						loc_1 = (loc_1 < 2147483644 and (loc_4 < loc_6 and loc_6 or loc_4) or
							        1073741823)
						if loc_1 ~= 0 then
							while true do
								if loc_1 >= 1073741824 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
								loc_0 = reg_0
								break
							end
							if desired then break end
						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 gt_i32(loc_3, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_3)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[115](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	end
FUNC_LIST[136] = --[[ Luau::BytecodeBuilder::getImportId(int) ]] function(
	param_0
)
	local reg_0
	while true do
		reg_0 = bor_i32(shl_i32(param_0, 20), 1073741824)
		break
	end
	return reg_0
end
FUNC_LIST[137] = --[[ Luau::BytecodeBuilder::getImportId(int, int) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = bor_i32(
			bor_i32(shl_i32(param_0, 20), shl_i32(param_1, 10)), 2147483648
		)
		break
	end
	return reg_0
end
FUNC_LIST[138] = --[[ Luau::BytecodeBuilder::getImportId(int, int, int) ]]
	function(param_0, param_1, param_2)
		local reg_0
		while true do
			reg_0 = bor_i32(
				bor_i32(
					bor_i32(shl_i32(param_0, 20), shl_i32(param_1, 10)), param_2
				), 3221225472
			)
			break
		end
		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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			if loc_0 == 0 then
				while true do
					reg_0 = 0
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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
				while true do
					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
					)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			if loc_0 ~= 1 then
				while true do
					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 continue end
						break
					end
					if desired then break end
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			reg_0 = param_0
			break
		end
		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
	local desired
	while true do
		while true do
			if load_i32_u8(memory_at_0, param_0 + 92) ~= 0 then break 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 break end
			loc_3 = load_i32(memory_at_0, param_0 + 32)
			loc_2 = load_i32(memory_at_0, param_0 + 20)
			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, 2147483903) == 23 then
					while true do
						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, 2147483903) == 23 then continue end
							break
						end
						if desired then break end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
				end
				while true do
					while true do
						if band_i32(loc_6, 255) ~= 23 then break end
						if band_i32(loc_0, 255) ~= 22 then break 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)))
						)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					loc_0 = add_i32(param_0, bxor_i32(loc_4, 4294967295))
					if add_i32(loc_0, 32768) > 65535 then break end
					store_i32(
						memory_at_0, loc_5, bor_i32(band_i32(loc_6, 65535), shl_i32(loc_0, 16))
					)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				store_i32(memory_at_0, loc_1 + 4, param_0)
				loc_1 = add_i32(loc_1, 8)
				if loc_1 ~= loc_7 then continue end
				break
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			break
		end
		break
	end
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
	local desired
	while true do
		loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_0
		while true do
			if load_i32_u8(memory_at_0, param_0 + 92) == 0 then break 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, i64_ZERO)
			loc_1 = sub_i32(loc_5, loc_12)
			loc_3 = shr_i32(loc_1, 2)
			while true do
				while true do
					while true do
						if loc_5 == loc_12 then
							while true do
								store_i32(memory_at_0, loc_0 + 24, 0)
								store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
								store_i32(memory_at_0, loc_0 + 8, 0)
								store_i64(memory_at_0, loc_0, i64_ZERO)
								desired = 4
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						end
						if lt_i32(loc_1, 0) then
							desired = 3
							break
						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, i64_ZERO)
						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)
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						while true do
							loc_13 = (loc_5 == loc_12 and 1 or 0)
							if loc_13 ~= 0 then
								while true do
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							end
							if lt_i32(loc_1, 0) then
								desired = 4
								break
							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)
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						while true do
							if loc_13 ~= 0 then
								while true do
									loc_3 = loc_10
									loc_12 = loc_5
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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
							while true do
								loc_11 = shl_i32(loc_13, 2)
								loc_12 = load_i32_u8(memory_at_0, add_i32(loc_12, loc_11))
								while true do
									while true do
										while true do
											while true do
												while true do
													while true do
														while true do
															while true do
																while true do
																	while true do
																		while true do
																			while true do
																				while true do
																					loc_2 = load_i32(memory_at_0, param_0 + 68)
																					if loc_16 >=
																						shr_i32(
																							sub_i32(load_i32(memory_at_0, param_0 + 72), loc_2), 3
																						) then break end
																					loc_2 = add_i32(loc_2, shl_i32(loc_16, 3))
																					if load_i32(memory_at_0, loc_2) ~= loc_13 then
																						break
																					end
																					while true do
																						loc_2 = add_i32(
																							load_i32(memory_at_0, loc_2 + 4),
																								bxor_i32(loc_13, 4294967295)
																						)
																						reg_0 = loc_2
																						loc_2 = shr_i32(loc_2, 31)
																						if sub_i32(bxor_i32(reg_0, loc_2), loc_2) < 10923 then
																							break
																						end
																						while true do
																							if loc_1 < loc_4 then
																								while true do
																									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)
																									desired = 21
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_2 = sub_i32(loc_1, loc_9)
																							loc_5 = shr_i32(loc_2, 2)
																							loc_1 = add_i32(loc_5, 1)
																							if loc_1 >= 1073741824 then
																								desired = 18
																								break
																							end
																							loc_7 = sub_i32(loc_4, loc_9)
																							loc_14 = shr_i32(loc_7, 1)
																							loc_1 = (loc_7 < 2147483644 and
																								        (loc_1 < loc_14 and loc_14 or loc_1) or
																								        1073741823)
																							if loc_1 ~= 0 then
																								while true do
																									if loc_1 >= 1073741824 then
																										desired = 17
																										break
																									end
																									reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							else
																								while true do
																									reg_0 = 0
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							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 gt_i32(loc_2, 0) then
																								while true do
																									reg_0 = FUNC_LIST[1119](loc_7, loc_9, loc_2)
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							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
																								while true do
																									FUNC_LIST[1276](loc_9)
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_9 = loc_7
																							break
																						end
																						if desired then
																							if desired == 20 then desired = nil end
																							break
																						end
																						while true do
																							if loc_1 < loc_4 then
																								while true do
																									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)
																									desired = 21
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_2 = sub_i32(loc_1, loc_9)
																							loc_5 = shr_i32(loc_2, 2)
																							loc_1 = add_i32(loc_5, 1)
																							if loc_1 >= 1073741824 then
																								desired = 16
																								break
																							end
																							loc_7 = sub_i32(loc_4, loc_9)
																							loc_14 = shr_i32(loc_7, 1)
																							loc_1 = (loc_7 < 2147483644 and
																								        (loc_1 < loc_14 and loc_14 or loc_1) or
																								        1073741823)
																							if loc_1 ~= 0 then
																								while true do
																									if loc_1 >= 1073741824 then
																										desired = 15
																										break
																									end
																									reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							else
																								while true do
																									reg_0 = 0
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							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 gt_i32(loc_2, 0) then
																								while true do
																									reg_0 = FUNC_LIST[1119](loc_7, loc_9, loc_2)
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							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
																								while true do
																									FUNC_LIST[1276](loc_9)
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_9 = loc_7
																							break
																						end
																						if desired then
																							if desired == 20 then desired = nil end
																							break
																						end
																						loc_2 = load_i32(memory_at_0, param_0 + 32)
																						loc_5 = add_i32(loc_2, loc_11)
																						while true do
																							if loc_3 ~= loc_8 then
																								while true do
																									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)
																									desired = 21
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_8 = sub_i32(loc_3, loc_10)
																							loc_17 = shr_i32(loc_8, 2)
																							loc_6 = add_i32(loc_17, 1)
																							if loc_6 >= 1073741824 then
																								while true do
																									store_i32(memory_at_0, loc_0 + 8, loc_3)
																									desired = 8
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_14 = shr_i32(loc_8, 1)
																							loc_14 = (loc_8 < 2147483644 and
																								         (loc_6 < loc_14 and loc_14 or loc_6) or
																								         1073741823)
																							if loc_14 ~= 0 then
																								while true do
																									if loc_14 >= 1073741824 then
																										desired = 14
																										break
																									end
																									reg_0 = FUNC_LIST[1275](shl_i32(loc_14, 2))
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							else
																								while true do
																									reg_0 = 0
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							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 gt_i32(loc_8, 0) then
																								while true do
																									reg_0 = FUNC_LIST[1119](loc_6, loc_10, loc_8)
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							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
																								while true do
																									FUNC_LIST[1276](loc_10)
																									loc_2 = load_i32(memory_at_0, param_0 + 32)
																									break
																								end
																								if desired then
																									if desired == 21 then
																										desired = nil
																									end
																									break
																								end
																							end
																							loc_10 = loc_6
																							break
																						end
																						if desired then
																							if desired == 20 then desired = nil end
																							break
																						end
																						loc_2 = add_i32(loc_2, loc_11)
																						if loc_3 ~= loc_8 then
																							while true do
																								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)
																								desired = 20
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_11 = sub_i32(loc_3, loc_10)
																						loc_8 = shr_i32(loc_11, 2)
																						loc_6 = add_i32(loc_8, 1)
																						if loc_6 >= 1073741824 then
																							while true do
																								store_i32(memory_at_0, loc_0 + 8, loc_3)
																								desired = 8
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_5 = shr_i32(loc_11, 1)
																						loc_5 = (loc_11 < 2147483644 and
																							        (loc_5 > loc_6 and loc_5 or loc_6) or 1073741823)
																						if loc_5 ~= 0 then
																							while true do
																								if loc_5 >= 1073741824 then
																									desired = 13
																									break
																								end
																								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 2))
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						else
																							while true do
																								reg_0 = 0
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						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 gt_i32(loc_11, 0) then
																							while true do
																								reg_0 = FUNC_LIST[1119](loc_6, loc_10, loc_11)
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						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
																							while true do
																								FUNC_LIST[1276](loc_10)
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_10 = loc_6
																						break
																					end
																					if desired then
																						if desired == 19 then desired = nil end
																						break
																					end
																					loc_16 = add_i32(loc_16, 1)
																					break
																				end
																				if desired then
																					if desired == 18 then desired = nil end
																					break
																				end
																				reg_0 = FUNC_LIST[91](loc_12)
																				loc_14 = add_i32(reg_0, loc_13)
																				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
																					)
																					while true do
																						if loc_1 ~= loc_4 then
																							while true do
																								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)
																								desired = 20
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_4 = add_i32(loc_5, 1)
																						if loc_4 >= 1073741824 then
																							desired = 12
																							break
																						end
																						loc_17 = shr_i32(loc_2, 1)
																						loc_4 = (loc_2 < 2147483644 and
																							        (loc_4 < loc_17 and loc_17 or loc_4) or
																							        1073741823)
																						if loc_4 ~= 0 then
																							while true do
																								if loc_4 >= 1073741824 then
																									desired = 11
																									break
																								end
																								reg_0 = FUNC_LIST[1275](shl_i32(loc_4, 2))
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						else
																							while true do
																								reg_0 = 0
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						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 gt_i32(loc_2, 0) then
																							while true do
																								reg_0 = FUNC_LIST[1119](loc_7, loc_9, loc_2)
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_4 = add_i32(loc_7, loc_11)
																						store_i32(memory_at_0, loc_0 + 20, loc_1)
																						if loc_9 ~= 0 then
																							while true do
																								FUNC_LIST[1276](loc_9)
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_9 = loc_7
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																							continue
																						end
																						break
																					end
																					loc_12 = add_i32(
																						load_i32(memory_at_0, param_0 + 32), loc_12
																					)
																					while true do
																						if loc_3 ~= loc_8 then
																							while true do
																								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)
																								desired = 20
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_2 = sub_i32(loc_3, loc_10)
																						loc_5 = shr_i32(loc_2, 2)
																						loc_11 = add_i32(loc_5, 1)
																						if loc_11 >= 1073741824 then
																							desired = 10
																							break
																						end
																						loc_8 = shr_i32(loc_2, 1)
																						loc_11 = (loc_2 < 2147483644 and
																							         (loc_8 > loc_11 and loc_8 or loc_11) or
																							         1073741823)
																						if loc_11 ~= 0 then
																							while true do
																								if loc_11 >= 1073741824 then
																									desired = 9
																									break
																								end
																								reg_0 = FUNC_LIST[1275](shl_i32(loc_11, 2))
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						else
																							while true do
																								reg_0 = 0
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						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 gt_i32(loc_2, 0) then
																							while true do
																								reg_0 = FUNC_LIST[1119](loc_6, loc_10, loc_2)
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_8 = add_i32(loc_6, loc_12)
																						store_i32(memory_at_0, loc_0 + 4, loc_3)
																						if loc_10 ~= 0 then
																							while true do
																								FUNC_LIST[1276](loc_10)
																								break
																							end
																							if desired then
																								if desired == 20 then
																									desired = nil
																								end
																								break
																							end
																						end
																						loc_10 = loc_6
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																							continue
																						end
																						break
																					end
																					loc_13 = add_i32(loc_13, 1)
																					if loc_14 ~= loc_13 then continue end
																					break
																				end
																				if desired then
																					if desired == 18 then desired = nil end
																					break
																				end
																				desired = 7
																				break
																			end
																			if desired then
																				if desired == 17 then desired = nil end
																				break
																			end
																			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")
																		end
																		if desired then
																			if desired == 16 then desired = nil end
																			break
																		end
																		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")
																	end
																	if desired then
																		if desired == 15 then desired = nil end
																		break
																	end
																	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")
																end
																if desired then
																	if desired == 14 then desired = nil end
																	break
																end
																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")
															end
															if desired then
																if desired == 13 then desired = nil end
																break
															end
															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")
														end
														if desired then
															if desired == 12 then desired = nil end
															break
														end
														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")
													end
													if desired then
														if desired == 11 then desired = nil end
														break
													end
													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")
												end
												if desired then
													if desired == 10 then desired = nil end
													break
												end
												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")
											end
											if desired then
												if desired == 9 then desired = nil end
												break
											end
											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")
										end
										if desired then
											if desired == 8 then desired = nil end
											break
										end
										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")
									end
									if desired then
										if desired == 7 then desired = nil end
										break
									end
									store_i32(memory_at_0, loc_0 + 24, loc_4)
									FUNC_LIST[115](loc_0)
									error("out of code bounds")
								end
								if desired then
									if desired == 6 then
										desired = nil
										continue
									end
									break
								end
								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 loc_13 < shr_i32(sub_i32(loc_5, loc_12), 2) then continue end
								break
							end
							if desired then
								if desired == 5 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						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
							desired = 2
							break
						end
						loc_10 = load_i32(memory_at_0, loc_0 + 16)
						loc_13 = load_i32(memory_at_0, loc_0 + 32)
						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
							)
							while true do
								loc_2 = add_i32(loc_2, bxor_i32(loc_9, 4294967295))
								reg_0 = loc_2
								loc_2 = shr_i32(loc_2, 31)
								if sub_i32(bxor_i32(reg_0, loc_2), loc_2) >= 10923 then
									while true do
										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))
										)
										desired = 6
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
								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)
								)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_1 = add_i32(loc_1, 8)
							if loc_1 ~= loc_6 then continue end
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					FUNC_LIST[252](5133)
					error("out of code bounds")
				end
				if desired then
					if desired == 2 then desired = nil end
					break
				end
				FUNC_LIST[113](add_i32(loc_0, 32))
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			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
				while true do
					store_i32(memory_at_0, loc_0 + 4, loc_1)
					FUNC_LIST[1276](loc_1)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
			end
			if loc_12 ~= 0 then
				while true do
					store_i32(memory_at_0, loc_0 + 20, loc_12)
					FUNC_LIST[1276](loc_12)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
			end
			loc_1 = load_i32(memory_at_0, loc_0 + 32)
			if loc_1 == 0 then break end
			FUNC_LIST[1276](loc_1)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_0, 48)
		break
	end
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 = i64_ZERO
		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 = i64_ZERO
		local reg_0
		local desired
		local br_map = {}
		while true do
			while true do
				loc_7 = sub_i32(param_1, 8)
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										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
											local temp = br_map[1][loc_2] or 4
											if temp < 3 then
												if temp < 1 then
													break
												elseif temp > 1 then
													desired = 6
													break
												else
													desired = 7
													break
												end
											elseif temp > 3 then
												if temp < 5 then
													desired = 4
													break
												else
													desired = 3
													break
												end
											else
												desired = 5
												break
											end
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										loc_0 = sub_i32(param_1, 8)
										if load_i32(memory_at_0, loc_0) >= load_i32(memory_at_0, param_0) then
											desired = 3
											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)
										desired = 0
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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 loc_3 >= load_i32(memory_at_0, param_0) then
										while true do
											if loc_2 >= loc_3 then
												desired = 3
												break
											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 load_i32(memory_at_0, param_0 + 8) >=
												load_i32(memory_at_0, param_0) then
												desired = 3
												break
											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)
											desired = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									loc_1 = load_i64(memory_at_0, param_0)
									if loc_2 < loc_3 then
										while true do
											store_i64(memory_at_0, param_0, load_i64(memory_at_0, loc_0))
											store_i64(memory_at_0, loc_0, loc_1)
											desired = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 load_i32(memory_at_0, loc_0) >= wrap_i32_i64(loc_1) then
										desired = 3
										break
									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)
									desired = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								reg_0 = FUNC_LIST[153](
									param_0, add_i32(param_0, 8), add_i32(param_0, 16), sub_i32(param_1, 8)
								)
								desired = 0
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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 load_i32(memory_at_0, loc_2) >= load_i32(memory_at_0, param_0 + 24) then
								desired = 3
								break
							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 load_i32(memory_at_0, loc_0) >= load_i32(memory_at_0, loc_3) then
								desired = 3
								break
							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 loc_0 >= load_i32(memory_at_0, loc_5) then
								desired = 3
								break
							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 load_i32(memory_at_0, param_0) <= loc_0 then
								desired = 3
								break
							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)
							desired = 3
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if le_i32(loc_0, 247) then
							while true do
								loc_0 = load_i32(memory_at_0, param_0 + 16)
								while true do
									loc_2 = load_i32(memory_at_0, param_0 + 8)
									loc_3 = load_i32(memory_at_0, param_0)
									if loc_2 >= loc_3 then
										while true do
											if loc_0 >= loc_2 then
												desired = 5
												break
											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 loc_3 <= wrap_i32_i64(loc_1) then
												desired = 5
												break
											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)
											desired = 5
											break
										end
										if desired then
											if desired == 5 then desired = nil end
											break
										end
									end
									loc_1 = load_i64(memory_at_0, param_0)
									if loc_0 < loc_2 then
										while true do
											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)
											desired = 5
											break
										end
										if desired then
											if desired == 5 then desired = nil end
											break
										end
									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 loc_0 >= loc_2 then break 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
									break
								end
								if desired then break end
								loc_3 = add_i32(param_0, 24)
								if loc_3 == param_1 then
									desired = 3
									break
								end
								loc_2 = add_i32(param_0, 16)
								while true do
									loc_4 = loc_3
									if loc_0 > load_i32(memory_at_0, loc_4) then
										while true do
											loc_1 = load_i64(memory_at_0, loc_4)
											loc_5 = wrap_i32_i64(loc_1)
											while true do
												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
														while true do
															loc_0 = param_0
															desired = 8
															break
														end
														if desired then
															if desired == 8 then desired = nil end
															break
														end
													end
													loc_3 = loc_0
													loc_2 = sub_i32(loc_0, 8)
													if load_i32(memory_at_0, loc_2) > loc_5 then
														desired = 7
														break
													end
													break
												end
												if desired then
													if desired == 7 then
														desired = nil
														continue
													end
													break
												end
												break
											end
											if desired then break end
											store_i64(memory_at_0, loc_0, loc_1)
											break
										end
										if desired then
											if desired == 5 then
												desired = nil
												continue
											end
											break
										end
									end
									loc_3 = add_i32(loc_4, 8)
									if loc_3 == param_1 then
										desired = 3
										break
									end
									loc_0 = load_i32(memory_at_0, loc_4)
									loc_2 = loc_4
									continue
								end
								if desired then break end
								error("out of code bounds")
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						loc_4 = add_i32(param_0, shl_i32(div_i32(loc_2, 2), 3))
						while true do
							if loc_0 >= 7993 then
								while true do
									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 load_i32(memory_at_0, loc_7) >= load_i32(memory_at_0, loc_0) then
										desired = 4
										break
									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 load_i32(memory_at_0, loc_0) >= load_i32(memory_at_0, loc_4) then
										while true do
											loc_6 = add_i32(loc_6, 1)
											desired = 4
											break
										end
										if desired then break end
									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 load_i32(memory_at_0, loc_4) >= load_i32(memory_at_0, loc_2) then
										while true do
											loc_6 = add_i32(loc_6, 2)
											desired = 4
											break
										end
										if desired then break end
									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 load_i32(memory_at_0, loc_2) >= load_i32(memory_at_0, param_0) then
										while true do
											loc_6 = add_i32(loc_6, 3)
											desired = 4
											break
										end
										if desired then break end
									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)
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_0 = load_i32(memory_at_0, loc_7)
							while true do
								loc_2 = load_i32(memory_at_0, loc_4)
								if loc_2 >= load_i32(memory_at_0, param_0) then
									while true do
										loc_6 = 0
										if loc_0 >= loc_2 then
											desired = 4
											break
										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 load_i32(memory_at_0, loc_4) >= load_i32(memory_at_0, param_0) then
											desired = 4
											break
										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)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								loc_1 = load_i64(memory_at_0, param_0)
								if loc_0 < loc_2 then
									while true do
										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
										desired = 4
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 load_i32(memory_at_0, loc_7) >= wrap_i32_i64(loc_1) then
									desired = 4
									break
								end
								store_i64(memory_at_0, loc_4, load_i64(memory_at_0, loc_7))
								store_i64(memory_at_0, loc_7, loc_1)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_6 = 2
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_0 = loc_7
						while true do
							while true do
								while true do
									loc_5 = load_i32(memory_at_0, param_0)
									loc_2 = load_i32(memory_at_0, loc_4)
									if loc_5 < loc_2 then
										while true do
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									while true do
										loc_0 = sub_i32(loc_0, 8)
										if loc_0 == param_0 then
											while true do
												loc_3 = add_i32(param_0, 8)
												if loc_5 < load_i32(memory_at_0, loc_7) then
													desired = 5
													break
												end
												if loc_3 == loc_7 then
													desired = 3
													break
												end
												while true do
													if load_i32(memory_at_0, loc_3) > loc_5 then
														while true do
															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)
															desired = 5
															break
														end
														if desired then
															if desired == 9 then
																desired = nil
																continue
															end
															break
														end
													end
													loc_3 = add_i32(loc_3, 8)
													if loc_7 ~= loc_3 then continue end
													break
												end
												if desired then break end
												desired = 3
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										end
										if load_i32(memory_at_0, loc_0) >= loc_2 then continue end
										break
									end
									if desired then
										if desired == 6 then desired = nil 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)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								loc_5 = add_i32(param_0, 8)
								if loc_0 > loc_5 then
									while true do
										while true do
											loc_3 = load_i32(memory_at_0, loc_4)
											while true do
												loc_2 = loc_5
												loc_5 = add_i32(loc_2, 8)
												if load_i32(memory_at_0, loc_2) < loc_3 then continue end
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
											while true do
												loc_0 = sub_i32(loc_0, 8)
												if load_i32(memory_at_0, loc_0) >= loc_3 then continue end
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
											if loc_0 < loc_2 then
												while true do
													reg_0 = loc_2
													break
												end
												if desired then
													if desired == 7 then
														desired = nil
														continue
													end
													break
												end
											else
												while true do
													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)
													desired = 7
													break
												end
												if desired then
													if desired == 7 then
														desired = nil
														continue
													end
													break
												end
											end
											break
										end
										if desired then break end
										loc_5 = reg_0
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								while true do
									if loc_4 == loc_5 then break end
									if load_i32(memory_at_0, loc_4) >= load_i32(memory_at_0, loc_5) then
										break
									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)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								if loc_6 == 0 then
									while true do
										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
											while true do
												param_1 = loc_5
												if loc_3 == 0 then
													desired = 1
													break
												end
												desired = 3
												break
											end
											if desired then break end
										end
										loc_2 = 2
										reg_0 = loc_2
										if loc_3 ~= 0 then
											desired = 4
											break
										end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								if lt_i32(sub_i32(loc_5, param_0), sub_i32(param_1, loc_5)) then
									while true do
										FUNC_LIST[142](param_0, loc_5)
										param_0 = add_i32(loc_5, 8)
										desired = 2
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								FUNC_LIST[142](add_i32(loc_5, 8), param_1)
								param_1 = loc_5
								desired = 1
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_2 = loc_7
							if loc_3 == loc_2 then
								desired = 3
								break
							end
							while true do
								loc_5 = load_i32(memory_at_0, param_0)
								while true do
									loc_0 = loc_3
									loc_3 = add_i32(loc_0, 8)
									if loc_5 >= load_i32(memory_at_0, loc_0) then continue end
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								while true do
									loc_2 = sub_i32(loc_2, 8)
									if loc_5 < load_i32(memory_at_0, loc_2) then continue end
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								if loc_0 >= loc_2 then
									while true do
										reg_0 = 4
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
								else
									while true do
										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)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_2 = reg_0
						param_0 = loc_0
						if loc_2 == 4 then
							desired = 2
							break
						end
						if loc_2 == 2 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					break
				end
				if desired then
					if desired == 1 then
						desired = nil
						continue
					end
					break
				end
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			break
		end
	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
		while true do
			store_i64(memory_at_0, param_0, i64_ZERO)
			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 = (lt_i32(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)
			)
			break
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_3 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_3), 24) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_3 = add_i32(loc_2, loc_3)
						if loc_5 < 72 then break end
						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, 4294967232), 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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_3)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_2 < 178956971 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_4), 24)
						loc_4 = shl_i32(loc_0, 1)
						loc_7 = (loc_0 < 89478485 and (loc_2 < loc_4 and loc_4 or loc_2) or
							        178956970)
						if loc_7 ~= 0 then
							while true do
								if loc_7 >= 178956971 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_7, 24))
								loc_5 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_6 >= 72 then
							while true do
								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, 4294967232), 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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967272), 24))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[145](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_1), 136) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_1 = add_i32(loc_1, loc_4)
						if loc_2 < 408 then break end
						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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_1)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_2 < 31580642 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_5), 136)
						loc_5 = shl_i32(loc_0, 1)
						loc_5 = (loc_0 < 15790320 and (loc_2 < loc_5 and loc_5 or loc_2) or
							        31580641)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 31580642 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 136))
								loc_4 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_2
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_3 = add_i32(loc_2, loc_6)
						if loc_7 >= 408 then
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967160), 136))
						if gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](param_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[147](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_1 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_0, loc_1), 3) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_1 = add_i32(loc_1, loc_2)
						if loc_3 < 7 then break end
						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, 4294967232)
							if loc_0 ~= loc_1 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_1)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 536870912 then
					while true do
						loc_0 = sub_i32(loc_0, loc_5)
						loc_5 = shr_i32(loc_0, 2)
						loc_5 = (loc_0 < 2147483640 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        536870911)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 3))
								loc_2 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_4 = add_i32(loc_3, loc_7)
						if loc_8 >= 7 then
							while true do
								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, 4294967232)
									if loc_0 ~= loc_4 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](param_1, param_2, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](param_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[149](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_2 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_2), 12) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_3 < 36 then break end
						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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_2)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 357913942 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
						loc_5 = shl_i32(loc_0, 1)
						loc_5 = (loc_0 < 178956970 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        357913941)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 357913942 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
								loc_4 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						param_1 = add_i32(loc_3, loc_6)
						if loc_7 >= 36 then
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967284), 12))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[151](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	end
FUNC_LIST[152] = --[[ std::__2::__vector_base<Luau::BytecodeBuilder::Function, std::__2::allocator<Luau::BytecodeBuilder::Function> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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 = i64_ZERO
		local loc_1 = 0
		local loc_2 = 0
		local loc_3 = 0
		local reg_0
		local desired
		while true do
			loc_1 = load_i32(memory_at_0, param_2)
			while true do
				loc_3 = load_i32(memory_at_0, param_1)
				if loc_3 >= load_i32(memory_at_0, param_0) then
					while true do
						reg_0 = 0
						if loc_1 >= loc_3 then
							desired = 1
							break
						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 load_i32(memory_at_0, param_1) >= load_i32(memory_at_0, param_0) then
							while true do
								loc_1 = wrap_i32_i64(loc_0)
								reg_0 = 1
								desired = 1
								break
							end
							if desired then break end
						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
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				loc_0 = load_i64(memory_at_0, param_0)
				if loc_1 < loc_3 then
					while true do
						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
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				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 loc_1 >= loc_3 then break 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
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			loc_2 = reg_0
			if loc_1 > load_i32(memory_at_0, param_3) then
				while true do
					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 load_i32(memory_at_0, param_2) >= load_i32(memory_at_0, param_1) then
						while true do
							reg_0 = add_i32(loc_2, 1)
							desired = 0
							break
						end
						if desired then break end
					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 load_i32(memory_at_0, param_1) >= load_i32(memory_at_0, param_0) then
						while true do
							reg_0 = add_i32(loc_2, 2)
							desired = 0
							break
						end
						if desired then break end
					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)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			reg_0 = loc_2
			break
		end
		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 = i64_ZERO
		local loc_2 = 0
		local loc_3 = i64_ZERO
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = 0
		local loc_7 = 0
		local reg_0
		local desired
		local br_map = {}
		while true do
			loc_6 = 1
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									if not br_map[1] then
										br_map[1] = (function() return { [0] = 5, 5, 0, 1, 2, 3 } end)()
									end
									local temp = br_map[1][shr_i32(sub_i32(param_1, param_0), 3)] or 4
									if temp < 3 then
										if temp < 1 then
											break
										elseif temp > 1 then
											desired = 4
											break
										else
											desired = 5
											break
										end
									elseif temp > 3 then
										if temp < 5 then
											desired = 2
											break
										else
											desired = 1
											break
										end
									else
										desired = 3
										break
									end
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								loc_0 = sub_i32(param_1, 8)
								if load_i32(memory_at_0, loc_0) >= load_i32(memory_at_0, param_0) then
									desired = 1
									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)
								reg_0 = 1
								desired = 0
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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 loc_4 >= load_i32(memory_at_0, param_0) then
								while true do
									if loc_2 >= loc_4 then
										desired = 1
										break
									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 load_i32(memory_at_0, param_0 + 8) >= load_i32(memory_at_0, param_0) then
										desired = 1
										break
									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
									desired = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_1 = load_i64(memory_at_0, param_0)
							if loc_2 < loc_4 then
								while true do
									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
									desired = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 load_i32(memory_at_0, loc_0) >= wrap_i32_i64(loc_1) then
								desired = 1
								break
							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
							desired = 0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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 load_i32(memory_at_0, loc_4) >= load_i32(memory_at_0, param_0 + 24) then
						desired = 1
						break
					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 load_i32(memory_at_0, loc_0) >= load_i32(memory_at_0, loc_2) then
						desired = 1
						break
					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 loc_0 >= load_i32(memory_at_0, loc_5) then
						desired = 1
						break
					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 load_i32(memory_at_0, param_0) <= loc_0 then
						desired = 1
						break
					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
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_0 = load_i32(memory_at_0, param_0 + 16)
				while true do
					loc_2 = load_i32(memory_at_0, param_0 + 8)
					loc_4 = load_i32(memory_at_0, param_0)
					if loc_2 >= loc_4 then
						while true do
							if loc_0 >= loc_2 then
								desired = 2
								break
							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 loc_4 <= wrap_i32_i64(loc_1) then
								desired = 2
								break
							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)
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					loc_1 = load_i64(memory_at_0, param_0)
					if loc_0 < loc_2 then
						while true do
							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)
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					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 loc_0 >= loc_2 then break 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
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_2 = add_i32(param_0, 24)
				if loc_2 == param_1 then break end
				loc_6 = add_i32(param_0, 16)
				while true do
					while true do
						loc_5 = loc_2
						if loc_0 > load_i32(memory_at_0, loc_5) then
							while true do
								loc_1 = load_i64(memory_at_0, loc_5)
								loc_4 = wrap_i32_i64(loc_1)
								while true do
									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
											while true do
												loc_0 = param_0
												desired = 6
												break
											end
											if desired then
												if desired == 6 then desired = nil end
												break
											end
										end
										loc_2 = loc_0
										loc_6 = sub_i32(loc_0, 8)
										if load_i32(memory_at_0, loc_6) > loc_4 then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
									break
								end
								if desired then break end
								store_i64(memory_at_0, loc_0, loc_1)
								loc_7 = add_i32(loc_7, 1)
								if loc_7 == 8 then
									desired = 3
									break
								end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						loc_2 = add_i32(loc_5, 8)
						if param_1 == loc_2 then
							while true do
								reg_0 = 1
								desired = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						else
							while true do
								loc_0 = load_i32(memory_at_0, loc_5)
								loc_6 = loc_5
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_6 = (add_i32(loc_5, 8) == param_1 and 1 or 0)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			reg_0 = loc_6
			break
		end
		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 = i64_ZERO
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = 0
		local loc_5 = 0
		local loc_6 = i64_ZERO
		local loc_7 = 0
		local loc_8 = 0
		local loc_9 = 0
		local loc_10 = 0
		local loc_11 = i64_ZERO
		local loc_12 = 0
		local loc_13 = 0
		local reg_0
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			store_i64(memory_at_0, loc_0 + 12, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 20, 0)
			store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 4, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 32, i64_ZERO)
			loc_9 = 11424
			store_i32(memory_at_0, loc_0, loc_9)
			while true do
				if param_2 == 0 then break end
				loc_10 = bor_i32(loc_0, 4)
				param_2 = sub_i32(param_2, 1)
				loc_11 = extend_i64_u32(add_i32((param_2 < 6 and param_2 or 6), 1))
				while true do
					loc_4 = add_i32(param_1, shl_i32(wrap_i32_i64(loc_1), 2))
					loc_6 = shl_i64(loc_1, i64_from_u32(3, 0))
					loc_6 = shl_i64(i64_from_u32(65280, 0), loc_6)
					loc_7 = 0
					param_2 = shr_i32(sub_i32(loc_5, loc_2), 4)
					if shr_u32(mul_i32(param_2, 3), 2) <= loc_3 then
						while true do
							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)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					while true do
						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
							while true do
								while true do
									if loc_3 == loc_4 then
										desired = 3
										break
									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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 3 then desired = nil 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)
						)
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					store_i64(memory_at_0, add_i32(loc_2, shl_i32(param_2, 4)) + 8, loc_6)
					loc_1 = add_i64(loc_1, i64_ONE)
					if eq_i64(loc_1, loc_11) then
						desired = 1
						break
					end
					loc_3 = load_i32(memory_at_0, loc_0 + 16)
					continue
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				error("out of code bounds")
			end
			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
				while true do
					store_i32(memory_at_0, loc_0 + 8, param_2)
					FUNC_LIST[1276](param_2)
					break
				end
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			reg_0 = loc_1
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1) > 255 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_1 = reg_0
						store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
						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
							desired = 2
							break
						end
						loc_1 = shr_i32(sub_i32(loc_1, loc_3), 4)
						loc_13 = (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)
						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
								while true do
									while true do
										while true do
											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 break end
											loc_4 = 0
											if loc_2 == loc_8 then
												desired = 6
												break
											end
											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
													desired = 7
													break
												end
												if loc_2 ~= loc_8 then continue end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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)
										break
									end
									if desired then break end
									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)
									)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_6 = add_i32(loc_6, 1)
							if loc_6 ~= loc_13 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, param_0 + 16)
					store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
					store_i32(memory_at_0, loc_0 + 8, loc_1)
					FUNC_LIST[171](param_0, 16, add_i32(loc_0, 8))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 12, loc_3)
				FUNC_LIST[1276](loc_3)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			break
		end
	end
FUNC_LIST[157] = --[[ Luau::Compile::CostVisitor::~CostVisitor() ]] function(
	param_0
)
	local loc_0 = 0
	local reg_0
	while true do
		store_i32(memory_at_0, param_0, 11424)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 8, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		reg_0 = param_0
		break
	end
	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
		local desired
		while true do
			while true do
				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 break end
				if param_2 == 0 then
					while true do
						reg_0 = loc_2
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				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 = (param_2 < 6 and param_2 or 6)
				reg_0 = loc_0
				if param_2 == 0 then break 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 break 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 break 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, i64_from_u32(32, 0))), 127)
					)
				)
				reg_0 = loc_0
				if param_2 == 4 then break 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, i64_from_u32(40, 0))), 127)
					)
				)
				reg_0 = loc_0
				if param_2 == 5 then break 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, i64_from_u32(48, 0))), 127)
					)
				)
				reg_0 = loc_0
				if param_2 == 6 then break 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, i64_from_u32(56, 0))), 127)
					)
				)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			loc_0 = reg_0
			reg_0 = loc_0
			break
		end
		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
		local desired
		while true do
			loc_2 = 2147483648
			while true do
				loc_1 = 2147483648
				reg_0 = loc_1
				if (param_0 >= -3.2767e4 and 1 or 0) == 0 then break end
				reg_0 = 2147483648
				if (param_0 <= 3.2767e4 and 1 or 0) == 0 then break end
				reg_0 = 2147483648
				while true do
					if abs_f64(param_0) < 2.147483648e9 then
						while true do
							reg_1 = truncate_i32_f64(param_0)
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					reg_1 = 2147483648
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_0 = reg_1
				if convert_f64_i32(loc_0) ~= param_0 then break end
				reg_0 = loc_0
				break
			end
			loc_1 = reg_0
			while true do
				if (param_1 >= -3.2767e4 and 1 or 0) == 0 then break end
				if (param_1 <= 3.2767e4 and 1 or 0) == 0 then break end
				while true do
					if abs_f64(param_1) < 2.147483648e9 then
						while true do
							reg_0 = truncate_i32_f64(param_1)
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					reg_0 = 2147483648
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_0 = reg_0
				if convert_f64_i32(loc_0) ~= param_1 then break end
				loc_2 = loc_0
				break
			end
			while true do
				loc_0 = 2147483648
				reg_0 = loc_0
				if (param_2 >= -3.2767e4 and 1 or 0) == 0 then break end
				reg_0 = 2147483648
				if (param_2 <= 3.2767e4 and 1 or 0) == 0 then break end
				reg_0 = 2147483648
				while true do
					if abs_f64(param_2) < 2.147483648e9 then
						while true do
							reg_1 = truncate_i32_f64(param_2)
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					reg_1 = 2147483648
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_3 = reg_1
				if convert_f64_i32(loc_3) ~= param_2 then break end
				reg_0 = loc_3
				break
			end
			loc_0 = reg_0
			loc_3 = 4294967295
			while true do
				if loc_1 == 2147483648 then break end
				if loc_2 == 2147483648 then break end
				if loc_0 == 2147483648 then break end
				if loc_0 == 0 then break end
				loc_3 = 0
				if band_i32((lt_i32(loc_0, 0) and 1 or 0), (lt_i32(loc_1, loc_2) and 1 or 0)) ~=
					0 then break end
				if band_i32((gt_i32(loc_0, 0) and 1 or 0), (gt_i32(loc_1, loc_2) and 1 or 0)) ~=
					0 then break end
				loc_3 = add_i32(div_i32(sub_i32(loc_2, loc_1), loc_0), 1)
				break
			end
			reg_0 = loc_3
			break
		end
		return reg_0
	end
FUNC_LIST[160] = --[[ Luau::Compile::CostVisitor::~CostVisitor().1 ]] function(
	param_0
)
	local loc_0 = 0
	while true do
		store_i32(memory_at_0, param_0, 11424)
		loc_0 = load_i32(memory_at_0, param_0 + 4)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 8, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		FUNC_LIST[1276](param_0)
		break
	end
end
FUNC_LIST[161] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstExpr*) ]]
	function(param_0, param_1)
		local loc_0 = 0
		local loc_1 = i64_ZERO
		local loc_2 = i64_ZERO
		local reg_0
		while true do
			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, i64_ZERO)
			loc_1 = add_i64(loc_1, load_i64(memory_at_0, param_0 + 32))
			loc_2 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
						band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
				)
			)
			GLOBAL_LIST[0].value = add_i32(loc_0, 16)
			reg_0 = 0
			break
		end
		return reg_0
	end
FUNC_LIST[162] = --[[ Luau::Compile::CostVisitor::model(Luau::AstExpr*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = i64_ZERO
		local loc_1 = 0
		local loc_2 = i64_ZERO
		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 = i64_ZERO
		local reg_0
		local desired
		while true do
			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)
			while true do
				while true do
					loc_3 = load_i32(memory_at_0, param_2 + 4)
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_5 then break end
						param_2 = load_i32(memory_at_0, param_2 + 24)
						desired = 2
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						while true do
							if loc_3 == loc_4 then break end
							if loc_3 == loc_19 then break end
							if loc_3 == loc_18 then break end
							if loc_3 ~= loc_17 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						store_i64(memory_at_0, param_0 + 8, i64_from_u32(4294967295, 4294967295))
						store_i64(memory_at_0, param_0, i64_ZERO)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_16 then break 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
							while true do
								loc_0 = load_i64(memory_at_0, param_2)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						store_i64(memory_at_0, param_0 + 8, loc_0)
						store_i64(memory_at_0, param_0, i64_ZERO)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					if loc_3 == loc_15 then
						while true do
							store_i64(memory_at_0, param_0 + 8, i64_ZERO)
							store_i64(memory_at_0, param_0, i64_ONE)
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					if loc_3 == loc_14 then
						while true do
							store_i64(memory_at_0, param_0 + 8, i64_ZERO)
							store_i64(memory_at_0, param_0, i64_from_u32(3, 0))
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_13 then break end
						store_i64(memory_at_0, param_0 + 8, i64_ZERO)
						store_i64(memory_at_0, param_0, i64_from_u32(3, 0))
						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, i64_ZERO)
						loc_0 = add_i64(loc_0, load_i64(memory_at_0, param_0))
						loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
						store_i64(
							memory_at_0, param_0, bor_i64(
								sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
									band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
							)
						)
						if load_i32(memory_at_0, param_2 + 32) == 0 then
							desired = 1
							break
						end
						loc_3 = 0
						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, i64_ZERO)
							loc_0 = add_i64(
								load_i64(memory_at_0, param_0),
									(eq_i64(loc_0, i64_ZERO) and i64_ONE or loc_0)
							)
							loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
							store_i64(
								memory_at_0, param_0, bor_i64(
									sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
										band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
								)
							)
							loc_3 = add_i32(loc_3, 1)
							if loc_3 < load_i32(memory_at_0, param_2 + 32) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_12 then break 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, i64_ZERO)
						loc_0 = add_i64(load_i64(memory_at_0, loc_1 + 32), i64_ONE)
						loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
						store_i64(
							memory_at_0, param_0, bor_i64(
								sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
									band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
							)
						)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_11 then break 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, i64_ZERO)
						loc_0 = add_i64(loc_0, loc_2)
						loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
						loc_0 = add_i64(
							bor_i64(
								sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
									band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
							), i64_ONE
						)
						loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
						store_i64(
							memory_at_0, param_0, bor_i64(
								sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
									band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
							)
						)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_10 then break end
						store_i64(memory_at_0, param_0 + 8, i64_ZERO)
						store_i64(memory_at_0, param_0, i64_from_u32(10, 0))
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_9 then break end
						store_i64(memory_at_0, param_0 + 8, i64_ZERO)
						store_i64(memory_at_0, param_0, i64_from_u32(10, 0))
						if load_i32(memory_at_0, param_2 + 28) == 0 then
							desired = 1
							break
						end
						loc_3 = 0
						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
								while true do
									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, i64_ZERO)
									loc_0 = add_i64(loc_0, load_i64(memory_at_0, param_0))
									loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
									store_i64(
										memory_at_0, param_0, bor_i64(
											sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
												band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
										)
									)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							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, i64_ZERO)
							loc_0 = add_i64(loc_0, loc_2)
							loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
							loc_0 = add_i64(
								bor_i64(
									sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
										band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
								), i64_ONE
							)
							loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
							store_i64(
								memory_at_0, param_0, bor_i64(
									sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
										band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
								)
							)
							loc_3 = add_i32(loc_3, 1)
							if loc_3 < load_i32(memory_at_0, param_2 + 28) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_8 then break 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, i64_from_u32(4294967295, 4294967295))
						store_i64(memory_at_0, loc_1 + 16, i64_ZERO)
						FUNC_LIST[174](param_0, add_i32(loc_1, 32), add_i32(loc_1, 16))
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_7 then break 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))
						desired = 1
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if param_2 == 0 then break end
						if loc_3 ~= loc_6 then break end
						param_2 = load_i32(memory_at_0, param_2 + 24)
						desired = 2
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				while true do
					if param_2 == 0 then break end
					if loc_3 ~= load_i32(memory_at_0, 55028) then break 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, i64_ZERO)
					loc_0 = add_i64(loc_0, loc_2)
					loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
					loc_0 = add_i64(
						loc_20, bor_i64(
							sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
								band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
						)
					)
					loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
					loc_0 = add_i64(
						bor_i64(
							sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
								band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
						), i64_from_u32(2, 0)
					)
					loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
					store_i64(
						memory_at_0, param_0, bor_i64(
							sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
								band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
						)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i64(memory_at_0, param_0, i64_ZERO)
				store_i64(memory_at_0, param_0 + 8, i64_ZERO)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_1, 48)
			break
		end
	end
FUNC_LIST[163] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStat*) ]]
	function(param_0, param_1)
		local loc_0 = i64_ZERO
		local loc_1 = i64_ZERO
		local reg_0
		local desired
		while true do
			loc_0 = i64_from_u32(2, 0)
			while true do
				while true do
					param_1 = load_i32(memory_at_0, param_1 + 4)
					if param_1 == load_i32(memory_at_0, 55044) then break end
					loc_0 = i64_ONE
					if param_1 == load_i32(memory_at_0, 55068) then break end
					if param_1 ~= load_i32(memory_at_0, 55076) then
						desired = 1
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i64(memory_at_0, param_0 + 40, i64_ZERO)
				loc_0 = add_i64(load_i64(memory_at_0, param_0 + 32), loc_0)
				loc_1 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
				store_i64(
					memory_at_0, param_0 + 32, bor_i64(
						sub_i64(loc_1, shr_u64(loc_1, i64_from_u32(7, 0))),
							band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
					)
				)
				break
			end
			reg_0 = 1
			break
		end
		return reg_0
	end
FUNC_LIST[164] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatWhile*) ]]
	function(param_0, param_1)
		local loc_0 = i64_ZERO
		local loc_1 = 0
		local loc_2 = i64_ZERO
		local loc_3 = i64_ZERO
		local loc_4 = 0
		local reg_0, reg_1, reg_2
		while true do
			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, i64_ZERO)
			loc_2 = load_i64(memory_at_0, param_0 + 32)
			store_i64(memory_at_0, param_0 + 32, i64_ZERO)
			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, i64_ZERO)
			loc_0 = add_i64(loc_0, load_i64(memory_at_0, param_0 + 32))
			loc_3 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			loc_0 = bor_i64(
				sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))),
					band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
			)
			loc_3 = band_i64(
				shr_u64(loc_0, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199)
			)
			loc_0 = mul_i64(
				band_i64(loc_0, i64_from_u32(8323199, 8323199)), i64_from_u32(3, 0)
			)
			reg_2 = bor_i64(
				band_i64(
					mul_i64(loc_3, i64_from_u32(768, 0)), i64_from_u32(2130738944, 2130738944)
				), band_i64(loc_0, i64_from_u32(8323199, 8323199))
			)
			loc_0 = bor_i64(
				band_i64(
					shr_u64(
						add_i64(
							loc_0, i64_from_u32(2139127680, 2139127680)
						), i64_from_u32(8, 0)
					), i64_from_u32(8388736, 8388736)
				), band_i64(
					add_i64(
						mul_i64(loc_3, i64_from_u32(3, 0)), i64_from_u32(2139127680, 2139127680)
					), i64_from_u32(2147516416, 2147516416)
				)
			)
			loc_0 = add_i64(
				loc_2, bor_i64(reg_2, sub_i64(loc_0, shr_u64(loc_0, i64_from_u32(7, 0))))
			)
			loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
						band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
				)
			)
			GLOBAL_LIST[0].value = add_i32(loc_1, 16)
			reg_0 = 0
			break
		end
		return reg_0
	end
FUNC_LIST[165] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatRepeat*) ]]
	function(param_0, param_1)
		local loc_0 = i64_ZERO
		local loc_1 = 0
		local loc_2 = i64_ZERO
		local loc_3 = i64_ZERO
		local loc_4 = 0
		local reg_0, reg_1, reg_2
		while true do
			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, i64_ZERO)
			loc_2 = load_i64(memory_at_0, param_0 + 32)
			store_i64(memory_at_0, param_0 + 32, i64_ZERO)
			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, i64_ZERO)
			loc_0 = add_i64(loc_0, load_i64(memory_at_0, param_0 + 32))
			loc_3 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			loc_0 = bor_i64(
				sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))),
					band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
			)
			loc_3 = band_i64(
				shr_u64(loc_0, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199)
			)
			loc_0 = mul_i64(
				band_i64(loc_0, i64_from_u32(8323199, 8323199)), i64_from_u32(3, 0)
			)
			reg_2 = bor_i64(
				band_i64(
					mul_i64(loc_3, i64_from_u32(768, 0)), i64_from_u32(2130738944, 2130738944)
				), band_i64(loc_0, i64_from_u32(8323199, 8323199))
			)
			loc_0 = bor_i64(
				band_i64(
					shr_u64(
						add_i64(
							loc_0, i64_from_u32(2139127680, 2139127680)
						), i64_from_u32(8, 0)
					), i64_from_u32(8388736, 8388736)
				), band_i64(
					add_i64(
						mul_i64(loc_3, i64_from_u32(3, 0)), i64_from_u32(2139127680, 2139127680)
					), i64_from_u32(2147516416, 2147516416)
				)
			)
			loc_0 = add_i64(
				loc_2, bor_i64(reg_2, sub_i64(loc_0, shr_u64(loc_0, i64_from_u32(7, 0))))
			)
			loc_2 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
						band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
				)
			)
			GLOBAL_LIST[0].value = add_i32(loc_1, 16)
			reg_0 = 0
			break
		end
		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 = i64_ZERO
		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 = i64_ZERO
		local reg_0
		local desired
		while true do
			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
				while true do
					loc_0 = add_i32(param_0, 4)
					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))
							)
						)
						while true do
							loc_2 = load_i64(memory_at_0, loc_3 + 8)
							if eq_i64(loc_2, i64_ZERO) then break end
							if loc_4 >= load_i32(memory_at_0, param_1 + 32) then break 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 load_i32(memory_at_0, loc_0 + 12) >= shr_u32(mul_i32(loc_1, 3), 2) then
								while true do
									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)
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							end
							while true do
								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
									while true do
										while true do
											if loc_5 == loc_7 then
												desired = 4
												break
											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 continue end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 4 then desired = nil 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)
								)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							store_i64(memory_at_0, add_i32(loc_6, shl_i32(loc_1, 4)) + 8, loc_2)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						loc_2 = load_i64(memory_at_0, loc_3)
						store_i64(memory_at_0, param_0 + 40, i64_ZERO)
						loc_2 = add_i64(loc_2, load_i64(memory_at_0, param_0 + 32))
						loc_12 = band_i64(loc_2, i64_from_u32(2155905152, 2155905152))
						store_i64(
							memory_at_0, param_0 + 32, bor_i64(
								sub_i64(loc_12, shr_u64(loc_12, i64_from_u32(7, 0))),
									band_i64(loc_2, i64_from_u32(2139062143, 2139062143))
							)
						)
						loc_4 = add_i32(loc_4, 1)
						if loc_4 < load_i32(memory_at_0, param_1 + 40) then continue end
						break
					end
					break
				end
			end
			GLOBAL_LIST[0].value = add_i32(loc_3, 16)
			reg_0 = 0
			break
		end
		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 = i64_ZERO
		local loc_2 = i64_ZERO
		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 = i64_ZERO
		local loc_11 = 0
		local loc_12 = i64_ZERO
		local reg_0, reg_1, reg_2
		local desired
		while true do
			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, i64_ZERO)
			loc_1 = add_i64(loc_1, load_i64(memory_at_0, param_0 + 32))
			loc_2 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
						band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
				)
			)
			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, i64_ZERO)
			loc_1 = add_i64(loc_1, load_i64(memory_at_0, param_0 + 32))
			loc_2 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
			loc_1 = bor_i64(
				sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
					band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
			)
			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
				while true do
					FUNC_LIST[162](loc_5, param_0, loc_0)
					loc_1 = add_i64(
						load_i64(memory_at_0, loc_5), load_i64(memory_at_0, param_0 + 32)
					)
					loc_2 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
					loc_1 = bor_i64(
						sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
							band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
					)
					break
				end
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								if loc_0 == 0 then break end
								if loc_3 ~= loc_4 then break end
								reg_0 = load_f64(memory_at_0, loc_0 + 24)
								desired = 4
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if loc_0 == 0 then
								desired = 3
								break
							end
							if loc_4 ~= load_i32(memory_at_0, 55004) then
								desired = 3
								break
							end
							if load_i32(memory_at_0, loc_0 + 24) ~= 1 then
								desired = 3
								break
							end
							loc_0 = load_i32(memory_at_0, loc_0 + 28)
							if load_i32(memory_at_0, loc_0 + 4) ~= loc_3 then
								desired = 3
								break
							end
							if loc_0 == 0 then
								desired = 3
								break
							end
							reg_0 = neg_f64(load_f64(memory_at_0, loc_0 + 24))
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_6 = reg_0
						loc_0 = load_i32(memory_at_0, param_1 + 36)
						loc_4 = load_i32(memory_at_0, loc_0 + 4)
						while true do
							while true do
								if loc_0 == 0 then break end
								if loc_3 ~= loc_4 then break end
								reg_0 = load_f64(memory_at_0, loc_0 + 24)
								desired = 4
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if loc_0 == 0 then
								desired = 3
								break
							end
							if loc_4 ~= load_i32(memory_at_0, 55004) then
								desired = 3
								break
							end
							if load_i32(memory_at_0, loc_0 + 24) ~= 1 then
								desired = 3
								break
							end
							loc_0 = load_i32(memory_at_0, loc_0 + 28)
							if load_i32(memory_at_0, loc_0 + 4) ~= loc_3 then
								desired = 3
								break
							end
							if loc_0 == 0 then
								desired = 3
								break
							end
							reg_0 = neg_f64(load_f64(memory_at_0, loc_0 + 24))
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_7 = reg_0
						while true do
							loc_0 = load_i32(memory_at_0, param_1 + 40)
							reg_0 = 1e0
							if loc_0 == 0 then break end
							loc_4 = load_i32(memory_at_0, loc_0 + 4)
							if loc_3 == loc_4 then
								while true do
									reg_0 = load_f64(memory_at_0, loc_0 + 24)
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							if loc_4 ~= load_i32(memory_at_0, 55004) then
								desired = 3
								break
							end
							if load_i32(memory_at_0, loc_0 + 24) ~= 1 then
								desired = 3
								break
							end
							loc_0 = load_i32(memory_at_0, loc_0 + 28)
							if load_i32(memory_at_0, loc_0 + 4) ~= loc_3 then
								desired = 3
								break
							end
							if loc_0 == 0 then
								desired = 3
								break
							end
							reg_0 = neg_f64(load_f64(memory_at_0, loc_0 + 24))
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_8 = reg_0
						loc_9 = 2147483648
						while true do
							loc_4 = 2147483648
							reg_0 = loc_4
							if (loc_6 >= -3.2767e4 and 1 or 0) == 0 then break end
							reg_0 = 2147483648
							if (loc_6 <= 3.2767e4 and 1 or 0) == 0 then break end
							reg_0 = 2147483648
							reg_1 = loc_6
							while true do
								if abs_f64(loc_6) < 2.147483648e9 then
									while true do
										reg_2 = truncate_i32_f64(loc_6)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								reg_2 = 2147483648
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_0 = reg_2
							if reg_1 ~= convert_f64_i32(loc_0) then break end
							reg_0 = loc_0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_4 = reg_0
						while true do
							if (loc_7 >= -3.2767e4 and 1 or 0) == 0 then break end
							if (loc_7 <= 3.2767e4 and 1 or 0) == 0 then break end
							reg_0 = loc_7
							while true do
								if abs_f64(loc_7) < 2.147483648e9 then
									while true do
										reg_1 = truncate_i32_f64(loc_7)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								reg_1 = 2147483648
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_0 = reg_1
							if reg_0 ~= convert_f64_i32(loc_0) then break end
							loc_9 = loc_0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						while true do
							loc_3 = 2147483648
							reg_0 = loc_3
							if (loc_8 >= -3.2767e4 and 1 or 0) == 0 then break end
							reg_0 = 2147483648
							if (loc_8 <= 3.2767e4 and 1 or 0) == 0 then break end
							reg_0 = 2147483648
							reg_1 = loc_8
							while true do
								if abs_f64(loc_8) < 2.147483648e9 then
									while true do
										reg_2 = truncate_i32_f64(loc_8)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								reg_2 = 2147483648
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_0 = reg_2
							if reg_1 ~= convert_f64_i32(loc_0) then break end
							reg_0 = loc_0
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_3 = reg_0
						if loc_4 == 2147483648 then break end
						if loc_9 == 2147483648 then break end
						if loc_3 == 2147483648 then break end
						if loc_3 == 0 then break end
						while true do
							if band_i32(
								(lt_i32(loc_3, 0) and 1 or 0), (lt_i32(loc_4, loc_9) and 1 or 0)
							) == 0 then
								while true do
									if le_i32(loc_3, 0) then
										desired = 4
										break
									end
									if le_i32(loc_4, loc_9) then
										desired = 4
										break
									end
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_0 = load_i32(memory_at_0, param_1 + 44)
							reg_0 = 0
							desired = 1
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_0 = load_i32(memory_at_0, param_1 + 44)
						param_1 = div_i32(sub_i32(loc_9, loc_4), loc_3)
						if le_i32(param_1, 4294967294) then
							desired = 2
							break
						end
						reg_0 = add_i32(param_1, 1)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_0 = load_i32(memory_at_0, param_1 + 44)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				reg_0 = 3
				break
			end
			param_1 = reg_0
			store_i64(memory_at_0, loc_11, i64_ZERO)
			store_i64(memory_at_0, loc_11 + 8, i64_ZERO)
			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, i64_ZERO)
			loc_2 = add_i64(load_i64(memory_at_0, param_0 + 32), i64_ONE)
			loc_10 = band_i64(loc_2, i64_from_u32(2155905152, 2155905152))
			loc_2 = bor_i64(
				sub_i64(loc_10, shr_u64(loc_10, i64_from_u32(7, 0))),
					band_i64(loc_2, i64_from_u32(2139062143, 2139062143))
			)
			loc_10 = extend_i64_u32((lt_i32(param_1, 127) and param_1 or 127))
			loc_12 = mul_i64(
				band_i64(
					shr_u64(loc_2, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199)
				), loc_10
			)
			loc_2 = mul_i64(band_i64(loc_2, i64_from_u32(8323199, 8323199)), loc_10)
			reg_1 = bor_i64(
				band_i64(
					shl_i64(loc_12, i64_from_u32(8, 0)), i64_from_u32(2130738944, 2130738944)
				), band_i64(loc_2, i64_from_u32(8323199, 8323199))
			)
			loc_2 = bor_i64(
				band_i64(
					shr_u64(
						add_i64(
							loc_2, i64_from_u32(2139127680, 2139127680)
						), i64_from_u32(8, 0)
					), i64_from_u32(8388736, 8388736)
				), band_i64(
					add_i64(loc_12, i64_from_u32(2139127680, 2139127680)),
						i64_from_u32(2147516416, 2147516416)
				)
			)
			loc_1 = add_i64(
				bor_i64(
					reg_1, sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0)))
				), loc_1
			)
			loc_2 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_2, shr_u64(loc_2, i64_from_u32(7, 0))),
						band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
				)
			)
			GLOBAL_LIST[0].value = add_i32(loc_5, 16)
			reg_0 = 0
			break
		end
		return reg_0
	end
FUNC_LIST[168] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatForIn*) ]]
	function(param_0, param_1)
		local loc_0 = i64_ZERO
		local loc_1 = i64_ZERO
		local loc_2 = 0
		local loc_3 = 0
		local loc_4 = i64_ZERO
		local reg_0, reg_1
		local desired
		while true do
			loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
			GLOBAL_LIST[0].value = loc_3
			while true do
				if load_i32(memory_at_0, param_1 + 40) == 0 then
					while true do
						loc_1 = load_i64(memory_at_0, param_0 + 32)
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				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, i64_ZERO)
					loc_1 = add_i64(loc_1, load_i64(memory_at_0, param_0 + 32))
					loc_0 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
					loc_1 = bor_i64(
						sub_i64(loc_0, shr_u64(loc_0, i64_from_u32(7, 0))),
							band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
					)
					store_i64(memory_at_0, param_0 + 32, loc_1)
					loc_2 = add_i32(loc_2, 1)
					if loc_2 < load_i32(memory_at_0, param_1 + 40) then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			loc_2 = load_i32(memory_at_0, param_1 + 44)
			param_1 = add_i32(param_0, 40)
			store_i64(memory_at_0, param_1, i64_ZERO)
			store_i64(memory_at_0, param_0 + 32, i64_ZERO)
			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, i64_ZERO)
			loc_0 = add_i64(load_i64(memory_at_0, param_0 + 32), i64_ONE)
			loc_4 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			loc_0 = bor_i64(
				sub_i64(loc_4, shr_u64(loc_4, i64_from_u32(7, 0))),
					band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
			)
			loc_4 = band_i64(
				shr_u64(loc_0, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199)
			)
			loc_0 = mul_i64(
				band_i64(loc_0, i64_from_u32(8323199, 8323199)), i64_from_u32(3, 0)
			)
			reg_1 = bor_i64(
				band_i64(
					mul_i64(loc_4, i64_from_u32(768, 0)), i64_from_u32(2130738944, 2130738944)
				), band_i64(loc_0, i64_from_u32(8323199, 8323199))
			)
			loc_0 = bor_i64(
				band_i64(
					shr_u64(
						add_i64(
							loc_0, i64_from_u32(2139127680, 2139127680)
						), i64_from_u32(8, 0)
					), i64_from_u32(8388736, 8388736)
				), band_i64(
					add_i64(
						mul_i64(loc_4, i64_from_u32(3, 0)), i64_from_u32(2139127680, 2139127680)
					), i64_from_u32(2147516416, 2147516416)
				)
			)
			loc_1 = add_i64(
				bor_i64(
					reg_1, sub_i64(loc_0, shr_u64(loc_0, i64_from_u32(7, 0)))
				), loc_1
			)
			loc_0 = band_i64(loc_1, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_0, shr_u64(loc_0, i64_from_u32(7, 0))),
						band_i64(loc_1, i64_from_u32(2139062143, 2139062143))
				)
			)
			GLOBAL_LIST[0].value = add_i32(loc_3, 16)
			reg_0 = 0
			break
		end
		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
		local desired
		while true do
			loc_6 = load_i32(memory_at_0, param_1 + 32)
			if loc_6 ~= 0 then
				while true do
					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)
					while true do
						while true do
							param_1 = load_i32(memory_at_0, add_i32(loc_8, shl_i32(loc_3, 2)))
							if param_1 == 0 then break end
							if load_i32(memory_at_0, param_1 + 4) ~= loc_7 then break end
							loc_0 = load_i32(memory_at_0, param_0 + 8)
							if loc_2 == loc_0 then break end
							loc_4 = load_i32(memory_at_0, param_1 + 24)
							if loc_4 == loc_5 then break 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
							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
									while true do
										if loc_1 == loc_5 then
											desired = 3
											break
										end
										param_1 = add_i32(param_1, 1)
										loc_1 = add_i32(param_1, loc_9)
										if param_1 <= loc_0 then
											desired = 4
											break
										end
										desired = 3
										break
									end
									if desired then
										if desired == 4 then
											desired = nil
											continue
										end
										break
									end
								end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							store_i64(memory_at_0, loc_10 + 8, i64_ZERO)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = add_i32(loc_3, 1)
						if loc_3 ~= loc_6 then continue end
						break
					end
					break
				end
			end
			reg_0 = 1
			break
		end
		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 = i64_ZERO
		local loc_9 = i64_ZERO
		local reg_0
		local desired
		while true do
			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)
			while true do
				if param_1 == 0 then break end
				if loc_4 ~= loc_5 then break 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 break 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 break 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
				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
						while true do
							if loc_1 == loc_7 then
								desired = 1
								break
							end
							param_1 = add_i32(param_1, 1)
							loc_1 = add_i32(param_1, loc_6)
							if param_1 <= loc_0 then
								desired = 2
								break
							end
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i64(memory_at_0, add_i32(loc_2, shl_i32(loc_6, 4)) + 8, i64_ZERO)
				break
			end
			store_i64(memory_at_0, param_0 + 40, i64_ZERO)
			loc_8 = add_i64(
				load_i64(memory_at_0, param_0 + 32),
					(loc_4 == loc_5 and i64_ONE or i64_from_u32(2, 0))
			)
			loc_9 = band_i64(loc_8, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0 + 32, bor_i64(
					sub_i64(loc_9, shr_u64(loc_9, i64_from_u32(7, 0))),
						band_i64(loc_8, i64_from_u32(2139062143, 2139062143))
				)
			)
			reg_0 = 1
			break
		end
		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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_2 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_0, loc_2), 4) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_2 = add_i32(loc_2, loc_3)
						if loc_4 < 3 then break end
						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, 4294967232)
							if loc_0 ~= loc_2 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_2)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_4 < 268435456 then
					while true do
						loc_0 = sub_i32(loc_0, loc_5)
						loc_5 = shr_i32(loc_0, 3)
						loc_5 = (loc_0 < 2147483632 and (loc_4 < loc_5 and loc_5 or loc_4) or
							        268435455)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 268435456 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_5, 4))
								loc_3 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						param_1 = add_i32(loc_4, loc_7)
						if loc_8 >= 3 then
							while true do
								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, 4294967232)
									if loc_0 ~= param_1 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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 gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[172](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			while true do
				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 break 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 break 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
				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
						desired = 1
						break
					end
					loc_0 = 0
					if param_1 == loc_4 then
						desired = 1
						break
					end
					param_0 = add_i32(param_0, 1)
					param_1 = add_i32(param_0, loc_5)
					if param_0 <= loc_1 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			reg_0 = (loc_0 ~= 0 and add_i32(loc_0, 8) or 0)
			break
		end
		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 = i64_ZERO
		local loc_1 = i64_ZERO
		local loc_2 = i64_ZERO
		local reg_0, reg_1
		while true do
			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 = (eq_i64(loc_0, i64_from_u32(4294967295, 4294967295)) and i64_ZERO or
				        bor_i64(band_i64(loc_0, i64_from_u32(16843008, 16843009)), i64_ONE))
			loc_0 = add_i64(loc_1, loc_2)
			loc_1 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			loc_0 = add_i64(
				reg_1, bor_i64(
					sub_i64(loc_1, shr_u64(loc_1, i64_from_u32(7, 0))),
						band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
				)
			)
			loc_1 = band_i64(loc_0, i64_from_u32(2155905152, 2155905152))
			store_i64(
				memory_at_0, param_0, bor_i64(
					sub_i64(loc_1, shr_u64(loc_1, i64_from_u32(7, 0))),
						band_i64(loc_0, i64_from_u32(2139062143, 2139062143))
				)
			)
			break
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					param_3 = load_i32(memory_at_0, param_1 + 4)
					if param_1 == 0 then
						desired = 1
						break
					end
					if param_3 ~= loc_7 then
						desired = 1
						break
					end
					while true do
						if loc_0 == loc_6 then break end
						loc_2 = load_i32(memory_at_0, param_1 + 24)
						if loc_2 == loc_3 then break end
						param_3 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
						param_1 = 0
						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
								while true do
									if param_3 == loc_3 then
										desired = 3
										break
									end
									param_1 = add_i32(param_1, 1)
									param_3 = add_i32(param_1, loc_4)
									if param_1 <= loc_1 then
										desired = 4
										break
									end
									desired = 3
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32_u8(memory_at_0, loc_5 + 8) ~= 0 then break end
						param_1 = load_i32(memory_at_0, loc_5 + 4)
						if param_1 ~= 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i64(memory_at_0, param_0, i64_ZERO)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			while true do
				if param_1 == 0 then break end
				if param_3 ~= load_i32(memory_at_0, 54972) then break end
				while true do
					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
						break
					end
					if param_3 == 0 then break end
					loc_0 = load_i32(memory_at_0, param_3 + 24)
					while true do
						while true do
							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 break end
							loc_5 = load_i32(memory_at_0, param_2 + 16)
							if loc_5 == loc_0 then break 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
							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
									while true do
										if loc_2 == loc_5 then
											desired = 4
											break
										end
										param_3 = add_i32(param_3, 1)
										loc_1 = add_i32(param_3, loc_1)
										if param_3 <= loc_4 then
											desired = 5
											break
										end
										desired = 4
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if load_i32(memory_at_0, add_i32(loc_3, shl_i32(loc_1, 3)) + 4) ~= 0 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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))
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					store_i64(memory_at_0, param_0, i64_ZERO)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i64(memory_at_0, param_0, i64_ZERO)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			while true do
				if param_1 == 0 then break end
				if param_3 ~= load_i32(memory_at_0, 54948) then break end
				loc_2 = load_i32(memory_at_0, param_1 + 24)
				while true do
					while true do
						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 break end
						loc_3 = load_i32(memory_at_0, param_2 + 16)
						if loc_3 == loc_2 then break 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
						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
								while true do
									if loc_3 == loc_4 then
										desired = 3
										break
									end
									param_1 = add_i32(param_1, 1)
									param_3 = add_i32(param_1, param_3)
									if param_1 <= loc_1 then
										desired = 4
										break
									end
									desired = 3
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32(memory_at_0, add_i32(loc_0, shl_i32(param_3, 3)) + 4) ~= 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					store_i32(memory_at_0, param_0 + 4, loc_2)
					store_i32(memory_at_0, param_0, 0)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				store_i64(memory_at_0, param_0, i64_ZERO)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			store_i64(memory_at_0, param_0, i64_ZERO)
			break
		end
	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
		local desired
		while true do
			loc_2 = 4294967295
			while true do
				while true do
					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 break end
					while true do
						if loc_1 == 0 then
							while true do
								if loc_0 == 0 then
									desired = 3
									break
								end
								reg_0 = FUNC_LIST[1193](loc_0, 1745)
								if reg_0 == 0 then
									while true do
										reg_0 = 1
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 5684)
								if reg_0 == 0 then
									while true do
										reg_0 = 40
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 5010)
								if reg_0 == 0 then
									while true do
										reg_0 = 44
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 2098)
								if reg_0 == 0 then
									while true do
										reg_0 = 49
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 2168)
								if reg_0 == 0 then
									while true do
										reg_0 = 50
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 4492)
								if reg_0 == 0 then
									while true do
										reg_0 = 51
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 4560)
								if reg_0 == 0 then
									while true do
										reg_0 = 53
										desired = 0
										break
									end
									if desired then break end
								end
								reg_0 = FUNC_LIST[1193](loc_0, 2175)
								if reg_0 ~= 0 then
									desired = 3
									break
								end
								reg_0 = 57
								desired = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						while true do
							while true do
								while true do
									while true do
										while true do
											while true do
												while true do
													while true do
														reg_0 = FUNC_LIST[1193](loc_1, 4624)
														if reg_0 == 0 then
															while true do
																if loc_0 == 0 then
																	desired = 3
																	break
																end
																reg_0 = FUNC_LIST[1193](loc_0, 2799)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 2
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 2630)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 3
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4214)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 4
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 8312)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 5
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4316)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 6
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4473)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 7
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4629)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 8
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 2631)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 9
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 5006)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 10
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 3632)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 11
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 3344)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 12
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 6962)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 13
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 3624)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 14
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 3630)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 15
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 8365)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 16
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4665)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 17
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 1324)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 18
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4256)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 19
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 5048)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 20
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 1382)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 21
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 7339)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 22
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4634)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 23
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4215)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 24
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 1706)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 25
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4639)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 26
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4317)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 27
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 3735)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 46
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 4267)
																if reg_0 == 0 then
																	while true do
																		reg_0 = 47
																		desired = 0
																		break
																	end
																	if desired then break end
																end
																reg_0 = FUNC_LIST[1193](loc_0, 6991)
																if reg_0 ~= 0 then
																	desired = 11
																	break
																end
																reg_0 = 48
																desired = 0
																break
															end
															if desired then
																if desired == 11 then desired = nil end
																break
															end
														end
														reg_0 = FUNC_LIST[1193](loc_1, 8318)
														if reg_0 ~= 0 then
															desired = 8
															break
														end
														if loc_0 ~= 0 then
															desired = 10
															break
														end
														desired = 8
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													reg_0 = FUNC_LIST[1193](loc_1, 8318)
													if reg_0 ~= 0 then
														desired = 9
														break
													end
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												reg_0 = FUNC_LIST[1193](loc_0, 2083)
												if reg_0 == 0 then
													while true do
														reg_0 = 28
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 7006)
												if reg_0 == 0 then
													while true do
														reg_0 = 29
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 1789)
												if reg_0 == 0 then
													while true do
														reg_0 = 30
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 3354)
												if reg_0 == 0 then
													while true do
														reg_0 = 31
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 3326)
												if reg_0 == 0 then
													while true do
														reg_0 = 32
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 1694)
												if reg_0 == 0 then
													while true do
														reg_0 = 33
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 2234)
												if reg_0 == 0 then
													while true do
														reg_0 = 34
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 5464)
												if reg_0 == 0 then
													while true do
														reg_0 = 35
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 2091)
												if reg_0 == 0 then
													while true do
														reg_0 = 36
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 6954)
												if reg_0 == 0 then
													while true do
														reg_0 = 37
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 5456)
												if reg_0 == 0 then
													while true do
														reg_0 = 38
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 2084)
												if reg_0 == 0 then
													while true do
														reg_0 = 39
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 1032)
												if reg_0 == 0 then
													while true do
														reg_0 = 55
														desired = 0
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 1024)
												if reg_0 ~= 0 then
													desired = 8
													break
												end
												reg_0 = 56
												desired = 0
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											reg_0 = FUNC_LIST[1193](loc_1, 4913)
											if reg_0 == 0 then
												desired = 7
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										reg_0 = FUNC_LIST[1193](loc_1, 4913)
										if reg_0 ~= 0 then
											desired = 6
											break
										end
										if loc_0 == 0 then
											desired = 3
											break
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									reg_0 = FUNC_LIST[1193](loc_0, 5451)
									if reg_0 == 0 then
										while true do
											reg_0 = 41
											desired = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									reg_0 = FUNC_LIST[1193](loc_0, 3600)
									if reg_0 == 0 then
										while true do
											reg_0 = 42
											desired = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									reg_0 = FUNC_LIST[1193](loc_0, 4307)
									if reg_0 == 0 then
										while true do
											reg_0 = 43
											desired = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									end
									reg_0 = FUNC_LIST[1193](loc_0, 7737)
									if reg_0 ~= 0 then
										desired = 5
										break
									end
									reg_0 = 45
									desired = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								reg_0 = FUNC_LIST[1193](loc_1, 6559)
								if reg_0 ~= 0 then
									desired = 3
									break
								end
								if loc_0 ~= 0 then
									desired = 4
									break
								end
								desired = 3
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							reg_0 = FUNC_LIST[1193](loc_1, 6559)
							if reg_0 ~= 0 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						reg_0 = FUNC_LIST[1193](loc_0, 1752)
						if reg_0 == 0 then
							while true do
								reg_0 = 52
								desired = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						reg_0 = FUNC_LIST[1193](loc_0, 4560)
						if reg_0 ~= 0 then break end
						reg_0 = 53
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_3 = load_i32(memory_at_0, param_1 + 16)
					if loc_3 == 0 then
						desired = 1
						break
					end
					param_1 = load_i32(memory_at_0, param_1 + 12)
					if param_1 ~= 0 then
						while true do
							loc_2 = 54
							reg_0 = FUNC_LIST[177](param_0, param_1, loc_3)
							if reg_0 == 0 then
								desired = 1
								break
							end
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					if loc_1 ~= 0 then
						desired = 1
						break
					end
					if loc_0 == 0 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1193](loc_0, loc_3)
					if reg_0 ~= 0 then
						desired = 1
						break
					end
					loc_2 = 54
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				reg_0 = loc_2
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			reg_0 = 4294967295
			break
		end
		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
		local desired
		while true do
			while true do
				loc_1 = load_i32(memory_at_0, param_0)
				if loc_1 == 0 then break end
				reg_0 = FUNC_LIST[1193](loc_1, param_1)
				if reg_0 ~= 0 then break end
				param_0 = load_i32(memory_at_0, param_0 + 4)
				if param_0 == 0 then break end
				reg_0 = FUNC_LIST[1193](param_0, param_2)
				loc_0 = (reg_0 == 0 and 1 or 0)
				break
			end
			reg_0 = loc_0
			break
		end
		return reg_0
	end
FUNC_LIST[178] = --[[ __cxx_global_var_init ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54904), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[179] = --[[ __cxx_global_var_init.1 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54912), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[180] = --[[ __cxx_global_var_init.2 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54920), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[181] = --[[ __cxx_global_var_init.3 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54928), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[182] = --[[ __cxx_global_var_init.4 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54936), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[183] = --[[ __cxx_global_var_init.5 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54944), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[184] = --[[ __cxx_global_var_init.6 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54952), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[185] = --[[ __cxx_global_var_init.7 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54960), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[186] = --[[ __cxx_global_var_init.8 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54968), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[187] = --[[ __cxx_global_var_init.9 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54976), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[188] = --[[ __cxx_global_var_init.10 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54984), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[189] = --[[ __cxx_global_var_init.11 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 54992), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[190] = --[[ __cxx_global_var_init.12 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55000), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[191] = --[[ __cxx_global_var_init.13 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55008), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[192] = --[[ __cxx_global_var_init.14 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55016), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[193] = --[[ __cxx_global_var_init.15 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55024), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[194] = --[[ __cxx_global_var_init.16 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55032), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[195] = --[[ __cxx_global_var_init.17 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55040), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[196] = --[[ __cxx_global_var_init.18 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55048), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[197] = --[[ __cxx_global_var_init.19 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55056), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[198] = --[[ __cxx_global_var_init.20 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55064), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[199] = --[[ __cxx_global_var_init.21 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55072), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[200] = --[[ __cxx_global_var_init.22 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55080), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[201] = --[[ __cxx_global_var_init.23 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55088), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[202] = --[[ __cxx_global_var_init.24 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55096), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[203] = --[[ __cxx_global_var_init.25 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55104), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[204] = --[[ __cxx_global_var_init.26 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55112), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[205] = --[[ __cxx_global_var_init.27 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55120), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[206] = --[[ __cxx_global_var_init.28 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55128), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[207] = --[[ __cxx_global_var_init.29 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55136), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[208] = --[[ __cxx_global_var_init.30 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55144), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[209] = --[[ __cxx_global_var_init.31 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55152), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[210] = --[[ __cxx_global_var_init.32 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55160), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[211] = --[[ __cxx_global_var_init.33 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55168), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[212] = --[[ __cxx_global_var_init.34 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55176), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[213] = --[[ __cxx_global_var_init.35 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55184), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[214] = --[[ __cxx_global_var_init.36 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55192), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[215] = --[[ __cxx_global_var_init.37 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55200), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[216] = --[[ __cxx_global_var_init.38 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55208), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[217] = --[[ __cxx_global_var_init.39 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55216), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[218] = --[[ __cxx_global_var_init.40 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55224), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[219] = --[[ __cxx_global_var_init.41 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55232), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[220] = --[[ __cxx_global_var_init.42 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55240), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[221] = --[[ __cxx_global_var_init.43 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55248), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[222] = --[[ __cxx_global_var_init.44 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55256), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[223] = --[[ __cxx_global_var_init.45 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55264), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[224] = --[[ __cxx_global_var_init.46 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55272), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[225] = --[[ __cxx_global_var_init.47 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55280), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[226] = --[[ __cxx_global_var_init.48 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55288), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	end
end
FUNC_LIST[227] = --[[ __cxx_global_var_init.49 ]] function()
	local loc_0 = 0
	while true do
		if band_i32(load_i32_u8(memory_at_0, 55296), 1) == 0 then
			while true do
				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)
				break
			end
		end
		break
	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
		local desired
		while true do
			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 ge_i32(load_i32_i8(memory_at_0, param_2 + 11), 0) then
				while true do
					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
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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
			break
		end
		return reg_0
	end
FUNC_LIST[229] = --[[ Luau::CompileError::~CompileError() ]] function(param_0)
	local reg_0
	while true do
		store_i32(memory_at_0, param_0, 11704)
		if lt_i32(load_i32_i8(memory_at_0, param_0 + 31), 0) then
			while true do
				FUNC_LIST[1276](load_i32(memory_at_0, param_0 + 20))
				break
			end
		end
		reg_0 = FUNC_LIST[1416](param_0)
		break
	end
	return reg_0
end
FUNC_LIST[230] = --[[ Luau::CompileError::~CompileError().1 ]] function(param_0)
	local reg_0
	while true do
		reg_0 = FUNC_LIST[229](param_0)
		FUNC_LIST[1276](param_0)
		break
	end
end
FUNC_LIST[231] = --[[ Luau::CompileError::what() const ]] function(param_0)
	local reg_0
	while true do
		reg_0 = (lt_i32(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))
		break
	end
	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
		while true do
			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
	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 = i64_ZERO
		local loc_3 = 0
		local reg_0, reg_1, reg_2
		local desired
		while true do
			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, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 372, 0)
			store_i64(memory_at_0, loc_0 + 388, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 396, 0)
			store_i64(memory_at_0, loc_0 + 412, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 420, 0)
			store_i64(memory_at_0, loc_0 + 436, i64_ZERO)
			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, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 332, loc_2)
			store_i64(memory_at_0, loc_0 + 356, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 380, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 404, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 428, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 452, i64_ZERO)
			store_i32(memory_at_0, loc_0 + 492, 0)
			store_i64(memory_at_0, loc_0 + 484, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 508, i64_ZERO)
			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, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 568, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 576, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 584, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 592, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 600, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 476, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 500, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 524, i64_ZERO)
			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, 4294967232))
			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, 4294967232))
			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)
			while true do
				if le_i32(load_i32(memory_at_0, param_3), 0) then break 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 le_i32(load_i32(memory_at_0, param_3), 0) then break end
				reg_0 = FUNC_LIST[973](param_2, 1521)
				if reg_0 == 0 then
					while true do
						reg_0 = FUNC_LIST[973](param_2, 1513)
						if reg_0 == 0 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					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)
				)
				break
			end
			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, 4294967232))
			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
				while true do
					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 continue end
						break
					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, i64_ZERO)
			loc_1 = add_i32(loc_0, 88)
			store_i32_n8(memory_at_0, loc_1, 0)
			store_i64(memory_at_0, loc_0 + 56, i64_ZERO)
			store_i32(
				memory_at_0, sub_i32(loc_0, 4294967232), load_i32(memory_at_0, param_3)
			)
			store_i64(memory_at_0, loc_0 + 160, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 152, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 120, i64_ZERO)
			store_i64(memory_at_0, loc_0 + 144, i64_ZERO)
			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, i64_ZERO)
			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
				while true do
					store_i32(memory_at_0, loc_0 + 316, param_3)
					FUNC_LIST[1276](param_3)
					break
				end
			end
			reg_0 = FUNC_LIST[235](add_i32(loc_0, 328))
			GLOBAL_LIST[0].value = add_i32(loc_0, 608)
			break
		end
	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
		local desired
		while true do
			loc_1 = add_i32(GLOBAL_LIST[0].value, 4294967232)
			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 gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
				while true do
					FUNC_LIST[124](
						load_i32(memory_at_0, param_0),
							add_i32(load_i32(memory_at_0, param_1 + 8), 1)
					)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			if load_i32_u8(memory_at_0, param_1 + 68) ~= 0 then
				while true do
					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
					)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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 loc_0 < 256 then
				while true do
					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, (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
						while true do
							FUNC_LIST[237](param_0, loc_0, band_i32(loc_4, 255))
							loc_2 = load_i32(memory_at_0, param_1 + 48)
							break
						end
						if desired then break end
					end
					if loc_2 ~= 0 then
						while true do
							loc_3 = add_i32(loc_3, loc_4)
							loc_0 = 0
							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 loc_0 < load_i32(memory_at_0, param_1 + 48) then continue end
								break
							end
							if desired then break end
							break
						end
						if desired then break end
					end
					loc_3 = load_i32(memory_at_0, param_1 + 92)
					if load_i32(memory_at_0, loc_3 + 32) ~= 0 then
						while true do
							loc_0 = 0
							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 loc_0 < load_i32(memory_at_0, loc_3 + 32) then continue end
								break
							end
							if desired then break end
							break
						end
						if desired then break end
					end
					reg_0 = FUNC_LIST[239](param_0, loc_3)
					if reg_0 == 0 then
						while true do
							if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
								while true do
									FUNC_LIST[124](
										load_i32(memory_at_0, param_0),
											add_i32(load_i32(memory_at_0, loc_3 + 16), 1)
									)
									break
								end
								if desired then break end
							end
							FUNC_LIST[240](param_0, 0)
							FUNC_LIST[114](load_i32(memory_at_0, param_0), 22, 0, 1, 0)
							break
						end
						if desired then break end
					end
					while true do
						if le_i32(load_i32(memory_at_0, param_0 + 4), 0) then break end
						if lt_i32(load_i32(memory_at_0, param_0 + 8), 2) then break end
						store_i32(memory_at_0, loc_1 + 56, 0)
						store_i64(memory_at_0, loc_1 + 48, i64_ZERO)
						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
							while true do
								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 continue end
									break
								end
								if desired then break end
								loc_0 = load_i32(memory_at_0, loc_1 + 48)
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						store_i32(memory_at_0, loc_1 + 40, loc_4)
						if loc_0 == 0 then break end
						store_i32(memory_at_0, loc_1 + 52, loc_0)
						FUNC_LIST[1276](loc_0)
						break
					end
					if desired then break end
					FUNC_LIST[123](
						load_i32(memory_at_0, param_0),
							add_i32(load_i32(memory_at_0, param_1 + 8), 1)
					)
					while true do
						loc_0 = load_i32(memory_at_0, param_0 + 8)
						if le_i32(loc_0, 0) then break end
						loc_2 = load_i32(memory_at_0, param_1 + 100)
						if loc_2 ~= 0 then
							while true do
								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)
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						if lt_i32(loc_0, 2) then break 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 break end
						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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					if gt_i32(load_i32(memory_at_0, param_0 + 4), 0) then
						while true do
							FUNC_LIST[140](load_i32(memory_at_0, param_0))
							break
						end
						if desired then break end
					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 load_i32(memory_at_0, param_0 + 40) >= shr_u32(mul_i32(loc_4, 3), 2) then
						while true do
							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)
							break
						end
						if desired then break end
					end
					loc_4 = sub_i32(loc_4, 1)
					loc_12 = load_i32(memory_at_0, loc_7 + 16)
					while true do
						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
								while true do
									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)
									)
									desired = 2
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							if param_1 == loc_2 then
								desired = 2
								break
							end
							loc_0 = add_i32(loc_0, 1)
							loc_2 = add_i32(loc_0, loc_6)
							if loc_0 <= loc_4 then continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						loc_5 = 0
						break
					end
					if desired then break end
					store_i32(memory_at_0, loc_5 + 8, loc_9)
					loc_0 = add_i32(loc_5, 12)
					if loc_8 ~= loc_0 then
						while true do
							FUNC_LIST[244](
								loc_0, load_i32(memory_at_0, loc_8), load_i32(memory_at_0, loc_8 + 4)
							)
							break
						end
						if desired then break end
					end
					while true do
						if lt_i32(load_i32(memory_at_0, param_0 + 4), 2) then break end
						if load_i32_u8(memory_at_0, param_1 + 68) ~= 0 then break end
						if load_i32_u8(memory_at_0, param_0 + 204) ~= 0 then break end
						if load_i32_u8(memory_at_0, param_0 + 205) ~= 0 then break 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 break 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))
						break
					end
					if desired then break end
					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, 4294967232)
					reg_0 = loc_9
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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")
		end
		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
	local desired
	while true do
		loc_0 = load_i32(memory_at_0, param_0 + 268)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 272, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_2 = load_i32(memory_at_0, param_0 + 256)
		if loc_2 ~= 0 then
			while true do
				loc_1 = loc_2
				loc_0 = load_i32(memory_at_0, param_0 + 260)
				if loc_2 ~= loc_0 then
					while true do
						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
								while true do
									store_i32(memory_at_0, loc_3 + 4, loc_0)
									FUNC_LIST[1276](loc_0)
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_0 = loc_1
							if loc_0 ~= loc_2 then continue end
							break
						end
						loc_1 = load_i32(memory_at_0, param_0 + 256)
						break
					end
				end
				store_i32(memory_at_0, param_0 + 260, loc_2)
				FUNC_LIST[1276](loc_1)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 244)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 248, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 232)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 236, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 220)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 224, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 208)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 212, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 172)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 176, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 148)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 152, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 124)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 128, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 100)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 104, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 76)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 80, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 52)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 56, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_2 = load_i32(memory_at_0, param_0 + 28)
		if loc_2 ~= 0 then
			while true do
				loc_1 = loc_2
				loc_0 = load_i32(memory_at_0, param_0 + 32)
				if loc_2 ~= loc_0 then
					while true do
						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
								while true do
									store_i32(memory_at_0, loc_3 + 4, loc_0)
									FUNC_LIST[1276](loc_0)
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_0 = loc_1
							if loc_0 ~= loc_2 then continue end
							break
						end
						loc_1 = load_i32(memory_at_0, param_0 + 28)
						break
					end
				end
				store_i32(memory_at_0, param_0 + 32, loc_2)
				FUNC_LIST[1276](loc_1)
				break
			end
		end
		reg_0 = param_0
		break
	end
	return reg_0
end
FUNC_LIST[236] = --[[ Luau::AstVisitor::~AstVisitor() ]] function(param_0)
	local reg_0
	while true do
		reg_0 = param_0
		break
	end
	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
		local desired
		while true do
			loc_7 = sub_i32(GLOBAL_LIST[0].value, 16)
			GLOBAL_LIST[0].value = loc_7
			while true do
				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 loc_5 < 797 then
					while true do
						while true do
							if load_i32(memory_at_0, param_0 + 216) ~= loc_0 then
								while true do
									store_i32(memory_at_0, loc_0, param_1)
									store_i32(memory_at_0, param_0 + 212, add_i32(loc_0, 4))
									desired = 3
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							end
							loc_3 = shr_u32(loc_5, 1)
							loc_4 = shr_i32(loc_5, 2)
							loc_1 = add_i32(loc_4, 1)
							loc_3 = (loc_1 < loc_3 and loc_3 or loc_1)
							if loc_3 >= 1073741824 then
								desired = 1
								break
							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
								while true do
									reg_0 = FUNC_LIST[1119](loc_3, loc_2, loc_5)
									break
								end
								if desired then
									if desired == 3 then desired = nil end
									break
								end
							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 break end
							FUNC_LIST[1276](loc_2)
							break
						end
						if desired then break end
						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 load_i32(memory_at_0, sub_i32(param_0, 4294967232)) >=
							shr_u32(mul_i32(loc_0, 3), 2) then
							while true do
								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)
								break
							end
							if desired then break end
						end
						loc_5 = sub_i32(loc_0, 1)
						loc_8 = load_i32(memory_at_0, loc_6 + 16)
						loc_0 = 0
						while true do
							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
									while true do
										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)
										)
										desired = 3
										break
									end
									if desired then
										if desired == 4 then
											desired = nil
											continue
										end
										break
									end
								end
								if param_1 == loc_2 then
									desired = 3
									break
								end
								loc_0 = add_i32(loc_0, 1)
								loc_2 = add_i32(loc_0, loc_3)
								if loc_0 <= loc_5 then continue end
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							loc_1 = 0
							break
						end
						if desired then break end
						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)
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				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")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
			while true do
				FUNC_LIST[124](
					load_i32(memory_at_0, param_0),
						add_i32(load_i32(memory_at_0, param_1 + 8), 1)
				)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
		end
		while true do
			if le_i32(load_i32(memory_at_0, param_0 + 12), 0) then break end
			loc_0 = load_i32(memory_at_0, param_1 + 4)
			if loc_0 == load_i32(memory_at_0, 55036) then break end
			if loc_0 == load_i32(memory_at_0, 55156) then break end
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 69, 0, 0, 0)
			break
		end
		if desired then
			if desired == 0 then desired = nil end
			break
		end
		loc_0 = load_i32(memory_at_0, param_1 + 4)
		while true do
			while true do
				while true do
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55036) then break 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
							while true do
								loc_0 = 0
								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 loc_0 < load_i32(memory_at_0, param_1 + 32) then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 4 then desired = nil 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)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55044) then break end
						FUNC_LIST[322](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55052) then break end
						FUNC_LIST[323](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55060) then break end
						FUNC_LIST[324](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					if load_i32(memory_at_0, 55068) == loc_0 then
						while true do
							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 param_1 < loc_1 then
								while true do
									store_i64(
										memory_at_0, param_1,
											shl_i64(extend_i64_u32(loc_3), i64_from_u32(32, 0))
									)
									store_i32(memory_at_0, loc_0 + 4, add_i32(param_1, 8))
									desired = 3
									break
								end
								if desired then break end
							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 param_1 >= 536870912 then
								desired = 2
								break
							end
							loc_1 = sub_i32(loc_1, param_0)
							loc_6 = shr_i32(loc_1, 2)
							loc_1 = (loc_1 < 2147483640 and (param_1 < loc_6 and loc_6 or param_1) or
								        536870911)
							if loc_1 ~= 0 then
								while true do
									if loc_1 >= 536870912 then
										desired = 1
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
									break
								end
								if desired then break end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then break end
							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), i64_from_u32(32, 0))
							)
							loc_3 = add_i32(param_1, shl_i32(loc_1, 3))
							loc_1 = add_i32(loc_4, 8)
							if gt_i32(loc_5, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](param_1, param_0, loc_5)
									break
								end
								if desired then break end
							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
								desired = 3
								break
							end
							FUNC_LIST[1276](param_0)
							desired = 3
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55076) then break 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
							while true do
								FUNC_LIST[325](param_0, param_1, loc_3)
								loc_0 = load_i32(memory_at_0, param_0 + 248)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						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))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55084) then break end
						while true do
							if lt_i32(load_i32(memory_at_0, param_0 + 4), 2) then break end
							if load_i32(memory_at_0, param_0 + 256) ==
								load_i32(memory_at_0, param_0 + 260) then break end
							FUNC_LIST[327](param_0, param_1, 0)
							desired = 3
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						FUNC_LIST[328](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55092) then break end
						while true do
							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
								break
							end
							if loc_0 == 0 then break end
							FUNC_LIST[329](
								param_0, loc_0, load_i32_u8(memory_at_0, param_0 + 196), 0, 0, 0
							)
							desired = 3
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						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)
						)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55100) then break end
						FUNC_LIST[331](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55108) then break end
						FUNC_LIST[332](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55116) then break end
						FUNC_LIST[333](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55124) then break end
						FUNC_LIST[334](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55132) then break end
						FUNC_LIST[335](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= load_i32(memory_at_0, 55140) then break end
						FUNC_LIST[336](param_0, param_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					if param_1 == 0 then break end
					if loc_0 ~= load_i32(memory_at_0, 55148) then break 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)
					break
				end
				if desired then
					if desired == 2 then desired = nil end
					break
				end
				GLOBAL_LIST[0].value = add_i32(loc_2, 16)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			FUNC_LIST[339](loc_0)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then desired = nil end
			break
		end
		FUNC_LIST[252](5133)
		error("out of code bounds")
	end
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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, 55036)
			while true do
				while true do
					loc_1 = load_i32(memory_at_0, param_1 + 4)
					while true do
						if param_1 == 0 then break end
						if loc_0 ~= loc_1 then break end
						loc_1 = load_i32(memory_at_0, param_1 + 32)
						if loc_1 == 0 then
							while true do
								loc_0 = 0
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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
							)
						)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					if load_i32(memory_at_0, 55084) == loc_1 then
						while true do
							reg_0 = 1
							desired = 0
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					loc_0 = 0
					if param_1 == 0 then break end
					if loc_1 ~= load_i32(memory_at_0, 55044) then break end
					if load_i32(memory_at_0, param_1 + 36) == 0 then break end
					reg_0 = FUNC_LIST[239](param_0, load_i32(memory_at_0, param_1 + 32))
					if reg_0 == 0 then break end
					loc_0 = load_i32(memory_at_0, 55036)
					param_1 = load_i32(memory_at_0, param_1 + 36)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then
						desired = nil
						continue
					end
					break
				end
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			reg_0 = loc_0
			break
		end
		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
	local desired
	while true do
		while true do
			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 loc_10 <= param_1 then break 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
			while true do
				loc_0 = 0
				while true do
					if loc_5 == loc_11 then break end
					loc_4 = load_i32(memory_at_0, add_i32(loc_9, shl_i32(param_1, 2)))
					if loc_4 == loc_7 then break end
					loc_3 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
					loc_1 = 0
					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
							desired = 3
							break
						end
						loc_0 = 0
						if loc_3 == loc_7 then
							desired = 3
							break
						end
						loc_1 = add_i32(loc_1, 1)
						loc_3 = add_i32(loc_1, loc_12)
						if loc_1 <= loc_6 then continue end
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				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
					while true do
						loc_8 = 1
						loc_1 = load_i32_u8(memory_at_0, loc_1)
						loc_0 = band_i32(loc_2, 255)
						loc_2 = (loc_0 > loc_1 and loc_1 or loc_0)
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
				end
				param_1 = add_i32(param_1, 1)
				if param_1 ~= loc_10 then continue end
				break
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			if loc_8 == 0 then break end
			FUNC_LIST[114](load_i32(memory_at_0, param_0), 11, band_i32(loc_2, 255), 0, 0)
			break
		end
		break
	end
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
	local desired
	while true do
		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)
		while true do
			while true do
				while true do
					while true do
						if loc_2 ~= loc_5 then
							while true do
								loc_0 = shr_i32(loc_3, 2)
								loc_1 = (loc_0 > 1 and loc_0 or 1)
								loc_0 = 0
								while true do
									if load_i32(memory_at_0, add_i32(loc_2, shl_i32(loc_0, 2))) == param_1 then
										desired = 4
										break
									end
									loc_0 = add_i32(loc_0, 1)
									if loc_0 ~= loc_1 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
						end
						if loc_3 >= 797 then
							desired = 3
							break
						end
						loc_4 = add_i32(param_0, 220)
						while true do
							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 break end
							loc_6 = load_i32(memory_at_0, param_0 + 116)
							if loc_6 == param_1 then break 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
							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
									while true do
										if loc_3 == loc_6 then
											desired = 5
											break
										end
										loc_0 = add_i32(loc_0, 1)
										loc_1 = add_i32(loc_0, loc_1)
										if loc_0 <= loc_2 then
											desired = 6
											break
										end
										desired = 5
										break
									end
									if desired then
										if desired == 6 then
											desired = nil
											continue
										end
										break
									end
								end
								break
							end
							if desired then
								if desired == 5 then desired = nil end
								break
							end
							if load_i32_u8(memory_at_0, add_i32(loc_7, mul_i32(loc_1, 12)) + 8) == 0 then
								break
							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 load_i32(memory_at_0, sub_i32(param_0, 4294967232)) >=
								shr_u32(mul_i32(loc_0, 3), 2) then
								while true do
									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)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							end
							while true do
								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
									while true do
										loc_1 = 0
										while true do
											if param_1 == loc_2 then
												desired = 6
												break
											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 continue end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 6 then desired = nil 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)
								)
								break
							end
							if desired then
								if desired == 5 then desired = nil end
								break
							end
							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)
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						while true do
							if load_i32(memory_at_0, loc_4 + 8) ~= loc_5 then
								while true do
									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)
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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 loc_0 >= 1073741824 then
								desired = 2
								break
							end
							loc_1 = shr_i32(loc_2, 1)
							loc_0 = (loc_2 < 2147483644 and (loc_0 < loc_1 and loc_1 or loc_0) or
								        1073741823)
							if loc_0 ~= 0 then
								while true do
									if loc_0 >= 1073741824 then
										desired = 1
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_0, 2))
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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 gt_i32(loc_2, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](loc_1, loc_3, loc_2)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
							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 break end
							FUNC_LIST[1276](loc_3)
							loc_0 = load_i32(memory_at_0, loc_4 + 4)
							break
						end
						if desired then
							if desired == 4 then desired = nil end
							break
						end
						loc_0 = sub_i32(
							shr_u32(sub_i32(loc_0, load_i32(memory_at_0, loc_4)), 2), 1
						)
						break
					end
					if desired then
						if desired == 3 then desired = nil end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_8, 16)
					reg_0 = band_i32(loc_0, 255)
					desired = 0
					break
				end
				if desired then
					if desired == 2 then desired = nil end
					break
				end
				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")
			end
			if desired then
				if desired == 1 then desired = nil end
				break
			end
			FUNC_LIST[250](loc_4)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then desired = nil end
			break
		end
		FUNC_LIST[252](5133)
		error("out of code bounds")
	end
	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
	local desired
	while true do
		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 param_1 < loc_0 then
			while true do
				loc_6 = param_1
				while true do
					loc_1 = 0
					while true do
						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 break 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 break 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
						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
								desired = 3
								break
							end
							loc_1 = 0
							if loc_3 == loc_10 then
								desired = 3
								break
							end
							loc_0 = add_i32(loc_0, 1)
							loc_3 = add_i32(loc_0, loc_11)
							if loc_0 <= loc_4 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						break
					end
					if desired then
						if desired == 2 then
							desired = nil
							continue
						end
						break
					end
					loc_0 = (loc_1 ~= 0 and add_i32(loc_1, 4) or 0)
					store_i32_n8(memory_at_0, loc_0 + 1, 0)
					if ge_i32(load_i32(memory_at_0, param_0 + 8), 2) then
						while true do
							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)
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					loc_6 = add_i32(loc_6, 1)
					loc_0 = shr_i32(sub_i32(loc_8, loc_5), 2)
					if loc_6 < loc_0 then continue end
					break
				end
				break
			end
		end
		loc_1 = add_i32(param_0, 208)
		while true do
			if param_1 > loc_0 then
				while true do
					FUNC_LIST[340](loc_1, sub_i32(param_1, loc_0))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
			end
			if param_1 >= loc_0 then break end
			store_i32(memory_at_0, loc_1 + 4, add_i32(loc_5, shl_i32(param_1, 2)))
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		break
	end
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
		local desired
		while true do
			loc_0 = add_i32(GLOBAL_LIST[0].value, 4294967232)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					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
						while true do
							if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 40) <= 15 then
								while true do
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									store_i64(memory_at_0, loc_0, i64_ZERO)
									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
									desired = 2
									break
								end
								if desired then break end
							end
							store_i64(memory_at_0, loc_0 + 54, i64_ZERO)
							store_i64(memory_at_0, loc_0 + 48, i64_ZERO)
							loc_1 = load_i32(memory_at_0, param_0 + 16)
							store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
							store_i64(memory_at_0, loc_0 + 32, i64_ZERO)
							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
								desired = 1
								break
							end
							store_i32(memory_at_0, loc_0 + 40, loc_1)
							FUNC_LIST[1276](loc_1)
							desired = 1
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
					store_i64(memory_at_0, loc_0, i64_ZERO)
					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)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_1 = reg_0
				store_i64(memory_at_0, loc_0 + 54, i64_ZERO)
				store_i64(memory_at_0, loc_0 + 48, i64_ZERO)
				store_i64(memory_at_0, loc_0 + 40, i64_ZERO)
				store_i64(memory_at_0, loc_0 + 32, i64_ZERO)
				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
					while true do
						store_i32(memory_at_0, loc_0 + 40, loc_1)
						FUNC_LIST[1276](loc_1)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				while true do
					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
						while true do
							loc_2 = loc_1
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					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
							while true do
								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)
								while true do
									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
											while true do
												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)
												desired = 5
												break
											end
											if desired then
												if desired == 6 then
													desired = nil
													continue
												end
												break
											end
										end
										if loc_2 == loc_6 then
											desired = 5
											break
										end
										loc_1 = add_i32(loc_1, 1)
										loc_2 = add_i32(loc_1, loc_11)
										if loc_1 <= loc_4 then continue end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
									loc_3 = 0
									break
								end
								if desired then break end
								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
									while true do
										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, i64_ZERO)
										break
									end
									if desired then break end
								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, i64_ZERO)
								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)
								break
							end
							if desired then
								if desired == 3 then
									desired = nil
									continue
								end
								break
							end
						end
						loc_7 = add_i32(loc_7, 1)
						if loc_7 < div_i32(sub_i32(loc_1, loc_2), 40) then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				if loc_1 ~= loc_2 then
					while true do
						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
								while true do
									store_i32(memory_at_0, loc_3 + 4, loc_1)
									FUNC_LIST[1276](loc_1)
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_1 = loc_4
							if loc_1 ~= loc_2 then continue end
							break
						end
						if desired then break end
						loc_1 = load_i32(memory_at_0, loc_0)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				store_i32(memory_at_0, loc_0 + 4, loc_2)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = sub_i32(loc_0, 4294967232)
			break
		end
	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
		local desired
		while true do
			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 loc_3 <= shr_i32(sub_i32(loc_1, loc_0), 2) then
				while true do
					loc_1 = sub_i32(load_i32(memory_at_0, param_0 + 4), loc_0)
					loc_4 = shr_i32(loc_1, 2)
					loc_1 = (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
						while true do
							reg_0 = FUNC_LIST[1120](loc_0, param_1, loc_2)
							break
						end
						if desired then break end
					end
					if loc_3 > loc_4 then
						while true do
							param_1 = load_i32(memory_at_0, param_0 + 4)
							param_2 = sub_i32(param_2, loc_1)
							if gt_i32(param_2, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](param_1, loc_1, param_2)
									param_1 = add_i32(reg_0, param_2)
									break
								end
								if desired then break end
							end
							store_i32(memory_at_0, param_0 + 4, param_1)
							desired = 0
							break
						end
						if desired then break end
					end
					store_i32(memory_at_0, param_0 + 4, add_i32(loc_0, loc_2))
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			if loc_0 ~= 0 then
				while true do
					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, i64_ZERO)
					loc_1 = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				if lt_i32(loc_2, 0) then break end
				loc_0 = shr_i32(loc_1, 1)
				loc_0 = (loc_1 < 2147483644 and (loc_0 > loc_3 and loc_0 or loc_3) or
					        1073741823)
				if loc_0 >= 1073741824 then break 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
					while true do
						reg_0 = FUNC_LIST[1119](loc_0, param_1, loc_2)
						loc_0 = add_i32(reg_0, loc_2)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				store_i32(memory_at_0, param_0 + 4, loc_0)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[250](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			store_i32(memory_at_0, param_0 + 8, 0)
			store_i64(memory_at_0, param_0, i64_ZERO)
			while true do
				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
					while true do
						loc_1 = sub_i32(loc_0, loc_1)
						if lt_i32(loc_1, 0) then
							desired = 1
							break
						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
							while true do
								loc_4 = 36316
								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)
									while true do
										if ge_i32(load_i32_i8(memory_at_0, loc_1 + 31), 0) then
											while true do
												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))
												desired = 5
												break
											end
											if desired then
												if desired == 5 then desired = nil end
												break
											end
										end
										FUNC_LIST[1345](
											loc_2, load_i32(memory_at_0, param_1),
												load_i32(memory_at_0, param_1 + 4)
										)
										break
									end
									if desired then
										if desired == 4 then
											desired = nil
											continue
										end
										break
									end
									loc_0 = add_i32(loc_0, 32)
									loc_1 = add_i32(loc_1, 32)
									if loc_1 ~= loc_3 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						store_i32(memory_at_0, param_0 + 4, loc_0)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				reg_0 = param_0
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[246](param_0)
			error("out of code bounds")
		end
		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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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 = (lt_i32(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)
			)
			while true do
				param_1 = load_i32(memory_at_0, loc_0 + 472)
				if param_1 ~= load_i32(memory_at_0, loc_0 + 476) then
					while true do
						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 ge_i32(load_i32_i8(memory_at_0, loc_0 + 27), 0) then
							desired = 1
							break
						end
						FUNC_LIST[1276](load_i32(memory_at_0, loc_0 + 16))
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				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)
				while true do
					if ge_i32(load_i32_i8(memory_at_0, param_1 + 407), 0) then
						while true do
							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))
							desired = 2
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					FUNC_LIST[1345](
						param_0, load_i32(memory_at_0, loc_1), load_i32(memory_at_0, loc_1 + 4)
					)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				reg_0 = FUNC_LIST[248](param_1)
				break
			end
			param_1 = load_i32(memory_at_0, loc_0 + 484)
			if param_1 ~= 0 then
				while true do
					store_i32(memory_at_0, loc_0 + 488, param_1)
					FUNC_LIST[1276](param_1)
					break
				end
			end
			loc_1 = load_i32(memory_at_0, loc_0 + 472)
			if loc_1 ~= 0 then
				while true do
					param_0 = loc_1
					param_1 = load_i32(memory_at_0, loc_0 + 476)
					if loc_1 ~= param_1 then
						while true do
							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 continue end
								break
							end
							param_0 = load_i32(memory_at_0, loc_0 + 472)
							break
						end
					end
					store_i32(memory_at_0, loc_0 + 476, loc_1)
					FUNC_LIST[1276](param_0)
					break
				end
			end
			param_0 = load_i32(memory_at_0, loc_0 + 460)
			if param_0 ~= 0 then
				while true do
					param_1 = load_i32(memory_at_0, loc_0 + 464)
					loc_1 = param_0
					if param_1 ~= loc_1 then
						while true do
							while true do
								loc_1 = sub_i32(param_1, 32)
								if lt_i32(load_i32_i8(memory_at_0, sub_i32(param_1, 1)), 0) then
									while true do
										FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(param_1, 12)))
										break
									end
									if desired then
										if desired == 3 then
											desired = nil
											continue
										end
										break
									end
								end
								param_1 = loc_1
								if param_1 ~= param_0 then continue end
								break
							end
							loc_1 = load_i32(memory_at_0, loc_0 + 460)
							break
						end
					end
					store_i32(memory_at_0, loc_0 + 464, param_0)
					FUNC_LIST[1276](loc_1)
					break
				end
			end
			param_1 = load_i32(memory_at_0, loc_2)
			if param_1 ~= 0 then
				while true do
					store_i32(memory_at_0, loc_2 + 4, param_1)
					FUNC_LIST[1276](param_1)
					break
				end
			end
			reg_0 = FUNC_LIST[957](loc_3)
			GLOBAL_LIST[0].value = add_i32(loc_0, 544)
			break
		end
	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
	local desired
	while true do
		loc_2 = load_i32(memory_at_0, param_0 + 412)
		if loc_2 ~= 0 then
			while true do
				loc_1 = load_i32(memory_at_0, param_0 + 416)
				loc_0 = loc_2
				if loc_1 ~= loc_0 then
					while true do
						while true do
							loc_0 = sub_i32(loc_1, 12)
							if lt_i32(load_i32_i8(memory_at_0, sub_i32(loc_1, 1)), 0) then
								while true do
									FUNC_LIST[1276](load_i32(memory_at_0, loc_0))
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_1 = loc_0
							if loc_0 ~= loc_2 then continue end
							break
						end
						loc_0 = load_i32(memory_at_0, param_0 + 412)
						break
					end
				end
				store_i32(memory_at_0, param_0 + 416, loc_2)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		if lt_i32(load_i32_i8(memory_at_0, param_0 + 407), 0) then
			while true do
				FUNC_LIST[1276](load_i32(memory_at_0, param_0 + 396))
				break
			end
		end
		if lt_i32(load_i32_i8(memory_at_0, param_0 + 391), 0) then
			while true do
				FUNC_LIST[1276](load_i32(memory_at_0, param_0 + 380))
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 368)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 372, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 340)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 344, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 328)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 332, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 316)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 320, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 288)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 292, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 136)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 140, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 96)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 100, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 80)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 84, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 68)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 72, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 56)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 60, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 44)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 48, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 32)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 36, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_0 = load_i32(memory_at_0, param_0 + 20)
		if loc_0 ~= 0 then
			while true do
				store_i32(memory_at_0, param_0 + 24, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
		end
		loc_2 = load_i32(memory_at_0, param_0)
		if loc_2 ~= 0 then
			while true do
				loc_0 = load_i32(memory_at_0, param_0 + 4)
				loc_1 = loc_2
				if loc_0 ~= loc_1 then
					while true do
						while true do
							if lt_i32(load_i32_i8(memory_at_0, sub_i32(loc_0, 1)), 0) then
								while true do
									FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 12)))
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_1 = sub_i32(loc_0, 48)
							if lt_i32(load_i32_i8(memory_at_0, sub_i32(loc_0, 13)), 0) then
								while true do
									FUNC_LIST[1276](load_i32(memory_at_0, sub_i32(loc_0, 24)))
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							if lt_i32(load_i32_i8(memory_at_0, loc_1 + 11), 0) then
								while true do
									FUNC_LIST[1276](load_i32(memory_at_0, loc_1))
									break
								end
								if desired then
									if desired == 3 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_0 = loc_1
							if loc_0 ~= loc_2 then continue end
							break
						end
						loc_1 = load_i32(memory_at_0, param_0)
						break
					end
				end
				store_i32(memory_at_0, param_0 + 4, loc_2)
				FUNC_LIST[1276](loc_1)
				break
			end
		end
		reg_0 = param_0
		break
	end
	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
		local desired
		while true do
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									loc_2 = load_i32(memory_at_0, param_0 + 8)
									loc_0 = load_i32(memory_at_0, param_0 + 4)
									if param_1 <= div_i32(sub_i32(loc_2, loc_0), 40) then
										while true do
											if param_1 ~= 0 then
												while true do
													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)
													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, i64_ZERO)
														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
															while true do
																loc_1 = sub_i32(param_1, loc_1)
																if lt_i32(loc_1, 0) then
																	desired = 6
																	break
																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 gt_i32(loc_1, 0) then
																	while true do
																		reg_0 = FUNC_LIST[1119](param_1, loc_6, loc_1)
																		param_1 = add_i32(reg_0, loc_1)
																		break
																	end
																	if desired then break end
																end
																store_i32(memory_at_0, loc_2 + 4, param_1)
																break
															end
															if desired then
																if desired == 9 then
																	desired = nil
																	continue
																end
																break
															end
														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 continue end
														break
													end
													if desired then break end
													loc_0 = loc_3
													break
												end
												if desired then break end
											end
											store_i32(memory_at_0, param_0 + 4, loc_0)
											desired = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 loc_1 >= 107374183 then
										desired = 5
										break
									end
									loc_0 = 0
									loc_2 = div_i32(sub_i32(loc_2, loc_3), 40)
									loc_3 = shl_i32(loc_2, 1)
									loc_1 = (loc_2 < 53687091 and (loc_1 < loc_3 and loc_3 or loc_1) or
										        107374182)
									if loc_1 ~= 0 then
										while true do
											if loc_1 >= 107374183 then
												desired = 4
												break
											end
											reg_0 = FUNC_LIST[1275](mul_i32(loc_1, 40))
											loc_0 = reg_0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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
									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, i64_ZERO)
										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
											while true do
												loc_3 = sub_i32(loc_1, loc_3)
												if lt_i32(loc_3, 0) then
													desired = 3
													break
												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 gt_i32(loc_3, 0) then
													while true do
														reg_0 = FUNC_LIST[1119](loc_1, loc_8, loc_3)
														loc_1 = add_i32(reg_0, loc_3)
														break
													end
													if desired then break end
												end
												store_i32(memory_at_0, param_1 + 4, loc_1)
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										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 continue end
										break
									end
									if desired then
										if desired == 6 then desired = nil 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
										desired = 2
										break
									end
									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, i64_ZERO)
										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, i64_ZERO)
										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 continue end
										break
									end
									if desired then
										if desired == 6 then desired = nil 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
										desired = 1
										break
									end
									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
											while true do
												store_i32(memory_at_0, loc_2 + 4, param_2)
												FUNC_LIST[1276](param_2)
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										end
										param_2 = loc_0
										if loc_3 ~= param_2 then continue end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									desired = 1
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								FUNC_LIST[250](loc_2)
								error("out of code bounds")
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[251](param_0)
							error("out of code bounds")
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						FUNC_LIST[252](5133)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[250](param_1)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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)
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			if loc_3 ~= 0 then
				while true do
					FUNC_LIST[1276](loc_3)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			break
		end
	end
FUNC_LIST[250] = --[[ std::__2::__vector_base<Luau::AstLocal*, std::__2::allocator<Luau::AstLocal*> >::__throw_length_error() const ]]
	function(param_0)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	end
FUNC_LIST[252] = --[[ std::__2::__throw_length_error(char const*) ]] function(
	param_0
)
	local reg_0
	while true do
		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
end
FUNC_LIST[253] = --[[ std::length_error::length_error(char const*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		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
		break
	end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_2 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_2), 12) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_3 < 36 then break end
						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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_2)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 357913942 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
						loc_5 = shl_i32(loc_0, 1)
						loc_5 = (loc_0 < 178956970 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        357913941)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 357913942 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
								loc_4 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						param_1 = add_i32(loc_3, loc_6)
						if loc_7 >= 36 then
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967284), 12))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[255](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_3 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_3), 24) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_3 = add_i32(loc_2, loc_3)
						if loc_5 < 72 then break end
						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, 4294967232), 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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_3)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_2 < 178956971 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_4), 24)
						loc_4 = shl_i32(loc_0, 1)
						loc_7 = (loc_0 < 89478485 and (loc_2 < loc_4 and loc_4 or loc_2) or
							        178956970)
						if loc_7 ~= 0 then
							while true do
								if loc_7 >= 178956971 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_7, 24))
								loc_5 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_6 >= 72 then
							while true do
								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, 4294967232), 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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967272), 24))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[257](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 8)
			loc_2 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= div_i32(sub_i32(loc_0, loc_2), 12) then
				while true do
					while true do
						if param_1 == 0 then break 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
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 2 then desired = nil end
								break
							end
						end
						loc_2 = add_i32(loc_2, loc_4)
						if loc_3 < 36 then break end
						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 continue end
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						break
					end
					if desired then break end
					store_i32(memory_at_0, param_0 + 4, loc_2)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_3 < 357913942 then
					while true do
						loc_0 = div_i32(sub_i32(loc_0, loc_5), 12)
						loc_5 = shl_i32(loc_0, 1)
						loc_5 = (loc_0 < 178956970 and (loc_3 < loc_5 and loc_5 or loc_3) or
							        357913941)
						if loc_5 ~= 0 then
							while true do
								if loc_5 >= 357913942 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](mul_i32(loc_5, 12))
								loc_4 = reg_0
								break
							end
							if desired then break end
						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
							while true do
								loc_0 = loc_3
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then break end
						end
						param_1 = add_i32(loc_3, loc_6)
						if loc_7 >= 36 then
							while true do
								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 continue end
									break
								end
								if desired then break end
								break
							end
							if desired then 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, 4294967284), 12))
						if gt_i32(param_2, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_1, loc_0, param_2)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_0)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[259](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	end
FUNC_LIST[260] = --[[ Luau::Compiler::FenvVisitor::~FenvVisitor() ]] function(
	param_0
)
	while true do
		FUNC_LIST[1276](param_0)
		break
	end
end
FUNC_LIST[261] = --[[ Luau::AstVisitor::visit(Luau::AstNode*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[262] = --[[ Luau::AstVisitor::visit(Luau::AstExpr*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 8
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[263] = --[[ Luau::AstVisitor::visit(Luau::AstExprGroup*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[264] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantNil*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[265] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantBool*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[266] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantNumber*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[267] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantString*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[268] = --[[ Luau::AstVisitor::visit(Luau::AstExprLocal*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[269] = --[[ Luau::Compiler::FenvVisitor::visit(Luau::AstExprGlobal*) ]]
	function(param_0, param_1)
		local reg_0
		local desired
		while true do
			while true do
				param_1 = load_i32(memory_at_0, param_1 + 24)
				if param_1 == 0 then break end
				reg_0 = FUNC_LIST[1193](param_1, 1521)
				if reg_0 == 0 then
					while true do
						store_i32_n8(memory_at_0, load_i32(memory_at_0, param_0 + 4), 1)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				reg_0 = FUNC_LIST[1193](param_1, 1513)
				if reg_0 ~= 0 then break end
				store_i32_n8(memory_at_0, load_i32(memory_at_0, param_0 + 8), 1)
				break
			end
			reg_0 = 0
			break
		end
		return reg_0
	end
FUNC_LIST[270] = --[[ Luau::AstVisitor::visit(Luau::AstExprVarargs*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[271] = --[[ Luau::AstVisitor::visit(Luau::AstExprCall*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[272] = --[[ Luau::AstVisitor::visit(Luau::AstExprIndexName*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[273] = --[[ Luau::AstVisitor::visit(Luau::AstExprIndexExpr*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[274] = --[[ Luau::AstVisitor::visit(Luau::AstExprFunction*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[275] = --[[ Luau::AstVisitor::visit(Luau::AstExprTable*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[276] = --[[ Luau::AstVisitor::visit(Luau::AstExprUnary*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[277] = --[[ Luau::AstVisitor::visit(Luau::AstExprBinary*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[278] = --[[ Luau::AstVisitor::visit(Luau::AstExprTypeAssertion*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 12
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[279] = --[[ Luau::AstVisitor::visit(Luau::AstExprIfElse*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[280] = --[[ Luau::AstVisitor::visit(Luau::AstExprError*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[281] = --[[ Luau::AstVisitor::visit(Luau::AstStat*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 8
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[282] = --[[ Luau::AstVisitor::visit(Luau::AstStatBlock*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[283] = --[[ Luau::AstVisitor::visit(Luau::AstStatIf*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[284] = --[[ Luau::AstVisitor::visit(Luau::AstStatWhile*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[285] = --[[ Luau::AstVisitor::visit(Luau::AstStatRepeat*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[286] = --[[ Luau::AstVisitor::visit(Luau::AstStatBreak*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[287] = --[[ Luau::AstVisitor::visit(Luau::AstStatContinue*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[288] = --[[ Luau::AstVisitor::visit(Luau::AstStatReturn*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[289] = --[[ Luau::AstVisitor::visit(Luau::AstStatExpr*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[290] = --[[ Luau::AstVisitor::visit(Luau::AstStatLocal*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[291] = --[[ Luau::AstVisitor::visit(Luau::AstStatFor*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[292] = --[[ Luau::AstVisitor::visit(Luau::AstStatForIn*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[293] = --[[ Luau::AstVisitor::visit(Luau::AstStatAssign*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[294] = --[[ Luau::AstVisitor::visit(Luau::AstStatCompoundAssign*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[295] = --[[ Luau::AstVisitor::visit(Luau::AstStatFunction*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[296] = --[[ Luau::AstVisitor::visit(Luau::AstStatLocalFunction*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[297] = --[[ Luau::AstVisitor::visit(Luau::AstStatTypeAlias*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[298] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareFunction*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[299] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareGlobal*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[300] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareClass*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 88
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[301] = --[[ Luau::AstVisitor::visit(Luau::AstStatError*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 88
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[302] = --[[ Luau::AstVisitor::visit(Luau::AstType*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[303] = --[[ Luau::AstVisitor::visit(Luau::AstTypeReference*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 172
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[304] = --[[ Luau::AstVisitor::visit(Luau::AstTypeTable*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[305] = --[[ Luau::AstVisitor::visit(Luau::AstTypeFunction*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 172
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[306] = --[[ Luau::AstVisitor::visit(Luau::AstTypeTypeof*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[307] = --[[ Luau::AstVisitor::visit(Luau::AstTypeUnion*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[308] = --[[ Luau::AstVisitor::visit(Luau::AstTypeIntersection*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 172
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[309] = --[[ Luau::AstVisitor::visit(Luau::AstTypeSingletonBool*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 172
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[310] = --[[ Luau::AstVisitor::visit(Luau::AstTypeSingletonString*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 172
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[311] = --[[ Luau::AstVisitor::visit(Luau::AstTypeError*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 172
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[312] = --[[ Luau::AstVisitor::visit(Luau::AstTypePack*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[313] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackExplicit*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 212
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[314] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackVariadic*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 212
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[315] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackGeneric*) ]]
	function(param_0, param_1)
		local reg_0
		while true do
			reg_0 = TABLE_LIST[0].data[load_i32(
				memory_at_0, load_i32(memory_at_0, param_0) + 212
			)](param_0, param_1)
			break
		end
		return reg_0
	end
FUNC_LIST[316] = --[[ Luau::AstVisitor::visit(Luau::AstExprGlobal*) ]] function(
	param_0, param_1
)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(
			memory_at_0, load_i32(memory_at_0, param_0) + 12
		)](param_0, param_1)
		break
	end
	return reg_0
end
FUNC_LIST[317] = --[[ Luau::Compiler::FunctionVisitor::~FunctionVisitor() ]]
	function(param_0)
		while true do
			FUNC_LIST[1276](param_0)
			break
		end
	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
		local desired
		while true do
			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
				while true do
					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
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_2 < 1073741824 then
					while true do
						loc_1 = shr_i32(loc_0, 1)
						loc_1 = (loc_0 < 2147483644 and (loc_1 > loc_2 and loc_1 or loc_2) or
							        1073741823)
						if loc_1 ~= 0 then
							while true do
								if loc_1 >= 1073741824 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
								break
							end
							if desired then break end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then break end
						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 gt_i32(loc_0, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_2, loc_3, loc_0)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_3)
								break
							end
							if desired then break end
						end
						reg_0 = 0
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[319](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
		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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		while true do
			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 loc_1 >= 256 then
				while true do
					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
			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, (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)
			break
		end
		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
		local desired
		while true do
			loc_0 = sub_i32(GLOBAL_LIST[0].value, 48)
			GLOBAL_LIST[0].value = loc_0
			while true do
				while true do
					while true do
						while true do
							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
								while true do
									if div_i32(sub_i32(load_i32(memory_at_0, param_0 + 8), loc_1), 12) > 15 then
										desired = 3
										break
									end
									store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
									store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
									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
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							store_i64(memory_at_0, loc_0 + 16, i64_ZERO)
							store_i64(memory_at_0, loc_0 + 8, i64_ZERO)
							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)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_1 = reg_0
						store_i64(memory_at_0, loc_0 + 36, i64_ZERO)
						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
							while true do
								loc_1 = loc_2
								desired = 2
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						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
								while true do
									while true do
										while true do
											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 break end
											loc_2 = 0
											if loc_3 == loc_7 then
												desired = 6
												break
											end
											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
													desired = 7
													break
												end
												if loc_3 ~= loc_7 then continue end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
										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)
										break
									end
									if desired then break end
									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)
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							loc_4 = add_i32(loc_4, 1)
							if loc_4 < div_i32(sub_i32(loc_2, loc_1), 12) then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, param_0 + 16)
					store_i64(memory_at_0, loc_0 + 12, i64_ZERO)
					store_i32(memory_at_0, loc_0 + 8, loc_1)
					FUNC_LIST[254](param_0, 16, add_i32(loc_0, 8))
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_0 + 12, loc_1)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 48)
			break
		end
	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 desired
		local br_map = {}
		while true do
			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)
			while true do
				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 break end
					loc_6 = load_i32(memory_at_0, param_0 + 140)
					if loc_6 == loc_7 then break 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
					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
							while true do
								if loc_5 == loc_6 then
									desired = 2
									break
								end
								loc_0 = add_i32(loc_0, 1)
								loc_1 = add_i32(loc_0, loc_1)
								if loc_0 <= loc_4 then
									desired = 3
									break
								end
								desired = 2
								break
							end
							if desired then
								if desired == 3 then
									desired = nil
									continue
								end
								break
							end
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					while true do
						while true do
							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
							local temp = br_map[1][sub_i32(load_i32(memory_at_0, loc_0 + 8), 1)] or 2
							if temp < 1 then
								break
							elseif temp > 1 then
								desired = 2
								break
							else
								desired = 3
								break
							end
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if load_i32_u8(memory_at_0, loc_0 + 16) ~= 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_0 = load_i32(memory_at_0, param_1 + 36)
					if loc_0 == 0 then
						desired = 1
						break
					end
					FUNC_LIST[238](param_0, loc_0)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_9 = load_i32(memory_at_0, param_1 + 32)
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										while true do
											while true do
												while true do
													while true do
														loc_14 = load_i32(memory_at_0, param_1 + 36)
														if loc_14 ~= 0 then break end
														loc_0 = load_i32(memory_at_0, loc_9 + 4)
														while true do
															while true do
																if loc_9 == 0 then break end
																if loc_0 ~= load_i32(memory_at_0, 55036) then
																	break
																end
																if load_i32(memory_at_0, loc_9 + 32) ~= 1 then
																	desired = 11
																	break
																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
																	desired = 11
																	break
																end
																desired = 12
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															if loc_0 ~= load_i32(memory_at_0, 55068) then
																desired = 11
																break
															end
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														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 loc_12 > loc_10 then
															while true do
																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
																while true do
																	loc_1 = 0
																	while true do
																		if loc_11 == loc_16 then break end
																		loc_6 = load_i32(
																			memory_at_0, add_i32(loc_15, shl_i32(loc_10, 2))
																		)
																		if loc_6 == loc_8 then break end
																		loc_4 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
																		loc_0 = 0
																		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
																				desired = 14
																				break
																			end
																			loc_1 = 0
																			if loc_4 == loc_8 then
																				desired = 14
																				break
																			end
																			loc_0 = add_i32(loc_0, 1)
																			loc_4 = add_i32(loc_0, loc_3)
																			if loc_0 <= loc_5 then continue end
																			break
																		end
																		if desired then
																			if desired == 14 then desired = nil end
																			break
																		end
																		break
																	end
																	if desired then
																		if desired == 13 then
																			desired = nil
																			continue
																		end
																		break
																	end
																	if load_i32_u8(
																		memory_at_0, (loc_1 ~= 0 and add_i32(loc_1, 4) or 0) + 2
																	) == 0 then
																		while true do
																			loc_10 = add_i32(loc_10, 1)
																			loc_13 = (loc_10 < loc_12 and 1 or 0)
																			if loc_10 ~= loc_12 then
																				desired = 13
																				break
																			end
																			break
																		end
																		if desired then
																			if desired == 13 then
																				desired = nil
																				continue
																			end
																			break
																		end
																	end
																	break
																end
																if desired then break end
																if band_i32(loc_13, 1) ~= 0 then
																	desired = 11
																	break
																end
																break
															end
															if desired then
																if desired == 11 then desired = nil end
																break
															end
														end
														store_i32(memory_at_0, loc_2 + 24, 0)
														store_i64(memory_at_0, loc_2 + 16, i64_ZERO)
														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
															desired = 2
															break
														end
														loc_0 = add_i32(param_0, 232)
														while true do
															loc_5 = load_i32(memory_at_0, loc_1)
															while true do
																param_0 = load_i32(memory_at_0, loc_0 + 4)
																loc_3 = load_i32(memory_at_0, loc_0 + 8)
																if param_0 < loc_3 then
																	while true do
																		store_i64(
																			memory_at_0, param_0,
																				shl_i64(extend_i64_u32(loc_5), i64_from_u32(32, 0))
																		)
																		store_i32(memory_at_0, loc_0 + 4, add_i32(param_0, 8))
																		desired = 13
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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 param_0 >= 536870912 then
																	desired = 10
																	break
																end
																loc_3 = sub_i32(loc_3, loc_4)
																loc_7 = shr_i32(loc_3, 2)
																loc_3 = (loc_3 < 2147483640 and
																	        (param_0 < loc_7 and loc_7 or param_0) or 536870911)
																if loc_3 ~= 0 then
																	while true do
																		if loc_3 >= 536870912 then
																			desired = 9
																			break
																		end
																		reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 3))
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																else
																	while true do
																		reg_0 = 0
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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), i64_from_u32(32, 0))
																)
																loc_5 = add_i32(param_0, shl_i32(loc_3, 3))
																loc_3 = add_i32(loc_8, 8)
																if gt_i32(loc_6, 0) then
																	while true do
																		reg_0 = FUNC_LIST[1119](param_0, loc_4, loc_6)
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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 break end
																FUNC_LIST[1276](loc_4)
																break
															end
															if desired then
																if desired == 12 then
																	desired = nil
																	continue
																end
																break
															end
															loc_1 = add_i32(loc_1, 4)
															if loc_11 ~= loc_1 then continue end
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														desired = 3
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													while true do
														if load_i32(memory_at_0, loc_9 + 32) ~= 1 then break end
														if loc_14 ~= 0 then break 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 break 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 loc_9 > loc_10 then
															while true do
																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
																while true do
																	loc_1 = 0
																	while true do
																		if loc_11 == loc_14 then break end
																		loc_6 = load_i32(
																			memory_at_0, add_i32(loc_13, shl_i32(loc_10, 2))
																		)
																		if loc_6 == loc_8 then break end
																		loc_4 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
																		loc_0 = 0
																		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
																				desired = 14
																				break
																			end
																			loc_1 = 0
																			if loc_4 == loc_8 then
																				desired = 14
																				break
																			end
																			loc_0 = add_i32(loc_0, 1)
																			loc_4 = add_i32(loc_0, loc_3)
																			if loc_0 <= loc_5 then continue end
																			break
																		end
																		if desired then
																			if desired == 14 then desired = nil end
																			break
																		end
																		break
																	end
																	if desired then
																		if desired == 13 then
																			desired = nil
																			continue
																		end
																		break
																	end
																	if load_i32_u8(
																		memory_at_0, (loc_1 ~= 0 and add_i32(loc_1, 4) or 0) + 2
																	) == 0 then
																		while true do
																			loc_10 = add_i32(loc_10, 1)
																			loc_12 = (loc_10 < loc_9 and 1 or 0)
																			if loc_9 ~= loc_10 then
																				desired = 13
																				break
																			end
																			break
																		end
																		if desired then
																			if desired == 13 then
																				desired = nil
																				continue
																			end
																			break
																		end
																	end
																	break
																end
																if desired then break end
																if band_i32(loc_12, 1) ~= 0 then
																	desired = 11
																	break
																end
																break
															end
															if desired then
																if desired == 11 then desired = nil end
																break
															end
														end
														loc_0 = load_i32(memory_at_0, sub_i32(loc_16, 4))
														if loc_0 ~= 0 then
															while true do
																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
																	desired = 8
																	break
																end
																loc_7 = load_i32(memory_at_0, param_1 + 28)
																break
															end
															if desired then
																if desired == 11 then desired = nil end
																break
															end
														end
														store_i32(memory_at_0, loc_2 + 24, 0)
														store_i64(memory_at_0, loc_2 + 16, i64_ZERO)
														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
															desired = 4
															break
														end
														loc_0 = add_i32(param_0, 232)
														while true do
															loc_5 = load_i32(memory_at_0, loc_1)
															while true do
																param_0 = load_i32(memory_at_0, loc_0 + 4)
																loc_3 = load_i32(memory_at_0, loc_0 + 8)
																if param_0 < loc_3 then
																	while true do
																		store_i64(
																			memory_at_0, param_0, bor_i64(
																				shl_i64(extend_i64_u32(loc_5), i64_from_u32(32, 0)), i64_ONE
																			)
																		)
																		store_i32(memory_at_0, loc_0 + 4, add_i32(param_0, 8))
																		desired = 13
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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 param_0 >= 536870912 then
																	desired = 7
																	break
																end
																loc_3 = sub_i32(loc_3, loc_4)
																loc_7 = shr_i32(loc_3, 2)
																loc_3 = (loc_3 < 2147483640 and
																	        (param_0 < loc_7 and loc_7 or param_0) or 536870911)
																if loc_3 ~= 0 then
																	while true do
																		if loc_3 >= 536870912 then
																			desired = 6
																			break
																		end
																		reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 3))
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																else
																	while true do
																		reg_0 = 0
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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), i64_from_u32(32, 0)), i64_ONE
																	)
																)
																loc_5 = add_i32(param_0, shl_i32(loc_3, 3))
																loc_3 = add_i32(loc_8, 8)
																if gt_i32(loc_6, 0) then
																	while true do
																		reg_0 = FUNC_LIST[1119](param_0, loc_4, loc_6)
																		break
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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 break end
																FUNC_LIST[1276](loc_4)
																break
															end
															if desired then
																if desired == 12 then
																	desired = nil
																	continue
																end
																break
															end
															loc_1 = add_i32(loc_1, 4)
															if loc_11 ~= loc_1 then continue end
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														desired = 5
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													store_i32(memory_at_0, loc_2 + 24, 0)
													store_i64(memory_at_0, loc_2 + 16, i64_ZERO)
													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))
													while true do
														while true do
															while true do
																if load_i32(memory_at_0, param_1 + 36) == 0 then
																	break
																end
																if load_i32(memory_at_0, loc_2 + 20) ==
																	load_i32(memory_at_0, loc_2 + 16) then break 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
																	while true do
																		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
																			desired = 11
																			break
																		end
																		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
																				while true do
																					loc_0 = add_i32(loc_0, 4)
																					if loc_4 ~= loc_0 then
																						desired = 15
																						break
																					end
																					desired = 12
																					break
																				end
																				if desired then
																					if desired == 15 then
																						desired = nil
																						continue
																					end
																					break
																				end
																			end
																			break
																		end
																		if desired then break end
																		FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
																		error("out of code bounds")
																	end
																	if desired then
																		if desired == 13 then desired = nil end
																		break
																	end
																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
																while true do
																	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 break end
																	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
																			while true do
																				loc_0 = add_i32(loc_0, 4)
																				if loc_5 ~= loc_0 then
																					desired = 15
																					break
																				end
																				desired = 14
																				break
																			end
																			if desired then
																				if desired == 15 then
																					desired = nil
																					continue
																				end
																				break
																			end
																		end
																		break
																	end
																	if desired then
																		if desired == 14 then desired = nil end
																		break
																	end
																	FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
																	error("out of code bounds")
																end
																if desired then
																	if desired == 13 then desired = nil end
																	break
																end
																reg_0 = FUNC_LIST[119](
																	load_i32(memory_at_0, param_0), loc_1, loc_3
																)
																if reg_0 ~= 0 then
																	desired = 12
																	break
																end
																FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
																error("out of code bounds")
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															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
																desired = 11
																break
															end
															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
																	while true do
																		loc_0 = add_i32(loc_0, 4)
																		if loc_4 ~= loc_0 then
																			desired = 13
																			break
																		end
																		desired = 12
																		break
																	end
																	if desired then
																		if desired == 13 then
																			desired = nil
																			continue
																		end
																		break
																	end
																end
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
															error("out of code bounds")
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														loc_0 = load_i32(memory_at_0, loc_2 + 16)
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													if loc_0 == 0 then
														desired = 1
														break
													end
													store_i32(memory_at_0, loc_2 + 20, loc_0)
													FUNC_LIST[1276](loc_0)
													desired = 1
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												FUNC_LIST[339](loc_0)
												error("out of code bounds")
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											FUNC_LIST[252](5133)
											error("out of code bounds")
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										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")
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									FUNC_LIST[339](loc_0)
									error("out of code bounds")
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								FUNC_LIST[252](5133)
								error("out of code bounds")
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_1 = load_i32(memory_at_0, loc_2 + 16)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						if loc_1 == 0 then
							desired = 1
							break
						end
						store_i32(memory_at_0, loc_2 + 20, loc_1)
						FUNC_LIST[1276](loc_1)
						desired = 1
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, loc_2 + 16)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if loc_1 == 0 then break end
				store_i32(memory_at_0, loc_2 + 20, loc_1)
				FUNC_LIST[1276](loc_1)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_2, 32)
			break
		end
	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 desired
		local br_map = {}
		while true do
			loc_5 = sub_i32(GLOBAL_LIST[0].value, 16)
			GLOBAL_LIST[0].value = loc_5
			while true do
				while true do
					while true do
						while true do
							while true do
								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 break 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 break 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
								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
										while true do
											if loc_3 == loc_4 then
												desired = 5
												break
											end
											loc_0 = add_i32(loc_0, 1)
											loc_1 = add_i32(loc_0, loc_1)
											if loc_0 <= loc_2 then
												desired = 6
												break
											end
											desired = 5
											break
										end
										if desired then
											if desired == 6 then
												desired = nil
												continue
											end
											break
										end
									end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								while true do
									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
									local temp = br_map[1][sub_i32(load_i32(memory_at_0, loc_0 + 8), 1)] or
										             1
									if temp < 1 then
										break
									elseif temp > 1 then
										desired = 4
										break
									else
										desired = 5
										break
									end
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								if load_i32_u8(memory_at_0, loc_0 + 16) == 0 then
									desired = 4
									break
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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)
							while true do
								loc_0 = load_i32(memory_at_0, param_0 + 248)
								loc_3 = load_i32(memory_at_0, param_0 + 252)
								if loc_0 < loc_3 then
									while true do
										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))
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 loc_8 >= 536870912 then
									desired = 3
									break
								end
								loc_0 = 0
								loc_3 = sub_i32(loc_3, loc_1)
								loc_11 = shr_i32(loc_3, 2)
								loc_3 = (loc_3 < 2147483640 and (loc_8 < loc_11 and loc_11 or loc_8) or
									        536870911)
								if loc_3 ~= 0 then
									while true do
										if loc_3 >= 536870912 then
											desired = 2
											break
										end
										reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 3))
										loc_0 = reg_0
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 gt_i32(loc_9, 0) then
									while true do
										reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_9)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								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 break end
								FUNC_LIST[1276](loc_1)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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, i64_ZERO)
							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 gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
								while true do
									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
										)
									)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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
								desired = 1
								break
							end
							while true do
								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 break end
								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
										while true do
											loc_0 = add_i32(loc_0, 4)
											if loc_2 ~= loc_0 then
												desired = 6
												break
											end
											desired = 5
											break
										end
										if desired then
											if desired == 6 then
												desired = nil
												continue
											end
											break
										end
									end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
								error("out of code bounds")
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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)
							while true do
								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 param_0 < loc_0 then
									while true do
										FUNC_LIST[343](loc_2, sub_i32(loc_0, param_0))
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								if param_0 <= loc_0 then break end
								store_i32(memory_at_0, loc_2 + 4, add_i32(loc_1, shl_i32(loc_0, 3)))
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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 break end
							store_i32(memory_at_0, loc_5 + 4, loc_0)
							FUNC_LIST[1276](loc_0)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						GLOBAL_LIST[0].value = add_i32(loc_5, 16)
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[344](loc_4)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[252](5133)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
		end
	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 desired
		local br_map = {}
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									loc_1 = load_i32(memory_at_0, param_0 + 248)
									loc_2 = load_i32(memory_at_0, param_0 + 252)
									if loc_1 < loc_2 then
										while true do
											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))
											desired = 6
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 loc_1 >= 536870912 then
										desired = 5
										break
									end
									loc_2 = sub_i32(loc_2, loc_3)
									loc_9 = shr_i32(loc_2, 2)
									loc_2 = (loc_2 < 2147483640 and (loc_1 < loc_9 and loc_9 or loc_1) or
										        536870911)
									if loc_2 ~= 0 then
										while true do
											if loc_2 >= 536870912 then
												desired = 4
												break
											end
											reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									else
										while true do
											reg_0 = 0
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 gt_i32(loc_8, 0) then
										while true do
											reg_0 = FUNC_LIST[1119](loc_1, loc_3, loc_8)
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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 break end
									FUNC_LIST[1276](loc_3)
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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
									while true do
										loc_0 = 0
										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 loc_0 < load_i32(memory_at_0, loc_1 + 32) then
												continue
											end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
								loc_13 = reg_0
								if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
									while true do
										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
											)
										)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								loc_2 = load_i32(memory_at_0, param_1 + 28)
								while true do
									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 break end
									loc_8 = load_i32(memory_at_0, param_0 + 140)
									if loc_8 == loc_2 then break 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
									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
											while true do
												if loc_4 == loc_8 then
													desired = 6
													break
												end
												loc_0 = add_i32(loc_0, 1)
												loc_1 = add_i32(loc_0, loc_1)
												if loc_0 <= loc_3 then
													desired = 7
													break
												end
												desired = 6
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									while true do
										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
										local temp = br_map[1][load_i32(memory_at_0, loc_0 + 8)] or 5
										if temp < 1 then
											break
										elseif temp > 1 then
											desired = 2
											break
										else
											desired = 6
											break
										end
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									if load_i32_u8(memory_at_0, loc_0 + 16) ~= 0 then
										desired = 2
										break
									end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								store_i32(memory_at_0, loc_5 + 8, 0)
								store_i64(memory_at_0, loc_5, i64_ZERO)
								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
									desired = 3
									break
								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
									while true do
										while true do
											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
													while true do
														loc_0 = add_i32(loc_0, 4)
														if loc_3 ~= loc_0 then
															desired = 8
															break
														end
														desired = 7
														break
													end
													if desired then
														if desired == 8 then
															desired = nil
															continue
														end
														break
													end
												end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
											FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
											error("out of code bounds")
										end
										if desired then break end
										loc_0 = load_i32(memory_at_0, loc_5)
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								if loc_0 == 0 then
									desired = 1
									break
								end
								store_i32(memory_at_0, loc_5 + 4, loc_0)
								FUNC_LIST[1276](loc_0)
								desired = 1
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[344](loc_0)
							error("out of code bounds")
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						FUNC_LIST[252](5133)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[240](param_0, loc_7)
				reg_0 = FUNC_LIST[118](load_i32(memory_at_0, param_0))
				loc_4 = reg_0
				break
			end
			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)
			while true do
				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 loc_1 < loc_0 then
					while true do
						FUNC_LIST[343](loc_3, sub_i32(loc_0, loc_1))
						desired = 1
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				if loc_0 >= loc_1 then break end
				store_i32(memory_at_0, loc_3 + 4, add_i32(loc_4, shl_i32(loc_0, 3)))
				break
			end
			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)
			break
		end
	end
FUNC_LIST[325] = --[[ Luau::Compiler::validateContinueUntil(Luau::AstStat*, Luau::AstExpr*) ]]
	function(param_0, param_1, param_2)
		local loc_0 = 0
		while true do
			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
				while true do
					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
			end
			GLOBAL_LIST[0].value = add_i32(loc_0, 32)
			break
		end
	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
		local desired
		while true do
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			if loc_0 < loc_1 then
				while true do
					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))
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_0 < 536870912 then
					while true do
						loc_1 = sub_i32(loc_1, loc_2)
						loc_5 = shr_i32(loc_1, 2)
						loc_1 = (loc_1 < 2147483640 and (loc_0 < loc_5 and loc_5 or loc_0) or
							        536870911)
						if loc_1 ~= 0 then
							while true do
								if loc_1 >= 536870912 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
								break
							end
							if desired then break end
						else
							while true do
								reg_0 = 0
								break
							end
							if desired then break end
						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 gt_i32(loc_4, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_4)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[339](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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 = i64_ZERO
		local reg_0, reg_1
		local desired
		while true do
			loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
			GLOBAL_LIST[0].value = loc_2
			if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
				while true do
					FUNC_LIST[124](
						load_i32(memory_at_0, param_0),
							add_i32(load_i32(memory_at_0, param_1 + 8), 1)
					)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			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, i64_ZERO)
			while true do
				while true do
					while true do
						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
							while true do
								loc_3 = sub_i32(loc_0, loc_3)
								if lt_i32(loc_3, 0) then
									desired = 3
									break
								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 gt_i32(loc_1, 0) then
									while true do
										reg_0 = FUNC_LIST[1119](loc_0, loc_3, loc_1)
										loc_0 = add_i32(reg_0, loc_1)
										break
									end
									if desired then break end
								end
								store_i32(memory_at_0, loc_2 + 24, loc_0)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						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))
						while true do
							if param_2 ~= 0 then break 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
								while true do
									store_i32(memory_at_0, loc_0, param_1)
									store_i32(memory_at_0, param_0 + 4, add_i32(loc_0, 4))
									desired = 4
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 loc_0 >= 1073741824 then
								desired = 2
								break
							end
							loc_3 = shr_i32(loc_1, 1)
							loc_3 = (loc_1 < 2147483644 and (loc_0 < loc_3 and loc_3 or loc_0) or
								        1073741823)
							if loc_3 ~= 0 then
								while true do
									if loc_3 >= 1073741824 then
										desired = 1
										break
									end
									reg_0 = FUNC_LIST[1275](shl_i32(loc_3, 2))
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							else
								while true do
									reg_0 = 0
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 gt_i32(loc_1, 0) then
								while true do
									reg_0 = FUNC_LIST[1119](loc_0, param_2, loc_1)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 break end
							FUNC_LIST[1276](param_2)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						param_0 = load_i32(memory_at_0, loc_2 + 20)
						if param_0 ~= 0 then
							while true do
								store_i32(memory_at_0, loc_2 + 24, param_0)
								FUNC_LIST[1276](param_0)
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
						end
						GLOBAL_LIST[0].value = add_i32(loc_2, 32)
						desired = 0
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					FUNC_LIST[346](add_i32(loc_2, 20))
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[346](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								loc_2 = load_i32(memory_at_0, param_1 + 32)
								if loc_2 == 0 then break 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)
								while true do
									while true do
										if loc_4 ~= 0 then
											while true do
												loc_1 = loc_4
												if loc_0 == loc_11 then
													desired = 7
													break
												end
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										end
										loc_5 = load_i32(memory_at_0, 55020)
										loc_3 = load_i32(memory_at_0, 54900)
										loc_1 = loc_4
										while true do
											if band_i32((loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_5 and 1 or 0)) ~=
												0 then
												desired = 6
												break
											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 continue end
											if loc_0 ~= loc_11 then continue end
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									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 break 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 break 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
									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
											while true do
												if loc_12 == loc_13 then
													desired = 6
													break
												end
												loc_0 = add_i32(loc_0, 1)
												loc_1 = add_i32(loc_0, loc_1)
												if loc_0 <= loc_3 then
													desired = 7
													break
												end
												desired = 6
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil 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 break end
									loc_10 = load_i32_u8(memory_at_0, loc_0 + 4)
									if loc_2 < 2 then
										desired = 5
										break
									end
									loc_19 = load_i32(memory_at_0, 55020)
									loc_6 = load_i32(memory_at_0, 54900)
									loc_16 = 1
									loc_7 = 1
									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)
										while true do
											if (loc_1 == loc_11 and loc_0 or 0) == 0 then
												while true do
													while true do
														while true do
															if loc_1 == loc_6 then break end
															if loc_1 == loc_19 then break end
															loc_14 = 4294967295
															desired = 8
															break
														end
														if desired then
															if desired == 10 then
																desired = nil
																continue
															end
															break
														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 continue end
														if loc_1 ~= loc_11 then continue end
														break
													end
													if desired then break end
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											end
											loc_14 = 4294967295
											loc_15 = load_i32(memory_at_0, loc_0 + 24)
											if loc_15 == loc_12 then break end
											loc_1 = bxor_i32(shr_u32(loc_15, 4), shr_u32(loc_15, 9))
											loc_0 = 0
											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
													while true do
														if loc_1 == loc_12 then
															desired = 8
															break
														end
														loc_0 = add_i32(loc_0, 1)
														loc_1 = add_i32(loc_0, loc_13)
														if loc_0 <= loc_3 then
															desired = 9
															break
														end
														desired = 8
														break
													end
													if desired then
														if desired == 9 then
															desired = nil
															continue
														end
														break
													end
												end
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											if load_i32_u8(memory_at_0, loc_17 + 5) == 0 then break end
											loc_14 = load_i32_u8(memory_at_0, loc_17 + 4)
											break
										end
										if desired then
											if desired == 7 then
												desired = nil
												continue
											end
											break
										end
										if add_i32(loc_7, loc_10) == loc_14 then
											while true do
												loc_7 = add_i32(loc_7, 1)
												loc_16 = (loc_7 < loc_2 and 1 or 0)
												if loc_2 == loc_7 then
													desired = 5
													break
												end
												desired = 7
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									if loc_16 == 0 then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								loc_0 = add_i32(loc_2, loc_9)
								if loc_0 >= 256 then
									desired = 1
									break
								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, (loc_0 < loc_1 and loc_1 or loc_0))
								loc_0 = 0
								loc_3 = 0
								while true do
									loc_1 = add_i32(loc_0, loc_9)
									while true do
										loc_0 = add_i32(loc_0, 1)
										if loc_2 == loc_0 then
											while true do
												reg_0 = FUNC_LIST[347](param_0, loc_4, band_i32(loc_1, 255))
												loc_3 = reg_0
												desired = 7
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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)
										break
									end
									if desired then
										if desired == 6 then
											desired = nil
											continue
										end
										break
									end
									loc_2 = load_i32(memory_at_0, param_1 + 32)
									if loc_0 >= loc_2 then
										desired = 4
										break
									end
									loc_4 = load_i32(
										memory_at_0,
											add_i32(load_i32(memory_at_0, param_1 + 28), shl_i32(loc_0, 2))
									)
									continue
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[240](param_0, 0)
							loc_2 = load_i32(memory_at_0, param_0)
							desired = 3
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					reg_0 = add_i32(load_i32_u8(memory_at_0, param_1 + 32), 1)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			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")
		end
	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
		local desired
		while true do
			loc_3 = add_i32(GLOBAL_LIST[0].value, 4294967232)
			GLOBAL_LIST[0].value = loc_3
			if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
				while true do
					FUNC_LIST[124](
						load_i32(memory_at_0, param_0),
							add_i32(load_i32(memory_at_0, param_1 + 8), 1)
					)
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				while true do
					while true do
						while true do
							if lt_i32(load_i32(memory_at_0, param_0 + 4), 2) then break end
							if load_i32_u8(memory_at_0, param_1 + 36) ~= 0 then break 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)
							while true do
								loc_1 = load_i32(memory_at_0, loc_0 + 4)
								while true do
									if loc_0 == 0 then break end
									if loc_1 ~= loc_11 then break end
									if loc_4 == loc_10 then
										desired = 4
										break
									end
									loc_5 = load_i32(memory_at_0, loc_0 + 24)
									if loc_5 == loc_7 then
										desired = 4
										break
									end
									loc_1 = bxor_i32(shr_u32(loc_5, 4), shr_u32(loc_5, 9))
									loc_0 = 0
									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
											while true do
												if loc_1 == loc_7 then
													desired = 4
													break
												end
												loc_0 = add_i32(loc_0, 1)
												loc_1 = add_i32(loc_0, loc_6)
												if loc_0 <= loc_2 then
													desired = 7
													break
												end
												desired = 4
												break
											end
											if desired then
												if desired == 7 then
													desired = nil
													continue
												end
												break
											end
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									if load_i32_u8(memory_at_0, loc_8 + 8) ~= 0 then
										desired = 4
										break
									end
									loc_0 = load_i32(memory_at_0, loc_8 + 4)
									if loc_0 ~= 0 then
										desired = 5
										break
									end
									desired = 4
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								while true do
									if loc_0 == 0 then break end
									if loc_1 ~= loc_9 then break end
									loc_0 = load_i32(memory_at_0, loc_0 + 24)
									desired = 5
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								while true do
									if loc_0 == 0 then break end
									if loc_1 ~= loc_12 then break end
									loc_0 = load_i32(memory_at_0, loc_0 + 24)
									desired = 5
									break
								end
								if desired then
									if desired == 5 then
										desired = nil
										continue
									end
									break
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if loc_1 ~= load_i32(memory_at_0, 54988) then break end
							while true do
								while true do
									while true do
										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 break end
										loc_7 = load_i32(memory_at_0, param_0 + 44)
										if loc_0 == loc_7 then break 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
										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
												desired = 6
												break
											end
											if loc_5 == loc_7 then
												desired = 7
												break
											end
											loc_1 = add_i32(loc_1, 1)
											loc_2 = add_i32(loc_1, loc_2)
											if loc_1 <= loc_6 then continue end
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									loc_1 = (load_i32_u8(memory_at_0, loc_0 + 68) ~= 0 and 7685 or 2635)
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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
									while true do
										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
											desired = 3
											break
										end
										if load_i32_u8(memory_at_0, loc_1) ~= 0 then
											desired = 4
											break
										end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								loc_1 = 7685
								if load_i32_u8(memory_at_0, loc_0 + 68) ~= 0 then break 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
									desired = 4
									break
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[130](load_i32(memory_at_0, param_0), loc_1, 0)
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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 = (param_3 < loc_0 and loc_0 or param_3)
						loc_10 = load_i32(memory_at_0, param_0 + 196)
						while true do
							while true do
								while true do
									while true do
										while true do
											while true do
												while true do
													while true do
														if param_4 ~= 0 then
															while true do
																loc_1 = sub_i32(loc_0, param_3)
																loc_0 = add_i32(loc_1, loc_10)
																if loc_0 >= 256 then
																	desired = 9
																	break
																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, (loc_0 < loc_1 and loc_1 or loc_0)
																)
																reg_0 = sub_i32(loc_10, param_3)
																desired = 11
																break
															end
															if desired then
																if desired == 11 then desired = nil end
																break
															end
														end
														loc_1 = add_i32(loc_0, loc_10)
														if loc_1 >= 256 then
															desired = 10
															break
														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, (loc_0 > loc_1 and loc_0 or loc_1)
														)
														reg_0 = loc_10
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													loc_4 = reg_0
													while true do
														while true do
															while true do
																loc_0 = add_i32(param_0, 4)
																if le_i32(load_i32(memory_at_0, loc_0), 0) then
																	break
																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
																	desired = 12
																	break
																end
																if param_3 ~= 1 then break end
																if param_5 ~= 0 then break end
																if load_i32(memory_at_0, param_1 + 32) ~= 2 then
																	break
																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 break end
																FUNC_LIST[350](
																	param_0, param_1, param_2, 1, param_4, 0, band_i32(loc_4, 255)
																)
																desired = 4
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															loc_9 = 4294967295
															if load_i32_u8(memory_at_0, param_1 + 36) ~= 0 then
																desired = 11
																break
															end
															desired = 7
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														loc_0 = load_i32_u8(memory_at_0, param_1 + 36)
														while true do
															if lt_i32(loc_9, 0) then break end
															if band_i32(loc_0, 255) ~= 0 then break end
															loc_1 = sub_i32(load_i32(memory_at_0, param_1 + 32), 1)
															if loc_1 > 1 then break 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 break end
															if loc_1 == load_i32(memory_at_0, 54956) then break end
															FUNC_LIST[351](
																param_0, param_1, param_2, param_3, param_4, param_5,
																	band_i32(loc_4, 255), loc_9
															)
															desired = 4
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														loc_13 = (ge_i32(loc_9, 0) and 1 or 0)
														if band_i32(loc_0, 255) == 0 then
															desired = 8
															break
														end
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													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)
													while true do
														while true do
															if loc_8 ~= 0 then
																while true do
																	loc_1 = loc_8
																	if loc_0 == loc_6 then
																		desired = 12
																		break
																	end
																	break
																end
																if desired then
																	if desired == 12 then desired = nil end
																	break
																end
															end
															loc_5 = load_i32(memory_at_0, 55020)
															loc_2 = load_i32(memory_at_0, 54900)
															loc_1 = loc_8
															while true do
																if band_i32(
																	(loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_5 and 1 or 0)
																) ~= 0 then
																	desired = 11
																	break
																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 continue end
																if loc_0 ~= loc_6 then continue end
																break
															end
															if desired then
																if desired == 12 then desired = nil end
																break
															end
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														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 break 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 break 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
														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
																while true do
																	if loc_6 == loc_11 then
																		desired = 11
																		break
																	end
																	loc_0 = add_i32(loc_0, 1)
																	loc_1 = add_i32(loc_0, loc_1)
																	if loc_0 <= loc_2 then
																		desired = 12
																		break
																	end
																	desired = 11
																	break
																end
																if desired then
																	if desired == 12 then
																		desired = nil
																		continue
																	end
																	break
																end
															end
															break
														end
														if desired then
															if desired == 11 then desired = nil 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
															desired = 6
															break
														end
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													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
													desired = 5
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												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")
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											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")
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										loc_12 = 0
										reg_0 = loc_12
										if ge_i32(loc_9, 0) then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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
									desired = 5
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								reg_0 = load_i32_u8(memory_at_0, loc_0 + 4)
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_12 = reg_0
							while true do
								loc_2 = load_i32(memory_at_0, param_1 + 32)
								if loc_2 == 0 then
									while true do
										loc_7 = 0
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								loc_8 = add_i32(loc_4, 1)
								loc_11 = band_i32(loc_4, 255)
								loc_7 = 0
								loc_0 = 0
								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)
									while true do
										loc_1 = add_i32(loc_0, 1)
										if loc_2 == loc_1 then
											while true do
												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
												desired = 7
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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)
										break
									end
									if desired then
										if desired == 6 then
											desired = nil
											continue
										end
										break
									end
									loc_2 = load_i32(memory_at_0, param_1 + 32)
									loc_0 = loc_1
									if loc_2 > loc_0 then continue end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
								while true do
									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
										)
									)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							while true do
								if load_i32_u8(memory_at_0, param_1 + 36) ~= 0 then
									while true do
										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 gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
											while true do
												FUNC_LIST[124](
													load_i32(memory_at_0, param_0),
														add_i32(load_i32(memory_at_0, loc_1 + 32), 1)
												)
												break
											end
											if desired then break end
										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 lt_i32(loc_2, 0) then
											desired = 2
											break
										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)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								if loc_13 == 0 then break 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
									desired = 1
									break
								end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							loc_0 = 0
							loc_1 = 0
							if band_i32(loc_7, 1) == 0 then
								while true do
									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
									)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							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 break end
							if param_4 ~= 0 then break end
							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 continue end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						store_i32(memory_at_0, param_0 + 196, loc_10)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					GLOBAL_LIST[0].value = sub_i32(loc_3, 4294967232)
					desired = 0
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[232](add_i32(loc_1, 8), 6074, 0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[232](add_i32(load_i32(memory_at_0, param_1 + 24), 8), 6181, 0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							if param_1 ~= 0 then
								while true do
									loc_1 = param_1
									if loc_0 == loc_4 then
										desired = 4
										break
									end
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_3 = load_i32(memory_at_0, 55020)
							loc_2 = load_i32(memory_at_0, 54900)
							loc_1 = param_1
							while true do
								if band_i32((loc_0 ~= loc_2 and 1 or 0), (loc_0 ~= loc_3 and 1 or 0)) ~=
									0 then
									desired = 3
									break
								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 continue end
								if loc_0 ~= loc_4 then continue end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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 break 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 break 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
						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
								while true do
									if loc_4 == loc_7 then
										desired = 3
										break
									end
									loc_0 = add_i32(loc_0, 1)
									loc_1 = add_i32(loc_0, loc_1)
									if loc_0 <= loc_2 then
										desired = 4
										break
									end
									desired = 3
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil 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
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, param_0 + 196)
					loc_0 = add_i32(loc_1, 1)
					if loc_0 < 256 then
						while true do
							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, (loc_0 < loc_2 and loc_2 or loc_0))
							FUNC_LIST[348](param_0, param_1, band_i32(loc_1, 255), 1)
							desired = 1
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					store_i64(memory_at_0, loc_5, i64_from_u32(1, 255))
					FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_5)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_5, 16)
			reg_0 = band_i32(loc_1, 255)
			break
		end
		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
		local desired
		while true do
			loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
			GLOBAL_LIST[0].value = loc_3
			while true do
				while true do
					while true do
						while true do
							if gt_i32(load_i32(memory_at_0, param_0 + 4), 0) then
								while true do
									if lt_i32(load_i32(memory_at_0, param_0 + 8), 2) then
										desired = 4
										break
									end
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
							end
							loc_2 = load_i32(memory_at_0, param_1 + 32)
							desired = 3
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_2 = load_i32(memory_at_0, param_1 + 32)
						if loc_2 < load_i32(memory_at_0, param_1 + 40) then break end
						if loc_2 == 0 then
							desired = 2
							break
						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 break 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)
						while true do
							loc_6 = load_i32(memory_at_0, loc_5)
							if loc_6 == loc_8 then
								desired = 3
								break
							end
							loc_1 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
							loc_0 = 0
							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
									while true do
										if loc_1 == loc_8 then
											desired = 3
											break
										end
										loc_0 = add_i32(loc_0, 1)
										loc_1 = add_i32(loc_0, loc_10)
										if loc_0 <= loc_4 then
											desired = 5
											break
										end
										desired = 3
										break
									end
									if desired then
										if desired == 5 then
											desired = nil
											continue
										end
										break
									end
								end
								break
							end
							if desired then
								if desired == 4 then
									desired = nil
									continue
								end
								break
							end
							if load_i32_u8(memory_at_0, loc_11 + 9) == 0 then
								desired = 3
								break
							end
							loc_5 = add_i32(loc_5, 4)
							if loc_9 ~= loc_5 then continue end
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						desired = 2
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_1 = load_i32(memory_at_0, param_0 + 196)
					loc_0 = add_i32(loc_1, loc_2)
					if loc_0 >= 256 then
						desired = 1
						break
					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, (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 break end
					loc_0 = 0
					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 loc_0 < load_i32(memory_at_0, param_1 + 32) then continue end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				GLOBAL_LIST[0].value = add_i32(loc_3, 16)
				desired = 0
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			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")
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										while true do
											if lt_i32(load_i32(memory_at_0, param_0 + 4), 2) then break 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 break 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 break 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
											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
													while true do
														if loc_4 == loc_6 then
															desired = 8
															break
														end
														loc_0 = add_i32(loc_0, 1)
														loc_1 = add_i32(loc_0, loc_1)
														if loc_0 <= loc_2 then
															desired = 9
															break
														end
														desired = 8
														break
													end
													if desired then
														if desired == 9 then
															desired = nil
															continue
														end
														break
													end
												end
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) == 0 then
												break
											end
											loc_3 = load_i32(memory_at_0, param_1 + 32)
											if loc_6 == loc_3 then break end
											loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
											loc_0 = 0
											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
													while true do
														if loc_4 == loc_6 then
															desired = 8
															break
														end
														loc_0 = add_i32(loc_0, 1)
														loc_1 = add_i32(loc_0, loc_1)
														if loc_0 <= loc_2 then
															desired = 9
															break
														end
														desired = 8
														break
													end
													if desired then
														if desired == 9 then
															desired = nil
															continue
														end
														break
													end
												end
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) == 0 then
												break
											end
											loc_3 = load_i32(memory_at_0, param_1 + 40)
											if loc_3 ~= 0 then
												while true do
													if loc_3 == loc_6 then
														desired = 8
														break
													end
													loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
													loc_0 = 0
													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
															while true do
																if loc_4 == loc_6 then
																	desired = 8
																	break
																end
																loc_0 = add_i32(loc_0, 1)
																loc_1 = add_i32(loc_0, loc_1)
																if loc_0 <= loc_2 then
																	desired = 10
																	break
																end
																desired = 8
																break
															end
															if desired then
																if desired == 10 then
																	desired = nil
																	continue
																end
																break
															end
														end
														break
													end
													if desired then break end
													if load_i32(memory_at_0, add_i32(loc_5, mul_i32(loc_1, 24)) + 8) ==
														0 then
														desired = 8
														break
													end
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												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
												desired = 7
												break
											end
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										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
										)
										while true do
											loc_0 = load_i32(memory_at_0, param_0 + 248)
											loc_1 = load_i32(memory_at_0, param_0 + 252)
											if loc_0 < loc_1 then
												while true do
													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))
													desired = 8
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											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 loc_4 >= 536870912 then
												desired = 6
												break
											end
											loc_0 = 0
											loc_1 = sub_i32(loc_1, loc_2)
											loc_7 = shr_i32(loc_1, 2)
											loc_1 = (loc_1 < 2147483640 and (loc_4 < loc_7 and loc_7 or loc_4) or
												        536870911)
											if loc_1 ~= 0 then
												while true do
													if loc_1 >= 536870912 then
														desired = 5
														break
													end
													reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
													loc_0 = reg_0
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											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 gt_i32(loc_5, 0) then
												while true do
													reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_5)
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											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 break end
											FUNC_LIST[1276](loc_2)
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										loc_7 = load_i32(memory_at_0, param_0 + 196)
										loc_11 = add_i32(loc_7, 3)
										if loc_11 >= 256 then
											desired = 4
											break
										end
										store_i32(memory_at_0, param_0 + 196, loc_11)
										loc_0 = load_i32(memory_at_0, param_0 + 200)
										loc_12 = (loc_0 > loc_11 and loc_0 or loc_11)
										store_i32(memory_at_0, param_0 + 200, loc_12)
										while true do
											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 break 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 break 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
											while true do
												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
														desired = 9
														break
													end
													reg_0 = loc_8
													if loc_4 == loc_17 then
														desired = 8
														break
													end
													loc_0 = add_i32(loc_0, 1)
													loc_2 = add_i32(loc_0, loc_2)
													if loc_0 <= loc_1 then continue end
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												reg_0 = loc_8
												desired = 8
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											reg_0 = loc_8
											if load_i32_u8(memory_at_0, add_i32(loc_5, mul_i32(loc_2, 12)) + 8) ==
												0 then break end
											loc_0 = add_i32(loc_7, 4)
											if loc_0 >= 256 then
												desired = 3
												break
											end
											store_i32(memory_at_0, param_0 + 196, loc_0)
											store_i32(
												memory_at_0, param_0 + 200, (loc_0 < loc_12 and loc_12 or loc_0)
											)
											reg_0 = loc_11
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										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)
										while true do
											loc_2 = load_i32(memory_at_0, param_1 + 40)
											if loc_2 ~= 0 then
												while true do
													FUNC_LIST[348](param_0, loc_2, band_i32(add_i32(loc_7, 1), 255), 1)
													desired = 8
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											end
											FUNC_LIST[114](
												load_i32(memory_at_0, param_0), 4, band_i32(add_i32(loc_7, 1), 255),
													1, 0
											)
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										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
											while true do
												FUNC_LIST[114](
													load_i32(memory_at_0, param_0), 6, loc_0, band_i32(loc_8, 255), 0
												)
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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 gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
											while true do
												FUNC_LIST[124](
													load_i32(memory_at_0, param_0),
														add_i32(load_i32(memory_at_0, param_1 + 8), 1)
												)
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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
											desired = 2
											break
										end
										reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_0, loc_4)
										if reg_0 == 0 then
											desired = 1
											break
										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)
										while true do
											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 loc_2 < loc_0 then
												while true do
													FUNC_LIST[343](loc_1, sub_i32(loc_0, loc_2))
													desired = 8
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											end
											if loc_0 >= loc_2 then break end
											store_i32(memory_at_0, loc_1 + 4, add_i32(param_1, shl_i32(loc_0, 3)))
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										store_i32(
											memory_at_0, loc_6 + 4, sub_i32(load_i32(memory_at_0, loc_6 + 4), 8)
										)
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									store_i32(memory_at_0, param_0 + 196, loc_13)
									GLOBAL_LIST[0].value = add_i32(loc_9, 32)
									desired = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								FUNC_LIST[344](loc_6)
								error("out of code bounds")
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[252](5133)
							error("out of code bounds")
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						store_i64(memory_at_0, loc_9, i64_from_u32(3, 255))
						FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_9)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					store_i64(memory_at_0, loc_9 + 16, i64_from_u32(1, 255))
					FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_9, 16))
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
		end
	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 desired
		local br_map = {}
		while true do
			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)
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										loc_2 = load_i32(memory_at_0, param_0 + 248)
										loc_1 = load_i32(memory_at_0, param_0 + 252)
										if loc_2 < loc_1 then
											while true do
												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))
												desired = 7
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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 loc_4 >= 536870912 then
											desired = 6
											break
										end
										loc_2 = 0
										loc_1 = sub_i32(loc_1, loc_5)
										loc_12 = shr_i32(loc_1, 2)
										loc_1 =
											(loc_1 < 2147483640 and (loc_4 < loc_12 and loc_12 or loc_4) or
												536870911)
										if loc_1 ~= 0 then
											while true do
												if loc_1 >= 536870912 then
													desired = 5
													break
												end
												reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 3))
												loc_2 = reg_0
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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 gt_i32(loc_6, 0) then
											while true do
												reg_0 = FUNC_LIST[1119](loc_2, loc_5, loc_6)
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										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 break end
										FUNC_LIST[1276](loc_5)
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									loc_5 = load_i32(memory_at_0, param_0 + 196)
									loc_0 = add_i32(loc_5, 3)
									if loc_0 >= 256 then
										desired = 4
										break
									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, (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 = (loc_4 > 2 and loc_4 or 2)
									loc_0 = add_i32(loc_2, loc_1)
									if loc_0 >= 256 then
										desired = 3
										break
									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, (loc_0 < loc_1 and loc_1 or loc_0)
									)
									loc_6 = 76
									loc_1 = 58
									while true do
										if le_i32(load_i32(memory_at_0, param_0 + 4), 0) then break end
										if loc_4 > 2 then break end
										while true do
											while true do
												while true do
													if not br_map[1] then
														br_map[1] = (function() return { [0] = 0, 1 } end)()
													end
													local temp = br_map[1][sub_i32(
														load_i32(memory_at_0, param_1 + 40), 1
													)] or 3
													if temp < 1 then
														break
													elseif temp > 1 then
														desired = 7
														break
													else
														desired = 9
														break
													end
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												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
													desired = 7
													break
												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
													desired = 7
													break
												end
												loc_0 = load_i32(memory_at_0, loc_3 + 28)
												if loc_0 == 0 then
													desired = 7
													break
												end
												reg_0 = FUNC_LIST[1193](loc_0, 2558)
												if reg_0 == 0 then
													while true do
														loc_6 = 59
														loc_1 = 60
														desired = 7
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												reg_0 = FUNC_LIST[1193](loc_0, 2559)
												if reg_0 ~= 0 then
													desired = 7
													break
												end
												reg_0 = (load_i32_u8(memory_at_0, 55300) ~= 0 and 58 or 62)
												desired = 8
												break
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											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
												desired = 7
												break
											end
											loc_0 = load_i32(memory_at_0, loc_3 + 28)
											if loc_0 == 0 then
												desired = 7
												break
											end
											reg_0 = FUNC_LIST[1193](loc_0, 1615)
											if reg_0 ~= 0 then
												desired = 7
												break
											end
											reg_0 = (load_i32_u8(memory_at_0, 55300) ~= 0 and 58 or 62)
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										loc_1 = reg_0
										loc_6 = 61
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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
										while true do
											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 loc_0 < load_i32(memory_at_0, param_1 + 32) then
													continue
												end
												break
											end
											if desired then break end
											break
										end
										if desired then
											if desired == 6 then desired = nil 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 gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
										while true do
											FUNC_LIST[124](
												load_i32(memory_at_0, param_0),
													add_i32(load_i32(memory_at_0, param_1 + 8), 1)
											)
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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
										while true do
											FUNC_LIST[117](
												load_i32(memory_at_0, param_0), load_i32(memory_at_0, param_1 + 32)
											)
											break
										end
										if desired then
											if desired == 6 then desired = nil end
											break
										end
									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
										desired = 2
										break
									end
									reg_0 = FUNC_LIST[119](load_i32(memory_at_0, param_0), loc_0, loc_6)
									if reg_0 == 0 then
										desired = 1
										break
									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)
									while true do
										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 param_1 < loc_0 then
											while true do
												FUNC_LIST[343](loc_5, sub_i32(loc_0, param_1))
												desired = 7
												break
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										end
										if param_1 <= loc_0 then break end
										store_i32(memory_at_0, loc_5 + 4, add_i32(loc_2, shl_i32(loc_0, 3)))
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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)
									desired = 0
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								FUNC_LIST[344](loc_0)
								error("out of code bounds")
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[252](5133)
							error("out of code bounds")
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						store_i64(memory_at_0, loc_3, i64_from_u32(3, 255))
						FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_3)
						error("out of code bounds")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6181, 0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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))
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										loc_0 = load_i32(memory_at_0, param_1 + 32)
										if loc_0 == 1 then
											while true do
												if load_i32(memory_at_0, param_1 + 40) ~= 1 then
													while true do
														store_i64(memory_at_0, loc_1 + 28, i64_ZERO)
														desired = 7
														break
													end
													if desired then break end
												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
													while true do
														FUNC_LIST[348](
															param_0, loc_5, load_i32_u8(memory_at_0, loc_1 + 44), 0
														)
														desired = 1
														break
													end
													if desired then break end
												end
												loc_0 = load_i32(memory_at_0, loc_5 + 4)
												loc_4 = load_i32(memory_at_0, 54940)
												while true do
													while true do
														if loc_5 ~= 0 then
															while true do
																loc_2 = loc_5
																if loc_0 == loc_4 then
																	desired = 10
																	break
																end
																break
															end
															if desired then
																if desired == 10 then desired = nil end
																break
															end
														end
														loc_6 = load_i32(memory_at_0, 55020)
														loc_3 = load_i32(memory_at_0, 54900)
														loc_2 = loc_5
														while true do
															if band_i32(
																(loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_6 and 1 or 0)
															) ~= 0 then
																desired = 9
																break
															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 continue end
															if loc_0 ~= loc_4 then continue end
															break
														end
														if desired then
															if desired == 10 then desired = nil end
															break
														end
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
													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 break 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 break 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
													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
															while true do
																if loc_4 == loc_8 then
																	desired = 9
																	break
																end
																loc_0 = add_i32(loc_0, 1)
																loc_2 = add_i32(loc_0, loc_2)
																if loc_0 <= loc_3 then
																	desired = 10
																	break
																end
																desired = 9
																break
															end
															if desired then
																if desired == 10 then
																	desired = nil
																	continue
																end
																break
															end
														end
														break
													end
													if desired then
														if desired == 9 then desired = nil 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
														desired = 3
														break
													end
													break
												end
												if desired then break end
												loc_2 = load_i32(memory_at_0, param_0 + 196)
												loc_0 = add_i32(loc_2, 1)
												if loc_0 < 256 then
													while true do
														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, (loc_0 < loc_3 and loc_3 or loc_0)
														)
														FUNC_LIST[348](param_0, loc_5, band_i32(loc_2, 255), 1)
														desired = 2
														break
													end
													if desired then break end
												end
												store_i64(memory_at_0, loc_1, i64_from_u32(1, 255))
												FUNC_LIST[232](add_i32(loc_5, 8), 7407, loc_1)
												error("out of code bounds")
											end
											if desired then
												if desired == 7 then desired = nil end
												break
											end
										end
										store_i32(memory_at_0, loc_1 + 32, 0)
										store_i64(memory_at_0, loc_1 + 24, i64_ZERO)
										if loc_0 == 0 then
											desired = 6
											break
										end
										if loc_0 >= 134217728 then
											desired = 5
											break
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									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)
									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, 4294967232))
										)
										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 loc_0 < load_i32(memory_at_0, param_1 + 32) then
											continue
										end
										break
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									break
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								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 loc_0 >= 256 then
									desired = 4
									break
								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, (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
									while true do
										loc_0 = 0
										while true do
											if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
												while true do
													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
														)
													)
													break
												end
												if desired then
													if desired == 7 then
														desired = nil
														continue
													end
													break
												end
											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 loc_0 < load_i32(memory_at_0, param_1 + 32) then
												continue
											end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
								end
								loc_0 = load_i32(memory_at_0, loc_1 + 24)
								if loc_0 == 0 then
									desired = 1
									break
								end
								store_i32(memory_at_0, loc_1 + 28, loc_0)
								FUNC_LIST[1276](loc_0)
								desired = 1
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							FUNC_LIST[356](add_i32(loc_1, 24))
							error("out of code bounds")
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						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")
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_2 = load_i32_u8(memory_at_0, loc_0 + 4)
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				if gt_i32(load_i32(memory_at_0, param_0 + 8), 0) then
					while true do
						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
							)
						)
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[355](param_0, add_i32(loc_1, 40), band_i32(loc_2, 255), 1)
				break
			end
			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)
			break
		end
	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
		local desired
		while true do
			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)
			)
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										while true do
											loc_1 = load_i32(memory_at_0, loc_2 + 56)
											if loc_1 == 0 then
												while true do
													loc_7 = load_i32_u8(memory_at_0, loc_2 + 60)
													desired = 8
													break
												end
												if desired then
													if desired == 8 then desired = nil end
													break
												end
											end
											loc_7 = load_i32(memory_at_0, param_0 + 196)
											loc_0 = add_i32(loc_7, 1)
											if loc_0 >= 256 then
												desired = 7
												break
											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, (loc_0 < loc_3 and loc_3 or loc_0)
											)
											break
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										while true do
											while true do
												loc_0 = load_i32(memory_at_0, param_1 + 28)
												if loc_0 >= 6 then
													while true do
														if loc_0 ~= 6 then
															desired = 1
															break
														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 loc_0 >= 256 then
															desired = 9
															break
														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, (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
															desired = 5
															break
														end
														loc_5 = shr_i32(sub_i32(loc_1, loc_3), 2)
														desired = 2
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												if loc_1 ~= 0 then
													while true do
														FUNC_LIST[355](
															param_0, add_i32(loc_2, 56), band_i32(loc_7, 255), 0
														)
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												loc_4 = load_i32(memory_at_0, param_1 + 36)
												while true do
													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 break end
													loc_8 = load_i32(memory_at_0, param_0 + 140)
													if loc_8 == loc_4 then break 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
													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
															while true do
																if loc_5 == loc_8 then
																	desired = 10
																	break
																end
																loc_0 = add_i32(loc_0, 1)
																loc_1 = add_i32(loc_0, loc_1)
																if loc_0 <= loc_3 then
																	desired = 11
																	break
																end
																desired = 10
																break
															end
															if desired then
																if desired == 11 then
																	desired = nil
																	continue
																end
																break
															end
														end
														break
													end
													if desired then
														if desired == 10 then desired = nil 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 break 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 lt_i32(loc_0, 0) then
														desired = 8
														break
													end
													if loc_0 < 256 then
														desired = 6
														break
													end
													loc_4 = load_i32(memory_at_0, param_1 + 36)
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												loc_0 = load_i32(memory_at_0, loc_4 + 4)
												loc_5 = load_i32(memory_at_0, 54940)
												while true do
													while true do
														if loc_4 ~= 0 then
															while true do
																loc_1 = loc_4
																if loc_0 == loc_5 then
																	desired = 11
																	break
																end
																break
															end
															if desired then
																if desired == 11 then desired = nil end
																break
															end
														end
														loc_6 = load_i32(memory_at_0, 55020)
														loc_3 = load_i32(memory_at_0, 54900)
														loc_1 = loc_4
														while true do
															if band_i32(
																(loc_0 ~= loc_3 and 1 or 0), (loc_0 ~= loc_6 and 1 or 0)
															) ~= 0 then
																desired = 10
																break
															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 continue end
															if loc_0 ~= loc_5 then continue end
															break
														end
														if desired then
															if desired == 11 then desired = nil end
															break
														end
														break
													end
													if desired then
														if desired == 10 then desired = nil end
														break
													end
													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 break 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 break 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
													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
															while true do
																if loc_5 == loc_9 then
																	desired = 10
																	break
																end
																loc_0 = add_i32(loc_0, 1)
																loc_1 = add_i32(loc_0, loc_1)
																if loc_0 <= loc_3 then
																	desired = 11
																	break
																end
																desired = 10
																break
															end
															if desired then
																if desired == 11 then
																	desired = nil
																	continue
																end
																break
															end
														end
														break
													end
													if desired then
														if desired == 10 then desired = nil 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
														desired = 4
														break
													end
													break
												end
												if desired then
													if desired == 9 then desired = nil end
													break
												end
												loc_1 = load_i32(memory_at_0, param_0 + 196)
												loc_0 = add_i32(loc_1, 1)
												if loc_0 < 256 then
													while true do
														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, (loc_0 < loc_3 and loc_3 or loc_0)
														)
														FUNC_LIST[348](param_0, loc_4, band_i32(loc_1, 255), 1)
														desired = 3
														break
													end
													if desired then
														if desired == 9 then desired = nil end
														break
													end
												end
												store_i64(memory_at_0, loc_2, i64_from_u32(1, 255))
												FUNC_LIST[232](add_i32(loc_4, 8), 7407, loc_2)
												error("out of code bounds")
											end
											if desired then
												if desired == 8 then desired = nil end
												break
											end
											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")
										end
										if desired then
											if desired == 7 then desired = nil end
											break
										end
										FUNC_LIST[232](add_i32(loc_4, 8), 6074, 0)
										error("out of code bounds")
									end
									if desired then
										if desired == 6 then desired = nil end
										break
									end
									store_i64(memory_at_0, loc_2 + 32, i64_from_u32(1, 255))
									FUNC_LIST[232](add_i32(param_1, 8), 7407, add_i32(loc_2, 32))
									error("out of code bounds")
								end
								if desired then
									if desired == 5 then desired = nil end
									break
								end
								loc_1 = load_i32(memory_at_0, param_1 + 28)
								reg_1 = (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)
								)
								desired = 1
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							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 loc_5 > loc_0 then continue end
								break
							end
							if desired then
								if desired == 4 then desired = nil end
								break
							end
							desired = 2
							break
						end
						if desired then
							if desired == 3 then desired = nil end
							break
						end
						loc_1 = load_i32_u8(memory_at_0, loc_0 + 4)
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					loc_0 = load_i32(memory_at_0, param_1 + 28)
					reg_1 = (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)
					)
					desired = 1
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				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 break end
				store_i32(memory_at_0, loc_2 + 44, loc_0)
				FUNC_LIST[1276](loc_0)
				break
			end
			if load_i32(memory_at_0, loc_2 + 56) ~= 0 then
				while true do
					FUNC_LIST[355](param_0, add_i32(loc_2, 56), band_i32(loc_7, 255), 1)
					break
				end
			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)
			break
		end
	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
		local desired
		while true do
			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)
			while true do
				while true do
					while true do
						loc_5 = load_i32(memory_at_0, 54940)
						if (loc_1 == loc_5 and loc_0 or 0) == 0 then
							while true do
								loc_4 = load_i32(memory_at_0, 55020)
								loc_3 = load_i32(memory_at_0, 54900)
								while true do
									if band_i32((loc_1 ~= loc_3 and 1 or 0), (loc_1 ~= loc_4 and 1 or 0)) ~=
										0 then
										desired = 3
										break
									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 continue end
									if loc_1 ~= loc_5 then continue end
									break
								end
								if desired then break end
								break
							end
							if desired then
								if desired == 3 then desired = nil 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 break 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 break 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
						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
								while true do
									if loc_5 == loc_7 then
										desired = 3
										break
									end
									loc_0 = add_i32(loc_0, 1)
									loc_1 = add_i32(loc_0, loc_1)
									if loc_0 <= loc_3 then
										desired = 4
										break
									end
									desired = 3
									break
								end
								if desired then
									if desired == 4 then
										desired = nil
										continue
									end
									break
								end
							end
							break
						end
						if desired then
							if desired == 3 then desired = nil 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
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 2 then desired = nil end
						break
					end
					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 loc_0 < 256 then
						while true do
							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, (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)
							)
							desired = 1
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
					end
					store_i64(memory_at_0, loc_2, i64_from_u32(1, 255))
					FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_2)
					error("out of code bounds")
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				FUNC_LIST[348](
					param_0, load_i32(memory_at_0, param_1 + 32),
						load_i32_u8(memory_at_0, loc_0 + 4), 0
				)
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_2, 48)
			break
		end
	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 = i64_ZERO
		local loc_14 = 0
		local loc_15 = 0
		local loc_16 = 0
		local reg_0, reg_1
		local desired
		while true do
			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)
			while true do
				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 break end
				loc_7 = load_i32(memory_at_0, param_0 + 44)
				if loc_7 == param_1 then break 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
				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
						desired = 1
						break
					end
					loc_1 = 0
					if loc_3 == loc_7 then
						desired = 1
						break
					end
					loc_0 = add_i32(loc_0, 1)
					loc_3 = add_i32(loc_0, loc_6)
					if loc_0 <= loc_2 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				break
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			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 ge_i32(loc_15, 0) then
				while true do
					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)
					while true do
						while true do
							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 loc_3 <=
								shr_i32(sub_i32(load_i32(memory_at_0, param_0 + 276), loc_0), 3) then
								break
							end
							if loc_1 >= 2147483645 then
								desired = 2
								break
							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 break end
							FUNC_LIST[1276](loc_0)
							break
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						while true do
							while true do
								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
									while true do
										while true do
											loc_0 = load_i32(memory_at_0, loc_11)
											while true do
												while true do
													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 break end
													loc_7 = load_i32(memory_at_0, param_0 + 68)
													if loc_7 == loc_0 then break 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
													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
															while true do
																if loc_2 == loc_7 then
																	desired = 8
																	break
																end
																loc_1 = add_i32(loc_1, 1)
																loc_2 = add_i32(loc_1, loc_6)
																if loc_1 <= loc_3 then
																	desired = 9
																	break
																end
																desired = 8
																break
															end
															if desired then
																if desired == 9 then
																	desired = nil
																	continue
																end
																break
															end
														end
														break
													end
													if desired then
														if desired == 8 then desired = nil end
														break
													end
													if load_i32_u8(memory_at_0, loc_8 + 5) == 0 then break end
													loc_13 = load_i64_u8(memory_at_0, loc_8 + 4)
													while true do
														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
															while true do
																loc_2 = 1
																desired = 9
																break
															end
															if desired then
																if desired == 9 then desired = nil end
																break
															end
														end
														loc_7 = load_i32(memory_at_0, param_0 + 116)
														if loc_7 == loc_0 then
															while true do
																loc_2 = 1
																desired = 9
																break
															end
															if desired then
																if desired == 9 then desired = nil end
																break
															end
														end
														loc_3 = sub_i32(div_i32(sub_i32(loc_1, loc_4), 12), 1)
														loc_1 = 0
														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
																while true do
																	if loc_2 == loc_7 then
																		while true do
																			loc_2 = 1
																			desired = 9
																			break
																		end
																		if desired then break end
																	end
																	loc_2 = 1
																	loc_1 = add_i32(loc_1, 1)
																	loc_12 = add_i32(loc_1, loc_6)
																	if loc_1 <= loc_3 then
																		desired = 10
																		break
																	end
																	desired = 9
																	break
																end
																if desired then
																	if desired == 10 then
																		desired = nil
																		continue
																	end
																	break
																end
															end
															break
														end
														if desired then
															if desired == 9 then desired = nil end
															break
														end
														loc_2 = bxor_i32(load_i32_u8(memory_at_0, loc_8 + 8), 1)
														break
													end
													if desired then
														if desired == 8 then desired = nil end
														break
													end
													loc_3 = band_i32(bxor_i32(loc_2, 4294967295), 1)
													loc_0 = load_i32(memory_at_0, loc_5 + 4)
													loc_2 = load_i32(memory_at_0, loc_5 + 8)
													if loc_0 < loc_2 then
														while true do
															store_i64(
																memory_at_0, loc_0, bor_i64(
																	extend_i64_u32(loc_3), shl_i64(loc_13, i64_from_u32(32, 0))
																)
															)
															store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, 8))
															desired = 7
															break
														end
														if desired then
															if desired == 8 then desired = nil end
															break
														end
													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 loc_0 >= 536870912 then
														desired = 4
														break
													end
													while true do
														loc_2 = sub_i32(loc_2, loc_1)
														loc_7 = shr_i32(loc_2, 2)
														loc_2 =
															(loc_2 < 2147483640 and (loc_0 < loc_7 and loc_7 or loc_0) or
																536870911)
														if loc_2 ~= 0 then
															while true do
																if loc_2 >= 536870912 then
																	desired = 9
																	break
																end
																reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
																break
															end
															if desired then
																if desired == 9 then desired = nil end
																break
															end
														else
															while true do
																reg_0 = 0
																break
															end
															if desired then
																if desired == 9 then desired = nil end
																break
															end
														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, i64_from_u32(32, 0))
															)
														)
														loc_3 = add_i32(loc_0, shl_i32(loc_2, 3))
														loc_2 = add_i32(loc_4, 8)
														if gt_i32(loc_6, 0) then
															while true do
																reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_6)
																break
															end
															if desired then
																if desired == 9 then desired = nil end
																break
															end
														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
															desired = 7
															break
														end
														FUNC_LIST[1276](loc_1)
														desired = 7
														break
													end
													if desired then
														if desired == 8 then desired = nil end
														break
													end
													FUNC_LIST[252](5133)
													error("out of code bounds")
												end
												if desired then
													if desired == 7 then desired = nil end
													break
												end
												while true do
													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 break end
													loc_7 = load_i32(memory_at_0, param_0 + 164)
													if loc_0 == loc_7 then break 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
													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
															while true do
																if loc_3 == loc_7 then
																	desired = 8
																	break
																end
																loc_1 = add_i32(loc_1, 1)
																loc_3 = add_i32(loc_1, loc_6)
																if loc_1 <= loc_2 then
																	desired = 9
																	break
																end
																desired = 8
																break
															end
															if desired then
																if desired == 9 then
																	desired = nil
																	continue
																end
																break
															end
														end
														break
													end
													if desired then
														if desired == 8 then desired = nil end
														break
													end
													if load_i32(memory_at_0, loc_8 + 8) == 0 then break end
													while true do
														loc_1 = load_i32(memory_at_0, param_0 + 196)
														loc_0 = add_i32(loc_1, 1)
														if loc_0 < 256 then
															while true do
																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, (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 loc_0 < loc_2 then
																	while true do
																		store_i64(
																			memory_at_0, loc_0,
																				shl_i64(extend_i64_u32(loc_3), i64_from_u32(32, 0))
																		)
																		store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, 8))
																		desired = 7
																		break
																	end
																	if desired then break end
																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 loc_0 >= 536870912 then
																	desired = 4
																	break
																end
																loc_2 = sub_i32(loc_2, loc_1)
																loc_7 = shr_i32(loc_2, 2)
																loc_2 = (loc_2 < 2147483640 and
																	        (loc_0 < loc_7 and loc_7 or loc_0) or 536870911)
																if loc_2 ~= 0 then
																	while true do
																		if loc_2 >= 536870912 then
																			desired = 9
																			break
																		end
																		reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
																		break
																	end
																	if desired then break end
																else
																	while true do
																		reg_0 = 0
																		break
																	end
																	if desired then break end
																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), i64_from_u32(32, 0))
																)
																loc_3 = add_i32(loc_0, shl_i32(loc_2, 3))
																loc_2 = add_i32(loc_4, 8)
																if gt_i32(loc_6, 0) then
																	while true do
																		reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_6)
																		break
																	end
																	if desired then break end
																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
																	desired = 7
																	break
																end
																FUNC_LIST[1276](loc_1)
																desired = 7
																break
															end
															if desired then
																if desired == 9 then desired = nil end
																break
															end
														end
														store_i64(memory_at_0, loc_10, i64_from_u32(1, 255))
														FUNC_LIST[232](add_i32(param_1, 8), 7407, loc_10)
														error("out of code bounds")
													end
													if desired then
														if desired == 8 then desired = nil end
														break
													end
													FUNC_LIST[252](5133)
													error("out of code bounds")
												end
												if desired then
													if desired == 7 then desired = nil end
													break
												end
												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 loc_0 < loc_2 then
													while true do
														store_i64(
															memory_at_0, loc_0, bor_i64(
																shl_i64(extend_i64_u32(loc_3), i64_from_u32(32, 0)),
																	i64_from_u32(2, 0)
															)
														)
														store_i32(memory_at_0, loc_5 + 4, add_i32(loc_0, 8))
														desired = 7
														break
													end
													if desired then
														if desired == 7 then desired = nil end
														break
													end
												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 loc_0 >= 536870912 then
													desired = 4
													break
												end
												loc_2 = sub_i32(loc_2, loc_1)
												loc_7 = shr_i32(loc_2, 2)
												loc_2 =
													(loc_2 < 2147483640 and (loc_0 < loc_7 and loc_7 or loc_0) or
														536870911)
												if loc_2 ~= 0 then
													while true do
														if loc_2 >= 536870912 then
															desired = 3
															break
														end
														reg_0 = FUNC_LIST[1275](shl_i32(loc_2, 3))
														break
													end
													if desired then
														if desired == 7 then desired = nil end
														break
													end
												else
													while true do
														reg_0 = 0
														break
													end
													if desired then
														if desired == 7 then desired = nil end
														break
													end
												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), i64_from_u32(32, 0)),
															i64_from_u32(2, 0)
													)
												)
												loc_3 = add_i32(loc_0, shl_i32(loc_2, 3))
												loc_2 = add_i32(loc_4, 8)
												if gt_i32(loc_6, 0) then
													while true do
														reg_0 = FUNC_LIST[1119](loc_0, loc_1, loc_6)
														break
													end
													if desired then
														if desired == 7 then desired = nil end
														break
													end
												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 break end
												FUNC_LIST[1276](loc_1)
												break
											end
											if desired then
												if desired == 6 then
													desired = nil
													continue
												end
												break
											end
											loc_11 = add_i32(loc_11, 4)
											if loc_11 ~= loc_16 then continue end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 4 then desired = nil end
										break
									end
								end
								while true do
									while true do
										if le_i32(load_i32(memory_at_0, param_0 + 4), 0) then break end
										reg_0 = FUNC_LIST[359](param_0, param_1)
										if reg_0 == 0 then break end
										if load_i32_u8(memory_at_0, param_0 + 205) ~= 0 then break 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 loc_0 > 32767 then break end
										FUNC_LIST[116](
											load_i32(memory_at_0, param_0), 64, param_2,
												shr_i32(shl_i32(loc_0, 16), 16)
										)
										desired = 5
										break
									end
									if desired then
										if desired == 5 then desired = nil end
										break
									end
									FUNC_LIST[116](load_i32(memory_at_0, param_0), 19, param_2, loc_15)
									break
								end
								if desired then
									if desired == 4 then desired = nil end
									break
								end
								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
									while true do
										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 continue end
											break
										end
										if desired then break end
										break
									end
									if desired then
										if desired == 4 then desired = nil end
										break
									end
								end
								store_i32(memory_at_0, param_0 + 196, loc_14)
								GLOBAL_LIST[0].value = add_i32(loc_10, 16)
								desired = 0
								break
							end
							if desired then
								if desired == 3 then desired = nil end
								break
							end
							FUNC_LIST[360](loc_5)
							error("out of code bounds")
						end
						if desired then
							if desired == 2 then desired = nil end
							break
						end
						FUNC_LIST[252](5133)
						error("out of code bounds")
					end
					if desired then break end
					FUNC_LIST[252](5133)
					error("out of code bounds")
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			FUNC_LIST[232](add_i32(param_1, 8), 6128, 0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			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 load_i32(memory_at_0, param_0 + 12) >= shr_u32(mul_i32(loc_0, 3), 2) then
				while true do
					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)
					break
				end
			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
			while true do
				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
						while true do
							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)
							)
							desired = 1
							break
						end
						if desired then
							if desired == 2 then
								desired = nil
								continue
							end
							break
						end
					end
					if param_1 == loc_1 then
						desired = 1
						break
					end
					loc_0 = add_i32(loc_0, 1)
					param_1 = add_i32(loc_0, loc_6)
					if loc_0 <= loc_4 then continue end
					break
				end
				if desired then
					if desired == 1 then desired = nil end
					break
				end
				loc_2 = 0
				break
			end
			reg_0 = add_i32(loc_2, 4)
			break
		end
		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)
		while true do
			FUNC_LIST[1388](param_0)
			error("out of code bounds")
		end
	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
		local desired
		while true do
			loc_1 = load_i32(memory_at_0, param_0 + 8)
			loc_0 = load_i32(memory_at_0, param_0 + 4)
			if param_1 <= shr_i32(sub_i32(loc_1, loc_0), 2) then
				while true do
					if param_1 ~= 0 then
						while true do
							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)
							break
						end
						if desired then break end
					end
					store_i32(memory_at_0, param_0 + 4, loc_0)
					desired = 0
					break
				end
				if desired then
					if desired == 0 then desired = nil end
					break
				end
			end
			while true do
				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 loc_4 < 1073741824 then
					while true do
						loc_0 = 0
						loc_1 = sub_i32(loc_1, loc_2)
						loc_6 = shr_i32(loc_1, 1)
						loc_1 = (loc_1 < 2147483644 and (loc_4 < loc_6 and loc_6 or loc_4) or
							        1073741823)
						if loc_1 ~= 0 then
							while true do
								if loc_1 >= 1073741824 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1275](shl_i32(loc_1, 2))
								loc_0 = reg_0
								break
							end
							if desired then break end
						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 gt_i32(loc_3, 0) then
							while true do
								reg_0 = FUNC_LIST[1119](loc_0, loc_2, loc_3)
								break
							end
							if desired then break end
						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
							while true do
								FUNC_LIST[1276](loc_2)
								break
							end
							if desired then break end
						end
						desired = 0
						break
					end
					if desired then
						if desired == 1 then desired = nil end
						break
					end
				end
				FUNC_LIST[250](param_0)
				error("out of code bounds")
			end
			if desired then
				if desired == 0 then desired = nil end
				break
			end
			FUNC_LIST[252](5133)
			error("out of code bounds")
		end
	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 desired
		local br_map = {}
		while true do
			loc_6 = sub_i32(GLOBAL_LIST[0].value, 32)
			GLOBAL_LIST[0].value = loc_6
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										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 break end
											loc_5 = load_i32(memory_at_0, param_0 + 140)
											if loc_5 == param_1 then break 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
											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
													while true do
														if loc_1 == loc_5 then
															desired = 8
															break
														end
														loc_0 = add_i32(loc_0, 1)
														loc_1 = add_i32(loc_0, loc_4)
														if loc_0 <= loc_2 then
															desired = 9
															break
														end
														desired = 8
														break
													end
													if desired then
														if desired == 9 then
															desired = nil
															continue
														end

this is awesome :D