Luau Web module, compiled to WebAssembly, then to Luau.

Luau.Web.lua

-- Brought to you by `https://github.com/Rerumu/Wasynth`

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 bit_and = bit32.band
	local bit_xor = bit32.bxor
	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)
		return bit_xor(num, 0x80000000) - 0x80000000
	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_modf = math.modf
		local math_round = math.round
		local math_sign = math.sign
		local math_min = math.min
		local math_max = math.max

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

		function add.i32(lhs, rhs)
			return bit_and(lhs + rhs, 0xFFFFFFFF)
		end

		function sub.i32(lhs, rhs)
			return bit_and(lhs - rhs, 0xFFFFFFFF)
		end

		function mul.i32(lhs, rhs)
			if (lhs + rhs) < 0x8000000 then
				return bit_and(lhs * rhs, 0xFFFFFFFF)
			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 bit_and(c00 + bit_lshift(c16, 16), 0xFFFFFFFF)
			end
		end

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

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

			return bit_and(math_modf(lhs / rhs), 0xFFFFFFFF)
		end

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

			return bit_and(math_modf(lhs / rhs), 0xFFFFFFFF)
		end

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

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

			return bit_and(math_fmod(lhs, rhs), 0xFFFFFFFF)
		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

		local CP_INSTANCE = buffer.create(8)

		local buffer_write_f64 = buffer.writef64
		local buffer_read_i8 = buffer.readi8

		function copysign.f32(lhs, rhs)
			buffer_write_f64(CP_INSTANCE, 0, rhs)

			if buffer_read_i8(CP_INSTANCE, 7) >= 0 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
				return result - math_sign(result)
			else
				return result
			end
		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 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 bit_and(truncate_f64(num), 0xFFFFFFFF)
		end

		truncate.i32_f64 = truncate.i32_f32

		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 bit_and(temp, 0xFFFFFFFF)
		end

		saturate.i32_f64 = saturate.i32_f32

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

			return 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 bit_and(num - 0x100, 0xFFFFFFFF)
			else
				return num
			end
		end

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

			if num >= 0x8000 then
				return bit_and(num - 0x10000, 0xFFFFFFFF)
			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

		local RE_INSTANCE = buffer.create(8)

		local buffer_read_f32 = buffer.readf32
		local buffer_read_f64 = buffer.readf64
		local buffer_read_u32 = buffer.readu32

		local buffer_write_f32 = buffer.writef32
		local buffer_write_f64 = buffer.writef64
		local buffer_write_u32 = buffer.writeu32

		function reinterpret.i32_f32(num)
			buffer_write_f32(RE_INSTANCE, 0, num)

			return buffer_read_u32(RE_INSTANCE, 0)
		end

		function reinterpret.i64_f64(num)
			buffer_write_f64(RE_INSTANCE, 0, num)

			local data_1 = buffer_read_u32(RE_INSTANCE, 0)
			local data_2 = buffer_read_u32(RE_INSTANCE, 4)

			return num_from_u32(data_1, data_2)
		end

		function reinterpret.f32_i32(num)
			buffer_write_u32(RE_INSTANCE, 0, num)

			return buffer_read_f32(RE_INSTANCE, 0)
		end

		function reinterpret.f64_i64(num)
			local data_1, data_2 = num_into_u32(num)

			buffer_write_u32(RE_INSTANCE, 0, data_1)
			buffer_write_u32(RE_INSTANCE, 4, data_2)

			return buffer_read_f64(RE_INSTANCE, 0)
		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 string_sub = string.sub

		local buffer_create = buffer.create
		local buffer_to_string = buffer.tostring
		local buffer_from_string = buffer.fromstring

		local buffer_len = buffer.len
		local buffer_copy = buffer.copy
		local buffer_fill = buffer.fill

		local buffer_read_i8 = buffer.readi8
		local buffer_read_u8 = buffer.readu8
		local buffer_read_i16 = buffer.readi16
		local buffer_read_u16 = buffer.readu16
		local buffer_read_i32 = buffer.readi32
		local buffer_read_u32 = buffer.readu32
		local buffer_read_f32 = buffer.readf32
		local buffer_read_f64 = buffer.readf64

		local buffer_write_u8 = buffer.writeu8
		local buffer_write_u16 = buffer.writeu16
		local buffer_write_u32 = buffer.writeu32
		local buffer_write_f32 = buffer.writef32
		local buffer_write_f64 = buffer.writef64

		function load.i32_i8(memory, addr)
			return bit_and(buffer_read_i8(memory, addr), 0xFFFFFFFF)
		end

		function load.i32_u8(memory, addr)
			return buffer_read_u8(memory, addr)
		end

		function load.i32_i16(memory, addr)
			return bit_and(buffer_read_i16(memory, addr), 0xFFFFFFFF)
		end

		function load.i32_u16(memory, addr)
			return buffer_read_u16(memory, addr)
		end

		function load.i32(memory, addr)
			return buffer_read_u32(memory, addr)
		end

		function load.i64_i8(memory, addr)
			local value = buffer_read_i8(memory, addr)

			if value >= 0 then
				return num_from_u32(value, 0)
			else
				return num_from_u32(value + 0x100000000, 0xFFFFFFFF)
			end
		end

		function load.i64_u8(memory, addr)
			return num_from_u32(buffer_read_u8(memory, addr), 0)
		end

		function load.i64_i16(memory, addr)
			local value = buffer_read_i16(memory, addr)

			if value >= 0 then
				return num_from_u32(value, 0)
			else
				return num_from_u32(value + 0x100000000, 0xFFFFFFFF)
			end
		end

		function load.i64_u16(memory, addr)
			return num_from_u32(buffer_read_u16(memory, addr), 0)
		end

		function load.i64_i32(memory, addr)
			local value = buffer_read_i32(memory, addr)

			if value >= 0 then
				return num_from_u32(value, 0)
			else
				return num_from_u32(value + 0x100000000, 0xFFFFFFFF)
			end
		end

		function load.i64_u32(memory, addr)
			return num_from_u32(buffer_read_u32(memory, addr), 0)
		end

		function load.i64(memory, addr)
			local value_1 = buffer_read_u32(memory, addr)
			local value_2 = buffer_read_u32(memory, addr + 4)

			return num_from_u32(value_1, value_2)
		end

		function load.f32(memory, addr)
			return buffer_read_f32(memory, addr)
		end

		function load.f64(memory, addr)
			return buffer_read_f64(memory, addr)
		end

		function load.string(memory, addr, len)
			local temp = buffer_create(len)

			buffer_copy(temp, 0, memory.data, addr, len)

			return buffer_to_string(temp)
		end

		function store.i32_n8(memory, addr, value)
			buffer_write_u8(memory, addr, value)
		end

		function store.i32_n16(memory, addr, value)
			buffer_write_u16(memory, addr, value)
		end

		function store.i32(memory, addr, value)
			buffer_write_u32(memory, addr, value)
		end

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

			buffer_write_u8(memory, addr, value_1)
		end

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

			buffer_write_u16(memory, addr, value_1)
		end

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

			buffer_write_u32(memory, addr, value_1)
		end

		function store.i64(memory, addr, value)
			local value_1, value_2 = num_into_u32(value)

			buffer_write_u32(memory, addr, value_1)
			buffer_write_u32(memory, addr + 4, value_2)
		end

		function store.f32(memory, addr, value)
			buffer_write_f32(memory, addr, value)
		end

		function store.f64(memory, addr, value)
			buffer_write_f64(memory, addr, value)
		end

		function store.string(memory, addr, data, len)
			local content = if not len or len == #data then data else string_sub(data, 1, len)
			local temp = buffer_from_string(content)

			buffer_copy(memory.data, addr, temp)
		end

		function store.copy(memory_1, addr_1, memory_2, addr_2, len)
			buffer_copy(memory_1.data, addr_1, memory_2.data, addr_2, len)
		end

		function store.fill(memory, addr, len, value)
			buffer_fill(memory.data, addr, value, len)
		end

		local WASM_PAGE_SIZE = 65536

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

		function allocator.size(memory)
			return buffer_len(memory.data) / WASM_PAGE_SIZE
		end

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

			if new <= memory.max then
				local reallocated = buffer_create(new * WASM_PAGE_SIZE)

				buffer_copy(reallocated, 0, memory.data)

				memory.data = reallocated

				return old
			else
				return 0xFFFFFFFF
			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_i64 = rt.div.i64
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 = buffer.readf32
local load_f64 = buffer.readf64
local load_i32 = buffer.readu32
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 rem_i64 = rt.rem.i64
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 = buffer.writef32
local store_f64 = buffer.writef64
local store_i32 = buffer.writeu32
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_n16 = rt.store.i64_n16
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(1643)
local TABLE_LIST = table.create(0)
local MEMORY_LIST = table.create(0)
local GLOBAL_LIST = table.create(1)
FUNC_LIST[35] = --[[ __wasm_call_ctors ]] function()
	while true do
		FUNC_LIST[1317]()
		FUNC_LIST[61]()
		FUNC_LIST[111]()
		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[228]()
		FUNC_LIST[229]()
		FUNC_LIST[230]()
		FUNC_LIST[231]()
		FUNC_LIST[232]()
		FUNC_LIST[233]()
		FUNC_LIST[234]()
		FUNC_LIST[235]()
		FUNC_LIST[236]()
		FUNC_LIST[237]()
		FUNC_LIST[238]()
		FUNC_LIST[239]()
		FUNC_LIST[240]()
		FUNC_LIST[241]()
		FUNC_LIST[242]()
		FUNC_LIST[243]()
		FUNC_LIST[244]()
		FUNC_LIST[245]()
		FUNC_LIST[246]()
		FUNC_LIST[247]()
		FUNC_LIST[248]()
		FUNC_LIST[249]()
		FUNC_LIST[250]()
		FUNC_LIST[251]()
		FUNC_LIST[252]()
		FUNC_LIST[425]()
		FUNC_LIST[562]()
		FUNC_LIST[649]()
		FUNC_LIST[723]()
		FUNC_LIST[737]()
		FUNC_LIST[1087]()
		FUNC_LIST[1215]()
		FUNC_LIST[1366]()
		break
	end
end
FUNC_LIST[36] = --[[ executeScript ]] function(loc_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 = sub_i32(GLOBAL_LIST[0].value, 352)
		GLOBAL_LIST[0].value = loc_1
		while true do
			loc_2 = load_i32(memory_at_0.data, 0 + 59792)
			if loc_2 == 0 then
				break
			end
			while true do
				while true do
					reg_0 = FUNC_LIST[1385](load_i32(memory_at_0.data, loc_2 + 4), 1600, 4)
					if reg_0 ~= 0 then
						break
					end
					store_i32_n8(memory_at_0.data, loc_2, 1)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_2 + 8)
				if loc_2 ~= 0 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
		reg_0 = FUNC_LIST[678]()
		loc_2 = reg_0
		store_i32(memory_at_0.data, 0 + 67480, 0)
		FUNC_LIST[0](1, loc_2)
		loc_3 = load_i32(memory_at_0.data, 0 + 67480)
		store_i32(memory_at_0.data, 0 + 67480, 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_3 == 1 then
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[1](2, loc_2, 3, 10291, 0, 0)
												loc_3 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_3 == 1 then
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[2](4, loc_2, 4294957294, 10291)
												loc_3 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_3 == 1 then
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[0](5, loc_2)
												loc_3 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_3 == 1 then
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[0](6, loc_2)
												loc_3 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_3 == 1 then
													break
												end
												while true do
													if load_i32_u8(memory_at_0.data, 0 + 59808) ~= 0 then
														break
													end
													store_i64(memory_at_0.data, 0 + 59796, i64_ZERO)
													store_i32(memory_at_0.data, 0 + 59804, 0)
													reg_0 = FUNC_LIST[1274](7, 0, 1024)
													store_i32_n8(memory_at_0.data, 0 + 59808, 1)
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												while true do
													reg_0 = FUNC_LIST[1383](loc_0)
													loc_3 = reg_0
													if loc_3 < 4294967280 then
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													FUNC_LIST[0](8, add_i32(loc_1, 8))
													loc_1 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 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
												while true do
													while true do
														while true do
															if loc_3 < 11 then
																break
															end
															store_i32(memory_at_0.data, 0 + 67480, 0)
															loc_4 = band_i32(add_i32(loc_3, 16), 4294967280)
															reg_0 = FUNC_LIST[3](9, loc_4)
															loc_5 = reg_0
															loc_6 = load_i32(memory_at_0.data, 0 + 67480)
															store_i32(memory_at_0.data, 0 + 67480, 0)
															if loc_6 == 1 then
																desired = 9
																break
															end
															store_i32(memory_at_0.data, loc_1 + 8, loc_5)
															store_i32(memory_at_0.data, loc_1 + 12, loc_3)
															store_i32(memory_at_0.data, loc_1 + 16, bor_i32(loc_4, 2147483648))
															desired = 12
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														store_i32_n8(memory_at_0.data, loc_1 + 19, loc_3)
														loc_5 = add_i32(loc_1, 8)
														if loc_3 == 0 then
															desired = 11
															break
														end
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													reg_0 = FUNC_LIST[1224](loc_5, loc_0, loc_3)
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32_n8(memory_at_0.data, add_i32(loc_5, loc_3), 0)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												store_i32(memory_at_0.data, loc_1 + 348, 0)
												loc_3 = load_i32_i8(memory_at_0.data, loc_1 + 19)
												loc_5 = (if lt_i32(loc_3, 0) then 1 else 0)
												reg_0 = FUNC_LIST[4](10, (if loc_5 ~= 0 then load_i32(memory_at_0.data, loc_1 + 8) else add_i32(loc_1, 8)), (if loc_5 ~= 0 then load_i32(memory_at_0.data, loc_1 + 12) else band_i32(loc_3, 255)), 0, add_i32(loc_1, 348))
												loc_3 = reg_0
												loc_5 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_5 == 1 then
													desired = 4
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												reg_0 = FUNC_LIST[5](11, loc_2, 5021, loc_3, load_i32(memory_at_0.data, loc_1 + 348), 0)
												loc_0 = reg_0
												loc_5 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_5 == 1 then
													desired = 4
													break
												end
												FUNC_LIST[1433](loc_3)
												while true do
													if loc_0 == 0 then
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													reg_0 = FUNC_LIST[6](12, loc_2, 4294967295, add_i32(loc_1, 56))
													loc_0 = reg_0
													loc_3 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_3 == 1 then
														desired = 4
														break
													end
													while true do
														loc_3 = load_i32(memory_at_0.data, loc_1 + 56)
														if loc_3 < 4294967280 then
															break
														end
														store_i32(memory_at_0.data, 0 + 67480, 0)
														FUNC_LIST[0](8, add_i32(loc_1, 24))
														loc_3 = load_i32(memory_at_0.data, 0 + 67480)
														store_i32(memory_at_0.data, 0 + 67480, 0)
														if loc_3 ~= 1 then
															desired = 1
															break
														end
														desired = 4
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														while true do
															while true do
																if loc_3 < 11 then
																	break
																end
																store_i32(memory_at_0.data, 0 + 67480, 0)
																loc_4 = band_i32(add_i32(loc_3, 16), 4294967280)
																reg_0 = FUNC_LIST[3](9, loc_4)
																loc_5 = reg_0
																loc_6 = load_i32(memory_at_0.data, 0 + 67480)
																store_i32(memory_at_0.data, 0 + 67480, 0)
																if loc_6 == 1 then
																	desired = 4
																	break
																end
																store_i32(memory_at_0.data, loc_1 + 24, loc_5)
																store_i32(memory_at_0.data, loc_1 + 28, loc_3)
																store_i32(memory_at_0.data, loc_1 + 32, bor_i32(loc_4, 2147483648))
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															store_i32_n8(memory_at_0.data, loc_1 + 35, loc_3)
															loc_5 = add_i32(loc_1, 24)
															if loc_3 == 0 then
																desired = 12
																break
															end
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														reg_0 = FUNC_LIST[1224](loc_5, loc_0, loc_3)
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													store_i32_n8(memory_at_0.data, add_i32(loc_5, loc_3), 0)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													FUNC_LIST[7](13, loc_2, 4294967294)
													loc_3 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_3 ~= 1 then
														desired = 5
														break
													end
													reg_0 = FUNC_LIST[8]()
													loc_3 = reg_0
													reg_0 = FUNC_LIST[1449]()
													if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 35), 4294967295) then
														desired = 3
														break
													end
													FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 24))
													desired = 3
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												reg_0 = FUNC_LIST[3](14, loc_2)
												loc_3 = reg_0
												loc_5 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_5 == 1 then
													desired = 4
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[7](15, loc_2, 4294967294)
												loc_5 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_5 == 1 then
													desired = 4
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[7](16, loc_2, 4294967293)
												loc_5 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_5 == 1 then
													desired = 4
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												FUNC_LIST[2](17, loc_2, loc_3, 1)
												loc_5 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_5 == 1 then
													desired = 4
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												reg_0 = FUNC_LIST[6](18, loc_3, 0, 0)
												loc_5 = reg_0
												loc_0 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_0 == 1 then
													desired = 4
													break
												end
												while true do
													if loc_5 ~= 0 then
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													reg_0 = FUNC_LIST[3](19, loc_3)
													loc_5 = reg_0
													loc_0 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_0 == 1 then
														desired = 4
														break
													end
													while true do
														if loc_5 == 0 then
															break
														end
														store_i32(memory_at_0.data, 0 + 67480, 0)
														FUNC_LIST[2](20, loc_3, 20, 1915)
														loc_0 = load_i32(memory_at_0.data, 0 + 67480)
														store_i32(memory_at_0.data, 0 + 67480, 0)
														if loc_0 == 1 then
															desired = 4
															break
														end
														store_i32(memory_at_0.data, 0 + 67480, 0)
														reg_0 = FUNC_LIST[6](21, loc_3, 4294957294, 1935)
														loc_0 = load_i32(memory_at_0.data, 0 + 67480)
														store_i32(memory_at_0.data, 0 + 67480, 0)
														if loc_0 == 1 then
															desired = 4
															break
														end
														store_i32(memory_at_0.data, 0 + 67480, 0)
														FUNC_LIST[7](22, loc_3, 1)
														loc_0 = load_i32(memory_at_0.data, 0 + 67480)
														store_i32(memory_at_0.data, 0 + 67480, 0)
														if loc_0 == 1 then
															desired = 4
															break
														end
														store_i32(memory_at_0.data, 0 + 67480, 0)
														reg_0 = FUNC_LIST[4](23, loc_3, loc_5, 0, 0)
														loc_3 = load_i32(memory_at_0.data, 0 + 67480)
														store_i32(memory_at_0.data, 0 + 67480, 0)
														if loc_3 == 1 then
															desired = 4
															break
														end
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													FUNC_LIST[7](13, loc_2, 4294967294)
													loc_3 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_3 == 1 then
														desired = 4
														break
													end
													store_i32(memory_at_0.data, add_i32(loc_1, 32), 0)
													store_i64(memory_at_0.data, loc_1 + 24, i64_ZERO)
													desired = 5
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32(memory_at_0.data, add_i32(loc_1, 32), 0)
												store_i64(memory_at_0.data, loc_1 + 24, i64_ZERO)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												reg_0 = FUNC_LIST[4](24, loc_2, 0, 4946, add_i32(loc_1, 56))
												loc_6 = reg_0
												loc_0 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												if loc_0 == 1 then
													desired = 7
													break
												end
												while true do
													if loc_6 == 0 then
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													reg_0 = FUNC_LIST[9](25, add_i32(loc_1, 24), load_i32(memory_at_0.data, loc_1 + 68))
													loc_0 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_0 == 1 then
														desired = 7
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													FUNC_LIST[7](26, add_i32(loc_1, 24), 58)
													loc_0 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_0 == 1 then
														desired = 7
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													FUNC_LIST[7](27, add_i32(loc_1, 40), load_i32(memory_at_0.data, loc_1 + 76))
													loc_0 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													while true do
														while true do
															if loc_0 == 1 then
																break
															end
															store_i32(memory_at_0.data, 0 + 67480, 0)
															loc_0 = load_i32_u8(memory_at_0.data, loc_1 + 51)
															loc_6 = (if lt_i32(shr_i32(shl_i32(loc_0, 24), 24), 0) then 1 else 0)
															reg_0 = FUNC_LIST[6](28, add_i32(loc_1, 24), (if loc_6 ~= 0 then load_i32(memory_at_0.data, loc_1 + 40) else add_i32(loc_1, 40)), (if loc_6 ~= 0 then load_i32(memory_at_0.data, loc_1 + 44) else loc_0))
															loc_0 = load_i32(memory_at_0.data, 0 + 67480)
															store_i32(memory_at_0.data, 0 + 67480, 0)
															if loc_0 == 1 then
																desired = 12
																break
															end
															while true do
																if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 51), 4294967295) then
																	break
																end
																FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 40))
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															store_i32(memory_at_0.data, 0 + 67480, 0)
															reg_0 = FUNC_LIST[9](25, add_i32(loc_1, 24), 12594)
															loc_0 = load_i32(memory_at_0.data, 0 + 67480)
															store_i32(memory_at_0.data, 0 + 67480, 0)
															if loc_0 ~= 1 then
																desired = 11
																break
															end
															desired = 7
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														reg_0 = FUNC_LIST[8]()
														loc_3 = reg_0
														reg_0 = FUNC_LIST[1449]()
														desired = 6
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													reg_0 = FUNC_LIST[8]()
													loc_3 = reg_0
													reg_0 = FUNC_LIST[1449]()
													if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 51), 4294967295) then
														desired = 6
														break
													end
													FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 40))
													desired = 6
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												while true do
													if loc_5 ~= 1 then
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													reg_0 = FUNC_LIST[9](25, add_i32(loc_1, 24), 1234)
													loc_5 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_5 == 1 then
														desired = 7
														break
													end
													desired = 8
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32(memory_at_0.data, 0 + 67480, 0)
												reg_0 = FUNC_LIST[6](12, loc_3, 4294967295, 0)
												loc_5 = reg_0
												loc_0 = load_i32(memory_at_0.data, 0 + 67480)
												store_i32(memory_at_0.data, 0 + 67480, 0)
												while true do
													if loc_0 == 1 then
														break
													end
													if loc_5 == 0 then
														desired = 8
														break
													end
													store_i32(memory_at_0.data, 0 + 67480, 0)
													reg_0 = FUNC_LIST[9](25, add_i32(loc_1, 24), loc_5)
													loc_5 = load_i32(memory_at_0.data, 0 + 67480)
													store_i32(memory_at_0.data, 0 + 67480, 0)
													if loc_5 ~= 1 then
														desired = 8
														break
													end
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												reg_0 = FUNC_LIST[8]()
												loc_3 = reg_0
												reg_0 = FUNC_LIST[1449]()
												desired = 6
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											reg_0 = FUNC_LIST[8]()
											loc_3 = reg_0
											reg_0 = FUNC_LIST[1449]()
											desired = 2
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										reg_0 = FUNC_LIST[8]()
										loc_3 = reg_0
										reg_0 = FUNC_LIST[1449]()
										desired = 2
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									store_i32(memory_at_0.data, 0 + 67480, 0)
									reg_0 = FUNC_LIST[9](25, add_i32(loc_1, 24), 12600)
									loc_5 = load_i32(memory_at_0.data, 0 + 67480)
									store_i32(memory_at_0.data, 0 + 67480, 0)
									if loc_5 == 1 then
										break
									end
									store_i32(memory_at_0.data, 0 + 67480, 0)
									reg_0 = FUNC_LIST[3](29, loc_3)
									loc_5 = reg_0
									loc_3 = load_i32(memory_at_0.data, 0 + 67480)
									store_i32(memory_at_0.data, 0 + 67480, 0)
									if loc_3 == 1 then
										break
									end
									store_i32(memory_at_0.data, 0 + 67480, 0)
									reg_0 = FUNC_LIST[9](25, add_i32(loc_1, 24), loc_5)
									loc_3 = load_i32(memory_at_0.data, 0 + 67480)
									store_i32(memory_at_0.data, 0 + 67480, 0)
									if loc_3 == 1 then
										break
									end
									store_i32(memory_at_0.data, 0 + 67480, 0)
									FUNC_LIST[7](13, loc_2, 4294967294)
									loc_3 = load_i32(memory_at_0.data, 0 + 67480)
									store_i32(memory_at_0.data, 0 + 67480, 0)
									if loc_3 ~= 1 then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								reg_0 = FUNC_LIST[8]()
								loc_3 = reg_0
								reg_0 = FUNC_LIST[1449]()
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 35), 4294967295) then
								desired = 3
								break
							end
							FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 24))
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if gt_i32(load_i32_i8(memory_at_0.data, 0 + 59807), 4294967295) then
								break
							end
							FUNC_LIST[1463](load_i32(memory_at_0.data, 0 + 59796))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i64(memory_at_0.data, 0 + 59796, load_i64(memory_at_0.data, loc_1 + 24))
						store_i32(memory_at_0.data, 0 + 59804, load_i32(memory_at_0.data, add_i32(loc_1, 32)))
						store_i32_n8(memory_at_0.data, loc_1 + 24, 0)
						store_i32_n8(memory_at_0.data, loc_1 + 35, 0)
						while true do
							if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 19), 4294967295) then
								break
							end
							FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 8))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_3 = load_i32_i8(memory_at_0.data, 0 + 59807)
						loc_5 = load_i32(memory_at_0.data, 0 + 59796)
						loc_0 = load_i32(memory_at_0.data, 0 + 59800)
						while true do
							if loc_2 == 0 then
								break
							end
							store_i32(memory_at_0.data, 0 + 67480, 0)
							FUNC_LIST[0](30, loc_2)
							loc_2 = load_i32(memory_at_0.data, 0 + 67480)
							store_i32(memory_at_0.data, 0 + 67480, 0)
							if loc_2 ~= 1 then
								break
							end
							reg_0 = FUNC_LIST[10](0)
							reg_0 = FUNC_LIST[1449]()
							FUNC_LIST[1593]()
							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, 352)
						loc_2 = (if lt_i32(loc_3, 0) then 1 else 0)
						reg_0 = (if (if loc_2 ~= 0 then loc_0 else band_i32(loc_3, 255)) ~= 0 then (if loc_2 ~= 0 then loc_5 else 59796) else 0)
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					reg_0 = FUNC_LIST[8]()
					loc_3 = reg_0
					reg_0 = FUNC_LIST[1449]()
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 19), 4294967295) then
					break
				end
				FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 8))
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				store_i32(memory_at_0.data, 0 + 67480, 0)
				FUNC_LIST[0](30, loc_2)
				loc_2 = load_i32(memory_at_0.data, 0 + 67480)
				store_i32(memory_at_0.data, 0 + 67480, 0)
				if loc_2 ~= 1 then
					break
				end
				reg_0 = FUNC_LIST[10](0)
				reg_0 = FUNC_LIST[1449]()
				FUNC_LIST[1593]()
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[11](loc_3)
			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] = --[[ lua_vector(lua_State*) ]] function(loc_0)
	local reg_0
	local reg_1
	local reg_2
	local reg_3
	while true do
		reg_1 = FUNC_LIST[508](loc_0, 1)
		reg_2 = FUNC_LIST[508](loc_0, 2)
		reg_3 = FUNC_LIST[508](loc_0, 3)
		FUNC_LIST[461](loc_0, demote_f32_f64(reg_1), demote_f32_f64(reg_2), demote_f32_f64(reg_3))
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[38] = --[[ __cxx_global_array_dtor ]] function(loc_0)
	while true do
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, 0 + 59807), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, 0 + 59796))
			break
		end
		break
	end
end
FUNC_LIST[39] = --[[ std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](5646)
		error("out of code bounds")
	end
end
FUNC_LIST[40] = --[[ std::__2::__throw_length_error(char const*) ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	while true do
		reg_0 = FUNC_LIST[1253](8)
		loc_1 = reg_0
		store_i32(memory_at_0.data, 0 + 67480, 0)
		reg_0 = FUNC_LIST[9](31, loc_1, loc_0)
		loc_0 = load_i32(memory_at_0.data, 0 + 67480)
		store_i32(memory_at_0.data, 0 + 67480, 0)
		while true do
			if loc_0 == 1 then
				break
			end
			FUNC_LIST[1252](loc_1, 59528, 32)
			error("out of code bounds")
		end
		reg_0 = FUNC_LIST[8]()
		loc_0 = reg_0
		reg_0 = FUNC_LIST[1449]()
		FUNC_LIST[12](loc_1)
		FUNC_LIST[11](loc_0)
		error("out of code bounds")
	end
end
FUNC_LIST[41] = --[[ std::length_error::length_error(char const*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = FUNC_LIST[1473](loc_0, loc_1)
		store_i32(memory_at_0.data, loc_0, add_i32(59488, 8))
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[42] = --[[ 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* const*) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local reg_1
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		reg_1 = FUNC_LIST[1067](loc_1, 9508)
		loc_4 = reg_1
		store_i32(memory_at_0.data, loc_3 + 8, loc_4)
		while true do
			if loc_4 == 0 then
				break
			end
			reg_0 = FUNC_LIST[43](loc_0, add_i32(loc_3, 8))
			store_i32(memory_at_0.data, reg_0, 1)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_2)
			if loc_4 == 0 then
				break
			end
			while true do
				reg_1 = FUNC_LIST[1067](loc_1, loc_4)
				loc_4 = reg_1
				store_i32(memory_at_0.data, loc_3, loc_4)
				while true do
					if loc_4 == 0 then
						break
					end
					reg_0 = FUNC_LIST[43](loc_0, loc_3)
					store_i32(memory_at_0.data, reg_0, 1)
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_2 + 4)
				loc_2 = add_i32(loc_2, 4)
				if loc_4 ~= 0 then
					continue
				end
				break
			end
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		break
	end
end
FUNC_LIST[43] = --[[ Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> >::operator[](Luau::AstName const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 3)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[44](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 3))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[44] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 3)
					loc_12 = add_i32(loc_4, loc_11)
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 8))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 24))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 3))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_12 = add_i32(loc_3, 4294967295)
			loc_13 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_14 = load_i32(memory_at_0.data, loc_0)
			loc_6 = 0
			while true do
				while true do
					loc_9 = add_i32(loc_14, shl_i32(loc_6, 3))
					loc_11 = load_i32(memory_at_0.data, loc_9)
					if loc_11 == loc_5 then
						break
					end
					while true do
						while true do
							loc_5 = band_i32(bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9)), loc_12)
							loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
							loc_7 = load_i32(memory_at_0.data, loc_10)
							if loc_7 == loc_1 then
								break
							end
							loc_8 = 0
							if loc_7 == loc_11 then
								desired = 4
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_5 = band_i32(add_i32(loc_8, loc_5), loc_12)
								loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
								loc_7 = load_i32(memory_at_0.data, loc_10)
								if loc_7 == loc_1 then
									desired = 5
									break
								end
								if loc_7 == loc_11 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_10, loc_11)
						loc_11 = load_i32(memory_at_0.data, loc_9)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_10, loc_11)
					store_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 3)) + 4, load_i32(memory_at_0.data, loc_9 + 4))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_5 = loc_13
				loc_6 = add_i32(loc_6, 1)
				if loc_6 ~= loc_2 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_5 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[45] = --[[ 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(loc_0, loc_1, loc_2)
	local loc_3 = 0
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		store_i32(memory_at_0.data, loc_3 + 8, loc_1)
		store_i32(memory_at_0.data, loc_3 + 4, loc_0)
		store_i32(memory_at_0.data, loc_3, add_i32(12640, 8))
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_3)
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		break
	end
end
FUNC_LIST[46] = --[[ Luau::Compile::ValueVisitor::~ValueVisitor() ]] function(loc_0)
	while true do
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[47] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatLocal*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local desired
	while true do
		while true do
			loc_2 = load_i32(memory_at_0.data, add_i32(loc_1, 32))
			if loc_2 == 0 then
				break
			end
			while true do
				if load_i32(memory_at_0.data, loc_1 + 40) == 0 then
					break
				end
				loc_3 = 0
				while true do
					loc_2 = shl_i32(loc_3, 2)
					loc_4 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), loc_2))
					reg_0 = FUNC_LIST[48](load_i32(memory_at_0.data, loc_0 + 8), add_i32(load_i32(memory_at_0.data, loc_1 + 28), loc_2))
					store_i32(memory_at_0.data, reg_0, loc_4)
					loc_3 = add_i32(loc_3, 1)
					loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
					if loc_3 >= loc_2 then
						desired = 2
						break
					end
					if loc_3 < load_i32(memory_at_0.data, loc_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_3 = load_i32(memory_at_0.data, loc_1 + 40)
			if loc_3 >= loc_2 then
				break
			end
			while true do
				reg_0 = FUNC_LIST[48](load_i32(memory_at_0.data, loc_0 + 8), add_i32(load_i32(memory_at_0.data, loc_1 + 28), shl_i32(loc_3, 2)))
				store_i32(memory_at_0.data, reg_0, 0)
				loc_3 = add_i32(loc_3, 1)
				if loc_3 < load_i32(memory_at_0.data, loc_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[48] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Variable, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::operator[](Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, mul_i32(loc_9, 12)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[53](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, mul_i32(loc_9, 12))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[49] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatAssign*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local desired
	while true do
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_1, 32)) == 0 then
				break
			end
			loc_2 = 0
			while true do
				loc_3 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 28), shl_i32(loc_2, 2)))
				loc_4 = load_i32(memory_at_0.data, loc_3 + 4)
				while true do
					while true do
						if loc_3 == 0 then
							break
						end
						if loc_4 ~= load_i32(memory_at_0.data, 0 + 59888) then
							break
						end
						reg_0 = FUNC_LIST[48](load_i32(memory_at_0.data, loc_0 + 8), add_i32(loc_3, 24))
						store_i32_n8(memory_at_0.data, reg_0 + 4, 1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_3 == 0 then
							break
						end
						if loc_4 ~= load_i32(memory_at_0.data, 0 + 59896) then
							break
						end
						reg_0 = FUNC_LIST[43](load_i32(memory_at_0.data, loc_0 + 4), add_i32(loc_3, 24))
						store_i32(memory_at_0.data, reg_0, 2)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_3))](loc_3, loc_0)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_2 = add_i32(loc_2, 1)
				if loc_2 < load_i32(memory_at_0.data, loc_1 + 32) then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_1, 40)) == 0 then
				break
			end
			loc_3 = 0
			while true do
				loc_2 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), shl_i32(loc_3, 2)))
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
				loc_3 = add_i32(loc_3, 1)
				if loc_3 < load_i32(memory_at_0.data, loc_1 + 40) then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[50] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatCompoundAssign*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	local desired
	while true do
		loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
		loc_3 = load_i32(memory_at_0.data, loc_2 + 4)
		while true do
			while true do
				if loc_2 == 0 then
					break
				end
				if loc_3 ~= load_i32(memory_at_0.data, 0 + 59888) then
					break
				end
				reg_0 = FUNC_LIST[48](load_i32(memory_at_0.data, loc_0 + 8), add_i32(loc_2, 24))
				store_i32_n8(memory_at_0.data, reg_0 + 4, 1)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				if loc_3 ~= load_i32(memory_at_0.data, 0 + 59896) then
					break
				end
				reg_0 = FUNC_LIST[43](load_i32(memory_at_0.data, loc_0 + 4), add_i32(loc_2, 24))
				store_i32(memory_at_0.data, reg_0, 2)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
			break
		end
		loc_2 = load_i32(memory_at_0.data, loc_1 + 36)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[51] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatFunction*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	local desired
	while true do
		loc_2 = load_i32(memory_at_0.data, loc_1 + 28)
		loc_3 = load_i32(memory_at_0.data, loc_2 + 4)
		while true do
			while true do
				if loc_2 == 0 then
					break
				end
				if loc_3 ~= load_i32(memory_at_0.data, 0 + 59888) then
					break
				end
				reg_0 = FUNC_LIST[48](load_i32(memory_at_0.data, loc_0 + 8), add_i32(loc_2, 24))
				store_i32_n8(memory_at_0.data, reg_0 + 4, 1)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				if loc_3 ~= load_i32(memory_at_0.data, 0 + 59896) then
					break
				end
				reg_0 = FUNC_LIST[43](load_i32(memory_at_0.data, loc_0 + 4), add_i32(loc_2, 24))
				store_i32(memory_at_0.data, reg_0, 2)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
			break
		end
		loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[52] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatLocalFunction*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local reg_0
	while true do
		loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
		reg_0 = FUNC_LIST[48](load_i32(memory_at_0.data, loc_0 + 8), add_i32(loc_1, 28))
		store_i32(memory_at_0.data, reg_0, loc_2)
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[53] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](mul_i32(loc_3, 12))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_2 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_8 = band_i32(loc_3, 4294967292)
				loc_2 = 0
				loc_9 = 0
				while true do
					loc_10 = add_i32(loc_4, mul_i32(loc_2, 12))
					store_i64(memory_at_0.data, loc_10 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					loc_10 = add_i32(loc_4, mul_i32(bor_i32(loc_2, 1), 12))
					store_i64(memory_at_0.data, loc_10 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					loc_10 = add_i32(loc_4, mul_i32(bor_i32(loc_2, 2), 12))
					store_i64(memory_at_0.data, loc_10 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					loc_10 = add_i32(loc_4, mul_i32(bor_i32(loc_2, 3), 12))
					store_i64(memory_at_0.data, loc_10 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					loc_2 = add_i32(loc_2, 4)
					loc_9 = add_i32(loc_9, 4)
					if loc_9 ~= 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_9 = add_i32(loc_4, mul_i32(loc_2, 12))
					store_i64(memory_at_0.data, loc_9 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_9, loc_5)
					loc_2 = add_i32(loc_2, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_7 = add_i32(loc_3, 4294967295)
			loc_11 = load_i32(memory_at_0.data, loc_0 + 4)
			loc_8 = 0
			while true do
				while true do
					loc_12 = add_i32(load_i32(memory_at_0.data, loc_0), mul_i32(loc_8, 12))
					loc_10 = load_i32(memory_at_0.data, loc_12)
					if loc_10 == loc_5 then
						break
					end
					loc_5 = bxor_i32(shr_u32(loc_10, 4), shr_u32(loc_10, 9))
					loc_2 = 0
					while true do
						while true do
							while true do
								loc_9 = band_i32(loc_5, loc_7)
								loc_6 = add_i32(loc_4, mul_i32(loc_9, 12))
								loc_5 = load_i32(memory_at_0.data, loc_6)
								if loc_5 ~= loc_1 then
									break
								end
								store_i32(memory_at_0.data, loc_6, loc_10)
								loc_10 = load_i32(memory_at_0.data, loc_12)
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							if loc_5 == loc_10 then
								desired = 4
								break
							end
							loc_2 = add_i32(loc_2, 1)
							loc_5 = add_i32(loc_2, loc_9)
							if loc_2 <= loc_7 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_6, loc_10)
					store_i32(memory_at_0.data, loc_6 + 4, load_i32(memory_at_0.data, loc_12 + 4))
					store_i32_n16(memory_at_0.data, add_i32(loc_6, 8), load_i32_u16(memory_at_0.data, add_i32(loc_12, 8)))
					loc_2 = loc_11
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_8 = add_i32(loc_8, 1)
				if loc_8 >= loc_2 then
					desired = 1
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_2 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			break
		end
		break
	end
end
FUNC_LIST[54] = --[[ 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(loc_0, loc_1, loc_2, loc_3)
	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_4 = add_i32(load_i32(memory_at_0.data, loc_3 + 4), 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_3)
		loc_6 = load_i32(memory_at_0.data, loc_3 + 12)
		loc_7 = load_i32(memory_at_0.data, loc_3 + 8)
		loc_8 = load_i32(memory_at_0.data, 0 + 59888)
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_1 + 4)
				if loc_1 == 0 then
					desired = 1
					break
				end
				if loc_3 ~= loc_8 then
					desired = 1
					break
				end
				while true do
					if loc_7 == 0 then
						break
					end
					loc_9 = load_i32(memory_at_0.data, loc_1 + 24)
					if loc_9 == loc_6 then
						break
					end
					loc_3 = bxor_i32(shr_u32(loc_9, 4), shr_u32(loc_9, 9))
					loc_1 = 0
					while true do
						while true do
							loc_10 = band_i32(loc_3, loc_4)
							loc_11 = add_i32(loc_5, mul_i32(loc_10, 12))
							loc_3 = load_i32(memory_at_0.data, loc_11)
							if loc_3 == loc_9 then
								desired = 4
								break
							end
							if loc_3 == loc_6 then
								desired = 3
								break
							end
							loc_1 = add_i32(loc_1, 1)
							loc_3 = add_i32(loc_1, loc_10)
							if loc_1 <= loc_4 then
								continue
							end
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if load_i32_u8(memory_at_0.data, add_i32(loc_11, 8)) ~= 0 then
						break
					end
					loc_1 = load_i32(memory_at_0.data, loc_11 + 4)
					if loc_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.data, loc_0, i64_ZERO)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if loc_1 == 0 then
				break
			end
			if loc_3 ~= load_i32(memory_at_0.data, 0 + 59920) then
				break
			end
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_1 + 24)
				if load_i32(memory_at_0.data, loc_3 + 4) ~= load_i32(memory_at_0.data, 0 + 59896) then
					break
				end
				if loc_3 == 0 then
					break
				end
				loc_6 = load_i32(memory_at_0.data, loc_3 + 24)
				while true do
					while true do
						if load_i32(memory_at_0.data, loc_2 + 8) == 0 then
							break
						end
						loc_11 = load_i32(memory_at_0.data, loc_2 + 12)
						if loc_11 == loc_6 then
							break
						end
						loc_4 = bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9))
						loc_10 = add_i32(load_i32(memory_at_0.data, loc_2 + 4), 4294967295)
						loc_5 = load_i32(memory_at_0.data, loc_2)
						loc_3 = 0
						while true do
							while true do
								loc_4 = band_i32(loc_4, loc_10)
								loc_9 = load_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_4, 3)))
								if loc_9 == loc_6 then
									desired = 5
									break
								end
								if loc_9 == loc_11 then
									desired = 4
									break
								end
								loc_3 = add_i32(loc_3, 1)
								loc_4 = add_i32(loc_3, loc_4)
								if loc_3 <= loc_10 then
									continue
								end
								desired = 4
								break
							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
						if load_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_4, 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.data, loc_0, loc_6)
					store_i32(memory_at_0.data, loc_0 + 4, load_i32(memory_at_0.data, add_i32(loc_1, 28)))
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i64(memory_at_0.data, loc_0, i64_ZERO)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, loc_0, i64_ZERO)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if loc_1 == 0 then
				break
			end
			if loc_3 ~= load_i32(memory_at_0.data, 0 + 59896) then
				break
			end
			loc_9 = load_i32(memory_at_0.data, loc_1 + 24)
			while true do
				while true do
					if load_i32(memory_at_0.data, loc_2 + 8) == 0 then
						break
					end
					loc_5 = load_i32(memory_at_0.data, loc_2 + 12)
					if loc_5 == loc_9 then
						break
					end
					loc_3 = bxor_i32(shr_u32(loc_9, 4), shr_u32(loc_9, 9))
					loc_4 = add_i32(load_i32(memory_at_0.data, loc_2 + 4), 4294967295)
					loc_6 = load_i32(memory_at_0.data, loc_2)
					loc_1 = 0
					while true do
						while true do
							loc_3 = band_i32(loc_3, loc_4)
							loc_10 = load_i32(memory_at_0.data, add_i32(loc_6, shl_i32(loc_3, 3)))
							if loc_10 == loc_9 then
								desired = 4
								break
							end
							if loc_10 == loc_5 then
								desired = 3
								break
							end
							loc_1 = add_i32(loc_1, 1)
							loc_3 = add_i32(loc_1, loc_3)
							if loc_1 <= loc_4 then
								continue
							end
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if load_i32(memory_at_0.data, add_i32(loc_6, shl_i32(loc_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.data, loc_0 + 4, loc_9)
				store_i32(memory_at_0.data, loc_0, 0)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, loc_0, i64_ZERO)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		break
	end
end
FUNC_LIST[55] = --[[ Luau::Compile::analyzeBuiltins(Luau::DenseHashMap<Luau::AstExprCall*, int, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprCall*> >&, 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&, Luau::CompileOptions const&, Luau::AstNode*) ]] function(loc_0, loc_1, loc_2, loc_3, loc_4)
	local loc_5 = 0
	while true do
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_5
		store_i32(memory_at_0.data, loc_5 + 24, loc_3)
		store_i32(memory_at_0.data, loc_5 + 20, loc_2)
		store_i32(memory_at_0.data, loc_5 + 16, loc_1)
		store_i32(memory_at_0.data, loc_5 + 12, loc_0)
		store_i32(memory_at_0.data, loc_5 + 8, add_i32(12924, 8))
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_4))](loc_4, add_i32(loc_5, 8))
		GLOBAL_LIST[0].value = add_i32(loc_5, 32)
		break
	end
end
FUNC_LIST[56] = --[[ Luau::Compile::getBuiltinInfo(int) ]] function(loc_0, loc_1)
	while true do
		loc_1 = shl_i32(loc_1, 2)
		store_i32(memory_at_0.data, loc_0 + 8, load_i32(memory_at_0.data, add_i32(loc_1, 13832)))
		store_i32(memory_at_0.data, loc_0 + 4, load_i32(memory_at_0.data, add_i32(loc_1, 13520)))
		store_i32(memory_at_0.data, loc_0, load_i32(memory_at_0.data, add_i32(loc_1, 13208)))
		break
	end
end
FUNC_LIST[57] = --[[ Luau::Compile::BuiltinVisitor::~BuiltinVisitor() ]] function(loc_0)
	while true do
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[58] = --[[ Luau::Compile::BuiltinVisitor::visit(Luau::AstExprCall*) ]] function(loc_0, loc_1)
	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_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		store_i32(memory_at_0.data, loc_2 + 12, loc_1)
		loc_3 = 0
		loc_4 = 0
		while true do
			if load_i32_u8(memory_at_0.data, loc_1 + 36) ~= 0 then
				break
			end
			FUNC_LIST[54](loc_2, load_i32(memory_at_0.data, loc_1 + 24), load_i32(memory_at_0.data, loc_0 + 8), load_i32(memory_at_0.data, loc_0 + 12))
			loc_3 = load_i32(memory_at_0.data, loc_2 + 4)
			loc_4 = load_i32(memory_at_0.data, loc_2)
			break
		end
		while true do
			if bor_i32(loc_4, loc_3) == 0 then
				break
			end
			loc_5 = load_i32(memory_at_0.data, loc_0 + 16)
			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_4 ~= 0 then
														break
													end
													if loc_3 == 0 then
														desired = 3
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 1822)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 1
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 6697)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 40
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 6013)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 44
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 2240)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 49
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 2310)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 50
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 5316)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 51
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 5077)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 58
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 5384)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 53
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													reg_0 = FUNC_LIST[1379](loc_3, 2317)
													if reg_0 == 0 then
														desired = 10
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 7563)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 60
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 7550)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 61
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 4159)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 62
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													reg_0 = FUNC_LIST[1379](loc_3, 5603)
													if reg_0 ~= 0 then
														desired = 3
														break
													end
													loc_6 = 63
													desired = 2
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												while true do
													while true do
														while true do
															while true do
																reg_0 = FUNC_LIST[1379](loc_4, 5469)
																if reg_0 ~= 0 then
																	break
																end
																if loc_3 == 0 then
																	desired = 4
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 3130)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 2
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 2824)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 3
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 4975)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 4
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 10333)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 5
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5095)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 6
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5297)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 7
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5474)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 8
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 2825)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 9
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 6009)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 10
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 4269)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 11
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 3853)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 12
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 8219)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 13
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 4261)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 14
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 4267)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 15
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 10493)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 16
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5510)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 17
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 1382)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 18
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5017)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 19
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 6056)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 20
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 1440)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 21
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 8685)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 22
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5479)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 23
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 4976)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 24
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 1783)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 25
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5484)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 26
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5096)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 27
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 4455)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 46
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[1379](loc_3, 5039)
																	if reg_0 ~= 0 then
																		break
																	end
																	loc_6 = 47
																	desired = 2
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																reg_0 = FUNC_LIST[1379](loc_3, 8248)
																if reg_0 ~= 0 then
																	desired = 13
																	break
																end
																loc_6 = 48
																desired = 2
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															reg_0 = FUNC_LIST[1379](loc_4, 10356)
															if reg_0 ~= 0 then
																desired = 9
																break
															end
															if loc_3 ~= 0 then
																desired = 12
																break
															end
															desired = 9
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														reg_0 = FUNC_LIST[1379](loc_4, 10356)
														if reg_0 ~= 0 then
															desired = 11
															break
														end
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 2225)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 28
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 8263)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 29
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 1866)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 30
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 3863)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 31
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 3784)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 32
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 1771)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 33
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 2376)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 34
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 6460)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 35
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 2233)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 36
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 8211)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 37
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 6452)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 38
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 2226)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 39
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 1046)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 55
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													while true do
														reg_0 = FUNC_LIST[1379](loc_3, 1038)
														if reg_0 ~= 0 then
															break
														end
														loc_6 = 56
														desired = 2
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if load_i32_u8(memory_at_0.data, 0 + 59812) == 0 then
														desired = 9
														break
													end
													reg_0 = FUNC_LIST[1379](loc_3, 4470)
													if reg_0 ~= 0 then
														desired = 9
														break
													end
													loc_6 = 64
													desired = 2
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												reg_0 = FUNC_LIST[1379](loc_4, 5916)
												if reg_0 == 0 then
													desired = 8
													break
												end
												desired = 7
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											if load_i32(memory_at_0.data, add_i32(loc_1, 32)) ~= 2 then
												desired = 1
												break
											end
											loc_6 = 57
											if load_i32(memory_at_0.data, load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1 + 28) + 4) + 4) ~= load_i32(memory_at_0.data, 0 + 59904) then
												desired = 1
												break
											end
											desired = 2
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										reg_0 = FUNC_LIST[1379](loc_4, 5916)
										if reg_0 ~= 0 then
											desired = 7
											break
										end
										if loc_3 == 0 then
											desired = 4
											break
										end
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									while true do
										reg_0 = FUNC_LIST[1379](loc_3, 6447)
										if reg_0 ~= 0 then
											break
										end
										loc_6 = 41
										desired = 2
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									while true do
										reg_0 = FUNC_LIST[1379](loc_3, 4214)
										if reg_0 ~= 0 then
											break
										end
										loc_6 = 42
										desired = 2
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									while true do
										reg_0 = FUNC_LIST[1379](loc_3, 5086)
										if reg_0 ~= 0 then
											break
										end
										loc_6 = 43
										desired = 2
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									reg_0 = FUNC_LIST[1379](loc_3, 9348)
									if reg_0 ~= 0 then
										desired = 6
										break
									end
									loc_6 = 45
									desired = 2
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								reg_0 = FUNC_LIST[1379](loc_4, 7753)
								if reg_0 ~= 0 then
									desired = 4
									break
								end
								if loc_3 ~= 0 then
									desired = 5
									break
								end
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							reg_0 = FUNC_LIST[1379](loc_4, 7753)
							if reg_0 ~= 0 then
								desired = 4
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							reg_0 = FUNC_LIST[1379](loc_3, 1829)
							if reg_0 ~= 0 then
								break
							end
							loc_6 = 52
							desired = 2
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						reg_0 = FUNC_LIST[1379](loc_3, 5384)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 53
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if load_i32_u8(memory_at_0.data, 0 + 59824) == 0 then
						break
					end
					reg_0 = FUNC_LIST[1379](loc_4, 4152)
					if reg_0 ~= 0 then
						break
					end
					if loc_3 == 0 then
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10222)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 65
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10207)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 66
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_6 = 67
					reg_0 = FUNC_LIST[1379](loc_3, 10214)
					if reg_0 == 0 then
						desired = 2
						break
					end
					reg_0 = FUNC_LIST[1379](loc_3, 10199)
					if reg_0 == 0 then
						desired = 2
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10266)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 68
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10249)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 69
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_6 = 70
					reg_0 = FUNC_LIST[1379](loc_3, 10257)
					if reg_0 == 0 then
						desired = 2
						break
					end
					reg_0 = FUNC_LIST[1379](loc_3, 10240)
					if reg_0 == 0 then
						desired = 2
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10371)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 71
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10348)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 72
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_6 = 73
					reg_0 = FUNC_LIST[1379](loc_3, 10362)
					if reg_0 == 0 then
						desired = 2
						break
					end
					reg_0 = FUNC_LIST[1379](loc_3, 10339)
					if reg_0 == 0 then
						desired = 2
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10388)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 74
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10379)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 75
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 10283)
						if reg_0 ~= 0 then
							break
						end
						loc_6 = 76
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					reg_0 = FUNC_LIST[1379](loc_3, 10274)
					if reg_0 ~= 0 then
						break
					end
					loc_6 = 77
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = load_i32(memory_at_0.data, loc_5 + 16)
				if loc_1 == 0 then
					desired = 1
					break
				end
				while true do
					loc_6 = load_i32(memory_at_0.data, loc_5 + 12)
					if loc_6 == 0 then
						break
					end
					if loc_4 == 0 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1379](loc_4, loc_6)
					if reg_0 ~= 0 then
						desired = 1
						break
					end
					if loc_3 == 0 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1379](loc_3, loc_1)
					if reg_0 ~= 0 then
						desired = 1
						break
					end
					loc_6 = 54
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_4 ~= 0 then
					desired = 1
					break
				end
				if loc_3 == 0 then
					desired = 1
					break
				end
				reg_0 = FUNC_LIST[1379](loc_3, loc_1)
				if reg_0 ~= 0 then
					desired = 1
					break
				end
				loc_6 = 54
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[59](load_i32(memory_at_0.data, loc_0 + 4), add_i32(loc_2, 12))
			store_i32(memory_at_0.data, reg_0, loc_6)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[59] = --[[ Luau::DenseHashMap<Luau::AstExprCall*, int, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprCall*> >::operator[](Luau::AstExprCall* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 3)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[60](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 3))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[60] = --[[ Luau::detail::DenseHashTable<Luau::AstExprCall*, std::__2::pair<Luau::AstExprCall*, int>, std::__2::pair<Luau::AstExprCall* const, int>, Luau::detail::ItemInterfaceMap<Luau::AstExprCall*, int>, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprCall*> >::rehash() ]] function(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 3)
					loc_12 = add_i32(loc_4, loc_11)
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 8))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 24))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 3))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_12 = add_i32(loc_3, 4294967295)
			loc_13 = load_i32(memory_at_0.data, loc_0)
			loc_6 = 0
			while true do
				while true do
					loc_9 = add_i32(loc_13, shl_i32(loc_6, 3))
					loc_11 = load_i32(memory_at_0.data, loc_9)
					if loc_11 == loc_5 then
						break
					end
					while true do
						while true do
							loc_5 = band_i32(bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9)), loc_12)
							loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
							loc_7 = load_i32(memory_at_0.data, loc_10)
							if loc_7 == loc_1 then
								break
							end
							loc_8 = 0
							if loc_7 == loc_11 then
								desired = 4
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_5 = band_i32(add_i32(loc_8, loc_5), loc_12)
								loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
								loc_7 = load_i32(memory_at_0.data, loc_10)
								if loc_7 == loc_1 then
									desired = 5
									break
								end
								if loc_7 == loc_11 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_10, loc_11)
						loc_11 = load_i32(memory_at_0.data, loc_9)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_10, loc_11)
					store_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 3)) + 4, load_i32(memory_at_0.data, loc_9 + 4))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_6 = add_i32(loc_6, 1)
				if loc_6 == loc_2 then
					desired = 1
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_5 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[61] = --[[ _GLOBAL__sub_I_Builtins.cpp ]] function()
	local loc_0 = 0
	while true do
		store_i32(memory_at_0.data, 59812 + 4, 4950)
		store_i32(memory_at_0.data, 59824 + 8, 59812)
		store_i32(memory_at_0.data, 59824 + 4, 2829)
		store_i32_n16(memory_at_0.data, 0 + 59824, 1)
		loc_0 = load_i32(memory_at_0.data, 0 + 59792)
		store_i32(memory_at_0.data, 0 + 59792, 59824)
		store_i32(memory_at_0.data, 59812 + 8, loc_0)
		store_i32_n16(memory_at_0.data, 0 + 59812, 0)
		break
	end
end
FUNC_LIST[62] = --[[ Luau::Compile::foldBuiltin(int, Luau::Compile::Constant const*, unsigned long) ]] function(loc_0, loc_1, loc_2, loc_3)
	local loc_4 = 0.0
	local loc_5 = 0.0
	local loc_6 = 0
	local loc_7 = i64_ZERO
	local loc_8 = 0
	local loc_9 = 0.0
	local reg_0
	local reg_1
	local reg_2
	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
																	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
																																	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, 6, 7, 8, 9, 10, 11, 43, 12, 13, 14, 15, 16, 43, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 43, 38, 39, 43, 40, 41, 42, }
																																															end)()
																																														end
																																														temp = br_map[1][add_i32(loc_1, 4294967294)] or 43
																																														if temp < 22 then
																																															if temp < 11 then
																																																if temp < 5 then
																																																	if temp < 2 then
																																																		if temp < 1 then
																																																			break
																																																		else
																																																			desired = 43
																																																			break
																																																		end
																																																	elseif temp > 2 then
																																																		if temp < 4 then
																																																			desired = 41
																																																			break
																																																		else
																																																			desired = 40
																																																			break
																																																		end
																																																	else
																																																		desired = 42
																																																		break
																																																	end
																																																elseif temp > 5 then
																																																	if temp < 8 then
																																																		if temp < 7 then
																																																			desired = 38
																																																			break
																																																		else
																																																			desired = 37
																																																			break
																																																		end
																																																	elseif temp > 8 then
																																																		if temp < 10 then
																																																			desired = 35
																																																			break
																																																		else
																																																			desired = 34
																																																			break
																																																		end
																																																	else
																																																		desired = 36
																																																		break
																																																	end
																																																else
																																																	desired = 39
																																																	break
																																																end
																																															elseif temp > 11 then
																																																if temp < 17 then
																																																	if temp < 14 then
																																																		if temp < 13 then
																																																			desired = 32
																																																			break
																																																		else
																																																			desired = 31
																																																			break
																																																		end
																																																	elseif temp > 14 then
																																																		if temp < 16 then
																																																			desired = 29
																																																			break
																																																		else
																																																			desired = 28
																																																			break
																																																		end
																																																	else
																																																		desired = 30
																																																		break
																																																	end
																																																elseif temp > 17 then
																																																	if temp < 20 then
																																																		if temp < 19 then
																																																			desired = 26
																																																			break
																																																		else
																																																			desired = 25
																																																			break
																																																		end
																																																	elseif temp > 20 then
																																																		desired = 23
																																																		break
																																																	else
																																																		desired = 24
																																																		break
																																																	end
																																																else
																																																	desired = 27
																																																	break
																																																end
																																															else
																																																desired = 33
																																																break
																																															end
																																														elseif temp > 22 then
																																															if temp < 33 then
																																																if temp < 28 then
																																																	if temp < 25 then
																																																		if temp < 24 then
																																																			desired = 21
																																																			break
																																																		else
																																																			desired = 20
																																																			break
																																																		end
																																																	elseif temp > 25 then
																																																		if temp < 27 then
																																																			desired = 18
																																																			break
																																																		else
																																																			desired = 17
																																																			break
																																																		end
																																																	else
																																																		desired = 19
																																																		break
																																																	end
																																																elseif temp > 28 then
																																																	if temp < 31 then
																																																		if temp < 30 then
																																																			desired = 15
																																																			break
																																																		else
																																																			desired = 14
																																																			break
																																																		end
																																																	elseif temp > 31 then
																																																		desired = 12
																																																		break
																																																	else
																																																		desired = 13
																																																		break
																																																	end
																																																else
																																																	desired = 16
																																																	break
																																																end
																																															elseif temp > 33 then
																																																if temp < 39 then
																																																	if temp < 36 then
																																																		if temp < 35 then
																																																			desired = 10
																																																			break
																																																		else
																																																			desired = 9
																																																			break
																																																		end
																																																	elseif temp > 36 then
																																																		if temp < 38 then
																																																			desired = 7
																																																			break
																																																		else
																																																			desired = 6
																																																			break
																																																		end
																																																	else
																																																		desired = 8
																																																		break
																																																	end
																																																elseif temp > 39 then
																																																	if temp < 42 then
																																																		if temp < 41 then
																																																			desired = 4
																																																			break
																																																		else
																																																			desired = 3
																																																			break
																																																		end
																																																	elseif temp > 42 then
																																																		desired = 1
																																																		break
																																																	else
																																																		desired = 2
																																																		break
																																																	end
																																																else
																																																	desired = 5
																																																	break
																																																end
																																															else
																																																desired = 11
																																																break
																																															end
																																														else
																																															desired = 22
																																															break
																																														end
																																													end
																																													if desired then
																																														if desired == 43 then
																																															desired = nil
																																														end
																																														break
																																													end
																																													if loc_3 ~= 1 then
																																														desired = 1
																																														break
																																													end
																																													if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																														desired = 1
																																														break
																																													end
																																													loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																													store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																													store_f64(memory_at_0.data, loc_0 + 8, abs_f64(loc_4))
																																													desired = 0
																																													break
																																												end
																																												if desired then
																																													if desired == 42 then
																																														desired = nil
																																													end
																																													break
																																												end
																																												if loc_3 ~= 1 then
																																													desired = 1
																																													break
																																												end
																																												if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																													desired = 1
																																													break
																																												end
																																												reg_1 = FUNC_LIST[1265](load_f64(memory_at_0.data, loc_2 + 8))
																																												store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																												store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																												desired = 0
																																												break
																																											end
																																											if desired then
																																												if desired == 41 then
																																													desired = nil
																																												end
																																												break
																																											end
																																											if loc_3 ~= 1 then
																																												desired = 1
																																												break
																																											end
																																											if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																												desired = 1
																																												break
																																											end
																																											reg_1 = FUNC_LIST[1267](load_f64(memory_at_0.data, loc_2 + 8))
																																											store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																											store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																											desired = 0
																																											break
																																										end
																																										if desired then
																																											if desired == 40 then
																																												desired = nil
																																											end
																																											break
																																										end
																																										if loc_3 ~= 2 then
																																											desired = 1
																																											break
																																										end
																																										if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																											desired = 1
																																											break
																																										end
																																										if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																																											desired = 1
																																											break
																																										end
																																										reg_1 = FUNC_LIST[1271](load_f64(memory_at_0.data, loc_2 + 8), load_f64(memory_at_0.data, add_i32(loc_2, 24)))
																																										store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																										store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																										desired = 0
																																										break
																																									end
																																									if desired then
																																										if desired == 39 then
																																											desired = nil
																																										end
																																										break
																																									end
																																									if loc_3 ~= 1 then
																																										desired = 1
																																										break
																																									end
																																									if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																										desired = 1
																																										break
																																									end
																																									reg_1 = FUNC_LIST[1269](load_f64(memory_at_0.data, loc_2 + 8))
																																									store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																									store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																									desired = 0
																																									break
																																								end
																																								if desired then
																																									if desired == 38 then
																																										desired = nil
																																									end
																																									break
																																								end
																																								if loc_3 ~= 1 then
																																									desired = 1
																																									break
																																								end
																																								if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																									desired = 1
																																									break
																																								end
																																								loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																								store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																								store_f64(memory_at_0.data, loc_0 + 8, ceil_f64(loc_4))
																																								desired = 0
																																								break
																																							end
																																							if desired then
																																								if desired == 37 then
																																									desired = nil
																																								end
																																								break
																																							end
																																							if loc_3 ~= 1 then
																																								desired = 1
																																								break
																																							end
																																							if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																								desired = 1
																																								break
																																							end
																																							reg_1 = FUNC_LIST[1282](load_f64(memory_at_0.data, loc_2 + 8))
																																							store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																							store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																							desired = 0
																																							break
																																						end
																																						if desired then
																																							if desired == 36 then
																																								desired = nil
																																							end
																																							break
																																						end
																																						if loc_3 ~= 1 then
																																							desired = 1
																																							break
																																						end
																																						if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																							desired = 1
																																							break
																																						end
																																						loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																						store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																						reg_1 = FUNC_LIST[1280](loc_4)
																																						store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																						desired = 0
																																						break
																																					end
																																					if desired then
																																						if desired == 35 then
																																							desired = nil
																																						end
																																						break
																																					end
																																					if loc_3 ~= 1 then
																																						desired = 1
																																						break
																																					end
																																					if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																						desired = 1
																																						break
																																					end
																																					loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																					store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																					store_f64(memory_at_0.data, loc_0 + 8, (loc_4 / 1.7453292519943295e-2))
																																					desired = 0
																																					break
																																				end
																																				if desired then
																																					if desired == 34 then
																																						desired = nil
																																					end
																																					break
																																				end
																																				if loc_3 ~= 1 then
																																					desired = 1
																																					break
																																				end
																																				if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																					desired = 1
																																					break
																																				end
																																				loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																				store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																				reg_1 = FUNC_LIST[1291](loc_4)
																																				store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																				desired = 0
																																				break
																																			end
																																			if desired then
																																				if desired == 33 then
																																					desired = nil
																																				end
																																				break
																																			end
																																			if loc_3 ~= 1 then
																																				desired = 1
																																				break
																																			end
																																			if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																				desired = 1
																																				break
																																			end
																																			loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																			store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																			store_f64(memory_at_0.data, loc_0 + 8, floor_f64(loc_4))
																																			desired = 0
																																			break
																																		end
																																		if desired then
																																			if desired == 32 then
																																				desired = nil
																																			end
																																			break
																																		end
																																		if loc_3 ~= 2 then
																																			desired = 1
																																			break
																																		end
																																		if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																			desired = 1
																																			break
																																		end
																																		if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																																			desired = 1
																																			break
																																		end
																																		loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
																																		loc_5 = load_f64(memory_at_0.data, loc_2 + 8)
																																		store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																		reg_1 = FUNC_LIST[1300](loc_5, loc_4)
																																		store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																		desired = 0
																																		break
																																	end
																																	if desired then
																																		if desired == 31 then
																																			desired = nil
																																		end
																																		break
																																	end
																																	if loc_3 ~= 2 then
																																		desired = 1
																																		break
																																	end
																																	if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																		desired = 1
																																		break
																																	end
																																	if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																																		desired = 1
																																		break
																																	end
																																	while true do
																																		while true do
																																			loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
																																			if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
																																				break
																																			end
																																			loc_3 = truncate_i32_f64(loc_4)
																																			desired = 32
																																			break
																																		end
																																		if desired then
																																			if desired == 32 then
																																				desired = nil
																																			end
																																			break
																																		end
																																		loc_3 = 2147483648
																																		break
																																	end
																																	if desired then
																																		if desired == 31 then
																																			desired = nil
																																		end
																																		break
																																	end
																																	reg_1 = FUNC_LIST[1332](load_f64(memory_at_0.data, loc_2 + 8), loc_3)
																																	store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																	store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																	desired = 0
																																	break
																																end
																																if desired then
																																	if desired == 30 then
																																		desired = nil
																																	end
																																	break
																																end
																																if loc_3 ~= 1 then
																																	desired = 1
																																	break
																																end
																																if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																	desired = 1
																																	break
																																end
																																loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																reg_1 = FUNC_LIST[1341](loc_4)
																																store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																desired = 0
																																break
																															end
																															if desired then
																																if desired == 29 then
																																	desired = nil
																																end
																																break
																															end
																															while true do
																																while true do
																																	if not br_map[2] then
																																		br_map[2] = (function()
																																			return { [0] = 0, 1, }
																																		end)()
																																	end
																																	temp = br_map[2][add_i32(loc_3, 4294967295)] or 30
																																	if temp < 1 then
																																		break
																																	elseif temp > 1 then
																																		desired = 1
																																		break
																																	else
																																		desired = 30
																																		break
																																	end
																																end
																																if desired then
																																	if desired == 30 then
																																		desired = nil
																																	end
																																	break
																																end
																																if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																	desired = 1
																																	break
																																end
																																loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																reg_1 = FUNC_LIST[1339](loc_4)
																																store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																desired = 0
																																break
																															end
																															if desired then
																																if desired == 29 then
																																	desired = nil
																																end
																																break
																															end
																															if load_i32(memory_at_0.data, loc_2) ~= 3 then
																																desired = 1
																																break
																															end
																															if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																																desired = 1
																																break
																															end
																															while true do
																																loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
																																if loc_4 ~= 2e0 then
																																	break
																																end
																																loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																																store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																reg_1 = FUNC_LIST[1342](loc_4)
																																store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																desired = 0
																																break
																															end
																															if desired then
																																if desired == 29 then
																																	desired = nil
																																end
																																break
																															end
																															loc_5 = load_f64(memory_at_0.data, loc_2 + 8)
																															while true do
																																if loc_4 ~= 1e1 then
																																	break
																																end
																																store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																																reg_1 = FUNC_LIST[1341](loc_5)
																																store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																																desired = 0
																																break
																															end
																															if desired then
																																if desired == 29 then
																																	desired = nil
																																end
																																break
																															end
																															store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																															reg_1 = FUNC_LIST[1339](loc_5)
																															reg_2 = FUNC_LIST[1339](loc_4)
																															store_f64(memory_at_0.data, loc_0 + 8, (reg_1 / reg_2))
																															desired = 0
																															break
																														end
																														if desired then
																															if desired == 28 then
																																desired = nil
																															end
																															break
																														end
																														if loc_3 == 0 then
																															desired = 1
																															break
																														end
																														if load_i32(memory_at_0.data, loc_2) ~= 3 then
																															desired = 1
																															break
																														end
																														loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																														while true do
																															if loc_3 < 2 then
																																break
																															end
																															loc_1 = 1
																															while true do
																																while true do
																																	loc_6 = add_i32(loc_2, shl_i32(loc_1, 4))
																																	if load_i32(memory_at_0.data, loc_6) == 3 then
																																		break
																																	end
																																	store_i64(memory_at_0.data, loc_0, i64_ZERO)
																																	store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
																																	desired = 0
																																	break
																																end
																																if desired then
																																	if desired == 30 then
																																		desired = nil
																																		continue
																																	end
																																	break
																																end
																																loc_5 = load_f64(memory_at_0.data, loc_6 + 8)
																																loc_4 = (if loc_5 > loc_4 then loc_5 else loc_4)
																																loc_1 = add_i32(loc_1, 1)
																																if loc_1 ~= loc_3 then
																																	continue
																																end
																																break
																															end
																															if desired then
																																if desired == 29 then
																																	desired = nil
																																end
																																break
																															end
																															break
																														end
																														if desired then
																															if desired == 28 then
																																desired = nil
																															end
																															break
																														end
																														store_f64(memory_at_0.data, loc_0 + 8, loc_4)
																														store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																														desired = 0
																														break
																													end
																													if desired then
																														if desired == 27 then
																															desired = nil
																														end
																														break
																													end
																													if loc_3 == 0 then
																														desired = 1
																														break
																													end
																													if load_i32(memory_at_0.data, loc_2) ~= 3 then
																														desired = 1
																														break
																													end
																													loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																													while true do
																														if loc_3 < 2 then
																															break
																														end
																														loc_1 = 1
																														while true do
																															while true do
																																loc_6 = add_i32(loc_2, shl_i32(loc_1, 4))
																																if load_i32(memory_at_0.data, loc_6) == 3 then
																																	break
																																end
																																store_i64(memory_at_0.data, loc_0, i64_ZERO)
																																store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
																																desired = 0
																																break
																															end
																															if desired then
																																if desired == 29 then
																																	desired = nil
																																	continue
																																end
																																break
																															end
																															loc_5 = load_f64(memory_at_0.data, loc_6 + 8)
																															loc_4 = (if loc_5 < loc_4 then loc_5 else loc_4)
																															loc_1 = add_i32(loc_1, 1)
																															if loc_1 ~= loc_3 then
																																continue
																															end
																															break
																														end
																														if desired then
																															if desired == 28 then
																																desired = nil
																															end
																															break
																														end
																														break
																													end
																													if desired then
																														if desired == 27 then
																															desired = nil
																														end
																														break
																													end
																													store_f64(memory_at_0.data, loc_0 + 8, loc_4)
																													store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																													desired = 0
																													break
																												end
																												if desired then
																													if desired == 26 then
																														desired = nil
																													end
																													break
																												end
																												if loc_3 ~= 2 then
																													desired = 1
																													break
																												end
																												if load_i32(memory_at_0.data, loc_2) ~= 3 then
																													desired = 1
																													break
																												end
																												if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																													desired = 1
																													break
																												end
																												loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
																												loc_5 = load_f64(memory_at_0.data, loc_2 + 8)
																												store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																												reg_1 = FUNC_LIST[1354](loc_5, loc_4)
																												store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																												desired = 0
																												break
																											end
																											if desired then
																												if desired == 25 then
																													desired = nil
																												end
																												break
																											end
																											if loc_3 ~= 1 then
																												desired = 1
																												break
																											end
																											if load_i32(memory_at_0.data, loc_2) ~= 3 then
																												desired = 1
																												break
																											end
																											loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																											store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																											store_f64(memory_at_0.data, loc_0 + 8, (loc_4 * 1.7453292519943295e-2))
																											desired = 0
																											break
																										end
																										if desired then
																											if desired == 24 then
																												desired = nil
																											end
																											break
																										end
																										if loc_3 ~= 1 then
																											desired = 1
																											break
																										end
																										if load_i32(memory_at_0.data, loc_2) ~= 3 then
																											desired = 1
																											break
																										end
																										reg_1 = FUNC_LIST[1370](load_f64(memory_at_0.data, loc_2 + 8))
																										store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																										store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																										desired = 0
																										break
																									end
																									if desired then
																										if desired == 23 then
																											desired = nil
																										end
																										break
																									end
																									if loc_3 ~= 1 then
																										desired = 1
																										break
																									end
																									if load_i32(memory_at_0.data, loc_2) ~= 3 then
																										desired = 1
																										break
																									end
																									loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																									store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																									reg_1 = FUNC_LIST[1369](loc_4)
																									store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																									desired = 0
																									break
																								end
																								if desired then
																									if desired == 22 then
																										desired = nil
																									end
																									break
																								end
																								if loc_3 ~= 1 then
																									desired = 1
																									break
																								end
																								if load_i32(memory_at_0.data, loc_2) ~= 3 then
																									desired = 1
																									break
																								end
																								loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																								store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																								store_f64(memory_at_0.data, loc_0 + 8, sqrt_f64(loc_4))
																								desired = 0
																								break
																							end
																							if desired then
																								if desired == 21 then
																									desired = nil
																								end
																								break
																							end
																							if loc_3 ~= 1 then
																								desired = 1
																								break
																							end
																							if load_i32(memory_at_0.data, loc_2) ~= 3 then
																								desired = 1
																								break
																							end
																							reg_1 = FUNC_LIST[1411](load_f64(memory_at_0.data, loc_2 + 8))
																							store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																							store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																							desired = 0
																							break
																						end
																						if desired then
																							if desired == 20 then
																								desired = nil
																							end
																							break
																						end
																						if loc_3 ~= 1 then
																							desired = 1
																							break
																						end
																						if load_i32(memory_at_0.data, loc_2) ~= 3 then
																							desired = 1
																							break
																						end
																						reg_1 = FUNC_LIST[1410](load_f64(memory_at_0.data, loc_2 + 8))
																						store_f64(memory_at_0.data, loc_0 + 8, reg_1)
																						store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																						desired = 0
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																						end
																						break
																					end
																					if loc_3 ~= 2 then
																						desired = 1
																						break
																					end
																					if load_i32(memory_at_0.data, loc_2) ~= 3 then
																						desired = 1
																						break
																					end
																					if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																						desired = 1
																						break
																					end
																					while true do
																						while true do
																							loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
																							if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
																								break
																							end
																							loc_3 = truncate_i32_f64(loc_4)
																							desired = 20
																							break
																						end
																						if desired then
																							if desired == 20 then
																								desired = nil
																							end
																							break
																						end
																						loc_3 = 2147483648
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																						end
																						break
																					end
																					if loc_3 > 31 then
																						desired = 1
																						break
																					end
																					loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																					store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																					while true do
																						while true do
																							if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																								break
																							end
																							loc_7 = truncate_i64_f64(loc_4)
																							desired = 20
																							break
																						end
																						if desired then
																							if desired == 20 then
																								desired = nil
																							end
																							break
																						end
																						loc_7 = i64_from_u32(0, 2147483648)
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																						end
																						break
																					end
																					store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(shr_i32(wrap_i32_i64(loc_7), loc_3)))
																					desired = 0
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				if loc_3 == 0 then
																					desired = 1
																					break
																				end
																				if load_i32(memory_at_0.data, loc_2) ~= 3 then
																					desired = 1
																					break
																				end
																				loc_1 = (if loc_3 < 2 then 1 else 0)
																				while true do
																					while true do
																						loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																						if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																							break
																						end
																						loc_7 = truncate_i64_f64(loc_4)
																						desired = 19
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																						end
																						break
																					end
																					loc_7 = i64_from_u32(0, 2147483648)
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				loc_6 = wrap_i32_i64(loc_7)
																				while true do
																					if loc_1 ~= 0 then
																						break
																					end
																					loc_1 = 1
																					while true do
																						while true do
																							loc_8 = add_i32(loc_2, shl_i32(loc_1, 4))
																							if load_i32(memory_at_0.data, loc_8) == 3 then
																								break
																							end
																							store_i64(memory_at_0.data, loc_0, i64_ZERO)
																							store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
																							desired = 0
																							break
																						end
																						if desired then
																							if desired == 20 then
																								desired = nil
																								continue
																							end
																							break
																						end
																						while true do
																							while true do
																								loc_4 = load_f64(memory_at_0.data, loc_8 + 8)
																								if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																									break
																								end
																								loc_7 = truncate_i64_f64(loc_4)
																								desired = 21
																								break
																							end
																							if desired then
																								if desired == 21 then
																									desired = nil
																								end
																								break
																							end
																							loc_7 = i64_from_u32(0, 2147483648)
																							break
																						end
																						if desired then
																							if desired == 20 then
																								desired = nil
																								continue
																							end
																							break
																						end
																						loc_6 = band_i32(loc_6, wrap_i32_i64(loc_7))
																						loc_1 = add_i32(loc_1, 1)
																						if loc_1 ~= loc_3 then
																							continue
																						end
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																						end
																						break
																					end
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																				store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(loc_6))
																				desired = 0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			if loc_3 ~= 1 then
																				desired = 1
																				break
																			end
																			if load_i32(memory_at_0.data, loc_2) ~= 3 then
																				desired = 1
																				break
																			end
																			loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																			store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																			while true do
																				while true do
																					if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																						break
																					end
																					loc_7 = truncate_i64_f64(loc_4)
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				loc_7 = i64_from_u32(0, 2147483648)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(bxor_i32(wrap_i32_i64(loc_7), 4294967295)))
																			desired = 0
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		if loc_3 == 0 then
																			desired = 1
																			break
																		end
																		if load_i32(memory_at_0.data, loc_2) ~= 3 then
																			desired = 1
																			break
																		end
																		loc_1 = (if loc_3 < 2 then 1 else 0)
																		while true do
																			while true do
																				loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																				if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																					break
																				end
																				loc_7 = truncate_i64_f64(loc_4)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_7 = i64_from_u32(0, 2147483648)
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_6 = wrap_i32_i64(loc_7)
																		while true do
																			if loc_1 ~= 0 then
																				break
																			end
																			loc_1 = 1
																			while true do
																				while true do
																					loc_8 = add_i32(loc_2, shl_i32(loc_1, 4))
																					if load_i32(memory_at_0.data, loc_8) == 3 then
																						break
																					end
																					store_i64(memory_at_0.data, loc_0, i64_ZERO)
																					store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
																					desired = 0
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																						continue
																					end
																					break
																				end
																				while true do
																					while true do
																						loc_4 = load_f64(memory_at_0.data, loc_8 + 8)
																						if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																							break
																						end
																						loc_7 = truncate_i64_f64(loc_4)
																						desired = 19
																						break
																					end
																					if desired then
																						if desired == 19 then
																							desired = nil
																						end
																						break
																					end
																					loc_7 = i64_from_u32(0, 2147483648)
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																						continue
																					end
																					break
																				end
																				loc_6 = bor_i32(loc_6, wrap_i32_i64(loc_7))
																				loc_1 = add_i32(loc_1, 1)
																				if loc_1 ~= loc_3 then
																					continue
																				end
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																		store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(loc_6))
																		desired = 0
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	if loc_3 == 0 then
																		desired = 1
																		break
																	end
																	if load_i32(memory_at_0.data, loc_2) ~= 3 then
																		desired = 1
																		break
																	end
																	loc_1 = (if loc_3 < 2 then 1 else 0)
																	while true do
																		while true do
																			loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																			if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																				break
																			end
																			loc_7 = truncate_i64_f64(loc_4)
																			desired = 16
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_7 = i64_from_u32(0, 2147483648)
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	loc_6 = wrap_i32_i64(loc_7)
																	while true do
																		if loc_1 ~= 0 then
																			break
																		end
																		loc_1 = 1
																		while true do
																			while true do
																				loc_8 = add_i32(loc_2, shl_i32(loc_1, 4))
																				if load_i32(memory_at_0.data, loc_8) == 3 then
																					break
																				end
																				store_i64(memory_at_0.data, loc_0, i64_ZERO)
																				store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
																				desired = 0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																					continue
																				end
																				break
																			end
																			while true do
																				while true do
																					loc_4 = load_f64(memory_at_0.data, loc_8 + 8)
																					if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																						break
																					end
																					loc_7 = truncate_i64_f64(loc_4)
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				loc_7 = i64_from_u32(0, 2147483648)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																					continue
																				end
																				break
																			end
																			loc_6 = bxor_i32(loc_6, wrap_i32_i64(loc_7))
																			loc_1 = add_i32(loc_1, 1)
																			if loc_1 ~= loc_3 then
																				continue
																			end
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
																	store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(loc_6))
																	desired = 0
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																if loc_3 == 0 then
																	desired = 1
																	break
																end
																if load_i32(memory_at_0.data, loc_2) ~= 3 then
																	desired = 1
																	break
																end
																loc_1 = (if loc_3 < 2 then 1 else 0)
																while true do
																	while true do
																		loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
																		if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																			break
																		end
																		loc_7 = truncate_i64_f64(loc_4)
																		desired = 15
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	loc_7 = i64_from_u32(0, 2147483648)
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																loc_6 = wrap_i32_i64(loc_7)
																while true do
																	if loc_1 ~= 0 then
																		break
																	end
																	loc_1 = 1
																	while true do
																		while true do
																			loc_8 = add_i32(loc_2, shl_i32(loc_1, 4))
																			if load_i32(memory_at_0.data, loc_8) == 3 then
																				break
																			end
																			store_i64(memory_at_0.data, loc_0, i64_ZERO)
																			store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
																			desired = 0
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																				continue
																			end
																			break
																		end
																		while true do
																			while true do
																				loc_4 = load_f64(memory_at_0.data, loc_8 + 8)
																				if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																					break
																				end
																				loc_7 = truncate_i64_f64(loc_4)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_7 = i64_from_u32(0, 2147483648)
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																				continue
																			end
																			break
																		end
																		loc_6 = band_i32(loc_6, wrap_i32_i64(loc_7))
																		loc_1 = add_i32(loc_1, 1)
																		if loc_1 ~= loc_3 then
																			continue
																		end
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																store_i32(memory_at_0.data, loc_0 + 8, 0)
																store_i64(memory_at_0.data, loc_0, i64_from_u32(2, 0))
																store_i32_n8(memory_at_0.data, loc_0 + 8, (if loc_6 ~= 0 then 1 else 0))
																desired = 0
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															if loc_3 < 2 then
																desired = 1
																break
															end
															if load_i32(memory_at_0.data, loc_2) ~= 3 then
																desired = 1
																break
															end
															if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
																desired = 1
																break
															end
															loc_1 = 1
															while true do
																if loc_3 == 2 then
																	break
																end
																if load_i32(memory_at_0.data, loc_2 + 32) ~= 3 then
																	desired = 1
																	break
																end
																while true do
																	loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 40))
																	if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
																		break
																	end
																	loc_1 = truncate_i32_f64(loc_4)
																	desired = 14
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																loc_1 = 2147483648
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															while true do
																while true do
																	loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
																	if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
																		break
																	end
																	loc_3 = truncate_i32_f64(loc_4)
																	desired = 14
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																loc_3 = 2147483648
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															if lt_i32(loc_3, 0) then
																desired = 1
																break
															end
															if lt_i32(loc_1, 1) then
																desired = 1
																break
															end
															if gt_i32(add_i32(loc_1, loc_3), 32) then
																desired = 1
																break
															end
															loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
															store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
															loc_2 = bxor_i32(shl_i32(4294967294, add_i32(loc_1, 4294967295)), 4294967295)
															while true do
																while true do
																	if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																		break
																	end
																	loc_7 = truncate_i64_f64(loc_4)
																	desired = 14
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																loc_7 = i64_from_u32(0, 2147483648)
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(band_i32(shr_u32(wrap_i32_i64(loc_7), loc_3), loc_2)))
															desired = 0
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														if loc_3 ~= 2 then
															desired = 1
															break
														end
														if load_i32(memory_at_0.data, loc_2) ~= 3 then
															desired = 1
															break
														end
														if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
															desired = 1
															break
														end
														loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
														loc_5 = load_f64(memory_at_0.data, loc_2 + 8)
														store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
														while true do
															while true do
																if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
																	break
																end
																loc_3 = truncate_i32_f64(loc_4)
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															loc_3 = 2147483648
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														while true do
															while true do
																if (if abs_f64(loc_5) < 9.223372036854776e18 then 1 else 0) == 0 then
																	break
																end
																loc_7 = truncate_i64_f64(loc_5)
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															loc_7 = i64_from_u32(0, 2147483648)
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(rotl_i32(wrap_i32_i64(loc_7), loc_3)))
														desired = 0
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if loc_3 ~= 2 then
														desired = 1
														break
													end
													if load_i32(memory_at_0.data, loc_2) ~= 3 then
														desired = 1
														break
													end
													if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
														desired = 1
														break
													end
													while true do
														while true do
															loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
															if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
																break
															end
															loc_3 = truncate_i32_f64(loc_4)
															desired = 12
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														loc_3 = 2147483648
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if loc_3 > 31 then
														desired = 1
														break
													end
													loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
													store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
													while true do
														while true do
															if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
																break
															end
															loc_7 = truncate_i64_f64(loc_4)
															desired = 12
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														loc_7 = i64_from_u32(0, 2147483648)
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(shl_i32(wrap_i32_i64(loc_7), loc_3)))
													desired = 0
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												if loc_3 < 3 then
													desired = 1
													break
												end
												if load_i32(memory_at_0.data, loc_2) ~= 3 then
													desired = 1
													break
												end
												if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
													desired = 1
													break
												end
												if load_i32(memory_at_0.data, loc_2 + 32) ~= 3 then
													desired = 1
													break
												end
												loc_1 = 1
												while true do
													if loc_3 == 3 then
														break
													end
													if load_i32(memory_at_0.data, loc_2 + 48) ~= 3 then
														desired = 1
														break
													end
													while true do
														loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 56))
														if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
															break
														end
														loc_1 = truncate_i32_f64(loc_4)
														desired = 11
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_1 = 2147483648
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												while true do
													while true do
														loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 40))
														if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
															break
														end
														loc_3 = truncate_i32_f64(loc_4)
														desired = 11
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_3 = 2147483648
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												if lt_i32(loc_3, 0) then
													desired = 1
													break
												end
												if lt_i32(loc_1, 1) then
													desired = 1
													break
												end
												if gt_i32(add_i32(loc_1, loc_3), 32) then
													desired = 1
													break
												end
												loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
												loc_5 = load_f64(memory_at_0.data, loc_2 + 8)
												store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
												loc_2 = bxor_i32(shl_i32(4294967294, add_i32(loc_1, 4294967295)), 4294967295)
												while true do
													while true do
														if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
															break
														end
														loc_7 = truncate_i64_f64(loc_4)
														desired = 11
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_7 = i64_from_u32(0, 2147483648)
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												loc_1 = shl_i32(band_i32(wrap_i32_i64(loc_7), loc_2), loc_3)
												loc_3 = bxor_i32(shl_i32(loc_2, loc_3), 4294967295)
												while true do
													while true do
														if (if abs_f64(loc_5) < 9.223372036854776e18 then 1 else 0) == 0 then
															break
														end
														loc_7 = truncate_i64_f64(loc_5)
														desired = 11
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_7 = i64_from_u32(0, 2147483648)
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(bor_i32(loc_1, band_i32(wrap_i32_i64(loc_7), loc_3))))
												desired = 0
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											if loc_3 ~= 2 then
												desired = 1
												break
											end
											if load_i32(memory_at_0.data, loc_2) ~= 3 then
												desired = 1
												break
											end
											if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
												desired = 1
												break
											end
											loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
											loc_5 = load_f64(memory_at_0.data, loc_2 + 8)
											store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
											while true do
												while true do
													if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
														break
													end
													loc_3 = truncate_i32_f64(loc_4)
													desired = 10
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												loc_3 = 2147483648
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											while true do
												while true do
													if (if abs_f64(loc_5) < 9.223372036854776e18 then 1 else 0) == 0 then
														break
													end
													loc_7 = truncate_i64_f64(loc_5)
													desired = 10
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												loc_7 = i64_from_u32(0, 2147483648)
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(rotr_i32(wrap_i32_i64(loc_7), loc_3)))
											desired = 0
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										if loc_3 ~= 2 then
											desired = 1
											break
										end
										if load_i32(memory_at_0.data, loc_2) ~= 3 then
											desired = 1
											break
										end
										if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
											desired = 1
											break
										end
										while true do
											while true do
												loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
												if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
													break
												end
												loc_3 = truncate_i32_f64(loc_4)
												desired = 9
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											loc_3 = 2147483648
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										if loc_3 > 31 then
											desired = 1
											break
										end
										loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
										store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
										while true do
											while true do
												if (if abs_f64(loc_4) < 9.223372036854776e18 then 1 else 0) == 0 then
													break
												end
												loc_7 = truncate_i64_f64(loc_4)
												desired = 9
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											loc_7 = i64_from_u32(0, 2147483648)
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(shr_u32(wrap_i32_i64(loc_7), loc_3)))
										desired = 0
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									if loc_3 ~= 1 then
										desired = 1
										break
									end
									if load_i32(memory_at_0.data, loc_2) == 0 then
										desired = 1
										break
									end
									FUNC_LIST[63](loc_0, loc_2)
									desired = 0
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								while true do
									while true do
										if not br_map[3] then
											br_map[3] = (function()
												return { [0] = 0, 1, }
											end)()
										end
										temp = br_map[3][add_i32(loc_3, 4294967295)] or 7
										if temp < 1 then
											break
										elseif temp > 1 then
											desired = 1
											break
										else
											desired = 7
											break
										end
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									if load_i32(memory_at_0.data, loc_2) ~= 4 then
										desired = 1
										break
									end
									if load_i32(memory_at_0.data, loc_2 + 4) == 0 then
										desired = 1
										break
									end
									loc_3 = load_i32_u8(memory_at_0.data, load_i32(memory_at_0.data, loc_2 + 8))
									store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
									store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(loc_3))
									desired = 0
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if load_i32(memory_at_0.data, loc_2) ~= 4 then
									desired = 1
									break
								end
								if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
									desired = 1
									break
								end
								while true do
									while true do
										loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
										if (if abs_f64(loc_4) < 2.147483648e9 then 1 else 0) == 0 then
											break
										end
										loc_3 = truncate_i32_f64(loc_4)
										desired = 7
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									loc_3 = 2147483648
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if lt_i32(loc_3, 1) then
									desired = 1
									break
								end
								if load_i32(memory_at_0.data, loc_2 + 4) < loc_3 then
									desired = 1
									break
								end
								loc_3 = load_i32_u8(memory_at_0.data, add_i32(add_i32(loc_3, load_i32(memory_at_0.data, loc_2 + 8)), 4294967295))
								store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
								store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(loc_3))
								desired = 0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_3 ~= 1 then
								desired = 1
								break
							end
							if load_i32(memory_at_0.data, loc_2) ~= 4 then
								desired = 1
								break
							end
							loc_3 = load_i32(memory_at_0.data, loc_2 + 4)
							store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
							store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(loc_3))
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_3 ~= 1 then
							desired = 1
							break
						end
						if load_i32(memory_at_0.data, loc_2) == 0 then
							desired = 1
							break
						end
						FUNC_LIST[63](loc_0, loc_2)
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_3 ~= 3 then
						desired = 1
						break
					end
					if load_i32(memory_at_0.data, loc_2) ~= 3 then
						desired = 1
						break
					end
					if load_i32(memory_at_0.data, loc_2 + 16) ~= 3 then
						desired = 1
						break
					end
					if load_i32(memory_at_0.data, loc_2 + 32) ~= 3 then
						desired = 1
						break
					end
					loc_4 = load_f64(memory_at_0.data, add_i32(loc_2, 24))
					loc_5 = load_f64(memory_at_0.data, add_i32(loc_2, 40))
					if (if loc_4 <= loc_5 then 1 else 0) == 0 then
						desired = 1
						break
					end
					loc_9 = load_f64(memory_at_0.data, loc_2 + 8)
					store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
					loc_4 = (if loc_9 < loc_4 then loc_4 else loc_9)
					store_f64(memory_at_0.data, loc_0 + 8, (if loc_4 > loc_5 then loc_5 else loc_4))
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_3 ~= 1 then
					desired = 1
					break
				end
				if load_i32(memory_at_0.data, loc_2) ~= 3 then
					desired = 1
					break
				end
				loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
				store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
				store_f64(memory_at_0.data, loc_0 + 8, (if loc_4 > 0e0 then 1e0 else (if loc_4 < 0e0 then -1e0 else 0e0)))
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_3 ~= 1 then
				break
			end
			if load_i32(memory_at_0.data, loc_2) ~= 3 then
				break
			end
			loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
			store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
			reg_1 = FUNC_LIST[1367](loc_4)
			store_f64(memory_at_0.data, loc_0 + 8, reg_1)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
		break
	end
end
FUNC_LIST[63] = --[[ Luau::Compile::ctype(Luau::Compile::Constant const&) ]] function(loc_0, loc_1)
	local desired
	local br_map = {}
	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, }
								end)()
							end
							temp = br_map[1][add_i32(load_i32(memory_at_0.data, loc_1), 4294967295)] or 4
							if temp < 2 then
								if temp < 1 then
									break
								else
									desired = 4
									break
								end
							elseif temp > 2 then
								if temp < 4 then
									desired = 2
									break
								else
									desired = 1
									break
								end
							else
								desired = 3
								break
							end
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 8, 5293)
						store_i64(memory_at_0.data, loc_0, i64_from_u32(4, 3))
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 8, 5111)
					store_i64(memory_at_0.data, loc_0, i64_from_u32(4, 7))
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, 4207)
				store_i64(memory_at_0.data, loc_0, i64_from_u32(4, 6))
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 8, 5916)
			store_i64(memory_at_0.data, loc_0, i64_from_u32(4, 6))
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
		break
	end
end
FUNC_LIST[64] = --[[ Luau::Compile::foldBuiltinMath(Luau::AstName) ]] function(loc_0, loc_1)
	local reg_0
	local desired
	while true do
		while true do
			if loc_1 == 0 then
				break
			end
			while true do
				reg_0 = FUNC_LIST[1379](loc_1, 5407)
				if reg_0 ~= 0 then
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_from_u32(1413754136, 1074340347))
				store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[1379](loc_1, 7818)
			if reg_0 ~= 0 then
				break
			end
			store_i64(memory_at_0.data, loc_0 + 8, i64_from_u32(0, 2146435072))
			store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
		break
	end
end
FUNC_LIST[65] = --[[ 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::DenseHashMap<Luau::AstExprCall*, int, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprCall*> > const*, bool, Luau::AstNode*) ]] function(loc_0, loc_1, loc_2, loc_3, loc_4, loc_5)
	local loc_6 = 0
	while true do
		loc_6 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_6
		store_i32(memory_at_0.data, add_i32(loc_6, 40), 0)
		store_i64(memory_at_0.data, loc_6 + 32, i64_ZERO)
		store_i32_n8(memory_at_0.data, loc_6 + 28, loc_4)
		store_i32(memory_at_0.data, loc_6 + 24, loc_3)
		store_i32(memory_at_0.data, loc_6 + 16, loc_1)
		loc_1 = add_i32(14144, 8)
		store_i32(memory_at_0.data, loc_6 + 8, loc_1)
		store_i32(memory_at_0.data, loc_6 + 12, loc_0)
		store_i32(memory_at_0.data, loc_6 + 20, loc_2)
		store_i32_n8(memory_at_0.data, loc_6 + 29, (if bor_i32(load_i32(memory_at_0.data, loc_0 + 8), load_i32(memory_at_0.data, loc_2 + 8)) == 0 then 1 else 0))
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_5))](loc_5, add_i32(loc_6, 8))
		store_i32(memory_at_0.data, loc_6 + 8, loc_1)
		while true do
			loc_5 = load_i32(memory_at_0.data, loc_6 + 32)
			if loc_5 == 0 then
				break
			end
			store_i32(memory_at_0.data, loc_6 + 36, loc_5)
			FUNC_LIST[1463](loc_5)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_6, 48)
		break
	end
end
FUNC_LIST[66] = --[[ Luau::Compile::ConstantVisitor::~ConstantVisitor() ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(14144, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 24)
			if loc_1 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 28), loc_1)
			FUNC_LIST[1463](loc_1)
			break
		end
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[67] = --[[ Luau::Compile::ConstantVisitor::~ConstantVisitor().1 ]] function(loc_0)
	local loc_1 = 0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(14144, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 24)
			if loc_1 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 28), loc_1)
			FUNC_LIST[1463](loc_1)
			break
		end
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[68] = --[[ Luau::Compile::ConstantVisitor::visit(Luau::AstExpr*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		FUNC_LIST[69](loc_2, loc_0, loc_1)
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[69] = --[[ Luau::Compile::ConstantVisitor::analyze(Luau::AstExpr*) ]] function(loc_0, loc_1, loc_2)
	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_3 = sub_i32(GLOBAL_LIST[0].value, 64)
		GLOBAL_LIST[0].value = loc_3
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_0, 8), 0)
		loc_4 = load_i32(memory_at_0.data, loc_2 + 4)
		while true do
			while true do
				while true do
					while true do
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59848) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
							store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(add_i32(loc_3, 48), 8)))
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3 + 48))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59856) then
								break
							end
							store_i32(memory_at_0.data, loc_0, 1)
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59864) then
								break
							end
							store_i32(memory_at_0.data, loc_0, 2)
							store_i32_n8(memory_at_0.data, loc_0 + 8, load_i32_u8(memory_at_0.data, loc_2 + 24))
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59872) then
								break
							end
							store_i32(memory_at_0.data, loc_0, 3)
							store_f64(memory_at_0.data, loc_0 + 8, load_f64(memory_at_0.data, loc_2 + 24))
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59880) then
								break
							end
							store_i32(memory_at_0.data, loc_0, 4)
							store_i32(memory_at_0.data, loc_0 + 8, load_i32(memory_at_0.data, loc_2 + 24))
							store_i32(memory_at_0.data, loc_0 + 4, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59888) then
								break
							end
							reg_0 = FUNC_LIST[72](load_i32(memory_at_0.data, loc_1 + 12), add_i32(loc_2, 24))
							loc_4 = reg_0
							if loc_4 == 0 then
								desired = 4
								break
							end
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_4))
							store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(loc_4, 8)))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_4 == load_i32(memory_at_0.data, 0 + 59896) then
							break
						end
						if loc_4 == load_i32(memory_at_0.data, 0 + 59904) then
							break
						end
						loc_5 = (if loc_4 == load_i32(memory_at_0.data, 0 + 59912) then loc_2 else 0)
						store_i32(memory_at_0.data, loc_3 + 44, loc_5)
						while true do
							if loc_5 == 0 then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_5 + 24))
							while true do
								while true do
									loc_4 = load_i32(memory_at_0.data, loc_1 + 16)
									if loc_4 == 0 then
										break
									end
									reg_0 = FUNC_LIST[73](loc_4, add_i32(loc_3, 44))
									loc_6 = reg_0
									if loc_6 ~= 0 then
										desired = 6
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_5 = load_i32(memory_at_0.data, loc_3 + 44)
								if load_i32(memory_at_0.data, add_i32(loc_5, 32)) == 0 then
									desired = 4
									break
								end
								loc_4 = 0
								while true do
									FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_5 + 28), shl_i32(loc_4, 2))))
									loc_4 = add_i32(loc_4, 1)
									loc_5 = load_i32(memory_at_0.data, loc_3 + 44)
									if loc_4 < load_i32(memory_at_0.data, add_i32(loc_5, 32)) then
										continue
									end
									desired = 4
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = add_i32(loc_1, 24)
							loc_8 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_1, 28)), load_i32(memory_at_0.data, loc_1 + 24)), 4)
							FUNC_LIST[74](loc_7, add_i32(loc_8, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_3 + 44), 32))))
							while true do
								while true do
									while true do
										loc_9 = load_i32(memory_at_0.data, loc_3 + 44)
										if load_i32(memory_at_0.data, add_i32(loc_9, 32)) ~= 0 then
											break
										end
										loc_10 = 0
										desired = 7
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									loc_4 = 0
									loc_11 = 1
									while true do
										FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_9 + 28), shl_i32(loc_4, 2))))
										loc_5 = 0
										while true do
											if load_i32(memory_at_0.data, loc_3 + 48) == 0 then
												break
											end
											FUNC_LIST[75](loc_7, add_i32(loc_3, 48))
											loc_5 = loc_11
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
												continue
											end
											break
										end
										loc_11 = loc_5
										loc_4 = add_i32(loc_4, 1)
										loc_9 = load_i32(memory_at_0.data, loc_3 + 44)
										loc_10 = load_i32(memory_at_0.data, add_i32(loc_9, 32))
										if loc_4 < loc_10 then
											continue
										end
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									if band_i32(loc_5, 1) == 0 then
										desired = 6
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								FUNC_LIST[62](add_i32(loc_3, 48), load_i32(memory_at_0.data, loc_6), add_i32(load_i32(memory_at_0.data, loc_7), shl_i32(loc_8, 4)), loc_10)
								store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(add_i32(loc_3, 48), 8)))
								store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3 + 48))
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							FUNC_LIST[76](loc_7, loc_8)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59920) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
							if load_i32_u8(memory_at_0.data, loc_1 + 20) == 0 then
								desired = 4
								break
							end
							loc_4 = load_i32(memory_at_0.data, loc_2 + 24)
							if load_i32(memory_at_0.data, loc_4 + 4) ~= load_i32(memory_at_0.data, 0 + 59896) then
								desired = 4
								break
							end
							if loc_4 == 0 then
								desired = 4
								break
							end
							loc_4 = load_i32(memory_at_0.data, loc_4 + 24)
							if loc_4 == 0 then
								desired = 4
								break
							end
							reg_0 = FUNC_LIST[1379](loc_4, 5469)
							if reg_0 ~= 0 then
								desired = 4
								break
							end
							FUNC_LIST[64](add_i32(loc_3, 48), load_i32(memory_at_0.data, add_i32(loc_2, 28)))
							store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(add_i32(loc_3, 48), 8)))
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3 + 48))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59928) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59936) then
								break
							end
							loc_4 = load_i32(memory_at_0.data, add_i32(loc_2, 92))
							TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_4))](loc_4, loc_1)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59944) then
								break
							end
							if loc_2 == 0 then
								break
							end
							if load_i32(memory_at_0.data, add_i32(loc_2, 28)) == 0 then
								desired = 4
								break
							end
							loc_4 = 0
							while true do
								while true do
									loc_5 = add_i32(load_i32(memory_at_0.data, loc_2 + 24), mul_i32(loc_4, 12))
									loc_9 = load_i32(memory_at_0.data, loc_5 + 4)
									if loc_9 == 0 then
										break
									end
									FUNC_LIST[69](add_i32(loc_3, 48), loc_1, loc_9)
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
										continue
									end
									break
								end
								FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_5 + 8))
								loc_4 = add_i32(loc_4, 1)
								if loc_4 < load_i32(memory_at_0.data, loc_2 + 28) then
									continue
								end
								desired = 4
								break
							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
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59952) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
							if load_i32(memory_at_0.data, loc_3 + 48) == 0 then
								desired = 4
								break
							end
							FUNC_LIST[77](loc_0, load_i32(memory_at_0.data, loc_2 + 24), add_i32(loc_3, 48))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59960) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
							FUNC_LIST[69](add_i32(loc_3, 24), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 32)))
							if load_i32(memory_at_0.data, loc_3 + 48) == 0 then
								desired = 4
								break
							end
							FUNC_LIST[78](loc_0, load_i32(memory_at_0.data, loc_2 + 24), add_i32(loc_3, 48), add_i32(loc_3, 24))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59968) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
							store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(add_i32(loc_3, 48), 8)))
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3 + 48))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if loc_2 == 0 then
								break
							end
							if loc_4 ~= load_i32(memory_at_0.data, 0 + 59976) then
								break
							end
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
							FUNC_LIST[69](add_i32(loc_3, 24), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 32)))
							FUNC_LIST[69](add_i32(loc_3, 8), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 40)))
							loc_4 = add_i32(loc_3, 8)
							while true do
								while true do
									while true do
										if not br_map[1] then
											br_map[1] = (function()
												return { [0] = 4, 2, 0, }
											end)()
										end
										temp = br_map[1][load_i32(memory_at_0.data, loc_3 + 48)] or 1
										if temp < 2 then
											if temp < 1 then
												break
											else
												desired = 7
												break
											end
										elseif temp > 2 then
											desired = 4
											break
										else
											desired = 6
											break
										end
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									if load_i32_u8(memory_at_0.data, loc_3 + 56) == 0 then
										desired = 6
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_4 = add_i32(loc_3, 24)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_4))
							store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(loc_4, 8)))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_2 == 0 then
							break
						end
						if loc_4 ~= load_i32(memory_at_0.data, 0 + 59984) then
							break
						end
						loc_5 = load_i32(memory_at_0.data, add_i32(loc_2, 36))
						if loc_5 == 0 then
							break
						end
						loc_4 = load_i32(memory_at_0.data, add_i32(loc_2, 32))
						loc_5 = add_i32(loc_4, shl_i32(loc_5, 2))
						while true do
							FUNC_LIST[69](add_i32(loc_3, 48), loc_1, load_i32(memory_at_0.data, loc_4))
							loc_4 = add_i32(loc_4, 4)
							if loc_4 ~= loc_5 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_4 = load_i32(memory_at_0.data, loc_1 + 4)
					loc_5 = load_i32(memory_at_0.data, loc_0)
					store_i32(memory_at_0.data, loc_3 + 48, loc_2)
					if loc_5 ~= 0 then
						desired = 2
						break
					end
					if load_i32_u8(memory_at_0.data, loc_1 + 21) ~= 0 then
						desired = 1
						break
					end
					if load_i32(memory_at_0.data, loc_4 + 8) == 0 then
						desired = 1
						break
					end
					loc_11 = load_i32(memory_at_0.data, loc_4 + 12)
					if loc_11 == loc_2 then
						desired = 1
						break
					end
					loc_1 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
					loc_5 = add_i32(load_i32(memory_at_0.data, loc_4 + 4), 4294967295)
					loc_9 = load_i32(memory_at_0.data, loc_4)
					loc_0 = 0
					while true do
						while true do
							loc_1 = band_i32(loc_1, loc_5)
							loc_4 = load_i32(memory_at_0.data, add_i32(loc_9, mul_i32(loc_1, 24)))
							if loc_4 == loc_2 then
								desired = 4
								break
							end
							if loc_4 == loc_11 then
								desired = 1
								break
							end
							loc_0 = add_i32(loc_0, 1)
							loc_1 = add_i32(loc_0, loc_1)
							if loc_0 <= loc_5 then
								continue
							end
							desired = 1
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, add_i32(loc_9, mul_i32(loc_1, 24)) + 8, 0)
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1 + 4)
				store_i32(memory_at_0.data, loc_3 + 48, loc_2)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[79](loc_4, add_i32(loc_3, 48))
			loc_2 = reg_0
			store_i64(memory_at_0.data, add_i32(loc_2, 8), load_i64(memory_at_0.data, add_i32(loc_0, 8)))
			store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_0))
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 64)
		break
	end
end
FUNC_LIST[70] = --[[ Luau::Compile::ConstantVisitor::visit(Luau::AstStatLocal*) ]] function(loc_0, loc_1)
	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_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			while true do
				while true do
					while true do
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_1, 32))
						if loc_3 ~= 0 then
							break
						end
						loc_4 = load_i32(memory_at_0.data, loc_1 + 40)
						loc_3 = 0
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						loc_4 = load_i32(memory_at_0.data, loc_1 + 40)
						if loc_4 == 0 then
							break
						end
						loc_5 = 0
						while true do
							loc_3 = shl_i32(loc_5, 2)
							FUNC_LIST[69](loc_2, loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), loc_3)))
							FUNC_LIST[71](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 28), loc_3)), loc_2)
							loc_4 = load_i32(memory_at_0.data, loc_1 + 40)
							loc_5 = add_i32(loc_5, 1)
							loc_3 = load_i32(memory_at_0.data, loc_1 + 32)
							if loc_5 >= loc_3 then
								desired = 4
								break
							end
							if loc_5 < 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
					if loc_3 > loc_4 then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_3 >= loc_4 then
					desired = 1
					break
				end
				while true do
					FUNC_LIST[69](loc_2, loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), shl_i32(loc_3, 2))))
					loc_3 = add_i32(loc_3, 1)
					if loc_3 < load_i32(memory_at_0.data, loc_1 + 40) then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_5 = 0
			while true do
				if loc_4 == 0 then
					break
				end
				while true do
					loc_5 = load_i32(memory_at_0.data, add_i32(add_i32(shl_i32(loc_4, 2), load_i32(memory_at_0.data, loc_1 + 36)), 4294967292))
					if loc_5 ~= 0 then
						break
					end
					loc_5 = loc_4
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_3 = load_i32(memory_at_0.data, loc_5 + 4)
				if loc_3 == load_i32(memory_at_0.data, 0 + 59912) then
					desired = 1
					break
				end
				loc_5 = loc_4
				if loc_3 == load_i32(memory_at_0.data, 0 + 59904) then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				store_i32(memory_at_0.data, loc_2 + 8, 0)
				store_i64(memory_at_0.data, loc_2, i64_ONE)
				FUNC_LIST[71](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 28), shl_i32(loc_5, 2))), loc_2)
				loc_5 = add_i32(loc_5, 1)
				if loc_5 < load_i32(memory_at_0.data, loc_1 + 32) 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_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[71] = --[[ Luau::Compile::ConstantVisitor::recordValue(Luau::AstLocal*, Luau::Compile::Constant const&) ]] function(loc_0, loc_1, loc_2)
	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_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		loc_4 = 0
		while true do
			loc_5 = load_i32(memory_at_0.data, loc_0 + 8)
			if load_i32(memory_at_0.data, loc_5 + 8) == 0 then
				break
			end
			loc_4 = 0
			loc_6 = load_i32(memory_at_0.data, loc_5 + 12)
			if loc_6 == loc_1 then
				break
			end
			loc_7 = bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9))
			loc_8 = add_i32(load_i32(memory_at_0.data, loc_5 + 4), 4294967295)
			loc_9 = load_i32(memory_at_0.data, loc_5)
			loc_5 = 0
			while true do
				loc_10 = band_i32(loc_7, loc_8)
				loc_4 = add_i32(loc_9, mul_i32(loc_10, 12))
				loc_7 = load_i32(memory_at_0.data, loc_4)
				if loc_7 == loc_1 then
					desired = 1
					break
				end
				loc_4 = 0
				if loc_7 == loc_6 then
					desired = 1
					break
				end
				loc_5 = add_i32(loc_5, 1)
				loc_7 = add_i32(loc_5, loc_10)
				if loc_5 <= loc_8 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			loc_5 = (if loc_4 ~= 0 then add_i32(loc_4, 4) else 0)
			if load_i32_u8(memory_at_0.data, loc_5 + 4) ~= 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_2)
			store_i32_n8(memory_at_0.data, loc_5 + 5, (if loc_4 ~= 0 then 1 else 0))
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			store_i32(memory_at_0.data, loc_3 + 12, loc_1)
			while true do
				if loc_4 == 0 then
					break
				end
				reg_0 = FUNC_LIST[411](loc_5, add_i32(loc_3, 12))
				loc_5 = reg_0
				store_i64(memory_at_0.data, add_i32(loc_5, 8), load_i64(memory_at_0.data, add_i32(loc_2, 8)))
				store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_2))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if load_i32_u8(memory_at_0.data, loc_0 + 21) ~= 0 then
				break
			end
			if load_i32(memory_at_0.data, loc_5 + 8) == 0 then
				break
			end
			loc_6 = load_i32(memory_at_0.data, loc_5 + 12)
			if loc_6 == loc_1 then
				break
			end
			loc_4 = bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9))
			loc_7 = add_i32(load_i32(memory_at_0.data, loc_5 + 4), 4294967295)
			loc_10 = load_i32(memory_at_0.data, loc_5)
			loc_5 = 0
			while true do
				while true do
					loc_8 = band_i32(loc_4, loc_7)
					loc_4 = load_i32(memory_at_0.data, add_i32(loc_10, mul_i32(loc_8, 24)))
					if loc_4 == loc_1 then
						desired = 2
						break
					end
					if loc_4 == loc_6 then
						desired = 1
						break
					end
					loc_5 = add_i32(loc_5, 1)
					loc_4 = add_i32(loc_5, loc_8)
					if loc_5 <= loc_7 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_10, mul_i32(loc_8, 24)) + 8, 0)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		break
	end
end
FUNC_LIST[72] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Constant, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::find(Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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_2 = 0
		while true do
			if load_i32(memory_at_0.data, loc_0 + 8) == 0 then
				break
			end
			loc_2 = 0
			loc_3 = load_i32(memory_at_0.data, loc_1)
			loc_4 = load_i32(memory_at_0.data, loc_0 + 12)
			if loc_3 == loc_4 then
				break
			end
			loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
			loc_5 = add_i32(load_i32(memory_at_0.data, loc_0 + 4), 4294967295)
			loc_6 = load_i32(memory_at_0.data, loc_0)
			loc_0 = 0
			while true do
				loc_7 = band_i32(loc_1, loc_5)
				loc_2 = add_i32(loc_6, mul_i32(loc_7, 24))
				loc_1 = load_i32(memory_at_0.data, loc_2)
				if loc_1 == loc_3 then
					desired = 1
					break
				end
				loc_2 = 0
				if loc_1 == loc_4 then
					desired = 1
					break
				end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_7)
				if loc_0 <= loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		reg_0 = (if loc_2 ~= 0 then add_i32(loc_2, 8) else 0)
		break
	end
	return reg_0
end
FUNC_LIST[73] = --[[ Luau::DenseHashMap<Luau::AstExprCall*, int, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprCall*> >::find(Luau::AstExprCall* const&) const ]] function(loc_0, loc_1)
	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_2 = 0
		while true do
			if load_i32(memory_at_0.data, loc_0 + 8) == 0 then
				break
			end
			loc_2 = 0
			loc_3 = load_i32(memory_at_0.data, loc_1)
			loc_4 = load_i32(memory_at_0.data, loc_0 + 12)
			if loc_3 == loc_4 then
				break
			end
			loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
			loc_5 = add_i32(load_i32(memory_at_0.data, loc_0 + 4), 4294967295)
			loc_6 = load_i32(memory_at_0.data, loc_0)
			loc_0 = 0
			while true do
				loc_7 = band_i32(loc_1, loc_5)
				loc_2 = add_i32(loc_6, shl_i32(loc_7, 3))
				loc_1 = load_i32(memory_at_0.data, loc_2)
				if loc_1 == loc_3 then
					desired = 1
					break
				end
				loc_2 = 0
				if loc_1 == loc_4 then
					desired = 1
					break
				end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_7)
				if loc_0 <= loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		reg_0 = (if loc_2 ~= 0 then add_i32(loc_2, 4) else 0)
		break
	end
	return reg_0
end
FUNC_LIST[74] = --[[ std::__2::vector<Luau::Compile::Constant, std::__2::allocator<Luau::Compile::Constant> >::reserve(unsigned long) ]] function(loc_0, loc_1)
	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
				loc_2 = load_i32(memory_at_0.data, loc_0)
				if shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 8), loc_2), 4) >= loc_1 then
					break
				end
				if loc_1 >= 268435456 then
					desired = 1
					break
				end
				loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_4 = shl_i32(loc_1, 4)
				reg_0 = FUNC_LIST[1461](loc_4)
				loc_1 = reg_0
				loc_4 = add_i32(loc_1, loc_4)
				loc_3 = sub_i32(loc_3, loc_2)
				loc_5 = add_i32(loc_1, loc_3)
				while true do
					if lt_i32(loc_3, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_1, loc_2, loc_3)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, loc_4)
				store_i32(memory_at_0.data, loc_0 + 4, loc_5)
				store_i32(memory_at_0.data, loc_0, loc_1)
				if loc_2 == 0 then
					break
				end
				FUNC_LIST[1463](loc_2)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[80](loc_0)
		error("out of code bounds")
	end
end
FUNC_LIST[75] = --[[ std::__2::vector<Luau::Compile::Constant, std::__2::allocator<Luau::Compile::Constant> >::push_back(Luau::Compile::Constant const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 == load_i32(memory_at_0.data, loc_0 + 8) then
				break
			end
			store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_1))
			store_i64(memory_at_0.data, add_i32(loc_2, 8), load_i64(memory_at_0.data, add_i32(loc_1, 8)))
			store_i32(memory_at_0.data, loc_0 + 4, add_i32(loc_2, 16))
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_0)
				loc_2 = sub_i32(loc_2, loc_3)
				loc_4 = shr_i32(loc_2, 4)
				loc_5 = add_i32(loc_4, 1)
				if loc_5 >= 268435456 then
					break
				end
				while true do
					while true do
						loc_6 = shr_i32(loc_2, 3)
						loc_6 = (if loc_2 < 2147483632 then (if loc_6 < loc_5 then loc_5 else loc_6) else 268435455)
						if loc_6 ~= 0 then
							break
						end
						loc_5 = 0
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_6 >= 268435456 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1461](shl_i32(loc_6, 4))
					loc_5 = reg_0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_4 = add_i32(loc_5, shl_i32(loc_4, 4))
				store_i64(memory_at_0.data, loc_4, load_i64(memory_at_0.data, loc_1))
				store_i64(memory_at_0.data, add_i32(loc_4, 8), load_i64(memory_at_0.data, add_i32(loc_1, 8)))
				loc_1 = add_i32(loc_5, shl_i32(loc_6, 4))
				loc_6 = add_i32(loc_4, 16)
				while true do
					if lt_i32(loc_2, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_5, loc_3, loc_2)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, loc_1)
				store_i32(memory_at_0.data, loc_0 + 4, loc_6)
				store_i32(memory_at_0.data, loc_0, loc_5)
				while true do
					if loc_3 == 0 then
						break
					end
					FUNC_LIST[1463](loc_3)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[80](loc_0)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[76] = --[[ std::__2::vector<Luau::Compile::Constant, std::__2::allocator<Luau::Compile::Constant> >::resize(unsigned long) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local desired
	while true do
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0)
			loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 4), loc_2), 4)
			if loc_3 >= loc_1 then
				break
			end
			FUNC_LIST[81](loc_0, sub_i32(loc_1, loc_3))
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if loc_3 <= loc_1 then
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, add_i32(loc_2, shl_i32(loc_1, 4)))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		break
	end
end
FUNC_LIST[77] = --[[ Luau::Compile::foldUnary(Luau::Compile::Constant&, Luau::AstExprUnary::Op, Luau::Compile::Constant const&) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 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
						temp = br_map[1][loc_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.data, loc_2) == 0 then
						desired = 1
						break
					end
					store_i32(memory_at_0.data, loc_0, 2)
					loc_3 = 1
					loc_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
								temp = br_map[2][add_i32(load_i32(memory_at_0.data, loc_2), 4294967295)] 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_3 = (if load_i32_u8(memory_at_0.data, loc_2 + 8) ~= 0 then 1 else 0)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_1 = loc_3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32_n8(memory_at_0.data, loc_0 + 8, bxor_i32(loc_1, 1))
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if load_i32(memory_at_0.data, loc_2) ~= 3 then
					desired = 1
					break
				end
				store_i32(memory_at_0.data, loc_0, 3)
				store_f64(memory_at_0.data, loc_0 + 8, neg_f64(load_f64(memory_at_0.data, loc_2 + 8)))
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if load_i32(memory_at_0.data, loc_2) ~= 4 then
				break
			end
			store_i32(memory_at_0.data, loc_0, 3)
			store_f64(memory_at_0.data, loc_0 + 8, convert_f64_u32(load_i32(memory_at_0.data, loc_2 + 4)))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		break
	end
end
FUNC_LIST[78] = --[[ Luau::Compile::foldBinary(Luau::Compile::Constant&, Luau::AstExprBinary::Op, Luau::Compile::Constant const&, Luau::Compile::Constant const&) ]] function(loc_0, loc_1, loc_2, loc_3)
	local loc_4 = 0.0
	local loc_5 = 0.0
	local loc_6 = 0
	local reg_0
	local 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
																	while true do
																		if not br_map[1] then
																			br_map[1] = (function()
																				return { [0] = 0, 1, 2, 3, 4, 5, 6, 15, 7, 8, 9, 10, 11, 12, 13, 14, }
																			end)()
																		end
																		temp = br_map[1][loc_1] or 15
																		if temp < 8 then
																			if temp < 4 then
																				if temp < 2 then
																					if temp < 1 then
																						break
																					else
																						desired = 15
																						break
																					end
																				elseif temp > 2 then
																					desired = 13
																					break
																				else
																					desired = 14
																					break
																				end
																			elseif temp > 4 then
																				if temp < 6 then
																					desired = 11
																					break
																				elseif temp > 6 then
																					desired = 9
																					break
																				else
																					desired = 10
																					break
																				end
																			else
																				desired = 12
																				break
																			end
																		elseif temp > 8 then
																			if temp < 12 then
																				if temp < 10 then
																					desired = 7
																					break
																				elseif temp > 10 then
																					desired = 5
																					break
																				else
																					desired = 6
																					break
																				end
																			elseif temp > 12 then
																				if temp < 14 then
																					desired = 3
																					break
																				elseif temp > 14 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 == 15 then
																			desired = nil
																		end
																		break
																	end
																	if load_i32(memory_at_0.data, loc_2) ~= 3 then
																		desired = 1
																		break
																	end
																	if load_i32(memory_at_0.data, loc_3) ~= 3 then
																		desired = 1
																		break
																	end
																	store_i32(memory_at_0.data, loc_0, 3)
																	store_f64(memory_at_0.data, loc_0 + 8, (load_f64(memory_at_0.data, loc_2 + 8) + load_f64(memory_at_0.data, loc_3 + 8)))
																	desired = 0
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																if load_i32(memory_at_0.data, loc_2) ~= 3 then
																	desired = 1
																	break
																end
																if load_i32(memory_at_0.data, loc_3) ~= 3 then
																	desired = 1
																	break
																end
																store_i32(memory_at_0.data, loc_0, 3)
																store_f64(memory_at_0.data, loc_0 + 8, (load_f64(memory_at_0.data, loc_2 + 8) - load_f64(memory_at_0.data, loc_3 + 8)))
																desired = 0
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															if load_i32(memory_at_0.data, loc_2) ~= 3 then
																desired = 1
																break
															end
															if load_i32(memory_at_0.data, loc_3) ~= 3 then
																desired = 1
																break
															end
															store_i32(memory_at_0.data, loc_0, 3)
															store_f64(memory_at_0.data, loc_0 + 8, (load_f64(memory_at_0.data, loc_2 + 8) * load_f64(memory_at_0.data, loc_3 + 8)))
															desired = 0
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														if load_i32(memory_at_0.data, loc_2) ~= 3 then
															desired = 1
															break
														end
														if load_i32(memory_at_0.data, loc_3) ~= 3 then
															desired = 1
															break
														end
														store_i32(memory_at_0.data, loc_0, 3)
														store_f64(memory_at_0.data, loc_0 + 8, (load_f64(memory_at_0.data, loc_2 + 8) / load_f64(memory_at_0.data, loc_3 + 8)))
														desired = 0
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if load_i32(memory_at_0.data, loc_2) ~= 3 then
														desired = 1
														break
													end
													if load_i32(memory_at_0.data, loc_3) ~= 3 then
														desired = 1
														break
													end
													store_i32(memory_at_0.data, loc_0, 3)
													store_f64(memory_at_0.data, loc_0 + 8, floor_f64((load_f64(memory_at_0.data, loc_2 + 8) / load_f64(memory_at_0.data, loc_3 + 8))))
													desired = 0
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												if load_i32(memory_at_0.data, loc_2) ~= 3 then
													desired = 1
													break
												end
												if load_i32(memory_at_0.data, loc_3) ~= 3 then
													desired = 1
													break
												end
												store_i32(memory_at_0.data, loc_0, 3)
												loc_4 = load_f64(memory_at_0.data, loc_2 + 8)
												loc_5 = load_f64(memory_at_0.data, loc_3 + 8)
												store_f64(memory_at_0.data, loc_0 + 8, (loc_4 - (floor_f64((loc_4 / loc_5)) * loc_5)))
												desired = 0
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											if load_i32(memory_at_0.data, loc_2) ~= 3 then
												desired = 1
												break
											end
											if load_i32(memory_at_0.data, loc_3) ~= 3 then
												desired = 1
												break
											end
											store_i32(memory_at_0.data, loc_0, 3)
											reg_1 = FUNC_LIST[1354](load_f64(memory_at_0.data, loc_2 + 8), load_f64(memory_at_0.data, loc_3 + 8))
											store_f64(memory_at_0.data, loc_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.data, loc_2) == 0 then
											desired = 1
											break
										end
										if load_i32(memory_at_0.data, loc_3) == 0 then
											desired = 1
											break
										end
										store_i32(memory_at_0.data, loc_0, 2)
										loc_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
															temp = br_map[2][add_i32(load_i32(memory_at_0.data, loc_2), 4294967295)] 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
														loc_1 = (if load_i32(memory_at_0.data, loc_3) == 1 then 1 else 0)
														desired = 9
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_1 = band_i32((if load_i32(memory_at_0.data, loc_3) == 2 then 1 else 0), (if load_i32_u8(memory_at_0.data, loc_2 + 8) == load_i32_u8(memory_at_0.data, loc_3 + 8) then 1 else 0))
													desired = 9
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												loc_1 = band_i32((if load_i32(memory_at_0.data, loc_3) == 3 then 1 else 0), (if load_f64(memory_at_0.data, loc_2 + 8) == load_f64(memory_at_0.data, loc_3 + 8) then 1 else 0))
												desired = 9
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											if load_i32(memory_at_0.data, loc_3) ~= 4 then
												break
											end
											loc_6 = load_i32(memory_at_0.data, loc_2 + 4)
											if loc_6 ~= load_i32(memory_at_0.data, loc_3 + 4) then
												break
											end
											reg_0 = FUNC_LIST[1345](load_i32(memory_at_0.data, loc_2 + 8), load_i32(memory_at_0.data, loc_3 + 8), loc_6)
											loc_1 = (if reg_0 == 0 then 1 else 0)
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										store_i32_n8(memory_at_0.data, loc_0 + 8, bxor_i32(loc_1, 1))
										desired = 0
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									if load_i32(memory_at_0.data, loc_2) == 0 then
										desired = 1
										break
									end
									if load_i32(memory_at_0.data, loc_3) == 0 then
										desired = 1
										break
									end
									store_i32(memory_at_0.data, loc_0, 2)
									loc_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
														temp = br_map[3][add_i32(load_i32(memory_at_0.data, loc_2), 4294967295)] 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.data, loc_0 + 8, (if load_i32(memory_at_0.data, loc_3) == 1 then 1 else 0))
													desired = 0
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32_n8(memory_at_0.data, loc_0 + 8, band_i32((if load_i32(memory_at_0.data, loc_3) == 2 then 1 else 0), (if load_i32_u8(memory_at_0.data, loc_2 + 8) == load_i32_u8(memory_at_0.data, loc_3 + 8) then 1 else 0)))
												desired = 0
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											store_i32_n8(memory_at_0.data, loc_0 + 8, band_i32((if load_i32(memory_at_0.data, loc_3) == 3 then 1 else 0), (if load_f64(memory_at_0.data, loc_2 + 8) == load_f64(memory_at_0.data, loc_3 + 8) then 1 else 0)))
											desired = 0
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										if load_i32(memory_at_0.data, loc_3) ~= 4 then
											break
										end
										loc_6 = load_i32(memory_at_0.data, loc_2 + 4)
										if loc_6 ~= load_i32(memory_at_0.data, loc_3 + 4) then
											break
										end
										reg_0 = FUNC_LIST[1345](load_i32(memory_at_0.data, loc_2 + 8), load_i32(memory_at_0.data, loc_3 + 8), loc_6)
										loc_1 = (if reg_0 == 0 then 1 else 0)
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									store_i32_n8(memory_at_0.data, loc_0 + 8, loc_1)
									desired = 0
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if load_i32(memory_at_0.data, loc_2) ~= 3 then
									desired = 1
									break
								end
								if load_i32(memory_at_0.data, loc_3) ~= 3 then
									desired = 1
									break
								end
								store_i32(memory_at_0.data, loc_0, 2)
								store_i32_n8(memory_at_0.data, loc_0 + 8, (if load_f64(memory_at_0.data, loc_2 + 8) < load_f64(memory_at_0.data, loc_3 + 8) then 1 else 0))
								desired = 0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if load_i32(memory_at_0.data, loc_2) ~= 3 then
								desired = 1
								break
							end
							if load_i32(memory_at_0.data, loc_3) ~= 3 then
								desired = 1
								break
							end
							store_i32(memory_at_0.data, loc_0, 2)
							store_i32_n8(memory_at_0.data, loc_0 + 8, (if load_f64(memory_at_0.data, loc_2 + 8) <= load_f64(memory_at_0.data, loc_3 + 8) then 1 else 0))
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if load_i32(memory_at_0.data, loc_2) ~= 3 then
							desired = 1
							break
						end
						if load_i32(memory_at_0.data, loc_3) ~= 3 then
							desired = 1
							break
						end
						store_i32(memory_at_0.data, loc_0, 2)
						store_i32_n8(memory_at_0.data, loc_0 + 8, (if load_f64(memory_at_0.data, loc_2 + 8) > load_f64(memory_at_0.data, loc_3 + 8) then 1 else 0))
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if load_i32(memory_at_0.data, loc_2) ~= 3 then
						desired = 1
						break
					end
					if load_i32(memory_at_0.data, loc_3) ~= 3 then
						desired = 1
						break
					end
					store_i32(memory_at_0.data, loc_0, 2)
					store_i32_n8(memory_at_0.data, loc_0 + 8, (if load_f64(memory_at_0.data, loc_2 + 8) >= load_f64(memory_at_0.data, loc_3 + 8) then 1 else 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
							temp = br_map[4][load_i32(memory_at_0.data, loc_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.data, loc_2 + 8) == 0 then
							desired = 3
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_2 = loc_3
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_2))
				store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(loc_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
						temp = br_map[5][load_i32(memory_at_0.data, loc_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.data, loc_2 + 8) == 0 then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_3 = loc_2
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3))
			store_i64(memory_at_0.data, add_i32(loc_0, 8), load_i64(memory_at_0.data, add_i32(loc_3, 8)))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		break
	end
end
FUNC_LIST[79] = --[[ Luau::DenseHashMap<Luau::AstExpr*, Luau::Compile::Constant, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExpr*> >::operator[](Luau::AstExpr* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, mul_i32(loc_9, 24)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[82](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, mul_i32(loc_9, 24))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 8)
		break
	end
	return reg_0
end
FUNC_LIST[80] = --[[ std::__2::vector<Luau::Compile::Constant, std::__2::allocator<Luau::Compile::Constant> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[81] = --[[ std::__2::vector<Luau::Compile::Constant, std::__2::allocator<Luau::Compile::Constant> >::__append(unsigned long) ]] function(loc_0, loc_1)
	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_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if shr_i32(sub_i32(loc_2, loc_3), 4) < loc_1 then
				break
			end
			while true do
				if loc_1 == 0 then
					break
				end
				loc_1 = shl_i32(loc_1, 4)
				reg_0 = FUNC_LIST[1286](loc_3, 0, loc_1)
				loc_3 = add_i32(reg_0, loc_1)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, loc_3)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				loc_4 = load_i32(memory_at_0.data, loc_0)
				loc_5 = sub_i32(loc_3, loc_4)
				loc_6 = shr_i32(loc_5, 4)
				loc_7 = add_i32(loc_6, loc_1)
				if loc_7 >= 268435456 then
					break
				end
				loc_3 = 0
				while true do
					loc_2 = sub_i32(loc_2, loc_4)
					loc_8 = shr_i32(loc_2, 3)
					loc_2 = (if loc_2 < 2147483632 then (if loc_8 < loc_7 then loc_7 else loc_8) else 268435455)
					if loc_2 == 0 then
						break
					end
					if loc_2 >= 268435456 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1461](shl_i32(loc_2, 4))
					loc_3 = reg_0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = shl_i32(loc_1, 4)
				reg_0 = FUNC_LIST[1286](add_i32(loc_3, shl_i32(loc_6, 4)), 0, loc_1)
				loc_1 = add_i32(reg_0, loc_1)
				loc_2 = add_i32(loc_3, shl_i32(loc_2, 4))
				while true do
					if lt_i32(loc_5, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_3, loc_4, loc_5)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, loc_2)
				store_i32(memory_at_0.data, loc_0 + 4, loc_1)
				store_i32(memory_at_0.data, loc_0, loc_3)
				while true do
					if loc_4 == 0 then
						break
					end
					FUNC_LIST[1463](loc_4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[80](loc_0)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[82] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](mul_i32(loc_3, 24))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_2 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_8 = band_i32(loc_3, 4294967292)
				loc_2 = 0
				loc_9 = 0
				while true do
					loc_10 = add_i32(loc_4, mul_i32(loc_2, 24))
					store_i64(memory_at_0.data, loc_10 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i64(memory_at_0.data, add_i32(loc_10, 16), i64_ZERO)
					loc_10 = add_i32(loc_4, mul_i32(bor_i32(loc_2, 1), 24))
					store_i64(memory_at_0.data, loc_10 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i64(memory_at_0.data, add_i32(loc_10, 16), i64_ZERO)
					loc_10 = add_i32(loc_4, mul_i32(bor_i32(loc_2, 2), 24))
					store_i64(memory_at_0.data, loc_10 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i64(memory_at_0.data, add_i32(loc_10, 16), i64_ZERO)
					loc_10 = add_i32(loc_4, mul_i32(bor_i32(loc_2, 3), 24))
					store_i64(memory_at_0.data, loc_10 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i64(memory_at_0.data, add_i32(loc_10, 16), i64_ZERO)
					loc_2 = add_i32(loc_2, 4)
					loc_9 = add_i32(loc_9, 4)
					if loc_9 ~= 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_10 = add_i32(loc_4, mul_i32(loc_2, 24))
					store_i64(memory_at_0.data, loc_10 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i64(memory_at_0.data, add_i32(loc_10, 16), i64_ZERO)
					loc_2 = add_i32(loc_2, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_10 = add_i32(loc_3, 4294967295)
			loc_8 = 0
			while true do
				while true do
					loc_11 = add_i32(load_i32(memory_at_0.data, loc_0), mul_i32(loc_8, 24))
					loc_9 = load_i32(memory_at_0.data, loc_11)
					if loc_9 == loc_5 then
						break
					end
					loc_5 = bxor_i32(shr_u32(loc_9, 4), shr_u32(loc_9, 9))
					loc_2 = 0
					while true do
						while true do
							while true do
								loc_7 = band_i32(loc_5, loc_10)
								loc_6 = add_i32(loc_4, mul_i32(loc_7, 24))
								loc_5 = load_i32(memory_at_0.data, loc_6)
								if loc_5 ~= loc_1 then
									break
								end
								store_i32(memory_at_0.data, loc_6, loc_9)
								loc_9 = load_i32(memory_at_0.data, loc_11)
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							if loc_5 == loc_9 then
								desired = 4
								break
							end
							loc_2 = add_i32(loc_2, 1)
							loc_5 = add_i32(loc_2, loc_7)
							if loc_2 <= loc_10 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_6, loc_9)
					store_i64(memory_at_0.data, loc_6 + 8, load_i64(memory_at_0.data, loc_11 + 8))
					store_i64(memory_at_0.data, add_i32(loc_6, 16), load_i64(memory_at_0.data, add_i32(loc_11, 16)))
					loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_8 = add_i32(loc_8, 1)
				if loc_8 >= loc_2 then
					desired = 1
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_2 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			break
		end
		break
	end
end
FUNC_LIST[83] = --[[ Luau::Compile::predictTableShapes(Luau::DenseHashMap<Luau::AstExprTable*, Luau::Compile::TableShape, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprTable*> >&, Luau::AstNode*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_2
		store_i64(memory_at_0.data, add_i32(loc_2, 24), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_2, 44), i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_2, 52), 0)
		store_i64(memory_at_0.data, add_i32(loc_2, 68), i64_ZERO)
		store_i64(memory_at_0.data, loc_2 + 16, i64_ZERO)
		store_i32(memory_at_0.data, loc_2 + 12, loc_0)
		store_i64(memory_at_0.data, loc_2 + 36, i64_ZERO)
		store_i64(memory_at_0.data, loc_2 + 60, i64_ZERO)
		loc_0 = add_i32(14432, 8)
		store_i32(memory_at_0.data, loc_2 + 8, loc_0)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1))](loc_1, add_i32(loc_2, 8))
		store_i32(memory_at_0.data, loc_2 + 8, loc_0)
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_2 + 60)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_2 + 60, i64_ZERO)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_2 + 36)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_2 + 36, i64_ZERO)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_2 + 16)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 80)
		break
	end
end
FUNC_LIST[84] = --[[ Luau::Compile::ShapeVisitor::~ShapeVisitor() ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(14432, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 52)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 52, i64_ZERO)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 28)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 28, i64_ZERO)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 8)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
			break
		end
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[85] = --[[ Luau::Compile::ShapeVisitor::~ShapeVisitor().1 ]] function(loc_0)
	local loc_1 = 0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(14432, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 52)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 52, i64_ZERO)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 28)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 28, i64_ZERO)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 8)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[86] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatLocal*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local desired
	while true do
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_1, 32)) ~= 1 then
				break
			end
			if load_i32(memory_at_0.data, add_i32(loc_1, 40)) ~= 1 then
				break
			end
			loc_2 = load_i32(memory_at_0.data, 0 + 59944)
			loc_3 = load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1 + 36))
			loc_4 = load_i32(memory_at_0.data, loc_3 + 4)
			while true do
				while true do
					if loc_3 == 0 then
						break
					end
					if loc_4 == loc_2 then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_3 == 0 then
					desired = 1
					break
				end
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59912) then
					desired = 1
					break
				end
				if load_i32_u8(memory_at_0.data, add_i32(loc_3, 36)) ~= 0 then
					desired = 1
					break
				end
				if load_i32(memory_at_0.data, add_i32(loc_3, 32)) ~= 2 then
					desired = 1
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_3 + 24)
				if load_i32(memory_at_0.data, loc_4 + 4) ~= load_i32(memory_at_0.data, 0 + 59896) then
					desired = 1
					break
				end
				if loc_4 == 0 then
					desired = 1
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_4 + 24)
				if loc_4 == 0 then
					desired = 1
					break
				end
				reg_0 = FUNC_LIST[1379](loc_4, 7550)
				if reg_0 ~= 0 then
					desired = 1
					break
				end
				loc_3 = load_i32(memory_at_0.data, load_i32(memory_at_0.data, add_i32(loc_3, 28)))
				if load_i32(memory_at_0.data, loc_3 + 4) ~= loc_2 then
					desired = 1
					break
				end
				if loc_3 == 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if load_i32(memory_at_0.data, add_i32(loc_3, 28)) ~= 0 then
				break
			end
			reg_0 = FUNC_LIST[87](add_i32(loc_0, 8), load_i32(memory_at_0.data, loc_1 + 28))
			store_i32(memory_at_0.data, reg_0, loc_3)
			break
		end
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[87] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::AstExprTable*, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::operator[](Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 3)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[94](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 3))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[88] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatFor*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0.0
	local reg_0
	local reg_1
	local reg_2
	local desired
	while true do
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
			reg_0 = loc_2
			reg_2 = load_i32(memory_at_0.data, loc_2 + 4)
			loc_2 = load_i32(memory_at_0.data, 0 + 59872)
			loc_3 = (if reg_2 == loc_2 then reg_0 else 0)
			if loc_3 == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_1 + 36)
			loc_2 = (if load_i32(memory_at_0.data, loc_4 + 4) == loc_2 then loc_4 else 0)
			if loc_2 == 0 then
				break
			end
			if load_f64(memory_at_0.data, loc_3 + 24) ~= 1e0 then
				break
			end
			loc_5 = load_f64(memory_at_0.data, loc_2 + 24)
			if (if loc_5 >= 1e0 then 1 else 0) == 0 then
				break
			end
			if (if loc_5 <= 1.6e1 then 1 else 0) == 0 then
				break
			end
			if load_i32(memory_at_0.data, loc_1 + 40) ~= 0 then
				break
			end
			loc_1 = add_i32(loc_1, 28)
			loc_2 = add_i32(loc_0, 52)
			while true do
				while true do
					if band_i32((if loc_5 < 4.294967296e9 then 1 else 0), (if loc_5 >= 0e0 then 1 else 0)) == 0 then
						break
					end
					loc_3 = truncate_u32_f64(loc_5)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_3 = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[89](loc_2, loc_1)
			store_i32(memory_at_0.data, reg_0, loc_3)
			break
		end
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[89] = --[[ Luau::DenseHashMap<Luau::AstLocal*, unsigned int, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::operator[](Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 3)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[95](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 3))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[90] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatAssign*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local desired
	while true do
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_1, 32)) == 0 then
				break
			end
			loc_2 = 0
			while true do
				loc_3 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 28), shl_i32(loc_2, 2)))
				loc_4 = load_i32(memory_at_0.data, loc_3 + 4)
				while true do
					while true do
						if loc_3 == 0 then
							break
						end
						if loc_4 ~= load_i32(memory_at_0.data, 0 + 59920) then
							break
						end
						FUNC_LIST[91](loc_0, load_i32(memory_at_0.data, loc_3 + 24), load_i32(memory_at_0.data, add_i32(loc_3, 28)))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_3 == 0 then
						break
					end
					if loc_4 ~= load_i32(memory_at_0.data, 0 + 59928) then
						break
					end
					FUNC_LIST[92](loc_0, load_i32(memory_at_0.data, loc_3 + 24), load_i32(memory_at_0.data, add_i32(loc_3, 28)))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_2 = add_i32(loc_2, 1)
				if loc_2 < load_i32(memory_at_0.data, loc_1 + 32) then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_1, 40)) == 0 then
				break
			end
			loc_3 = 0
			while true do
				loc_2 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), shl_i32(loc_3, 2)))
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
				loc_3 = add_i32(loc_3, 1)
				if loc_3 < load_i32(memory_at_0.data, loc_1 + 40) then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[91] = --[[ Luau::Compile::ShapeVisitor::assignField(Luau::AstExpr*, Luau::AstName) ]] function(loc_0, loc_1, loc_2)
	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, 16)
		GLOBAL_LIST[0].value = loc_3
		while true do
			if loc_1 == 0 then
				break
			end
			if load_i32(memory_at_0.data, loc_1 + 4) ~= load_i32(memory_at_0.data, 0 + 59888) then
				break
			end
			if load_i32(memory_at_0.data, add_i32(loc_0, 16)) == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_1 + 24)
			loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 20))
			if loc_4 == loc_5 then
				break
			end
			loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
			loc_7 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 12)), 4294967295)
			loc_8 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_1 = 0
			while true do
				while true do
					loc_6 = band_i32(loc_6, loc_7)
					loc_9 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_6, 3)))
					if loc_9 == loc_4 then
						desired = 2
						break
					end
					if loc_9 == loc_5 then
						desired = 1
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_6 = add_i32(loc_1, loc_6)
					if loc_1 <= loc_7 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_10 = add_i32(loc_8, shl_i32(loc_6, 3))
			loc_8 = load_i32(memory_at_0.data, loc_10 + 4)
			store_i32(memory_at_0.data, loc_3 + 12, loc_2)
			store_i32(memory_at_0.data, loc_3 + 8, loc_8)
			while true do
				if load_i32(memory_at_0.data, add_i32(loc_0, 36)) == 0 then
					break
				end
				loc_11 = load_i32(memory_at_0.data, add_i32(loc_0, 44))
				while true do
					loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 40))
					if loc_8 ~= loc_5 then
						break
					end
					if loc_11 == loc_2 then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_6 = bxor_i32(bxor_i32(bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9)), shr_u32(loc_2, 9)), shr_u32(loc_2, 4))
				loc_7 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 32)), 4294967295)
				loc_12 = load_i32(memory_at_0.data, loc_0 + 28)
				loc_1 = 0
				while true do
					loc_4 = band_i32(loc_6, loc_7)
					loc_6 = add_i32(loc_12, shl_i32(loc_4, 3))
					loc_9 = load_i32(memory_at_0.data, loc_6 + 4)
					while true do
						loc_6 = load_i32(memory_at_0.data, loc_6)
						if loc_6 ~= loc_8 then
							break
						end
						if loc_9 == loc_2 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if loc_6 ~= loc_5 then
							break
						end
						if loc_9 == loc_11 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_6 = add_i32(loc_1, loc_4)
					if loc_1 <= loc_7 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
			reg_0 = FUNC_LIST[96](add_i32(loc_0, 28), add_i32(loc_3, 8))
			reg_0 = FUNC_LIST[393](load_i32(memory_at_0.data, loc_0 + 4), add_i32(loc_10, 4))
			loc_1 = reg_0
			store_i32(memory_at_0.data, loc_1 + 4, add_i32(load_i32(memory_at_0.data, loc_1 + 4), 1))
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		break
	end
end
FUNC_LIST[92] = --[[ Luau::Compile::ShapeVisitor::assignField(Luau::AstExpr*, Luau::AstExpr*) ]] function(loc_0, loc_1, loc_2)
	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
			if loc_1 == 0 then
				break
			end
			loc_3 = load_i32(memory_at_0.data, loc_1 + 4)
			if loc_3 ~= load_i32(memory_at_0.data, 0 + 59888) then
				break
			end
			if load_i32(memory_at_0.data, add_i32(loc_0, 16)) == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_1 + 24)
			loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 20))
			if loc_4 == loc_5 then
				break
			end
			loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
			loc_7 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 12)), 4294967295)
			loc_8 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_1 = 0
			while true do
				while true do
					loc_6 = band_i32(loc_6, loc_7)
					loc_9 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_6, 3)))
					if loc_9 == loc_4 then
						desired = 2
						break
					end
					if loc_9 == loc_5 then
						desired = 1
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_6 = add_i32(loc_1, loc_6)
					if loc_1 <= loc_7 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_10 = add_i32(add_i32(loc_8, shl_i32(loc_6, 3)), 4)
			loc_1 = load_i32(memory_at_0.data, loc_2 + 4)
			while true do
				if loc_2 == 0 then
					break
				end
				if loc_1 ~= load_i32(memory_at_0.data, 0 + 59872) then
					break
				end
				reg_0 = FUNC_LIST[393](load_i32(memory_at_0.data, loc_0 + 4), loc_10)
				loc_1 = reg_0
				loc_6 = add_i32(load_i32(memory_at_0.data, loc_1), 1)
				if load_f64(memory_at_0.data, loc_2 + 24) ~= convert_f64_u32(loc_6) then
					desired = 1
					break
				end
				store_i32(memory_at_0.data, loc_1, loc_6)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_2 == 0 then
				break
			end
			if loc_1 ~= loc_3 then
				break
			end
			if load_i32(memory_at_0.data, add_i32(loc_0, 60)) == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_2 + 24)
			loc_8 = load_i32(memory_at_0.data, add_i32(loc_0, 64))
			if loc_4 == loc_8 then
				break
			end
			loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
			loc_7 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 56)), 4294967295)
			loc_5 = load_i32(memory_at_0.data, loc_0 + 52)
			loc_1 = 0
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_9, 3)))
					if loc_6 == loc_4 then
						desired = 2
						break
					end
					if loc_6 == loc_8 then
						desired = 1
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_6 = add_i32(loc_1, loc_9)
					if loc_1 <= loc_7 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[393](load_i32(memory_at_0.data, loc_0 + 4), loc_10)
			loc_1 = reg_0
			if load_i32(memory_at_0.data, loc_1) ~= 0 then
				break
			end
			store_i32(memory_at_0.data, loc_1, load_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_9, 3)) + 4))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		break
	end
end
FUNC_LIST[93] = --[[ Luau::Compile::ShapeVisitor::visit(Luau::AstStatFunction*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	local desired
	while true do
		loc_2 = load_i32(memory_at_0.data, loc_1 + 28)
		loc_3 = load_i32(memory_at_0.data, loc_2 + 4)
		while true do
			while true do
				if loc_2 == 0 then
					break
				end
				if loc_3 ~= load_i32(memory_at_0.data, 0 + 59920) then
					break
				end
				FUNC_LIST[91](loc_0, load_i32(memory_at_0.data, loc_2 + 24), load_i32(memory_at_0.data, add_i32(loc_2, 28)))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_2 == 0 then
				break
			end
			if loc_3 ~= load_i32(memory_at_0.data, 0 + 59928) then
				break
			end
			FUNC_LIST[92](loc_0, load_i32(memory_at_0.data, loc_2 + 24), load_i32(memory_at_0.data, add_i32(loc_2, 28)))
			break
		end
		loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[94] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 3)
					loc_12 = add_i32(loc_4, loc_11)
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 8))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 24))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 3))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_12 = add_i32(loc_3, 4294967295)
			loc_13 = load_i32(memory_at_0.data, loc_0)
			loc_6 = 0
			while true do
				while true do
					loc_9 = add_i32(loc_13, shl_i32(loc_6, 3))
					loc_11 = load_i32(memory_at_0.data, loc_9)
					if loc_11 == loc_5 then
						break
					end
					while true do
						while true do
							loc_5 = band_i32(bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9)), loc_12)
							loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
							loc_7 = load_i32(memory_at_0.data, loc_10)
							if loc_7 == loc_1 then
								break
							end
							loc_8 = 0
							if loc_7 == loc_11 then
								desired = 4
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_5 = band_i32(add_i32(loc_8, loc_5), loc_12)
								loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
								loc_7 = load_i32(memory_at_0.data, loc_10)
								if loc_7 == loc_1 then
									desired = 5
									break
								end
								if loc_7 == loc_11 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_10, loc_11)
						loc_11 = load_i32(memory_at_0.data, loc_9)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_10, loc_11)
					store_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 3)) + 4, load_i32(memory_at_0.data, loc_9 + 4))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_6 = add_i32(loc_6, 1)
				if loc_6 == loc_2 then
					desired = 1
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_5 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[95] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 3)
					loc_12 = add_i32(loc_4, loc_11)
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 8))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 24))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 3))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_12 = add_i32(loc_3, 4294967295)
			loc_13 = load_i32(memory_at_0.data, loc_0)
			loc_6 = 0
			while true do
				while true do
					loc_9 = add_i32(loc_13, shl_i32(loc_6, 3))
					loc_11 = load_i32(memory_at_0.data, loc_9)
					if loc_11 == loc_5 then
						break
					end
					while true do
						while true do
							loc_5 = band_i32(bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9)), loc_12)
							loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
							loc_7 = load_i32(memory_at_0.data, loc_10)
							if loc_7 == loc_1 then
								break
							end
							loc_8 = 0
							if loc_7 == loc_11 then
								desired = 4
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_5 = band_i32(add_i32(loc_8, loc_5), loc_12)
								loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
								loc_7 = load_i32(memory_at_0.data, loc_10)
								if loc_7 == loc_1 then
									desired = 5
									break
								end
								if loc_7 == loc_11 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_10, loc_11)
						loc_11 = load_i32(memory_at_0.data, loc_9)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_10, loc_11)
					store_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 3)) + 4, load_i32(memory_at_0.data, loc_9 + 4))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_6 = add_i32(loc_6, 1)
				if loc_6 == loc_2 then
					desired = 1
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_5 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[96] = --[[ Luau::DenseHashSet<std::__2::pair<Luau::AstExprTable*, Luau::AstName>, Luau::Compile::ShapeVisitor::Hasher, std::__2::equal_to<std::__2::pair<Luau::AstExprTable*, Luau::AstName> > >::insert(std::__2::pair<Luau::AstExprTable*, Luau::AstName> const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 16))
				loc_5 = load_i32(memory_at_0.data, loc_1 + 4)
				while true do
					loc_6 = load_i32(memory_at_0.data, loc_1)
					loc_7 = load_i32(memory_at_0.data, loc_0 + 12)
					if loc_6 ~= loc_7 then
						break
					end
					if loc_5 == loc_4 then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = bxor_i32(bxor_i32(bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9)), shr_u32(loc_5, 9)), shr_u32(loc_5, 4))
				loc_9 = add_i32(loc_3, 4294967295)
				loc_10 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_11 = band_i32(loc_8, loc_9)
					loc_8 = add_i32(loc_10, shl_i32(loc_11, 3))
					loc_12 = load_i32(memory_at_0.data, loc_8 + 4)
					while true do
						loc_8 = load_i32(memory_at_0.data, loc_8)
						if loc_8 ~= loc_6 then
							break
						end
						if loc_12 == loc_5 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if loc_8 ~= loc_7 then
							break
						end
						if loc_12 == loc_4 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_8 = add_i32(loc_2, loc_11)
					if loc_2 <= loc_9 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
			FUNC_LIST[97](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_6 = load_i32(memory_at_0.data, loc_1)
		loc_5 = load_i32(memory_at_0.data, loc_1 + 4)
		loc_8 = bxor_i32(bxor_i32(bxor_i32(shr_u32(loc_6, 4), shr_u32(loc_6, 9)), shr_u32(loc_5, 9)), shr_u32(loc_5, 4))
		loc_9 = add_i32(loc_3, 4294967295)
		loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 16))
		loc_10 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_7 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				loc_11 = band_i32(loc_8, loc_9)
				loc_8 = add_i32(loc_7, shl_i32(loc_11, 3))
				loc_12 = load_i32(memory_at_0.data, loc_8 + 4)
				while true do
					loc_3 = load_i32(memory_at_0.data, loc_8)
					if loc_3 ~= loc_10 then
						break
					end
					if loc_12 ~= loc_4 then
						break
					end
					store_i32(memory_at_0.data, loc_8, loc_6)
					store_i32(memory_at_0.data, add_i32(loc_7, shl_i32(loc_11, 3)) + 4, load_i32(memory_at_0.data, loc_1 + 4))
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					reg_0 = loc_8
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				while true do
					if loc_3 ~= loc_6 then
						break
					end
					if loc_12 == loc_5 then
						desired = 1
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_8 = add_i32(loc_2, loc_11)
				if loc_2 <= loc_9 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_8 = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		reg_0 = loc_8
		break
	end
	return reg_0
end
FUNC_LIST[97] = --[[ 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(loc_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 = i64_ZERO
	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 loc_17 = 0
	local loc_18 = 0
	local reg_0
	local desired
	while true do
		loc_1 = load_i32(memory_at_0.data, add_i32(loc_0, 16))
		loc_2 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_4 = (if loc_3 ~= 0 then shl_i32(loc_3, 1) else 16)
				if loc_4 ~= 0 then
					break
				end
				loc_5 = 0
				loc_6 = loc_1
				loc_7 = loc_2
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_8 = band_i32(loc_4, 6)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_4, 3))
			loc_5 = reg_0
			loc_9 = load_i64(memory_at_0.data, loc_0 + 12)
			loc_10 = shr_u64(loc_9, i64_from_u32(32, 0))
			loc_11 = 0
			loc_12 = 0
			while true do
				if add_i32(loc_4, 4294967295) < 7 then
					break
				end
				loc_13 = band_i32(loc_4, 4294967288)
				loc_12 = 0
				loc_6 = 0
				while true do
					loc_7 = shl_i32(loc_12, 3)
					store_i64(memory_at_0.data, add_i32(loc_5, loc_7), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 8)), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 16)), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 24)), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 32)), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 40)), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 48)), loc_9)
					store_i64(memory_at_0.data, add_i32(loc_5, bor_i32(loc_7, 56)), loc_9)
					loc_12 = add_i32(loc_12, 8)
					loc_6 = add_i32(loc_6, 8)
					if loc_6 ~= loc_13 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_6 = wrap_i32_i64(loc_10)
			loc_7 = wrap_i32_i64(loc_9)
			while true do
				if loc_8 == 0 then
					break
				end
				while true do
					store_i64(memory_at_0.data, add_i32(loc_5, shl_i32(loc_12, 3)), loc_9)
					loc_12 = add_i32(loc_12, 1)
					loc_11 = add_i32(loc_11, 1)
					if loc_11 ~= 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
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_3 == 0 then
				break
			end
			loc_14 = add_i32(loc_4, 4294967295)
			loc_15 = load_i32(memory_at_0.data, loc_0)
			loc_16 = 0
			while true do
				loc_17 = add_i32(loc_15, shl_i32(loc_16, 3))
				loc_18 = load_i32(memory_at_0.data, loc_17 + 4)
				while true do
					while true do
						loc_11 = load_i32(memory_at_0.data, loc_17)
						if loc_11 ~= loc_7 then
							break
						end
						if loc_18 == loc_6 then
							desired = 3
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_12 = band_i32(bxor_i32(bxor_i32(bxor_i32(shr_u32(loc_18, 4), shr_u32(loc_18, 9)), shr_u32(loc_11, 9)), shr_u32(loc_11, 4)), loc_14)
					loc_7 = add_i32(loc_5, shl_i32(loc_12, 3))
					loc_8 = load_i32(memory_at_0.data, loc_7 + 4)
					while true do
						while true do
							while true do
								loc_13 = load_i32(memory_at_0.data, loc_7)
								if loc_13 ~= loc_2 then
									break
								end
								if loc_8 == loc_1 then
									desired = 5
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_6 = 0
							while true do
								if loc_13 ~= loc_11 then
									break
								end
								if loc_8 == loc_18 then
									desired = 4
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								loc_6 = add_i32(loc_6, 1)
								loc_12 = band_i32(add_i32(loc_6, loc_12), loc_14)
								loc_7 = add_i32(loc_5, shl_i32(loc_12, 3))
								loc_8 = load_i32(memory_at_0.data, loc_7 + 4)
								while true do
									loc_13 = load_i32(memory_at_0.data, loc_7)
									if loc_13 ~= loc_2 then
										break
									end
									if loc_8 == loc_1 then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
										continue
									end
									break
								end
								if loc_13 ~= loc_11 then
									continue
								end
								if loc_8 == loc_18 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_7, loc_11)
						store_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_12, 3)) + 4, load_i32(memory_at_0.data, loc_17 + 4))
						loc_11 = load_i32(memory_at_0.data, loc_17)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_7, loc_11)
					store_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_12, 3)) + 4, load_i32(memory_at_0.data, loc_17 + 4))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_16 = add_i32(loc_16, 1)
				if loc_16 == loc_3 then
					desired = 1
					break
				end
				loc_6 = load_i32(memory_at_0.data, loc_0 + 16)
				loc_7 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_4)
		loc_7 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_5)
		while true do
			if loc_7 == 0 then
				break
			end
			FUNC_LIST[1463](loc_7)
			break
		end
		break
	end
end
FUNC_LIST[98] = --[[ Luau::buildTypeMap(Luau::DenseHashMap<Luau::AstExprFunction*, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprFunction*> >&, Luau::AstNode*, char const*) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_3
		store_i32(memory_at_0.data, add_i32(loc_3, 40), 0)
		store_i64(memory_at_0.data, add_i32(loc_3, 20), i64_ZERO)
		store_i64(memory_at_0.data, loc_3 + 32, i64_ZERO)
		store_i32(memory_at_0.data, loc_3 + 8, loc_2)
		store_i32(memory_at_0.data, loc_3 + 4, loc_0)
		store_i64(memory_at_0.data, loc_3 + 12, i64_ZERO)
		loc_0 = add_i32(14716, 8)
		store_i32(memory_at_0.data, loc_3, loc_0)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1))](loc_1, loc_3)
		store_i32(memory_at_0.data, loc_3, loc_0)
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_3 + 32)
			if loc_1 == 0 then
				break
			end
			store_i32(memory_at_0.data, loc_3 + 36, loc_1)
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_3 + 12)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 48)
		break
	end
end
FUNC_LIST[99] = --[[ Luau::TypeMapVisitor::~TypeMapVisitor() ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(14716, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 32)
			if loc_1 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 36), loc_1)
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 12)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 12, i64_ZERO)
			break
		end
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[100] = --[[ Luau::TypeMapVisitor::~TypeMapVisitor().1 ]] function(loc_0)
	local loc_1 = 0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(14716, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 32)
			if loc_1 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 36), loc_1)
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 12)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[101] = --[[ Luau::TypeMapVisitor::visit(Luau::AstExprFunction*) ]] function(loc_0, loc_1)
	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_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		store_i32(memory_at_0.data, loc_2 + 12, loc_1)
		loc_3 = load_i32(memory_at_0.data, loc_0 + 8)
		loc_4 = load_i32(memory_at_0.data, loc_1 + 40)
		store_i32(memory_at_0.data, add_i32(loc_2, 24), 0)
		store_i64(memory_at_0.data, loc_2 + 16, i64_ZERO)
		loc_5 = add_i32(loc_1, 48)
		FUNC_LIST[1538](add_i32(loc_2, 16), add_i32(load_i32(memory_at_0.data, loc_5), (if loc_4 ~= 0 then 3 else 2)))
		FUNC_LIST[1547](add_i32(loc_2, 16), 5)
		FUNC_LIST[1547](add_i32(loc_2, 16), shr_i32(shl_i32(add_i32(load_i32(memory_at_0.data, loc_5), (if loc_4 ~= 0 then 1 else 0)), 24), 24))
		while true do
			if loc_4 == 0 then
				break
			end
			FUNC_LIST[1547](add_i32(loc_2, 16), 4)
			break
		end
		while true do
			while true do
				loc_5 = load_i32(memory_at_0.data, loc_1 + 48)
				if loc_5 == 0 then
					break
				end
				loc_6 = add_i32(loc_0, 12)
				loc_4 = load_i32(memory_at_0.data, loc_1 + 44)
				loc_5 = add_i32(loc_4, shl_i32(loc_5, 2))
				loc_7 = add_i32(loc_1, 24)
				loc_8 = 0
				while true do
					while true do
						while true do
							while true do
								loc_1 = load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_4) + 32)
								if loc_1 == 0 then
									break
								end
								reg_0 = FUNC_LIST[102](loc_1, loc_7, loc_6, 1, loc_3)
								loc_1 = reg_0
								if loc_1 ~= 15 then
									desired = 5
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							FUNC_LIST[1547](add_i32(loc_2, 16), 15)
							loc_4 = add_i32(loc_4, 4)
							if loc_4 ~= loc_5 then
								desired = 4
								break
							end
							if band_i32(loc_8, 1) ~= 0 then
								desired = 3
								break
							end
							desired = 2
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						FUNC_LIST[1547](add_i32(loc_2, 16), shr_i32(shl_i32(loc_1, 24), 24))
						loc_8 = 1
						loc_4 = add_i32(loc_4, 4)
						if loc_4 ~= loc_5 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
				store_i32_n16(memory_at_0.data, loc_2 + 8, load_i32_u16(memory_at_0.data, loc_2 + 24))
				store_i32_n8(memory_at_0.data, loc_2 + 10, load_i32_u8(memory_at_0.data, add_i32(loc_2, 26)))
				loc_5 = load_i32(memory_at_0.data, loc_2 + 16)
				while true do
					loc_3 = load_i32(memory_at_0.data, loc_2 + 20)
					loc_1 = load_i32_i8(memory_at_0.data, loc_2 + 27)
					if (if lt_i32(loc_1, 0) then loc_3 else band_i32(loc_1, 255)) == 0 then
						break
					end
					while true do
						reg_0 = FUNC_LIST[103](load_i32(memory_at_0.data, loc_0 + 4), add_i32(loc_2, 12))
						loc_4 = reg_0
						if gt_i32(load_i32_i8(memory_at_0.data, loc_4 + 11), 4294967295) then
							break
						end
						FUNC_LIST[1463](load_i32(memory_at_0.data, loc_4))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_4 + 4, loc_3)
					store_i32(memory_at_0.data, loc_4, loc_5)
					store_i32_n16(memory_at_0.data, loc_4 + 8, load_i32_u16(memory_at_0.data, loc_2 + 8))
					store_i32_n8(memory_at_0.data, add_i32(loc_4, 10), load_i32_u8(memory_at_0.data, loc_2 + 10))
					store_i32_n8(memory_at_0.data, loc_4 + 11, loc_1)
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if gt_i32(loc_1, 4294967295) then
					desired = 1
					break
				end
				FUNC_LIST[1463](loc_5)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if gt_i32(load_i32_i8(memory_at_0.data, loc_2 + 27), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_2 + 16))
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[102] = --[[ Luau::getType(Luau::AstType*, Luau::AstArray<Luau::AstGenericType> const&, Luau::DenseHashMap<Luau::AstName, Luau::AstStatTypeAlias*, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> > const&, bool, char const*) ]] function(loc_0, loc_1, loc_2, loc_3, loc_4)
	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_5 = load_i32(memory_at_0.data, loc_0 + 4)
		while true do
			while true do
				while true do
					if loc_0 == 0 then
						break
					end
					loc_6 = load_i32(memory_at_0.data, 0 + 60144)
					if loc_5 ~= loc_6 then
						break
					end
					loc_7 = bxor_i32(loc_3, 1)
					loc_8 = add_i32(load_i32(memory_at_0.data, loc_2 + 4), 4294967295)
					loc_9 = load_i32(memory_at_0.data, loc_2)
					loc_10 = load_i32(memory_at_0.data, loc_2 + 12)
					loc_11 = load_i32(memory_at_0.data, loc_2 + 8)
					loc_12 = loc_1
					loc_13 = loc_0
					while true do
						while true do
							loc_14 = 15
							if load_i32_u8(memory_at_0.data, add_i32(loc_13, 32)) ~= 0 then
								desired = 1
								break
							end
							while true do
								if loc_11 ~= 0 then
									break
								end
								loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 56))
								loc_12 = loc_1
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							while true do
								loc_3 = load_i32(memory_at_0.data, loc_13 + 56)
								if loc_3 ~= loc_10 then
									break
								end
								loc_3 = loc_10
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_15 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
							loc_5 = 0
							while true do
								while true do
									loc_16 = band_i32(loc_15, loc_8)
									loc_17 = add_i32(loc_9, shl_i32(loc_16, 3))
									loc_15 = load_i32(memory_at_0.data, loc_17)
									if loc_15 == loc_3 then
										desired = 6
										break
									end
									if loc_15 == loc_10 then
										desired = 4
										break
									end
									loc_5 = add_i32(loc_5, 1)
									loc_15 = add_i32(loc_5, loc_16)
									if loc_5 <= loc_8 then
										continue
									end
									desired = 4
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							while true do
								loc_5 = load_i32(memory_at_0.data, loc_17 + 4)
								if band_i32(bor_i32((if loc_5 == 0 then 1 else 0), loc_7), 1) ~= 0 then
									break
								end
								loc_12 = add_i32(loc_5, 48)
								loc_13 = load_i32(memory_at_0.data, loc_5 + 64)
								loc_5 = load_i32(memory_at_0.data, loc_13 + 4)
								loc_3 = 0
								if loc_13 == 0 then
									desired = 2
									break
								end
								loc_7 = 1
								if loc_5 == loc_6 then
									desired = 5
									break
								end
								desired = 2
								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_5 ~= 0 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						loc_15 = load_i32(memory_at_0.data, loc_12 + 4)
						if loc_15 == 0 then
							break
						end
						loc_5 = load_i32(memory_at_0.data, loc_12)
						loc_15 = add_i32(loc_5, mul_i32(loc_15, 24))
						while true do
							if load_i32(memory_at_0.data, loc_5) == loc_3 then
								desired = 1
								break
							end
							loc_5 = add_i32(loc_5, 24)
							if loc_5 ~= loc_15 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
					while true do
						if loc_4 == 0 then
							break
						end
						loc_5 = load_i32(memory_at_0.data, loc_13 + 56)
						if loc_5 == 0 then
							break
						end
						reg_0 = FUNC_LIST[1379](loc_5, loc_4)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 8
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_14 = 7
					if loc_3 == 0 then
						desired = 1
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 5293)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 0
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 5111)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 1
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 4207)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 2
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 5916)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 3
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 8827)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 6
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if load_i32_u8(memory_at_0.data, 0 + 59836) == 0 then
							break
						end
						reg_0 = FUNC_LIST[1379](loc_3, 4152)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = 9
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						reg_0 = FUNC_LIST[1379](loc_3, 1230)
						if reg_0 == 0 then
							break
						end
						reg_0 = FUNC_LIST[1379](loc_3, 4517)
						if reg_0 ~= 0 then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					reg_0 = 15
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_13 = loc_0
				loc_12 = loc_1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_14 = 4
			if loc_5 == load_i32(memory_at_0.data, 0 + 60152) then
				break
			end
			loc_14 = 5
			if loc_5 == load_i32(memory_at_0.data, 0 + 60160) then
				break
			end
			loc_14 = 15
			if loc_5 ~= load_i32(memory_at_0.data, 0 + 60176) then
				break
			end
			loc_15 = load_i32(memory_at_0.data, add_i32(loc_13, 28))
			if loc_15 == 0 then
				break
			end
			loc_5 = load_i32(memory_at_0.data, loc_13 + 24)
			loc_16 = add_i32(loc_5, shl_i32(loc_15, 2))
			loc_8 = 256
			loc_10 = 0
			while true do
				while true do
					while true do
						reg_0 = FUNC_LIST[102](load_i32(memory_at_0.data, loc_5), loc_12, loc_2, loc_3, loc_4)
						loc_15 = reg_0
						if loc_15 ~= 0 then
							break
						end
						loc_10 = 1
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_8 ~= 256 then
							break
						end
						loc_8 = loc_15
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_8 ~= loc_15 then
						desired = 1
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_5 = add_i32(loc_5, 4)
				if loc_5 ~= loc_16 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_8 == 256 then
				break
			end
			loc_14 = bor_i32((if band_i32(loc_10, 1) ~= 0 then shl_i32((if loc_8 ~= 15 then 1 else 0), 7) else 0), loc_8)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		reg_0 = loc_14
		break
	end
	return reg_0
end
FUNC_LIST[103] = --[[ Luau::DenseHashMap<Luau::AstExprFunction*, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprFunction*> >::operator[](Luau::AstExprFunction* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 4)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[108](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 4))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[104] = --[[ Luau::TypeMapVisitor::visit(Luau::AstStatBlock*) ]] function(loc_0, loc_1)
	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
	while true do
		reg_0 = FUNC_LIST[105](loc_0, loc_1)
		loc_2 = reg_0
		while true do
			loc_3 = load_i32(memory_at_0.data, add_i32(loc_1, 32))
			if loc_3 == 0 then
				break
			end
			loc_4 = band_i32(add_i32(loc_3, 4294967295), 1073741823)
			loc_5 = load_i32(memory_at_0.data, loc_1 + 28)
			loc_1 = loc_5
			while true do
				loc_6 = band_i32(loc_3, 3)
				if loc_6 == 0 then
					break
				end
				loc_7 = 0
				loc_1 = loc_5
				while true do
					loc_8 = load_i32(memory_at_0.data, loc_1)
					TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, loc_0)
					loc_1 = add_i32(loc_1, 4)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 then
						continue
					end
					break
				end
				break
			end
			if loc_4 <= 2 then
				break
			end
			loc_8 = add_i32(loc_5, shl_i32(loc_3, 2))
			while true do
				loc_7 = load_i32(memory_at_0.data, loc_1)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_7))](loc_7, loc_0)
				loc_7 = load_i32(memory_at_0.data, loc_1 + 4)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_7))](loc_7, loc_0)
				loc_7 = load_i32(memory_at_0.data, loc_1 + 8)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_7))](loc_7, loc_0)
				loc_7 = load_i32(memory_at_0.data, loc_1 + 12)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_7))](loc_7, loc_0)
				loc_1 = add_i32(loc_1, 16)
				if loc_1 ~= loc_8 then
					continue
				end
				break
			end
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
			if shr_i32(sub_i32(loc_1, load_i32(memory_at_0.data, loc_0 + 32)), 3) <= loc_2 then
				break
			end
			loc_8 = add_i32(loc_0, 12)
			while true do
				loc_7 = load_i32(memory_at_0.data, add_i32(loc_1, 4294967292))
				reg_0 = FUNC_LIST[106](loc_8, add_i32(loc_1, 4294967288))
				store_i32(memory_at_0.data, reg_0, loc_7)
				loc_1 = add_i32(load_i32(memory_at_0.data, loc_0 + 36), 4294967288)
				store_i32(memory_at_0.data, loc_0 + 36, loc_1)
				if shr_i32(sub_i32(loc_1, load_i32(memory_at_0.data, loc_0 + 32)), 3) > loc_2 then
					continue
				end
				break
			end
			break
		end
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[105] = --[[ Luau::TypeMapVisitor::pushTypeAliases(Luau::AstStatBlock*) ]] function(loc_0, loc_1)
	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
	while true do
		loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
		loc_3 = load_i32(memory_at_0.data, loc_0 + 32)
		while true do
			while true do
				while true do
					loc_4 = load_i32(memory_at_0.data, add_i32(loc_1, 32))
					if loc_4 == 0 then
						break
					end
					loc_5 = add_i32(loc_0, 32)
					loc_1 = load_i32(memory_at_0.data, loc_1 + 28)
					loc_6 = add_i32(loc_1, shl_i32(loc_4, 2))
					loc_7 = add_i32(loc_0, 12)
					while true do
						while true do
							loc_4 = load_i32(memory_at_0.data, loc_1)
							if load_i32(memory_at_0.data, loc_4 + 4) ~= load_i32(memory_at_0.data, 0 + 60112) then
								break
							end
							if loc_4 == 0 then
								break
							end
							loc_8 = add_i32(loc_4, 28)
							reg_0 = FUNC_LIST[106](loc_7, loc_8)
							loc_9 = reg_0
							loc_10 = load_i32(memory_at_0.data, loc_9)
							loc_11 = load_i32(memory_at_0.data, loc_8)
							while true do
								while true do
									loc_8 = load_i32(memory_at_0.data, loc_0 + 36)
									loc_12 = load_i32(memory_at_0.data, loc_0 + 40)
									if loc_8 >= loc_12 then
										break
									end
									store_i32(memory_at_0.data, loc_8 + 4, loc_10)
									store_i32(memory_at_0.data, loc_8, loc_11)
									store_i32(memory_at_0.data, loc_0 + 36, add_i32(loc_8, 8))
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_13 = load_i32(memory_at_0.data, loc_5)
								loc_14 = sub_i32(loc_8, loc_13)
								loc_15 = shr_i32(loc_14, 3)
								loc_8 = add_i32(loc_15, 1)
								if loc_8 >= 536870912 then
									desired = 2
									break
								end
								loc_12 = sub_i32(loc_12, loc_13)
								loc_16 = shr_i32(loc_12, 2)
								loc_8 = (if loc_12 < 2147483640 then (if loc_16 < loc_8 then loc_8 else loc_16) else 536870911)
								if loc_8 >= 536870912 then
									desired = 1
									break
								end
								loc_16 = shl_i32(loc_8, 3)
								reg_0 = FUNC_LIST[1461](loc_16)
								loc_8 = reg_0
								loc_12 = add_i32(loc_8, shl_i32(loc_15, 3))
								store_i32(memory_at_0.data, loc_12 + 4, loc_10)
								store_i32(memory_at_0.data, loc_12, loc_11)
								loc_10 = add_i32(loc_8, loc_16)
								loc_11 = add_i32(loc_12, 8)
								while true do
									if lt_i32(loc_14, 1) then
										break
									end
									reg_0 = FUNC_LIST[1224](loc_8, loc_13, loc_14)
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								store_i32(memory_at_0.data, loc_0 + 40, loc_10)
								store_i32(memory_at_0.data, loc_0 + 36, loc_11)
								store_i32(memory_at_0.data, loc_0 + 32, loc_8)
								if loc_13 == 0 then
									break
								end
								FUNC_LIST[1463](loc_13)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_9, loc_4)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_1 = add_i32(loc_1, 4)
						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
					end
					break
				end
				reg_0 = shr_i32(sub_i32(loc_2, loc_3), 3)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[109](loc_5)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[106] = --[[ Luau::DenseHashMap<Luau::AstName, Luau::AstStatTypeAlias*, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> >::operator[](Luau::AstName const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 3)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[110](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 3))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[107] = --[[ Luau::TypeMapVisitor::visit(Luau::AstStatRepeat*) ]] function(loc_0, loc_1)
	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
	while true do
		reg_0 = FUNC_LIST[105](loc_0, load_i32(memory_at_0.data, loc_1 + 32))
		loc_2 = reg_0
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_1 + 32)
			loc_4 = load_i32(memory_at_0.data, add_i32(loc_3, 32))
			if loc_4 == 0 then
				break
			end
			loc_5 = band_i32(add_i32(loc_4, 4294967295), 1073741823)
			loc_6 = load_i32(memory_at_0.data, loc_3 + 28)
			loc_3 = loc_6
			while true do
				loc_7 = band_i32(loc_4, 3)
				if loc_7 == 0 then
					break
				end
				loc_8 = 0
				loc_3 = loc_6
				while true do
					loc_9 = load_i32(memory_at_0.data, loc_3)
					TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_9))](loc_9, loc_0)
					loc_3 = add_i32(loc_3, 4)
					loc_8 = add_i32(loc_8, 1)
					if loc_8 ~= loc_7 then
						continue
					end
					break
				end
				break
			end
			if loc_5 <= 2 then
				break
			end
			loc_9 = add_i32(loc_6, shl_i32(loc_4, 2))
			while true do
				loc_8 = load_i32(memory_at_0.data, loc_3)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, loc_0)
				loc_8 = load_i32(memory_at_0.data, loc_3 + 4)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, loc_0)
				loc_8 = load_i32(memory_at_0.data, loc_3 + 8)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, loc_0)
				loc_8 = load_i32(memory_at_0.data, loc_3 + 12)
				TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, loc_0)
				loc_3 = add_i32(loc_3, 16)
				if loc_3 ~= loc_9 then
					continue
				end
				break
			end
			break
		end
		loc_3 = load_i32(memory_at_0.data, loc_1 + 28)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_3))](loc_3, loc_0)
		while true do
			loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
			if shr_i32(sub_i32(loc_3, load_i32(memory_at_0.data, loc_0 + 32)), 3) <= loc_2 then
				break
			end
			loc_9 = add_i32(loc_0, 12)
			while true do
				loc_8 = load_i32(memory_at_0.data, add_i32(loc_3, 4294967292))
				reg_0 = FUNC_LIST[106](loc_9, add_i32(loc_3, 4294967288))
				store_i32(memory_at_0.data, reg_0, loc_8)
				loc_3 = add_i32(load_i32(memory_at_0.data, loc_0 + 36), 4294967288)
				store_i32(memory_at_0.data, loc_0 + 36, loc_3)
				if shr_i32(sub_i32(loc_3, load_i32(memory_at_0.data, loc_0 + 32)), 3) > loc_2 then
					continue
				end
				break
			end
			break
		end
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[108] = --[[ Luau::detail::DenseHashTable<Luau::AstExprFunction*, std::__2::pair<Luau::AstExprFunction*, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > >, std::__2::pair<Luau::AstExprFunction* const, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > >, Luau::detail::ItemInterfaceMap<Luau::AstExprFunction*, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > >, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprFunction*> >::rehash() ]] function(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 4))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_2 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_8 = band_i32(loc_3, 4294967292)
				loc_2 = 0
				loc_9 = 0
				while true do
					loc_10 = shl_i32(loc_2, 4)
					loc_11 = add_i32(loc_4, loc_10)
					store_i64(memory_at_0.data, loc_11 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_11, loc_5)
					store_i32(memory_at_0.data, add_i32(loc_11, 12), 0)
					loc_11 = add_i32(loc_4, bor_i32(loc_10, 16))
					store_i64(memory_at_0.data, loc_11 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_11, loc_5)
					store_i32(memory_at_0.data, add_i32(loc_11, 12), 0)
					loc_11 = add_i32(loc_4, bor_i32(loc_10, 32))
					store_i64(memory_at_0.data, loc_11 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_11, loc_5)
					store_i32(memory_at_0.data, add_i32(loc_11, 12), 0)
					loc_10 = add_i32(loc_4, bor_i32(loc_10, 48))
					store_i64(memory_at_0.data, loc_10 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i32(memory_at_0.data, add_i32(loc_10, 12), 0)
					loc_2 = add_i32(loc_2, 4)
					loc_9 = add_i32(loc_9, 4)
					if loc_9 ~= 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_10 = add_i32(loc_4, shl_i32(loc_2, 4))
					store_i64(memory_at_0.data, loc_10 + 4, i64_ZERO)
					store_i32(memory_at_0.data, loc_10, loc_5)
					store_i32(memory_at_0.data, add_i32(loc_10, 12), 0)
					loc_2 = add_i32(loc_2, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			while true do
				while true do
					if loc_2 == 0 then
						break
					end
					loc_10 = add_i32(loc_3, 4294967295)
					loc_6 = 0
					while true do
						while true do
							loc_8 = add_i32(load_i32(memory_at_0.data, loc_0), shl_i32(loc_6, 4))
							loc_7 = load_i32(memory_at_0.data, loc_8)
							if loc_7 == loc_5 then
								break
							end
							loc_2 = bxor_i32(shr_u32(loc_7, 4), shr_u32(loc_7, 9))
							loc_5 = 0
							while true do
								while true do
									while true do
										loc_11 = band_i32(loc_2, loc_10)
										loc_9 = add_i32(loc_4, shl_i32(loc_11, 4))
										loc_2 = load_i32(memory_at_0.data, loc_9)
										if loc_2 ~= loc_1 then
											break
										end
										store_i32(memory_at_0.data, loc_9, loc_7)
										loc_7 = load_i32(memory_at_0.data, loc_8)
										desired = 6
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									if loc_2 == loc_7 then
										desired = 6
										break
									end
									loc_5 = add_i32(loc_5, 1)
									loc_2 = add_i32(loc_5, loc_11)
									if loc_5 <= loc_10 then
										continue
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_9 = 0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_9, loc_7)
							loc_2 = add_i32(loc_9, 4)
							loc_5 = add_i32(loc_8, 4)
							while true do
								if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_9, 15)), 4294967295) then
									break
								end
								FUNC_LIST[1463](load_i32(memory_at_0.data, loc_2))
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_5))
							store_i32(memory_at_0.data, add_i32(loc_2, 8), load_i32(memory_at_0.data, add_i32(loc_5, 8)))
							store_i32_n8(memory_at_0.data, loc_5 + 11, 0)
							store_i32_n8(memory_at_0.data, loc_5, 0)
							loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						while true do
							loc_6 = add_i32(loc_6, 1)
							if loc_6 >= loc_2 then
								break
							end
							loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 4, loc_3)
					loc_11 = load_i32(memory_at_0.data, loc_0)
					store_i32(memory_at_0.data, loc_0, loc_4)
					if loc_11 == 0 then
						desired = 1
						break
					end
					if loc_2 == 0 then
						desired = 2
						break
					end
					loc_5 = 0
					while true do
						while true do
							loc_10 = add_i32(loc_11, shl_i32(loc_5, 4))
							if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_10, 15)), 4294967295) then
								break
							end
							FUNC_LIST[1463](load_i32(memory_at_0.data, add_i32(loc_10, 4)))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_5 = add_i32(loc_5, 1)
						if loc_5 ~= loc_2 then
							continue
						end
						desired = 2
						break
					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
				store_i32(memory_at_0.data, loc_0 + 4, loc_3)
				loc_11 = load_i32(memory_at_0.data, loc_0)
				store_i32(memory_at_0.data, loc_0, loc_4)
				if loc_11 == 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1463](loc_11)
			break
		end
		break
	end
end
FUNC_LIST[109] = --[[ std::__2::vector<std::__2::pair<Luau::AstName, Luau::AstStatTypeAlias*>, std::__2::allocator<std::__2::pair<Luau::AstName, Luau::AstStatTypeAlias*> > >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[110] = --[[ Luau::detail::DenseHashTable<Luau::AstName, std::__2::pair<Luau::AstName, Luau::AstStatTypeAlias*>, std::__2::pair<Luau::AstName const, Luau::AstStatTypeAlias*>, Luau::detail::ItemInterfaceMap<Luau::AstName, Luau::AstStatTypeAlias*>, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName> >::rehash() ]] function(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 3)
					loc_12 = add_i32(loc_4, loc_11)
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 8))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i32(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 24))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 3))
					store_i32(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_12 = add_i32(loc_3, 4294967295)
			loc_13 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_14 = load_i32(memory_at_0.data, loc_0)
			loc_6 = 0
			while true do
				while true do
					loc_9 = add_i32(loc_14, shl_i32(loc_6, 3))
					loc_11 = load_i32(memory_at_0.data, loc_9)
					if loc_11 == loc_5 then
						break
					end
					while true do
						while true do
							loc_5 = band_i32(bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9)), loc_12)
							loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
							loc_7 = load_i32(memory_at_0.data, loc_10)
							if loc_7 == loc_1 then
								break
							end
							loc_8 = 0
							if loc_7 == loc_11 then
								desired = 4
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_5 = band_i32(add_i32(loc_8, loc_5), loc_12)
								loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
								loc_7 = load_i32(memory_at_0.data, loc_10)
								if loc_7 == loc_1 then
									desired = 5
									break
								end
								if loc_7 == loc_11 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_10, loc_11)
						loc_11 = load_i32(memory_at_0.data, loc_9)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_10, loc_11)
					store_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 3)) + 4, load_i32(memory_at_0.data, loc_9 + 4))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_5 = loc_13
				loc_6 = add_i32(loc_6, 1)
				if loc_6 ~= loc_2 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_5 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[111] = --[[ _GLOBAL__sub_I_Types.cpp ]] function()
	local loc_0 = 0
	while true do
		store_i32(memory_at_0.data, 59836 + 4, 4820)
		loc_0 = load_i32(memory_at_0.data, 0 + 59792)
		store_i32(memory_at_0.data, 0 + 59792, 59836)
		store_i32(memory_at_0.data, 59836 + 8, loc_0)
		store_i32_n16(memory_at_0.data, 0 + 59836, 0)
		break
	end
end
FUNC_LIST[112] = --[[ Luau::BytecodeBuilder::BytecodeBuilder(Luau::BytecodeEncoder*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local reg_0
	local reg_1
	while true do
		store_i64(memory_at_0.data, loc_0 + 96, i64_ZERO)
		store_i32(memory_at_0.data, loc_0 + 16, 4294967295)
		store_i64(memory_at_0.data, loc_0 + 8, i64_from_u32(0, 4294967295))
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_0, 112), 0)
		store_i32(memory_at_0.data, add_i32(loc_0, 104), 0)
		reg_0 = FUNC_LIST[1286](add_i32(loc_0, 20), 0, 73)
		store_i64(memory_at_0.data, add_i32(loc_0, 120), i64_from_u32(4294967295, 4294967295))
		reg_0 = FUNC_LIST[1286](add_i32(loc_0, 136), 0, 144)
		store_i64(memory_at_0.data, loc_0 + 304, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 292), i64_from_u32(0, 4294967295))
		store_i64(memory_at_0.data, loc_0 + 284, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 312), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 320), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 328), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 336), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 344), i64_ZERO)
		store_i64(memory_at_0.data, loc_0 + 356, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 364), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 372), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 380), i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_0, 388), 0)
		store_i64(memory_at_0.data, loc_0 + 396, i64_ZERO)
		store_i32(memory_at_0.data, loc_0 + 392, loc_1)
		store_i64(memory_at_0.data, add_i32(loc_0, 404), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 412), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 420), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 428), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_0, 436), i64_ZERO)
		reg_1 = FUNC_LIST[1461](128)
		loc_1 = reg_1
		store_i32(memory_at_0.data, add_i32(loc_0, 24), loc_1)
		store_i32(memory_at_0.data, loc_0 + 20, loc_1)
		store_i32(memory_at_0.data, add_i32(loc_0, 28), add_i32(loc_1, 128))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 32)
			if sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 40)), loc_1) > 127 then
				break
			end
			loc_2 = load_i32(memory_at_0.data, loc_0 + 36)
			reg_0 = FUNC_LIST[1461](128)
			loc_3 = reg_0
			loc_4 = add_i32(loc_3, 128)
			loc_2 = sub_i32(loc_2, loc_1)
			loc_5 = add_i32(loc_3, loc_2)
			while true do
				if lt_i32(loc_2, 1) then
					break
				end
				reg_0 = FUNC_LIST[1224](loc_3, loc_1, loc_2)
				break
			end
			store_i32(memory_at_0.data, loc_0 + 40, loc_4)
			store_i32(memory_at_0.data, loc_0 + 36, loc_5)
			store_i32(memory_at_0.data, loc_0 + 32, loc_3)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 44)
			if sub_i32(load_i32(memory_at_0.data, loc_0 + 52), loc_1) > 255 then
				break
			end
			loc_2 = load_i32(memory_at_0.data, loc_0 + 48)
			reg_0 = FUNC_LIST[1461](256)
			loc_3 = reg_0
			loc_4 = add_i32(loc_3, 256)
			loc_2 = sub_i32(loc_2, loc_1)
			loc_5 = add_i32(loc_3, loc_2)
			while true do
				if lt_i32(loc_2, 1) then
					break
				end
				reg_0 = FUNC_LIST[1224](loc_3, loc_1, loc_2)
				break
			end
			store_i32(memory_at_0.data, loc_0 + 52, loc_4)
			store_i32(memory_at_0.data, loc_0 + 48, loc_5)
			store_i32(memory_at_0.data, loc_0 + 44, loc_3)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 56)
			if sub_i32(load_i32(memory_at_0.data, loc_0 + 64), loc_1) > 63 then
				break
			end
			loc_2 = load_i32(memory_at_0.data, loc_0 + 60)
			reg_0 = FUNC_LIST[1461](64)
			loc_3 = reg_0
			loc_4 = add_i32(loc_3, 64)
			loc_2 = sub_i32(loc_2, loc_1)
			loc_5 = add_i32(loc_3, loc_2)
			while true do
				if lt_i32(loc_2, 1) then
					break
				end
				reg_0 = FUNC_LIST[1224](loc_3, loc_1, loc_2)
				break
			end
			store_i32(memory_at_0.data, loc_0 + 64, loc_4)
			store_i32(memory_at_0.data, loc_0 + 60, loc_5)
			store_i32(memory_at_0.data, loc_0 + 56, loc_3)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		FUNC_LIST[113](loc_0, 8)
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[113] = --[[ std::__2::vector<Luau::BytecodeBuilder::Function, std::__2::allocator<Luau::BytecodeBuilder::Function> >::reserve(unsigned long) ]] function(loc_0, loc_1)
	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
			loc_2 = load_i32(memory_at_0.data, loc_0)
			if div_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 8), loc_2), 72) >= loc_1 then
				break
			end
			while true do
				while true do
					while true do
						if loc_1 >= 59652324 then
							break
						end
						loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
						loc_1 = mul_i32(loc_1, 72)
						reg_0 = FUNC_LIST[1461](loc_1)
						loc_4 = reg_0
						loc_5 = add_i32(loc_4, loc_1)
						loc_6 = add_i32(loc_4, mul_i32(div_i32(sub_i32(loc_3, loc_2), 72), 72))
						if loc_3 == loc_2 then
							desired = 3
							break
						end
						loc_7 = add_i32(loc_0, 8)
						loc_1 = loc_6
						while true do
							loc_1 = add_i32(loc_1, 4294967224)
							loc_3 = add_i32(loc_3, 4294967224)
							store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_3))
							loc_4 = add_i32(loc_3, 8)
							store_i32(memory_at_0.data, add_i32(loc_1, 8), load_i32(memory_at_0.data, loc_4))
							store_i64(memory_at_0.data, loc_3, i64_ZERO)
							store_i32(memory_at_0.data, loc_4, 0)
							store_i32(memory_at_0.data, add_i32(loc_1, 20), load_i32(memory_at_0.data, add_i32(loc_3, 20)))
							store_i64(memory_at_0.data, loc_1 + 12, load_i64(memory_at_0.data, loc_3 + 12))
							loc_4 = add_i32(loc_3, 32)
							store_i32(memory_at_0.data, add_i32(loc_1, 32), load_i32(memory_at_0.data, loc_4))
							store_i64(memory_at_0.data, loc_1 + 24, load_i64(memory_at_0.data, loc_3 + 24))
							store_i32(memory_at_0.data, loc_4, 0)
							store_i64(memory_at_0.data, loc_3 + 24, i64_ZERO)
							loc_4 = add_i32(loc_3, 44)
							store_i32(memory_at_0.data, add_i32(loc_1, 44), load_i32(memory_at_0.data, loc_4))
							store_i64(memory_at_0.data, loc_1 + 36, load_i64(memory_at_0.data, loc_3 + 36))
							store_i64(memory_at_0.data, loc_3 + 36, i64_ZERO)
							store_i32(memory_at_0.data, loc_4, 0)
							store_i32(memory_at_0.data, loc_1 + 48, load_i32(memory_at_0.data, loc_3 + 48))
							store_i32(memory_at_0.data, add_i32(loc_1, 52), load_i32(memory_at_0.data, add_i32(loc_3, 52)))
							loc_4 = add_i32(loc_3, 56)
							store_i32(memory_at_0.data, add_i32(loc_1, 56), load_i32(memory_at_0.data, loc_4))
							store_i32(memory_at_0.data, loc_4, 0)
							store_i64(memory_at_0.data, loc_3 + 48, i64_ZERO)
							loc_4 = add_i32(loc_3, 68)
							store_i32(memory_at_0.data, add_i32(loc_1, 68), load_i32(memory_at_0.data, loc_4))
							store_i64(memory_at_0.data, loc_1 + 60, load_i64(memory_at_0.data, loc_3 + 60))
							store_i64(memory_at_0.data, loc_3 + 60, i64_ZERO)
							store_i32(memory_at_0.data, loc_4, 0)
							if loc_3 ~= loc_2 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 8, loc_5)
						loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
						store_i32(memory_at_0.data, loc_0 + 4, loc_6)
						loc_2 = load_i32(memory_at_0.data, loc_0)
						store_i32(memory_at_0.data, loc_0, loc_1)
						if loc_3 == loc_2 then
							desired = 2
							break
						end
						while true do
							loc_3 = add_i32(loc_3, 4294967224)
							FUNC_LIST[274](loc_7, loc_3)
							if loc_3 ~= loc_2 then
								continue
							end
							desired = 2
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[114](loc_0)
					error("out of code bounds")
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, loc_5)
				store_i32(memory_at_0.data, loc_0 + 4, loc_6)
				store_i32(memory_at_0.data, loc_0, loc_6)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			break
		end
		break
	end
end
FUNC_LIST[114] = --[[ std::__2::vector<Luau::BytecodeBuilder::Function, std::__2::allocator<Luau::BytecodeBuilder::Function> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[115] = --[[ Luau::BytecodeBuilder::beginFunction(unsigned char, bool) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local reg_0
	local reg_1
	local desired
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_3
		loc_4 = load_i32(memory_at_0.data, loc_0)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 4)
		reg_0 = FUNC_LIST[1286](add_i32(loc_3, 8), 0, 72)
		store_i32_n8(memory_at_0.data, loc_3 + 23, loc_2)
		store_i32_n8(memory_at_0.data, loc_3 + 21, loc_1)
		loc_1 = div_i32(sub_i32(loc_5, loc_4), 72)
		while true do
			while true do
				if loc_5 == load_i32(memory_at_0.data, loc_0 + 8) then
					break
				end
				reg_1 = FUNC_LIST[116](loc_5, add_i32(loc_3, 8))
				store_i32(memory_at_0.data, loc_0 + 4, add_i32(reg_1, 72))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[117](loc_0, add_i32(loc_3, 8))
			break
		end
		store_i32(memory_at_0.data, loc_0 + 304, 0)
		store_i32_n8(memory_at_0.data, loc_0 + 92, 0)
		store_i32(memory_at_0.data, loc_0 + 12, loc_1)
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_3, 79)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_3 + 68))
			break
		end
		while true do
			loc_0 = load_i32(memory_at_0.data, loc_3 + 56)
			if loc_0 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_3, 60), loc_0)
			FUNC_LIST[1463](loc_0)
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_3, 55)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_3 + 44))
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_3, 43)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_3 + 32))
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, loc_3 + 19), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_3 + 8))
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 80)
		reg_0 = loc_1
		break
	end
	return reg_0
end
FUNC_LIST[116] = --[[ Luau::BytecodeBuilder::Function::Function(Luau::BytecodeBuilder::Function const&) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local reg_0
	local reg_1
	local desired
	while true do
		while true do
			while true do
				if lt_i32(load_i32_i8(memory_at_0.data, loc_1 + 11), 0) then
					break
				end
				store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_1))
				store_i32(memory_at_0.data, add_i32(loc_0, 8), load_i32(memory_at_0.data, add_i32(loc_1, 8)))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1536](loc_0, load_i32(memory_at_0.data, loc_1), load_i32(memory_at_0.data, loc_1 + 4))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_0 + 12, load_i64(memory_at_0.data, loc_1 + 12))
		store_i32(memory_at_0.data, add_i32(loc_0, 20), load_i32(memory_at_0.data, add_i32(loc_1, 20)))
		loc_2 = add_i32(loc_0, 24)
		while true do
			while true do
				if lt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 35)), 0) then
					break
				end
				loc_3 = add_i32(loc_1, 24)
				store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_3))
				store_i32(memory_at_0.data, add_i32(loc_2, 8), load_i32(memory_at_0.data, add_i32(loc_3, 8)))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1536](loc_2, load_i32(memory_at_0.data, loc_1 + 24), load_i32(memory_at_0.data, add_i32(loc_1, 28)))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_2 = add_i32(loc_0, 36)
		while true do
			while true do
				if lt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 47)), 0) then
					break
				end
				loc_3 = add_i32(loc_1, 36)
				store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_3))
				store_i32(memory_at_0.data, add_i32(loc_2, 8), load_i32(memory_at_0.data, add_i32(loc_3, 8)))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1536](loc_2, load_i32(memory_at_0.data, loc_1 + 36), load_i32(memory_at_0.data, add_i32(loc_1, 40)))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_0 + 48, i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_0, 56), 0)
		while true do
			while true do
				loc_3 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_1, 52)), load_i32(memory_at_0.data, loc_1 + 48))
				if loc_3 == 0 then
					break
				end
				if le_i32(loc_3, 4294967295) then
					desired = 1
					break
				end
				reg_1 = FUNC_LIST[1461](loc_3)
				loc_2 = reg_1
				store_i32(memory_at_0.data, loc_0 + 48, loc_2)
				store_i32(memory_at_0.data, loc_0 + 52, loc_2)
				store_i32(memory_at_0.data, loc_0 + 56, add_i32(loc_2, shl_i32(shr_i32(loc_3, 2), 2)))
				while true do
					loc_4 = load_i32(memory_at_0.data, loc_1 + 48)
					loc_3 = sub_i32(load_i32(memory_at_0.data, loc_1 + 52), loc_4)
					if lt_i32(loc_3, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_2, loc_4, loc_3)
					loc_2 = add_i32(reg_0, loc_3)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 52, loc_2)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_2 = add_i32(loc_0, 60)
			while true do
				if lt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 71)), 0) then
					break
				end
				loc_1 = add_i32(loc_1, 60)
				store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_1))
				store_i32(memory_at_0.data, add_i32(loc_2, 8), load_i32(memory_at_0.data, add_i32(loc_1, 8)))
				reg_0 = loc_0
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1536](loc_2, load_i32(memory_at_0.data, loc_1 + 60), load_i32(memory_at_0.data, add_i32(loc_1, 64)))
			reg_0 = loc_0
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[145](add_i32(loc_0, 48))
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[117] = --[[ 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(loc_0, loc_1)
	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
			while true do
				while true do
					while true do
						loc_2 = load_i32(memory_at_0.data, loc_0)
						loc_3 = div_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 4), loc_2), 72)
						loc_4 = add_i32(loc_3, 1)
						if loc_4 >= 59652324 then
							break
						end
						while true do
							while true do
								loc_2 = div_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 8), loc_2), 72)
								loc_5 = shl_i32(loc_2, 1)
								loc_4 = (if loc_2 < 29826161 then (if loc_5 < loc_4 then loc_4 else loc_5) else 59652323)
								if loc_4 ~= 0 then
									break
								end
								loc_2 = 0
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_4 >= 59652324 then
								desired = 3
								break
							end
							reg_0 = FUNC_LIST[1461](mul_i32(loc_4, 72))
							loc_2 = reg_0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = add_i32(loc_2, mul_i32(loc_4, 72))
						reg_0 = FUNC_LIST[116](add_i32(loc_2, mul_i32(loc_3, 72)), loc_1)
						loc_2 = reg_0
						loc_7 = add_i32(loc_2, 72)
						loc_4 = load_i32(memory_at_0.data, loc_0 + 4)
						loc_5 = load_i32(memory_at_0.data, loc_0)
						if loc_4 == loc_5 then
							desired = 2
							break
						end
						loc_8 = add_i32(loc_0, 8)
						while true do
							loc_2 = add_i32(loc_2, 4294967224)
							loc_4 = add_i32(loc_4, 4294967224)
							store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_4))
							loc_1 = add_i32(loc_4, 8)
							store_i32(memory_at_0.data, add_i32(loc_2, 8), load_i32(memory_at_0.data, loc_1))
							store_i64(memory_at_0.data, loc_4, i64_ZERO)
							store_i32(memory_at_0.data, loc_1, 0)
							store_i32(memory_at_0.data, add_i32(loc_2, 20), load_i32(memory_at_0.data, add_i32(loc_4, 20)))
							store_i64(memory_at_0.data, loc_2 + 12, load_i64(memory_at_0.data, loc_4 + 12))
							loc_1 = add_i32(loc_4, 32)
							store_i32(memory_at_0.data, add_i32(loc_2, 32), load_i32(memory_at_0.data, loc_1))
							store_i64(memory_at_0.data, loc_2 + 24, load_i64(memory_at_0.data, loc_4 + 24))
							store_i32(memory_at_0.data, loc_1, 0)
							store_i64(memory_at_0.data, loc_4 + 24, i64_ZERO)
							loc_1 = add_i32(loc_4, 44)
							store_i32(memory_at_0.data, add_i32(loc_2, 44), load_i32(memory_at_0.data, loc_1))
							store_i64(memory_at_0.data, loc_2 + 36, load_i64(memory_at_0.data, loc_4 + 36))
							store_i64(memory_at_0.data, loc_4 + 36, i64_ZERO)
							store_i32(memory_at_0.data, loc_1, 0)
							loc_1 = add_i32(loc_2, 56)
							store_i32(memory_at_0.data, loc_1, 0)
							store_i64(memory_at_0.data, loc_2 + 48, i64_ZERO)
							store_i32(memory_at_0.data, loc_2 + 48, load_i32(memory_at_0.data, loc_4 + 48))
							store_i32(memory_at_0.data, add_i32(loc_2, 52), load_i32(memory_at_0.data, add_i32(loc_4, 52)))
							loc_3 = add_i32(loc_4, 56)
							store_i32(memory_at_0.data, loc_1, load_i32(memory_at_0.data, loc_3))
							store_i32(memory_at_0.data, loc_3, 0)
							store_i64(memory_at_0.data, loc_4 + 48, i64_ZERO)
							loc_1 = add_i32(loc_4, 68)
							store_i32(memory_at_0.data, add_i32(loc_2, 68), load_i32(memory_at_0.data, loc_1))
							store_i64(memory_at_0.data, loc_2 + 60, load_i64(memory_at_0.data, loc_4 + 60))
							store_i64(memory_at_0.data, loc_4 + 60, i64_ZERO)
							store_i32(memory_at_0.data, loc_1, 0)
							if loc_4 ~= loc_5 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 8, loc_6)
						loc_4 = load_i32(memory_at_0.data, loc_0 + 4)
						store_i32(memory_at_0.data, loc_0 + 4, loc_7)
						loc_5 = load_i32(memory_at_0.data, loc_0)
						store_i32(memory_at_0.data, loc_0, loc_2)
						if loc_4 == loc_5 then
							desired = 1
							break
						end
						while true do
							loc_4 = add_i32(loc_4, 4294967224)
							FUNC_LIST[274](loc_8, loc_4)
							if loc_4 ~= loc_5 then
								continue
							end
							desired = 1
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[114](loc_0)
					error("out of code bounds")
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[276]()
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 8, loc_6)
			store_i32(memory_at_0.data, loc_0 + 4, loc_7)
			store_i32(memory_at_0.data, loc_0, loc_2)
			break
		end
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[118] = --[[ Luau::BytecodeBuilder::endFunction(unsigned char, unsigned char, unsigned char) ]] function(loc_0, loc_1, loc_2, loc_3)
	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 reg_0
	local desired
	while true do
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_4
		loc_5 = load_i32(memory_at_0.data, loc_0)
		loc_6 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_7 = add_i32(loc_5, mul_i32(loc_6, 72))
		store_i32_n8(memory_at_0.data, loc_7 + 14, loc_2)
		store_i32_n8(memory_at_0.data, loc_7 + 12, loc_1)
		while true do
			loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 440))
			loc_8 = band_i32(loc_2, 1)
			loc_1 = load_i32(memory_at_0.data, loc_0 + 436)
			if bor_i32(loc_8, loc_1) == 0 then
				break
			end
			loc_9 = add_i32(loc_0, shr_i32(loc_2, 1))
			while true do
				if loc_8 == 0 then
					break
				end
				loc_1 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_9), loc_1))
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_2 = add_i32(loc_5, mul_i32(loc_6, 72))
			TABLE_LIST[0].data[loc_1](loc_4, loc_9, add_i32(loc_2, 48))
			loc_1 = add_i32(loc_2, 24)
			while true do
				if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_2, 35)), 4294967295) then
					break
				end
				FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1))
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_4))
			store_i32(memory_at_0.data, add_i32(loc_1, 8), load_i32(memory_at_0.data, add_i32(loc_4, 8)))
			break
		end
		FUNC_LIST[1538](loc_7, add_i32(mul_i32(shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 24)), load_i32(memory_at_0.data, loc_0 + 20)), 2), 7), 32))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 392)
			if loc_1 == 0 then
				break
			end
			loc_2 = load_i32(memory_at_0.data, loc_0 + 20)
			TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1) + 8)](loc_1, loc_2, shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 24), loc_2), 2))
			break
		end
		FUNC_LIST[119](loc_0, loc_7, load_i32(memory_at_0.data, loc_0 + 12), loc_3)
		store_i32(memory_at_0.data, loc_0 + 12, 4294967295)
		store_i32(memory_at_0.data, loc_0 + 24, load_i32(memory_at_0.data, loc_0 + 20))
		store_i32(memory_at_0.data, add_i32(loc_0, 36), load_i32(memory_at_0.data, loc_0 + 32))
		store_i32(memory_at_0.data, add_i32(loc_0, 48), load_i32(memory_at_0.data, loc_0 + 44))
		store_i32(memory_at_0.data, add_i32(loc_0, 60), load_i32(memory_at_0.data, loc_0 + 56))
		store_i32(memory_at_0.data, add_i32(loc_0, 72), load_i32(memory_at_0.data, loc_0 + 68))
		store_i32(memory_at_0.data, add_i32(loc_0, 84), load_i32(memory_at_0.data, loc_0 + 80))
		store_i32(memory_at_0.data, add_i32(loc_0, 312), load_i32(memory_at_0.data, loc_0 + 308))
		store_i32(memory_at_0.data, add_i32(loc_0, 324), load_i32(memory_at_0.data, loc_0 + 320))
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_0, 104)) == 0 then
				break
			end
			while true do
				while true do
					loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 100))
					if loc_3 < 33 then
						break
					end
					FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0 + 96))
					store_i64(memory_at_0.data, loc_0 + 96, i64_ZERO)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_3 == 0 then
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_0 + 96)
				loc_9 = band_i32(loc_3, 1)
				loc_1 = add_i32(loc_0, 112)
				loc_7 = 0
				while true do
					if loc_3 == 1 then
						break
					end
					loc_8 = band_i32(loc_3, 4294967294)
					loc_7 = 0
					loc_5 = 0
					while true do
						loc_3 = add_i32(loc_2, mul_i32(loc_7, 24))
						store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, loc_1))
						loc_6 = add_i32(loc_1, 8)
						loc_10 = load_i64(memory_at_0.data, loc_6)
						store_i32(memory_at_0.data, loc_3 + 16, 0)
						store_i64(memory_at_0.data, add_i32(loc_3, 8), loc_10)
						loc_3 = add_i32(loc_2, mul_i32(bor_i32(loc_7, 1), 24))
						store_i64(memory_at_0.data, add_i32(loc_3, 8), load_i64(memory_at_0.data, loc_6))
						store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, loc_1))
						store_i32(memory_at_0.data, loc_3 + 16, 0)
						loc_7 = add_i32(loc_7, 2)
						loc_5 = add_i32(loc_5, 2)
						if loc_5 ~= loc_8 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_9 == 0 then
					break
				end
				loc_7 = add_i32(loc_2, mul_i32(loc_7, 24))
				store_i64(memory_at_0.data, loc_7, load_i64(memory_at_0.data, loc_1))
				loc_10 = load_i64(memory_at_0.data, add_i32(loc_1, 8))
				store_i32(memory_at_0.data, loc_7 + 16, 0)
				store_i64(memory_at_0.data, add_i32(loc_7, 8), loc_10)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 104, 0)
			break
		end
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_0, 144)) == 0 then
				break
			end
			while true do
				while true do
					loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 140))
					if loc_2 < 33 then
						break
					end
					FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0 + 136))
					store_i64(memory_at_0.data, loc_0 + 136, i64_ZERO)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_2 == 0 then
					break
				end
				loc_1 = load_i32(memory_at_0.data, loc_0 + 136)
				loc_6 = band_i32(loc_2, 1)
				loc_3 = add_i32(loc_0, 148)
				loc_7 = 0
				while true do
					if loc_2 == 1 then
						break
					end
					loc_5 = band_i32(loc_2, 4294967294)
					loc_7 = 0
					loc_2 = 0
					while true do
						reg_0 = FUNC_LIST[1224](add_i32(loc_1, mul_i32(loc_7, 136)), loc_3, 132)
						store_i32(memory_at_0.data, reg_0 + 132, 0)
						reg_0 = FUNC_LIST[1224](add_i32(loc_1, mul_i32(bor_i32(loc_7, 1), 136)), loc_3, 132)
						store_i32(memory_at_0.data, reg_0 + 132, 0)
						loc_7 = add_i32(loc_7, 2)
						loc_2 = add_i32(loc_2, 2)
						if loc_2 ~= loc_5 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_6 == 0 then
					break
				end
				reg_0 = FUNC_LIST[1224](add_i32(loc_1, mul_i32(loc_7, 136)), loc_3, 132)
				store_i32(memory_at_0.data, reg_0 + 132, 0)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 144, 0)
			break
		end
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_0, 292)) == 0 then
				break
			end
			while true do
				while true do
					loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 288))
					if loc_3 < 33 then
						break
					end
					FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0 + 284))
					store_i64(memory_at_0.data, loc_0 + 284, i64_ZERO)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_3 == 0 then
					break
				end
				loc_1 = load_i32(memory_at_0.data, loc_0 + 284)
				loc_9 = band_i32(loc_3, 3)
				loc_2 = 0
				loc_7 = 0
				while true do
					if add_i32(loc_3, 4294967295) < 3 then
						break
					end
					loc_11 = band_i32(loc_3, 4294967292)
					loc_7 = 0
					loc_5 = 0
					while true do
						loc_6 = load_i32(memory_at_0.data, loc_0 + 296)
						loc_3 = shl_i32(loc_7, 3)
						loc_8 = add_i32(loc_1, loc_3)
						store_i32_n16(memory_at_0.data, loc_8 + 4, 0)
						store_i32(memory_at_0.data, loc_8, loc_6)
						loc_6 = load_i32(memory_at_0.data, loc_0 + 296)
						loc_8 = add_i32(loc_1, bor_i32(loc_3, 8))
						store_i32_n16(memory_at_0.data, loc_8 + 4, 0)
						store_i32(memory_at_0.data, loc_8, loc_6)
						loc_6 = load_i32(memory_at_0.data, loc_0 + 296)
						loc_8 = add_i32(loc_1, bor_i32(loc_3, 16))
						store_i32_n16(memory_at_0.data, loc_8 + 4, 0)
						store_i32(memory_at_0.data, loc_8, loc_6)
						loc_6 = load_i32(memory_at_0.data, loc_0 + 296)
						loc_3 = add_i32(loc_1, bor_i32(loc_3, 24))
						store_i32_n16(memory_at_0.data, loc_3 + 4, 0)
						store_i32(memory_at_0.data, loc_3, loc_6)
						loc_7 = add_i32(loc_7, 4)
						loc_5 = add_i32(loc_5, 4)
						if loc_5 ~= loc_11 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_9 == 0 then
					break
				end
				while true do
					loc_3 = load_i32(memory_at_0.data, loc_0 + 296)
					loc_5 = add_i32(loc_1, shl_i32(loc_7, 3))
					store_i32_n16(memory_at_0.data, loc_5 + 4, 0)
					store_i32(memory_at_0.data, loc_5, loc_3)
					loc_7 = add_i32(loc_7, 1)
					loc_2 = add_i32(loc_2, 1)
					if loc_2 ~= loc_9 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.data, loc_0 + 292, 0)
			break
		end
		store_i32(memory_at_0.data, add_i32(loc_0, 372), load_i32(memory_at_0.data, loc_0 + 368))
		while true do
			while true do
				if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_0, 391)), 4294967295) then
					break
				end
				store_i32_n8(memory_at_0.data, load_i32(memory_at_0.data, loc_0 + 380), 0)
				store_i32(memory_at_0.data, add_i32(loc_0, 384), 0)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32_n8(memory_at_0.data, loc_0 + 391, 0)
			store_i32_n8(memory_at_0.data, loc_0 + 380, 0)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_4, 16)
		break
	end
end
FUNC_LIST[119] = --[[ Luau::BytecodeBuilder::writeFunction(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >&, unsigned int, unsigned char) const ]] function(loc_0, loc_1, loc_2, loc_3)
	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_4 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_4
		loc_5 = load_i32(memory_at_0.data, loc_0)
		loc_6 = add_i32(loc_5, mul_i32(loc_2, 72))
		store_i32_n8(memory_at_0.data, loc_4 + 8, load_i32_u8(memory_at_0.data, loc_6 + 12))
		reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
		store_i32_n8(memory_at_0.data, loc_4 + 8, load_i32_u8(memory_at_0.data, loc_6 + 13))
		reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
		store_i32_n8(memory_at_0.data, loc_4 + 8, load_i32_u8(memory_at_0.data, loc_6 + 14))
		reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
		store_i32_n8(memory_at_0.data, loc_4 + 8, load_i32_u8(memory_at_0.data, loc_6 + 15))
		reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
		store_i32_n8(memory_at_0.data, loc_4 + 8, loc_3)
		reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
		loc_7 = add_i32(loc_6, 64)
		loc_3 = load_i32_u8(memory_at_0.data, add_i32(loc_6, 71))
		loc_3 = (if lt_i32(shr_i32(shl_i32(loc_3, 24), 24), 0) then load_i32(memory_at_0.data, loc_7) else loc_3)
		loc_8 = add_i32(loc_6, 60)
		while true do
			loc_6 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_6 ~= 0 then
				continue
			end
			break
		end
		loc_3 = load_i32_u8(memory_at_0.data, loc_8 + 11)
		loc_6 = (if lt_i32(shr_i32(shl_i32(loc_3, 24), 24), 0) then 1 else 0)
		reg_0 = FUNC_LIST[1541](loc_1, (if loc_6 ~= 0 then load_i32(memory_at_0.data, loc_8) else loc_8), (if loc_6 ~= 0 then load_i32(memory_at_0.data, loc_7) else loc_3))
		loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 24)), load_i32(memory_at_0.data, loc_0 + 20)), 2)
		while true do
			loc_6 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_6 ~= 0 then
				continue
			end
			break
		end
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_0 + 20)
			loc_6 = load_i32(memory_at_0.data, loc_0 + 24)
			if loc_3 == loc_6 then
				break
			end
			while true do
				store_i32(memory_at_0.data, loc_4 + 8, load_i32(memory_at_0.data, loc_3))
				reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 4)
				loc_3 = add_i32(loc_3, 4)
				if loc_3 ~= loc_6 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 48)), load_i32(memory_at_0.data, loc_0 + 44)), 4)
		while true do
			loc_6 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_6 ~= 0 then
				continue
			end
			break
		end
		while true do
			loc_7 = load_i32(memory_at_0.data, loc_0 + 44)
			loc_9 = load_i32(memory_at_0.data, loc_0 + 48)
			if loc_7 == loc_9 then
				break
			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
											while true do
												if not br_map[1] then
													br_map[1] = (function()
														return { [0] = 0, 1, 2, 3, 4, 5, 6, }
													end)()
												end
												temp = br_map[1][load_i32(memory_at_0.data, loc_7)] 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.data, loc_4 + 8, 0)
											reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
											desired = 3
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										store_i32_n8(memory_at_0.data, loc_4 + 8, 1)
										reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
										store_i32_n8(memory_at_0.data, loc_4 + 8, load_i32_u8(memory_at_0.data, loc_7 + 8))
										reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
										desired = 3
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									store_i32_n8(memory_at_0.data, loc_4 + 8, 2)
									reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
									store_f64(memory_at_0.data, loc_4 + 8, load_f64(memory_at_0.data, loc_7 + 8))
									reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 8)
									desired = 3
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								store_i32_n8(memory_at_0.data, loc_4 + 8, 3)
								reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
								loc_3 = load_i32(memory_at_0.data, loc_7 + 8)
								while true do
									store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32((if loc_3 > 127 then 1 else 0), 7), band_i32(loc_3, 127)))
									reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
									loc_6 = (if loc_3 < 128 then 1 else 0)
									loc_3 = shr_u32(loc_3, 7)
									if loc_6 == 0 then
										continue
									end
									desired = 3
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32_n8(memory_at_0.data, loc_4 + 8, 4)
							reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
							store_i32(memory_at_0.data, loc_4 + 8, load_i32(memory_at_0.data, loc_7 + 8))
							reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 4)
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_3 = load_i32(memory_at_0.data, loc_0 + 80)
						loc_6 = load_i32(memory_at_0.data, loc_7 + 8)
						store_i32_n8(memory_at_0.data, loc_4 + 8, 5)
						reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
						loc_10 = add_i32(loc_3, mul_i32(loc_6, 132))
						loc_11 = add_i32(loc_10, 128)
						loc_3 = load_i32(memory_at_0.data, loc_10 + 128)
						while true do
							loc_6 = (if loc_3 > 127 then 1 else 0)
							store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
							reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
							loc_3 = shr_u32(loc_3, 7)
							if loc_6 ~= 0 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = 0
						if load_i32(memory_at_0.data, loc_11) == 0 then
							desired = 3
							break
						end
						while true do
							loc_3 = load_i32(memory_at_0.data, add_i32(loc_10, shl_i32(loc_8, 2)))
							while true do
								loc_6 = (if loc_3 > 127 then 1 else 0)
								store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
								reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
								loc_3 = shr_u32(loc_3, 7)
								if loc_6 ~= 0 then
									continue
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_8 = add_i32(loc_8, 1)
							if loc_8 < load_i32(memory_at_0.data, loc_11) then
								continue
							end
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32_n8(memory_at_0.data, loc_4 + 8, 6)
					reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
					loc_3 = load_i32(memory_at_0.data, loc_7 + 8)
					while true do
						loc_6 = (if loc_3 > 127 then 1 else 0)
						store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
						reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
						loc_3 = shr_u32(loc_3, 7)
						if loc_6 ~= 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_7 = add_i32(loc_7, 16)
				if loc_7 ~= loc_9 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 60)), load_i32(memory_at_0.data, loc_0 + 56)), 2)
		while true do
			loc_6 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_6 ~= 0 then
				continue
			end
			break
		end
		while true do
			loc_8 = load_i32(memory_at_0.data, loc_0 + 56)
			loc_7 = load_i32(memory_at_0.data, loc_0 + 60)
			if loc_8 == loc_7 then
				break
			end
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_8)
				while true do
					loc_6 = (if loc_3 > 127 then 1 else 0)
					store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
					reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
					loc_3 = shr_u32(loc_3, 7)
					if loc_6 ~= 0 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_8 = add_i32(loc_8, 4)
				if loc_8 ~= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_3 = load_i32(memory_at_0.data, add_i32(loc_5, mul_i32(loc_2, 72)) + 20)
		while true do
			loc_6 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_6 ~= 0 then
				continue
			end
			break
		end
		loc_3 = load_i32(memory_at_0.data, add_i32(loc_5, mul_i32(loc_2, 72)) + 16)
		while true do
			loc_6 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_6 ~= 0 then
				continue
			end
			break
		end
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_0 + 32)
				loc_6 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
				if loc_3 == loc_6 then
					break
				end
				while true do
					while true do
						if load_i32(memory_at_0.data, loc_3) == 0 then
							desired = 3
							break
						end
						loc_3 = add_i32(loc_3, 4)
						if loc_3 == loc_6 then
							desired = 2
							break
						end
						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
				store_i32_n8(memory_at_0.data, loc_4 + 8, 0)
				reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32_n8(memory_at_0.data, loc_4 + 8, 1)
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			FUNC_LIST[120](loc_0, loc_1)
			break
		end
		while true do
			while true do
				while true do
					if load_i32(memory_at_0.data, loc_0 + 308) ~= load_i32(memory_at_0.data, add_i32(loc_0, 312)) then
						break
					end
					if load_i32(memory_at_0.data, loc_0 + 320) == load_i32(memory_at_0.data, add_i32(loc_0, 324)) then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32_n8(memory_at_0.data, loc_4 + 8, 1)
				reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
				loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 312), load_i32(memory_at_0.data, loc_0 + 308)), 4)
				while true do
					loc_6 = (if loc_3 > 127 then 1 else 0)
					store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
					reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
					loc_3 = shr_u32(loc_3, 7)
					if loc_6 ~= 0 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					loc_8 = load_i32(memory_at_0.data, loc_0 + 308)
					loc_7 = load_i32(memory_at_0.data, loc_0 + 312)
					if loc_8 == loc_7 then
						break
					end
					while true do
						loc_3 = load_i32(memory_at_0.data, loc_8)
						while true do
							loc_6 = (if loc_3 > 127 then 1 else 0)
							store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
							reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
							loc_3 = shr_u32(loc_3, 7)
							if loc_6 ~= 0 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = load_i32(memory_at_0.data, loc_8 + 8)
						while true do
							loc_6 = (if loc_3 > 127 then 1 else 0)
							store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
							reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
							loc_3 = shr_u32(loc_3, 7)
							if loc_6 ~= 0 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = load_i32(memory_at_0.data, loc_8 + 12)
						while true do
							loc_6 = (if loc_3 > 127 then 1 else 0)
							store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
							reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
							loc_3 = shr_u32(loc_3, 7)
							if loc_6 ~= 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.data, loc_4 + 8, load_i32_u8(memory_at_0.data, loc_8 + 4))
						reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
						loc_8 = add_i32(loc_8, 16)
						if loc_8 ~= 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
					end
					break
				end
				loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 324)), load_i32(memory_at_0.data, loc_0 + 320)), 2)
				while true do
					loc_6 = (if loc_3 > 127 then 1 else 0)
					store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
					reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
					loc_3 = shr_u32(loc_3, 7)
					if loc_6 ~= 0 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = load_i32(memory_at_0.data, loc_0 + 320)
				loc_7 = load_i32(memory_at_0.data, loc_0 + 324)
				if loc_8 == loc_7 then
					desired = 1
					break
				end
				while true do
					loc_3 = load_i32(memory_at_0.data, loc_8)
					while true do
						loc_6 = (if loc_3 > 127 then 1 else 0)
						store_i32_n8(memory_at_0.data, loc_4 + 8, bor_i32(shl_i32(loc_6, 7), band_i32(loc_3, 127)))
						reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
						loc_3 = shr_u32(loc_3, 7)
						if loc_6 ~= 0 then
							continue
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_8 = add_i32(loc_8, 4)
					if loc_8 ~= loc_7 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32_n8(memory_at_0.data, loc_4 + 8, 0)
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_4, 8), 1)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_4, 16)
		break
	end
end
FUNC_LIST[120] = --[[ Luau::BytecodeBuilder::writeLineInfo(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >&) const ]] function(loc_0, loc_1)
	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_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i32(memory_at_0.data, loc_0 + 32)
		loc_4 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 36)), loc_3)
		loc_5 = shr_i32(loc_4, 2)
		loc_6 = 16777216
		while true do
			if loc_4 == 0 then
				break
			end
			loc_7 = 0
			while true do
				while true do
					while true do
						loc_8 = loc_7
						loc_7 = add_i32(loc_6, loc_8)
						if loc_8 < loc_7 then
							break
						end
						loc_9 = (if loc_8 < loc_5 then 1 else 0)
						loc_10 = loc_8
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_11 = load_i32(memory_at_0.data, add_i32(loc_3, shl_i32(loc_8, 2)))
					loc_12 = loc_11
					loc_10 = loc_8
					while true do
						loc_10 = add_i32(loc_10, 1)
						loc_9 = (if loc_10 < loc_5 then 1 else 0)
						if loc_10 >= loc_5 then
							desired = 3
							break
						end
						if loc_10 >= loc_7 then
							desired = 3
							break
						end
						loc_9 = load_i32(memory_at_0.data, add_i32(loc_3, shl_i32(loc_10, 2)))
						loc_11 = (if lt_i32(loc_11, loc_9) then loc_9 else loc_11)
						loc_12 = (if lt_i32(loc_9, loc_12) then loc_9 else loc_12)
						if lt_i32(sub_i32(loc_11, loc_12), 256) then
							continue
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_9 = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				while true do
					if loc_9 == 0 then
						break
					end
					loc_9 = 0
					loc_11 = sub_i32(loc_10, loc_8)
					if loc_11 >= loc_6 then
						break
					end
					while true do
						loc_10 = loc_9
						loc_9 = add_i32(loc_10, 1)
						if le_i32(shl_i32(2, loc_10), loc_11) then
							continue
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_6 = shl_i32(1, loc_10)
					loc_7 = add_i32(loc_6, loc_8)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_7 < loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_12 = 0
		store_i32(memory_at_0.data, loc_2 + 24, 0)
		store_i32(memory_at_0.data, loc_2 + 16, 0)
		store_i64(memory_at_0.data, loc_2 + 8, i64_ZERO)
		loc_8 = add_i32(loc_2, 24)
		while true do
			loc_13 = div_u32(add_i32(loc_5, 4294967295), loc_6)
			loc_14 = add_i32(loc_13, 1)
			if loc_14 <= 1 then
				break
			end
			FUNC_LIST[167](add_i32(loc_2, 8), loc_14)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 32)
			loc_4 = sub_i32(load_i32(memory_at_0.data, loc_0 + 36), loc_3)
			loc_5 = shr_i32(loc_4, 2)
			loc_8 = load_i32(memory_at_0.data, loc_2 + 8)
			break
		end
		while true do
			if loc_4 == 0 then
				break
			end
			while true do
				loc_7 = loc_12
				loc_9 = load_i32(memory_at_0.data, add_i32(loc_3, shl_i32(loc_7, 2)))
				while true do
					loc_12 = add_i32(loc_7, loc_6)
					if loc_7 >= loc_12 then
						break
					end
					loc_10 = add_i32(loc_7, 1)
					if loc_10 >= loc_5 then
						break
					end
					if loc_10 >= loc_12 then
						break
					end
					while true do
						loc_11 = load_i32(memory_at_0.data, add_i32(loc_3, shl_i32(loc_10, 2)))
						loc_9 = (if lt_i32(loc_11, loc_9) then loc_11 else loc_9)
						loc_10 = add_i32(loc_10, 1)
						if loc_10 >= loc_5 then
							desired = 3
							break
						end
						if loc_10 < loc_12 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.data, add_i32(loc_8, shl_i32(div_u32(loc_7, loc_6), 2)), loc_9)
				if loc_12 < loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_9 = 0
		while true do
			loc_10 = loc_9
			loc_9 = add_i32(loc_10, 1)
			if le_i32(shl_i32(2, loc_10), loc_6) then
				continue
			end
			break
		end
		store_i32_n8(memory_at_0.data, loc_2 + 28, loc_10)
		reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_2, 28), 1)
		while true do
			loc_5 = load_i32(memory_at_0.data, loc_0 + 32)
			if load_i32(memory_at_0.data, loc_0 + 36) == loc_5 then
				break
			end
			loc_9 = 0
			loc_11 = 0
			while true do
				loc_5 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_9, 2))), load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(shr_u32(loc_9, loc_10), 2))))
				store_i32_n8(memory_at_0.data, loc_2 + 28, sub_i32(loc_5, loc_11))
				reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_2, 28), 1)
				loc_11 = loc_5
				loc_9 = add_i32(loc_9, 1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 32)
				if loc_9 < shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 36), loc_5), 2) then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			if loc_14 == 0 then
				break
			end
			loc_10 = 0
			loc_9 = 0
			while true do
				loc_5 = add_i32(loc_8, shl_i32(loc_10, 2))
				store_i32(memory_at_0.data, loc_2 + 28, sub_i32(load_i32(memory_at_0.data, loc_5), loc_9))
				reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_2, 28), 4)
				loc_11 = (if loc_10 == loc_13 then 1 else 0)
				loc_9 = load_i32(memory_at_0.data, loc_5)
				loc_10 = add_i32(loc_10, 1)
				if loc_11 == 0 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			loc_10 = load_i32(memory_at_0.data, loc_2 + 8)
			if loc_10 == 0 then
				break
			end
			store_i32(memory_at_0.data, loc_2 + 12, loc_10)
			FUNC_LIST[1463](loc_10)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		break
	end
end
FUNC_LIST[121] = --[[ Luau::BytecodeBuilder::setMainFunction(unsigned int) ]] function(loc_0, loc_1)
	while true do
		store_i32(memory_at_0.data, loc_0 + 16, loc_1)
		break
	end
end
FUNC_LIST[122] = --[[ Luau::BytecodeBuilder::addConstant(Luau::BytecodeBuilder::ConstantKey const&, Luau::BytecodeBuilder::Constant const&) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = i64_ZERO
	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 loc_11 = 0
	local loc_12 = i64_ZERO
	local loc_13 = 0
	local loc_14 = 0
	local reg_0
	local desired
	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 load_i32(memory_at_0.data, add_i32(loc_0, 104)) == 0 then
										break
									end
									loc_3 = load_i64(memory_at_0.data, add_i32(loc_0, 120))
									loc_4 = load_i64(memory_at_0.data, loc_1 + 8)
									while true do
										loc_5 = load_i32(memory_at_0.data, loc_1)
										loc_6 = load_i32(memory_at_0.data, add_i32(loc_0, 112))
										if loc_5 ~= loc_6 then
											break
										end
										if eq_i64(loc_4, loc_3) then
											desired = 7
											break
										end
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									loc_7 = bxor_i32(mul_i32(loc_5, 1540483477), wrap_i32_i64(shr_u64(loc_4, i64_from_u32(32, 0))))
									loc_8 = mul_i32(bxor_i32(shr_u32(loc_7, 18), wrap_i32_i64(loc_4)), 1540483477)
									loc_7 = mul_i32(bxor_i32(shr_u32(loc_8, 22), loc_7), 1540483477)
									loc_8 = mul_i32(bxor_i32(shr_u32(mul_i32(bxor_i32(shr_u32(loc_7, 17), loc_8), 1540483477), 19), loc_7), 1540483477)
									loc_9 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 100)), 4294967295)
									loc_10 = load_i32(memory_at_0.data, loc_0 + 96)
									loc_7 = 0
									while true do
										loc_11 = band_i32(loc_8, loc_9)
										loc_8 = add_i32(loc_10, mul_i32(loc_11, 24))
										loc_12 = load_i64(memory_at_0.data, loc_8 + 8)
										while true do
											loc_8 = load_i32(memory_at_0.data, loc_8)
											if loc_8 ~= loc_5 then
												break
											end
											if eq_i64(loc_12, loc_4) then
												desired = 6
												break
											end
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
												continue
											end
											break
										end
										while true do
											if loc_8 ~= loc_6 then
												break
											end
											if eq_i64(loc_12, loc_3) then
												desired = 7
												break
											end
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
												continue
											end
											break
										end
										loc_7 = add_i32(loc_7, 1)
										loc_8 = add_i32(loc_7, loc_11)
										if loc_7 <= loc_9 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_13 = 4294967295
								loc_7 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 48)), load_i32(memory_at_0.data, loc_0 + 44))
								if loc_7 > 134217712 then
									desired = 3
									break
								end
								loc_13 = shr_i32(loc_7, 4)
								FUNC_LIST[123](add_i32(loc_0, 96), loc_1)
								loc_5 = load_i32(memory_at_0.data, loc_0 + 96)
								loc_6 = load_i32(memory_at_0.data, loc_1)
								loc_4 = load_i64(memory_at_0.data, loc_1 + 8)
								loc_7 = bxor_i32(mul_i32(loc_6, 1540483477), wrap_i32_i64(shr_u64(loc_4, i64_from_u32(32, 0))))
								loc_8 = mul_i32(bxor_i32(shr_u32(loc_7, 18), wrap_i32_i64(loc_4)), 1540483477)
								loc_7 = mul_i32(bxor_i32(shr_u32(loc_8, 22), loc_7), 1540483477)
								loc_10 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 100)), 4294967295)
								loc_8 = band_i32(mul_i32(bxor_i32(shr_u32(mul_i32(bxor_i32(shr_u32(loc_7, 17), loc_8), 1540483477), 19), loc_7), 1540483477), loc_10)
								loc_7 = add_i32(loc_5, mul_i32(loc_8, 24))
								loc_12 = load_i64(memory_at_0.data, loc_7 + 8)
								loc_3 = load_i64(memory_at_0.data, add_i32(loc_0, 120))
								loc_11 = 0
								while true do
									loc_9 = load_i32(memory_at_0.data, loc_7)
									loc_14 = load_i32(memory_at_0.data, add_i32(loc_0, 112))
									if loc_9 ~= loc_14 then
										break
									end
									if eq_i64(loc_12, loc_3) then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								while true do
									while true do
										if loc_9 ~= loc_6 then
											break
										end
										if eq_i64(loc_12, loc_4) then
											desired = 4
											break
										end
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									loc_11 = add_i32(loc_11, 1)
									loc_8 = band_i32(add_i32(loc_11, loc_8), loc_10)
									loc_7 = add_i32(loc_5, mul_i32(loc_8, 24))
									loc_12 = load_i64(memory_at_0.data, loc_7 + 8)
									loc_9 = load_i32(memory_at_0.data, loc_7)
									if loc_9 ~= loc_14 then
										continue
									end
									if eq_i64(loc_12, loc_3) then
										desired = 5
										break
									end
									continue
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							reg_0 = load_i32(memory_at_0.data, add_i32(loc_10, mul_i32(loc_11, 24)) + 16)
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i64(memory_at_0.data, loc_7, load_i64(memory_at_0.data, loc_1))
						store_i64(memory_at_0.data, add_i32(loc_7, 8), load_i64(memory_at_0.data, add_i32(loc_1, 8)))
						store_i32(memory_at_0.data, loc_0 + 104, add_i32(load_i32(memory_at_0.data, loc_0 + 104), 1))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, add_i32(loc_5, mul_i32(loc_8, 24)) + 16, loc_13)
					while true do
						loc_7 = load_i32(memory_at_0.data, loc_0 + 48)
						if loc_7 == load_i32(memory_at_0.data, add_i32(loc_0, 52)) then
							break
						end
						store_i64(memory_at_0.data, loc_7, load_i64(memory_at_0.data, loc_2))
						store_i64(memory_at_0.data, add_i32(loc_7, 8), load_i64(memory_at_0.data, add_i32(loc_2, 8)))
						store_i32(memory_at_0.data, loc_0 + 48, add_i32(loc_7, 16))
						reg_0 = loc_13
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_11 = add_i32(loc_0, 44)
					loc_9 = load_i32(memory_at_0.data, loc_11)
					loc_7 = sub_i32(loc_7, loc_9)
					loc_5 = shr_i32(loc_7, 4)
					loc_8 = add_i32(loc_5, 1)
					if loc_8 >= 268435456 then
						desired = 2
						break
					end
					while true do
						while true do
							loc_11 = shr_i32(loc_7, 3)
							loc_11 = (if loc_7 < 2147483632 then (if loc_11 < loc_8 then loc_8 else loc_11) else 268435455)
							if loc_11 ~= 0 then
								break
							end
							loc_8 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_11 >= 268435456 then
							desired = 1
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_11, 4))
						loc_8 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_5 = add_i32(loc_8, shl_i32(loc_5, 4))
					store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_2))
					store_i64(memory_at_0.data, add_i32(loc_5, 8), load_i64(memory_at_0.data, add_i32(loc_2, 8)))
					loc_11 = add_i32(loc_8, shl_i32(loc_11, 4))
					loc_5 = add_i32(loc_5, 16)
					while true do
						if lt_i32(loc_7, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_8, loc_9, loc_7)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 52, loc_11)
					store_i32(memory_at_0.data, loc_0 + 48, loc_5)
					store_i32(memory_at_0.data, loc_0 + 44, loc_8)
					if loc_9 == 0 then
						break
					end
					FUNC_LIST[1463](loc_9)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				reg_0 = loc_13
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[124](loc_11)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[123] = --[[ 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_if_full(Luau::BytecodeBuilder::ConstantKey const&) ]] function(loc_0, loc_1)
	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 = 0
	local loc_8 = 0
	local loc_9 = 0
	local loc_10 = i64_ZERO
	local desired
	while true do
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i64(memory_at_0.data, add_i32(loc_0, 24))
				loc_5 = load_i64(memory_at_0.data, loc_1 + 8)
				while true do
					loc_6 = load_i32(memory_at_0.data, loc_1)
					loc_7 = load_i32(memory_at_0.data, loc_0 + 16)
					if loc_6 ~= loc_7 then
						break
					end
					if eq_i64(loc_5, loc_4) then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = bxor_i32(mul_i32(loc_6, 1540483477), wrap_i32_i64(shr_u64(loc_5, i64_from_u32(32, 0))))
				loc_2 = mul_i32(bxor_i32(shr_u32(loc_1, 18), wrap_i32_i64(loc_5)), 1540483477)
				loc_1 = mul_i32(bxor_i32(shr_u32(loc_2, 22), loc_1), 1540483477)
				loc_2 = mul_i32(bxor_i32(shr_u32(mul_i32(bxor_i32(shr_u32(loc_1, 17), loc_2), 1540483477), 19), loc_1), 1540483477)
				loc_3 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_1 = 0
				while true do
					loc_9 = band_i32(loc_2, loc_3)
					loc_2 = add_i32(loc_8, mul_i32(loc_9, 24))
					loc_10 = load_i64(memory_at_0.data, loc_2 + 8)
					while true do
						loc_2 = load_i32(memory_at_0.data, loc_2)
						if loc_2 ~= loc_6 then
							break
						end
						if eq_i64(loc_10, loc_5) then
							desired = 1
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if loc_2 ~= loc_7 then
							break
						end
						if eq_i64(loc_10, loc_4) then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_2 = add_i32(loc_1, loc_9)
					if loc_1 <= 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
			FUNC_LIST[178](loc_0)
			break
		end
		break
	end
end
FUNC_LIST[124] = --[[ std::__2::vector<Luau::BytecodeBuilder::Constant, std::__2::allocator<Luau::BytecodeBuilder::Constant> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[125] = --[[ Luau::BytecodeBuilder::addStringTableEntry(Luau::BytecodeBuilder::StringRef) ]] function(loc_0, loc_1)
	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_2 = add_i32(loc_0, 332)
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_0, 340)) < shr_u32(mul_i32(load_i32(memory_at_0.data, add_i32(loc_0, 336)), 3), 2) then
				break
			end
			reg_0 = FUNC_LIST[126](loc_2, loc_1)
			if reg_0 ~= 0 then
				break
			end
			FUNC_LIST[127](loc_2)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				while true do
					reg_0 = FUNC_LIST[128](loc_2, loc_1)
					loc_2 = reg_0
					if load_i32(memory_at_0.data, loc_2 + 8) ~= 0 then
						break
					end
					store_i32(memory_at_0.data, loc_2 + 8, load_i32(memory_at_0.data, loc_0 + 340))
					if band_i32(load_i32_u8(memory_at_0.data, loc_0 + 408), 1) == 0 then
						break
					end
					while true do
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 360))
						if loc_3 == load_i32(memory_at_0.data, add_i32(loc_0, 364)) then
							break
						end
						store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, loc_1))
						store_i32(memory_at_0.data, loc_0 + 360, add_i32(loc_3, 8))
						reg_0 = load_i32(memory_at_0.data, loc_2 + 8)
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_4 = add_i32(loc_0, 356)
					loc_5 = load_i32(memory_at_0.data, loc_4)
					loc_3 = sub_i32(loc_3, loc_5)
					loc_6 = shr_i32(loc_3, 3)
					loc_7 = add_i32(loc_6, 1)
					if loc_7 >= 536870912 then
						desired = 2
						break
					end
					while true do
						while true do
							loc_4 = shr_i32(loc_3, 2)
							loc_4 = (if loc_3 < 2147483640 then (if loc_4 < loc_7 then loc_7 else loc_4) else 536870911)
							if loc_4 ~= 0 then
								break
							end
							loc_7 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_4 >= 536870912 then
							desired = 1
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_4, 3))
						loc_7 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_6 = add_i32(loc_7, shl_i32(loc_6, 3))
					store_i64(memory_at_0.data, loc_6, load_i64(memory_at_0.data, loc_1))
					loc_1 = add_i32(loc_7, shl_i32(loc_4, 3))
					loc_4 = add_i32(loc_6, 8)
					while true do
						if lt_i32(loc_3, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_7, loc_5, loc_3)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 364, loc_1)
					store_i32(memory_at_0.data, loc_0 + 360, loc_4)
					store_i32(memory_at_0.data, loc_0 + 356, loc_7)
					if loc_5 == 0 then
						break
					end
					FUNC_LIST[1463](loc_5)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				reg_0 = load_i32(memory_at_0.data, loc_2 + 8)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[129](loc_4)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[126] = --[[ 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> >::find(Luau::BytecodeBuilder::StringRef const&) const ]] function(loc_0, loc_1)
	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_2 = 0
		while true do
			if load_i32(memory_at_0.data, loc_0 + 8) == 0 then
				break
			end
			loc_3 = load_i32(memory_at_0.data, loc_0 + 12)
			while true do
				while true do
					loc_4 = load_i32(memory_at_0.data, loc_1)
					if loc_4 == 0 then
						break
					end
					if loc_3 == 0 then
						desired = 2
						break
					end
					loc_5 = load_i32(memory_at_0.data, loc_1 + 4)
					if loc_5 ~= load_i32(memory_at_0.data, add_i32(loc_0, 16)) then
						desired = 2
						break
					end
					reg_0 = FUNC_LIST[1345](loc_4, loc_3, loc_5)
					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
				if loc_3 == 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = add_i32(load_i32(memory_at_0.data, loc_0 + 4), 4294967295)
			reg_0 = FUNC_LIST[1219](loc_4, load_i32(memory_at_0.data, loc_1 + 4))
			loc_4 = reg_0
			loc_6 = load_i32(memory_at_0.data, loc_1)
			loc_7 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_8 = bor_i32((if loc_6 == 0 then 1 else 0), (if loc_7 == 0 then 1 else 0))
			loc_9 = load_i32(memory_at_0.data, add_i32(loc_0, 16))
			loc_10 = load_i32(memory_at_0.data, loc_1 + 4)
			loc_1 = load_i32(memory_at_0.data, loc_0)
			loc_0 = 0
			while true do
				while true do
					while true do
						while true do
							loc_4 = band_i32(loc_4, loc_3)
							loc_5 = mul_i32(loc_4, 12)
							loc_2 = add_i32(loc_1, loc_5)
							loc_11 = load_i32(memory_at_0.data, loc_2)
							if loc_11 == 0 then
								break
							end
							while true do
								if loc_6 == 0 then
									break
								end
								if load_i32(memory_at_0.data, add_i32(loc_1, loc_5) + 4) ~= loc_10 then
									break
								end
								reg_0 = FUNC_LIST[1345](loc_11, loc_6, loc_10)
								if reg_0 == 0 then
									desired = 1
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_7 == 0 then
								desired = 4
								break
							end
							if load_i32(memory_at_0.data, add_i32(loc_1, loc_5) + 4) ~= loc_9 then
								desired = 4
								break
							end
							reg_0 = FUNC_LIST[1345](loc_11, loc_7, loc_9)
							if reg_0 ~= 0 then
								desired = 4
								break
							end
							reg_0 = 0
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_8 ~= 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_0 = add_i32(loc_0, 1)
					loc_4 = add_i32(loc_0, loc_4)
					if loc_0 <= loc_3 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				reg_0 = 0
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_2 = (if loc_6 ~= 0 then 0 else loc_2)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		reg_0 = loc_2
		break
	end
	return reg_0
end
FUNC_LIST[127] = --[[ 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(loc_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 loc_11 = 0
	local reg_0
	local desired
	while true do
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_1
		loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
		loc_3 = 0
		store_i32(memory_at_0.data, loc_1 + 16, 0)
		store_i64(memory_at_0.data, loc_1 + 8, i64_ZERO)
		loc_4 = load_i64(memory_at_0.data, loc_0 + 12)
		store_i64(memory_at_0.data, loc_1 + 20, loc_4)
		loc_5 = 0
		while true do
			loc_6 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
			if loc_6 == 0 then
				break
			end
			reg_0 = FUNC_LIST[1461](mul_i32(loc_6, 12))
			loc_5 = reg_0
			store_i32(memory_at_0.data, loc_1 + 12, loc_6)
			store_i32(memory_at_0.data, loc_1 + 8, loc_5)
			loc_7 = band_i32(loc_6, 2)
			loc_4 = load_i64(memory_at_0.data, loc_0 + 12)
			loc_8 = 0
			loc_9 = 0
			while true do
				if add_i32(loc_6, 4294967295) < 3 then
					break
				end
				loc_10 = band_i32(loc_6, 4294967292)
				loc_9 = 0
				loc_2 = 0
				while true do
					loc_11 = add_i32(loc_5, mul_i32(loc_9, 12))
					store_i32(memory_at_0.data, loc_11 + 8, 0)
					store_i64(memory_at_0.data, loc_11, loc_4)
					loc_11 = add_i32(loc_5, mul_i32(bor_i32(loc_9, 1), 12))
					store_i32(memory_at_0.data, loc_11 + 8, 0)
					store_i64(memory_at_0.data, loc_11, loc_4)
					loc_11 = add_i32(loc_5, mul_i32(bor_i32(loc_9, 2), 12))
					store_i32(memory_at_0.data, loc_11 + 8, 0)
					store_i64(memory_at_0.data, loc_11, loc_4)
					loc_11 = add_i32(loc_5, mul_i32(bor_i32(loc_9, 3), 12))
					store_i32(memory_at_0.data, loc_11 + 8, 0)
					store_i64(memory_at_0.data, loc_11, loc_4)
					loc_9 = add_i32(loc_9, 4)
					loc_2 = add_i32(loc_2, 4)
					if loc_2 ~= loc_10 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
			while true do
				if loc_7 == 0 then
					break
				end
				while true do
					loc_2 = add_i32(loc_5, mul_i32(loc_9, 12))
					store_i32(memory_at_0.data, loc_2 + 8, 0)
					store_i64(memory_at_0.data, loc_2, loc_4)
					loc_9 = add_i32(loc_9, 1)
					loc_8 = add_i32(loc_8, 1)
					if loc_8 ~= loc_7 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_5 = wrap_i32_i64(loc_4)
			loc_9 = 0
			while true do
				while true do
					while true do
						while true do
							loc_11 = mul_i32(loc_9, 12)
							loc_8 = add_i32(load_i32(memory_at_0.data, loc_0), loc_11)
							loc_7 = load_i32(memory_at_0.data, loc_8)
							if loc_7 == 0 then
								break
							end
							if loc_5 == 0 then
								desired = 4
								break
							end
							loc_10 = load_i32(memory_at_0.data, loc_8 + 4)
							if loc_10 ~= load_i32(memory_at_0.data, loc_0 + 16) then
								desired = 4
								break
							end
							reg_0 = FUNC_LIST[1345](loc_7, loc_5, loc_10)
							if reg_0 == 0 then
								desired = 3
								break
							end
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_5 == 0 then
							desired = 3
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					reg_0 = FUNC_LIST[128](add_i32(loc_1, 8), loc_8)
					loc_5 = reg_0
					loc_8 = add_i32(load_i32(memory_at_0.data, loc_0), loc_11)
					store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_8))
					store_i32(memory_at_0.data, loc_5 + 8, load_i32(memory_at_0.data, loc_8 + 8))
					loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				while true do
					loc_9 = add_i32(loc_9, 1)
					if loc_9 < loc_2 then
						break
					end
					loc_6 = load_i32(memory_at_0.data, loc_1 + 12)
					loc_5 = load_i32(memory_at_0.data, loc_1 + 8)
					loc_3 = loc_2
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		loc_9 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_5)
		store_i32(memory_at_0.data, loc_1 + 8, loc_9)
		store_i32(memory_at_0.data, loc_0 + 4, loc_6)
		store_i32(memory_at_0.data, loc_1 + 12, loc_3)
		while true do
			if loc_9 == 0 then
				break
			end
			FUNC_LIST[1463](loc_9)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_1, 32)
		break
	end
end
FUNC_LIST[128] = --[[ 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(loc_0, loc_1)
	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_2 = add_i32(load_i32(memory_at_0.data, loc_0 + 4), 4294967295)
		reg_0 = FUNC_LIST[1219](load_i32(memory_at_0.data, loc_1), load_i32(memory_at_0.data, loc_1 + 4))
		loc_3 = reg_0
		loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 16))
		loc_5 = load_i32(memory_at_0.data, loc_1 + 4)
		loc_6 = load_i32(memory_at_0.data, loc_1)
		loc_7 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_9 = 0
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_3 = band_i32(loc_3, loc_2)
							loc_10 = mul_i32(loc_3, 12)
							loc_11 = add_i32(loc_8, loc_10)
							loc_12 = load_i32(memory_at_0.data, loc_11)
							if loc_12 == 0 then
								break
							end
							while true do
								if loc_7 == 0 then
									break
								end
								if load_i32(memory_at_0.data, add_i32(loc_8, loc_10) + 4) ~= loc_4 then
									break
								end
								reg_0 = FUNC_LIST[1345](loc_12, loc_7, loc_4)
								if reg_0 == 0 then
									desired = 1
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_6 == 0 then
								desired = 4
								break
							end
							if load_i32(memory_at_0.data, add_i32(loc_8, loc_10) + 4) ~= loc_5 then
								desired = 4
								break
							end
							reg_0 = FUNC_LIST[1345](loc_12, loc_6, loc_5)
							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
						if loc_7 == 0 then
							desired = 1
							break
						end
						if loc_6 == 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_9 = add_i32(loc_9, 1)
					loc_3 = add_i32(loc_9, loc_3)
					if loc_9 <= loc_2 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_11 = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = loc_11
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i64(memory_at_0.data, loc_11, load_i64(memory_at_0.data, loc_1))
		store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
		reg_0 = loc_11
		break
	end
	return reg_0
end
FUNC_LIST[129] = --[[ std::__2::vector<Luau::BytecodeBuilder::StringRef, std::__2::allocator<Luau::BytecodeBuilder::StringRef> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[130] = --[[ Luau::BytecodeBuilder::addConstantNil() ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	while true do
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_1
		store_i64(memory_at_0.data, add_i32(add_i32(loc_1, 16), 8), i64_ZERO)
		store_i64(memory_at_0.data, loc_1 + 16, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_1, 8), i64_ZERO)
		store_i64(memory_at_0.data, loc_1, i64_ZERO)
		reg_0 = FUNC_LIST[122](loc_0, loc_1, add_i32(loc_1, 16))
		loc_0 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_1, 32)
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[131] = --[[ Luau::BytecodeBuilder::addConstantBoolean(bool) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = add_i32(loc_2, 24)
		store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, 0 + 15000))
		store_i32_n8(memory_at_0.data, loc_3, loc_1)
		store_i64(memory_at_0.data, loc_2 + 16, load_i64(memory_at_0.data, 0 + 14992))
		store_i64(memory_at_0.data, loc_2 + 8, extend_i64_u32(loc_1))
		store_i32(memory_at_0.data, loc_2, 1)
		reg_0 = FUNC_LIST[122](loc_0, loc_2, add_i32(loc_2, 16))
		loc_1 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		reg_0 = loc_1
		break
	end
	return reg_0
end
FUNC_LIST[132] = --[[ Luau::BytecodeBuilder::addConstantNumber(double) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		store_f64(memory_at_0.data, loc_2 + 24, loc_1)
		store_i64(memory_at_0.data, loc_2 + 16, i64_from_u32(2, 0))
		store_f64(memory_at_0.data, loc_2 + 8, loc_1)
		store_i64(memory_at_0.data, loc_2, i64_from_u32(2, 0))
		reg_0 = FUNC_LIST[122](loc_0, loc_2, add_i32(loc_2, 16))
		loc_0 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[133] = --[[ Luau::BytecodeBuilder::addConstantString(Luau::BytecodeBuilder::StringRef) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = 0
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i64(memory_at_0.data, loc_1)
		store_i64(memory_at_0.data, loc_2, loc_3)
		store_i64(memory_at_0.data, loc_2 + 40, loc_3)
		reg_0 = FUNC_LIST[125](loc_0, loc_2)
		loc_1 = reg_0
		loc_4 = add_i32(loc_2, 32)
		store_i64(memory_at_0.data, loc_4, load_i64(memory_at_0.data, 0 + 15016))
		store_i32(memory_at_0.data, loc_4, loc_1)
		store_i64(memory_at_0.data, loc_2 + 24, load_i64(memory_at_0.data, 0 + 15008))
		store_i64(memory_at_0.data, loc_2 + 16, extend_i64_u32(loc_1))
		store_i32(memory_at_0.data, loc_2 + 8, 3)
		reg_0 = FUNC_LIST[122](loc_0, add_i32(loc_2, 8), add_i32(loc_2, 24))
		loc_0 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_2, 48)
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[134] = --[[ Luau::BytecodeBuilder::addImport(unsigned int) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = add_i32(loc_2, 24)
		store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, 0 + 15032))
		store_i32(memory_at_0.data, loc_3, loc_1)
		store_i64(memory_at_0.data, loc_2 + 16, load_i64(memory_at_0.data, 0 + 15024))
		store_i64(memory_at_0.data, loc_2 + 8, extend_i64_u32(loc_1))
		store_i32(memory_at_0.data, loc_2, 4)
		reg_0 = FUNC_LIST[122](loc_0, loc_2, add_i32(loc_2, 16))
		loc_1 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		reg_0 = loc_1
		break
	end
	return reg_0
end
FUNC_LIST[135] = --[[ Luau::BytecodeBuilder::addConstantTable(Luau::BytecodeBuilder::TableShape const&) ]] function(loc_0, loc_1)
	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 reg_1
	local desired
	while true do
		while true do
			loc_2 = add_i32(loc_0, 136)
			reg_0 = FUNC_LIST[136](loc_2, loc_1)
			loc_3 = reg_0
			if loc_3 == 0 then
				break
			end
			reg_0 = load_i32(memory_at_0.data, loc_3 + 132)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_3 = 4294967295
		while true do
			while true do
				while true do
					while true do
						loc_4 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 48)), load_i32(memory_at_0.data, loc_0 + 44))
						if loc_4 > 134217712 then
							break
						end
						loc_3 = shr_i32(loc_4, 4)
						loc_4 = div_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 84)), load_i32(memory_at_0.data, loc_0 + 80)), 132)
						while true do
							if load_i32(memory_at_0.data, add_i32(loc_0, 144)) < shr_u32(mul_i32(load_i32(memory_at_0.data, add_i32(loc_0, 140)), 3), 2) then
								break
							end
							reg_0 = FUNC_LIST[136](loc_2, loc_1)
							if reg_0 ~= 0 then
								break
							end
							FUNC_LIST[137](loc_2)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						reg_0 = FUNC_LIST[138](loc_2, loc_1)
						store_i32(memory_at_0.data, reg_0 + 132, loc_3)
						while true do
							while true do
								loc_2 = load_i32(memory_at_0.data, loc_0 + 84)
								if loc_2 == load_i32(memory_at_0.data, add_i32(loc_0, 88)) then
									break
								end
								reg_1 = FUNC_LIST[1224](loc_2, loc_1, 132)
								store_i32(memory_at_0.data, loc_0 + 84, add_i32(reg_1, 132))
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_5 = add_i32(loc_0, 80)
							loc_6 = load_i32(memory_at_0.data, loc_5)
							loc_7 = sub_i32(loc_2, loc_6)
							loc_2 = div_i32(loc_7, 132)
							loc_8 = add_i32(loc_2, 1)
							if loc_8 >= 32537632 then
								desired = 3
								break
							end
							while true do
								while true do
									loc_5 = shl_i32(loc_2, 1)
									loc_8 = (if loc_2 < 16268815 then (if loc_5 < loc_8 then loc_8 else loc_5) else 32537631)
									if loc_8 ~= 0 then
										break
									end
									loc_5 = 0
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if loc_8 >= 32537632 then
									desired = 2
									break
								end
								reg_0 = FUNC_LIST[1461](mul_i32(loc_8, 132))
								loc_5 = reg_0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							reg_0 = FUNC_LIST[1224](add_i32(loc_5, mul_i32(loc_2, 132)), loc_1, 132)
							loc_2 = reg_0
							loc_1 = add_i32(loc_2, mul_i32(div_i32(loc_7, 4294967164), 132))
							loc_8 = add_i32(loc_5, mul_i32(loc_8, 132))
							loc_2 = add_i32(loc_2, 132)
							while true do
								if lt_i32(loc_7, 1) then
									break
								end
								reg_0 = FUNC_LIST[1224](loc_1, loc_6, loc_7)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_0 + 88, loc_8)
							store_i32(memory_at_0.data, loc_0 + 84, loc_2)
							store_i32(memory_at_0.data, loc_0 + 80, loc_1)
							if loc_6 == 0 then
								break
							end
							FUNC_LIST[1463](loc_6)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							loc_1 = load_i32(memory_at_0.data, loc_0 + 48)
							if loc_1 == load_i32(memory_at_0.data, add_i32(loc_0, 52)) then
								break
							end
							store_i32(memory_at_0.data, loc_1 + 12, 0)
							store_i32(memory_at_0.data, loc_1 + 8, loc_4)
							store_i64(memory_at_0.data, loc_1, i64_from_u32(5, 0))
							store_i32(memory_at_0.data, loc_0 + 48, 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
						loc_7 = add_i32(loc_0, 44)
						loc_6 = load_i32(memory_at_0.data, loc_7)
						loc_1 = sub_i32(loc_1, loc_6)
						loc_8 = shr_i32(loc_1, 4)
						loc_2 = add_i32(loc_8, 1)
						if loc_2 >= 268435456 then
							desired = 1
							break
						end
						loc_7 = shr_i32(loc_1, 3)
						loc_2 = (if loc_1 < 2147483632 then (if loc_7 < loc_2 then loc_2 else loc_7) else 268435455)
						if loc_2 >= 268435456 then
							desired = 2
							break
						end
						loc_5 = shl_i32(loc_2, 4)
						reg_0 = FUNC_LIST[1461](loc_5)
						loc_7 = reg_0
						loc_2 = add_i32(loc_7, shl_i32(loc_8, 4))
						store_i32(memory_at_0.data, loc_2 + 12, 0)
						store_i32(memory_at_0.data, loc_2 + 8, loc_4)
						store_i64(memory_at_0.data, loc_2, i64_from_u32(5, 0))
						loc_4 = add_i32(loc_7, loc_5)
						loc_2 = add_i32(loc_2, 16)
						while true do
							if lt_i32(loc_1, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_7, loc_6, loc_1)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 52, loc_4)
						store_i32(memory_at_0.data, loc_0 + 48, loc_2)
						store_i32(memory_at_0.data, loc_0 + 44, loc_7)
						if loc_6 == 0 then
							break
						end
						FUNC_LIST[1463](loc_6)
						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
				FUNC_LIST[139](loc_5)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[124](loc_7)
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[136] = --[[ 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(loc_0, loc_1)
	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_2 = 0
		while true do
			if load_i32(memory_at_0.data, loc_0 + 8) == 0 then
				break
			end
			loc_3 = add_i32(loc_0, 12)
			while true do
				loc_4 = load_i32(memory_at_0.data, loc_1 + 128)
				loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 140))
				if loc_4 ~= loc_5 then
					break
				end
				reg_0 = FUNC_LIST[1345](loc_1, loc_3, shl_i32(loc_4, 2))
				if reg_0 == 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = load_i32(memory_at_0.data, loc_0 + 4)
			while true do
				while true do
					if loc_4 ~= 0 then
						break
					end
					loc_2 = 2166136261
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_7 = band_i32(loc_4, 3)
				loc_8 = 0
				while true do
					while true do
						if add_i32(loc_4, 4294967295) >= 3 then
							break
						end
						loc_2 = 2166136261
						loc_9 = 0
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_10 = band_i32(loc_4, 4294967292)
					loc_2 = 2166136261
					loc_9 = 0
					loc_11 = 0
					while true do
						loc_12 = shl_i32(loc_9, 2)
						loc_2 = mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, bor_i32(loc_12, 12))), mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, bor_i32(loc_12, 8))), mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, bor_i32(loc_12, 4))), mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, loc_12)), loc_2), 16777619)), 16777619)), 16777619)), 16777619)
						loc_9 = add_i32(loc_9, 4)
						loc_11 = add_i32(loc_11, 4)
						if loc_11 ~= loc_10 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_7 == 0 then
					break
				end
				while true do
					loc_2 = mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, shl_i32(loc_9, 2))), loc_2), 16777619)
					loc_9 = add_i32(loc_9, 1)
					loc_8 = add_i32(loc_8, 1)
					if loc_8 ~= loc_7 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_12 = add_i32(loc_6, 4294967295)
			loc_6 = shl_i32(loc_5, 2)
			loc_10 = shl_i32(loc_4, 2)
			loc_7 = load_i32(memory_at_0.data, loc_0)
			loc_9 = 0
			while true do
				while true do
					loc_11 = band_i32(loc_2, loc_12)
					loc_2 = add_i32(loc_7, mul_i32(loc_11, 136))
					loc_8 = load_i32(memory_at_0.data, loc_2 + 128)
					if loc_8 ~= loc_4 then
						break
					end
					reg_0 = FUNC_LIST[1345](loc_2, loc_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
				while true do
					while true do
						if loc_8 ~= loc_5 then
							break
						end
						reg_0 = FUNC_LIST[1345](loc_2, loc_3, 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
					loc_9 = add_i32(loc_9, 1)
					loc_2 = add_i32(loc_9, loc_11)
					if loc_9 <= loc_12 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_2 = 0
			break
		end
		reg_0 = loc_2
		break
	end
	return reg_0
end
FUNC_LIST[137] = --[[ 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(loc_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_1 = sub_i32(GLOBAL_LIST[0].value, 160)
		GLOBAL_LIST[0].value = loc_1
		loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
		loc_3 = 0
		store_i32(memory_at_0.data, loc_1 + 16, 0)
		store_i64(memory_at_0.data, loc_1 + 8, i64_ZERO)
		loc_4 = add_i32(loc_0, 12)
		reg_0 = FUNC_LIST[1224](add_i32(add_i32(loc_1, 8), 12), loc_4, 132)
		loc_5 = 0
		while true do
			loc_6 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
			if loc_6 == 0 then
				break
			end
			reg_0 = FUNC_LIST[1461](mul_i32(loc_6, 136))
			loc_5 = reg_0
			store_i32(memory_at_0.data, loc_1 + 12, loc_6)
			store_i32(memory_at_0.data, loc_1 + 8, loc_5)
			loc_7 = 0
			loc_2 = 0
			while true do
				reg_0 = FUNC_LIST[1224](add_i32(loc_5, mul_i32(loc_7, 136)), loc_4, 132)
				store_i32(memory_at_0.data, reg_0 + 132, 0)
				reg_0 = FUNC_LIST[1224](add_i32(loc_5, mul_i32(bor_i32(loc_7, 1), 136)), loc_4, 132)
				store_i32(memory_at_0.data, reg_0 + 132, 0)
				loc_7 = add_i32(loc_7, 2)
				loc_2 = add_i32(loc_2, 2)
				if loc_2 ~= loc_6 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_7 = 0
			while true do
				while true do
					while true do
						loc_6 = mul_i32(loc_7, 136)
						loc_5 = add_i32(load_i32(memory_at_0.data, loc_0), loc_6)
						loc_3 = load_i32(memory_at_0.data, loc_5 + 128)
						if loc_3 ~= load_i32(memory_at_0.data, loc_0 + 140) then
							break
						end
						reg_0 = FUNC_LIST[1345](loc_5, loc_4, shl_i32(loc_3, 2))
						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[138](add_i32(loc_1, 8), loc_5)
					loc_5 = add_i32(load_i32(memory_at_0.data, loc_0), loc_6)
					reg_0 = FUNC_LIST[1224](reg_0, loc_5, 132)
					store_i32(memory_at_0.data, reg_0 + 132, load_i32(memory_at_0.data, loc_5 + 132))
					loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_7 = add_i32(loc_7, 1)
				if loc_7 < loc_2 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = load_i32(memory_at_0.data, loc_1 + 12)
			loc_5 = load_i32(memory_at_0.data, loc_1 + 8)
			loc_3 = loc_2
			break
		end
		loc_7 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_5)
		store_i32(memory_at_0.data, loc_1 + 8, loc_7)
		store_i32(memory_at_0.data, loc_0 + 4, loc_6)
		store_i32(memory_at_0.data, loc_1 + 12, loc_3)
		while true do
			if loc_7 == 0 then
				break
			end
			FUNC_LIST[1463](loc_7)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_1, 160)
		break
	end
end
FUNC_LIST[138] = --[[ 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(loc_0, loc_1)
	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_2 = load_i32(memory_at_0.data, loc_0 + 4)
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_1 + 128)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 2166136261
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_5 = band_i32(loc_3, 3)
			loc_6 = 0
			while true do
				while true do
					if add_i32(loc_3, 4294967295) >= 3 then
						break
					end
					loc_4 = 2166136261
					loc_7 = 0
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = band_i32(loc_3, 4294967292)
				loc_4 = 2166136261
				loc_7 = 0
				loc_9 = 0
				while true do
					loc_10 = shl_i32(loc_7, 2)
					loc_4 = mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, bor_i32(loc_10, 12))), mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, bor_i32(loc_10, 8))), mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, bor_i32(loc_10, 4))), mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, loc_10)), loc_4), 16777619)), 16777619)), 16777619)), 16777619)
					loc_7 = add_i32(loc_7, 4)
					loc_9 = add_i32(loc_9, 4)
					if loc_9 ~= 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_5 == 0 then
				break
			end
			while true do
				loc_4 = mul_i32(bxor_i32(load_i32(memory_at_0.data, add_i32(loc_1, shl_i32(loc_7, 2))), loc_4), 16777619)
				loc_7 = add_i32(loc_7, 1)
				loc_6 = add_i32(loc_6, 1)
				if loc_6 ~= loc_5 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_10 = add_i32(loc_2, 4294967295)
		loc_11 = shl_i32(loc_3, 2)
		loc_2 = add_i32(loc_0, 12)
		loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 140))
		loc_12 = shl_i32(loc_5, 2)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_7 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_4, loc_10)
					loc_4 = add_i32(loc_8, mul_i32(loc_9, 136))
					loc_6 = load_i32(memory_at_0.data, loc_4 + 128)
					if loc_6 ~= loc_5 then
						break
					end
					reg_0 = FUNC_LIST[1345](loc_4, loc_2, loc_12)
					if reg_0 ~= 0 then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_4, loc_1, 132)
					loc_4 = reg_0
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					reg_0 = loc_4
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				while true do
					if loc_6 ~= loc_3 then
						break
					end
					reg_0 = FUNC_LIST[1345](loc_4, loc_1, loc_11)
					if reg_0 == 0 then
						desired = 1
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_7 = add_i32(loc_7, 1)
				loc_4 = add_i32(loc_7, loc_9)
				if loc_7 <= loc_10 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_4 = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		reg_0 = loc_4
		break
	end
	return reg_0
end
FUNC_LIST[139] = --[[ std::__2::vector<Luau::BytecodeBuilder::TableShape, std::__2::allocator<Luau::BytecodeBuilder::TableShape> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[140] = --[[ Luau::BytecodeBuilder::addConstantClosure(unsigned int) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = add_i32(loc_2, 24)
		store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, 0 + 15048))
		store_i32(memory_at_0.data, loc_3, loc_1)
		store_i64(memory_at_0.data, loc_2 + 16, load_i64(memory_at_0.data, 0 + 15040))
		store_i64(memory_at_0.data, loc_2 + 8, extend_i64_u32(loc_1))
		store_i32(memory_at_0.data, loc_2, 6)
		reg_0 = FUNC_LIST[122](loc_0, loc_2, add_i32(loc_2, 16))
		loc_1 = reg_0
		GLOBAL_LIST[0].value = add_i32(loc_2, 32)
		reg_0 = loc_1
		break
	end
	return reg_0
end
FUNC_LIST[141] = --[[ Luau::BytecodeBuilder::addChildFunction(unsigned int) ]] function(loc_0, loc_1)
	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
			while true do
				while true do
					while true do
						while true do
							loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 292))
							if loc_2 == 0 then
								break
							end
							loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 296))
							if loc_3 == loc_1 then
								break
							end
							loc_4 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 288)), 4294967295)
							loc_5 = load_i32(memory_at_0.data, loc_0 + 284)
							loc_6 = 0
							loc_7 = loc_1
							while true do
								loc_7 = band_i32(loc_7, loc_4)
								loc_8 = load_i32(memory_at_0.data, add_i32(loc_5, shl_i32(loc_7, 3)))
								if loc_8 == loc_1 then
									desired = 4
									break
								end
								if loc_8 == loc_3 then
									desired = 5
									break
								end
								loc_6 = add_i32(loc_6, 1)
								loc_7 = add_i32(loc_6, loc_7)
								if loc_6 <= loc_4 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_9 = 65535
						loc_3 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 60)), load_i32(memory_at_0.data, loc_0 + 56))
						if loc_3 > 131068 then
							desired = 1
							break
						end
						while true do
							loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 288))
							if loc_2 < shr_u32(mul_i32(loc_5, 3), 2) then
								break
							end
							loc_10 = add_i32(loc_0, 284)
							while true do
								if loc_2 == 0 then
									break
								end
								loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 296))
								if loc_2 == loc_1 then
									break
								end
								loc_4 = add_i32(loc_5, 4294967295)
								loc_9 = load_i32(memory_at_0.data, loc_10)
								loc_6 = 0
								loc_7 = loc_1
								while true do
									loc_8 = band_i32(loc_7, loc_4)
									loc_7 = load_i32(memory_at_0.data, add_i32(loc_9, shl_i32(loc_8, 3)))
									if loc_7 == loc_1 then
										desired = 5
										break
									end
									if loc_7 == loc_2 then
										desired = 6
										break
									end
									loc_6 = add_i32(loc_6, 1)
									loc_7 = add_i32(loc_6, loc_8)
									if loc_6 <= loc_4 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[142](loc_10)
							loc_5 = load_i32(memory_at_0.data, loc_0 + 288)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_9 = shr_u32(loc_3, 2)
						while true do
							while true do
								loc_8 = load_i32(memory_at_0.data, loc_0 + 284)
								loc_5 = add_i32(loc_5, 4294967295)
								loc_6 = band_i32(loc_5, loc_1)
								loc_3 = add_i32(loc_8, shl_i32(loc_6, 3))
								loc_4 = load_i32(memory_at_0.data, loc_3)
								loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 296))
								if loc_4 == loc_2 then
									break
								end
								loc_7 = 0
								while true do
									if loc_4 == loc_1 then
										desired = 5
										break
									end
									loc_7 = add_i32(loc_7, 1)
									loc_6 = band_i32(add_i32(loc_7, loc_6), loc_5)
									loc_3 = add_i32(loc_8, shl_i32(loc_6, 3))
									loc_4 = load_i32(memory_at_0.data, loc_3)
									if loc_4 ~= loc_2 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
							store_i32(memory_at_0.data, loc_3, loc_1)
							store_i32(memory_at_0.data, loc_0 + 292, add_i32(load_i32(memory_at_0.data, loc_0 + 292), 1))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32_n16(memory_at_0.data, add_i32(loc_8, shl_i32(loc_6, 3)) + 4, loc_9)
						while true do
							loc_6 = load_i32(memory_at_0.data, loc_0 + 60)
							if loc_6 == load_i32(memory_at_0.data, add_i32(loc_0, 64)) then
								break
							end
							store_i32(memory_at_0.data, loc_6, loc_1)
							store_i32(memory_at_0.data, loc_0 + 60, add_i32(loc_6, 4))
							desired = 1
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = add_i32(loc_0, 56)
						loc_7 = load_i32(memory_at_0.data, loc_8)
						loc_6 = sub_i32(loc_6, loc_7)
						loc_3 = shr_i32(loc_6, 2)
						loc_4 = add_i32(loc_3, 1)
						if loc_4 >= 1073741824 then
							desired = 3
							break
						end
						while true do
							while true do
								loc_8 = shr_i32(loc_6, 1)
								loc_8 = (if loc_6 < 2147483644 then (if loc_8 < loc_4 then loc_4 else loc_8) else 1073741823)
								if loc_8 ~= 0 then
									break
								end
								loc_4 = 0
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_8 >= 1073741824 then
								desired = 2
								break
							end
							reg_0 = FUNC_LIST[1461](shl_i32(loc_8, 2))
							loc_4 = reg_0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_3 = add_i32(loc_4, shl_i32(loc_3, 2))
						store_i32(memory_at_0.data, loc_3, loc_1)
						loc_1 = add_i32(loc_4, shl_i32(loc_8, 2))
						loc_8 = add_i32(loc_3, 4)
						while true do
							if lt_i32(loc_6, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_4, loc_7, loc_6)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 64, loc_1)
						store_i32(memory_at_0.data, loc_0 + 60, loc_8)
						store_i32(memory_at_0.data, loc_0 + 56, loc_4)
						if loc_7 == 0 then
							desired = 1
							break
						end
						FUNC_LIST[1463](loc_7)
						desired = 1
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_9 = load_i32_u16(memory_at_0.data, add_i32(loc_5, shl_i32(loc_7, 3)) + 4)
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[143](loc_8)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		reg_0 = shr_i32(shl_i32(loc_9, 16), 16)
		break
	end
	return reg_0
end
FUNC_LIST[142] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 3)
					loc_12 = add_i32(loc_4, loc_11)
					store_i32_n16(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 8))
					store_i32_n16(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i32_n16(memory_at_0.data, loc_12 + 4, 0)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 24))
					store_i32_n16(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 3))
					store_i32_n16(memory_at_0.data, loc_11 + 4, 0)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_13 = load_i32(memory_at_0.data, loc_0)
		while true do
			while true do
				while true do
					if loc_2 == 0 then
						break
					end
					loc_6 = add_i32(loc_3, 4294967295)
					loc_12 = 0
					while true do
						while true do
							loc_9 = add_i32(loc_13, shl_i32(loc_12, 3))
							loc_8 = load_i32(memory_at_0.data, loc_9)
							if loc_8 == loc_5 then
								break
							end
							while true do
								while true do
									loc_5 = band_i32(loc_8, loc_6)
									loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
									loc_7 = load_i32(memory_at_0.data, loc_10)
									if loc_7 == loc_1 then
										break
									end
									loc_11 = 0
									if loc_7 == loc_8 then
										desired = 6
										break
									end
									while true do
										loc_11 = add_i32(loc_11, 1)
										loc_5 = band_i32(add_i32(loc_11, loc_5), loc_6)
										loc_10 = add_i32(loc_4, shl_i32(loc_5, 3))
										loc_7 = load_i32(memory_at_0.data, loc_10)
										if loc_7 == loc_1 then
											desired = 7
											break
										end
										if loc_7 == loc_8 then
											desired = 6
											break
										end
										continue
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									error("out of code bounds")
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								store_i32(memory_at_0.data, loc_10, loc_8)
								loc_8 = load_i32(memory_at_0.data, loc_9)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_10, loc_8)
							store_i32_n16(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 3)) + 4, load_i32_u16(memory_at_0.data, loc_9 + 4))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						while true do
							loc_12 = add_i32(loc_12, 1)
							if loc_12 ~= loc_2 then
								break
							end
							store_i32(memory_at_0.data, loc_0 + 4, loc_3)
							store_i32(memory_at_0.data, loc_0, loc_4)
							desired = 2
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
						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
				store_i32(memory_at_0.data, loc_0 + 4, loc_3)
				store_i32(memory_at_0.data, loc_0, loc_4)
				if loc_13 == 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1463](loc_13)
			break
		end
		break
	end
end
FUNC_LIST[143] = --[[ std::__2::vector<unsigned int, std::__2::allocator<unsigned int> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[144] = --[[ Luau::BytecodeBuilder::emitABC(LuauOpcode, unsigned char, unsigned char, unsigned char) ]] function(loc_0, loc_1, loc_2, loc_3, loc_4)
	local loc_5 = 0
	local loc_6 = 0
	local reg_0
	local desired
	while true do
		loc_1 = bor_i32(bor_i32(bor_i32(shl_i32(loc_2, 8), loc_1), shl_i32(loc_3, 16)), shl_i32(loc_4, 24))
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 24))
							if loc_4 == load_i32(memory_at_0.data, add_i32(loc_0, 28)) then
								break
							end
							store_i32(memory_at_0.data, loc_4, loc_1)
							store_i32(memory_at_0.data, loc_0 + 24, add_i32(loc_4, 4))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_5 = add_i32(loc_0, 20)
						loc_3 = load_i32(memory_at_0.data, loc_5)
						loc_4 = sub_i32(loc_4, loc_3)
						loc_6 = shr_i32(loc_4, 2)
						loc_2 = add_i32(loc_6, 1)
						if loc_2 >= 1073741824 then
							desired = 3
							break
						end
						while true do
							while true do
								loc_5 = shr_i32(loc_4, 1)
								loc_5 = (if loc_4 < 2147483644 then (if loc_5 < loc_2 then loc_2 else loc_5) else 1073741823)
								if loc_5 ~= 0 then
									break
								end
								loc_2 = 0
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_5 >= 1073741824 then
								desired = 2
								break
							end
							reg_0 = FUNC_LIST[1461](shl_i32(loc_5, 2))
							loc_2 = reg_0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = add_i32(loc_2, shl_i32(loc_6, 2))
						store_i32(memory_at_0.data, loc_6, loc_1)
						loc_1 = add_i32(loc_2, shl_i32(loc_5, 2))
						loc_5 = add_i32(loc_6, 4)
						while true do
							if lt_i32(loc_4, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_2, loc_3, loc_4)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 28, loc_1)
						store_i32(memory_at_0.data, loc_0 + 24, loc_5)
						store_i32(memory_at_0.data, loc_0 + 20, loc_2)
						if loc_3 == 0 then
							break
						end
						FUNC_LIST[1463](loc_3)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
						if loc_4 == load_i32(memory_at_0.data, add_i32(loc_0, 40)) then
							break
						end
						store_i32(memory_at_0.data, loc_4, load_i32(memory_at_0.data, loc_0 + 304))
						store_i32(memory_at_0.data, loc_0 + 36, add_i32(loc_4, 4))
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_3 = add_i32(loc_0, 32)
					loc_2 = load_i32(memory_at_0.data, loc_3)
					loc_4 = sub_i32(loc_4, loc_2)
					loc_5 = shr_i32(loc_4, 2)
					loc_1 = add_i32(loc_5, 1)
					if loc_1 >= 1073741824 then
						desired = 1
						break
					end
					while true do
						while true do
							loc_3 = shr_i32(loc_4, 1)
							loc_3 = (if loc_4 < 2147483644 then (if loc_3 < loc_1 then loc_1 else loc_3) else 1073741823)
							if loc_3 ~= 0 then
								break
							end
							loc_1 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_3 >= 1073741824 then
							desired = 2
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 2))
						loc_1 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_5 = add_i32(loc_1, shl_i32(loc_5, 2))
					store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_0 + 304))
					loc_3 = add_i32(loc_1, shl_i32(loc_3, 2))
					loc_5 = add_i32(loc_5, 4)
					while true do
						if lt_i32(loc_4, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_1, loc_2, loc_4)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 40, loc_3)
					store_i32(memory_at_0.data, loc_0 + 36, loc_5)
					store_i32(memory_at_0.data, loc_0 + 32, loc_1)
					while true do
						if loc_2 == 0 then
							break
						end
						FUNC_LIST[1463](loc_2)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[143](loc_5)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[145](loc_3)
		error("out of code bounds")
	end
end
FUNC_LIST[145] = --[[ std::__2::vector<int, std::__2::allocator<int> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[146] = --[[ Luau::BytecodeBuilder::emitAD(LuauOpcode, unsigned char, short) ]] function(loc_0, loc_1, loc_2, loc_3)
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local reg_0
	local desired
	while true do
		loc_2 = bor_i32(bor_i32(shl_i32(loc_2, 8), loc_1), shl_i32(loc_3, 16))
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_1 = load_i32(memory_at_0.data, add_i32(loc_0, 24))
							if loc_1 == load_i32(memory_at_0.data, add_i32(loc_0, 28)) then
								break
							end
							store_i32(memory_at_0.data, loc_1, loc_2)
							store_i32(memory_at_0.data, loc_0 + 24, add_i32(loc_1, 4))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_4 = add_i32(loc_0, 20)
						loc_5 = load_i32(memory_at_0.data, loc_4)
						loc_1 = sub_i32(loc_1, loc_5)
						loc_6 = shr_i32(loc_1, 2)
						loc_3 = add_i32(loc_6, 1)
						if loc_3 >= 1073741824 then
							desired = 3
							break
						end
						while true do
							while true do
								loc_4 = shr_i32(loc_1, 1)
								loc_4 = (if loc_1 < 2147483644 then (if loc_4 < loc_3 then loc_3 else loc_4) else 1073741823)
								if loc_4 ~= 0 then
									break
								end
								loc_3 = 0
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_4 >= 1073741824 then
								desired = 2
								break
							end
							reg_0 = FUNC_LIST[1461](shl_i32(loc_4, 2))
							loc_3 = reg_0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = add_i32(loc_3, shl_i32(loc_6, 2))
						store_i32(memory_at_0.data, loc_6, loc_2)
						loc_2 = add_i32(loc_3, shl_i32(loc_4, 2))
						loc_4 = add_i32(loc_6, 4)
						while true do
							if lt_i32(loc_1, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_3, loc_5, loc_1)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 28, loc_2)
						store_i32(memory_at_0.data, loc_0 + 24, loc_4)
						store_i32(memory_at_0.data, loc_0 + 20, loc_3)
						if loc_5 == 0 then
							break
						end
						FUNC_LIST[1463](loc_5)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						loc_1 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
						if loc_1 == load_i32(memory_at_0.data, add_i32(loc_0, 40)) then
							break
						end
						store_i32(memory_at_0.data, loc_1, load_i32(memory_at_0.data, loc_0 + 304))
						store_i32(memory_at_0.data, loc_0 + 36, add_i32(loc_1, 4))
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_5 = add_i32(loc_0, 32)
					loc_3 = load_i32(memory_at_0.data, loc_5)
					loc_1 = sub_i32(loc_1, loc_3)
					loc_4 = shr_i32(loc_1, 2)
					loc_2 = add_i32(loc_4, 1)
					if loc_2 >= 1073741824 then
						desired = 1
						break
					end
					while true do
						while true do
							loc_5 = shr_i32(loc_1, 1)
							loc_5 = (if loc_1 < 2147483644 then (if loc_5 < loc_2 then loc_2 else loc_5) else 1073741823)
							if loc_5 ~= 0 then
								break
							end
							loc_2 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_5 >= 1073741824 then
							desired = 2
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_5, 2))
						loc_2 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_4 = add_i32(loc_2, shl_i32(loc_4, 2))
					store_i32(memory_at_0.data, loc_4, load_i32(memory_at_0.data, loc_0 + 304))
					loc_5 = add_i32(loc_2, shl_i32(loc_5, 2))
					loc_4 = add_i32(loc_4, 4)
					while true do
						if lt_i32(loc_1, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_2, loc_3, loc_1)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 40, loc_5)
					store_i32(memory_at_0.data, loc_0 + 36, loc_4)
					store_i32(memory_at_0.data, loc_0 + 32, loc_2)
					while true do
						if loc_3 == 0 then
							break
						end
						FUNC_LIST[1463](loc_3)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[143](loc_4)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[145](loc_5)
		error("out of code bounds")
	end
end
FUNC_LIST[147] = --[[ Luau::BytecodeBuilder::emitAux(unsigned int) ]] function(loc_0, loc_1)
	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
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 24))
							if loc_2 == load_i32(memory_at_0.data, add_i32(loc_0, 28)) then
								break
							end
							store_i32(memory_at_0.data, loc_2, loc_1)
							store_i32(memory_at_0.data, loc_0 + 24, add_i32(loc_2, 4))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_3 = add_i32(loc_0, 20)
						loc_4 = load_i32(memory_at_0.data, loc_3)
						loc_2 = sub_i32(loc_2, loc_4)
						loc_5 = shr_i32(loc_2, 2)
						loc_6 = add_i32(loc_5, 1)
						if loc_6 >= 1073741824 then
							desired = 3
							break
						end
						while true do
							while true do
								loc_3 = shr_i32(loc_2, 1)
								loc_3 = (if loc_2 < 2147483644 then (if loc_3 < loc_6 then loc_6 else loc_3) else 1073741823)
								if loc_3 ~= 0 then
									break
								end
								loc_6 = 0
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_3 >= 1073741824 then
								desired = 2
								break
							end
							reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 2))
							loc_6 = reg_0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_5 = add_i32(loc_6, shl_i32(loc_5, 2))
						store_i32(memory_at_0.data, loc_5, loc_1)
						loc_1 = add_i32(loc_6, shl_i32(loc_3, 2))
						loc_3 = add_i32(loc_5, 4)
						while true do
							if lt_i32(loc_2, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_6, loc_4, loc_2)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 28, loc_1)
						store_i32(memory_at_0.data, loc_0 + 24, loc_3)
						store_i32(memory_at_0.data, loc_0 + 20, loc_6)
						if loc_4 == 0 then
							break
						end
						FUNC_LIST[1463](loc_4)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
						if loc_2 == load_i32(memory_at_0.data, add_i32(loc_0, 40)) then
							break
						end
						store_i32(memory_at_0.data, loc_2, load_i32(memory_at_0.data, loc_0 + 304))
						store_i32(memory_at_0.data, loc_0 + 36, add_i32(loc_2, 4))
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_4 = add_i32(loc_0, 32)
					loc_6 = load_i32(memory_at_0.data, loc_4)
					loc_2 = sub_i32(loc_2, loc_6)
					loc_3 = shr_i32(loc_2, 2)
					loc_1 = add_i32(loc_3, 1)
					if loc_1 >= 1073741824 then
						desired = 1
						break
					end
					while true do
						while true do
							loc_4 = shr_i32(loc_2, 1)
							loc_4 = (if loc_2 < 2147483644 then (if loc_4 < loc_1 then loc_1 else loc_4) else 1073741823)
							if loc_4 ~= 0 then
								break
							end
							loc_1 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_4 >= 1073741824 then
							desired = 2
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_4, 2))
						loc_1 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_3 = add_i32(loc_1, shl_i32(loc_3, 2))
					store_i32(memory_at_0.data, loc_3, load_i32(memory_at_0.data, loc_0 + 304))
					loc_4 = add_i32(loc_1, shl_i32(loc_4, 2))
					loc_3 = add_i32(loc_3, 4)
					while true do
						if lt_i32(loc_2, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_1, loc_6, loc_2)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 40, loc_4)
					store_i32(memory_at_0.data, loc_0 + 36, loc_3)
					store_i32(memory_at_0.data, loc_0 + 32, loc_1)
					while true do
						if loc_6 == 0 then
							break
						end
						FUNC_LIST[1463](loc_6)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[143](loc_3)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[145](loc_4)
		error("out of code bounds")
	end
end
FUNC_LIST[148] = --[[ Luau::BytecodeBuilder::emitLabel() ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 24)), load_i32(memory_at_0.data, loc_0 + 20)), 2)
		break
	end
	return reg_0
end
FUNC_LIST[149] = --[[ Luau::BytecodeBuilder::patchJumpD(unsigned long, unsigned long) ]] function(loc_0, loc_1, loc_2)
	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
			while true do
				while true do
					while true do
						while true do
							loc_3 = add_i32(bxor_i32(loc_1, 4294967295), loc_2)
							if add_i32(loc_3, 32768) > 65535 then
								break
							end
							loc_4 = add_i32(load_i32(memory_at_0.data, loc_0 + 20), shl_i32(loc_1, 2))
							store_i32(memory_at_0.data, loc_4, bor_i32(load_i32(memory_at_0.data, loc_4), shl_i32(loc_3, 16)))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_5 = 0
						loc_4 = shr_i32(loc_3, 31)
						if bxor_i32(add_i32(loc_3, loc_4), loc_4) > 8388607 then
							desired = 3
							break
						end
						store_i32_n8(memory_at_0.data, loc_0 + 92, 1)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 72))
						loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 76))
						if loc_3 >= loc_5 then
							break
						end
						store_i64(memory_at_0.data, loc_3, bor_i64(shl_i64(extend_i64_u32(loc_2), i64_from_u32(32, 0)), extend_i64_u32(loc_1)))
						store_i32(memory_at_0.data, loc_0 + 72, add_i32(loc_3, 8))
						reg_0 = 1
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_6 = add_i32(loc_0, 68)
					loc_4 = load_i32(memory_at_0.data, loc_6)
					loc_7 = sub_i32(loc_3, loc_4)
					loc_8 = shr_i32(loc_7, 3)
					loc_3 = add_i32(loc_8, 1)
					if loc_3 >= 536870912 then
						desired = 2
						break
					end
					while true do
						while true do
							loc_5 = sub_i32(loc_5, loc_4)
							loc_6 = shr_i32(loc_5, 2)
							loc_5 = (if loc_5 < 2147483640 then (if loc_6 < loc_3 then loc_3 else loc_6) else 536870911)
							if loc_5 ~= 0 then
								break
							end
							loc_3 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_5 >= 536870912 then
							desired = 1
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_5, 3))
						loc_3 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_8 = add_i32(loc_3, shl_i32(loc_8, 3))
					store_i64(memory_at_0.data, loc_8, bor_i64(shl_i64(extend_i64_u32(loc_2), i64_from_u32(32, 0)), extend_i64_u32(loc_1)))
					loc_1 = add_i32(loc_3, shl_i32(loc_5, 3))
					loc_2 = add_i32(loc_8, 8)
					loc_5 = 1
					while true do
						if lt_i32(loc_7, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_3, loc_4, loc_7)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 76, loc_1)
					store_i32(memory_at_0.data, loc_0 + 72, loc_2)
					store_i32(memory_at_0.data, loc_0 + 68, loc_3)
					if loc_4 == 0 then
						break
					end
					FUNC_LIST[1463](loc_4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				reg_0 = loc_5
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[150](loc_6)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[150] = --[[ std::__2::vector<Luau::BytecodeBuilder::Jump, std::__2::allocator<Luau::BytecodeBuilder::Jump> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[151] = --[[ Luau::BytecodeBuilder::patchSkipC(unsigned long, unsigned long) ]] function(loc_0, loc_1, loc_2)
	local reg_0
	while true do
		while true do
			loc_2 = add_i32(bxor_i32(loc_1, 4294967295), loc_2)
			if loc_2 > 255 then
				break
			end
			loc_1 = add_i32(load_i32(memory_at_0.data, loc_0 + 20), shl_i32(loc_1, 2))
			store_i32(memory_at_0.data, loc_1, bor_i32(load_i32(memory_at_0.data, loc_1), shl_i32(loc_2, 24)))
			break
		end
		reg_0 = (if loc_2 < 256 then 1 else 0)
		break
	end
	return reg_0
end
FUNC_LIST[152] = --[[ Luau::BytecodeBuilder::setFunctionTypeInfo(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >) ]] function(loc_0, loc_1)
	local loc_2 = 0
	while true do
		loc_2 = add_i32(load_i32(memory_at_0.data, loc_0), mul_i32(load_i32(memory_at_0.data, loc_0 + 12), 72))
		loc_0 = add_i32(loc_2, 60)
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_2, 71)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0))
			break
		end
		store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_1))
		store_i32(memory_at_0.data, add_i32(loc_0, 8), load_i32(memory_at_0.data, add_i32(loc_1, 8)))
		store_i32_n8(memory_at_0.data, loc_1 + 11, 0)
		store_i32_n8(memory_at_0.data, loc_1, 0)
		break
	end
end
FUNC_LIST[153] = --[[ Luau::BytecodeBuilder::setDebugFunctionName(Luau::BytecodeBuilder::StringRef) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = i64_ZERO
	local loc_5 = 0
	local loc_6 = 0
	local reg_0
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i64(memory_at_0.data, loc_1)
		store_i64(memory_at_0.data, loc_2, loc_3)
		store_i64(memory_at_0.data, loc_2 + 24, loc_3)
		reg_0 = FUNC_LIST[125](loc_0, loc_2)
		loc_1 = reg_0
		store_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_0), mul_i32(load_i32(memory_at_0.data, loc_0 + 12), 72)) + 16, loc_1)
		while true do
			while true do
				if bor_i32(band_i32(load_i32(memory_at_0.data, add_i32(loc_0, 440)), 1), load_i32(memory_at_0.data, loc_0 + 436)) == 0 then
					break
				end
				loc_4 = shr_u64(loc_3, i64_from_u32(32, 0))
				loc_1 = wrap_i32_i64(loc_4)
				if loc_1 >= 4294967280 then
					desired = 1
					break
				end
				while true do
					while true do
						while true do
							if loc_1 < 11 then
								break
							end
							loc_5 = band_i32(add_i32(loc_1, 16), 4294967280)
							reg_0 = FUNC_LIST[1461](loc_5)
							loc_6 = reg_0
							store_i32(memory_at_0.data, loc_2 + 16, bor_i32(loc_5, 2147483648))
							store_i32(memory_at_0.data, loc_2 + 8, loc_6)
							store_i32(memory_at_0.data, loc_2 + 12, loc_1)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i64_n8(memory_at_0.data, loc_2 + 19, loc_4)
						loc_6 = add_i32(loc_2, 8)
						if loc_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[1224](loc_6, wrap_i32_i64(loc_3), loc_1)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32_n8(memory_at_0.data, add_i32(loc_6, loc_1), 0)
				loc_1 = add_i32(load_i32(memory_at_0.data, loc_0), mul_i32(load_i32(memory_at_0.data, loc_0 + 12), 72))
				loc_0 = add_i32(loc_1, 36)
				while true do
					if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 47)), 4294967295) then
						break
					end
					FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_2 + 8))
				store_i32(memory_at_0.data, add_i32(loc_0, 8), load_i32(memory_at_0.data, add_i32(add_i32(loc_2, 8), 8)))
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_2, 32)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[39](add_i32(loc_2, 8))
		error("out of code bounds")
	end
end
FUNC_LIST[154] = --[[ Luau::BytecodeBuilder::setDebugFunctionLineDefined(int) ]] function(loc_0, loc_1)
	while true do
		store_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_0), mul_i32(load_i32(memory_at_0.data, loc_0 + 12), 72)) + 20, loc_1)
		break
	end
end
FUNC_LIST[155] = --[[ Luau::BytecodeBuilder::setDebugLine(int) ]] function(loc_0, loc_1)
	while true do
		store_i32(memory_at_0.data, loc_0 + 304, loc_1)
		break
	end
end
FUNC_LIST[156] = --[[ Luau::BytecodeBuilder::pushDebugLocal(Luau::BytecodeBuilder::StringRef, unsigned char, unsigned int, unsigned int) ]] function(loc_0, loc_1, loc_2, loc_3, loc_4)
	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 = 0
	local loc_12 = 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_6 = load_i64(memory_at_0.data, loc_1)
		store_i64(memory_at_0.data, loc_5, loc_6)
		store_i64(memory_at_0.data, loc_5 + 8, loc_6)
		reg_0 = FUNC_LIST[125](loc_0, loc_5)
		loc_7 = reg_0
		while true do
			while true do
				while true do
					while true do
						loc_1 = load_i32(memory_at_0.data, add_i32(loc_0, 312))
						if loc_1 == load_i32(memory_at_0.data, add_i32(loc_0, 316)) then
							break
						end
						store_i32(memory_at_0.data, loc_1 + 12, loc_4)
						store_i32(memory_at_0.data, loc_1 + 8, loc_3)
						store_i32_n8(memory_at_0.data, loc_1 + 4, loc_2)
						store_i32(memory_at_0.data, loc_1, loc_7)
						store_i32(memory_at_0.data, loc_0 + 312, add_i32(loc_1, 16))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_8 = add_i32(loc_0, 308)
					loc_9 = load_i32(memory_at_0.data, loc_8)
					loc_10 = sub_i32(loc_1, loc_9)
					loc_11 = shr_i32(loc_10, 4)
					loc_1 = add_i32(loc_11, 1)
					if loc_1 >= 268435456 then
						desired = 2
						break
					end
					loc_8 = shr_i32(loc_10, 3)
					loc_1 = (if loc_10 < 2147483632 then (if loc_8 < loc_1 then loc_1 else loc_8) else 268435455)
					if loc_1 >= 268435456 then
						desired = 1
						break
					end
					loc_12 = shl_i32(loc_1, 4)
					reg_0 = FUNC_LIST[1461](loc_12)
					loc_8 = reg_0
					loc_1 = add_i32(loc_8, shl_i32(loc_11, 4))
					store_i32(memory_at_0.data, loc_1 + 12, loc_4)
					store_i32(memory_at_0.data, loc_1 + 8, loc_3)
					store_i32_n8(memory_at_0.data, loc_1 + 4, loc_2)
					store_i32(memory_at_0.data, loc_1, loc_7)
					loc_2 = add_i32(loc_8, loc_12)
					loc_1 = add_i32(loc_1, 16)
					while true do
						if lt_i32(loc_10, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_8, loc_9, loc_10)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 316, loc_2)
					store_i32(memory_at_0.data, loc_0 + 312, loc_1)
					store_i32(memory_at_0.data, loc_0 + 308, loc_8)
					if loc_9 == 0 then
						break
					end
					FUNC_LIST[1463](loc_9)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				GLOBAL_LIST[0].value = add_i32(loc_5, 16)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[157](loc_8)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[157] = --[[ std::__2::vector<Luau::BytecodeBuilder::DebugLocal, std::__2::allocator<Luau::BytecodeBuilder::DebugLocal> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[158] = --[[ Luau::BytecodeBuilder::pushDebugUpval(Luau::BytecodeBuilder::StringRef) ]] function(loc_0, loc_1)
	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 loc_8 = 0
	local reg_0
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i64(memory_at_0.data, loc_1)
		store_i64(memory_at_0.data, loc_2, loc_3)
		store_i64(memory_at_0.data, loc_2 + 8, loc_3)
		reg_0 = FUNC_LIST[125](loc_0, loc_2)
		loc_4 = reg_0
		while true do
			while true do
				while true do
					while true do
						loc_1 = load_i32(memory_at_0.data, add_i32(loc_0, 324))
						if loc_1 == load_i32(memory_at_0.data, add_i32(loc_0, 328)) then
							break
						end
						store_i32(memory_at_0.data, loc_1, loc_4)
						store_i32(memory_at_0.data, loc_0 + 324, add_i32(loc_1, 4))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_5 = add_i32(loc_0, 320)
					loc_6 = load_i32(memory_at_0.data, loc_5)
					loc_1 = sub_i32(loc_1, loc_6)
					loc_7 = shr_i32(loc_1, 2)
					loc_8 = add_i32(loc_7, 1)
					if loc_8 >= 1073741824 then
						desired = 2
						break
					end
					while true do
						while true do
							loc_5 = shr_i32(loc_1, 1)
							loc_5 = (if loc_1 < 2147483644 then (if loc_5 < loc_8 then loc_8 else loc_5) else 1073741823)
							if loc_5 ~= 0 then
								break
							end
							loc_8 = 0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_5 >= 1073741824 then
							desired = 1
							break
						end
						reg_0 = FUNC_LIST[1461](shl_i32(loc_5, 2))
						loc_8 = reg_0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_7 = add_i32(loc_8, shl_i32(loc_7, 2))
					store_i32(memory_at_0.data, loc_7, loc_4)
					loc_4 = add_i32(loc_8, shl_i32(loc_5, 2))
					loc_5 = add_i32(loc_7, 4)
					while true do
						if lt_i32(loc_1, 1) then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_8, loc_6, loc_1)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 328, loc_4)
					store_i32(memory_at_0.data, loc_0 + 324, loc_5)
					store_i32(memory_at_0.data, loc_0 + 320, loc_8)
					if loc_6 == 0 then
						break
					end
					FUNC_LIST[1463](loc_6)
					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[159](loc_5)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[159] = --[[ std::__2::vector<Luau::BytecodeBuilder::DebugUpval, std::__2::allocator<Luau::BytecodeBuilder::DebugUpval> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[160] = --[[ Luau::BytecodeBuilder::getInstructionCount() const ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 24)), load_i32(memory_at_0.data, loc_0 + 20)), 2)
		break
	end
	return reg_0
end
FUNC_LIST[161] = --[[ Luau::BytecodeBuilder::getDebugPC() const ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 24)), load_i32(memory_at_0.data, loc_0 + 20)), 2)
		break
	end
	return reg_0
end
FUNC_LIST[162] = --[[ Luau::BytecodeBuilder::addDebugRemark(char const*, ...) ]] function(loc_0, loc_1, loc_2)
	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_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 band_i32(load_i32_u8(memory_at_0.data, loc_0 + 408), 16) == 0 then
							break
						end
						loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 384))
						loc_5 = load_i32_u8(memory_at_0.data, add_i32(loc_0, 391))
						store_i32(memory_at_0.data, loc_3 + 12, loc_2)
						loc_6 = add_i32(loc_0, 380)
						FUNC_LIST[1216](loc_6, loc_1, loc_2)
						FUNC_LIST[1547](loc_6, 0)
						loc_1 = (if lt_i32(shr_i32(shl_i32(loc_5, 24), 24), 0) then loc_4 else loc_5)
						loc_4 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 24)), load_i32(memory_at_0.data, loc_0 + 20)), 2)
						while true do
							while true do
								loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 372))
								loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 376))
								if loc_2 >= loc_7 then
									break
								end
								store_i32(memory_at_0.data, loc_2 + 4, loc_1)
								store_i32(memory_at_0.data, loc_2, loc_4)
								store_i32(memory_at_0.data, loc_0 + 372, add_i32(loc_2, 8))
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_8 = add_i32(loc_0, 368)
							loc_5 = load_i32(memory_at_0.data, loc_8)
							loc_9 = sub_i32(loc_2, loc_5)
							loc_10 = shr_i32(loc_9, 3)
							loc_2 = add_i32(loc_10, 1)
							if loc_2 >= 536870912 then
								desired = 3
								break
							end
							while true do
								while true do
									loc_7 = sub_i32(loc_7, loc_5)
									loc_8 = shr_i32(loc_7, 2)
									loc_7 = (if loc_7 < 2147483640 then (if loc_8 < loc_2 then loc_2 else loc_8) else 536870911)
									if loc_7 ~= 0 then
										break
									end
									loc_2 = 0
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if loc_7 >= 536870912 then
									desired = 2
									break
								end
								reg_0 = FUNC_LIST[1461](shl_i32(loc_7, 3))
								loc_2 = reg_0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_10 = add_i32(loc_2, shl_i32(loc_10, 3))
							store_i32(memory_at_0.data, loc_10 + 4, loc_1)
							store_i32(memory_at_0.data, loc_10, loc_4)
							loc_4 = add_i32(loc_2, shl_i32(loc_7, 3))
							loc_7 = add_i32(loc_10, 8)
							while true do
								if lt_i32(loc_9, 1) then
									break
								end
								reg_0 = FUNC_LIST[1224](loc_2, loc_5, loc_9)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_0 + 376, loc_4)
							store_i32(memory_at_0.data, loc_0 + 372, loc_7)
							store_i32(memory_at_0.data, loc_0 + 368, loc_2)
							if loc_5 == 0 then
								break
							end
							FUNC_LIST[1463](loc_5)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = add_i32((if lt_i32(load_i32_i8(memory_at_0.data, loc_0 + 391), 0) then load_i32(memory_at_0.data, loc_0 + 380) else loc_6), loc_1)
						store_i32(memory_at_0.data, loc_3 + 8, loc_6)
						loc_1 = add_i32(loc_0, 304)
						while true do
							loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 428))
							if loc_2 >= load_i32(memory_at_0.data, add_i32(loc_0, 432)) then
								break
							end
							store_i32(memory_at_0.data, loc_2, load_i32(memory_at_0.data, loc_1))
							loc_5 = add_i32(loc_2, 4)
							reg_0 = FUNC_LIST[1383](loc_6)
							loc_1 = reg_0
							if loc_1 >= 4294967280 then
								desired = 1
								break
							end
							while true do
								while true do
									while true do
										if loc_1 < 11 then
											break
										end
										loc_4 = band_i32(add_i32(loc_1, 16), 4294967280)
										reg_0 = FUNC_LIST[1461](loc_4)
										loc_5 = reg_0
										store_i32(memory_at_0.data, add_i32(loc_2, 12), bor_i32(loc_4, 2147483648))
										store_i32(memory_at_0.data, loc_2 + 4, loc_5)
										store_i32(memory_at_0.data, add_i32(loc_2, 8), loc_1)
										desired = 7
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									store_i32_n8(memory_at_0.data, loc_5 + 11, loc_1)
									if loc_1 == 0 then
										desired = 6
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								reg_0 = FUNC_LIST[1224](loc_5, loc_6, loc_1)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32_n8(memory_at_0.data, add_i32(loc_5, loc_1), 0)
							store_i32(memory_at_0.data, loc_0 + 428, add_i32(loc_2, 16))
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						FUNC_LIST[163](add_i32(loc_0, 424), loc_1, add_i32(loc_3, 8))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_3, 16)
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[164](loc_8)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[39](loc_5)
		error("out of code bounds")
	end
end
FUNC_LIST[163] = --[[ void std::__2::vector<std::__2::pair<int, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > >, std::__2::allocator<std::__2::pair<int, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > > > >::__emplace_back_slow_path<int&, char const*>(int&, char const*&&) ]] function(loc_0, loc_1, loc_2)
	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 reg_1
	local desired
	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.data, loc_0)
							loc_4 = shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 4), loc_3), 4)
							loc_5 = add_i32(loc_4, 1)
							if loc_5 >= 268435456 then
								break
							end
							while true do
								while true do
									loc_3 = sub_i32(load_i32(memory_at_0.data, loc_0 + 8), loc_3)
									loc_6 = shr_i32(loc_3, 3)
									loc_7 = (if loc_3 < 2147483632 then (if loc_6 < loc_5 then loc_5 else loc_6) else 268435455)
									if loc_7 ~= 0 then
										break
									end
									loc_6 = 0
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if loc_7 >= 268435456 then
									desired = 4
									break
								end
								reg_0 = FUNC_LIST[1461](shl_i32(loc_7, 4))
								loc_6 = reg_0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_3 = add_i32(loc_6, shl_i32(loc_4, 4))
							store_i32(memory_at_0.data, loc_3, load_i32(memory_at_0.data, loc_1))
							loc_1 = add_i32(loc_3, 4)
							loc_2 = load_i32(memory_at_0.data, loc_2)
							reg_0 = FUNC_LIST[1383](loc_2)
							loc_5 = reg_0
							if loc_5 >= 4294967280 then
								desired = 3
								break
							end
							loc_7 = shl_i32(loc_7, 4)
							while true do
								while true do
									while true do
										if loc_5 < 11 then
											break
										end
										loc_8 = band_i32(add_i32(loc_5, 16), 4294967280)
										reg_1 = FUNC_LIST[1461](loc_8)
										loc_9 = reg_1
										store_i32(memory_at_0.data, loc_1, loc_9)
										loc_1 = add_i32(loc_6, shl_i32(loc_4, 4))
										store_i32(memory_at_0.data, add_i32(loc_1, 8), loc_5)
										store_i32(memory_at_0.data, add_i32(loc_1, 12), bor_i32(loc_8, 2147483648))
										loc_1 = loc_9
										desired = 7
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									store_i32_n8(memory_at_0.data, loc_1 + 11, loc_5)
									if loc_5 == 0 then
										desired = 6
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								reg_0 = FUNC_LIST[1224](loc_1, loc_2, loc_5)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = add_i32(loc_6, loc_7)
							store_i32_n8(memory_at_0.data, add_i32(loc_1, loc_5), 0)
							loc_4 = add_i32(loc_3, 16)
							loc_5 = load_i32(memory_at_0.data, loc_0 + 4)
							loc_6 = load_i32(memory_at_0.data, loc_0)
							if loc_5 == loc_6 then
								desired = 2
								break
							end
							while true do
								loc_3 = add_i32(loc_3, 4294967280)
								loc_5 = add_i32(loc_5, 4294967280)
								store_i32(memory_at_0.data, loc_3, load_i32(memory_at_0.data, loc_5))
								loc_1 = add_i32(loc_5, 12)
								store_i32(memory_at_0.data, add_i32(loc_3, 12), load_i32(memory_at_0.data, loc_1))
								store_i64(memory_at_0.data, loc_3 + 4, load_i64(memory_at_0.data, loc_5 + 4))
								store_i32(memory_at_0.data, loc_1, 0)
								store_i64(memory_at_0.data, loc_5 + 4, i64_ZERO)
								if loc_5 ~= loc_6 then
									continue
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_0 + 8, loc_7)
							loc_5 = load_i32(memory_at_0.data, loc_0 + 4)
							store_i32(memory_at_0.data, loc_0 + 4, loc_4)
							loc_6 = load_i32(memory_at_0.data, loc_0)
							store_i32(memory_at_0.data, loc_0, loc_3)
							if loc_5 == loc_6 then
								desired = 1
								break
							end
							while true do
								loc_3 = add_i32(loc_5, 4294967280)
								while true do
									if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_5, 4294967295)), 4294967295) then
										break
									end
									FUNC_LIST[1463](load_i32(memory_at_0.data, add_i32(loc_5, 4294967284)))
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
										continue
									end
									break
								end
								loc_5 = loc_3
								if loc_3 ~= loc_6 then
									continue
								end
								desired = 1
								break
							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[177](loc_0)
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[276]()
					error("out of code bounds")
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[39](loc_1)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 8, loc_7)
			store_i32(memory_at_0.data, loc_0 + 4, loc_4)
			store_i32(memory_at_0.data, loc_0, loc_3)
			break
		end
		while true do
			if loc_6 == 0 then
				break
			end
			FUNC_LIST[1463](loc_6)
			break
		end
		break
	end
end
FUNC_LIST[164] = --[[ std::__2::vector<std::__2::pair<unsigned int, unsigned int>, std::__2::allocator<std::__2::pair<unsigned int, unsigned int> > >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[165] = --[[ Luau::BytecodeBuilder::finalize() ]] function(loc_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_1 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_1
		while true do
			while true do
				while true do
					loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 336))
					if loc_2 ~= 0 then
						break
					end
					loc_3 = 0
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 348))
				loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 344))
				loc_6 = load_i32(memory_at_0.data, loc_0 + 332)
				loc_3 = 0
				while true do
					while true do
						while true do
							loc_7 = add_i32(loc_6, mul_i32(loc_3, 12))
							loc_8 = load_i32(memory_at_0.data, loc_7)
							if loc_8 == 0 then
								break
							end
							if loc_5 == 0 then
								desired = 2
								break
							end
							if load_i32(memory_at_0.data, loc_7 + 4) ~= loc_4 then
								desired = 2
								break
							end
							reg_0 = FUNC_LIST[1345](loc_8, loc_5, loc_4)
							if reg_0 ~= 0 then
								desired = 2
								break
							end
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_5 ~= 0 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_3 = add_i32(loc_3, 1)
					if loc_3 ~= loc_2 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_5 = 16
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_5 = 16
			if loc_3 == loc_2 then
				break
			end
			loc_9 = load_i32(memory_at_0.data, add_i32(loc_0, 348))
			loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 344))
			loc_6 = load_i32(memory_at_0.data, loc_0 + 332)
			loc_5 = 16
			while true do
				loc_5 = add_i32(add_i32(loc_5, load_i32(memory_at_0.data, add_i32(loc_6, mul_i32(loc_3, 12)) + 4)), 2)
				while true do
					loc_3 = add_i32(loc_3, 1)
					if loc_3 >= loc_2 then
						break
					end
					while true do
						while true do
							while true do
								loc_8 = add_i32(loc_6, mul_i32(loc_3, 12))
								loc_4 = load_i32(memory_at_0.data, loc_8)
								if loc_4 == 0 then
									break
								end
								if loc_7 == 0 then
									desired = 3
									break
								end
								if load_i32(memory_at_0.data, loc_8 + 4) ~= loc_9 then
									desired = 3
									break
								end
								reg_0 = FUNC_LIST[1345](loc_4, loc_7, loc_9)
								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
							if loc_7 ~= 0 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = add_i32(loc_3, 1)
						if loc_3 == loc_2 then
							desired = 1
							break
						end
						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
						continue
					end
					break
				end
				if loc_3 ~= loc_2 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_0)
			loc_7 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_3 == loc_7 then
				break
			end
			while true do
				loc_2 = load_i32_u8(memory_at_0.data, loc_3 + 11)
				loc_5 = add_i32((if lt_i32(shr_i32(shl_i32(loc_2, 24), 24), 0) then load_i32(memory_at_0.data, loc_3 + 4) else loc_2), loc_5)
				loc_3 = add_i32(loc_3, 72)
				if loc_3 ~= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_2 = add_i32(loc_0, 396)
		FUNC_LIST[1538](loc_2, loc_5)
		reg_0 = FUNC_LIST[1535](loc_2, 4)
		store_i32_n8(memory_at_0.data, loc_1 + 13, 1)
		reg_0 = FUNC_LIST[1541](loc_2, add_i32(loc_1, 13), 1)
		FUNC_LIST[166](loc_0, loc_2)
		loc_3 = div_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 4), load_i32(memory_at_0.data, loc_0)), 72)
		while true do
			loc_5 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_1 + 14, bor_i32(shl_i32(loc_5, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_2, add_i32(loc_1, 14), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_5 ~= 0 then
				continue
			end
			break
		end
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_0)
			loc_8 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_3 == loc_8 then
				break
			end
			while true do
				loc_5 = load_i32_u8(memory_at_0.data, loc_3 + 11)
				loc_7 = (if lt_i32(shr_i32(shl_i32(loc_5, 24), 24), 0) then 1 else 0)
				reg_0 = FUNC_LIST[1541](loc_2, (if loc_7 ~= 0 then load_i32(memory_at_0.data, loc_3) else loc_3), (if loc_7 ~= 0 then load_i32(memory_at_0.data, loc_3 + 4) else loc_5))
				loc_3 = add_i32(loc_3, 72)
				if loc_3 ~= loc_8 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_3 = load_i32(memory_at_0.data, loc_0 + 16)
		while true do
			loc_5 = (if loc_3 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_1 + 15, bor_i32(shl_i32(loc_5, 7), band_i32(loc_3, 127)))
			reg_0 = FUNC_LIST[1541](loc_2, add_i32(loc_1, 15), 1)
			loc_3 = shr_u32(loc_3, 7)
			if loc_5 ~= 0 then
				continue
			end
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_1, 16)
		break
	end
end
FUNC_LIST[166] = --[[ Luau::BytecodeBuilder::writeStringTable(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> >&) const ]] function(loc_0, loc_1)
	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 reg_1
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 340))
		loc_4 = 0
		store_i32(memory_at_0.data, loc_2 + 8, 0)
		store_i64(memory_at_0.data, loc_2, i64_ZERO)
		loc_5 = 0
		loc_6 = 0
		while true do
			while true do
				while true do
					while true do
						if loc_3 == 0 then
							break
						end
						if loc_3 >= 536870912 then
							desired = 3
							break
						end
						loc_3 = shl_i32(loc_3, 3)
						reg_1 = FUNC_LIST[1461](loc_3)
						loc_5 = reg_1
						store_i32(memory_at_0.data, loc_2, loc_5)
						loc_6 = add_i32(loc_5, loc_3)
						store_i32(memory_at_0.data, loc_2 + 8, loc_6)
						reg_0 = FUNC_LIST[1286](loc_5, 0, loc_3)
						store_i32(memory_at_0.data, loc_2 + 4, loc_6)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 336))
					if loc_7 == 0 then
						desired = 2
						break
					end
					loc_8 = load_i32(memory_at_0.data, add_i32(loc_0, 348))
					loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 344))
					loc_9 = load_i32(memory_at_0.data, loc_0 + 332)
					loc_4 = 0
					while true do
						while true do
							while true do
								loc_10 = add_i32(loc_9, mul_i32(loc_4, 12))
								loc_11 = load_i32(memory_at_0.data, loc_10)
								if loc_11 == 0 then
									break
								end
								if loc_3 == 0 then
									desired = 2
									break
								end
								if load_i32(memory_at_0.data, loc_10 + 4) ~= loc_8 then
									desired = 2
									break
								end
								reg_0 = FUNC_LIST[1345](loc_11, loc_3, loc_8)
								if reg_0 == 0 then
									desired = 5
									break
								end
								desired = 2
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_3 ~= 0 then
								desired = 2
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_4 = add_i32(loc_4, 1)
						if loc_4 ~= loc_7 then
							continue
						end
						desired = 1
						break
					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[129](loc_2)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_4 == loc_7 then
				break
			end
			while true do
				loc_3 = add_i32(load_i32(memory_at_0.data, loc_0 + 332), mul_i32(loc_4, 12))
				store_i64(memory_at_0.data, add_i32(add_i32(shl_i32(load_i32(memory_at_0.data, loc_3 + 8), 3), loc_5), 4294967288), load_i64(memory_at_0.data, loc_3))
				while true do
					loc_4 = add_i32(loc_4, 1)
					loc_11 = load_i32(memory_at_0.data, loc_0 + 336)
					if loc_4 >= loc_11 then
						break
					end
					loc_6 = load_i32(memory_at_0.data, loc_0 + 348)
					loc_3 = load_i32(memory_at_0.data, loc_0 + 344)
					loc_8 = load_i32(memory_at_0.data, loc_0 + 332)
					while true do
						while true do
							while true do
								loc_10 = add_i32(loc_8, mul_i32(loc_4, 12))
								loc_5 = load_i32(memory_at_0.data, loc_10)
								if loc_5 == 0 then
									break
								end
								if loc_3 == 0 then
									desired = 3
									break
								end
								if load_i32(memory_at_0.data, loc_10 + 4) ~= loc_6 then
									desired = 3
									break
								end
								reg_0 = FUNC_LIST[1345](loc_5, loc_3, loc_6)
								if reg_0 == 0 then
									desired = 5
									break
								end
								desired = 3
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							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_4 = add_i32(loc_4, 1)
						if loc_4 ~= loc_11 then
							continue
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_4 = loc_11
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				while true do
					if loc_4 == loc_7 then
						break
					end
					loc_5 = load_i32(memory_at_0.data, loc_2)
					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
			loc_5 = load_i32(memory_at_0.data, loc_2)
			loc_6 = load_i32(memory_at_0.data, loc_2 + 4)
			break
		end
		loc_4 = shr_i32(sub_i32(loc_6, loc_5), 3)
		while true do
			loc_3 = (if loc_4 > 127 then 1 else 0)
			store_i32_n8(memory_at_0.data, loc_2 + 14, bor_i32(shl_i32(loc_3, 7), band_i32(loc_4, 127)))
			reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_2, 14), 1)
			loc_4 = shr_u32(loc_4, 7)
			if loc_3 ~= 0 then
				continue
			end
			break
		end
		while true do
			if loc_5 == loc_6 then
				break
			end
			loc_10 = loc_5
			while true do
				loc_4 = load_i32(memory_at_0.data, loc_10 + 4)
				while true do
					loc_3 = (if loc_4 > 127 then 1 else 0)
					store_i32_n8(memory_at_0.data, loc_2 + 15, bor_i32(shl_i32(loc_3, 7), band_i32(loc_4, 127)))
					reg_0 = FUNC_LIST[1541](loc_1, add_i32(loc_2, 15), 1)
					loc_4 = shr_u32(loc_4, 7)
					if loc_3 ~= 0 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				reg_0 = FUNC_LIST[1541](loc_1, load_i32(memory_at_0.data, loc_10), load_i32(memory_at_0.data, loc_10 + 4))
				loc_10 = add_i32(loc_10, 8)
				if loc_10 ~= loc_6 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		break
	end
end
FUNC_LIST[167] = --[[ std::__2::vector<int, std::__2::allocator<int> >::__append(unsigned long) ]] function(loc_0, loc_1)
	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_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if shr_i32(sub_i32(loc_2, loc_3), 2) < loc_1 then
				break
			end
			while true do
				if loc_1 == 0 then
					break
				end
				loc_1 = shl_i32(loc_1, 2)
				reg_0 = FUNC_LIST[1286](loc_3, 0, loc_1)
				loc_3 = add_i32(reg_0, loc_1)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, loc_3)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				loc_4 = load_i32(memory_at_0.data, loc_0)
				loc_5 = sub_i32(loc_3, loc_4)
				loc_6 = shr_i32(loc_5, 2)
				loc_7 = add_i32(loc_6, loc_1)
				if loc_7 >= 1073741824 then
					break
				end
				loc_3 = 0
				while true do
					loc_2 = sub_i32(loc_2, loc_4)
					loc_8 = shr_i32(loc_2, 1)
					loc_2 = (if loc_2 < 2147483644 then (if loc_8 < loc_7 then loc_7 else loc_8) else 1073741823)
					if loc_2 == 0 then
						break
					end
					if loc_2 >= 1073741824 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1461](shl_i32(loc_2, 2))
					loc_3 = reg_0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = shl_i32(loc_1, 2)
				reg_0 = FUNC_LIST[1286](add_i32(loc_3, shl_i32(loc_6, 2)), 0, loc_1)
				loc_1 = add_i32(reg_0, loc_1)
				loc_2 = add_i32(loc_3, shl_i32(loc_2, 2))
				while true do
					if lt_i32(loc_5, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_3, loc_4, loc_5)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, loc_2)
				store_i32(memory_at_0.data, loc_0 + 4, loc_1)
				store_i32(memory_at_0.data, loc_0, loc_3)
				while true do
					if loc_4 == 0 then
						break
					end
					FUNC_LIST[1463](loc_4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[145](loc_0)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[168] = --[[ Luau::BytecodeBuilder::getImportId(int) ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = bor_i32(shl_i32(loc_0, 20), 1073741824)
		break
	end
	return reg_0
end
FUNC_LIST[169] = --[[ Luau::BytecodeBuilder::getImportId(int, int) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = bor_i32(bor_i32(shl_i32(loc_0, 20), shl_i32(loc_1, 10)), 2147483648)
		break
	end
	return reg_0
end
FUNC_LIST[170] = --[[ Luau::BytecodeBuilder::getImportId(int, int, int) ]] function(loc_0, loc_1, loc_2)
	local reg_0
	while true do
		reg_0 = bor_i32(bor_i32(bor_i32(shl_i32(loc_0, 20), shl_i32(loc_1, 10)), loc_2), 3221225472)
		break
	end
	return reg_0
end
FUNC_LIST[171] = --[[ Luau::BytecodeBuilder::getStringHash(Luau::BytecodeBuilder::StringRef) ]] function(loc_0)
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	local desired
	while true do
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_1 ~= 0 then
				break
			end
			reg_0 = 0
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_2 = load_i32(memory_at_0.data, loc_0)
		loc_3 = loc_1
		loc_0 = loc_1
		while true do
			if band_i32(loc_1, 1) == 0 then
				break
			end
			loc_3 = add_i32(loc_1, 4294967295)
			loc_0 = bxor_i32(add_i32(add_i32(shl_i32(loc_1, 5), shr_u32(loc_1, 2)), load_i32_u8(memory_at_0.data, add_i32(loc_2, loc_3))), loc_1)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if loc_1 == 1 then
				break
			end
			while true do
				loc_0 = bxor_i32(add_i32(add_i32(shl_i32(loc_0, 5), shr_u32(loc_0, 2)), load_i32_u8(memory_at_0.data, add_i32(add_i32(loc_3, loc_2), 4294967295))), loc_0)
				loc_3 = add_i32(loc_3, 4294967294)
				loc_0 = bxor_i32(add_i32(add_i32(shl_i32(loc_0, 5), shr_u32(loc_0, 2)), load_i32_u8(memory_at_0.data, add_i32(loc_2, loc_3))), loc_0)
				if loc_3 ~= 0 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
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[172] = --[[ Luau::BytecodeBuilder::foldJumps() ]] function(loc_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 desired
	while true do
		while true do
			if load_i32_u8(memory_at_0.data, loc_0 + 92) ~= 0 then
				break
			end
			loc_1 = load_i32(memory_at_0.data, loc_0 + 68)
			loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 72))
			if loc_1 == loc_2 then
				break
			end
			loc_3 = load_i32(memory_at_0.data, loc_0 + 32)
			loc_4 = load_i32(memory_at_0.data, loc_0 + 20)
			while true do
				while true do
					loc_5 = load_i32(memory_at_0.data, loc_1)
					loc_6 = shl_i32(loc_5, 2)
					loc_7 = add_i32(loc_4, loc_6)
					loc_8 = load_i32(memory_at_0.data, loc_7)
					loc_0 = add_i32(add_i32(loc_5, shr_i32(loc_8, 16)), 1)
					loc_9 = load_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_0, 2)))
					if band_i32(loc_9, 2147483903) ~= 23 then
						break
					end
					while true do
						loc_0 = add_i32(add_i32(loc_0, shr_u32(loc_9, 16)), 1)
						loc_9 = load_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_0, 2)))
						if band_i32(loc_9, 2147483903) == 23 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
				while true do
					while true do
						if band_i32(loc_8, 255) ~= 23 then
							break
						end
						if band_i32(loc_9, 255) ~= 22 then
							break
						end
						store_i32(memory_at_0.data, loc_7, loc_9)
						store_i32(memory_at_0.data, add_i32(loc_3, loc_6), load_i32(memory_at_0.data, add_i32(loc_3, shl_i32(loc_0, 2))))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_9 = add_i32(loc_0, bxor_i32(loc_5, 4294967295))
					if add_i32(loc_9, 32768) > 65535 then
						break
					end
					store_i32(memory_at_0.data, loc_7, bor_i32(shl_i32(loc_9, 16), band_i32(loc_8, 65535)))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				store_i32(memory_at_0.data, loc_1 + 4, loc_0)
				loc_1 = add_i32(loc_1, 8)
				if loc_1 ~= loc_2 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		break
	end
end
FUNC_LIST[173] = --[[ Luau::BytecodeBuilder::expandJumps() ]] function(loc_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 reg_1
	local desired
	while true do
		loc_1 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_1
		while true do
			while true do
				while true do
					if load_i32_u8(memory_at_0.data, loc_0 + 92) == 0 then
						break
					end
					loc_2 = 0
					while true do
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 72))
						loc_4 = load_i32(memory_at_0.data, loc_0 + 68)
						loc_5 = sub_i32(loc_3, loc_4)
						if lt_i32(loc_5, 9) then
							break
						end
						loc_2 = shr_u32(loc_5, 3)
						loc_5 = 0
						while true do
							loc_5 = add_i32(loc_5, 1)
							loc_6 = (if loc_2 > 3 then 1 else 0)
							loc_2 = shr_u32(loc_2, 1)
							if loc_6 ~= 0 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_2 = shl_i32(loc_5, 1)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[174](loc_4, loc_3, loc_2)
					loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 24))
					loc_3 = load_i32(memory_at_0.data, loc_0 + 20)
					store_i32(memory_at_0.data, loc_1 + 40, 0)
					store_i64(memory_at_0.data, loc_1 + 32, i64_ZERO)
					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 = sub_i32(loc_7, loc_3)
																if loc_2 ~= 0 then
																	break
																end
																loc_8 = 0
																store_i32(memory_at_0.data, loc_1 + 24, 0)
																store_i64(memory_at_0.data, loc_1 + 16, i64_ZERO)
																store_i32(memory_at_0.data, loc_1 + 8, 0)
																store_i64(memory_at_0.data, loc_1, i64_ZERO)
																loc_9 = 0
																loc_10 = 0
																loc_11 = 0
																loc_12 = 0
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															if le_i32(loc_2, 4294967295) then
																desired = 12
																break
															end
															reg_1 = FUNC_LIST[1461](loc_2)
															loc_10 = reg_1
															store_i32(memory_at_0.data, loc_1 + 32, loc_10)
															loc_5 = shl_i32(shr_i32(loc_2, 2), 2)
															loc_6 = add_i32(loc_10, loc_5)
															store_i32(memory_at_0.data, loc_1 + 40, loc_6)
															reg_0 = FUNC_LIST[1286](loc_10, 0, loc_5)
															store_i32(memory_at_0.data, loc_1 + 36, loc_6)
															reg_1 = FUNC_LIST[1461](loc_2)
															loc_9 = reg_1
															store_i32(memory_at_0.data, loc_1 + 20, loc_9)
															store_i32(memory_at_0.data, loc_1 + 16, loc_9)
															loc_8 = add_i32(loc_9, loc_5)
															store_i32(memory_at_0.data, loc_1 + 24, loc_8)
															reg_1 = FUNC_LIST[1461](loc_2)
															loc_11 = reg_1
															store_i32(memory_at_0.data, loc_1 + 4, loc_11)
															store_i32(memory_at_0.data, loc_1, loc_11)
															loc_12 = add_i32(loc_11, loc_5)
															store_i32(memory_at_0.data, loc_1 + 8, loc_12)
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														while true do
															while true do
																if loc_7 ~= loc_3 then
																	break
																end
																loc_5 = loc_11
																loc_3 = loc_7
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															loc_13 = 0
															loc_14 = load_i32(memory_at_0.data, loc_1)
															loc_15 = load_i32(memory_at_0.data, loc_1 + 16)
															loc_2 = loc_9
															loc_5 = loc_11
															loc_6 = 0
															while true do
																loc_16 = shl_i32(loc_6, 2)
																loc_3 = load_i32_u8(memory_at_0.data, add_i32(loc_3, loc_16))
																while true do
																	loc_4 = load_i32(memory_at_0.data, loc_0 + 68)
																	if loc_13 >= shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 72), loc_4), 3) then
																		break
																	end
																	loc_4 = add_i32(loc_4, shl_i32(loc_13, 3))
																	if load_i32(memory_at_0.data, loc_4) ~= loc_6 then
																		break
																	end
																	while true do
																		loc_4 = add_i32(load_i32(memory_at_0.data, loc_4 + 4), bxor_i32(loc_6, 4294967295))
																		reg_0 = loc_4
																		loc_4 = shr_i32(loc_4, 31)
																		if bxor_i32(add_i32(reg_0, loc_4), loc_4) < 10923 then
																			break
																		end
																		while true do
																			while true do
																				if loc_2 >= loc_8 then
																					break
																				end
																				store_i32(memory_at_0.data, loc_2, 65559)
																				loc_2 = add_i32(loc_2, 4)
																				store_i32(memory_at_0.data, loc_1 + 20, loc_2)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_4 = sub_i32(loc_2, loc_9)
																			loc_7 = shr_i32(loc_4, 2)
																			loc_2 = add_i32(loc_7, 1)
																			if loc_2 >= 1073741824 then
																				desired = 11
																				break
																			end
																			while true do
																				while true do
																					loc_17 = sub_i32(loc_8, loc_9)
																					loc_18 = shr_i32(loc_17, 1)
																					loc_2 = (if loc_17 < 2147483644 then (if loc_18 < loc_2 then loc_2 else loc_18) else 1073741823)
																					if loc_2 ~= 0 then
																						break
																					end
																					loc_15 = 0
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				if loc_2 >= 1073741824 then
																					desired = 2
																					break
																				end
																				reg_0 = FUNC_LIST[1461](shl_i32(loc_2, 2))
																				loc_15 = reg_0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_7 = add_i32(loc_15, shl_i32(loc_7, 2))
																			store_i32(memory_at_0.data, loc_7, 65559)
																			loc_8 = shl_i32(loc_2, 2)
																			loc_2 = add_i32(loc_7, 4)
																			while true do
																				if lt_i32(loc_4, 1) then
																					break
																				end
																				reg_0 = FUNC_LIST[1224](loc_15, loc_9, loc_4)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_8 = add_i32(loc_15, loc_8)
																			store_i32(memory_at_0.data, loc_1 + 20, loc_2)
																			while true do
																				if loc_9 == 0 then
																					break
																				end
																				FUNC_LIST[1463](loc_9)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_9 = loc_15
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		while true do
																			while true do
																				if loc_2 >= loc_8 then
																					break
																				end
																				store_i32(memory_at_0.data, loc_2, 67)
																				loc_2 = add_i32(loc_2, 4)
																				store_i32(memory_at_0.data, loc_1 + 20, loc_2)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_4 = sub_i32(loc_2, loc_9)
																			loc_7 = shr_i32(loc_4, 2)
																			loc_2 = add_i32(loc_7, 1)
																			if loc_2 >= 1073741824 then
																				desired = 10
																				break
																			end
																			while true do
																				while true do
																					loc_17 = sub_i32(loc_8, loc_9)
																					loc_18 = shr_i32(loc_17, 1)
																					loc_2 = (if loc_17 < 2147483644 then (if loc_18 < loc_2 then loc_2 else loc_18) else 1073741823)
																					if loc_2 ~= 0 then
																						break
																					end
																					loc_15 = 0
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				if loc_2 >= 1073741824 then
																					desired = 2
																					break
																				end
																				reg_0 = FUNC_LIST[1461](shl_i32(loc_2, 2))
																				loc_15 = reg_0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_7 = add_i32(loc_15, shl_i32(loc_7, 2))
																			store_i32(memory_at_0.data, loc_7, 67)
																			loc_8 = shl_i32(loc_2, 2)
																			loc_2 = add_i32(loc_7, 4)
																			while true do
																				if lt_i32(loc_4, 1) then
																					break
																				end
																				reg_0 = FUNC_LIST[1224](loc_15, loc_9, loc_4)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_8 = add_i32(loc_15, loc_8)
																			store_i32(memory_at_0.data, loc_1 + 20, loc_2)
																			while true do
																				if loc_9 == 0 then
																					break
																				end
																				FUNC_LIST[1463](loc_9)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_9 = loc_15
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_4 = load_i32(memory_at_0.data, loc_0 + 32)
																		loc_7 = add_i32(loc_4, loc_16)
																		while true do
																			while true do
																				if loc_5 == loc_12 then
																					break
																				end
																				store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_7))
																				loc_5 = add_i32(loc_5, 4)
																				store_i32(memory_at_0.data, loc_1 + 4, loc_5)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_12 = sub_i32(loc_5, loc_11)
																			loc_18 = shr_i32(loc_12, 2)
																			loc_17 = add_i32(loc_18, 1)
																			if loc_17 >= 1073741824 then
																				desired = 9
																				break
																			end
																			while true do
																				while true do
																					loc_19 = shr_i32(loc_12, 1)
																					loc_17 = (if loc_12 < 2147483644 then (if loc_19 < loc_17 then loc_17 else loc_19) else 1073741823)
																					if loc_17 ~= 0 then
																						break
																					end
																					loc_14 = 0
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				if loc_17 >= 1073741824 then
																					desired = 8
																					break
																				end
																				reg_0 = FUNC_LIST[1461](shl_i32(loc_17, 2))
																				loc_14 = reg_0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_5 = add_i32(loc_14, shl_i32(loc_18, 2))
																			store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_7))
																			loc_7 = shl_i32(loc_17, 2)
																			loc_5 = add_i32(loc_5, 4)
																			while true do
																				if lt_i32(loc_12, 1) then
																					break
																				end
																				reg_0 = FUNC_LIST[1224](loc_14, loc_11, loc_12)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_12 = add_i32(loc_14, loc_7)
																			store_i32(memory_at_0.data, loc_1 + 4, loc_5)
																			while true do
																				if loc_11 == 0 then
																					break
																				end
																				FUNC_LIST[1463](loc_11)
																				loc_4 = load_i32(memory_at_0.data, loc_0 + 32)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_11 = loc_14
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_4 = add_i32(loc_4, loc_16)
																		while true do
																			if loc_5 == loc_12 then
																				break
																			end
																			store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_4))
																			loc_5 = add_i32(loc_5, 4)
																			store_i32(memory_at_0.data, loc_1 + 4, loc_5)
																			desired = 16
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_16 = sub_i32(loc_5, loc_11)
																		loc_12 = shr_i32(loc_16, 2)
																		loc_7 = add_i32(loc_12, 1)
																		if loc_7 >= 1073741824 then
																			desired = 7
																			break
																		end
																		while true do
																			while true do
																				loc_17 = shr_i32(loc_16, 1)
																				loc_7 = (if loc_16 < 2147483644 then (if loc_17 < loc_7 then loc_7 else loc_17) else 1073741823)
																				if loc_7 ~= 0 then
																					break
																				end
																				loc_14 = 0
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			if loc_7 >= 1073741824 then
																				desired = 6
																				break
																			end
																			reg_0 = FUNC_LIST[1461](shl_i32(loc_7, 2))
																			loc_14 = reg_0
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_5 = add_i32(loc_14, shl_i32(loc_12, 2))
																		store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_4))
																		loc_4 = shl_i32(loc_7, 2)
																		loc_5 = add_i32(loc_5, 4)
																		while true do
																			if lt_i32(loc_16, 1) then
																				break
																			end
																			reg_0 = FUNC_LIST[1224](loc_14, loc_11, loc_16)
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_12 = add_i32(loc_14, loc_4)
																		store_i32(memory_at_0.data, loc_1 + 4, loc_5)
																		while true do
																			if loc_11 == 0 then
																				break
																			end
																			FUNC_LIST[1463](loc_11)
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																			end
																			break
																		end
																		loc_11 = loc_14
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	loc_13 = add_i32(loc_13, 1)
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																		continue
																	end
																	break
																end
																while true do
																	reg_0 = FUNC_LIST[175](loc_3)
																	loc_3 = reg_0
																	if lt_i32(loc_3, 1) then
																		break
																	end
																	loc_17 = add_i32(loc_3, loc_6)
																	while true do
																		loc_3 = shl_i32(loc_6, 2)
																		loc_4 = sub_i32(loc_2, loc_9)
																		loc_7 = shr_i32(loc_4, 2)
																		store_i32(memory_at_0.data, add_i32(loc_10, loc_3), loc_7)
																		loc_16 = add_i32(load_i32(memory_at_0.data, loc_0 + 20), loc_3)
																		while true do
																			while true do
																				if loc_2 == loc_8 then
																					break
																				end
																				store_i32(memory_at_0.data, loc_2, load_i32(memory_at_0.data, loc_16))
																				loc_2 = add_i32(loc_2, 4)
																				store_i32(memory_at_0.data, loc_1 + 20, loc_2)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_8 = add_i32(loc_7, 1)
																			if loc_8 >= 1073741824 then
																				desired = 5
																				break
																			end
																			while true do
																				while true do
																					loc_18 = shr_i32(loc_4, 1)
																					loc_8 = (if loc_4 < 2147483644 then (if loc_18 < loc_8 then loc_8 else loc_18) else 1073741823)
																					if loc_8 ~= 0 then
																						break
																					end
																					loc_15 = 0
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				while true do
																					if loc_8 < 1073741824 then
																						break
																					end
																					store_i32(memory_at_0.data, loc_1, loc_14)
																					store_i32(memory_at_0.data, loc_1 + 16, loc_15)
																					store_i32(memory_at_0.data, loc_1 + 24, loc_2)
																					desired = 1
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				reg_0 = FUNC_LIST[1461](shl_i32(loc_8, 2))
																				loc_15 = reg_0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_2 = add_i32(loc_15, shl_i32(loc_7, 2))
																			store_i32(memory_at_0.data, loc_2, load_i32(memory_at_0.data, loc_16))
																			loc_16 = shl_i32(loc_8, 2)
																			loc_2 = add_i32(loc_2, 4)
																			while true do
																				if lt_i32(loc_4, 1) then
																					break
																				end
																				reg_0 = FUNC_LIST[1224](loc_15, loc_9, loc_4)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_8 = add_i32(loc_15, loc_16)
																			store_i32(memory_at_0.data, loc_1 + 20, loc_2)
																			while true do
																				if loc_9 == 0 then
																					break
																				end
																				FUNC_LIST[1463](loc_9)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_9 = loc_15
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																				continue
																			end
																			break
																		end
																		loc_3 = add_i32(load_i32(memory_at_0.data, loc_0 + 32), loc_3)
																		while true do
																			while true do
																				if loc_5 == loc_12 then
																					break
																				end
																				store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_3))
																				loc_5 = add_i32(loc_5, 4)
																				store_i32(memory_at_0.data, loc_1 + 4, loc_5)
																				desired = 17
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_4 = sub_i32(loc_5, loc_11)
																			loc_7 = shr_i32(loc_4, 2)
																			loc_16 = add_i32(loc_7, 1)
																			if loc_16 >= 1073741824 then
																				desired = 9
																				break
																			end
																			while true do
																				while true do
																					loc_12 = shr_i32(loc_4, 1)
																					loc_16 = (if loc_4 < 2147483644 then (if loc_12 < loc_16 then loc_16 else loc_12) else 1073741823)
																					if loc_16 ~= 0 then
																						break
																					end
																					loc_14 = 0
																					desired = 18
																					break
																				end
																				if desired then
																					if desired == 18 then
																						desired = nil
																					end
																					break
																				end
																				if loc_16 >= 1073741824 then
																					desired = 8
																					break
																				end
																				reg_0 = FUNC_LIST[1461](shl_i32(loc_16, 2))
																				loc_14 = reg_0
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_5 = add_i32(loc_14, shl_i32(loc_7, 2))
																			store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, loc_3))
																			loc_3 = shl_i32(loc_16, 2)
																			loc_5 = add_i32(loc_5, 4)
																			while true do
																				if lt_i32(loc_4, 1) then
																					break
																				end
																				reg_0 = FUNC_LIST[1224](loc_14, loc_11, loc_4)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_12 = add_i32(loc_14, loc_3)
																			store_i32(memory_at_0.data, loc_1 + 4, loc_5)
																			while true do
																				if loc_11 == 0 then
																					break
																				end
																				FUNC_LIST[1463](loc_11)
																				break
																			end
																			if desired then
																				if desired == 17 then
																					desired = nil
																				end
																				break
																			end
																			loc_11 = loc_14
																			break
																		end
																		if desired then
																			if desired == 16 then
																				desired = nil
																				continue
																			end
																			break
																		end
																		loc_6 = add_i32(loc_6, 1)
																		if loc_6 ~= loc_17 then
																			continue
																		end
																		break
																	end
																	if desired then
																		if desired == 15 then
																			desired = nil
																		end
																		break
																	end
																	loc_6 = loc_17
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																		continue
																	end
																	break
																end
																loc_7 = load_i32(memory_at_0.data, loc_0 + 24)
																loc_3 = load_i32(memory_at_0.data, loc_0 + 20)
																if loc_6 < shr_i32(sub_i32(loc_7, loc_3), 2) then
																	continue
																end
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															store_i32(memory_at_0.data, loc_1, loc_14)
															store_i32(memory_at_0.data, loc_1 + 16, loc_15)
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														store_i32(memory_at_0.data, loc_1 + 8, loc_12)
														store_i32(memory_at_0.data, loc_1 + 24, loc_8)
														loc_2 = load_i32(memory_at_0.data, loc_0 + 68)
														loc_14 = load_i32(memory_at_0.data, loc_0 + 72)
														if loc_2 == loc_14 then
															desired = 4
															break
														end
														loc_11 = load_i32(memory_at_0.data, loc_1 + 16)
														loc_6 = load_i32(memory_at_0.data, loc_1 + 32)
														while true do
															loc_4 = load_i32(memory_at_0.data, loc_2 + 4)
															loc_9 = load_i32(memory_at_0.data, loc_2)
															loc_16 = load_i32(memory_at_0.data, add_i32(loc_6, shl_i32(loc_9, 2)))
															loc_15 = sub_i32(load_i32(memory_at_0.data, add_i32(loc_6, shl_i32(loc_4, 2))), loc_16)
															while true do
																while true do
																	loc_4 = add_i32(loc_4, bxor_i32(loc_9, 4294967295))
																	reg_0 = loc_4
																	loc_4 = shr_i32(loc_4, 31)
																	if bxor_i32(add_i32(reg_0, loc_4), loc_4) < 10923 then
																		break
																	end
																	loc_4 = add_i32(loc_11, shl_i32(loc_16, 2))
																	store_i32_n16(memory_at_0.data, add_i32(loc_4, 2), 65534)
																	loc_4 = add_i32(loc_4, 4294967292)
																	store_i32(memory_at_0.data, loc_4, bor_i32(load_i32_u8(memory_at_0.data, loc_4), shl_i32(loc_15, 8)))
																	desired = 14
																	break
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																store_i32_n16(memory_at_0.data, add_i32(add_i32(loc_11, shl_i32(loc_16, 2)), 2), shr_u32(add_i32(shl_i32(loc_15, 16), 4294901760), 16))
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																	continue
																end
																break
															end
															loc_2 = add_i32(loc_2, 8)
															if loc_2 ~= loc_14 then
																continue
															end
															desired = 4
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														error("out of code bounds")
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													FUNC_LIST[143](add_i32(loc_1, 32))
													error("out of code bounds")
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32(memory_at_0.data, loc_1, loc_14)
												store_i32(memory_at_0.data, loc_1 + 16, loc_15)
												store_i32(memory_at_0.data, loc_1 + 24, loc_8)
												store_i32(memory_at_0.data, loc_1 + 8, loc_12)
												FUNC_LIST[143](add_i32(loc_1, 16))
												error("out of code bounds")
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											store_i32(memory_at_0.data, loc_1, loc_14)
											store_i32(memory_at_0.data, loc_1 + 16, loc_15)
											store_i32(memory_at_0.data, loc_1 + 24, loc_8)
											store_i32(memory_at_0.data, loc_1 + 8, loc_12)
											FUNC_LIST[143](add_i32(loc_1, 16))
											error("out of code bounds")
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										store_i32(memory_at_0.data, loc_1, loc_14)
										store_i32(memory_at_0.data, loc_1 + 16, loc_15)
										store_i32(memory_at_0.data, loc_1 + 24, loc_8)
										store_i32(memory_at_0.data, loc_1 + 8, loc_5)
										FUNC_LIST[145](loc_1)
										error("out of code bounds")
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									store_i32(memory_at_0.data, loc_1, loc_14)
									store_i32(memory_at_0.data, loc_1 + 16, loc_15)
									store_i32(memory_at_0.data, loc_1 + 24, loc_8)
									store_i32(memory_at_0.data, loc_1 + 8, loc_5)
									FUNC_LIST[276]()
									error("out of code bounds")
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								store_i32(memory_at_0.data, loc_1, loc_14)
								store_i32(memory_at_0.data, loc_1 + 16, loc_15)
								store_i32(memory_at_0.data, loc_1 + 24, loc_8)
								store_i32(memory_at_0.data, loc_1 + 8, loc_5)
								FUNC_LIST[145](loc_1)
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_1, loc_14)
							store_i32(memory_at_0.data, loc_1 + 16, loc_15)
							store_i32(memory_at_0.data, loc_1 + 24, loc_8)
							store_i32(memory_at_0.data, loc_1 + 8, loc_5)
							FUNC_LIST[276]()
							error("out of code bounds")
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_1, loc_14)
						store_i32(memory_at_0.data, loc_1 + 16, loc_15)
						store_i32(memory_at_0.data, loc_1 + 24, loc_2)
						store_i32(memory_at_0.data, loc_1 + 8, loc_12)
						FUNC_LIST[143](add_i32(loc_1, 16))
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 20, load_i32(memory_at_0.data, loc_1 + 16))
					store_i32(memory_at_0.data, loc_1 + 16, loc_3)
					store_i32(memory_at_0.data, loc_0 + 24, load_i32(memory_at_0.data, loc_1 + 20))
					store_i32(memory_at_0.data, loc_1 + 20, loc_7)
					loc_2 = add_i32(loc_0, 28)
					loc_6 = load_i32(memory_at_0.data, loc_2)
					store_i32(memory_at_0.data, loc_2, loc_8)
					store_i32(memory_at_0.data, loc_1 + 24, loc_6)
					loc_2 = load_i32(memory_at_0.data, loc_0 + 32)
					store_i32(memory_at_0.data, loc_0 + 32, load_i32(memory_at_0.data, loc_1))
					store_i32(memory_at_0.data, loc_1, loc_2)
					loc_6 = add_i32(loc_0, 36)
					loc_4 = load_i32(memory_at_0.data, loc_6)
					store_i32(memory_at_0.data, loc_6, loc_5)
					store_i32(memory_at_0.data, loc_1 + 4, loc_4)
					loc_5 = add_i32(loc_0, 40)
					loc_6 = load_i32(memory_at_0.data, loc_5)
					store_i32(memory_at_0.data, loc_5, loc_12)
					store_i32(memory_at_0.data, loc_1 + 8, loc_6)
					while true do
						if loc_2 == 0 then
							break
						end
						store_i32(memory_at_0.data, loc_1 + 4, loc_2)
						FUNC_LIST[1463](loc_2)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_3 == 0 then
							break
						end
						store_i32(memory_at_0.data, loc_1 + 20, loc_3)
						FUNC_LIST[1463](loc_3)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_2 = load_i32(memory_at_0.data, loc_1 + 32)
					if loc_2 == 0 then
						break
					end
					FUNC_LIST[1463](loc_2)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				GLOBAL_LIST[0].value = add_i32(loc_1, 48)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_1, loc_14)
			store_i32(memory_at_0.data, loc_1 + 16, loc_15)
			store_i32(memory_at_0.data, loc_1 + 24, loc_8)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		store_i32(memory_at_0.data, loc_1 + 8, loc_12)
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[174] = --[[ void std::__2::__introsort<Luau::BytecodeBuilder::expandJumps()::$_0&, Luau::BytecodeBuilder::Jump*>(Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::expandJumps()::$_0&, std::__2::iterator_traits<Luau::BytecodeBuilder::Jump*>::difference_type) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = i64_ZERO
	local loc_8 = 0
	local loc_9 = i64_ZERO
	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
	local br_map = {}
	while true do
		while true do
			loc_3 = add_i32(loc_1, 4294967288)
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									while true do
										loc_4 = sub_i32(loc_1, loc_0)
										loc_5 = shr_i32(loc_4, 3)
										if not br_map[1] then
											br_map[1] = (function()
												return { [0] = 6, 6, 0, 1, 2, 3, }
											end)()
										end
										temp = br_map[1][loc_5] 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 < 6 then
												desired = 4
												break
											else
												desired = 2
												break
											end
										else
											desired = 5
											break
										end
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									loc_6 = add_i32(loc_1, 4294967288)
									if load_i32(memory_at_0.data, loc_6) >= load_i32(memory_at_0.data, loc_0) then
										desired = 2
										break
									end
									loc_7 = load_i64(memory_at_0.data, loc_0)
									store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_6))
									store_i64(memory_at_0.data, loc_6, loc_7)
									desired = 0
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_6 = add_i32(loc_1, 4294967288)
								loc_8 = load_i32(memory_at_0.data, loc_6)
								while true do
									loc_5 = load_i32(memory_at_0.data, loc_0 + 8)
									if loc_5 < load_i32(memory_at_0.data, loc_0) then
										break
									end
									if loc_8 >= loc_5 then
										desired = 2
										break
									end
									loc_7 = load_i64(memory_at_0.data, loc_0 + 8)
									store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_6))
									store_i64(memory_at_0.data, loc_6, loc_7)
									if load_i32(memory_at_0.data, loc_0 + 8) >= load_i32(memory_at_0.data, loc_0) then
										desired = 2
										break
									end
									loc_7 = load_i64(memory_at_0.data, loc_0 + 8)
									store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_0))
									store_i64(memory_at_0.data, loc_0, loc_7)
									desired = 0
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_0)
								while true do
									if loc_8 >= loc_5 then
										break
									end
									store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_6))
									store_i64(memory_at_0.data, loc_6, loc_7)
									desired = 0
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_9 = load_i64(memory_at_0.data, loc_0 + 8)
								store_i64(memory_at_0.data, loc_0 + 8, loc_7)
								store_i64(memory_at_0.data, loc_0, loc_9)
								if load_i32(memory_at_0.data, loc_6) >= wrap_i32_i64(loc_7) then
									desired = 2
									break
								end
								store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_6))
								store_i64(memory_at_0.data, loc_6, loc_7)
								desired = 0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							reg_0 = FUNC_LIST[179](loc_0, add_i32(loc_0, 8), add_i32(loc_0, 16), add_i32(loc_1, 4294967288))
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_10 = add_i32(loc_0, 8)
						loc_5 = add_i32(loc_0, 16)
						loc_6 = add_i32(loc_0, 24)
						reg_0 = FUNC_LIST[179](loc_0, loc_10, loc_5, loc_6)
						loc_8 = add_i32(loc_1, 4294967288)
						if load_i32(memory_at_0.data, loc_8) >= load_i32(memory_at_0.data, loc_0 + 24) then
							desired = 2
							break
						end
						loc_7 = load_i64(memory_at_0.data, loc_6)
						store_i64(memory_at_0.data, loc_6, load_i64(memory_at_0.data, loc_8))
						store_i64(memory_at_0.data, loc_8, loc_7)
						if load_i32(memory_at_0.data, loc_6) >= load_i32(memory_at_0.data, loc_5) then
							desired = 2
							break
						end
						loc_9 = load_i64(memory_at_0.data, loc_5)
						loc_7 = load_i64(memory_at_0.data, loc_6)
						store_i64(memory_at_0.data, loc_5, loc_7)
						store_i64(memory_at_0.data, loc_6, loc_9)
						loc_6 = wrap_i32_i64(loc_7)
						if load_i32(memory_at_0.data, loc_10) <= loc_6 then
							desired = 2
							break
						end
						store_i64(memory_at_0.data, loc_0 + 16, load_i64(memory_at_0.data, loc_0 + 8))
						store_i64(memory_at_0.data, loc_0 + 8, loc_7)
						if load_i32(memory_at_0.data, loc_0) <= loc_6 then
							desired = 2
							break
						end
						store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_0))
						store_i64(memory_at_0.data, loc_0, loc_7)
						desired = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if gt_i32(loc_4, 247) then
							break
						end
						loc_6 = load_i32(memory_at_0.data, loc_0 + 16)
						while true do
							while true do
								loc_8 = load_i32(memory_at_0.data, loc_0 + 8)
								loc_5 = load_i32(memory_at_0.data, loc_0)
								if loc_8 < loc_5 then
									break
								end
								if loc_6 >= loc_8 then
									desired = 5
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_0 + 16)
								loc_9 = load_i64(memory_at_0.data, loc_0 + 8)
								store_i64(memory_at_0.data, loc_0 + 16, loc_9)
								store_i64(memory_at_0.data, loc_0 + 8, loc_7)
								loc_6 = wrap_i32_i64(loc_9)
								if loc_5 <= wrap_i32_i64(loc_7) then
									desired = 5
									break
								end
								store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_0))
								store_i64(memory_at_0.data, loc_0, loc_7)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_0)
							while true do
								if loc_6 >= loc_8 then
									break
								end
								loc_9 = load_i64(memory_at_0.data, loc_0 + 16)
								store_i64(memory_at_0.data, loc_0 + 16, loc_7)
								store_i64(memory_at_0.data, loc_0, loc_9)
								loc_6 = wrap_i32_i64(loc_7)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_9 = load_i64(memory_at_0.data, loc_0 + 8)
							store_i64(memory_at_0.data, loc_0 + 8, loc_7)
							store_i64(memory_at_0.data, loc_0, loc_9)
							loc_8 = wrap_i32_i64(loc_7)
							if loc_6 >= loc_8 then
								break
							end
							loc_9 = load_i64(memory_at_0.data, loc_0 + 16)
							store_i64(memory_at_0.data, loc_0 + 16, loc_7)
							store_i64(memory_at_0.data, loc_0 + 8, loc_9)
							loc_6 = loc_8
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_5 = add_i32(loc_0, 24)
						if loc_5 == loc_1 then
							desired = 2
							break
						end
						loc_8 = add_i32(loc_0, 16)
						while true do
							while true do
								loc_11 = loc_5
								if load_i32(memory_at_0.data, loc_11) >= loc_6 then
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_11)
								loc_10 = wrap_i32_i64(loc_7)
								loc_5 = loc_11
								while true do
									while true do
										loc_6 = loc_8
										store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_6))
										while true do
											if loc_6 ~= loc_0 then
												break
											end
											loc_6 = loc_0
											desired = 7
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
												continue
											end
											break
										end
										loc_5 = loc_6
										loc_8 = add_i32(loc_6, 4294967288)
										if load_i32(memory_at_0.data, loc_8) > loc_10 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
								store_i64(memory_at_0.data, loc_6, loc_7)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_5 = add_i32(loc_11, 8)
							if loc_5 == loc_1 then
								desired = 2
								break
							end
							loc_6 = load_i32(memory_at_0.data, loc_11)
							loc_8 = loc_11
							continue
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					while true do
						if loc_2 ~= 0 then
							break
						end
						if loc_0 == loc_1 then
							desired = 2
							break
						end
						loc_6 = add_i32(loc_5, 4294967294)
						loc_3 = shr_u32(loc_6, 1)
						loc_6 = div_i32(loc_6, 2)
						while true do
							while true do
								loc_12 = loc_6
								if lt_i32(loc_3, loc_12) then
									break
								end
								loc_10 = add_i32(loc_0, shl_i32(loc_12, 3))
								loc_11 = shl_i32(loc_12, 1)
								loc_8 = bor_i32(loc_11, 1)
								loc_6 = add_i32(loc_0, shl_i32(loc_8, 3))
								while true do
									loc_11 = add_i32(loc_11, 2)
									if ge_i32(loc_11, loc_5) then
										break
									end
									loc_2 = (if load_i32(memory_at_0.data, loc_6) < load_i32(memory_at_0.data, loc_6 + 8) then 1 else 0)
									loc_6 = (if loc_2 ~= 0 then add_i32(loc_6, 8) else loc_6)
									loc_8 = (if loc_2 ~= 0 then loc_11 else loc_8)
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if load_i32(memory_at_0.data, loc_6) < load_i32(memory_at_0.data, loc_10) then
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_10)
								loc_2 = wrap_i32_i64(loc_7)
								while true do
									while true do
										loc_11 = loc_6
										store_i64(memory_at_0.data, loc_10, load_i64(memory_at_0.data, loc_11))
										if lt_i32(loc_3, loc_8) then
											desired = 7
											break
										end
										loc_10 = shl_i32(loc_8, 1)
										loc_8 = bor_i32(loc_10, 1)
										loc_6 = add_i32(loc_0, shl_i32(loc_8, 3))
										while true do
											loc_10 = add_i32(loc_10, 2)
											if ge_i32(loc_10, loc_5) then
												break
											end
											loc_13 = (if load_i32(memory_at_0.data, loc_6) < load_i32(memory_at_0.data, loc_6 + 8) then 1 else 0)
											loc_6 = (if loc_13 ~= 0 then add_i32(loc_6, 8) else loc_6)
											loc_8 = (if loc_13 ~= 0 then loc_10 else loc_8)
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
												continue
											end
											break
										end
										loc_10 = loc_11
										if load_i32(memory_at_0.data, loc_6) >= loc_2 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
								store_i64(memory_at_0.data, loc_11, loc_7)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_6 = add_i32(loc_12, 4294967295)
							if gt_i32(loc_12, 0) then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_14 = add_i32(loc_0, 16)
						loc_13 = add_i32(loc_0, 8)
						loc_12 = shr_u32(loc_4, 3)
						while true do
							loc_7 = load_i64(memory_at_0.data, loc_0)
							loc_1 = add_i32(loc_1, 4294967288)
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_1))
							store_i64(memory_at_0.data, loc_1, loc_7)
							if loc_12 == 2 then
								desired = 2
								break
							end
							loc_8 = 1
							loc_6 = loc_13
							while true do
								loc_11 = add_i32(loc_12, 4294967295)
								if loc_11 < 3 then
									break
								end
								loc_8 = (if load_i32(memory_at_0.data, loc_13) < load_i32(memory_at_0.data, loc_14) then 1 else 0)
								loc_6 = (if loc_8 ~= 0 then loc_14 else loc_13)
								loc_8 = (if loc_8 ~= 0 then 2 else 1)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							while true do
								if load_i32(memory_at_0.data, loc_6) < load_i32(memory_at_0.data, loc_0) then
									break
								end
								loc_4 = shr_u32(add_i32(loc_12, 4294967293), 1)
								loc_7 = load_i64(memory_at_0.data, loc_0)
								loc_3 = wrap_i32_i64(loc_7)
								loc_5 = loc_0
								while true do
									while true do
										loc_10 = loc_6
										store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_10))
										if lt_i32(loc_4, loc_8) then
											desired = 7
											break
										end
										loc_5 = shl_i32(loc_8, 1)
										loc_8 = bor_i32(loc_5, 1)
										loc_6 = add_i32(loc_0, shl_i32(loc_8, 3))
										while true do
											loc_5 = add_i32(loc_5, 2)
											if ge_i32(loc_5, loc_11) then
												break
											end
											loc_2 = (if load_i32(memory_at_0.data, loc_6) < load_i32(memory_at_0.data, loc_6 + 8) then 1 else 0)
											loc_6 = (if loc_2 ~= 0 then add_i32(loc_6, 8) else loc_6)
											loc_8 = (if loc_2 ~= 0 then loc_5 else loc_8)
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
												continue
											end
											break
										end
										loc_5 = loc_10
										if load_i32(memory_at_0.data, loc_6) >= loc_3 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
								store_i64(memory_at_0.data, loc_10, loc_7)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_6 = (if gt_i32(loc_12, 2) then 1 else 0)
							loc_12 = loc_11
							if loc_6 == 0 then
								desired = 2
								break
							end
							continue
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_11 = add_i32(loc_0, shl_i32(div_i32(loc_5, 2), 3))
					while true do
						while true do
							if loc_4 < 7993 then
								break
							end
							loc_6 = shl_i32(div_i32(loc_5, 4), 3)
							loc_8 = add_i32(loc_0, loc_6)
							loc_6 = add_i32(loc_11, loc_6)
							reg_0 = FUNC_LIST[179](loc_0, loc_8, loc_11, loc_6)
							loc_4 = reg_0
							if load_i32(memory_at_0.data, loc_3) >= load_i32(memory_at_0.data, loc_6) then
								desired = 4
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_6)
							store_i64(memory_at_0.data, loc_6, load_i64(memory_at_0.data, loc_3))
							store_i64(memory_at_0.data, loc_3, loc_7)
							while true do
								if load_i32(memory_at_0.data, loc_6) < load_i32(memory_at_0.data, loc_11) then
									break
								end
								loc_4 = add_i32(loc_4, 1)
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_11)
							store_i64(memory_at_0.data, loc_11, load_i64(memory_at_0.data, loc_6))
							store_i64(memory_at_0.data, loc_6, loc_7)
							while true do
								if load_i32(memory_at_0.data, loc_11) < load_i32(memory_at_0.data, loc_8) then
									break
								end
								loc_4 = add_i32(loc_4, 2)
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_8)
							store_i64(memory_at_0.data, loc_8, load_i64(memory_at_0.data, loc_11))
							store_i64(memory_at_0.data, loc_11, loc_7)
							while true do
								if load_i32(memory_at_0.data, loc_8) < load_i32(memory_at_0.data, loc_0) then
									break
								end
								loc_4 = add_i32(loc_4, 3)
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_0)
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_8))
							store_i64(memory_at_0.data, loc_8, loc_7)
							loc_4 = add_i32(loc_4, 4)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = load_i32(memory_at_0.data, loc_3)
						while true do
							while true do
								loc_8 = load_i32(memory_at_0.data, loc_11)
								if loc_8 < load_i32(memory_at_0.data, loc_0) then
									break
								end
								loc_4 = 0
								if loc_6 >= loc_8 then
									desired = 4
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_11)
								store_i64(memory_at_0.data, loc_11, load_i64(memory_at_0.data, loc_3))
								store_i64(memory_at_0.data, loc_3, loc_7)
								loc_4 = 1
								if load_i32(memory_at_0.data, loc_11) >= load_i32(memory_at_0.data, loc_0) then
									desired = 4
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_0)
								store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_11))
								store_i64(memory_at_0.data, loc_11, loc_7)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_0)
							while true do
								if loc_6 >= loc_8 then
									break
								end
								store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3))
								store_i64(memory_at_0.data, loc_3, loc_7)
								loc_4 = 1
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_11))
							store_i64(memory_at_0.data, loc_11, loc_7)
							loc_4 = 1
							if load_i32(memory_at_0.data, loc_3) >= wrap_i32_i64(loc_7) then
								desired = 4
								break
							end
							store_i64(memory_at_0.data, loc_11, load_i64(memory_at_0.data, loc_3))
							store_i64(memory_at_0.data, loc_3, loc_7)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_4 = 2
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_2 = add_i32(loc_2, 4294967295)
					loc_6 = loc_3
					while true do
						while true do
							while true do
								while true do
									loc_10 = load_i32(memory_at_0.data, loc_0)
									loc_8 = load_i32(memory_at_0.data, loc_11)
									if loc_10 >= loc_8 then
										break
									end
									loc_6 = loc_3
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								while true do
									while true do
										loc_6 = add_i32(loc_6, 4294967288)
										if loc_0 ~= loc_6 then
											break
										end
										loc_5 = add_i32(loc_0, 8)
										if loc_10 < load_i32(memory_at_0.data, loc_3) then
											desired = 5
											break
										end
										if loc_5 == loc_3 then
											desired = 2
											break
										end
										while true do
											while true do
												if loc_10 >= load_i32(memory_at_0.data, loc_5) then
													break
												end
												loc_7 = load_i64(memory_at_0.data, loc_5)
												store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_3))
												store_i64(memory_at_0.data, loc_3, loc_7)
												loc_5 = add_i32(loc_5, 8)
												desired = 5
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
													continue
												end
												break
											end
											loc_5 = add_i32(loc_5, 8)
											if loc_5 == loc_3 then
												desired = 2
												break
											end
											continue
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										error("out of code bounds")
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									if load_i32(memory_at_0.data, loc_6) >= loc_8 then
										continue
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_0)
								store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_6))
								store_i64(memory_at_0.data, loc_6, loc_7)
								loc_4 = add_i32(loc_4, 1)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								loc_10 = add_i32(loc_0, 8)
								if loc_10 >= loc_6 then
									break
								end
								while true do
									loc_5 = load_i32(memory_at_0.data, loc_11)
									while true do
										loc_8 = loc_10
										loc_10 = add_i32(loc_8, 8)
										if load_i32(memory_at_0.data, loc_8) < loc_5 then
											continue
										end
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									while true do
										loc_6 = add_i32(loc_6, 4294967288)
										if load_i32(memory_at_0.data, loc_6) >= loc_5 then
											continue
										end
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									while true do
										if loc_8 <= loc_6 then
											break
										end
										loc_10 = loc_8
										desired = 6
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									loc_7 = load_i64(memory_at_0.data, loc_8)
									store_i64(memory_at_0.data, loc_8, load_i64(memory_at_0.data, loc_6))
									store_i64(memory_at_0.data, loc_6, loc_7)
									loc_11 = (if loc_11 == loc_8 then loc_6 else loc_11)
									loc_4 = add_i32(loc_4, 1)
									continue
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								if loc_10 == loc_11 then
									break
								end
								if load_i32(memory_at_0.data, loc_11) >= load_i32(memory_at_0.data, loc_10) then
									break
								end
								loc_7 = load_i64(memory_at_0.data, loc_10)
								store_i64(memory_at_0.data, loc_10, load_i64(memory_at_0.data, loc_11))
								store_i64(memory_at_0.data, loc_11, loc_7)
								loc_4 = add_i32(loc_4, 1)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								if loc_4 ~= 0 then
									break
								end
								reg_0 = FUNC_LIST[180](loc_0, loc_10)
								loc_5 = reg_0
								while true do
									loc_6 = add_i32(loc_10, 8)
									reg_0 = FUNC_LIST[180](loc_6, loc_1)
									if reg_0 == 0 then
										break
									end
									loc_1 = loc_10
									if loc_5 == 0 then
										desired = 1
										break
									end
									desired = 2
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_8 = 2
								if loc_5 ~= 0 then
									desired = 4
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								if ge_i32(sub_i32(loc_10, loc_0), sub_i32(loc_1, loc_10)) then
									break
								end
								FUNC_LIST[174](loc_0, loc_10, loc_2)
								loc_0 = add_i32(loc_10, 8)
								desired = 3
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							FUNC_LIST[174](add_i32(loc_10, 8), loc_1, loc_2)
							loc_1 = loc_10
							desired = 1
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = loc_3
						if loc_5 == loc_3 then
							desired = 2
							break
						end
						while true do
							loc_10 = load_i32(memory_at_0.data, loc_0)
							while true do
								loc_6 = loc_5
								loc_5 = add_i32(loc_6, 8)
								if loc_10 >= load_i32(memory_at_0.data, loc_6) then
									continue
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 4294967288)
								if loc_10 < load_i32(memory_at_0.data, loc_8) then
									continue
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							while true do
								if loc_6 < loc_8 then
									break
								end
								loc_8 = 4
								desired = 4
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
									continue
								end
								break
							end
							loc_7 = load_i64(memory_at_0.data, loc_6)
							store_i64(memory_at_0.data, loc_6, load_i64(memory_at_0.data, loc_8))
							store_i64(memory_at_0.data, loc_8, loc_7)
							continue
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_0 = loc_6
					if loc_8 == 4 then
						continue
					end
					loc_0 = loc_6
					if loc_8 == 2 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
					continue
				end
				break
			end
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		break
	end
end
FUNC_LIST[175] = --[[ Luau::getOpLength(LuauOpcode) ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	local desired
	local br_map = {}
	while true do
		loc_1 = 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, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, }
					end)()
				end
				temp = br_map[1][add_i32(loc_0, 4294967289)] 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_1 = 1
			break
		end
		reg_0 = loc_1
		break
	end
	return reg_0
end
FUNC_LIST[176] = --[[ Luau::BytecodeBuilder::getError(std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > const&) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	while true do
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_0, 8), 0)
		FUNC_LIST[1547](loc_0, 0)
		loc_2 = load_i32_u8(memory_at_0.data, loc_1 + 11)
		loc_3 = (if lt_i32(shr_i32(shl_i32(loc_2, 24), 24), 0) then 1 else 0)
		reg_0 = FUNC_LIST[1541](loc_0, (if loc_3 ~= 0 then load_i32(memory_at_0.data, loc_1) else loc_1), (if loc_3 ~= 0 then load_i32(memory_at_0.data, loc_1 + 4) else loc_2))
		break
	end
end
FUNC_LIST[177] = --[[ std::__2::vector<std::__2::pair<int, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > >, std::__2::allocator<std::__2::pair<int, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > > > >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[178] = --[[ 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(loc_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 = 0
	local loc_9 = 0
	local loc_10 = i64_ZERO
	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 loc_17 = i64_ZERO
	local loc_18 = 0
	local reg_0
	local desired
	while true do
		loc_1 = load_i64(memory_at_0.data, add_i32(loc_0, 24))
		loc_2 = load_i32(memory_at_0.data, loc_0 + 16)
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_4 = (if loc_3 ~= 0 then shl_i32(loc_3, 1) else 16)
				if loc_4 ~= 0 then
					break
				end
				loc_5 = 0
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = add_i32(loc_0, 16)
			reg_0 = FUNC_LIST[1461](mul_i32(loc_4, 24))
			loc_5 = reg_0
			loc_3 = 0
			loc_7 = 0
			while true do
				loc_8 = add_i32(loc_5, mul_i32(loc_3, 24))
				store_i64(memory_at_0.data, loc_8, load_i64(memory_at_0.data, loc_6))
				loc_9 = add_i32(loc_6, 8)
				loc_10 = load_i64(memory_at_0.data, loc_9)
				store_i32(memory_at_0.data, loc_8 + 16, 0)
				store_i64(memory_at_0.data, add_i32(loc_8, 8), loc_10)
				loc_8 = add_i32(loc_5, mul_i32(bor_i32(loc_3, 1), 24))
				store_i64(memory_at_0.data, add_i32(loc_8, 8), load_i64(memory_at_0.data, loc_9))
				store_i64(memory_at_0.data, loc_8, load_i64(memory_at_0.data, loc_6))
				store_i32(memory_at_0.data, loc_8 + 16, 0)
				loc_3 = add_i32(loc_3, 2)
				loc_7 = add_i32(loc_7, 2)
				if loc_7 ~= loc_4 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_3 == 0 then
				break
			end
			loc_11 = add_i32(loc_4, 4294967295)
			loc_12 = load_i32(memory_at_0.data, loc_0 + 4)
			loc_13 = load_i64(memory_at_0.data, loc_0 + 24)
			loc_14 = load_i32(memory_at_0.data, loc_0 + 16)
			loc_15 = load_i32(memory_at_0.data, loc_0)
			loc_16 = 0
			while true do
				loc_7 = add_i32(loc_15, mul_i32(loc_16, 24))
				loc_17 = load_i64(memory_at_0.data, loc_7 + 8)
				while true do
					while true do
						loc_18 = load_i32(memory_at_0.data, loc_7)
						if loc_18 ~= loc_14 then
							break
						end
						if eq_i64(loc_17, loc_13) then
							desired = 3
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_3 = bxor_i32(mul_i32(loc_18, 1540483477), wrap_i32_i64(shr_u64(loc_17, i64_from_u32(32, 0))))
					loc_6 = mul_i32(bxor_i32(shr_u32(loc_3, 18), wrap_i32_i64(loc_17)), 1540483477)
					loc_3 = mul_i32(bxor_i32(shr_u32(loc_6, 22), loc_3), 1540483477)
					loc_6 = band_i32(mul_i32(bxor_i32(shr_u32(mul_i32(bxor_i32(shr_u32(loc_3, 17), loc_6), 1540483477), 19), loc_3), 1540483477), loc_11)
					loc_3 = add_i32(loc_5, mul_i32(loc_6, 24))
					loc_10 = load_i64(memory_at_0.data, loc_3 + 8)
					while true do
						while true do
							while true do
								loc_9 = load_i32(memory_at_0.data, loc_3)
								if loc_9 ~= loc_2 then
									break
								end
								if eq_i64(loc_10, loc_1) then
									desired = 5
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_8 = 0
							while true do
								if loc_9 ~= loc_18 then
									break
								end
								if eq_i64(loc_10, loc_17) then
									desired = 4
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_6 = band_i32(add_i32(loc_8, loc_6), loc_11)
								loc_3 = add_i32(loc_5, mul_i32(loc_6, 24))
								loc_10 = load_i64(memory_at_0.data, loc_3 + 8)
								while true do
									loc_9 = load_i32(memory_at_0.data, loc_3)
									if loc_9 ~= loc_2 then
										break
									end
									if eq_i64(loc_10, loc_1) then
										desired = 5
										break
									end
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
										continue
									end
									break
								end
								if loc_9 ~= loc_18 then
									continue
								end
								if eq_i64(loc_10, loc_17) then
									desired = 4
									break
								end
								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
						store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, loc_7))
						store_i64(memory_at_0.data, add_i32(loc_3, 8), load_i64(memory_at_0.data, add_i32(loc_7, 8)))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, loc_7))
					store_i64(memory_at_0.data, add_i32(loc_3, 8), load_i64(memory_at_0.data, add_i32(loc_7, 8)))
					store_i32(memory_at_0.data, add_i32(loc_5, mul_i32(loc_6, 24)) + 16, load_i32(memory_at_0.data, loc_7 + 16))
					loc_3 = loc_12
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_16 = add_i32(loc_16, 1)
				if loc_16 < loc_3 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_4)
		loc_3 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_5)
		while true do
			if loc_3 == 0 then
				break
			end
			FUNC_LIST[1463](loc_3)
			break
		end
		break
	end
end
FUNC_LIST[179] = --[[ 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(loc_0, loc_1, loc_2, loc_3)
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = i64_ZERO
	local reg_0
	local desired
	while true do
		loc_4 = load_i32(memory_at_0.data, loc_2)
		while true do
			while true do
				loc_5 = load_i32(memory_at_0.data, loc_1)
				if loc_5 < load_i32(memory_at_0.data, loc_0) then
					break
				end
				loc_6 = 0
				if loc_4 >= loc_5 then
					desired = 1
					break
				end
				loc_7 = load_i64(memory_at_0.data, loc_1)
				store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_2))
				store_i64(memory_at_0.data, loc_2, loc_7)
				while true do
					if load_i32(memory_at_0.data, loc_1) < load_i32(memory_at_0.data, loc_0) then
						break
					end
					loc_4 = wrap_i32_i64(loc_7)
					loc_6 = 1
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_7 = load_i64(memory_at_0.data, loc_0)
				store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_1))
				store_i64(memory_at_0.data, loc_1, loc_7)
				loc_4 = load_i32(memory_at_0.data, loc_2)
				loc_6 = 2
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_7 = load_i64(memory_at_0.data, loc_0)
			while true do
				if loc_4 >= loc_5 then
					break
				end
				store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_2))
				store_i64(memory_at_0.data, loc_2, loc_7)
				loc_4 = wrap_i32_i64(loc_7)
				loc_6 = 1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_1))
			store_i64(memory_at_0.data, loc_1, loc_7)
			loc_6 = 1
			loc_4 = load_i32(memory_at_0.data, loc_2)
			loc_5 = wrap_i32_i64(loc_7)
			if loc_4 >= loc_5 then
				break
			end
			store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_2))
			store_i64(memory_at_0.data, loc_2, loc_7)
			loc_6 = 2
			loc_4 = loc_5
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if load_i32(memory_at_0.data, loc_3) >= loc_4 then
				break
			end
			loc_7 = load_i64(memory_at_0.data, loc_2)
			store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_3))
			store_i64(memory_at_0.data, loc_3, loc_7)
			while true do
				if load_i32(memory_at_0.data, loc_2) < load_i32(memory_at_0.data, loc_1) then
					break
				end
				reg_0 = add_i32(loc_6, 1)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_7 = load_i64(memory_at_0.data, loc_1)
			store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_2))
			store_i64(memory_at_0.data, loc_2, loc_7)
			while true do
				if load_i32(memory_at_0.data, loc_1) < load_i32(memory_at_0.data, loc_0) then
					break
				end
				reg_0 = add_i32(loc_6, 2)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_7 = load_i64(memory_at_0.data, loc_0)
			store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_1))
			store_i64(memory_at_0.data, loc_1, loc_7)
			loc_6 = add_i32(loc_6, 3)
			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[180] = --[[ bool std::__2::__insertion_sort_incomplete<Luau::BytecodeBuilder::expandJumps()::$_0&, Luau::BytecodeBuilder::Jump*>(Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::Jump*, Luau::BytecodeBuilder::expandJumps()::$_0&) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = i64_ZERO
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = i64_ZERO
	local loc_8 = 0
	local loc_9 = 0
	local reg_0
	local desired
	local br_map = {}
	while true do
		loc_2 = 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
								temp = br_map[1][shr_i32(sub_i32(loc_1, loc_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_3 = add_i32(loc_1, 4294967288)
							if load_i32(memory_at_0.data, loc_3) >= load_i32(memory_at_0.data, loc_0) then
								desired = 1
								break
							end
							loc_4 = load_i64(memory_at_0.data, loc_0)
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3))
							store_i64(memory_at_0.data, loc_3, loc_4)
							reg_0 = 1
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_3 = add_i32(loc_1, 4294967288)
						loc_5 = load_i32(memory_at_0.data, loc_3)
						while true do
							loc_6 = load_i32(memory_at_0.data, loc_0 + 8)
							if loc_6 < load_i32(memory_at_0.data, loc_0) then
								break
							end
							if loc_5 >= loc_6 then
								desired = 1
								break
							end
							loc_4 = load_i64(memory_at_0.data, loc_0 + 8)
							store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_3))
							store_i64(memory_at_0.data, loc_3, loc_4)
							if load_i32(memory_at_0.data, loc_0 + 8) >= load_i32(memory_at_0.data, loc_0) then
								desired = 1
								break
							end
							loc_4 = load_i64(memory_at_0.data, loc_0 + 8)
							store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_0))
							store_i64(memory_at_0.data, loc_0, loc_4)
							reg_0 = 1
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_4 = load_i64(memory_at_0.data, loc_0)
						while true do
							if loc_5 >= loc_6 then
								break
							end
							store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_3))
							store_i64(memory_at_0.data, loc_3, loc_4)
							reg_0 = 1
							desired = 0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_7 = load_i64(memory_at_0.data, loc_0 + 8)
						store_i64(memory_at_0.data, loc_0 + 8, loc_4)
						store_i64(memory_at_0.data, loc_0, loc_7)
						if load_i32(memory_at_0.data, loc_3) >= wrap_i32_i64(loc_4) then
							desired = 1
							break
						end
						store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_3))
						store_i64(memory_at_0.data, loc_3, loc_4)
						reg_0 = 1
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					reg_0 = FUNC_LIST[179](loc_0, add_i32(loc_0, 8), add_i32(loc_0, 16), add_i32(loc_1, 4294967288))
					reg_0 = 1
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = add_i32(loc_0, 8)
				loc_5 = add_i32(loc_0, 16)
				loc_3 = add_i32(loc_0, 24)
				reg_0 = FUNC_LIST[179](loc_0, loc_8, loc_5, loc_3)
				loc_6 = add_i32(loc_1, 4294967288)
				if load_i32(memory_at_0.data, loc_6) >= load_i32(memory_at_0.data, loc_0 + 24) then
					desired = 1
					break
				end
				loc_4 = load_i64(memory_at_0.data, loc_3)
				store_i64(memory_at_0.data, loc_3, load_i64(memory_at_0.data, loc_6))
				store_i64(memory_at_0.data, loc_6, loc_4)
				if load_i32(memory_at_0.data, loc_3) >= load_i32(memory_at_0.data, loc_5) then
					desired = 1
					break
				end
				loc_7 = load_i64(memory_at_0.data, loc_5)
				loc_4 = load_i64(memory_at_0.data, loc_3)
				store_i64(memory_at_0.data, loc_5, loc_4)
				store_i64(memory_at_0.data, loc_3, loc_7)
				loc_3 = wrap_i32_i64(loc_4)
				if load_i32(memory_at_0.data, loc_8) <= loc_3 then
					desired = 1
					break
				end
				store_i64(memory_at_0.data, loc_0 + 16, load_i64(memory_at_0.data, loc_0 + 8))
				store_i64(memory_at_0.data, loc_0 + 8, loc_4)
				if load_i32(memory_at_0.data, loc_0) <= loc_3 then
					desired = 1
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_0))
				store_i64(memory_at_0.data, loc_0, loc_4)
				reg_0 = 1
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = load_i32(memory_at_0.data, loc_0 + 16)
			while true do
				while true do
					loc_5 = load_i32(memory_at_0.data, loc_0 + 8)
					loc_6 = load_i32(memory_at_0.data, loc_0)
					if loc_5 < loc_6 then
						break
					end
					if loc_3 >= loc_5 then
						desired = 2
						break
					end
					loc_4 = load_i64(memory_at_0.data, loc_0 + 16)
					loc_7 = load_i64(memory_at_0.data, loc_0 + 8)
					store_i64(memory_at_0.data, loc_0 + 16, loc_7)
					store_i64(memory_at_0.data, loc_0 + 8, loc_4)
					loc_3 = wrap_i32_i64(loc_7)
					if loc_6 <= wrap_i32_i64(loc_4) then
						desired = 2
						break
					end
					store_i64(memory_at_0.data, loc_0 + 8, load_i64(memory_at_0.data, loc_0))
					store_i64(memory_at_0.data, loc_0, loc_4)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_4 = load_i64(memory_at_0.data, loc_0)
				while true do
					if loc_3 >= loc_5 then
						break
					end
					loc_7 = load_i64(memory_at_0.data, loc_0 + 16)
					store_i64(memory_at_0.data, loc_0 + 16, loc_4)
					store_i64(memory_at_0.data, loc_0, loc_7)
					loc_3 = wrap_i32_i64(loc_4)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_7 = load_i64(memory_at_0.data, loc_0 + 8)
				store_i64(memory_at_0.data, loc_0 + 8, loc_4)
				store_i64(memory_at_0.data, loc_0, loc_7)
				loc_5 = wrap_i32_i64(loc_4)
				if loc_3 >= loc_5 then
					break
				end
				loc_7 = load_i64(memory_at_0.data, loc_0 + 16)
				store_i64(memory_at_0.data, loc_0 + 16, loc_4)
				store_i64(memory_at_0.data, loc_0 + 8, loc_7)
				loc_3 = loc_5
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_5 = add_i32(loc_0, 24)
			if loc_5 == loc_1 then
				break
			end
			loc_2 = add_i32(loc_0, 16)
			loc_9 = 0
			while true do
				while true do
					while true do
						loc_8 = loc_5
						if load_i32(memory_at_0.data, loc_8) >= loc_3 then
							break
						end
						loc_4 = load_i64(memory_at_0.data, loc_8)
						loc_6 = wrap_i32_i64(loc_4)
						loc_5 = loc_8
						while true do
							while true do
								loc_3 = loc_2
								store_i64(memory_at_0.data, loc_5, load_i64(memory_at_0.data, loc_3))
								while true do
									if loc_3 ~= loc_0 then
										break
									end
									loc_3 = loc_0
									desired = 5
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
										continue
									end
									break
								end
								loc_5 = loc_3
								loc_2 = add_i32(loc_3, 4294967288)
								if load_i32(memory_at_0.data, loc_2) > loc_6 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_i64(memory_at_0.data, loc_3, loc_4)
						loc_9 = add_i32(loc_9, 1)
						if loc_9 == 8 then
							desired = 2
							break
						end
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					while true do
						loc_5 = add_i32(loc_8, 8)
						if loc_5 ~= loc_1 then
							break
						end
						reg_0 = 1
						desired = 0
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_3 = load_i32(memory_at_0.data, loc_8)
					loc_2 = loc_8
					continue
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_2 = (if add_i32(loc_8, 8) == loc_1 then 1 else 0)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		reg_0 = loc_2
		break
	end
	return reg_0
end
FUNC_LIST[181] = --[[ Luau::Compile::modelCost(Luau::AstNode*, Luau::AstLocal* const*, unsigned long, Luau::DenseHashMap<Luau::AstExprCall*, int, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprCall*> > const&) ]] function(loc_0, loc_1, loc_2, loc_3)
	local loc_4 = 0
	local loc_5 = i64_ZERO
	local loc_6 = i64_ZERO
	local reg_0
	while true do
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_4
		loc_5 = i64_ZERO
		store_i64(memory_at_0.data, add_i32(loc_4, 16), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 40), i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 8, i64_ZERO)
		store_i32(memory_at_0.data, loc_4 + 4, loc_3)
		store_i64(memory_at_0.data, loc_4 + 32, i64_ZERO)
		loc_3 = add_i32(15056, 8)
		store_i32(memory_at_0.data, loc_4, loc_3)
		while true do
			if loc_2 == 0 then
				break
			end
			loc_2 = add_i32(loc_2, 4294967295)
			loc_6 = extend_i64_u32(add_i32((if loc_2 < 6 then loc_2 else 6), 1))
			loc_2 = add_i32(loc_4, 8)
			while true do
				reg_0 = FUNC_LIST[182](loc_2, add_i32(loc_1, shl_i32(wrap_i32_i64(loc_5), 2)))
				store_i64(memory_at_0.data, reg_0, shl_i64(i64_from_u32(65280, 0), shl_i64(loc_5, i64_from_u32(3, 0))))
				loc_5 = add_i64(loc_5, i64_ONE)
				if ne_i64(loc_5, loc_6) then
					continue
				end
				break
			end
			break
		end
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0))](loc_0, loc_4)
		store_i32(memory_at_0.data, loc_4, loc_3)
		loc_5 = load_i64(memory_at_0.data, loc_4 + 32)
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_4 + 8)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_4, 48)
		reg_0 = loc_5
		break
	end
	return reg_0
end
FUNC_LIST[182] = --[[ Luau::DenseHashMap<Luau::AstLocal*, unsigned long long, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::operator[](Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_9, 4)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[183](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, shl_i32(loc_9, 4))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 8)
		break
	end
	return reg_0
end
FUNC_LIST[183] = --[[ 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(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 12)
		while true do
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
				loc_3 = (if loc_2 ~= 0 then shl_i32(loc_2, 1) else 16)
				if loc_3 ~= 0 then
					break
				end
				loc_4 = 0
				loc_5 = loc_1
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = band_i32(loc_3, 2)
			reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 4))
			loc_4 = reg_0
			loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
			loc_7 = 0
			loc_8 = 0
			while true do
				if add_i32(loc_3, 4294967295) < 3 then
					break
				end
				loc_9 = band_i32(loc_3, 4294967292)
				loc_8 = 0
				loc_10 = 0
				while true do
					loc_11 = shl_i32(loc_8, 4)
					loc_12 = add_i32(loc_4, loc_11)
					store_i64(memory_at_0.data, loc_12 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 16))
					store_i64(memory_at_0.data, loc_12 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_12 = add_i32(loc_4, bor_i32(loc_11, 32))
					store_i64(memory_at_0.data, loc_12 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_12, loc_5)
					loc_11 = add_i32(loc_4, bor_i32(loc_11, 48))
					store_i64(memory_at_0.data, loc_11 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 4)
					loc_10 = add_i32(loc_10, 4)
					if loc_10 ~= loc_9 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
			while true do
				if loc_6 == 0 then
					break
				end
				while true do
					loc_11 = add_i32(loc_4, shl_i32(loc_8, 4))
					store_i64(memory_at_0.data, loc_11 + 8, i64_ZERO)
					store_i32(memory_at_0.data, loc_11, loc_5)
					loc_8 = add_i32(loc_8, 1)
					loc_7 = add_i32(loc_7, 1)
					if loc_7 ~= loc_6 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_2 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		while true do
			if loc_2 == 0 then
				break
			end
			loc_12 = add_i32(loc_3, 4294967295)
			loc_13 = load_i32(memory_at_0.data, loc_0)
			loc_6 = 0
			while true do
				while true do
					loc_9 = add_i32(loc_13, shl_i32(loc_6, 4))
					loc_11 = load_i32(memory_at_0.data, loc_9)
					if loc_11 == loc_5 then
						break
					end
					while true do
						while true do
							loc_5 = band_i32(bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9)), loc_12)
							loc_10 = add_i32(loc_4, shl_i32(loc_5, 4))
							loc_7 = load_i32(memory_at_0.data, loc_10)
							if loc_7 == loc_1 then
								break
							end
							loc_8 = 0
							if loc_7 == loc_11 then
								desired = 4
								break
							end
							while true do
								loc_8 = add_i32(loc_8, 1)
								loc_5 = band_i32(add_i32(loc_8, loc_5), loc_12)
								loc_10 = add_i32(loc_4, shl_i32(loc_5, 4))
								loc_7 = load_i32(memory_at_0.data, loc_10)
								if loc_7 == loc_1 then
									desired = 5
									break
								end
								if loc_7 == loc_11 then
									desired = 4
									break
								end
								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
						store_i32(memory_at_0.data, loc_10, loc_11)
						loc_11 = load_i32(memory_at_0.data, loc_9)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_10, loc_11)
					store_i64(memory_at_0.data, add_i32(loc_4, shl_i32(loc_5, 4)) + 8, load_i64(memory_at_0.data, loc_9 + 8))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_6 = add_i32(loc_6, 1)
				if loc_6 == loc_2 then
					desired = 1
					break
				end
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 4, loc_3)
		loc_5 = load_i32(memory_at_0.data, loc_0)
		store_i32(memory_at_0.data, loc_0, loc_4)
		while true do
			if loc_5 == 0 then
				break
			end
			FUNC_LIST[1463](loc_5)
			break
		end
		break
	end
end
FUNC_LIST[184] = --[[ Luau::Compile::CostVisitor::~CostVisitor() ]] function(loc_0)
	local loc_1 = 0
	local reg_0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(15056, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 8)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
			break
		end
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[185] = --[[ Luau::Compile::computeCost(unsigned long long, bool const*, unsigned long) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local reg_0
	local desired
	while true do
		loc_3 = 127
		while true do
			loc_4 = wrap_i32_i64(loc_0)
			loc_5 = band_i32(loc_4, 127)
			if loc_5 == 127 then
				break
			end
			while true do
				if loc_2 ~= 0 then
					break
				end
				reg_0 = loc_5
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = sub_i32(loc_5, mul_i32(band_i32(shr_u32(loc_4, 8), 127), load_i32_u8(memory_at_0.data, loc_1)))
			loc_2 = add_i32(loc_2, 4294967295)
			loc_2 = (if loc_2 < 6 then loc_2 else 6)
			if loc_2 == 0 then
				break
			end
			loc_3 = sub_i32(loc_3, mul_i32(band_i32(shr_u32(loc_4, 16), 127), load_i32_u8(memory_at_0.data, loc_1 + 1)))
			loc_2 = add_i32(loc_2, 1)
			if loc_2 == 2 then
				break
			end
			loc_3 = sub_i32(loc_3, mul_i32(band_i32(shr_u32(loc_4, 24), 127), load_i32_u8(memory_at_0.data, loc_1 + 2)))
			if loc_2 == 3 then
				break
			end
			loc_3 = sub_i32(loc_3, mul_i32(band_i32(wrap_i32_i64(shr_u64(loc_0, i64_from_u32(32, 0))), 127), load_i32_u8(memory_at_0.data, loc_1 + 3)))
			if loc_2 == 4 then
				break
			end
			loc_3 = sub_i32(loc_3, mul_i32(band_i32(wrap_i32_i64(shr_u64(loc_0, i64_from_u32(40, 0))), 127), load_i32_u8(memory_at_0.data, loc_1 + 4)))
			if loc_2 == 5 then
				break
			end
			loc_3 = sub_i32(loc_3, mul_i32(band_i32(wrap_i32_i64(shr_u64(loc_0, i64_from_u32(48, 0))), 127), load_i32_u8(memory_at_0.data, loc_1 + 5)))
			if loc_2 == 6 then
				break
			end
			loc_3 = sub_i32(loc_3, mul_i32(band_i32(wrap_i32_i64(shr_u64(loc_0, i64_from_u32(56, 0))), 127), load_i32_u8(memory_at_0.data, loc_1 + 6)))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		reg_0 = loc_3
		break
	end
	return reg_0
end
FUNC_LIST[186] = --[[ Luau::Compile::getTripCount(double, double, double) ]] function(loc_0, loc_1, loc_2)
	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 = 2147483648
		loc_4 = 2147483648
		while true do
			if (if loc_0 >= -3.2767e4 then 1 else 0) == 0 then
				break
			end
			loc_4 = 2147483648
			if (if loc_0 <= 3.2767e4 then 1 else 0) == 0 then
				break
			end
			while true do
				while true do
					if (if abs_f64(loc_0) < 2.147483648e9 then 1 else 0) == 0 then
						break
					end
					loc_5 = truncate_i32_f64(loc_0)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_5 = 2147483648
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_4 = 2147483648
			if convert_f64_i32(loc_5) ~= loc_0 then
				break
			end
			loc_4 = loc_5
			break
		end
		while true do
			if (if loc_1 >= -3.2767e4 then 1 else 0) == 0 then
				break
			end
			if (if loc_1 <= 3.2767e4 then 1 else 0) == 0 then
				break
			end
			while true do
				while true do
					if (if abs_f64(loc_1) < 2.147483648e9 then 1 else 0) == 0 then
						break
					end
					loc_5 = truncate_i32_f64(loc_1)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_5 = 2147483648
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if convert_f64_i32(loc_5) ~= loc_1 then
				break
			end
			loc_3 = loc_5
			break
		end
		loc_5 = 2147483648
		while true do
			if (if loc_2 >= -3.2767e4 then 1 else 0) == 0 then
				break
			end
			loc_5 = 2147483648
			if (if loc_2 <= 3.2767e4 then 1 else 0) == 0 then
				break
			end
			while true do
				while true do
					if (if abs_f64(loc_2) < 2.147483648e9 then 1 else 0) == 0 then
						break
					end
					loc_6 = truncate_i32_f64(loc_2)
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_6 = 2147483648
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_5 = 2147483648
			if convert_f64_i32(loc_6) ~= loc_2 then
				break
			end
			loc_5 = loc_6
			break
		end
		loc_6 = 4294967295
		while true do
			if loc_4 == 2147483648 then
				break
			end
			if loc_3 == 2147483648 then
				break
			end
			if loc_5 == 2147483648 then
				break
			end
			if loc_5 == 0 then
				break
			end
			loc_6 = 0
			while true do
				if gt_i32(loc_5, 4294967295) then
					break
				end
				if gt_i32(loc_3, loc_4) then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if lt_i32(loc_5, 1) then
					break
				end
				if lt_i32(loc_3, loc_4) then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_6 = add_i32(div_i32(sub_i32(loc_3, loc_4), loc_5), 1)
			break
		end
		reg_0 = loc_6
		break
	end
	return reg_0
end
FUNC_LIST[187] = --[[ Luau::Compile::CostVisitor::~CostVisitor().1 ]] function(loc_0)
	local loc_1 = 0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(15056, 8))
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 8)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[188] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstExpr*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = i64_ZERO
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		FUNC_LIST[189](loc_2, loc_0, loc_1)
		loc_3 = load_i64(memory_at_0.data, loc_2)
		store_i64(memory_at_0.data, add_i32(loc_0, 40), i64_ZERO)
		loc_3 = add_i64(loc_3, load_i64(memory_at_0.data, loc_0 + 32))
		loc_4 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_4, shr_u64(loc_4, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143))))
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[189] = --[[ Luau::Compile::CostVisitor::model(Luau::AstExpr*) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = i64_ZERO
	local loc_7 = i64_ZERO
	local loc_8 = 0
	local loc_9 = i64_ZERO
	local reg_0
	local desired
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 64)
		GLOBAL_LIST[0].value = loc_3
		loc_4 = load_i32(memory_at_0.data, loc_2 + 4)
		while true do
			if loc_2 == 0 then
				break
			end
			loc_5 = load_i32(memory_at_0.data, 0 + 59848)
			if loc_4 ~= loc_5 then
				break
			end
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_2 + 24)
				loc_4 = load_i32(memory_at_0.data, loc_2 + 4)
				if loc_2 == 0 then
					desired = 1
					break
				end
				if loc_4 == loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			while true do
				while true do
					if loc_4 == load_i32(memory_at_0.data, 0 + 59856) then
						break
					end
					if loc_4 == load_i32(memory_at_0.data, 0 + 59864) then
						break
					end
					if loc_4 == load_i32(memory_at_0.data, 0 + 59872) then
						break
					end
					if loc_4 ~= load_i32(memory_at_0.data, 0 + 59880) then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_from_u32(4294967295, 4294967295))
				store_i64(memory_at_0.data, loc_0, i64_ZERO)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59888) then
					break
				end
				loc_6 = i64_ZERO
				while true do
					reg_0 = FUNC_LIST[200](add_i32(loc_1, 8), add_i32(loc_2, 24))
					loc_2 = reg_0
					if loc_2 == 0 then
						break
					end
					loc_6 = load_i64(memory_at_0.data, loc_2)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, loc_6)
				store_i64(memory_at_0.data, loc_0, i64_ZERO)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59896) then
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				store_i64(memory_at_0.data, loc_0, i64_ONE)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59904) then
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_5 = (if loc_4 == load_i32(memory_at_0.data, 0 + 59912) then loc_2 else 0)
			store_i32(memory_at_0.data, loc_3 + 60, loc_5)
			while true do
				if loc_5 == 0 then
					break
				end
				while true do
					while true do
						reg_0 = FUNC_LIST[73](load_i32(memory_at_0.data, loc_1 + 4), add_i32(loc_3, 60))
						if reg_0 == 0 then
							break
						end
						loc_4 = load_i32(memory_at_0.data, loc_3 + 60)
						loc_2 = load_i32(memory_at_0.data, add_i32(loc_4, 32))
						store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
						store_i64(memory_at_0.data, loc_0, i64_from_u32(2, 0))
						loc_5 = (if loc_2 < 3 then 1 else 0)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
					store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
					FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_3 + 60) + 24))
					loc_6 = load_i64(memory_at_0.data, loc_3 + 40)
					store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
					loc_6 = add_i64(loc_6, load_i64(memory_at_0.data, loc_0))
					loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
					store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
					loc_4 = load_i32(memory_at_0.data, loc_3 + 60)
					loc_2 = load_i32(memory_at_0.data, add_i32(loc_4, 32))
					loc_5 = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				if loc_2 == 0 then
					desired = 1
					break
				end
				loc_2 = 0
				while true do
					FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_4 + 28), shl_i32(loc_2, 2))))
					loc_6 = load_i64(memory_at_0.data, loc_3 + 40)
					store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
					loc_6 = add_i64((if ne_i64(loc_6, i64_ZERO) then loc_6 else (if loc_5 ~= 0 then loc_6 else i64_ONE)), load_i64(memory_at_0.data, loc_0))
					loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
					store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
					loc_2 = add_i32(loc_2, 1)
					loc_4 = load_i32(memory_at_0.data, loc_3 + 60)
					if loc_2 < load_i32(memory_at_0.data, add_i32(loc_4, 32)) then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59920) then
					break
				end
				FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				loc_6 = add_i64(load_i64(memory_at_0.data, loc_3 + 40), i64_ONE)
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59928) then
					break
				end
				FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
				FUNC_LIST[189](add_i32(loc_3, 24), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
				loc_6 = load_i64(memory_at_0.data, loc_3 + 24)
				loc_7 = load_i64(memory_at_0.data, loc_3 + 40)
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				loc_6 = add_i64(loc_6, loc_7)
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				loc_6 = add_i64(bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))), i64_ONE)
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59936) then
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				store_i64(memory_at_0.data, loc_0, i64_from_u32(10, 0))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59944) then
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				store_i64(memory_at_0.data, loc_0, i64_from_u32(10, 0))
				if load_i32(memory_at_0.data, add_i32(loc_2, 28)) == 0 then
					desired = 1
					break
				end
				loc_4 = 0
				while true do
					while true do
						loc_5 = add_i32(load_i32(memory_at_0.data, loc_2 + 24), mul_i32(loc_4, 12))
						loc_8 = load_i32(memory_at_0.data, loc_5 + 4)
						if loc_8 == 0 then
							break
						end
						FUNC_LIST[189](add_i32(loc_3, 40), loc_1, loc_8)
						loc_6 = load_i64(memory_at_0.data, loc_3 + 40)
						store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
						loc_6 = add_i64(loc_6, load_i64(memory_at_0.data, loc_0))
						loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
						store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, loc_5 + 8))
					loc_6 = load_i64(memory_at_0.data, loc_0)
					loc_7 = load_i64(memory_at_0.data, loc_3 + 40)
					store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
					loc_6 = add_i64(loc_7, loc_6)
					loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
					loc_6 = add_i64(bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))), i64_ONE)
					loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
					store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
					loc_4 = add_i32(loc_4, 1)
					if loc_4 < load_i32(memory_at_0.data, loc_2 + 28) then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59952) then
					break
				end
				FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
				store_i64(memory_at_0.data, loc_3 + 32, i64_from_u32(4294967295, 4294967295))
				store_i64(memory_at_0.data, loc_3 + 24, i64_ZERO)
				FUNC_LIST[201](loc_0, add_i32(loc_3, 40), add_i32(loc_3, 24))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59960) then
					break
				end
				FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 28)))
				FUNC_LIST[189](add_i32(loc_3, 24), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 32)))
				FUNC_LIST[201](loc_0, add_i32(loc_3, 40), add_i32(loc_3, 24))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59968) then
					break
				end
				FUNC_LIST[189](loc_0, loc_1, load_i32(memory_at_0.data, loc_2 + 24))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59976) then
					break
				end
				FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, loc_2 + 24))
				FUNC_LIST[189](add_i32(loc_3, 24), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 32)))
				loc_6 = load_i64(memory_at_0.data, loc_3 + 24)
				loc_7 = load_i64(memory_at_0.data, loc_3 + 40)
				FUNC_LIST[189](add_i32(loc_3, 8), loc_1, load_i32(memory_at_0.data, add_i32(loc_2, 40)))
				loc_9 = load_i64(memory_at_0.data, loc_3 + 8)
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				loc_6 = add_i64(loc_6, loc_7)
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				loc_6 = add_i64(loc_9, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				loc_6 = add_i64(bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))), i64_from_u32(2, 0))
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 ~= load_i32(memory_at_0.data, 0 + 59984) then
					break
				end
				store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
				store_i64(memory_at_0.data, loc_0, i64_from_u32(3, 0))
				loc_4 = load_i32(memory_at_0.data, add_i32(loc_2, 36))
				if loc_4 == 0 then
					desired = 1
					break
				end
				loc_2 = load_i32(memory_at_0.data, add_i32(loc_2, 32))
				loc_4 = add_i32(loc_2, shl_i32(loc_4, 2))
				while true do
					FUNC_LIST[189](add_i32(loc_3, 40), loc_1, load_i32(memory_at_0.data, loc_2))
					loc_6 = load_i64(memory_at_0.data, loc_3 + 40)
					store_i64(memory_at_0.data, loc_0 + 8, i64_ZERO)
					loc_6 = add_i64(loc_6, load_i64(memory_at_0.data, loc_0))
					loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
					store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
					loc_2 = add_i32(loc_2, 4)
					if loc_2 ~= loc_4 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, loc_0, i64_ZERO)
			store_i64(memory_at_0.data, add_i32(loc_0, 8), i64_ZERO)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_3, 64)
		break
	end
end
FUNC_LIST[190] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatIf*) ]] function(loc_0, loc_1)
	local loc_2 = i64_ZERO
	local loc_3 = i64_ZERO
	local reg_0
	local desired
	while true do
		while true do
			while true do
				loc_1 = load_i32(memory_at_0.data, loc_1 + 36)
				if loc_1 ~= 0 then
					break
				end
				loc_2 = i64_ONE
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_2 = (if load_i32(memory_at_0.data, loc_1 + 4) == load_i32(memory_at_0.data, 0 + 60000) then i64_ONE else i64_from_u32(2, 0))
			break
		end
		store_i64(memory_at_0.data, add_i32(loc_0, 40), i64_ZERO)
		loc_2 = add_i64(load_i64(memory_at_0.data, loc_0 + 32), loc_2)
		loc_3 = band_i64(loc_2, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))), band_i64(loc_2, i64_from_u32(2139062143, 2139062143))))
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[191] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatWhile*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = 0
	local loc_5 = i64_ZERO
	local loc_6 = i64_ZERO
	local reg_0
	local reg_1
	local reg_2
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, loc_1 + 28))
		loc_1 = load_i32(memory_at_0.data, loc_1 + 32)
		loc_3 = load_i64(memory_at_0.data, loc_2)
		loc_4 = add_i32(loc_0, 40)
		store_i64(memory_at_0.data, loc_4, i64_ZERO)
		loc_5 = load_i64(memory_at_0.data, loc_0 + 32)
		store_i64(memory_at_0.data, loc_0 + 32, i64_ZERO)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1))](loc_1, loc_0)
		store_i64(memory_at_0.data, loc_4, i64_ZERO)
		loc_3 = add_i64(loc_3, load_i64(memory_at_0.data, loc_0 + 32))
		loc_6 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		loc_3 = bor_i64(sub_i64(loc_6, shr_u64(loc_6, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143)))
		loc_6 = band_i64(shr_u64(loc_3, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199))
		loc_3 = mul_i64(band_i64(loc_3, i64_from_u32(8323199, 8323199)), i64_from_u32(3, 0))
		reg_2 = bor_i64(band_i64(mul_i64(loc_6, i64_from_u32(768, 0)), i64_from_u32(2130738944, 2130738944)), band_i64(loc_3, i64_from_u32(8323199, 8323199)))
		loc_3 = bor_i64(band_i64(shr_u64(add_i64(loc_3, i64_from_u32(2139127680, 2139127680)), i64_from_u32(8, 0)), i64_from_u32(8388736, 8388736)), band_i64(add_i64(mul_i64(loc_6, i64_from_u32(3, 0)), i64_from_u32(2139127680, 2139127680)), i64_from_u32(2147516416, 2147516416)))
		loc_3 = add_i64(loc_5, bor_i64(reg_2, sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0)))))
		loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143))))
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[192] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatRepeat*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = 0
	local loc_5 = i64_ZERO
	local loc_6 = i64_ZERO
	local reg_0
	local reg_1
	local reg_2
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, loc_1 + 28))
		loc_1 = load_i32(memory_at_0.data, loc_1 + 32)
		loc_3 = load_i64(memory_at_0.data, loc_2)
		loc_4 = add_i32(loc_0, 40)
		store_i64(memory_at_0.data, loc_4, i64_ZERO)
		loc_5 = load_i64(memory_at_0.data, loc_0 + 32)
		store_i64(memory_at_0.data, loc_0 + 32, i64_ZERO)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1))](loc_1, loc_0)
		store_i64(memory_at_0.data, loc_4, i64_ZERO)
		loc_3 = add_i64(loc_3, load_i64(memory_at_0.data, loc_0 + 32))
		loc_6 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		loc_3 = bor_i64(sub_i64(loc_6, shr_u64(loc_6, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143)))
		loc_6 = band_i64(shr_u64(loc_3, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199))
		loc_3 = mul_i64(band_i64(loc_3, i64_from_u32(8323199, 8323199)), i64_from_u32(3, 0))
		reg_2 = bor_i64(band_i64(mul_i64(loc_6, i64_from_u32(768, 0)), i64_from_u32(2130738944, 2130738944)), band_i64(loc_3, i64_from_u32(8323199, 8323199)))
		loc_3 = bor_i64(band_i64(shr_u64(add_i64(loc_3, i64_from_u32(2139127680, 2139127680)), i64_from_u32(8, 0)), i64_from_u32(8388736, 8388736)), band_i64(add_i64(mul_i64(loc_6, i64_from_u32(3, 0)), i64_from_u32(2139127680, 2139127680)), i64_from_u32(2147516416, 2147516416)))
		loc_3 = add_i64(loc_5, bor_i64(reg_2, sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0)))))
		loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143))))
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[193] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatBreak*) ]] function(loc_0, loc_1)
	local loc_2 = i64_ZERO
	local loc_3 = i64_ZERO
	local reg_0
	while true do
		store_i64(memory_at_0.data, add_i32(loc_0, 40), i64_ZERO)
		loc_2 = add_i64(load_i64(memory_at_0.data, loc_0 + 32), i64_ONE)
		loc_3 = band_i64(loc_2, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))), band_i64(loc_2, i64_from_u32(2139062143, 2139062143))))
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[194] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatContinue*) ]] function(loc_0, loc_1)
	local loc_2 = i64_ZERO
	local loc_3 = i64_ZERO
	local reg_0
	while true do
		store_i64(memory_at_0.data, add_i32(loc_0, 40), i64_ZERO)
		loc_2 = add_i64(load_i64(memory_at_0.data, loc_0 + 32), i64_ONE)
		loc_3 = band_i64(loc_2, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))), band_i64(loc_2, i64_from_u32(2139062143, 2139062143))))
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[195] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatLocal*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = i64_ZERO
	local loc_7 = i64_ZERO
	local reg_0
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_1, 40)) == 0 then
				break
			end
			loc_3 = add_i32(loc_0, 8)
			loc_4 = 0
			while true do
				loc_5 = shl_i32(loc_4, 2)
				FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), loc_5)))
				while true do
					loc_6 = load_i64(memory_at_0.data, loc_2 + 8)
					if eq_i64(loc_6, i64_ZERO) then
						break
					end
					if loc_4 >= load_i32(memory_at_0.data, loc_1 + 32) then
						break
					end
					reg_0 = FUNC_LIST[182](loc_3, add_i32(load_i32(memory_at_0.data, loc_1 + 28), loc_5))
					store_i64(memory_at_0.data, reg_0, loc_6)
					break
				end
				loc_6 = load_i64(memory_at_0.data, loc_2)
				store_i64(memory_at_0.data, loc_0 + 40, i64_ZERO)
				loc_6 = add_i64(loc_6, load_i64(memory_at_0.data, loc_0 + 32))
				loc_7 = band_i64(loc_6, i64_from_u32(2155905152, 2155905152))
				store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_7, shr_u64(loc_7, i64_from_u32(7, 0))), band_i64(loc_6, i64_from_u32(2139062143, 2139062143))))
				loc_4 = add_i32(loc_4, 1)
				if loc_4 < load_i32(memory_at_0.data, loc_1 + 40) then
					continue
				end
				break
			end
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[196] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatFor*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = 0
	local loc_5 = i64_ZERO
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0.0
	local loc_10 = 0.0
	local loc_11 = 0.0
	local loc_12 = 0
	local loc_13 = i64_ZERO
	local loc_14 = i64_ZERO
	local reg_0
	local reg_1
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, loc_1 + 32))
		loc_3 = load_i64(memory_at_0.data, loc_2)
		loc_4 = add_i32(loc_0, 40)
		store_i64(memory_at_0.data, loc_4, i64_ZERO)
		loc_3 = add_i64(loc_3, load_i64(memory_at_0.data, loc_0 + 32))
		loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143))))
		FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, loc_1 + 36))
		loc_3 = load_i64(memory_at_0.data, loc_2)
		store_i64(memory_at_0.data, loc_4, i64_ZERO)
		loc_3 = add_i64(loc_3, load_i64(memory_at_0.data, loc_0 + 32))
		loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		loc_3 = bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143)))
		store_i64(memory_at_0.data, loc_0 + 32, loc_3)
		while true do
			loc_4 = load_i32(memory_at_0.data, loc_1 + 40)
			if loc_4 == 0 then
				break
			end
			FUNC_LIST[189](loc_2, loc_0, loc_4)
			loc_3 = add_i64(load_i64(memory_at_0.data, loc_2), load_i64(memory_at_0.data, loc_0 + 32))
			loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
			loc_3 = bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143)))
			break
		end
		loc_6 = add_i32(loc_0, 32)
		loc_7 = load_i32(memory_at_0.data, 0 + 59872)
		loc_4 = load_i32(memory_at_0.data, loc_1 + 32)
		loc_8 = load_i32(memory_at_0.data, loc_4 + 4)
		while true do
			while true do
				while true do
					while true do
						while true do
							if loc_4 == 0 then
								break
							end
							if loc_8 ~= loc_7 then
								break
							end
							loc_9 = load_f64(memory_at_0.data, loc_4 + 24)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_4 == 0 then
							desired = 3
							break
						end
						if loc_8 ~= load_i32(memory_at_0.data, 0 + 59952) then
							desired = 3
							break
						end
						if load_i32(memory_at_0.data, loc_4 + 24) ~= 1 then
							desired = 3
							break
						end
						loc_4 = load_i32(memory_at_0.data, add_i32(loc_4, 28))
						if load_i32(memory_at_0.data, loc_4 + 4) ~= loc_7 then
							desired = 3
							break
						end
						if loc_4 == 0 then
							desired = 3
							break
						end
						loc_9 = neg_f64(load_f64(memory_at_0.data, loc_4 + 24))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_4 = load_i32(memory_at_0.data, loc_1 + 36)
					loc_8 = load_i32(memory_at_0.data, loc_4 + 4)
					while true do
						while true do
							if loc_4 == 0 then
								break
							end
							if loc_8 ~= loc_7 then
								break
							end
							loc_10 = load_f64(memory_at_0.data, loc_4 + 24)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_4 == 0 then
							desired = 3
							break
						end
						if loc_8 ~= load_i32(memory_at_0.data, 0 + 59952) then
							desired = 3
							break
						end
						if load_i32(memory_at_0.data, loc_4 + 24) ~= 1 then
							desired = 3
							break
						end
						loc_4 = load_i32(memory_at_0.data, add_i32(loc_4, 28))
						if load_i32(memory_at_0.data, loc_4 + 4) ~= loc_7 then
							desired = 3
							break
						end
						if loc_4 == 0 then
							desired = 3
							break
						end
						loc_10 = neg_f64(load_f64(memory_at_0.data, loc_4 + 24))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						while true do
							loc_4 = load_i32(memory_at_0.data, loc_1 + 40)
							if loc_4 ~= 0 then
								break
							end
							loc_11 = 1e0
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							loc_8 = load_i32(memory_at_0.data, loc_4 + 4)
							if loc_8 ~= loc_7 then
								break
							end
							loc_11 = load_f64(memory_at_0.data, loc_4 + 24)
							desired = 4
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_8 ~= load_i32(memory_at_0.data, 0 + 59952) then
							desired = 3
							break
						end
						if load_i32(memory_at_0.data, loc_4 + 24) ~= 1 then
							desired = 3
							break
						end
						loc_4 = load_i32(memory_at_0.data, add_i32(loc_4, 28))
						if load_i32(memory_at_0.data, loc_4 + 4) ~= loc_7 then
							desired = 3
							break
						end
						if loc_4 == 0 then
							desired = 3
							break
						end
						loc_11 = neg_f64(load_f64(memory_at_0.data, loc_4 + 24))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_12 = 2147483648
					loc_8 = 2147483648
					while true do
						if (if loc_9 >= -3.2767e4 then 1 else 0) == 0 then
							break
						end
						loc_8 = 2147483648
						if (if loc_9 <= 3.2767e4 then 1 else 0) == 0 then
							break
						end
						while true do
							while true do
								if (if abs_f64(loc_9) < 2.147483648e9 then 1 else 0) == 0 then
									break
								end
								loc_4 = truncate_i32_f64(loc_9)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_4 = 2147483648
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = 2147483648
						if loc_9 ~= convert_f64_i32(loc_4) then
							break
						end
						loc_8 = loc_4
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if (if loc_10 >= -3.2767e4 then 1 else 0) == 0 then
							break
						end
						if (if loc_10 <= 3.2767e4 then 1 else 0) == 0 then
							break
						end
						while true do
							while true do
								if (if abs_f64(loc_10) < 2.147483648e9 then 1 else 0) == 0 then
									break
								end
								loc_4 = truncate_i32_f64(loc_10)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_4 = 2147483648
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						if loc_10 ~= convert_f64_i32(loc_4) then
							break
						end
						loc_12 = loc_4
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_7 = 2147483648
					while true do
						if (if loc_11 >= -3.2767e4 then 1 else 0) == 0 then
							break
						end
						loc_7 = 2147483648
						if (if loc_11 <= 3.2767e4 then 1 else 0) == 0 then
							break
						end
						while true do
							while true do
								if (if abs_f64(loc_11) < 2.147483648e9 then 1 else 0) == 0 then
									break
								end
								loc_4 = truncate_i32_f64(loc_11)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_4 = 2147483648
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_7 = 2147483648
						if loc_11 ~= convert_f64_i32(loc_4) then
							break
						end
						loc_7 = loc_4
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_8 == 2147483648 then
						break
					end
					if loc_12 == 2147483648 then
						break
					end
					if loc_7 == 2147483648 then
						break
					end
					if loc_7 == 0 then
						break
					end
					while true do
						while true do
							while true do
								if gt_i32(loc_7, 4294967295) then
									break
								end
								if gt_i32(loc_12, loc_8) then
									desired = 5
									break
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if lt_i32(loc_7, 1) then
								desired = 4
								break
							end
							if ge_i32(loc_12, loc_8) then
								desired = 4
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_4 = load_i32(memory_at_0.data, loc_1 + 44)
						loc_1 = 0
						desired = 1
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_4 = load_i32(memory_at_0.data, loc_1 + 44)
					loc_1 = div_i32(sub_i32(loc_12, loc_8), loc_7)
					if le_i32(loc_1, 4294967294) then
						desired = 2
						break
					end
					loc_1 = add_i32(loc_1, 1)
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1 + 44)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_1 = 3
			break
		end
		store_i64(memory_at_0.data, loc_6, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_6, 8), i64_ZERO)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_4))](loc_4, loc_0)
		store_i64(memory_at_0.data, loc_0 + 40, i64_ZERO)
		loc_5 = add_i64(load_i64(memory_at_0.data, loc_0 + 32), i64_ONE)
		loc_13 = band_i64(loc_5, i64_from_u32(2155905152, 2155905152))
		loc_5 = bor_i64(sub_i64(loc_13, shr_u64(loc_13, i64_from_u32(7, 0))), band_i64(loc_5, i64_from_u32(2139062143, 2139062143)))
		loc_13 = extend_i64_u32((if loc_1 < 127 then loc_1 else 127))
		loc_14 = mul_i64(band_i64(shr_u64(loc_5, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199)), loc_13)
		loc_5 = mul_i64(band_i64(loc_5, i64_from_u32(8323199, 8323199)), loc_13)
		reg_1 = bor_i64(band_i64(shl_i64(loc_14, i64_from_u32(8, 0)), i64_from_u32(2130738944, 2130738944)), band_i64(loc_5, i64_from_u32(8323199, 8323199)))
		loc_5 = bor_i64(band_i64(shr_u64(add_i64(loc_5, i64_from_u32(2139127680, 2139127680)), i64_from_u32(8, 0)), i64_from_u32(8388736, 8388736)), band_i64(add_i64(loc_14, i64_from_u32(2139127680, 2139127680)), i64_from_u32(2147516416, 2147516416)))
		loc_3 = add_i64(bor_i64(reg_1, sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0)))), loc_3)
		loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143))))
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[197] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatForIn*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = i64_ZERO
	local loc_4 = 0
	local loc_5 = i64_ZERO
	local loc_6 = i64_ZERO
	local reg_0
	local reg_1
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			while true do
				if load_i32(memory_at_0.data, add_i32(loc_1, 40)) ~= 0 then
					break
				end
				loc_3 = load_i64(memory_at_0.data, loc_0 + 32)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_4 = 0
			while true do
				FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), shl_i32(loc_4, 2))))
				loc_3 = load_i64(memory_at_0.data, loc_2)
				store_i64(memory_at_0.data, loc_0 + 40, i64_ZERO)
				loc_3 = add_i64(loc_3, load_i64(memory_at_0.data, loc_0 + 32))
				loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
				loc_3 = bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143)))
				store_i64(memory_at_0.data, loc_0 + 32, loc_3)
				loc_4 = add_i32(loc_4, 1)
				if loc_4 < load_i32(memory_at_0.data, loc_1 + 40) then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1 + 44)
		loc_1 = add_i32(loc_0, 40)
		store_i64(memory_at_0.data, loc_1, i64_ZERO)
		store_i64(memory_at_0.data, loc_0 + 32, i64_ZERO)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_4))](loc_4, loc_0)
		store_i64(memory_at_0.data, loc_1, i64_ZERO)
		loc_5 = add_i64(load_i64(memory_at_0.data, loc_0 + 32), i64_ONE)
		loc_6 = band_i64(loc_5, i64_from_u32(2155905152, 2155905152))
		loc_5 = bor_i64(sub_i64(loc_6, shr_u64(loc_6, i64_from_u32(7, 0))), band_i64(loc_5, i64_from_u32(2139062143, 2139062143)))
		loc_6 = band_i64(shr_u64(loc_5, i64_from_u32(8, 0)), i64_from_u32(8323199, 8323199))
		loc_5 = mul_i64(band_i64(loc_5, i64_from_u32(8323199, 8323199)), i64_from_u32(3, 0))
		reg_1 = bor_i64(band_i64(mul_i64(loc_6, i64_from_u32(768, 0)), i64_from_u32(2130738944, 2130738944)), band_i64(loc_5, i64_from_u32(8323199, 8323199)))
		loc_5 = bor_i64(band_i64(shr_u64(add_i64(loc_5, i64_from_u32(2139127680, 2139127680)), i64_from_u32(8, 0)), i64_from_u32(8388736, 8388736)), band_i64(add_i64(mul_i64(loc_6, i64_from_u32(3, 0)), i64_from_u32(2139127680, 2139127680)), i64_from_u32(2147516416, 2147516416)))
		loc_3 = add_i64(bor_i64(reg_1, sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0)))), loc_3)
		loc_5 = band_i64(loc_3, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_5, shr_u64(loc_5, i64_from_u32(7, 0))), band_i64(loc_3, i64_from_u32(2139062143, 2139062143))))
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[198] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatAssign*) ]] function(loc_0, loc_1)
	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 = i64_ZERO
	local loc_16 = i64_ZERO
	local reg_0
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			loc_3 = load_i32(memory_at_0.data, add_i32(loc_1, 32))
			if loc_3 == 0 then
				break
			end
			loc_4 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 12)), 4294967295)
			loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 20))
			loc_6 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_7 = 0
			loc_8 = load_i32(memory_at_0.data, 0 + 59888)
			loc_9 = load_i32(memory_at_0.data, loc_1 + 28)
			while true do
				while true do
					loc_10 = load_i32(memory_at_0.data, add_i32(loc_9, shl_i32(loc_7, 2)))
					if loc_10 == 0 then
						break
					end
					if load_i32(memory_at_0.data, loc_10 + 4) ~= loc_8 then
						break
					end
					if load_i32(memory_at_0.data, loc_0 + 16) == 0 then
						break
					end
					loc_11 = load_i32(memory_at_0.data, loc_10 + 24)
					if loc_11 == loc_5 then
						break
					end
					loc_12 = bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9))
					loc_10 = 0
					while true do
						while true do
							loc_13 = band_i32(loc_12, loc_4)
							loc_14 = add_i32(loc_6, shl_i32(loc_13, 4))
							loc_12 = load_i32(memory_at_0.data, loc_14)
							if loc_12 == loc_11 then
								desired = 4
								break
							end
							if loc_12 == loc_5 then
								desired = 3
								break
							end
							loc_10 = add_i32(loc_10, 1)
							loc_12 = add_i32(loc_10, loc_13)
							if loc_10 <= loc_4 then
								continue
							end
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i64(memory_at_0.data, loc_14 + 8, i64_ZERO)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_7 = add_i32(loc_7, 1)
				if loc_7 ~= loc_3 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_10 = 0
		while true do
			while true do
				while true do
					if loc_10 < loc_3 then
						break
					end
					loc_15 = i64_ZERO
					loc_3 = load_i32(memory_at_0.data, loc_1 + 40)
					if loc_10 < loc_3 then
						desired = 2
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_2, 16)
					reg_0 = 0
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 28), shl_i32(loc_10, 2))))
				loc_15 = load_i64(memory_at_0.data, loc_2)
				loc_16 = band_i64(loc_15, i64_from_u32(2155905152, 2155905152))
				loc_15 = bor_i64(sub_i64(loc_16, shr_u64(loc_16, i64_from_u32(7, 0))), band_i64(loc_15, i64_from_u32(2139062143, 2139062143)))
				loc_3 = load_i32(memory_at_0.data, loc_1 + 40)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
					continue
				end
				break
			end
			while true do
				if loc_10 >= loc_3 then
					break
				end
				FUNC_LIST[189](loc_2, loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 36), shl_i32(loc_10, 2))))
				loc_15 = add_i64(load_i64(memory_at_0.data, loc_2), loc_15)
				loc_16 = band_i64(loc_15, i64_from_u32(2155905152, 2155905152))
				loc_15 = bor_i64(sub_i64(loc_16, shr_u64(loc_16, i64_from_u32(7, 0))), band_i64(loc_15, i64_from_u32(2139062143, 2139062143)))
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
					continue
				end
				break
			end
			store_i64(memory_at_0.data, loc_0 + 40, i64_ZERO)
			loc_15 = add_i64((if eq_i64(loc_15, i64_ZERO) then i64_ONE else loc_15), load_i64(memory_at_0.data, loc_0 + 32))
			loc_16 = band_i64(loc_15, i64_from_u32(2155905152, 2155905152))
			store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_16, shr_u64(loc_16, i64_from_u32(7, 0))), band_i64(loc_15, i64_from_u32(2139062143, 2139062143))))
			loc_10 = add_i32(loc_10, 1)
			loc_3 = load_i32(memory_at_0.data, loc_1 + 32)
			continue
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		break
	end
	return reg_0
end
FUNC_LIST[199] = --[[ Luau::Compile::CostVisitor::visit(Luau::AstStatCompoundAssign*) ]] function(loc_0, loc_1)
	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 = i64_ZERO
	local reg_0
	local desired
	while true do
		loc_2 = load_i32(memory_at_0.data, 0 + 59888)
		loc_1 = load_i32(memory_at_0.data, loc_1 + 32)
		loc_3 = load_i32(memory_at_0.data, loc_1 + 4)
		while true do
			if loc_1 == 0 then
				break
			end
			if loc_3 ~= loc_2 then
				break
			end
			if load_i32(memory_at_0.data, add_i32(loc_0, 16)) == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_1 + 24)
			loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 20))
			if loc_4 == loc_5 then
				break
			end
			loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
			loc_7 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 12)), 4294967295)
			loc_8 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_1 = 0
			while true do
				while true do
					loc_6 = band_i32(loc_6, loc_7)
					loc_9 = load_i32(memory_at_0.data, add_i32(loc_8, shl_i32(loc_6, 4)))
					if loc_9 == loc_4 then
						desired = 2
						break
					end
					if loc_9 == loc_5 then
						desired = 1
						break
					end
					loc_1 = add_i32(loc_1, 1)
					loc_6 = add_i32(loc_1, loc_6)
					if loc_1 <= loc_7 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i64(memory_at_0.data, add_i32(loc_8, shl_i32(loc_6, 4)) + 8, i64_ZERO)
			break
		end
		store_i64(memory_at_0.data, add_i32(loc_0, 40), i64_ZERO)
		loc_10 = add_i64((if loc_3 == loc_2 then i64_ONE else i64_from_u32(2, 0)), load_i64(memory_at_0.data, loc_0 + 32))
		loc_11 = band_i64(loc_10, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0 + 32, bor_i64(sub_i64(loc_11, shr_u64(loc_11, i64_from_u32(7, 0))), band_i64(loc_10, i64_from_u32(2139062143, 2139062143))))
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[200] = --[[ Luau::DenseHashMap<Luau::AstLocal*, unsigned long long, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::find(Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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_2 = 0
		while true do
			if load_i32(memory_at_0.data, loc_0 + 8) == 0 then
				break
			end
			loc_2 = 0
			loc_3 = load_i32(memory_at_0.data, loc_1)
			loc_4 = load_i32(memory_at_0.data, loc_0 + 12)
			if loc_3 == loc_4 then
				break
			end
			loc_1 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
			loc_5 = add_i32(load_i32(memory_at_0.data, loc_0 + 4), 4294967295)
			loc_6 = load_i32(memory_at_0.data, loc_0)
			loc_0 = 0
			while true do
				loc_7 = band_i32(loc_1, loc_5)
				loc_2 = add_i32(loc_6, shl_i32(loc_7, 4))
				loc_1 = load_i32(memory_at_0.data, loc_2)
				if loc_1 == loc_3 then
					desired = 1
					break
				end
				loc_2 = 0
				if loc_1 == loc_4 then
					desired = 1
					break
				end
				loc_0 = add_i32(loc_0, 1)
				loc_1 = add_i32(loc_0, loc_7)
				if loc_0 <= loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		reg_0 = (if loc_2 ~= 0 then add_i32(loc_2, 8) else 0)
		break
	end
	return reg_0
end
FUNC_LIST[201] = --[[ Luau::Compile::Cost::fold(Luau::Compile::Cost const&, Luau::Compile::Cost const&) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = i64_ZERO
	local loc_4 = i64_ZERO
	local loc_5 = i64_ZERO
	local reg_0
	local reg_1
	while true do
		loc_3 = load_i64(memory_at_0.data, loc_2)
		loc_4 = load_i64(memory_at_0.data, loc_1)
		loc_5 = band_i64(load_i64(memory_at_0.data, loc_2 + 8), load_i64(memory_at_0.data, loc_1 + 8))
		store_i64(memory_at_0.data, loc_0 + 8, loc_5)
		reg_1 = (if eq_i64(loc_5, i64_from_u32(4294967295, 4294967295)) then i64_ZERO else bor_i64(band_i64(loc_5, i64_from_u32(16843008, 16843009)), i64_ONE))
		loc_5 = add_i64(loc_3, loc_4)
		loc_3 = band_i64(loc_5, i64_from_u32(2155905152, 2155905152))
		loc_5 = add_i64(reg_1, bor_i64(sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))), band_i64(loc_5, i64_from_u32(2139062143, 2139062143))))
		loc_3 = band_i64(loc_5, i64_from_u32(2155905152, 2155905152))
		store_i64(memory_at_0.data, loc_0, bor_i64(sub_i64(loc_3, shr_u64(loc_3, i64_from_u32(7, 0))), band_i64(loc_5, i64_from_u32(2139062143, 2139062143))))
		break
	end
end
FUNC_LIST[202] = --[[ __cxx_global_var_init ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59852), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59852, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59848, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[203] = --[[ __cxx_global_var_init.1 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59860), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59860, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59856, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[204] = --[[ __cxx_global_var_init.2 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59868), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59868, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59864, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[205] = --[[ __cxx_global_var_init.3 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59876), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59876, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59872, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[206] = --[[ __cxx_global_var_init.4 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59884), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59884, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59880, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[207] = --[[ __cxx_global_var_init.5 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59892), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59892, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59888, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[208] = --[[ __cxx_global_var_init.6 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59900), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59900, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59896, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[209] = --[[ __cxx_global_var_init.7 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59908), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59908, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59904, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[210] = --[[ __cxx_global_var_init.8 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59916), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59916, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59912, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[211] = --[[ __cxx_global_var_init.9 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59924), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59924, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59920, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[212] = --[[ __cxx_global_var_init.10 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59932), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59932, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59928, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[213] = --[[ __cxx_global_var_init.11 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59940), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59940, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59936, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[214] = --[[ __cxx_global_var_init.12 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59948), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59948, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59944, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[215] = --[[ __cxx_global_var_init.13 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59956), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59956, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59952, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[216] = --[[ __cxx_global_var_init.14 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59964), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59964, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59960, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[217] = --[[ __cxx_global_var_init.15 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59972), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59972, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59968, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[218] = --[[ __cxx_global_var_init.16 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59980), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59980, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59976, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[219] = --[[ __cxx_global_var_init.17 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59988), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59988, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59984, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[220] = --[[ __cxx_global_var_init.18 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 59996), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 59996, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 59992, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[221] = --[[ __cxx_global_var_init.19 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60004), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60004, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60000, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[222] = --[[ __cxx_global_var_init.20 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60012), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60012, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60008, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[223] = --[[ __cxx_global_var_init.21 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60020), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60020, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60016, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[224] = --[[ __cxx_global_var_init.22 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60028), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60028, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60024, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[225] = --[[ __cxx_global_var_init.23 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60036), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60036, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60032, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[226] = --[[ __cxx_global_var_init.24 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60044), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60044, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60040, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[227] = --[[ __cxx_global_var_init.25 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60052), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60052, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60048, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[228] = --[[ __cxx_global_var_init.26 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60060), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60060, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60056, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[229] = --[[ __cxx_global_var_init.27 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60068), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60068, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60064, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[230] = --[[ __cxx_global_var_init.28 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60076), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60076, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60072, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[231] = --[[ __cxx_global_var_init.29 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60084), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60084, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60080, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[232] = --[[ __cxx_global_var_init.30 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60092), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60092, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60088, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[233] = --[[ __cxx_global_var_init.31 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60100), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60100, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60096, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[234] = --[[ __cxx_global_var_init.32 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60108), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60108, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60104, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[235] = --[[ __cxx_global_var_init.33 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60116), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60116, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60112, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[236] = --[[ __cxx_global_var_init.34 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60124), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60124, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60120, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[237] = --[[ __cxx_global_var_init.35 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60132), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60132, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60128, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[238] = --[[ __cxx_global_var_init.36 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60140), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60140, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60136, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[239] = --[[ __cxx_global_var_init.37 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60148), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60148, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60144, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[240] = --[[ __cxx_global_var_init.38 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60156), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60156, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60152, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[241] = --[[ __cxx_global_var_init.39 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60164), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60164, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60160, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[242] = --[[ __cxx_global_var_init.40 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60172), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60172, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60168, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[243] = --[[ __cxx_global_var_init.41 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60180), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60180, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60176, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[244] = --[[ __cxx_global_var_init.42 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60188), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60188, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60184, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[245] = --[[ __cxx_global_var_init.43 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60196), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60196, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60192, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[246] = --[[ __cxx_global_var_init.44 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60204), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60204, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60200, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[247] = --[[ __cxx_global_var_init.45 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60212), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60212, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60208, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[248] = --[[ __cxx_global_var_init.46 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60220), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60220, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60216, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[249] = --[[ __cxx_global_var_init.47 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60228), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60228, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60224, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[250] = --[[ __cxx_global_var_init.48 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60236), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60236, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60232, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[251] = --[[ __cxx_global_var_init.49 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60244), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60244, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60240, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[252] = --[[ __cxx_global_var_init.50 ]] function()
	local loc_0 = 0
	while true do
		while true do
			if band_i32(load_i32_u8(memory_at_0.data, 0 + 60252), 1) ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, 0 + 60252, 1)
			loc_0 = add_i32(load_i32(memory_at_0.data, 0 + 65168), 1)
			store_i32(memory_at_0.data, 0 + 60248, loc_0)
			store_i32(memory_at_0.data, 0 + 65168, loc_0)
			break
		end
		break
	end
end
FUNC_LIST[253] = --[[ Luau::CompileError::CompileError(Luau::Location const&, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char> > const&) ]] function(loc_0, loc_1, loc_2)
	local reg_0
	local desired
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(15340, 8))
		store_i64(memory_at_0.data, add_i32(loc_0, 12), load_i64(memory_at_0.data, add_i32(loc_1, 8)))
		store_i64(memory_at_0.data, loc_0 + 4, load_i64(memory_at_0.data, loc_1))
		loc_1 = add_i32(loc_0, 20)
		while true do
			if lt_i32(load_i32_i8(memory_at_0.data, loc_2 + 11), 0) then
				break
			end
			store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_2))
			store_i32(memory_at_0.data, add_i32(loc_1, 8), load_i32(memory_at_0.data, add_i32(loc_2, 8)))
			reg_0 = loc_0
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[1536](loc_1, load_i32(memory_at_0.data, loc_2), load_i32(memory_at_0.data, loc_2 + 4))
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[254] = --[[ Luau::CompileError::~CompileError() ]] function(loc_0)
	local reg_0
	while true do
		store_i32(memory_at_0.data, loc_0, add_i32(15340, 8))
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_0, 31)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0 + 20))
			break
		end
		reg_0 = FUNC_LIST[1618](loc_0)
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[255] = --[[ Luau::CompileError::~CompileError().1 ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = FUNC_LIST[254](loc_0)
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[256] = --[[ Luau::CompileError::what() const ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = (if lt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_0, 31)), 0) then load_i32(memory_at_0.data, loc_0 + 20) else add_i32(loc_0, 20))
		break
	end
	return reg_0
end
FUNC_LIST[257] = --[[ Luau::CompileError::raise(Luau::Location const&, char const*, ...) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local reg_0
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		store_i32(memory_at_0.data, loc_3 + 12, loc_2)
		FUNC_LIST[1218](loc_3, loc_1, loc_2)
		reg_0 = FUNC_LIST[1253](32)
		loc_2 = reg_0
		reg_0 = FUNC_LIST[253](loc_2, loc_0, loc_3)
		FUNC_LIST[1252](loc_2, 15384, 126)
		error("out of code bounds")
	end
end
FUNC_LIST[258] = --[[ Luau::compileOrThrow(Luau::BytecodeBuilder&, Luau::ParseResult const&, Luau::AstNameTable const&, Luau::CompileOptions const&) ]] function(loc_0, loc_1, loc_2, loc_3)
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = i64_ZERO
	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 reg_1
	local reg_2
	local desired
	while true do
		loc_4 = sub_i32(GLOBAL_LIST[0].value, 608)
		GLOBAL_LIST[0].value = loc_4
		loc_5 = add_i32(add_i32(loc_4, 576), 24)
		store_i32(memory_at_0.data, loc_5, load_i32(memory_at_0.data, add_i32(loc_3, 24)))
		loc_6 = add_i32(add_i32(loc_4, 576), 16)
		store_i64(memory_at_0.data, loc_6, load_i64(memory_at_0.data, add_i32(loc_3, 16)))
		loc_7 = add_i32(add_i32(loc_4, 576), 8)
		store_i64(memory_at_0.data, loc_7, load_i64(memory_at_0.data, add_i32(loc_3, 8)))
		loc_8 = load_i64(memory_at_0.data, loc_3)
		store_i64(memory_at_0.data, loc_4 + 576, loc_8)
		loc_9 = wrap_i32_i64(loc_8)
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_1 + 8)
				loc_10 = load_i32(memory_at_0.data, add_i32(loc_1, 12))
				if loc_3 ~= loc_10 then
					break
				end
				loc_11 = 0
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_11 = 0
			while true do
				while true do
					if load_i32_u8(memory_at_0.data, loc_3) == 0 then
						break
					end
					while true do
						loc_12 = add_i32(loc_3, 20)
						reg_0 = FUNC_LIST[1552](loc_12, 0, 9, 12579)
						if reg_0 ~= 0 then
							break
						end
						reg_0 = FUNC_LIST[1275](add_i32((if lt_i32(load_i32_i8(memory_at_0.data, loc_12 + 11), 0) then load_i32(memory_at_0.data, loc_12) else loc_12), 9))
						loc_9 = reg_0
						loc_9 = (if lt_i32(loc_9, 2) then loc_9 else 2)
						loc_9 = (if gt_i32(loc_9, 0) then loc_9 else 0)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if load_i32_u8(memory_at_0.data, loc_3) == 0 then
						break
					end
					loc_13 = load_i32_u8(memory_at_0.data, loc_3 + 31)
					if (if lt_i32(shr_i32(shl_i32(loc_13, 24), 24), 0) then load_i32(memory_at_0.data, add_i32(loc_3, 24)) else loc_13) ~= 6 then
						break
					end
					reg_2 = FUNC_LIST[1550](loc_12, 0, 4294967295, 6204, 6)
					loc_12 = reg_2
					loc_9 = (if loc_12 ~= 0 then loc_9 else 2)
					loc_11 = bor_i32(loc_11, (if loc_12 == 0 then 1 else 0))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_3 = add_i32(loc_3, 32)
				if loc_3 ~= loc_10 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_4 + 576, loc_9)
			break
		end
		loc_10 = load_i32(memory_at_0.data, loc_1)
		store_i64(memory_at_0.data, add_i32(add_i32(loc_4, 256), 12), load_i64(memory_at_0.data, loc_7))
		store_i64(memory_at_0.data, add_i32(loc_4, 276), load_i64(memory_at_0.data, loc_6))
		store_i32(memory_at_0.data, add_i32(loc_4, 284), load_i32(memory_at_0.data, loc_5))
		store_i64(memory_at_0.data, add_i32(loc_4, 296), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 316), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 336), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 356), i64_ZERO)
		store_i32(memory_at_0.data, loc_4 + 256, loc_0)
		store_i64(memory_at_0.data, loc_4 + 260, load_i64(memory_at_0.data, loc_4 + 576))
		store_i32_n8(memory_at_0.data, loc_4 + 472, 0)
		store_i32(memory_at_0.data, loc_4 + 468, 0)
		store_i64(memory_at_0.data, loc_4 + 288, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 308, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 328, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 348, i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 376), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 396), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 416), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 436), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 456), i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_4, 483), 0)
		store_i64(memory_at_0.data, add_i32(loc_4, 512), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 520), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 528), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 536), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 544), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 552), i64_ZERO)
		store_i64(memory_at_0.data, add_i32(loc_4, 560), i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_4, 568), 0)
		store_i64(memory_at_0.data, loc_4 + 368, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 388, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 408, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 428, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 448, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 476, i64_ZERO)
		reg_1 = FUNC_LIST[1461](64)
		loc_3 = reg_1
		store_i32(memory_at_0.data, add_i32(loc_4, 492), loc_3)
		store_i32(memory_at_0.data, add_i32(loc_4, 496), add_i32(loc_3, 64))
		store_i32(memory_at_0.data, loc_4 + 488, loc_3)
		reg_1 = FUNC_LIST[1461](64)
		loc_3 = reg_1
		store_i32(memory_at_0.data, add_i32(loc_4, 504), loc_3)
		store_i32(memory_at_0.data, add_i32(loc_4, 508), add_i32(loc_3, 64))
		store_i32(memory_at_0.data, loc_4 + 500, loc_3)
		loc_6 = add_i32(loc_4, 328)
		FUNC_LIST[42](loc_6, loc_2, load_i32(memory_at_0.data, loc_5))
		loc_5 = add_i32(loc_4, 348)
		FUNC_LIST[45](loc_6, loc_5, loc_10)
		while true do
			if le_i32(loc_9, 0) then
				break
			end
			while true do
				reg_0 = FUNC_LIST[1067](loc_2, 1579)
				if reg_0 ~= 0 then
					break
				end
				reg_0 = FUNC_LIST[1067](loc_2, 1571)
				if reg_0 == 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_4 + 104, add_i32(loc_4, 486))
			store_i32(memory_at_0.data, loc_4 + 100, add_i32(loc_4, 485))
			store_i32(memory_at_0.data, loc_4 + 96, add_i32(15396, 8))
			TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_10))](loc_10, add_i32(loc_4, 96))
			break
		end
		while true do
			if lt_i32(loc_9, 2) then
				break
			end
			if band_i32(load_i32_u8(memory_at_0.data, loc_4 + 485), 255) ~= 0 then
				break
			end
			if band_i32(load_i32_u8(memory_at_0.data, loc_4 + 486), 255) ~= 0 then
				break
			end
			store_i32(memory_at_0.data, loc_4 + 468, add_i32(loc_4, 428))
			reg_0 = FUNC_LIST[1067](loc_2, 5469)
			loc_2 = reg_0
			if loc_2 == 0 then
				break
			end
			while true do
				if load_i32(memory_at_0.data, add_i32(loc_4, 336)) == 0 then
					break
				end
				loc_14 = load_i32(memory_at_0.data, add_i32(loc_4, 340))
				if loc_14 == loc_2 then
					break
				end
				loc_12 = bxor_i32(shr_u32(loc_2, 4), shr_u32(loc_2, 9))
				loc_13 = add_i32(load_i32(memory_at_0.data, add_i32(loc_4, 332)), 4294967295)
				loc_3 = 0
				loc_7 = load_i32(memory_at_0.data, loc_4 + 328)
				while true do
					while true do
						loc_12 = band_i32(loc_12, loc_13)
						loc_1 = load_i32(memory_at_0.data, add_i32(loc_7, shl_i32(loc_12, 3)))
						if loc_1 == loc_2 then
							desired = 3
							break
						end
						if loc_1 == loc_14 then
							desired = 2
							break
						end
						loc_3 = add_i32(loc_3, 1)
						loc_12 = add_i32(loc_3, loc_12)
						if loc_3 <= loc_13 then
							continue
						end
						desired = 2
						break
					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
				if load_i32(memory_at_0.data, add_i32(loc_7, shl_i32(loc_12, 3)) + 4) ~= 0 then
					desired = 1
					break
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32_n8(memory_at_0.data, loc_4 + 472, 1)
			break
		end
		while true do
			if lt_i32(loc_9, 1) then
				break
			end
			FUNC_LIST[55](add_i32(loc_4, 428), loc_6, loc_5, add_i32(loc_4, 576), loc_10)
			FUNC_LIST[65](add_i32(loc_4, 368), loc_5, add_i32(loc_4, 388), load_i32(memory_at_0.data, loc_4 + 468), load_i32_u8(memory_at_0.data, loc_4 + 472), loc_10)
			FUNC_LIST[83](add_i32(loc_4, 408), loc_10)
			break
		end
		store_i32_n8(memory_at_0.data, loc_4 + 236, 0)
		store_i32(memory_at_0.data, loc_4 + 224, add_i32(15708, 8))
		store_i32(memory_at_0.data, loc_4 + 232, add_i32(loc_4, 240))
		store_i32(memory_at_0.data, loc_4 + 228, add_i32(loc_4, 256))
		reg_1 = FUNC_LIST[1461](64)
		loc_3 = reg_1
		store_i32(memory_at_0.data, loc_4 + 244, loc_3)
		store_i32(memory_at_0.data, loc_4 + 240, loc_3)
		store_i32(memory_at_0.data, loc_4 + 248, add_i32(loc_3, 64))
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_10))](loc_10, add_i32(loc_4, 224))
		while true do
			if load_i32_u8(memory_at_0.data, loc_4 + 236) == 0 then
				break
			end
			FUNC_LIST[98](add_i32(loc_4, 448), loc_10, load_i32(memory_at_0.data, loc_4 + 596))
			break
		end
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_4 + 240)
			loc_12 = load_i32(memory_at_0.data, loc_4 + 244)
			if loc_3 == loc_12 then
				break
			end
			while true do
				reg_0 = FUNC_LIST[259](add_i32(loc_4, 256), load_i32(memory_at_0.data, loc_3), 0)
				loc_3 = add_i32(loc_3, 4)
				if loc_3 ~= loc_12 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		store_i64(memory_at_0.data, loc_4 + 88, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 80, i64_ZERO)
		store_i64(memory_at_0.data, loc_4 + 72, i64_ZERO)
		reg_0 = FUNC_LIST[1090](add_i32(loc_4, 56))
		loc_3 = reg_0
		store_i32(memory_at_0.data, loc_4 + 48, 0)
		store_i32_n8(memory_at_0.data, loc_4 + 44, 0)
		store_i32_n8(memory_at_0.data, loc_4 + 32, 0)
		store_i32_n8(memory_at_0.data, loc_4 + 24, 0)
		store_i32_n8(memory_at_0.data, loc_4 + 8, 0)
		reg_2 = FUNC_LIST[962](add_i32(loc_4, 96), add_i32(loc_10, 8), add_i32(loc_4, 88), add_i32(loc_4, 80), 0, add_i32(loc_4, 72), 1, loc_3, loc_10, 0, add_i32(loc_4, 48), add_i32(loc_4, 32), 0, 0, add_i32(loc_4, 8))
		reg_1 = FUNC_LIST[259](add_i32(loc_4, 256), reg_2, band_i32(loc_11, 255))
		FUNC_LIST[121](loc_0, reg_1)
		FUNC_LIST[165](loc_0)
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_4 + 240)
			if loc_3 == 0 then
				break
			end
			store_i32(memory_at_0.data, loc_4 + 244, loc_3)
			FUNC_LIST[1463](loc_3)
			break
		end
		reg_0 = FUNC_LIST[260](add_i32(loc_4, 256))
		GLOBAL_LIST[0].value = add_i32(loc_4, 608)
		break
	end
end
FUNC_LIST[259] = --[[ Luau::Compiler::compileFunction(Luau::AstExprFunction*, unsigned char) ]] function(loc_0, loc_1, loc_2)
	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 reg_1
	local desired
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 80)
		GLOBAL_LIST[0].value = loc_3
		store_i32(memory_at_0.data, loc_3 + 52, loc_1)
		loc_4 = load_i32(memory_at_0.data, loc_0 + 220)
		loc_5 = (if load_i32(memory_at_0.data, loc_1 + 40) ~= 0 then 1 else 0)
		reg_0 = FUNC_LIST[115](load_i32(memory_at_0.data, loc_0), band_i32(add_i32(load_i32(memory_at_0.data, add_i32(loc_1, 48)), loc_5), 255), load_i32_u8(memory_at_0.data, loc_1 + 68))
		loc_6 = reg_0
		while true do
			if lt_i32(load_i32(memory_at_0.data, add_i32(loc_0, 8)), 1) then
				break
			end
			FUNC_LIST[155](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, loc_1 + 8), 1))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if load_i32(memory_at_0.data, add_i32(loc_0, 200)) == 0 then
				break
			end
			loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 204))
			if loc_7 == loc_1 then
				break
			end
			loc_8 = bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9))
			loc_9 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 196)), 4294967295)
			loc_10 = load_i32(memory_at_0.data, loc_0 + 192)
			loc_11 = 0
			while true do
				while true do
					loc_8 = band_i32(loc_8, loc_9)
					loc_12 = load_i32(memory_at_0.data, add_i32(loc_10, shl_i32(loc_8, 4)))
					if loc_12 == loc_1 then
						desired = 2
						break
					end
					if loc_12 == loc_7 then
						desired = 1
						break
					end
					loc_11 = add_i32(loc_11, 1)
					loc_8 = add_i32(loc_11, loc_8)
					if loc_11 <= loc_9 then
						continue
					end
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_9 = load_i32(memory_at_0.data, loc_0)
			loc_11 = add_i32(loc_10, shl_i32(loc_8, 4))
			loc_8 = add_i32(loc_11, 12)
			store_i32(memory_at_0.data, add_i32(loc_3, 48), load_i32(memory_at_0.data, loc_8))
			store_i64(memory_at_0.data, loc_3 + 40, load_i64(memory_at_0.data, loc_11 + 4))
			store_i64(memory_at_0.data, loc_11 + 4, i64_ZERO)
			store_i32(memory_at_0.data, loc_8, 0)
			FUNC_LIST[152](loc_9, add_i32(loc_3, 40))
			if gt_i32(load_i32_i8(memory_at_0.data, loc_3 + 51), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_3 + 40))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if load_i32_u8(memory_at_0.data, loc_1 + 68) == 0 then
				break
			end
			FUNC_LIST[144](load_i32(memory_at_0.data, loc_0), 65, band_i32(add_i32(load_i32(memory_at_0.data, loc_1 + 48), loc_5), 255), 0, 0)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				loc_9 = load_i32(memory_at_0.data, loc_0 + 220)
				loc_8 = load_i32(memory_at_0.data, loc_1 + 48)
				loc_12 = add_i32(loc_8, loc_5)
				loc_11 = add_i32(loc_9, loc_12)
				if loc_11 >= 256 then
					break
				end
				store_i32(memory_at_0.data, loc_0 + 220, loc_11)
				loc_12 = load_i32(memory_at_0.data, loc_0 + 224)
				store_i32(memory_at_0.data, loc_0 + 224, (if loc_12 < loc_11 then loc_11 else loc_12))
				while true do
					loc_11 = load_i32(memory_at_0.data, loc_1 + 40)
					if loc_11 == 0 then
						break
					end
					FUNC_LIST[262](loc_0, loc_11, band_i32(loc_9, 255))
					loc_8 = load_i32(memory_at_0.data, loc_1 + 48)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					if loc_8 == 0 then
						break
					end
					loc_8 = add_i32(loc_9, loc_5)
					loc_11 = 0
					while true do
						FUNC_LIST[262](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 44), shl_i32(loc_11, 2))), band_i32(add_i32(loc_8, loc_11), 255))
						loc_11 = add_i32(loc_11, 1)
						if loc_11 < load_i32(memory_at_0.data, loc_1 + 48) 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
				while true do
					loc_8 = load_i32(memory_at_0.data, loc_1 + 92)
					if load_i32(memory_at_0.data, add_i32(loc_8, 32)) == 0 then
						break
					end
					loc_11 = 0
					while true do
						FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_8 + 28), shl_i32(loc_11, 2))))
						loc_11 = add_i32(loc_11, 1)
						if loc_11 < load_i32(memory_at_0.data, loc_8 + 32) 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
				while true do
					reg_0 = FUNC_LIST[264](loc_0, loc_8)
					if reg_0 ~= 0 then
						break
					end
					while true do
						if lt_i32(load_i32(memory_at_0.data, loc_0 + 8), 1) then
							break
						end
						FUNC_LIST[155](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, add_i32(loc_8, 16)), 1))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[265](loc_0, 0)
					FUNC_LIST[144](load_i32(memory_at_0.data, loc_0), 22, 0, 1, 0)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					if lt_i32(load_i32(memory_at_0.data, loc_0 + 4), 1) then
						break
					end
					if lt_i32(load_i32(memory_at_0.data, loc_0 + 8), 2) then
						break
					end
					store_i32(memory_at_0.data, add_i32(loc_3, 72), 0)
					store_i64(memory_at_0.data, loc_3 + 64, i64_ZERO)
					store_i32(memory_at_0.data, loc_3 + 60, loc_0)
					loc_12 = add_i32(16692, 8)
					store_i32(memory_at_0.data, loc_3 + 56, loc_12)
					loc_11 = load_i32(memory_at_0.data, loc_1 + 92)
					TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_11))](loc_11, add_i32(loc_3, 56))
					while true do
						loc_11 = load_i32(memory_at_0.data, loc_3 + 64)
						loc_9 = load_i32(memory_at_0.data, add_i32(loc_3, 68))
						if loc_11 == loc_9 then
							break
						end
						while true do
							reg_0 = FUNC_LIST[266](loc_0, load_i32(memory_at_0.data, loc_11))
							loc_11 = add_i32(loc_11, 4)
							if loc_11 ~= loc_9 then
								continue
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_11 = load_i32(memory_at_0.data, loc_3 + 64)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_3 + 56, loc_12)
					if loc_11 == 0 then
						break
					end
					store_i32(memory_at_0.data, loc_3 + 68, loc_11)
					FUNC_LIST[1463](loc_11)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[154](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, loc_1 + 8), 1))
				while true do
					loc_11 = load_i32(memory_at_0.data, loc_0 + 8)
					if lt_i32(loc_11, 1) then
						break
					end
					while true do
						loc_9 = load_i32(memory_at_0.data, loc_1 + 100)
						if loc_9 == 0 then
							break
						end
						loc_11 = load_i32(memory_at_0.data, loc_0)
						store_i32(memory_at_0.data, loc_3 + 32, loc_9)
						reg_1 = FUNC_LIST[1383](loc_9)
						store_i32(memory_at_0.data, loc_3 + 36, reg_1)
						store_i64(memory_at_0.data, loc_3 + 16, load_i64(memory_at_0.data, loc_3 + 32))
						FUNC_LIST[153](loc_11, add_i32(loc_3, 16))
						loc_11 = load_i32(memory_at_0.data, loc_0 + 8)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if lt_i32(loc_11, 2) then
						break
					end
					loc_11 = load_i32(memory_at_0.data, loc_0 + 244)
					loc_10 = load_i32(memory_at_0.data, add_i32(loc_0, 248))
					if loc_11 == loc_10 then
						break
					end
					while true do
						loc_9 = load_i32(memory_at_0.data, loc_0)
						loc_12 = load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_11))
						store_i32(memory_at_0.data, loc_3 + 24, loc_12)
						reg_1 = FUNC_LIST[1383](loc_12)
						store_i32(memory_at_0.data, loc_3 + 28, reg_1)
						store_i64(memory_at_0.data, loc_3 + 8, load_i64(memory_at_0.data, loc_3 + 24))
						FUNC_LIST[158](loc_9, add_i32(loc_3, 8))
						loc_11 = add_i32(loc_11, 4)
						if loc_11 ~= loc_10 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
				while true do
					if lt_i32(load_i32(memory_at_0.data, loc_0 + 4), 1) then
						break
					end
					FUNC_LIST[172](load_i32(memory_at_0.data, loc_0))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[173](load_i32(memory_at_0.data, loc_0))
				FUNC_LIST[267](loc_0, 0)
				reg_0 = FUNC_LIST[160](load_i32(memory_at_0.data, loc_0))
				if reg_0 >= 1000000001 then
					desired = 1
					break
				end
				FUNC_LIST[118](load_i32(memory_at_0.data, loc_0), load_i32_u8(memory_at_0.data, loc_0 + 224), band_i32(shr_u32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 248)), load_i32(memory_at_0.data, loc_0 + 244)), 2), 255), (if load_i32(memory_at_0.data, loc_1 + 96) ~= 0 then loc_2 else (if load_i32_u8(memory_at_0.data, loc_0 + 228) ~= 0 then loc_2 else bor_i32(loc_2, 2))))
				reg_0 = FUNC_LIST[268](add_i32(loc_0, 32), add_i32(loc_3, 52))
				loc_11 = reg_0
				store_i32(memory_at_0.data, loc_11, loc_6)
				while true do
					loc_1 = add_i32(loc_11, 4)
					if add_i32(loc_0, 244) == loc_1 then
						break
					end
					FUNC_LIST[269](loc_1, load_i32(memory_at_0.data, loc_0 + 244), load_i32(memory_at_0.data, loc_0 + 248))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					if lt_i32(load_i32(memory_at_0.data, loc_0 + 4), 2) then
						break
					end
					loc_1 = load_i32(memory_at_0.data, loc_3 + 52)
					if load_i32_u8(memory_at_0.data, loc_1 + 68) ~= 0 then
						break
					end
					if load_i32(memory_at_0.data, loc_1 + 40) ~= 0 then
						break
					end
					if band_i32(load_i32_u8(memory_at_0.data, loc_0 + 229), 255) ~= 0 then
						break
					end
					if band_i32(load_i32_u8(memory_at_0.data, loc_0 + 230), 255) ~= 0 then
						break
					end
					store_i32_n8(memory_at_0.data, loc_11 + 28, 1)
					store_i32(memory_at_0.data, loc_11 + 24, load_i32(memory_at_0.data, loc_0 + 224))
					reg_1 = FUNC_LIST[181](load_i32(memory_at_0.data, loc_1 + 92), load_i32(memory_at_0.data, loc_1 + 44), load_i32(memory_at_0.data, add_i32(loc_1, 48)), add_i32(loc_0, 172))
					store_i64(memory_at_0.data, loc_11 + 16, reg_1)
					reg_0 = FUNC_LIST[264](loc_0, load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_3 + 52) + 92))
					if reg_0 == 0 then
						break
					end
					store_i32_n8(memory_at_0.data, loc_3 + 64, 1)
					store_i32(memory_at_0.data, loc_3 + 60, loc_0)
					store_i32(memory_at_0.data, loc_3 + 56, add_i32(16984, 8))
					TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, add_i32(loc_3, 56))
					store_i32_n8(memory_at_0.data, loc_11 + 29, load_i32_u8(memory_at_0.data, loc_3 + 64))
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32_n8(memory_at_0.data, loc_0 + 228, 0)
				store_i32(memory_at_0.data, loc_0 + 224, 0)
				store_i32(memory_at_0.data, loc_0 + 220, loc_4)
				store_i32(memory_at_0.data, loc_0 + 248, load_i32(memory_at_0.data, loc_0 + 244))
				GLOBAL_LIST[0].value = add_i32(loc_3, 80)
				reg_0 = loc_6
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_3 + 4, 255)
			store_i32(memory_at_0.data, loc_3, loc_12)
			FUNC_LIST[257](add_i32(loc_1, 8), 8962, loc_3)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[257](add_i32(loc_1, 8), 7139, 0)
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[260] = --[[ Luau::Compiler::~Compiler() ]] function(loc_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_1 = load_i32(memory_at_0.data, loc_0 + 304)
			if loc_1 == 0 then
				break
			end
			while true do
				while true do
					loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 308))
					if loc_2 ~= loc_1 then
						break
					end
					loc_2 = loc_1
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					loc_2 = add_i32(loc_2, 4294967292)
					loc_3 = load_i32(memory_at_0.data, loc_2)
					store_i32(memory_at_0.data, loc_2, 0)
					while true do
						if loc_3 == 0 then
							break
						end
						FUNC_LIST[1464](loc_3)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					if loc_2 ~= loc_1 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_0 + 304)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 308, loc_1)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 292)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 296), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_4 = load_i32(memory_at_0.data, loc_0 + 280)
			if loc_4 == 0 then
				break
			end
			while true do
				while true do
					loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 284))
					if loc_2 ~= loc_4 then
						break
					end
					loc_2 = loc_4
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					loc_3 = add_i32(loc_2, 4294967272)
					while true do
						loc_1 = load_i32(memory_at_0.data, add_i32(loc_2, 4294967284))
						if loc_1 == 0 then
							break
						end
						store_i32(memory_at_0.data, add_i32(loc_2, 4294967288), loc_1)
						FUNC_LIST[1463](loc_1)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_2 = loc_3
					if loc_3 ~= loc_4 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_0 + 280)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 284, loc_4)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 268)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 272), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 256)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 260), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 244)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 248), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 232)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 236), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 192)
			if loc_1 == 0 then
				break
			end
			while true do
				loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 196))
				if loc_4 == 0 then
					break
				end
				loc_2 = 0
				while true do
					while true do
						loc_3 = add_i32(loc_1, shl_i32(loc_2, 4))
						if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_3, 15)), 4294967295) then
							break
						end
						FUNC_LIST[1463](load_i32(memory_at_0.data, add_i32(loc_3, 4)))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_2 = add_i32(loc_2, 1)
					if loc_2 ~= loc_4 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = load_i32(memory_at_0.data, loc_0 + 192)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1463](loc_1)
			store_i64(memory_at_0.data, loc_0 + 192, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 172)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 172, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 152)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 152, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 132)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 132, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 112)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 112, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 92)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 92, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 72)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 72, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 52)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 52, i64_ZERO)
			break
		end
		while true do
			loc_4 = load_i32(memory_at_0.data, loc_0 + 32)
			if loc_4 == 0 then
				break
			end
			while true do
				loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 36))
				if loc_5 == 0 then
					break
				end
				loc_2 = 0
				while true do
					while true do
						loc_1 = add_i32(loc_4, mul_i32(loc_2, 40))
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_1, 12))
						if loc_3 == 0 then
							break
						end
						store_i32(memory_at_0.data, add_i32(loc_1, 16), loc_3)
						FUNC_LIST[1463](loc_3)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_2 = add_i32(loc_2, 1)
					if loc_2 ~= loc_5 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_0 + 32)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[1463](loc_4)
			store_i64(memory_at_0.data, loc_0 + 32, i64_ZERO)
			break
		end
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[261] = --[[ Luau::AstVisitor::~AstVisitor() ]] function(loc_0)
	local reg_0
	while true do
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[262] = --[[ Luau::Compiler::pushLocal(Luau::AstLocal*, unsigned char) ]] function(loc_0, loc_1, loc_2)
	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 reg_1
	local desired
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		store_i32(memory_at_0.data, loc_3 + 12, loc_1)
		while true do
			while true do
				loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 236))
				loc_5 = load_i32(memory_at_0.data, loc_0 + 232)
				loc_6 = sub_i32(loc_4, loc_5)
				if loc_6 >= 797 then
					break
				end
				while true do
					while true do
						if loc_4 == load_i32(memory_at_0.data, add_i32(loc_0, 240)) then
							break
						end
						store_i32(memory_at_0.data, loc_4, loc_1)
						store_i32(memory_at_0.data, loc_0 + 236, add_i32(loc_4, 4))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_7 = shr_i32(loc_6, 2)
					loc_4 = add_i32(loc_7, 1)
					loc_8 = shr_u32(loc_6, 1)
					loc_4 = (if loc_8 < loc_4 then loc_4 else loc_8)
					if loc_4 >= 1073741824 then
						desired = 1
						break
					end
					loc_8 = shl_i32(loc_4, 2)
					reg_0 = FUNC_LIST[1461](loc_8)
					loc_4 = reg_0
					loc_7 = add_i32(loc_4, shl_i32(loc_7, 2))
					store_i32(memory_at_0.data, loc_7, loc_1)
					loc_1 = add_i32(loc_4, loc_8)
					loc_8 = add_i32(loc_7, 4)
					while true do
						if loc_6 == 0 then
							break
						end
						reg_0 = FUNC_LIST[1224](loc_4, loc_5, loc_6)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					store_i32(memory_at_0.data, loc_0 + 240, loc_1)
					store_i32(memory_at_0.data, loc_0 + 236, loc_8)
					store_i32(memory_at_0.data, loc_0 + 232, loc_4)
					if loc_5 == 0 then
						break
					end
					FUNC_LIST[1463](loc_5)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				reg_0 = FUNC_LIST[339](add_i32(loc_0, 52), add_i32(loc_3, 12))
				loc_4 = reg_0
				store_i32_n8(memory_at_0.data, loc_4 + 1, 1)
				store_i32_n8(memory_at_0.data, loc_4, loc_2)
				reg_1 = FUNC_LIST[161](load_i32(memory_at_0.data, loc_0))
				store_i32(memory_at_0.data, loc_4 + 4, reg_1)
				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
			loc_0 = load_i32(memory_at_0.data, loc_1)
			store_i32(memory_at_0.data, loc_3 + 4, 200)
			store_i32(memory_at_0.data, loc_3, loc_0)
			FUNC_LIST[257](add_i32(loc_1, 4), 9035, loc_3)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[263] = --[[ Luau::Compiler::compileStat(Luau::AstStat*) ]] function(loc_0, loc_1)
	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 reg_1
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			if lt_i32(load_i32(memory_at_0.data, add_i32(loc_0, 8)), 1) then
				break
			end
			FUNC_LIST[155](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, loc_1 + 8), 1))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if lt_i32(load_i32(memory_at_0.data, add_i32(loc_0, 12)), 1) then
				break
			end
			loc_3 = load_i32(memory_at_0.data, loc_1 + 4)
			if loc_3 == load_i32(memory_at_0.data, 0 + 59992) then
				break
			end
			if loc_3 == load_i32(memory_at_0.data, 0 + 60112) then
				break
			end
			FUNC_LIST[144](load_i32(memory_at_0.data, loc_0), 69, 0, 0, 0)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_3 = load_i32(memory_at_0.data, loc_1 + 4)
		while true do
			while true do
				while true do
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 59992) then
							break
						end
						loc_4 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 236)), load_i32(memory_at_0.data, loc_0 + 232)), 2)
						loc_5 = load_i32(memory_at_0.data, loc_0 + 220)
						while true do
							if load_i32(memory_at_0.data, add_i32(loc_1, 32)) == 0 then
								break
							end
							loc_3 = 0
							while true do
								FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_1 + 28), shl_i32(loc_3, 2))))
								loc_3 = add_i32(loc_3, 1)
								if loc_3 < load_i32(memory_at_0.data, loc_1 + 32) 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
						FUNC_LIST[265](loc_0, loc_4)
						FUNC_LIST[267](loc_0, loc_4)
						store_i32(memory_at_0.data, loc_0 + 220, loc_5)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60000) then
							break
						end
						FUNC_LIST[340](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60008) then
							break
						end
						FUNC_LIST[341](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60016) then
							break
						end
						FUNC_LIST[342](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60024) then
							break
						end
						FUNC_LIST[265](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 272)), 4294967280)))
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_4 = reg_0
						FUNC_LIST[146](load_i32(memory_at_0.data, loc_0), 23, 0, 0)
						while true do
							loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 260))
							loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 264))
							if loc_3 >= loc_5 then
								break
							end
							store_i64(memory_at_0.data, loc_3, shl_i64(extend_i64_u32(loc_4), i64_from_u32(32, 0)))
							store_i32(memory_at_0.data, loc_0 + 260, add_i32(loc_3, 8))
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = add_i32(loc_0, 256)
						loc_1 = load_i32(memory_at_0.data, loc_6)
						loc_7 = sub_i32(loc_3, loc_1)
						loc_8 = shr_i32(loc_7, 3)
						loc_3 = add_i32(loc_8, 1)
						if loc_3 >= 536870912 then
							desired = 2
							break
						end
						while true do
							while true do
								loc_5 = sub_i32(loc_5, loc_1)
								loc_6 = shr_i32(loc_5, 2)
								loc_5 = (if loc_5 < 2147483640 then (if loc_6 < loc_3 then loc_3 else loc_6) else 536870911)
								if loc_5 ~= 0 then
									break
								end
								loc_3 = 0
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_5 >= 536870912 then
								desired = 1
								break
							end
							reg_0 = FUNC_LIST[1461](shl_i32(loc_5, 3))
							loc_3 = reg_0
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = add_i32(loc_3, shl_i32(loc_8, 3))
						store_i64(memory_at_0.data, loc_8, shl_i64(extend_i64_u32(loc_4), i64_from_u32(32, 0)))
						loc_4 = add_i32(loc_3, shl_i32(loc_5, 3))
						loc_5 = add_i32(loc_8, 8)
						while true do
							if lt_i32(loc_7, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_3, loc_1, loc_7)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 264, loc_4)
						store_i32(memory_at_0.data, loc_0 + 260, loc_5)
						store_i32(memory_at_0.data, loc_0 + 256, loc_3)
						if loc_1 == 0 then
							desired = 3
							break
						end
						FUNC_LIST[1463](loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60032) then
							break
						end
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 272))
						while true do
							while true do
								if load_i32_u8(memory_at_0.data, 0 + 60336) == 0 then
									break
								end
								loc_4 = add_i32(loc_3, 4294967292)
								if load_i32(memory_at_0.data, loc_4) ~= 0 then
									desired = 5
									break
								end
								store_i32(memory_at_0.data, loc_4, loc_1)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_4 = load_i32(memory_at_0.data, add_i32(loc_3, 4294967288))
							if loc_4 == 0 then
								break
							end
							FUNC_LIST[343](loc_0, loc_1, loc_4)
							loc_3 = load_i32(memory_at_0.data, loc_0 + 272)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						FUNC_LIST[265](loc_0, load_i32(memory_at_0.data, add_i32(loc_3, 4294967284)))
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_3 = reg_0
						FUNC_LIST[146](load_i32(memory_at_0.data, loc_0), 23, 0, 0)
						store_i32(memory_at_0.data, loc_2 + 12, loc_3)
						store_i32(memory_at_0.data, loc_2 + 8, 1)
						FUNC_LIST[344](add_i32(loc_0, 256), 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 loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60040) then
							break
						end
						while true do
							if lt_i32(load_i32(memory_at_0.data, loc_0 + 4), 2) then
								break
							end
							if load_i32(memory_at_0.data, loc_0 + 280) == load_i32(memory_at_0.data, add_i32(loc_0, 284)) then
								break
							end
							FUNC_LIST[345](loc_0, loc_1, 0)
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						FUNC_LIST[346](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60048) then
							break
						end
						while true do
							loc_3 = load_i32(memory_at_0.data, loc_1 + 28)
							if load_i32(memory_at_0.data, loc_3 + 4) ~= load_i32(memory_at_0.data, 0 + 59912) then
								break
							end
							if loc_3 == 0 then
								break
							end
							FUNC_LIST[347](loc_0, loc_3, load_i32_u8(memory_at_0.data, loc_0 + 220), 0, 0, 0)
							desired = 3
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_2 + 8, loc_0)
						store_i32(memory_at_0.data, loc_2 + 12, load_i32(memory_at_0.data, loc_0 + 220))
						reg_0 = FUNC_LIST[348](loc_0, loc_3, add_i32(loc_2, 8))
						store_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2 + 8) + 220, load_i32(memory_at_0.data, loc_2 + 12))
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60056) then
							break
						end
						FUNC_LIST[349](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60064) then
							break
						end
						FUNC_LIST[350](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60072) then
							break
						end
						FUNC_LIST[351](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60080) then
							break
						end
						FUNC_LIST[352](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60088) then
							break
						end
						FUNC_LIST[353](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					while true do
						if loc_1 == 0 then
							break
						end
						if loc_3 ~= load_i32(memory_at_0.data, 0 + 60096) then
							break
						end
						FUNC_LIST[354](loc_0, loc_1)
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_1 == 0 then
						break
					end
					if loc_3 ~= load_i32(memory_at_0.data, 0 + 60104) then
						break
					end
					reg_0 = FUNC_LIST[338](loc_0, loc_1, 1)
					loc_3 = reg_0
					FUNC_LIST[262](loc_0, load_i32(memory_at_0.data, loc_1 + 28), loc_3)
					FUNC_LIST[355](loc_0, load_i32(memory_at_0.data, add_i32(loc_1, 32)), loc_3)
					reg_0 = FUNC_LIST[339](add_i32(loc_0, 52), add_i32(loc_1, 28))
					reg_1 = FUNC_LIST[161](load_i32(memory_at_0.data, loc_0))
					store_i32(memory_at_0.data, 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[356](loc_6)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[264] = --[[ Luau::Compiler::alwaysTerminates(Luau::AstStat*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	local desired
	while true do
		loc_2 = load_i32(memory_at_0.data, 0 + 59992)
		while true do
			while true do
				loc_3 = load_i32(memory_at_0.data, loc_1 + 4)
				while true do
					if loc_1 == 0 then
						break
					end
					if loc_3 ~= loc_2 then
						break
					end
					while true do
						loc_3 = load_i32(memory_at_0.data, add_i32(loc_1, 32))
						if loc_3 ~= 0 then
							break
						end
						loc_2 = 0
						desired = 1
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					loc_1 = load_i32(memory_at_0.data, add_i32(add_i32(shl_i32(loc_3, 2), load_i32(memory_at_0.data, loc_1 + 28)), 4294967292))
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_2 = 1
				if loc_3 == load_i32(memory_at_0.data, 0 + 60040) then
					desired = 1
					break
				end
				if loc_3 == load_i32(memory_at_0.data, 0 + 60024) then
					desired = 1
					break
				end
				if loc_3 == load_i32(memory_at_0.data, 0 + 60032) then
					desired = 1
					break
				end
				loc_2 = 0
				if loc_1 == 0 then
					desired = 1
					break
				end
				if loc_3 ~= load_i32(memory_at_0.data, 0 + 60000) then
					desired = 1
					break
				end
				loc_3 = add_i32(loc_1, 36)
				if load_i32(memory_at_0.data, loc_3) == 0 then
					desired = 1
					break
				end
				reg_0 = FUNC_LIST[264](loc_0, load_i32(memory_at_0.data, add_i32(loc_1, 32)))
				if reg_0 == 0 then
					desired = 1
					break
				end
				loc_2 = load_i32(memory_at_0.data, 0 + 59992)
				loc_1 = load_i32(memory_at_0.data, loc_3)
				continue
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			error("out of code bounds")
		end
		reg_0 = loc_2
		break
	end
	return reg_0
end
FUNC_LIST[265] = --[[ Luau::Compiler::closeLocals(unsigned long) ]] function(loc_0, loc_1)
	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 desired
	while true do
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 232)
			loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 236)), loc_2), 2)
			if loc_3 <= loc_1 then
				break
			end
			loc_4 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 56)), 4294967295)
			loc_5 = load_i32(memory_at_0.data, add_i32(loc_0, 64))
			loc_6 = load_i32(memory_at_0.data, add_i32(loc_0, 60))
			loc_7 = load_i32(memory_at_0.data, loc_0 + 52)
			loc_8 = 0
			loc_9 = 255
			while true do
				loc_10 = 0
				while true do
					if loc_6 == 0 then
						break
					end
					loc_10 = 0
					loc_11 = load_i32(memory_at_0.data, add_i32(loc_2, shl_i32(loc_1, 2)))
					if loc_11 == loc_5 then
						break
					end
					loc_12 = bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9))
					loc_13 = 0
					while true do
						loc_14 = band_i32(loc_12, loc_4)
						loc_10 = add_i32(loc_7, mul_i32(loc_14, 12))
						loc_12 = load_i32(memory_at_0.data, loc_10)
						if loc_12 == loc_11 then
							desired = 3
							break
						end
						loc_10 = 0
						if loc_12 == loc_5 then
							desired = 3
							break
						end
						loc_13 = add_i32(loc_13, 1)
						loc_12 = add_i32(loc_13, loc_14)
						if loc_13 <= 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
				while true do
					loc_13 = (if loc_10 ~= 0 then add_i32(loc_10, 4) else 0)
					if load_i32_u8(memory_at_0.data, loc_13 + 2) == 0 then
						break
					end
					loc_13 = load_i32_u8(memory_at_0.data, loc_13)
					loc_9 = (if loc_13 < band_i32(loc_9, 255) then loc_13 else loc_9)
					loc_8 = 1
					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 ~= loc_3 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if band_i32(loc_8, 1) == 0 then
				break
			end
			FUNC_LIST[144](load_i32(memory_at_0.data, loc_0), 11, band_i32(loc_9, 255), 0, 0)
			break
		end
		break
	end
end
FUNC_LIST[266] = --[[ Luau::Compiler::getUpval(Luau::AstLocal*) ]] function(loc_0, loc_1)
	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_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		store_i32(memory_at_0.data, loc_2 + 12, loc_1)
		while true do
			while true do
				while true do
					while true do
						while true do
							loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 248))
							loc_4 = load_i32(memory_at_0.data, loc_0 + 244)
							loc_5 = sub_i32(loc_3, loc_4)
							if loc_5 == 0 then
								break
							end
							loc_6 = shr_i32(loc_5, 2)
							loc_7 = (if loc_6 > 1 then loc_6 else 1)
							loc_6 = 0
							while true do
								if load_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_6, 2))) == loc_1 then
									desired = 4
									break
								end
								loc_6 = add_i32(loc_6, 1)
								if loc_6 ~= loc_7 then
									continue
								end
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_5 >= 797 then
								desired = 3
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						while true do
							if load_i32(memory_at_0.data, add_i32(loc_0, 100)) == 0 then
								break
							end
							loc_8 = load_i32(memory_at_0.data, add_i32(loc_0, 104))
							if loc_8 == loc_1 then
								break
							end
							loc_4 = bxor_i32(shr_u32(loc_1, 4), shr_u32(loc_1, 9))
							loc_7 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 96)), 4294967295)
							loc_9 = load_i32(memory_at_0.data, loc_0 + 92)
							loc_6 = 0
							while true do
								while true do
									loc_4 = band_i32(loc_4, loc_7)
									loc_5 = load_i32(memory_at_0.data, add_i32(loc_9, mul_i32(loc_4, 12)))
									if loc_5 == loc_1 then
										desired = 6
										break
									end
									if loc_5 == loc_8 then
										desired = 5
										break
									end
									loc_6 = add_i32(loc_6, 1)
									loc_4 = add_i32(loc_6, loc_4)
									if loc_6 <= loc_7 then
										continue
									end
									desired = 5
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if load_i32_u8(memory_at_0.data, add_i32(add_i32(loc_9, mul_i32(loc_4, 12)), 8)) == 0 then
								break
							end
							reg_0 = FUNC_LIST[339](add_i32(loc_0, 52), add_i32(loc_2, 12))
							store_i32_n8(memory_at_0.data, reg_0 + 2, 1)
							loc_3 = load_i32(memory_at_0.data, loc_0 + 248)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_1 = add_i32(loc_0, 244)
						while true do
							while true do
								if loc_3 == load_i32(memory_at_0.data, add_i32(loc_0, 252)) then
									break
								end
								store_i32(memory_at_0.data, loc_3, load_i32(memory_at_0.data, loc_2 + 12))
								loc_6 = add_i32(loc_3, 4)
								store_i32(memory_at_0.data, loc_0 + 248, loc_6)
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_5 = load_i32(memory_at_0.data, loc_1)
							loc_4 = sub_i32(loc_3, loc_5)
							loc_9 = shr_i32(loc_4, 2)
							loc_6 = add_i32(loc_9, 1)
							if loc_6 >= 1073741824 then
								desired = 2
								break
							end
							while true do
								while true do
									loc_7 = shr_i32(loc_4, 1)
									loc_6 = (if loc_4 < 2147483644 then (if loc_7 < loc_6 then loc_6 else loc_7) else 1073741823)
									if loc_6 ~= 0 then
										break
									end
									loc_7 = 0
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								if loc_6 >= 1073741824 then
									desired = 1
									break
								end
								reg_0 = FUNC_LIST[1461](shl_i32(loc_6, 2))
								loc_7 = reg_0
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_9 = add_i32(loc_7, shl_i32(loc_9, 2))
							store_i32(memory_at_0.data, loc_9, load_i32(memory_at_0.data, loc_2 + 12))
							loc_8 = add_i32(loc_7, shl_i32(loc_6, 2))
							loc_6 = add_i32(loc_9, 4)
							while true do
								if lt_i32(loc_4, 1) then
									break
								end
								reg_0 = FUNC_LIST[1224](loc_7, loc_5, loc_4)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_0 + 252, loc_8)
							store_i32(memory_at_0.data, loc_0 + 248, loc_6)
							store_i32(memory_at_0.data, loc_0 + 244, loc_7)
							if loc_5 == 0 then
								break
							end
							FUNC_LIST[1463](loc_5)
							loc_6 = load_i32(memory_at_0.data, loc_0 + 248)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_6 = add_i32(shr_u32(sub_i32(loc_6, load_i32(memory_at_0.data, loc_1)), 2), 4294967295)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_2, 16)
					reg_0 = band_i32(loc_6, 255)
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_6 = load_i32(memory_at_0.data, loc_1)
				store_i32(memory_at_0.data, loc_2 + 4, 200)
				store_i32(memory_at_0.data, loc_2, loc_6)
				FUNC_LIST[257](add_i32(loc_1, 4), 9104, loc_2)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[275](loc_1)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[267] = --[[ Luau::Compiler::popLocals(unsigned long) ]] function(loc_0, loc_1)
	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 reg_1
	local desired
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 236))
			loc_4 = load_i32(memory_at_0.data, loc_0 + 232)
			loc_5 = shr_i32(sub_i32(loc_3, loc_4), 2)
			if loc_5 <= loc_1 then
				break
			end
			loc_6 = loc_1
			while true do
				loc_7 = 0
				while true do
					if load_i32(memory_at_0.data, loc_0 + 60) == 0 then
						break
					end
					loc_7 = 0
					loc_8 = load_i32(memory_at_0.data, add_i32(loc_4, shl_i32(loc_6, 2)))
					loc_9 = load_i32(memory_at_0.data, loc_0 + 64)
					if loc_8 == loc_9 then
						break
					end
					loc_10 = bxor_i32(shr_u32(loc_8, 4), shr_u32(loc_8, 9))
					loc_11 = add_i32(load_i32(memory_at_0.data, loc_0 + 56), 4294967295)
					loc_12 = load_i32(memory_at_0.data, loc_0 + 52)
					loc_5 = 0
					while true do
						loc_13 = band_i32(loc_10, loc_11)
						loc_7 = add_i32(loc_12, mul_i32(loc_13, 12))
						loc_10 = load_i32(memory_at_0.data, loc_7)
						if loc_10 == loc_8 then
							desired = 3
							break
						end
						loc_7 = 0
						if loc_10 == loc_9 then
							desired = 3
							break
						end
						loc_5 = add_i32(loc_5, 1)
						loc_10 = add_i32(loc_5, loc_13)
						if loc_5 <= loc_11 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_5 = (if loc_7 ~= 0 then add_i32(loc_7, 4) else 0)
				store_i32_n8(memory_at_0.data, loc_5 + 1, 0)
				while true do
					if lt_i32(load_i32(memory_at_0.data, loc_0 + 8), 2) then
						break
					end
					reg_0 = FUNC_LIST[161](load_i32(memory_at_0.data, loc_0))
					loc_7 = reg_0
					loc_10 = load_i32(memory_at_0.data, loc_0)
					loc_11 = load_i32(memory_at_0.data, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_0 + 232), shl_i32(loc_6, 2))))
					store_i32(memory_at_0.data, loc_2 + 8, loc_11)
					reg_1 = FUNC_LIST[1383](loc_11)
					store_i32(memory_at_0.data, loc_2 + 12, reg_1)
					loc_11 = load_i32(memory_at_0.data, loc_5 + 4)
					loc_5 = load_i32_u8(memory_at_0.data, loc_5)
					store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_2 + 8))
					FUNC_LIST[156](loc_10, loc_2, loc_5, loc_11, loc_7)
					loc_4 = load_i32(memory_at_0.data, loc_0 + 232)
					loc_3 = load_i32(memory_at_0.data, loc_0 + 236)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				loc_6 = add_i32(loc_6, 1)
				loc_5 = shr_i32(sub_i32(loc_3, loc_4), 2)
				if loc_6 < loc_5 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			break
		end
		while true do
			while true do
				if loc_5 >= loc_1 then
					break
				end
				FUNC_LIST[357](add_i32(loc_0, 232), sub_i32(loc_1, loc_5))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_5 <= loc_1 then
				break
			end
			store_i32(memory_at_0.data, loc_0 + 236, add_i32(loc_4, shl_i32(loc_1, 2)))
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		break
	end
end
FUNC_LIST[268] = --[[ Luau::DenseHashMap<Luau::AstExprFunction*, Luau::Compiler::Function, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstExprFunction*> >::operator[](Luau::AstExprFunction* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, mul_i32(loc_9, 40)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[358](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, mul_i32(loc_9, 40))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 8)
		break
	end
	return reg_0
end
FUNC_LIST[269] = --[[ 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(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local loc_7 = 0
	local reg_0
	local reg_1
	local desired
	while true do
		while true do
			loc_3 = sub_i32(loc_2, loc_1)
			loc_4 = shr_i32(loc_3, 2)
			loc_5 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_6 = load_i32(memory_at_0.data, loc_0)
			if loc_4 > shr_i32(sub_i32(loc_5, loc_6), 2) then
				break
			end
			while true do
				loc_3 = sub_i32(load_i32(memory_at_0.data, loc_0 + 4), loc_6)
				loc_5 = shr_i32(loc_3, 2)
				loc_7 = (if loc_4 > loc_5 then add_i32(loc_1, loc_3) else loc_2)
				loc_3 = sub_i32(loc_7, loc_1)
				if loc_3 == 0 then
					break
				end
				reg_0 = FUNC_LIST[1285](loc_6, loc_1, loc_3)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			while true do
				if loc_4 <= loc_5 then
					break
				end
				loc_1 = load_i32(memory_at_0.data, loc_0 + 4)
				while true do
					loc_6 = sub_i32(loc_2, loc_7)
					if lt_i32(loc_6, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_1, loc_7, loc_6)
					loc_1 = add_i32(reg_0, loc_6)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 4, loc_1)
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, add_i32(loc_6, loc_3))
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if loc_6 == 0 then
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, loc_6)
			FUNC_LIST[1463](loc_6)
			loc_5 = 0
			store_i32(memory_at_0.data, loc_0 + 8, 0)
			store_i64(memory_at_0.data, loc_0, i64_ZERO)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			if le_i32(loc_3, 4294967295) then
				break
			end
			loc_6 = shr_i32(loc_5, 1)
			loc_6 = (if loc_5 < 2147483644 then (if loc_6 < loc_4 then loc_4 else loc_6) else 1073741823)
			if loc_6 >= 1073741824 then
				break
			end
			loc_4 = shl_i32(loc_6, 2)
			reg_1 = FUNC_LIST[1461](loc_4)
			loc_6 = reg_1
			store_i32(memory_at_0.data, loc_0, loc_6)
			store_i32(memory_at_0.data, loc_0 + 4, loc_6)
			store_i32(memory_at_0.data, loc_0 + 8, add_i32(loc_6, loc_4))
			while true do
				if loc_3 == 0 then
					break
				end
				reg_0 = FUNC_LIST[1224](loc_6, loc_1, loc_3)
				loc_6 = add_i32(reg_0, loc_3)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, loc_6)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[275](loc_0)
		error("out of code bounds")
	end
end
FUNC_LIST[270] = --[[ std::__2::vector<Luau::ParseError, std::__2::allocator<Luau::ParseError> >::vector(std::__2::vector<Luau::ParseError, std::__2::allocator<Luau::ParseError> > const&) ]] function(loc_0, loc_1)
	local loc_2 = 0
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local loc_6 = 0
	local reg_0
	local reg_1
	local desired
	while true do
		store_i32(memory_at_0.data, loc_0 + 8, 0)
		store_i64(memory_at_0.data, loc_0, i64_ZERO)
		while true do
			while true do
				loc_2 = sub_i32(load_i32(memory_at_0.data, loc_1 + 4), load_i32(memory_at_0.data, loc_1))
				if loc_2 == 0 then
					break
				end
				if le_i32(loc_2, 4294967295) then
					desired = 1
					break
				end
				reg_1 = FUNC_LIST[1461](loc_2)
				loc_3 = reg_1
				store_i32(memory_at_0.data, loc_0, loc_3)
				store_i32(memory_at_0.data, loc_0 + 4, loc_3)
				store_i32(memory_at_0.data, loc_0 + 8, add_i32(loc_3, shl_i32(shr_i32(loc_2, 5), 5)))
				while true do
					loc_2 = load_i32(memory_at_0.data, loc_1)
					loc_4 = load_i32(memory_at_0.data, loc_1 + 4)
					if loc_2 == loc_4 then
						break
					end
					loc_5 = add_i32(41816, 8)
					while true do
						store_i32(memory_at_0.data, loc_3, loc_5)
						store_i64(memory_at_0.data, add_i32(loc_3, 12), load_i64(memory_at_0.data, add_i32(loc_2, 12)))
						store_i64(memory_at_0.data, loc_3 + 4, load_i64(memory_at_0.data, loc_2 + 4))
						loc_1 = add_i32(loc_3, 20)
						while true do
							while true do
								if lt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_2, 31)), 0) then
									break
								end
								loc_6 = add_i32(loc_2, 20)
								store_i64(memory_at_0.data, loc_1, load_i64(memory_at_0.data, loc_6))
								store_i32(memory_at_0.data, add_i32(loc_1, 8), load_i32(memory_at_0.data, add_i32(loc_6, 8)))
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							FUNC_LIST[1536](loc_1, load_i32(memory_at_0.data, loc_2 + 20), load_i32(memory_at_0.data, add_i32(loc_2, 24)))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
								continue
							end
							break
						end
						loc_3 = add_i32(loc_3, 32)
						loc_2 = add_i32(loc_2, 32)
						if loc_2 ~= 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
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 4, loc_3)
				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
		FUNC_LIST[271](loc_0)
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[271] = --[[ std::__2::vector<Luau::ParseError, std::__2::allocator<Luau::ParseError> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[272] = --[[ 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(loc_0, loc_1, loc_2, loc_3, loc_4)
	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 reg_1
	local desired
	while true do
		loc_5 = sub_i32(GLOBAL_LIST[0].value, 560)
		GLOBAL_LIST[0].value = loc_5
		reg_1 = FUNC_LIST[1051](add_i32(loc_5, 552))
		loc_6 = reg_1
		reg_0 = FUNC_LIST[1060](add_i32(loc_5, 520), loc_6)
		loc_7 = reg_0
		loc_8 = load_i32(memory_at_0.data, loc_1)
		loc_9 = load_i32(memory_at_0.data, loc_1 + 4)
		loc_10 = load_i32_u8(memory_at_0.data, loc_1 + 11)
		loc_3 = load_i32_u16(memory_at_0.data, loc_3)
		store_i32_n16(memory_at_0.data, loc_5 + 14, loc_3)
		store_i32_n16(memory_at_0.data, loc_5 + 470, loc_3)
		loc_3 = (if lt_i32(shr_i32(shl_i32(loc_10, 24), 24), 0) then 1 else 0)
		FUNC_LIST[1101](add_i32(loc_5, 472), (if loc_3 ~= 0 then loc_8 else loc_1), (if loc_3 ~= 0 then loc_9 else loc_10), loc_7, loc_6, add_i32(loc_5, 14))
		while true do
			while true do
				loc_1 = load_i32(memory_at_0.data, loc_5 + 492)
				if loc_1 == load_i32(memory_at_0.data, add_i32(add_i32(loc_5, 472), 24)) then
					break
				end
				reg_0 = FUNC_LIST[1097](loc_1)
				loc_10 = load_i32(memory_at_0.data, reg_0)
				reg_1 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1) + 8)](loc_1)
				store_i32(memory_at_0.data, loc_5 + 4, reg_1)
				store_i32(memory_at_0.data, loc_5, add_i32(loc_10, 1))
				FUNC_LIST[1217](add_i32(loc_5, 16), 3759, loc_5)
				FUNC_LIST[176](loc_0, add_i32(loc_5, 16))
				if gt_i32(load_i32_i8(memory_at_0.data, loc_5 + 27), 4294967295) then
					desired = 1
					break
				end
				FUNC_LIST[1463](load_i32(memory_at_0.data, loc_5 + 16))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[112](add_i32(loc_5, 16), loc_4)
			loc_1 = reg_0
			FUNC_LIST[258](loc_1, add_i32(loc_5, 472), loc_7, loc_2)
			while true do
				while true do
					if lt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 407)), 0) then
						break
					end
					loc_10 = add_i32(loc_1, 396)
					store_i64(memory_at_0.data, loc_0, load_i64(memory_at_0.data, loc_10))
					store_i32(memory_at_0.data, add_i32(loc_0, 8), load_i32(memory_at_0.data, add_i32(loc_10, 8)))
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[1536](loc_0, load_i32(memory_at_0.data, loc_1 + 396), load_i32(memory_at_0.data, add_i32(loc_1, 400)))
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			reg_0 = FUNC_LIST[273](loc_1)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_5 + 504)
			if loc_1 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_5, 508), loc_1)
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_10 = load_i32(memory_at_0.data, loc_5 + 492)
			if loc_10 == 0 then
				break
			end
			while true do
				while true do
					loc_1 = load_i32(memory_at_0.data, loc_5 + 496)
					if loc_1 ~= loc_10 then
						break
					end
					loc_1 = loc_10
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					loc_1 = add_i32(loc_1, 4294967264)
					reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1))](loc_1)
					if loc_1 ~= loc_10 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = load_i32(memory_at_0.data, loc_5 + 492)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_5 + 496, loc_10)
			FUNC_LIST[1463](loc_1)
			break
		end
		while true do
			loc_0 = load_i32(memory_at_0.data, loc_5 + 480)
			if loc_0 == 0 then
				break
			end
			loc_10 = loc_0
			while true do
				loc_1 = load_i32(memory_at_0.data, add_i32(loc_5, 484))
				if loc_1 == loc_0 then
					break
				end
				while true do
					loc_10 = add_i32(loc_1, 4294967264)
					while true do
						if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 4294967295)), 4294967295) then
							break
						end
						FUNC_LIST[1463](load_i32(memory_at_0.data, add_i32(loc_1, 4294967284)))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_1 = loc_10
					if loc_10 ~= loc_0 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_10 = load_i32(memory_at_0.data, loc_5 + 480)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_5 + 484, loc_0)
			FUNC_LIST[1463](loc_10)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_7)
			if loc_1 == 0 then
				break
			end
			FUNC_LIST[1463](loc_1)
			break
		end
		reg_0 = FUNC_LIST[1052](loc_6)
		GLOBAL_LIST[0].value = add_i32(loc_5, 560)
		break
	end
end
FUNC_LIST[273] = --[[ Luau::BytecodeBuilder::~BytecodeBuilder() ]] function(loc_0)
	local loc_1 = 0
	local loc_2 = 0
	local loc_3 = 0
	local reg_0
	local desired
	while true do
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 424)
			if loc_1 == 0 then
				break
			end
			while true do
				while true do
					loc_2 = load_i32(memory_at_0.data, add_i32(loc_0, 428))
					if loc_2 ~= loc_1 then
						break
					end
					loc_2 = loc_1
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					loc_3 = add_i32(loc_2, 4294967280)
					while true do
						if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_2, 4294967295)), 4294967295) then
							break
						end
						FUNC_LIST[1463](load_i32(memory_at_0.data, add_i32(loc_2, 4294967284)))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_2 = loc_3
					if loc_3 ~= loc_1 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_0 + 424)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 428, loc_1)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_0 + 412)
			if loc_1 == 0 then
				break
			end
			while true do
				while true do
					loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 416))
					if loc_3 ~= loc_1 then
						break
					end
					loc_2 = loc_1
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				while true do
					loc_2 = add_i32(loc_3, 4294967284)
					while true do
						if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_3, 4294967295)), 4294967295) then
							break
						end
						FUNC_LIST[1463](load_i32(memory_at_0.data, loc_2))
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
							continue
						end
						break
					end
					loc_3 = loc_2
					if loc_2 ~= loc_1 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_0 + 412)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 416, loc_1)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_0, 407)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0 + 396))
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_0, 391)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_0 + 380))
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 368)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 372), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 356)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 360), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 332)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 332, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 320)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 324), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 308)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 312), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 284)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 284, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 136)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 136, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 96)
			if loc_2 == 0 then
				break
			end
			FUNC_LIST[1463](loc_2)
			store_i64(memory_at_0.data, loc_0 + 96, i64_ZERO)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 80)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 84), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 68)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 72), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 56)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 60), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 44)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 48), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 32)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 36), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 20)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_0, 24), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			loc_3 = load_i32(memory_at_0.data, loc_0)
			if loc_3 == 0 then
				break
			end
			while true do
				while true do
					loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
					if loc_2 ~= loc_3 then
						break
					end
					loc_2 = loc_3
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_1 = add_i32(loc_0, 8)
				while true do
					loc_2 = add_i32(loc_2, 4294967224)
					FUNC_LIST[274](loc_1, loc_2)
					if loc_2 ~= loc_3 then
						continue
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_2 = load_i32(memory_at_0.data, loc_0)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			store_i32(memory_at_0.data, loc_0 + 4, loc_3)
			FUNC_LIST[1463](loc_2)
			break
		end
		reg_0 = loc_0
		break
	end
	return reg_0
end
FUNC_LIST[274] = --[[ std::__2::allocator<Luau::BytecodeBuilder::Function>::destroy(Luau::BytecodeBuilder::Function*) ]] function(loc_0, loc_1)
	local loc_2 = 0
	while true do
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 71)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 60))
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_1 + 48)
			if loc_2 == 0 then
				break
			end
			store_i32(memory_at_0.data, add_i32(loc_1, 52), loc_2)
			FUNC_LIST[1463](loc_2)
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 47)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 36))
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, add_i32(loc_1, 35)), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1 + 24))
			break
		end
		while true do
			if gt_i32(load_i32_i8(memory_at_0.data, loc_1 + 11), 4294967295) then
				break
			end
			FUNC_LIST[1463](load_i32(memory_at_0.data, loc_1))
			break
		end
		break
	end
end
FUNC_LIST[275] = --[[ std::__2::vector<Luau::AstLocal*, std::__2::allocator<Luau::AstLocal*> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[276] = --[[ std::__throw_bad_array_new_length() ]] function()
	local loc_0 = 0
	local reg_0
	while true do
		reg_0 = FUNC_LIST[1253](4)
		loc_0 = reg_0
		reg_0 = FUNC_LIST[1625](loc_0)
		FUNC_LIST[1252](loc_0, 59428, 127)
		error("out of code bounds")
	end
end
FUNC_LIST[277] = --[[ Luau::Compiler::FenvVisitor::~FenvVisitor() ]] function(loc_0)
	while true do
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[278] = --[[ Luau::AstVisitor::visit(Luau::AstNode*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = 1
		break
	end
	return reg_0
end
FUNC_LIST[279] = --[[ Luau::AstVisitor::visit(Luau::AstExpr*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 8)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[280] = --[[ Luau::AstVisitor::visit(Luau::AstExprGroup*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[281] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantNil*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[282] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantBool*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[283] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantNumber*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[284] = --[[ Luau::AstVisitor::visit(Luau::AstExprConstantString*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[285] = --[[ Luau::AstVisitor::visit(Luau::AstExprLocal*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[286] = --[[ Luau::Compiler::FenvVisitor::visit(Luau::AstExprGlobal*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		while true do
			loc_1 = load_i32(memory_at_0.data, loc_1 + 24)
			if loc_1 == 0 then
				break
			end
			while true do
				reg_0 = FUNC_LIST[1379](loc_1, 1579)
				if reg_0 ~= 0 then
					break
				end
				store_i32_n8(memory_at_0.data, load_i32(memory_at_0.data, loc_0 + 4), 1)
				break
			end
			reg_0 = FUNC_LIST[1379](loc_1, 1571)
			if reg_0 ~= 0 then
				break
			end
			store_i32_n8(memory_at_0.data, load_i32(memory_at_0.data, loc_0 + 8), 1)
			break
		end
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[287] = --[[ Luau::AstVisitor::visit(Luau::AstExprVarargs*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[288] = --[[ Luau::AstVisitor::visit(Luau::AstExprCall*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[289] = --[[ Luau::AstVisitor::visit(Luau::AstExprIndexName*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[290] = --[[ Luau::AstVisitor::visit(Luau::AstExprIndexExpr*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[291] = --[[ Luau::AstVisitor::visit(Luau::AstExprFunction*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[292] = --[[ Luau::AstVisitor::visit(Luau::AstExprTable*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[293] = --[[ Luau::AstVisitor::visit(Luau::AstExprUnary*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[294] = --[[ Luau::AstVisitor::visit(Luau::AstExprBinary*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[295] = --[[ Luau::AstVisitor::visit(Luau::AstExprTypeAssertion*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[296] = --[[ Luau::AstVisitor::visit(Luau::AstExprIfElse*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[297] = --[[ Luau::AstVisitor::visit(Luau::AstExprInterpString*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[298] = --[[ Luau::AstVisitor::visit(Luau::AstExprError*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[299] = --[[ Luau::AstVisitor::visit(Luau::AstStat*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 8)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[300] = --[[ Luau::AstVisitor::visit(Luau::AstStatBlock*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[301] = --[[ Luau::AstVisitor::visit(Luau::AstStatIf*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[302] = --[[ Luau::AstVisitor::visit(Luau::AstStatWhile*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[303] = --[[ Luau::AstVisitor::visit(Luau::AstStatRepeat*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[304] = --[[ Luau::AstVisitor::visit(Luau::AstStatBreak*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[305] = --[[ Luau::AstVisitor::visit(Luau::AstStatContinue*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[306] = --[[ Luau::AstVisitor::visit(Luau::AstStatReturn*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[307] = --[[ Luau::AstVisitor::visit(Luau::AstStatExpr*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[308] = --[[ Luau::AstVisitor::visit(Luau::AstStatLocal*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[309] = --[[ Luau::AstVisitor::visit(Luau::AstStatFor*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[310] = --[[ Luau::AstVisitor::visit(Luau::AstStatForIn*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[311] = --[[ Luau::AstVisitor::visit(Luau::AstStatAssign*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[312] = --[[ Luau::AstVisitor::visit(Luau::AstStatCompoundAssign*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[313] = --[[ Luau::AstVisitor::visit(Luau::AstStatFunction*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[314] = --[[ Luau::AstVisitor::visit(Luau::AstStatLocalFunction*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[315] = --[[ Luau::AstVisitor::visit(Luau::AstStatTypeAlias*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[316] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareFunction*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[317] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareGlobal*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[318] = --[[ Luau::AstVisitor::visit(Luau::AstStatDeclareClass*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[319] = --[[ Luau::AstVisitor::visit(Luau::AstStatError*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 92)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[320] = --[[ Luau::AstVisitor::visit(Luau::AstType*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[321] = --[[ Luau::AstVisitor::visit(Luau::AstTypeReference*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[322] = --[[ Luau::AstVisitor::visit(Luau::AstTypeTable*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[323] = --[[ Luau::AstVisitor::visit(Luau::AstTypeFunction*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[324] = --[[ Luau::AstVisitor::visit(Luau::AstTypeTypeof*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[325] = --[[ Luau::AstVisitor::visit(Luau::AstTypeUnion*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[326] = --[[ Luau::AstVisitor::visit(Luau::AstTypeIntersection*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[327] = --[[ Luau::AstVisitor::visit(Luau::AstTypeSingletonBool*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[328] = --[[ Luau::AstVisitor::visit(Luau::AstTypeSingletonString*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[329] = --[[ Luau::AstVisitor::visit(Luau::AstTypeError*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 176)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[330] = --[[ Luau::AstVisitor::visit(Luau::AstTypePack*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = 0
		break
	end
	return reg_0
end
FUNC_LIST[331] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackExplicit*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 216)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[332] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackVariadic*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 216)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[333] = --[[ Luau::AstVisitor::visit(Luau::AstTypePackGeneric*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 216)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[334] = --[[ Luau::AstVisitor::visit(Luau::AstExprGlobal*) ]] function(loc_0, loc_1)
	local reg_0
	while true do
		reg_0 = TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_0) + 12)](loc_0, loc_1)
		break
	end
	return reg_0
end
FUNC_LIST[335] = --[[ Luau::Compiler::FunctionVisitor::~FunctionVisitor() ]] function(loc_0)
	while true do
		FUNC_LIST[1463](loc_0)
		break
	end
end
FUNC_LIST[336] = --[[ Luau::Compiler::FunctionVisitor::visit(Luau::AstExprFunction*) ]] function(loc_0, loc_1)
	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_2 = load_i32(memory_at_0.data, loc_1 + 92)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, loc_0)
		while true do
			loc_3 = load_i32(memory_at_0.data, add_i32(loc_1, 48))
			if loc_3 == 0 then
				break
			end
			loc_4 = load_i32(memory_at_0.data, loc_1 + 44)
			loc_5 = band_i32(add_i32(loc_3, 4294967295), 1073741823)
			loc_6 = load_i32_u8(memory_at_0.data, loc_0 + 12)
			while true do
				while true do
					loc_7 = band_i32(loc_3, 3)
					if loc_7 ~= 0 then
						break
					end
					loc_2 = loc_4
					desired = 2
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = 0
				loc_9 = loc_4
				while true do
					loc_6 = bor_i32(loc_6, (if load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_9) + 32) ~= 0 then 1 else 0))
					loc_2 = add_i32(loc_9, 4)
					loc_9 = loc_2
					loc_8 = add_i32(loc_8, 1)
					if loc_8 ~= loc_7 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
			while true do
				if loc_5 <= 2 then
					break
				end
				loc_9 = add_i32(loc_4, shl_i32(loc_3, 2))
				while true do
					loc_6 = bor_i32(bor_i32(bor_i32(bor_i32(loc_6, (if load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2) + 32) ~= 0 then 1 else 0)), (if load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2 + 4) + 32) ~= 0 then 1 else 0)), (if load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2 + 8) + 32) ~= 0 then 1 else 0)), (if load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2 + 12) + 32) ~= 0 then 1 else 0))
					loc_2 = add_i32(loc_2, 16)
					if loc_2 ~= loc_9 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_n8(memory_at_0.data, loc_0 + 12, loc_6)
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_6 = load_i32(memory_at_0.data, loc_2 + 4)
			if loc_6 == load_i32(memory_at_0.data, loc_2 + 8) then
				break
			end
			store_i32(memory_at_0.data, loc_6, loc_1)
			store_i32(memory_at_0.data, loc_2 + 4, add_i32(loc_6, 4))
			reg_0 = 0
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				loc_8 = load_i32(memory_at_0.data, loc_2)
				loc_6 = sub_i32(loc_6, loc_8)
				loc_0 = shr_i32(loc_6, 2)
				loc_9 = add_i32(loc_0, 1)
				if loc_9 >= 1073741824 then
					break
				end
				while true do
					while true do
						loc_7 = shr_i32(loc_6, 1)
						loc_7 = (if loc_6 < 2147483644 then (if loc_7 < loc_9 then loc_9 else loc_7) else 1073741823)
						if loc_7 ~= 0 then
							break
						end
						loc_9 = 0
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_7 >= 1073741824 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1461](shl_i32(loc_7, 2))
					loc_9 = reg_0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_0 = add_i32(loc_9, shl_i32(loc_0, 2))
				store_i32(memory_at_0.data, loc_0, loc_1)
				loc_7 = add_i32(loc_9, shl_i32(loc_7, 2))
				loc_1 = add_i32(loc_0, 4)
				while true do
					if lt_i32(loc_6, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_9, loc_8, loc_6)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_2 + 8, loc_7)
				store_i32(memory_at_0.data, loc_2 + 4, loc_1)
				store_i32(memory_at_0.data, loc_2, loc_9)
				while true do
					if loc_8 == 0 then
						break
					end
					FUNC_LIST[1463](loc_8)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				reg_0 = 0
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[337](loc_2)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
	return reg_0
end
FUNC_LIST[337] = --[[ std::__2::vector<Luau::AstExprFunction*, std::__2::allocator<Luau::AstExprFunction*> >::__throw_length_error() const ]] function(loc_0)
	while true do
		FUNC_LIST[40](3789)
		error("out of code bounds")
	end
end
FUNC_LIST[338] = --[[ Luau::Compiler::allocReg(Luau::AstNode*, unsigned int) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = 0
	local reg_0
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_3
		while true do
			loc_4 = load_i32(memory_at_0.data, loc_0 + 220)
			loc_5 = add_i32(loc_4, loc_2)
			if loc_5 < 256 then
				break
			end
			store_i32(memory_at_0.data, loc_3 + 4, 255)
			store_i32(memory_at_0.data, loc_3, loc_2)
			FUNC_LIST[257](add_i32(loc_1, 8), 8962, loc_3)
			error("out of code bounds")
		end
		store_i32(memory_at_0.data, loc_0 + 220, loc_5)
		loc_2 = load_i32(memory_at_0.data, loc_0 + 224)
		store_i32(memory_at_0.data, loc_0 + 224, (if loc_2 < loc_5 then loc_5 else loc_2))
		GLOBAL_LIST[0].value = add_i32(loc_3, 16)
		reg_0 = band_i32(loc_4, 255)
		break
	end
	return reg_0
end
FUNC_LIST[339] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::Compiler::Local, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*> >::operator[](Luau::AstLocal* const&) ]] function(loc_0, loc_1)
	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
		while true do
			loc_2 = load_i32(memory_at_0.data, loc_0 + 8)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			if loc_2 < shr_u32(mul_i32(loc_3, 3), 2) then
				break
			end
			while true do
				if loc_2 == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, loc_1)
				loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
				if loc_4 == loc_5 then
					break
				end
				loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
				loc_7 = add_i32(loc_3, 4294967295)
				loc_8 = load_i32(memory_at_0.data, loc_0)
				loc_2 = 0
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_6 = load_i32(memory_at_0.data, add_i32(loc_8, mul_i32(loc_9, 12)))
					if loc_6 == loc_4 then
						desired = 1
						break
					end
					if loc_6 == loc_5 then
						desired = 2
						break
					end
					loc_2 = add_i32(loc_2, 1)
					loc_6 = add_i32(loc_2, loc_9)
					if loc_2 <= loc_7 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
			FUNC_LIST[359](loc_0)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 4)
			break
		end
		loc_4 = load_i32(memory_at_0.data, loc_1)
		loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
		loc_7 = add_i32(loc_3, 4294967295)
		loc_5 = load_i32(memory_at_0.data, loc_0 + 12)
		loc_8 = load_i32(memory_at_0.data, loc_0)
		loc_2 = 0
		while true do
			while true do
				while true do
					loc_9 = band_i32(loc_6, loc_7)
					loc_3 = add_i32(loc_8, mul_i32(loc_9, 12))
					loc_6 = load_i32(memory_at_0.data, loc_3)
					if loc_6 ~= loc_5 then
						break
					end
					store_i32(memory_at_0.data, loc_3, loc_4)
					store_i32(memory_at_0.data, loc_0 + 8, add_i32(load_i32(memory_at_0.data, loc_0 + 8), 1))
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
						continue
					end
					break
				end
				if loc_6 == loc_4 then
					desired = 1
					break
				end
				loc_2 = add_i32(loc_2, 1)
				loc_6 = add_i32(loc_2, loc_9)
				if loc_2 <= loc_7 then
					continue
				end
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			loc_3 = 0
			break
		end
		reg_0 = add_i32(loc_3, 4)
		break
	end
	return reg_0
end
FUNC_LIST[340] = --[[ Luau::Compiler::compileStatIf(Luau::AstStatIf*) ]] function(loc_0, loc_1)
	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 reg_0
	local desired
	local br_map = {}
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = load_i32(memory_at_0.data, loc_1 + 28)
		while true do
			while true do
				if load_i32(memory_at_0.data, add_i32(loc_0, 120)) == 0 then
					break
				end
				loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 124))
				if loc_4 == loc_3 then
					break
				end
				loc_5 = bxor_i32(shr_u32(loc_3, 4), shr_u32(loc_3, 9))
				loc_6 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 116)), 4294967295)
				loc_7 = load_i32(memory_at_0.data, loc_0 + 112)
				loc_8 = 0
				while true do
					while true do
						loc_5 = band_i32(loc_5, loc_6)
						loc_9 = load_i32(memory_at_0.data, add_i32(loc_7, mul_i32(loc_5, 24)))
						if loc_9 == loc_3 then
							desired = 3
							break
						end
						if loc_9 == loc_4 then
							desired = 2
							break
						end
						loc_8 = add_i32(loc_8, 1)
						loc_5 = add_i32(loc_8, loc_5)
						if loc_8 <= loc_6 then
							continue
						end
						desired = 2
						break
					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
				while true do
					while true do
						loc_8 = add_i32(loc_7, mul_i32(loc_5, 24))
						if not br_map[1] then
							br_map[1] = (function()
								return { [0] = 1, 0, }
							end)()
						end
						temp = br_map[1][add_i32(load_i32(memory_at_0.data, loc_8 + 8), 4294967295)] 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.data, add_i32(loc_8, 16)) ~= 0 then
						desired = 2
						break
					end
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = load_i32(memory_at_0.data, loc_1 + 36)
				if loc_8 == 0 then
					desired = 1
					break
				end
				FUNC_LIST[263](loc_0, loc_8)
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			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
											while true do
												while true do
													loc_10 = load_i32(memory_at_0.data, loc_1 + 36)
													if loc_10 == 0 then
														break
													end
													loc_11 = load_i32(memory_at_0.data, loc_1 + 32)
													desired = 10
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												loc_11 = load_i32(memory_at_0.data, loc_1 + 32)
												loc_8 = load_i32(memory_at_0.data, loc_11 + 4)
												while true do
													while true do
														if loc_11 == 0 then
															break
														end
														if loc_8 ~= load_i32(memory_at_0.data, 0 + 59992) then
															break
														end
														if load_i32(memory_at_0.data, add_i32(loc_11, 32)) ~= 1 then
															desired = 10
															break
														end
														if load_i32(memory_at_0.data, load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_11 + 28)) + 4) ~= load_i32(memory_at_0.data, 0 + 60024) then
															desired = 10
															break
														end
														desired = 11
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if loc_8 ~= load_i32(memory_at_0.data, 0 + 60024) then
														desired = 10
														break
													end
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												while true do
													loc_12 = load_i32(memory_at_0.data, loc_0 + 232)
													loc_13 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 236)), loc_12), 2)
													loc_14 = load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 272)), 4294967280))
													if loc_13 <= loc_14 then
														break
													end
													loc_9 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 56)), 4294967295)
													loc_15 = load_i32(memory_at_0.data, add_i32(loc_0, 64))
													loc_16 = load_i32(memory_at_0.data, add_i32(loc_0, 60))
													loc_17 = load_i32(memory_at_0.data, loc_0 + 52)
													loc_18 = 1
													while true do
														loc_5 = 0
														while true do
															if loc_16 == 0 then
																break
															end
															loc_5 = 0
															loc_4 = load_i32(memory_at_0.data, add_i32(loc_12, shl_i32(loc_14, 2)))
															if loc_4 == loc_15 then
																break
															end
															loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
															loc_8 = 0
															while true do
																loc_7 = band_i32(loc_6, loc_9)
																loc_5 = add_i32(loc_17, mul_i32(loc_7, 12))
																loc_6 = load_i32(memory_at_0.data, loc_5)
																if loc_6 == loc_4 then
																	desired = 13
																	break
																end
																loc_5 = 0
																if loc_6 == loc_15 then
																	desired = 13
																	break
																end
																loc_8 = add_i32(loc_8, 1)
																loc_6 = add_i32(loc_8, loc_7)
																if loc_8 <= loc_9 then
																	continue
																end
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
																continue
															end
															break
														end
														while true do
															if load_i32_u8(memory_at_0.data, (if loc_5 ~= 0 then add_i32(loc_5, 4) else 0) + 2) ~= 0 then
																break
															end
															loc_14 = add_i32(loc_14, 1)
															loc_18 = (if loc_14 < loc_13 then 1 else 0)
															if loc_14 ~= loc_13 then
																desired = 12
																break
															end
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
																continue
															end
															break
														end
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if band_i32(loc_18, 1) ~= 0 then
														desired = 10
														break
													end
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32(memory_at_0.data, loc_2 + 24, 0)
												store_i64(memory_at_0.data, loc_2 + 16, i64_ZERO)
												FUNC_LIST[360](loc_0, loc_3, 0, add_i32(loc_2, 16), 1)
												loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
												loc_15 = load_i32(memory_at_0.data, loc_2 + 20)
												if loc_8 == loc_15 then
													desired = 2
													break
												end
												loc_14 = add_i32(loc_0, 256)
												while true do
													loc_9 = load_i32(memory_at_0.data, loc_8)
													while true do
														while true do
															loc_5 = load_i32(memory_at_0.data, loc_0 + 260)
															loc_7 = load_i32(memory_at_0.data, loc_0 + 264)
															if loc_5 >= loc_7 then
																break
															end
															store_i64(memory_at_0.data, loc_5, shl_i64(extend_i64_u32(loc_9), i64_from_u32(32, 0)))
															store_i32(memory_at_0.data, loc_0 + 260, add_i32(loc_5, 8))
															desired = 12
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														loc_6 = load_i32(memory_at_0.data, loc_14)
														loc_4 = sub_i32(loc_5, loc_6)
														loc_3 = shr_i32(loc_4, 3)
														loc_5 = add_i32(loc_3, 1)
														if loc_5 >= 536870912 then
															desired = 9
															break
														end
														while true do
															while true do
																loc_7 = sub_i32(loc_7, loc_6)
																loc_17 = shr_i32(loc_7, 2)
																loc_7 = (if loc_7 < 2147483640 then (if loc_17 < loc_5 then loc_5 else loc_17) else 536870911)
																if loc_7 ~= 0 then
																	break
																end
																loc_5 = 0
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															if loc_7 >= 536870912 then
																desired = 8
																break
															end
															reg_0 = FUNC_LIST[1461](shl_i32(loc_7, 3))
															loc_5 = reg_0
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														loc_3 = add_i32(loc_5, shl_i32(loc_3, 3))
														store_i64(memory_at_0.data, loc_3, shl_i64(extend_i64_u32(loc_9), i64_from_u32(32, 0)))
														loc_9 = add_i32(loc_5, shl_i32(loc_7, 3))
														loc_7 = add_i32(loc_3, 8)
														while true do
															if lt_i32(loc_4, 1) then
																break
															end
															reg_0 = FUNC_LIST[1224](loc_5, loc_6, loc_4)
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														store_i32(memory_at_0.data, loc_0 + 264, loc_9)
														store_i32(memory_at_0.data, loc_0 + 260, loc_7)
														store_i32(memory_at_0.data, loc_0 + 256, loc_5)
														if loc_6 == 0 then
															break
														end
														FUNC_LIST[1463](loc_6)
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
															continue
														end
														break
													end
													loc_8 = add_i32(loc_8, 4)
													if loc_8 == loc_15 then
														desired = 3
														break
													end
													continue
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												error("out of code bounds")
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											while true do
												if load_i32(memory_at_0.data, add_i32(loc_11, 32)) ~= 1 then
													break
												end
												if loc_10 ~= 0 then
													break
												end
												loc_8 = load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_11 + 28))
												loc_12 = (if load_i32(memory_at_0.data, loc_8 + 4) == load_i32(memory_at_0.data, 0 + 60032) then loc_8 else 0)
												if loc_12 == 0 then
													break
												end
												while true do
													loc_18 = load_i32(memory_at_0.data, loc_0 + 232)
													loc_11 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 236)), loc_18), 2)
													loc_16 = load_i32(memory_at_0.data, add_i32(loc_0, 272))
													loc_14 = load_i32(memory_at_0.data, add_i32(loc_16, 4294967284))
													if loc_11 <= loc_14 then
														break
													end
													loc_9 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 56)), 4294967295)
													loc_15 = load_i32(memory_at_0.data, add_i32(loc_0, 64))
													loc_10 = load_i32(memory_at_0.data, add_i32(loc_0, 60))
													loc_17 = load_i32(memory_at_0.data, loc_0 + 52)
													loc_13 = 1
													while true do
														loc_5 = 0
														while true do
															if loc_10 == 0 then
																break
															end
															loc_5 = 0
															loc_4 = load_i32(memory_at_0.data, add_i32(loc_18, shl_i32(loc_14, 2)))
															if loc_4 == loc_15 then
																break
															end
															loc_6 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
															loc_8 = 0
															while true do
																loc_7 = band_i32(loc_6, loc_9)
																loc_5 = add_i32(loc_17, mul_i32(loc_7, 12))
																loc_6 = load_i32(memory_at_0.data, loc_5)
																if loc_6 == loc_4 then
																	desired = 13
																	break
																end
																loc_5 = 0
																if loc_6 == loc_15 then
																	desired = 13
																	break
																end
																loc_8 = add_i32(loc_8, 1)
																loc_6 = add_i32(loc_8, loc_7)
																if loc_8 <= loc_9 then
																	continue
																end
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
																continue
															end
															break
														end
														while true do
															if load_i32_u8(memory_at_0.data, (if loc_5 ~= 0 then add_i32(loc_5, 4) else 0) + 2) ~= 0 then
																break
															end
															loc_14 = add_i32(loc_14, 1)
															loc_13 = (if loc_14 < loc_11 then 1 else 0)
															if loc_14 ~= loc_11 then
																desired = 12
																break
															end
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
																continue
															end
															break
														end
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													if band_i32(loc_13, 1) ~= 0 then
														desired = 10
														break
													end
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												while true do
													while true do
														if load_i32_u8(memory_at_0.data, 0 + 60336) == 0 then
															break
														end
														loc_8 = add_i32(loc_16, 4294967292)
														if load_i32(memory_at_0.data, loc_8) ~= 0 then
															desired = 11
															break
														end
														store_i32(memory_at_0.data, loc_8, loc_12)
														desired = 11
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_8 = load_i32(memory_at_0.data, add_i32(loc_16, 4294967288))
													if loc_8 == 0 then
														break
													end
													store_i64(memory_at_0.data, add_i32(loc_2, 32), i64_ZERO)
													store_i32(memory_at_0.data, add_i32(loc_2, 40), 0)
													store_i64(memory_at_0.data, loc_2 + 24, i64_ZERO)
													store_i32(memory_at_0.data, loc_2 + 20, loc_0)
													loc_5 = add_i32(15996, 8)
													store_i32(memory_at_0.data, loc_2 + 16, loc_5)
													TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_8))](loc_8, add_i32(loc_2, 16))
													loc_6 = load_i32(memory_at_0.data, loc_2 + 24)
													if loc_6 ~= 0 then
														desired = 7
														break
													end
													store_i32(memory_at_0.data, loc_2 + 16, loc_5)
													while true do
														loc_8 = load_i32(memory_at_0.data, loc_2 + 28)
														if loc_8 == 0 then
															break
														end
														FUNC_LIST[1463](loc_8)
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													loc_3 = load_i32(memory_at_0.data, loc_1 + 28)
													break
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												store_i32(memory_at_0.data, loc_2 + 24, 0)
												store_i64(memory_at_0.data, loc_2 + 16, i64_ZERO)
												FUNC_LIST[360](loc_0, loc_3, 0, add_i32(loc_2, 16), 1)
												loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
												loc_15 = load_i32(memory_at_0.data, loc_2 + 20)
												if loc_8 == loc_15 then
													desired = 4
													break
												end
												loc_14 = add_i32(loc_0, 256)
												while true do
													loc_9 = load_i32(memory_at_0.data, loc_8)
													while true do
														while true do
															loc_5 = load_i32(memory_at_0.data, loc_0 + 260)
															loc_7 = load_i32(memory_at_0.data, loc_0 + 264)
															if loc_5 >= loc_7 then
																break
															end
															store_i64(memory_at_0.data, loc_5, bor_i64(shl_i64(extend_i64_u32(loc_9), i64_from_u32(32, 0)), i64_ONE))
															store_i32(memory_at_0.data, loc_0 + 260, add_i32(loc_5, 8))
															desired = 12
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														loc_6 = load_i32(memory_at_0.data, loc_14)
														loc_4 = sub_i32(loc_5, loc_6)
														loc_3 = shr_i32(loc_4, 3)
														loc_5 = add_i32(loc_3, 1)
														if loc_5 >= 536870912 then
															desired = 6
															break
														end
														while true do
															while true do
																loc_7 = sub_i32(loc_7, loc_6)
																loc_17 = shr_i32(loc_7, 2)
																loc_7 = (if loc_7 < 2147483640 then (if loc_17 < loc_5 then loc_5 else loc_17) else 536870911)
																if loc_7 ~= 0 then
																	break
																end
																loc_5 = 0
																desired = 13
																break
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															if loc_7 >= 536870912 then
																desired = 8
																break
															end
															reg_0 = FUNC_LIST[1461](shl_i32(loc_7, 3))
															loc_5 = reg_0
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														loc_3 = add_i32(loc_5, shl_i32(loc_3, 3))
														store_i64(memory_at_0.data, loc_3, bor_i64(shl_i64(extend_i64_u32(loc_9), i64_from_u32(32, 0)), i64_ONE))
														loc_9 = add_i32(loc_5, shl_i32(loc_7, 3))
														loc_7 = add_i32(loc_3, 8)
														while true do
															if lt_i32(loc_4, 1) then
																break
															end
															reg_0 = FUNC_LIST[1224](loc_5, loc_6, loc_4)
															break
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														store_i32(memory_at_0.data, loc_0 + 264, loc_9)
														store_i32(memory_at_0.data, loc_0 + 260, loc_7)
														store_i32(memory_at_0.data, loc_0 + 256, loc_5)
														if loc_6 == 0 then
															break
														end
														FUNC_LIST[1463](loc_6)
														break
													end
													if desired then
														if desired == 11 then
															desired = nil
															continue
														end
														break
													end
													loc_8 = add_i32(loc_8, 4)
													if loc_8 == loc_15 then
														desired = 5
														break
													end
													continue
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												error("out of code bounds")
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											store_i32(memory_at_0.data, loc_2 + 24, 0)
											store_i64(memory_at_0.data, loc_2 + 16, i64_ZERO)
											FUNC_LIST[360](loc_0, loc_3, 0, add_i32(loc_2, 16), 0)
											FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, loc_1 + 32))
											while true do
												while true do
													while true do
														if load_i32(memory_at_0.data, loc_1 + 36) == 0 then
															break
														end
														if load_i32(memory_at_0.data, loc_2 + 20) == load_i32(memory_at_0.data, loc_2 + 16) then
															break
														end
														reg_0 = FUNC_LIST[264](loc_0, load_i32(memory_at_0.data, loc_1 + 32))
														loc_8 = reg_0
														reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
														loc_5 = reg_0
														while true do
															if loc_8 == 0 then
																break
															end
															FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, loc_1 + 36))
															loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
															loc_6 = load_i32(memory_at_0.data, loc_2 + 20)
															if loc_8 == loc_6 then
																desired = 10
																break
															end
															while true do
																while true do
																	reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), load_i32(memory_at_0.data, loc_8), loc_5)
																	if reg_0 == 0 then
																		desired = 14
																		break
																	end
																	loc_8 = add_i32(loc_8, 4)
																	if loc_8 == loc_6 then
																		desired = 11
																		break
																	end
																	continue
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																error("out of code bounds")
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
															error("out of code bounds")
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														FUNC_LIST[146](load_i32(memory_at_0.data, loc_0), 23, 0, 0)
														reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
														loc_6 = reg_0
														FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, loc_1 + 36))
														reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
														loc_7 = reg_0
														while true do
															loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
															loc_9 = load_i32(memory_at_0.data, loc_2 + 20)
															if loc_8 == loc_9 then
																break
															end
															while true do
																while true do
																	reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), load_i32(memory_at_0.data, loc_8), loc_6)
																	if reg_0 == 0 then
																		desired = 14
																		break
																	end
																	loc_8 = add_i32(loc_8, 4)
																	if loc_8 == loc_9 then
																		desired = 13
																		break
																	end
																	continue
																end
																if desired then
																	if desired == 14 then
																		desired = nil
																	end
																	break
																end
																error("out of code bounds")
															end
															if desired then
																if desired == 13 then
																	desired = nil
																end
																break
															end
															FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
															error("out of code bounds")
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), loc_5, loc_7)
														if reg_0 ~= 0 then
															desired = 11
															break
														end
														FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
														error("out of code bounds")
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
													loc_5 = reg_0
													loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
													loc_6 = load_i32(memory_at_0.data, loc_2 + 20)
													if loc_8 == loc_6 then
														desired = 10
														break
													end
													while true do
														while true do
															reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), load_i32(memory_at_0.data, loc_8), loc_5)
															if reg_0 == 0 then
																desired = 12
																break
															end
															loc_8 = add_i32(loc_8, 4)
															if loc_8 == loc_6 then
																desired = 11
																break
															end
															continue
														end
														if desired then
															if desired == 12 then
																desired = nil
															end
															break
														end
														error("out of code bounds")
													end
													if desired then
														if desired == 11 then
															desired = nil
														end
														break
													end
													FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
													error("out of code bounds")
												end
												if desired then
													if desired == 10 then
														desired = nil
													end
													break
												end
												loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
												break
											end
											if desired then
												if desired == 9 then
													desired = nil
												end
												break
											end
											if loc_8 == 0 then
												desired = 1
												break
											end
											store_i32(memory_at_0.data, loc_2 + 20, loc_8)
											FUNC_LIST[1463](loc_8)
											desired = 1
											break
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										FUNC_LIST[356](loc_14)
										error("out of code bounds")
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									FUNC_LIST[276]()
									error("out of code bounds")
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_0 = load_i32(memory_at_0.data, loc_12 + 8)
								store_i32(memory_at_0.data, loc_2, load_i32(memory_at_0.data, loc_6))
								store_i32(memory_at_0.data, loc_2 + 4, add_i32(loc_0, 1))
								FUNC_LIST[257](add_i32(loc_8, 8), 2115, loc_2)
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							FUNC_LIST[356](loc_14)
							error("out of code bounds")
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_8 == 0 then
						desired = 1
						break
					end
					store_i32(memory_at_0.data, loc_2 + 20, loc_8)
					FUNC_LIST[1463](loc_8)
					desired = 1
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_8 = load_i32(memory_at_0.data, loc_2 + 16)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_8 == 0 then
				break
			end
			store_i32(memory_at_0.data, loc_2 + 20, loc_8)
			FUNC_LIST[1463](loc_8)
			break
		end
		GLOBAL_LIST[0].value = add_i32(loc_2, 48)
		break
	end
end
FUNC_LIST[341] = --[[ Luau::Compiler::compileStatWhile(Luau::AstStatWhile*) ]] function(loc_0, loc_1)
	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_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		while true do
			while true do
				while true do
					while true do
						while true do
							if load_i32(memory_at_0.data, add_i32(loc_0, 120)) == 0 then
								break
							end
							loc_3 = load_i32(memory_at_0.data, add_i32(loc_0, 124))
							loc_4 = load_i32(memory_at_0.data, loc_1 + 28)
							if loc_3 == loc_4 then
								break
							end
							loc_5 = bxor_i32(shr_u32(loc_4, 4), shr_u32(loc_4, 9))
							loc_6 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 116)), 4294967295)
							loc_7 = load_i32(memory_at_0.data, loc_0 + 112)
							loc_8 = 0
							while true do
								while true do
									loc_5 = band_i32(loc_5, loc_6)
									loc_9 = load_i32(memory_at_0.data, add_i32(loc_7, mul_i32(loc_5, 24)))
									if loc_9 == loc_4 then
										desired = 6
										break
									end
									if loc_9 == loc_3 then
										desired = 5
										break
									end
									loc_8 = add_i32(loc_8, 1)
									loc_5 = add_i32(loc_8, loc_5)
									if loc_8 <= loc_6 then
										continue
									end
									desired = 5
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							while true do
								loc_8 = add_i32(loc_7, mul_i32(loc_5, 24))
								if not br_map[1] then
									br_map[1] = (function()
										return { [0] = 2, 0, }
									end)()
								end
								temp = br_map[1][add_i32(load_i32(memory_at_0.data, loc_8 + 8), 4294967295)] 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.data, add_i32(loc_8, 16)) == 0 then
								desired = 4
								break
							end
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_5 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 236)), load_i32(memory_at_0.data, loc_0 + 232)), 2)
						loc_9 = load_i32(memory_at_0.data, add_i32(loc_0, 260))
						loc_4 = load_i32(memory_at_0.data, loc_0 + 256)
						while true do
							while true do
								loc_8 = load_i32(memory_at_0.data, add_i32(loc_0, 272))
								loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 276))
								if loc_8 >= loc_7 then
									break
								end
								store_i64(memory_at_0.data, loc_8 + 8, i64_ZERO)
								store_i32(memory_at_0.data, loc_8 + 4, loc_5)
								store_i32(memory_at_0.data, loc_8, loc_5)
								store_i32(memory_at_0.data, loc_0 + 272, add_i32(loc_8, 16))
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_10 = add_i32(loc_0, 268)
							loc_6 = load_i32(memory_at_0.data, loc_10)
							loc_3 = sub_i32(loc_8, loc_6)
							loc_11 = shr_i32(loc_3, 4)
							loc_8 = add_i32(loc_11, 1)
							if loc_8 >= 268435456 then
								desired = 3
								break
							end
							loc_7 = sub_i32(loc_7, loc_6)
							loc_10 = shr_i32(loc_7, 3)
							loc_8 = (if loc_7 < 2147483632 then (if loc_10 < loc_8 then loc_8 else loc_10) else 268435455)
							if loc_8 >= 268435456 then
								desired = 2
								break
							end
							loc_10 = shl_i32(loc_8, 4)
							reg_0 = FUNC_LIST[1461](loc_10)
							loc_7 = reg_0
							loc_8 = add_i32(loc_7, shl_i32(loc_11, 4))
							store_i64(memory_at_0.data, loc_8 + 8, i64_ZERO)
							store_i32(memory_at_0.data, loc_8 + 4, loc_5)
							store_i32(memory_at_0.data, loc_8, loc_5)
							loc_5 = add_i32(loc_7, loc_10)
							loc_8 = add_i32(loc_8, 16)
							while true do
								if lt_i32(loc_3, 1) then
									break
								end
								reg_0 = FUNC_LIST[1224](loc_7, loc_6, loc_3)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32(memory_at_0.data, loc_0 + 276, loc_5)
							store_i32(memory_at_0.data, loc_0 + 272, loc_8)
							store_i32(memory_at_0.data, loc_0 + 268, loc_7)
							if loc_6 == 0 then
								break
							end
							FUNC_LIST[1463](loc_6)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32_n8(memory_at_0.data, loc_0 + 228, 1)
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_8 = reg_0
						store_i32(memory_at_0.data, loc_2 + 8, 0)
						store_i64(memory_at_0.data, loc_2, i64_ZERO)
						FUNC_LIST[360](loc_0, load_i32(memory_at_0.data, loc_1 + 28), 0, loc_2, 0)
						FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, loc_1 + 32))
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_7 = reg_0
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_6 = reg_0
						while true do
							if lt_i32(load_i32(memory_at_0.data, add_i32(loc_0, 8)), 1) then
								break
							end
							FUNC_LIST[155](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1 + 28) + 8), 1))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						FUNC_LIST[146](load_i32(memory_at_0.data, loc_0), 24, 0, 0)
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_5 = reg_0
						reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), loc_6, loc_8)
						if reg_0 == 0 then
							desired = 1
							break
						end
						while true do
							loc_8 = load_i32(memory_at_0.data, loc_2)
							loc_6 = load_i32(memory_at_0.data, loc_2 + 4)
							if loc_8 == loc_6 then
								break
							end
							while true do
								while true do
									reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), load_i32(memory_at_0.data, loc_8), loc_5)
									if reg_0 == 0 then
										desired = 6
										break
									end
									loc_8 = add_i32(loc_8, 4)
									if loc_8 == loc_6 then
										desired = 5
										break
									end
									continue
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								error("out of code bounds")
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
							error("out of code bounds")
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						loc_8 = shr_i32(sub_i32(loc_9, loc_4), 3)
						FUNC_LIST[361](loc_0, loc_1, loc_8, loc_5, loc_7)
						while true do
							while true do
								loc_6 = load_i32(memory_at_0.data, loc_0 + 256)
								loc_5 = shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 260), loc_6), 3)
								if loc_8 <= loc_5 then
									break
								end
								FUNC_LIST[362](add_i32(loc_0, 256), sub_i32(loc_8, loc_5))
								desired = 5
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_8 >= loc_5 then
								break
							end
							store_i32(memory_at_0.data, loc_0 + 260, add_i32(loc_6, shl_i32(loc_8, 3)))
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_0 + 272, add_i32(load_i32(memory_at_0.data, loc_0 + 272), 4294967280))
						loc_8 = load_i32(memory_at_0.data, loc_2)
						if loc_8 == 0 then
							break
						end
						store_i32(memory_at_0.data, loc_2 + 4, loc_8)
						FUNC_LIST[1463](loc_8)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					GLOBAL_LIST[0].value = add_i32(loc_2, 16)
					desired = 0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[363](loc_10)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[276]()
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
		error("out of code bounds")
	end
end
FUNC_LIST[342] = --[[ Luau::Compiler::compileStatRepeat(Luau::AstStatRepeat*) ]] function(loc_0, loc_1)
	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
	local br_map = {}
	while true do
		loc_2 = sub_i32(GLOBAL_LIST[0].value, 16)
		GLOBAL_LIST[0].value = loc_2
		loc_3 = shr_i32(sub_i32(load_i32(memory_at_0.data, add_i32(loc_0, 236)), load_i32(memory_at_0.data, loc_0 + 232)), 2)
		loc_4 = load_i32(memory_at_0.data, add_i32(loc_0, 260))
		loc_5 = load_i32(memory_at_0.data, loc_0 + 256)
		loc_6 = load_i32(memory_at_0.data, loc_1 + 28)
		while true do
			while true do
				while true do
					while true do
						while true do
							while true do
								while true do
									loc_7 = load_i32(memory_at_0.data, add_i32(loc_0, 272))
									loc_8 = load_i32(memory_at_0.data, add_i32(loc_0, 276))
									if loc_7 >= loc_8 then
										break
									end
									store_i32(memory_at_0.data, loc_7 + 12, 0)
									store_i32(memory_at_0.data, loc_7 + 8, loc_6)
									store_i32(memory_at_0.data, loc_7 + 4, loc_3)
									store_i32(memory_at_0.data, loc_7, loc_3)
									store_i32(memory_at_0.data, loc_0 + 272, add_i32(loc_7, 16))
									desired = 6
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_9 = add_i32(loc_0, 268)
								loc_10 = load_i32(memory_at_0.data, loc_9)
								loc_11 = sub_i32(loc_7, loc_10)
								loc_12 = shr_i32(loc_11, 4)
								loc_7 = add_i32(loc_12, 1)
								if loc_7 >= 268435456 then
									desired = 5
									break
								end
								loc_8 = sub_i32(loc_8, loc_10)
								loc_9 = shr_i32(loc_8, 3)
								loc_7 = (if loc_8 < 2147483632 then (if loc_9 < loc_7 then loc_7 else loc_9) else 268435455)
								if loc_7 >= 268435456 then
									desired = 4
									break
								end
								loc_9 = shl_i32(loc_7, 4)
								reg_0 = FUNC_LIST[1461](loc_9)
								loc_8 = reg_0
								loc_7 = add_i32(loc_8, shl_i32(loc_12, 4))
								store_i32(memory_at_0.data, loc_7 + 12, 0)
								store_i32(memory_at_0.data, loc_7 + 8, loc_6)
								store_i32(memory_at_0.data, loc_7 + 4, loc_3)
								store_i32(memory_at_0.data, loc_7, loc_3)
								loc_6 = add_i32(loc_8, loc_9)
								loc_7 = add_i32(loc_7, 16)
								while true do
									if lt_i32(loc_11, 1) then
										break
									end
									reg_0 = FUNC_LIST[1224](loc_8, loc_10, loc_11)
									break
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								store_i32(memory_at_0.data, loc_0 + 276, loc_6)
								store_i32(memory_at_0.data, loc_0 + 272, loc_7)
								store_i32(memory_at_0.data, loc_0 + 268, loc_8)
								if loc_10 == 0 then
									break
								end
								FUNC_LIST[1463](loc_10)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							store_i32_n8(memory_at_0.data, loc_0 + 228, 1)
							reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
							loc_13 = reg_0
							loc_14 = load_i32(memory_at_0.data, loc_0 + 220)
							while true do
								loc_10 = load_i32(memory_at_0.data, loc_1 + 32)
								if load_i32(memory_at_0.data, add_i32(loc_10, 32)) == 0 then
									break
								end
								loc_8 = 0
								loc_7 = 0
								while true do
									FUNC_LIST[263](loc_0, load_i32(memory_at_0.data, add_i32(load_i32(memory_at_0.data, loc_10 + 28), shl_i32(loc_7, 2))))
									loc_6 = load_i32(memory_at_0.data, loc_0 + 272)
									store_i32(memory_at_0.data, add_i32(loc_6, 4294967284), shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 236), load_i32(memory_at_0.data, loc_0 + 232)), 2))
									while true do
										if load_i32_u8(memory_at_0.data, 0 + 60336) == 0 then
											break
										end
										loc_6 = load_i32(memory_at_0.data, add_i32(loc_6, 4294967292))
										if band_i32(bor_i32((if loc_6 == 0 then 1 else 0), loc_8), 1) ~= 0 then
											break
										end
										loc_8 = 1
										FUNC_LIST[364](loc_0, loc_6, load_i32(memory_at_0.data, loc_1 + 28), loc_10, add_i32(loc_7, 1))
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
											continue
										end
										break
									end
									loc_7 = add_i32(loc_7, 1)
									if loc_7 < load_i32(memory_at_0.data, loc_10 + 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
							reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
							loc_15 = reg_0
							while true do
								if lt_i32(load_i32(memory_at_0.data, add_i32(loc_0, 8)), 1) then
									break
								end
								FUNC_LIST[155](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_1 + 28) + 8), 1))
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							loc_11 = load_i32(memory_at_0.data, loc_1 + 28)
							while true do
								if load_i32(memory_at_0.data, add_i32(loc_0, 120)) == 0 then
									break
								end
								loc_9 = load_i32(memory_at_0.data, add_i32(loc_0, 124))
								if loc_9 == loc_11 then
									break
								end
								loc_10 = bxor_i32(shr_u32(loc_11, 4), shr_u32(loc_11, 9))
								loc_6 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 116)), 4294967295)
								loc_12 = load_i32(memory_at_0.data, loc_0 + 112)
								loc_7 = 0
								while true do
									while true do
										loc_10 = band_i32(loc_10, loc_6)
										loc_8 = load_i32(memory_at_0.data, add_i32(loc_12, mul_i32(loc_10, 24)))
										if loc_8 == loc_11 then
											desired = 7
											break
										end
										if loc_8 == loc_9 then
											desired = 6
											break
										end
										loc_7 = add_i32(loc_7, 1)
										loc_10 = add_i32(loc_7, loc_10)
										if loc_7 <= loc_6 then
											continue
										end
										desired = 6
										break
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									error("out of code bounds")
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								while true do
									loc_7 = add_i32(loc_12, mul_i32(loc_10, 24))
									if not br_map[1] then
										br_map[1] = (function()
											return { [0] = 1, 1, 0, }
										end)()
									end
									temp = br_map[1][load_i32(memory_at_0.data, loc_7 + 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.data, add_i32(loc_7, 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.data, loc_2 + 8, 0)
							store_i64(memory_at_0.data, loc_2, i64_ZERO)
							FUNC_LIST[360](loc_0, loc_11, 0, loc_2, 1)
							FUNC_LIST[265](loc_0, loc_3)
							reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
							loc_7 = reg_0
							FUNC_LIST[146](load_i32(memory_at_0.data, loc_0), 24, 0, 0)
							reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
							loc_10 = reg_0
							FUNC_LIST[265](loc_0, loc_3)
							reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
							loc_8 = reg_0
							reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), loc_7, loc_13)
							if reg_0 == 0 then
								desired = 3
								break
							end
							while true do
								loc_7 = load_i32(memory_at_0.data, loc_2)
								loc_6 = load_i32(memory_at_0.data, loc_2 + 4)
								if loc_7 == loc_6 then
									break
								end
								while true do
									while true do
										while true do
											reg_0 = FUNC_LIST[149](load_i32(memory_at_0.data, loc_0), load_i32(memory_at_0.data, loc_7), loc_10)
											if reg_0 == 0 then
												desired = 8
												break
											end
											loc_7 = add_i32(loc_7, 4)
											if loc_7 == loc_6 then
												desired = 7
												break
											end
											continue
										end
										if desired then
											if desired == 8 then
												desired = nil
											end
											break
										end
										error("out of code bounds")
									end
									if desired then
										if desired == 7 then
											desired = nil
										end
										break
									end
									FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
									error("out of code bounds")
								end
								if desired then
									if desired == 6 then
										desired = nil
									end
									break
								end
								loc_7 = load_i32(memory_at_0.data, loc_2)
								break
							end
							if desired then
								if desired == 5 then
									desired = nil
								end
								break
							end
							if loc_7 == 0 then
								desired = 1
								break
							end
							store_i32(memory_at_0.data, loc_2 + 4, loc_7)
							FUNC_LIST[1463](loc_7)
							desired = 1
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						FUNC_LIST[363](loc_9)
						error("out of code bounds")
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[276]()
					error("out of code bounds")
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				FUNC_LIST[257](add_i32(loc_1, 8), 7324, 0)
				error("out of code bounds")
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[265](loc_0, loc_3)
			reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
			loc_8 = reg_0
			break
		end
		FUNC_LIST[267](loc_0, loc_3)
		loc_7 = shr_i32(sub_i32(loc_4, loc_5), 3)
		FUNC_LIST[361](loc_0, loc_1, loc_7, loc_8, loc_15)
		while true do
			while true do
				loc_6 = load_i32(memory_at_0.data, loc_0 + 256)
				loc_10 = shr_i32(sub_i32(load_i32(memory_at_0.data, loc_0 + 260), loc_6), 3)
				if loc_7 <= loc_10 then
					break
				end
				FUNC_LIST[362](add_i32(loc_0, 256), sub_i32(loc_7, loc_10))
				desired = 1
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			if loc_7 >= loc_10 then
				break
			end
			store_i32(memory_at_0.data, loc_0 + 260, add_i32(loc_6, shl_i32(loc_7, 3)))
			break
		end
		store_i32(memory_at_0.data, loc_0 + 220, loc_14)
		store_i32(memory_at_0.data, loc_0 + 272, add_i32(load_i32(memory_at_0.data, loc_0 + 272), 4294967280))
		GLOBAL_LIST[0].value = add_i32(loc_2, 16)
		break
	end
end
FUNC_LIST[343] = --[[ Luau::Compiler::validateContinueUntil(Luau::AstStat*, Luau::AstExpr*) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local desired
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 48)
		GLOBAL_LIST[0].value = loc_3
		store_i64(memory_at_0.data, add_i32(loc_3, 32), i64_ZERO)
		store_i32(memory_at_0.data, add_i32(loc_3, 40), 0)
		store_i64(memory_at_0.data, loc_3 + 24, i64_ZERO)
		store_i32(memory_at_0.data, loc_3 + 20, loc_0)
		loc_0 = add_i32(15996, 8)
		store_i32(memory_at_0.data, loc_3 + 16, loc_0)
		TABLE_LIST[0].data[load_i32(memory_at_0.data, load_i32(memory_at_0.data, loc_2))](loc_2, add_i32(loc_3, 16))
		while true do
			loc_4 = load_i32(memory_at_0.data, loc_3 + 24)
			if loc_4 ~= 0 then
				break
			end
			store_i32(memory_at_0.data, loc_3 + 16, loc_0)
			while true do
				loc_2 = load_i32(memory_at_0.data, loc_3 + 28)
				if loc_2 == 0 then
					break
				end
				FUNC_LIST[1463](loc_2)
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			GLOBAL_LIST[0].value = add_i32(loc_3, 48)
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_0 = load_i32(memory_at_0.data, loc_1 + 8)
		store_i32(memory_at_0.data, loc_3, load_i32(memory_at_0.data, loc_4))
		store_i32(memory_at_0.data, loc_3 + 4, add_i32(loc_0, 1))
		FUNC_LIST[257](add_i32(loc_2, 8), 2115, loc_3)
		error("out of code bounds")
	end
end
FUNC_LIST[344] = --[[ std::__2::vector<Luau::Compiler::LoopJump, std::__2::allocator<Luau::Compiler::LoopJump> >::push_back(Luau::Compiler::LoopJump&&) ]] function(loc_0, loc_1)
	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
			loc_2 = load_i32(memory_at_0.data, loc_0 + 4)
			loc_3 = load_i32(memory_at_0.data, loc_0 + 8)
			if loc_2 >= loc_3 then
				break
			end
			store_i64(memory_at_0.data, loc_2, load_i64(memory_at_0.data, loc_1))
			store_i32(memory_at_0.data, loc_0 + 4, add_i32(loc_2, 8))
			desired = 0
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		while true do
			while true do
				loc_4 = load_i32(memory_at_0.data, loc_0)
				loc_5 = sub_i32(loc_2, loc_4)
				loc_6 = shr_i32(loc_5, 3)
				loc_2 = add_i32(loc_6, 1)
				if loc_2 >= 536870912 then
					break
				end
				while true do
					while true do
						loc_3 = sub_i32(loc_3, loc_4)
						loc_7 = shr_i32(loc_3, 2)
						loc_3 = (if loc_3 < 2147483640 then (if loc_7 < loc_2 then loc_2 else loc_7) else 536870911)
						if loc_3 ~= 0 then
							break
						end
						loc_2 = 0
						desired = 3
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					if loc_3 >= 536870912 then
						desired = 1
						break
					end
					reg_0 = FUNC_LIST[1461](shl_i32(loc_3, 3))
					loc_2 = reg_0
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				loc_6 = add_i32(loc_2, shl_i32(loc_6, 3))
				store_i64(memory_at_0.data, loc_6, load_i64(memory_at_0.data, loc_1))
				loc_1 = add_i32(loc_2, shl_i32(loc_3, 3))
				loc_3 = add_i32(loc_6, 8)
				while true do
					if lt_i32(loc_5, 1) then
						break
					end
					reg_0 = FUNC_LIST[1224](loc_2, loc_4, loc_5)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				store_i32(memory_at_0.data, loc_0 + 8, loc_1)
				store_i32(memory_at_0.data, loc_0 + 4, loc_3)
				store_i32(memory_at_0.data, loc_0, loc_2)
				while true do
					if loc_4 == 0 then
						break
					end
					FUNC_LIST[1463](loc_4)
					break
				end
				if desired then
					if desired == 2 then
						desired = nil
					end
					break
				end
				desired = 0
				break
			end
			if desired then
				if desired == 1 then
					desired = nil
				end
				break
			end
			FUNC_LIST[356](loc_0)
			error("out of code bounds")
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		FUNC_LIST[276]()
		error("out of code bounds")
	end
end
FUNC_LIST[345] = --[[ Luau::Compiler::compileInlineReturn(Luau::AstStatReturn*, bool) ]] function(loc_0, loc_1, loc_2)
	local loc_3 = 0
	local loc_4 = 0
	local loc_5 = i64_ZERO
	local loc_6 = 0
	local loc_7 = 0
	local loc_8 = 0
	local loc_9 = 0
	local loc_10 = 0
	local reg_0
	local reg_1
	local desired
	while true do
		loc_3 = sub_i32(GLOBAL_LIST[0].value, 32)
		GLOBAL_LIST[0].value = loc_3
		while true do
			if lt_i32(load_i32(memory_at_0.data, add_i32(loc_0, 8)), 1) then
				break
			end
			FUNC_LIST[155](load_i32(memory_at_0.data, loc_0), add_i32(load_i32(memory_at_0.data, loc_1 + 8), 1))
			break
		end
		if desired then
			if desired == 0 then
				desired = nil
			end
			break
		end
		loc_4 = add_i32(load_i32(memory_at_0.data, add_i32(loc_0, 284)), 4294967272)
		loc_5 = load_i64(memory_at_0.data, loc_4)
		loc_6 = load_i32_u16(memory_at_0.data, add_i32(loc_4, 8))
		store_i32(memory_at_0.data, add_i32(loc_3, 28), 0)
		store_i32_n16(memory_at_0.data, add_i32(add_i32(loc_3, 8), 8), loc_6)
		store_i64(memory_at_0.data, loc_3 + 8, loc_5)
		store_i64(memory_at_0.data, loc_3 + 20, i64_ZERO)
		while true do
			while true do
				while true do
					while true do
						loc_7 = add_i32(loc_4, 16)
						loc_6 = sub_i32(load_i32(memory_at_0.data, loc_7), load_i32(memory_at_0.data, loc_4 + 12))
						if loc_6 == 0 then
							break
						end
						if le_i32(loc_6, 4294967295) then
							desired = 3
							break
						end
						reg_1 = FUNC_LIST[1461](loc_6)
						loc_8 = reg_1
						store_i32(memory_at_0.data, loc_3 + 20, loc_8)
						store_i32(memory_at_0.data, loc_3 + 28, add_i32(loc_8, shl_i32(shr_i32(loc_6, 2), 2)))
						while true do
							loc_6 = load_i32(memory_at_0.data, add_i32(loc_4, 12))
							loc_4 = sub_i32(load_i32(memory_at_0.data, loc_7), loc_6)
							if lt_i32(loc_4, 1) then
								break
							end
							reg_0 = FUNC_LIST[1224](loc_8, loc_6, loc_4)
							loc_8 = add_i32(reg_0, loc_4)
							break
						end
						if desired then
							if desired == 4 then
								desired = nil
							end
							break
						end
						store_i32(memory_at_0.data, loc_3 + 24, loc_8)
						break
					end
					if desired then
						if desired == 3 then
							desired = nil
						end
						break
					end
					FUNC_LIST[365](loc_0, add_i32(loc_1, 28), load_i32_u8(memory_at_0.data, loc_3 + 16), load_i32_u8(memory_at_0.data, loc_3 + 17), 0)
					FUNC_LIST[265](loc_0, load_i32(memory_at_0.data, loc_3 + 12))
					while true do
						if loc_2 ~= 0 then
							break
						end
						reg_0 = FUNC_LIST[148](load_i32(memory_at_0.data, loc_0))
						loc_6 = reg_0
						FUNC_LIST[146](load_i32(memory_at_0.data, loc_0), 23, 0, 0)
						while true do
							loc_4 = load_i32(memory_at_0.data, loc_0 + 284)
							loc_8 = add_i32(loc_4, 4294967288)
							loc_0 = load_i32(memory_at_0.data, loc_8)
							loc_1 = add_i32(loc_4, 4294967292)
							if loc_0 == load_i32(memory_at_0.data, loc_1) then