-- ModuleScript Util (via bytefall decompiler)
-- Decompiled using ByteFall
-- discord.gg/pHTnqmmWzk
local tweenService: TweenService = game:GetService("TweenService")
local runService: RunService = game:GetService("RunService")
local collectionService: CollectionService = game:GetService("CollectionService")
local textService: TextService = game:GetService("TextService")
local starterGui: StarterGui = game:GetService("StarterGui")
local logService: LogService = game:GetService("LogService")
local cancellingFunction = require(script.CancellingFunction)
local debouncingFunction = require(script.DebouncingFunction)
local bufferingFunction = require(script.BufferingFunction)
local cachingFunction = require(script.CachingFunction)

if runService:IsClient() then
	player = game.Players.LocalPlayer
	starterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false)
	starterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Health, false)
	starterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false)
end

local module: {[any]: any} = {
	spritesheet_image = function(p1, image, list, list2, p5, p6)
		local u26 = p6 or 8
		local v27 = list[1]
		local n1 = list2[1] / v27
		local n2 = list2[2] / list[2]
		local n3 = 0

		p1.Image = image

		local v31 = task.spawn(function()
			while p1.Parent do
				local n4 = n3 % v27
				local floored = math.floor(n3 / v27)

				p1.ImageRectSize = Vector2.new(n1, n2)
				p1.ImageRectOffset = Vector2.new(n4 * n1, floored * n2)
				n3 = (n3 + 1) % p5
				task.wait(1 / u26)
			end
		end)

		return {
			unhook = function()
				task.cancel(v31)
				p1.ImageRectSize = Vector2.zero
				p1.ImageRectOffset = Vector2.zero
			end
		}
	end,
	shuffle_table = function(p7)
		for i = #p7, 2, -1 do
			local randomNumber = math.random(i)
			local v35 = p7[i]

			p7[i] = p7[randomNumber]
			p7[randomNumber] = v35
		end

		return p7
	end,
	closest_point_on_segment = function(p8, p9, p10)
		local n1 = p10 - p9
		local v40 = n1:Dot(n1)

		if v40 == 0 then
			return p9
		end

		local v41 = (p8 - p9):Dot(n1)
		local v42 = math.min(1, v41 / v40)

		v41 = math.max(0, v42)

		return p9 + n1 * v41
	end,
	get_point_to_part_info = function(p11, p12)
		local cFrame = p12.CFrame
		local v46 = p12.CFrame:PointToObjectSpace(p11)
		local v47 = cFrame:PointToWorldSpace(v46:Clamp(-p12.Size / 2, p12.Size / 2))
		local n1 = p11 - p12.Position
		local absoluteValue = math.abs(n1.X / (p12.Size.X / 2))
		local absoluteValue2 = math.abs(n1.Y / (p12.Size.Y / 2))
		local absoluteValue3 = math.abs(n1.Z / (p12.Size.Z / 2))
		local vector3 = Vector3.new(absoluteValue, absoluteValue2, absoluteValue3)
		local vectorValue = nil
		local n2 = -math.huge

		if n2 < vector3.X then
			vectorValue = Vector3.new(1, 0, 0)
			n2 = vector3.X
		end

		if n2 < vector3.Y then
			vectorValue = Vector3.new(0, 1, 0)
			n2 = vector3.Y
		end

		if n2 < vector3.Z then
			vectorValue = Vector3.new(0, 0, 1)

			local vector3Z = vector3.Z
		end

		local v56 = p12.CFrame
		local vectorValueX = vectorValue.X
		local v58 = math.sign(n1.X)
		local vectorValueY = vectorValue.Y
		local v60 = math.sign(n1.Y)
		local vectorValueZ = vectorValue.Z
		local v62 = math.sign(n1.Z)
		local vector32 = Vector3.new(vectorValueX * v58, vectorValueY * v60, vectorValueZ * v62)

		n2 = v56:VectorToWorldSpace(vector32)

		return v47, n2
	end,
	map_log = function(p13, p14, p15, p16, p17)
		return math.log10((p13 - p14) / (p15 - p14) * 9.5 + 0.5) * (p17 - p16) + p16
	end,
	map_sensitivity = function(p18)
		return math.exp(0.04651687056553628 * (p18 - 1) + 0.023258435282768275) * 0.1
	end,
	clamp_deadzone = function(p19, p20)
		local v72 = p20 or 0.05
		local v73 = p19.X
		local v74 = p19.Y
		local z = p19.Z
		local absoluteValue = math.abs(v73)

		if v72 >= absoluteValue then
			v73 = 0
		end

		local absoluteValue4 = math.abs(v74)

		if v72 >= absoluteValue4 then
			v74 = 0
		end

		local vector3 = Vector3.new(v73, v74, z)

		return vector3
	end,
	warn = function(p21, p22)
		logService:Warn(p21, p22)
	end,
	get_kd = function(p23, p24)
		if p24 == nil or p24 <= 1 then
			local rounded = math.round(p23 or 0)

			return (("%*.0"):format((math.max(1, rounded))))
		end

		return math.floor(p23 / p24 * 10 + 0.5) / 10
	end
}

function module.get_weighted_kd(p25)
	if p25 and #p25 ~= 0 then
		local n1 = 0
		local n2 = 0

		for _, v in ipairs(p25) do
			local v89 = v[1] or 0
			local v90 = v[2] or 0
			local v91 = math.clamp(v[3] or 1, 0, 1)

			if v89 > v90 then
				v89 = math.lerp(v89, v90, 1 - v91)
			elseif v89 < v90 then
				v90 = math.lerp(v90, v89, 1 - v91)
			end

			n1 += v89
			n2 += v90
		end

		return module.get_kd(n1, n2)
	end

	return "1.0"
end
function module.os_time()
	if game.Workspace:GetAttribute("frozen_time") then
		return game.Workspace:GetAttribute("frozen_time")
	end

	if runService:IsClient() then
		local v92: number = workspace:GetServerTimeNow()

		return (math.floor(v92))
	end

	return os.time()
end
function module.apply_offsets(p26, p27)
	local cFrame = CFrame.new(p26.Position)

	for iterFirst, iterSecond in p27 do
		cFrame *= iterSecond
	end

	return cFrame * p26.Rotation
end
function module.get_rank_from_mmr(p28)
	if p28 <= 0 then
		return 0, 0, 1
	end

	local n1: number = 1
	local n2: number = n1 * 100

	while not (p28 < n2) do
		n1 += 1
	end

	if n1 >= 16 then
		return 16, 0, 0
	end

	return n1, (n1 - 1) * 100, n2
end
function module.get_level_from_xp(p29)
	local n1: number = 1
	local n2: number = n1 * 10 * n1

	while not (p29 < n2) do
		n1 += 1
	end

	return n1, (n1 - 1) * 10 * (n1 - 1), n2
end
function module.is_assembly_anchored(p30)
	if p30:IsA("Model") then
		for iterFirst, iterSecond in p30:GetChildren() do
			if iterSecond:IsA("BasePart") and iterSecond.Anchored then
				return true
			end
		end
	elseif p30:IsA("BasePart") then
		for iterFirst2, iterSecond2 in p30:GetConnectedParts() do
			if iterSecond2.Anchored then
				return true
			end
		end
	end

	return false
end
function module.look_at_with_stable_roll(p31, p32, p33, p34)
	local unit = (p32 - p31).unit
	local v114 = unit:Cross(p33).unit
	local v115 = v114:Cross(unit)
	local v116 = CFrame.fromMatrix(p31, v114, v115, -unit)

	if v114:Dot(p34) < -0.99 then
		local v117 = CFrame.Angles(0, 0, 3.141592653589793)

		v116 *= v117
	end

	local v118 = CFrame.Angles(0, 0, 1.5707963267948966)

	return v116 * v118
end
function module.get_xy_offset(p35, p36)
	local n1 = p36.Position - p35.Position
	local v122 = n1:Dot(p35.RightVector)
	local v123 = n1:Dot(p35.UpVector)

	return v122, v123
end
function module.get_closest_point_on_box(p37, p38, p39)
	local v127 = p38:pointToObjectSpace(p37)
	local n1 = p39 * 0.5
	local v129 = math.clamp(v127.X, -n1.X, n1.X)
	local v130 = math.clamp(v127.Y, -n1.Y, n1.Y)
	local v131 = math.clamp(v127.Z, -n1.Z, n1.Z)
	local vector3 = Vector3.new(v129, v130, v131)

	return p38:pointToWorldSpace(vector3)
end
function module.get_closest_point_on_part(p40, p41)
	return p41:GetClosestPointOnSurface(p40)
end
function module.get_point_to_box_distance(p42, p43, p44)
	local v138 = module.get_closest_point_on_box(p42, p43, p44)

	return (p42 - v138).Magnitude
end
function module.get_point_to_part_distance(p45, p46)
	local v141 = module.get_closest_point_on_part(p45, p46)

	return (p45 - v141).Magnitude
end
function module.adjust_reach(p47, p48, p49)
	local n1 = p48 - p47
	local magnitude = n1.Magnitude

	if p49 < magnitude then
		return p47 + n1.Unit * (magnitude - p49)
	end

	local v147: boolean = p49 > magnitude

	return p47
end
function module.ownership(p50, p51)
	local v150 = p51 or player

	if p50 and v150 then
		local userId = p50:GetAttribute("UserId")
		local userId2 = v150:GetAttribute("UserId")

		if userId == userId2 then
			return 3
		end

		if v150:GetAttribute("Spectator") then
			return 2
		end

		if p50:GetAttribute("Team") and p50:GetAttribute("Team") == v150:GetAttribute("Team") then
			return 2
		end

		return 0
	end

	return 1
end
function module.clamp_look_vector(p52, p53, p54)
	local v156 = math.rad(p54)
	local unit = p52.Unit
	local v158 = p53.Unit
	local v159 = unit:Dot(v158)
	local v160 = math.clamp(v159, -1, 1)

	v159 = math.acos(v160)

	if v156 >= v159 then
		return v158
	end

	local v161 = unit:Cross(v158).Unit

	if v161.Magnitude == 0 then
		return unit
	end

	local cosine = math.cos(v156)
	local sine = math.sin(v156)
	local v164 = v161:Cross(unit)
	local v165 = v161:Dot(unit)

	return (unit * cosine + v164 * sine + v161 * (v165 * (1 - cosine))).Unit
end
function module.is_facing_point(p55, p56, p57)
	local v169 = math.rad(p57 or 5)
	local cosine = math.cos(v169)
	local v171 = p55.Position
	local v172 = p55.LookVector:Dot((p56 - v171).Magnitude > 0 and (p56 - v171).Unit or Vector3.new(0, 0, 0))

	return cosine <= v172
end
function module.is_point_inside_plane(p58, p59, p60, p61)
	local v177 = p61 or 0.1
	local v178 = p59:PointToObjectSpace(p58)
	local u179: boolean = false

	if math.abs(v178.X) <= p60.X * 0.5 + v177 then
		u179 = math.abs(v178.Z) <= p60.Z * 0.5 + v177
	end

	return u179
end
function module.is_point_inside_part(p62, p63, p64)
	local v183 = p64 or 0.1

	if p63:IsA("Model") then
		local v184, v185 = p63:GetBoundingBox()
		local v186 = module.get_closest_point_on_box(p62, v184, v185)

		return v183 > (p62 - v186).Magnitude
	end

	local v187 = module.get_closest_point_on_part(p62, p63)

	return v183 > (p62 - v187).Magnitude
end
function module.get_zone_is_in(p65)
	local foundChild: Instance = game.Workspace:FindFirstChild("SoundZones", true)

	if foundChild == nil then
		return
	end

	local v190 = OverlapParams.new()

	v190.MaxParts = 3
	v190.FilterType = Enum.RaycastFilterType.Include
	v190.FilterDescendantsInstances = { foundChild }

	local n1 = math.huge
	local v192 = nil

	for iterFirst, iterSecond in workspace:GetPartBoundsInRadius(p65, 0.1, v190), nil, nil do
		if module.is_point_inside_part(p65, iterSecond, 0.1) then
			local v195 = module.get_point_to_part_distance(p65, iterSecond)

			if n1 > v195 or v195 + n1 < 0.01 and iterSecond.Size.Magnitude < v192.Size.Magnitude then
				n1 = v195
				v192 = iterSecond
			end
		end
	end

	return v192 and v192.Parent
end
function normalize_angle(p66)
	return (p66 + 180) % 360 - 180
end
function module.angles_within_range(p67, p68, p69)
	local v200 = normalize_angle(p67 - p68)
	local absoluteValue = math.abs(v200)

	return p69 >= absoluteValue
end
function module.clampAngle(p70, p71, p72)
	if p70 < p71 then
		return p71
	end

	if p70 > p72 then
		return p72
	end

	return p70
end
function module.clampCFrameRotation(p73, p74, p75)
	local v208, v209, v210 = p74:ToOrientation()
	local v211, v212, v213 = p73:ToOrientation()
	local v214 = module.clampAngle(v211, v208 - p75, v208 + p75)
	local v215 = module.clampAngle(v212, v209 - p75, v209 + p75)
	local v216 = module.clampAngle(v213, v210 - p75, v210 + p75)
	local cFrame = CFrame.new(p73.Position)
	local v218 = CFrame.Angles(v214, v215, v216)

	return cFrame * v218
end
function module.clip_angle(p76, p77, p78, p79)
	local v223 = normalize_angle(p76)
	local v224 = normalize_angle(p77)
	local v225 = normalize_angle(v224 + p78)
	local v226 = normalize_angle(v224 + p79)

	if v225 <= v226 then
		if v223 < v225 then
			return v225
		end

		if v223 > v226 then
			return v226
		end

		return v223
	end

	if v223 >= v225 or v223 <= v226 then
		return v223
	end

	if math.abs(v223 - v225) < math.abs(v223 - v226) then
		return v225
	end

	return v226
end
function module.angle_distance_and_direction(p80, p81)
	local n1 = math.abs(p81 - p80) % 6.283185307179586
	local n2: number = 1

	if p80 > p81 then
		n2 = -1
	end

	if n1 > 3.141592653589793 then
		n1 = 6.283185307179586 - n1
		n2 = -n2
	end

	return n1, n2
end
function module.center_pivot(p82)
	local pivot = p82:GetPivot()

	p82.PrimaryPart = nil

	local v233 = p82:GetBoundingBox()

	p82.WorldPivot = CFrame.new(v233.Position) * pivot.Rotation
	p82:PivotTo(pivot)
end
function module.center_pivot_longitude(p83)
	local pivot = p83:GetPivot()

	p83.PrimaryPart = nil

	local v236 = p83:GetBoundingBox()

	p83.WorldPivot = CFrame.new(v236.Position.X, pivot.Position.Y, v236.Position.Z) * pivot.Rotation
	p83:PivotTo(pivot)
end

local random = Random.new()

function module.rand(p84, p85, p86)
	if typeof(p84) == "number" then
		return p86 and random:NextInteger(p84, p85) or random:NextNumber(p84, p85)
	end

	if typeof(p84) == "Vector3" then
		local v240 = module.rand(p84.X, p85.X, p86)
		local v241 = module.rand(p84.Y, p85.Y, p86)
		local vector3 = Vector3.new(v240, v241, module.rand(p84.Z, p85.Z, p86))

		return vector3
	end
end
function module.weighted_random(p87, p88)
	local n1 = 0

	for iterFirst, iterSecond in p87 do
		n1 += iterSecond
	end

	local n2

	if p88 then
		n2 = p88:NextNumber() * n1
	else
		for _ = 1, 5 do
			math.random()
		end

		n2 = math.random() * n1
	end

	n1 = 0

	for iterFirst2, iterSecond2 in p87 do
		n1 += iterSecond2

		if n2 <= n1 then
			return iterFirst2
		end
	end
end
function module.weld(part0, part1)
	local weld: Weld = Instance.new("Weld", part0)

	weld.Part0 = part0
	weld.Part1 = part1
	part0.Anchored = false

	return weld
end
function module.weld_c(part0, part1)
	local weldConstraint: WeldConstraint = Instance.new("WeldConstraint", part0)

	weldConstraint.Part0 = part0
	weldConstraint.Part1 = part1
	part0.Anchored = false

	return weldConstraint
end
function module.weld_model(p93)
	local primaryPart = p93.PrimaryPart

	if primaryPart == nil then
		warn(p93, "does not have a Primary Part")
	end

	for iterFirst, iterSecond in p93:GetDescendants() do
		if iterSecond:IsA("BasePart") and iterSecond ~= primaryPart and iterSecond.Anchored then
			iterSecond.Anchored = false
			module.weld_c(iterSecond, primaryPart)
		end
	end
end
function module.render(p94, p95)
	local connection = runService.RenderStepped:Connect(function()
		p95()
	end)

	task.wait(p94)
	connection:Disconnect()
end
function module.run_pre(p96)
	local connection = runService.PreSimulation:Connect(function(deltaTimeSim: number)
		p96(deltaTimeSim)
	end)

	return connection
end
function module.run_post(p98)
	local connection = runService.PreRender:Connect(function(deltaTimeRender: number)
		p98(deltaTimeRender)
	end)

	return connection
end
function module.bind_render_step(p100, p101, p102)
	runService:BindToRenderStep(p100, p101, p102)
end
function module.unbind_render_step(p103)
	runService:UnbindFromRenderStep(p103)
end

local t2: {[any]: any} = {}

function module.get_cached(p104)
	if t2[p104] then
		return t2[p104]
	end
end
function module.set_cached(p105, p106)
	if t2[p105] == nil then
		p105.Destroying:Connect(function()
			t2[p105] = nil
		end)
	end

	t2[p105] = p106
end

module.run = module.run_post

function module.clock()
	return workspace:GetServerTimeNow() - 1700000000
end
function module.lerp(p107, p108, p109)
	if typeof(p107) == "number" then
		return p107 + p109 * (p108 - p107)
	end

	return p107:Lerp(p108, p109)
end
function module.cubic_blerp(p110, p111, p112, p113, p114)
	local v284 = module.lerp(p110, p111, p114)
	local v285 = module.lerp(p111, p112, p114)
	local v286 = module.lerp(p112, p113, p114)
	local v287 = module.lerp(v284, v285, p114)
	local v288 = module.lerp(v285, v286, p114)

	return (module.lerp(v287, v288, p114))
end
function module.quad_blerp(p115, p116, p117, p118)
	local v293 = module.lerp(p115, p116, p118)
	local v294 = module.lerp(p116, p117, p118)

	return (module.lerp(v293, v294, p118))
end
function module.ease_in_out_expo(p119)
	if p119 == 0 or p119 == 1 then
		return p119
	end

	if p119 < 0.5 then
		return math.pow(2, p119 * 20 - 10) / 2
	end

	return (2 - math.pow(2, p119 * -20 + 10)) / 2
end

module.db = debouncingFunction.db
module.gdb = debouncingFunction.gdb
module.is_gdb_debounced = debouncingFunction.is_gdb_debounced
module.ov = cancellingFunction.ov
module.bf = bufferingFunction.bf
module.cf = cachingFunction.cf

function module.is_moving_forward_or_backward(p120, p121)
	local v298 = p120:Dot(p121)
	local v299 = math.clamp(v298, -1, 1)
	local v300 = math.acos(v299)
	local v301 = math.deg(v300)

	if v301 <= 60 then
		return 1
	end

	if v301 >= 120 then
		return -1
	end

	return 0
end
function module.move_angle(p122, p123)
	local v304 = p122:Dot(p123)
	local v305 = math.clamp(v304, -1, 1)
	local v306 = math.acos(v305)

	return (math.deg(v306))
end
function module.get_look_vector_angle(p124, p125)
	local unit = p124.Unit
	local v310 = p125.Unit
	local v311 = unit:Dot(v310)
	local v312 = math.atan2(unit.X * v310.Z - unit.Z * v310.X, v311)

	return (math.deg(v312))
end
function module.get_move_components(p126, p127)
	local unit = Vector3.new(-p127.Z, 0, p127.X).Unit
	local v316 = Vector3.new(p127.X, 0, p127.Z).Unit
	local v317 = p126:Dot(unit)
	local v318 = math.clamp(v317, -1, 1)
	local v319 = p126:Dot(v316)

	v317 = math.clamp(v319, -1, 1)

	return v318, v317
end
function module.normal_to_face(p128, p129)
	for _, v in pairs({
		Enum.NormalId.Front,
		Enum.NormalId.Back,
		Enum.NormalId.Bottom,
		Enum.NormalId.Top,
		Enum.NormalId.Left,
		Enum.NormalId.Right
	}) do
		if GetNormalFromFace(p129, v):Dot(p128) > 0.999 then
			return v
		end
	end

	return nil
end
function GetNormalFromFace(p130, p131)
	return p130.CFrame:VectorToWorldSpace(Vector3.FromNormalId(p131))
end
function module.get(p132, p133, p134)
	local v329 = p134 or 60
	local v330 = os.clock()

	while p132[p133] == nil do
		task.wait()

		if v329 ~= nil and v329 < os.clock() - v330 then
			module.warn("Timeout getting: {index}", { index = p133 })

			break
		end
	end

	return p132[p133]
end
function module.base_tween(p135, p136, p137)
	local v334: Tween = tweenService:Create(p135, p136, p137)

	v334:Play()

	return v334
end

local t3: {[any]: any} = {}

function module.tween(p138, p139, p140)
	if t3[p138] then
		t3[p138]:Cancel()
		t3[p138] = nil
	end

	local v338: Tween = tweenService:Create(p138, p139, p140)

	v338:Play()
	t3[p138] = v338
	v338.Completed:Once(function()
		if t3[p138] == v338 then
			t3[p138] = nil
		end
	end)

	return v338
end
function module.quad_tween(p141, p142, p143, p144)
	if t3[p141] then
		t3[p141]:Cancel()
		t3[p141] = nil
	end

	local t8: {[any]: any} = {}

	for iterFirst, iterSecond in p143 do
		t8[iterFirst] = p141[iterFirst]
	end

	local numberValue: NumberValue = Instance.new("NumberValue")

	numberValue.Changed:Connect(function(p145: number)
		for iterFirst, iterSecond in p143 do
			p141[iterFirst] = module.quad_blerp(t8[iterFirst], p143[iterFirst], p144[iterFirst], p145)
		end
	end)

	local v347: Tween = tweenService:Create(numberValue, p142, { Value = 1 })

	v347:Play()
	t3[p141] = v347
	v347.Completed:Once(function()
		if t3[p141] == v347 then
			t3[p141] = nil
		end

		numberValue:Destroy()
	end)

	return v347
end
function module.seconds_to_legible_time(p146)
	if not (p146 < 60) then
		if p146 < 3600 then
			local floored = math.floor(p146 / 60)

			if floored == 1 then
				return (("%* minute"):format(floored))
			end

			return (("%* minutes"):format(floored))
		end

		if p146 < 86400 then
			local floored = math.floor(p146 / 3600)

			if floored == 1 then
				return (("%* hour"):format(floored))
			end

			return (("%* hours"):format(floored))
		end

		local floored = math.floor(p146 / 86400)

		if floored == 1 then
			return (("%* day"):format(floored))
		end

		return (("%* days"):format(floored))
	end

	if p146 == 1 then
		return (("%* second"):format(p146))
	end

	return (("%* seconds"):format(p146))
end
function module.seconds_to_time_full(p147)
	local floored = math.floor(p147 / 3600)
	local n1 = p147 - floored * 3600
	local floored2 = math.floor(n1 / 60)
	local n2 = n1 - floored2 * 60

	return (floored < 10 and "0" .. floored or floored) .. ":" .. (floored2 < 10 and "0" .. floored2 or floored2) .. ":" .. (n2 < 10 and "0" .. n2 or n2)
end
function module.time_ago(p148)
	local n1 = os.time() - p148

	if n1 < 0 then
		return "just now"
	end

	if n1 < 1 then
		return "just now"
	end

	if n1 < 60 then
		return string.format("%d second%s ago", n1, if n1 == 1 then "" else "s")
	end

	if n1 < 3600 then
		local floored = math.floor(n1 / 60)

		return string.format("%d minute%s ago", floored, if floored == 1 then "" else "s")
	end

	if n1 < 86400 then
		local floored = math.floor(n1 / 3600)

		return string.format("%d hour%s ago", floored, if floored == 1 then "" else "s")
	end

	if n1 < 604800 then
		local floored = math.floor(n1 / 86400)

		return string.format("%d day%s ago", floored, if floored == 1 then "" else "s")
	end

	local dateText = os.date("*t", p148)

	return string.format("%04d-%02d-%02d %02d:%02d", dateText.year, dateText.month, dateText.day, dateText.hour, dateText.min)
end
function module.get_adjacent(p149, p150, p151)
	local v366 = p151 or 0.1

	if p150 == nil then
		p150 = OverlapParams.new()
		p150.RespectCanCollide = true
		p150.FilterType = Enum.RaycastFilterType.Exclude
		p150.FilterDescendantsInstances = { p149 }
	end

	if p149:IsA("BasePart") then
		return game.Workspace:GetPartBoundsInBox(p149.CFrame, p149.Size + Vector3.new(1, 1, 1) * v366, p150)
	end

	if p149:IsA("Model") then
		local v367, v368 = p149:GetBoundingBox()

		return game.Workspace:GetPartBoundsInBox(v367, v368 + Vector3.new(1, 1, 1) * v366, p150)
	end

	error("Not supported part type")
end

local t4: {[any]: any} = {}

local t5: {[any]: any} = {
	add_item = function(p152, p153)
		table.insert(p152.items, p153)

		if p152.destroy_time then
			module.debris(p153, p152.destroy_time)
		end

		p153.Destroying:Connect(function()
			local v830 = table.find(p152.items, p153)

			if v830 then
				table.remove(p152.items, v830)
			end
		end)

		while #p152.items > p152.max do
			local v371 = p152.items[1]

			table.remove(p152.items, 1)
			v371:Destroy()
		end
	end
}

function module.create_debris_queue(p154, p155, p156)
	local object = setmetatable({
		destroy_time = p156,
		items = {},
		max = p155
	}, { __index = t5 })

	t4[p154] = object

	if typeof(p154) == "Instance" then
		p154.Destroying:Connect(function()
			t4[p154] = nil
		end)
	end

	return object
end
function module.get_closest_tagged_instance(p157, p158)
	local v378 = nil
	local n1 = math.huge

	for iterFirst, iterSecond in module.get_tagged(p158) do
		local magnitude = (iterSecond:GetPivot().Position - p157).Magnitude

		if n1 > magnitude then
			n1 = magnitude
			v378 = iterSecond
		end
	end

	return v378
end
function module.debris_queue(p159, p160, p161)
	if p159 == nil then
		return nil
	end

	return t4[p159] or module.create_debris_queue(p159, p160, p161)
end
function module.get_tagged(p162)
	return collectionService:GetTagged(p162)
end

if runService:IsClient() then
	function module.hook_tagged(p163, p164)
		for iterFirst, iterSecond in collectionService:GetTagged(p163) do
			task.spawn(p164, iterSecond)
		end

		return collectionService:GetInstanceAddedSignal(p163):Connect(function(p165)
			p164(p165)
		end)
	end
else
	local t6: {[any]: any} = {}

	runService.Heartbeat:Connect(function(deltaTime: number)
		for _ = 1, 100 do
			local v393 = table.remove(t6, 1)

			if not v393 then
				break
			end

			if v393[2].Parent ~= nil and not v393[2]:IsDescendantOf(game.ServerStorage) then
				v393[1](v393[2])
			end
		end
	end)

	function module.hook_tagged(p167, p168)
		for iterFirst, iterSecond in collectionService:GetTagged(p167) do
			table.insert(t6, { p168, iterSecond })
		end

		return collectionService:GetInstanceAddedSignal(p167):Connect(function(p169)
			table.insert(t6, { p168, p169 })
		end)
	end
end

function module.is_testing_place()
	return game.GameId == 8473504591
end
function module.is_studio()
	return runService:IsStudio()
end
function module.debris(p170, p171)
	if p170:IsA("BasePart") then
		p170.CastShadow = false
		p170.CanQuery = false
	end

	task.delay(p171, function()
		p170:Destroy()
	end)
end
function module.is_utf8_compatible(p172)
	local typeName: string = typeof(p172)

	if typeName == "table" then
		for iterFirst, iterSecond in p172 do
			if not module.is_utf8_compatible(iterFirst) then
				return false
			end

			if not module.is_utf8_compatible(iterSecond) then
				return false
			end
		end
	end

	if typeName == "string" and string.len(typeName) > 100 then
		return false
	end

	local u404: boolean = true

	if typeName ~= "table" then
		u404 = true

		if typeName ~= "string" then
			u404 = true

			if typeName ~= "boolean" then
				u404 = true

				if typeName ~= "number" then
					u404 = typeName == "nil"
				end
			end
		end
	end

	return u404
end
function module.deep_copy(p173)
	if typeof(p173) == "table" then
		local t9: {[any]: any} = {}

		for iterFirst, iterSecond in p173 do
			t9[iterFirst] = module.deep_copy(iterSecond)
		end

		return t9
	end

	return p173
end
function module.cubic_tween(p174, p175, p176, p177, p178)
	if t3[p174] then
		t3[p174]:Cancel()
		t3[p174] = nil
	end

	local t10: {[any]: any} = {}

	for iterFirst, iterSecond in p176 do
		t10[iterFirst] = p174[iterFirst]
	end

	local numberValue: NumberValue = Instance.new("NumberValue")

	numberValue.Changed:Connect(function(p179: number)
		for iterFirst, iterSecond in p176 do
			p174[iterFirst] = module.cubic_blerp(t10[iterFirst], p176[iterFirst], p177[iterFirst], p178[iterFirst], p179)
		end

		if p179 >= 1 then
			numberValue:Destroy()
		end
	end)

	local v418: Tween = tweenService:Create(numberValue, p175, { Value = 1 })

	v418:Play()
	t3[p174] = v418

	return v418
end
function module.absolute_size(p180, p181)
	local mathAbs = math.abs
	local v422 = p181 or p180:GetPivot()
	local v423 = p180:GetExtentsSize()
	local x = v423.X
	local y = v423.Y
	local z = v423.Z
	local v427, v428, v429, v430, v431, v432, v433, v434, v435, v436, v437, v438 = v422:components()
	local v439 = mathAbs(v430)
	local v440 = mathAbs(v431)
	local v441 = mathAbs(v432)
	local v442 = mathAbs(v433)
	local v443 = mathAbs(v434)
	local v444 = mathAbs(v435)
	local v445 = mathAbs(v436)
	local v446 = mathAbs(v437)
	local v447 = mathAbs(v438)
	local vector3 = Vector3.new(v439 * x + v440 * y + v441 * z, v442 * x + v443 * y + v444 * z, v445 * x + v446 * y + v447 * z)

	return vector3
end
function module.move_cframe_to_closest(p182, p183)
	local v451 = p183.Position
	local lookVector = p183.LookVector
	local v453 = (p182.Position - v451):Dot(lookVector)

	return CFrame.new(v451 + lookVector * v453) * (p183 - v451)
end
function module.create_cache_table(p184, p185)
	return (setmetatable({
		tab = {}
	}, {
		__index = function(p186, p187)
			if p186.tab[p187] then
				if p185 then
					p186.tab[p187].destroy()
				end

				return p186.tab[p187].value
			end

			return nil
		end,
		__newindex = function(p188, p189, p190)
			if p190 == nil then
				if p188.tab[p189] then
					p188.tab[p189].destroy:cancel()
				end

				p188.tab[p189] = nil

				return
			end

			local t17 = p188.tab[p189]

			if not t17 then
				t17 = {
					value = nil,
					destroy = module.ov(function()
						task.wait(p184)
						p188.tab[p189] = nil
					end)
				}
			end

			p188.tab[p189] = t17
			p188.tab[p189].value = p190
			p188.tab[p189].destroy()
		end
	}))
end
function module.create_reinforce(p191)
	local x = p191.Size.X
	local v458 = math.min(8, p191.Size.Y)
	local PlateSize = script.Plate.Size
	local y = PlateSize.Y
	local floored = math.floor(v458 / y)
	local n1 = y + v458 % y / floored
	local v463 = PlateSize.X
	local floored3 = math.floor(x / v463)

	v458 = v463 + x % v463 / floored3

	local vector3 = Vector3.new(v458, n1, 0.3)
	local n2 = p191.CFrame - p191.CFrame.RightVector * (p191.Size.X * 0.5) - p191.CFrame.UpVector * (p191.Size.Y * 0.5)
	local reinforcement: Model = Instance.new("Model")

	reinforcement.Name = "Reinforcement"

	for i = 0, floored - 1 do
		local u469: boolean = i % 2 == 1
		local v470 = if u469 then floored3 else floored3 - 1
		local n3 = 0
		local n4: number = 0

		for j = 0, v470 do
			local n5

			if not u469 then
				n5 = n2 + n2.RightVector * (n3 + v458 * 0.5) + n2.UpVector * (n1 * i + n1 * 0.5)
				n3 += v458
			elseif j == 0 or j == v470 then
				n5 = n2 + n2.RightVector * (n3 + v458 * 0.25) + n2.UpVector * (n1 * i + n1 * 0.5)
				n3 += v458 * 0.5
			else
				n5 = n2 + n2.RightVector * (n3 + v458 * 0.5) + n2.UpVector * (n1 * i + n1 * 0.5)
				n3 += v458
			end

			local clone = script.Plate:Clone()

			clone.Parent = reinforcement
			clone.CFrame = n5

			if u469 and (j == 0 or j == v470) then
				clone.Size = Vector3.new(v458 * 0.5, n1, vector3.Z)
			else
				clone.Size = Vector3.new(v458, n1, vector3.Z)
			end

			n4 += 1

			if n4 % 2 == 0 then
				local clone2 = script.PlatePole:Clone()

				clone2.Parent = reinforcement

				local cFrame = CFrame.new(0, 0, p191.Size.Z * 0.5 + vector3.Z * 0.5)

				clone2.CFrame = n5 * cFrame
				clone2.Size = Vector3.new(0.4, 0.4, p191.Size.Z + 0.2)
			end
		end
	end

	return reinforcement
end
function module.create_barricade(p192)
	local x = p192.Size.X
	local v480 = p192.Size.Y

	if p192:GetAttribute("Type") == "Door" then
		v480 = math.floor(p192.Size.Y)
	end

	local DoorPlankSize = script.DoorPlank.Size

	DoorPlankSize = Vector3.new(p192.Size.X * 0.5, DoorPlankSize.Y, DoorPlankSize.Z)

	local rounded = math.round(v480 / DoorPlankSize.Y)
	local n1 = p192.CFrame - p192.CFrame.RightVector * (p192.Size.X * 0.5) - p192.CFrame.UpVector * (p192.Size.Y * 0.5)
	local doorBarricade: Model = Instance.new("Model")
	local color3 = Color3.fromRGB(245, 205, 48)
	local color32 = Color3.fromRGB(27, 42, 53)
	local n2: number = 0

	doorBarricade.Name = "DoorBarricade"

	for i = 0, rounded - 1 do
		for j = 0, 1 do
			local n3 = n1 + n1.RightVector * (DoorPlankSize.X * 0.5) + n1.UpVector * (DoorPlankSize.Y * i + DoorPlankSize.Y * 0.5)
			local clone = script.DoorPlank:Clone()

			if i % 2 == 0 then
				clone.Color = color3
			else
				clone.Color = color32
			end

			n2 += 1
			clone.Parent = doorBarricade

			local v492 = CFrame.Angles(0, 0, 0)
			local cFrame = CFrame.new(DoorPlankSize.X * j, 0, 0)

			clone.CFrame = n3 * v492 * cFrame
			clone.Size = Vector3.new(DoorPlankSize.X, DoorPlankSize.Y * 1, DoorPlankSize.Z * 1)
		end
	end

	return doorBarricade
end
function module.create_planks_barricade(p193)
	local x = p193.Size.X
	local v496 = p193.Size.Y

	if p193:GetAttribute("Type") == "Door" then
		v496 = math.floor(p193.Size.Y)
	end

	local SolidDoorPlankSize = script.SolidDoorPlank.Size

	SolidDoorPlankSize = Vector3.new(p193.Size.X, SolidDoorPlankSize.Y, SolidDoorPlankSize.Z)

	local rounded = math.round(v496 / SolidDoorPlankSize.Y)
	local n1 = p193.CFrame - p193.CFrame.RightVector * (p193.Size.X * 0.5) - p193.CFrame.UpVector * (p193.Size.Y * 0.5)
	local doorBarricade: Model = Instance.new("Model")

	doorBarricade.Name = "DoorBarricade"

	for i = 0, rounded - 1 do
		local v502 = module.rand(-3, 3)
		local v503 = module.rand(0.85, 0.9)
		local v504 = module.rand(0.95, 1.05)
		local n2 = n1 + n1.RightVector * (SolidDoorPlankSize.X * 1) + n1.UpVector * (SolidDoorPlankSize.Y * i + SolidDoorPlankSize.Y * 0.5)
		local clone = script.SolidDoorPlank:Clone()

		clone.Parent = doorBarricade

		local cFrameAngles = CFrame.Angles
		local v508 = math.rad(v502)
		local cFrame = cFrameAngles(0, 0, v508)

		clone.CFrame = n2 * cFrame
		clone.Size = Vector3.new(SolidDoorPlankSize.X, SolidDoorPlankSize.Y * v503, SolidDoorPlankSize.Z * v504)
	end

	return doorBarricade
end
function module.create_motor(p194, p195)
	local part0 = p194
	local part1 = p195
	local motor6D: Motor6D = Instance.new("Motor6D")

	motor6D.Part0 = part0
	motor6D.Part1 = part1
	motor6D.C1 = part1.PivotOffset
	motor6D.C0 = part0.CFrame:ToObjectSpace(part1:GetPivot())
	p195.Anchored = false

	return motor6D
end
function module.create_metal_barricade(p196)
	local x = p196.Size.X
	local v517 = p196.Size.Y

	if p196:GetAttribute("Type") == "Door" then
		v517 = math.floor(p196.Size.Y)
	end

	local MetalRollSize = script.MetalRoll.Size

	MetalRollSize = Vector3.new(p196.Size.X, MetalRollSize.Y, MetalRollSize.Z)

	local rounded = math.round(v517 / MetalRollSize.Y)
	local n1 = p196.CFrame - p196.CFrame.RightVector * (p196.Size.X * 0.5) - p196.CFrame.UpVector * (p196.Size.Y * 0.5)
	local doorBarricade: Model = Instance.new("Model")

	doorBarricade.Name = "DoorBarricade"

	for i = 0, rounded - 1 do
		local cFrame = n1 + n1.RightVector * (MetalRollSize.X * 1) + n1.UpVector * (MetalRollSize.Y * i + MetalRollSize.Y * 0.5)
		local clone = script.MetalRoll:Clone()

		clone.Parent = doorBarricade
		clone.CFrame = cFrame
		clone.Size = Vector3.new(x, v517, MetalRollSize.Z)
	end

	return doorBarricade
end

local t7: {[any]: any} = {}

function module.tween_slow(p197, p198, p199, p200)
	local time = p198.Time
	local t11: {[any]: any} = {}

	for iterFirst, iterSecond in p199 do
		t11[iterFirst] = p197[iterFirst]
	end

	local t12: {[any]: any} = {
		elapsed_time = 0,
		accumulator = 0,
		on_complete = nil,
		instance = p197,
		start_values = t11,
		goal = p199,
		total_time = time,
		step_interval = p200 or 0.1
	}

	t7[p197] = t12

	return t12
end

if runService:IsServer() then
	module.tween = module.tween_slow
	runService.Heartbeat:Connect(function(deltaTime: number)
		for key, value in t7 do
			value.elapsed_time = value.elapsed_time + deltaTime
			value.accumulator = value.accumulator + deltaTime

			if value.accumulator >= value.step_interval then
				value.accumulator = 0

				local v537 = math.min(value.elapsed_time / value.total_time, 1)

				for k, v in pairs(value.goal) do
					value.instance[k] = module.lerp(value.start_values[k], v, v537)
				end

				if v537 >= 1 then
					t7[key] = nil

					if value.on_complete then
						value.on_complete()
					end
				end
			end
		end
	end)
end

function module.are_points_collinear(list, p203)
	if #list < 3 then
		return true
	end

	local unit = (list[2] - list[1]).unit

	for i = 3, #list do
		local v544 = unit:Dot((list[i] - list[1]).unit)
		local absoluteValue = math.abs(1 - v544)

		if p203 < absoluteValue then
			return false
		end
	end

	return true
end
function module.is_close(p204, p205, p206)
	local v549 = p206 or 0.001
	local typeName: string = typeof(p204)
	local typeName2: string = typeof(p205)

	if typeName ~= typeName2 then
		return false
	end

	if typeof(p204) == "number" then
		local absoluteValue = math.abs(p204 - p205)

		return v549 >= absoluteValue
	end

	if typeof(p204) == "Vector3" or typeof(p204) == "Vector2" then
		return v549 >= (p204 - p205).Magnitude
	end

	if typeof(p204) == "CFrame" then
		local v553, v554, v555 = p204:ToOrientation()
		local v556, v557, v558 = p205:ToOrientation()

		return v549 >= (p204.Position - p205.Position).Magnitude and v549 >= math.abs(v553 - v556) and v549 >= math.abs(v554 - v557) and v549 >= math.abs(v555 - v558)
	end

	error("Unsupported types: values must be numbers, vectors, or CFrames.")
end
function module.frame_dt(p207, p208)
	return 1 - (1 - p207) ^ (p208 * 60)
end
function module.frame_lerp(p209, p210, p211, p212)
	local n1 = 1 - (1 - p211) ^ (p212 * 60)

	if typeof(p209) == "number" then
		return p209 + n1 * (p210 - p209)
	end

	return p209:Lerp(p210, n1)
end
function module.hook_first_child(p213, p214, p215)
	local foundChild = p213:FindFirstChild(p214)

	if foundChild then
		task.spawn(p215, foundChild)

		return
	end

	local connection = nil

	connection = p213.ChildAdded:Connect(function(p216)
		if p216.Name == p214 then
			connection:Disconnect()
			task.spawn(p215, p216)
		end
	end)
end
function module.hook_children(p217: {[any]: any}, p218, p219)
	if typeof(p217) ~= "table" then
		p217 = { p217 }
	end

	for iterFirst, iterSecond in p217 do
		for _, v in pairs(iterSecond:GetChildren()) do
			task.spawn(p218, v, true)
		end

		iterSecond.ChildAdded:Connect(function(p220)
			p218(p220, true)
		end)

		if p219 then
			iterSecond.ChildRemoved:Connect(function(p221)
				p218(p221, false)
			end)
		end
	end
end
function module.hook_child_added(p222, p223)
	for iterFirst, iterSecond in p222:GetChildren() do
		task.spawn(p223, iterSecond)
	end

	return p222.ChildAdded:Connect(p223)
end
function module.hook_descendant_added(p224, p225)
	for iterFirst, iterSecond in p224:GetDescendants() do
		task.spawn(p225, iterSecond)
	end

	return p224.DescendantAdded:Connect(p225)
end
function module.capitalize_first(p226)
	local v587 = p226:sub(1, 1):upper()
	local substring = p226:sub(2)

	return v587 .. substring
end
function module.hook_descendants(p227, p228, p229)
	for iterFirst, iterSecond in p227:GetDescendants() do
		task.spawn(p228, iterSecond, true)
	end

	local connection2 = nil

	local connection = p227.DescendantAdded:Connect(function(p230)
		p228(p230, true)
	end)

	if p229 then
		connection2 = p227.DescendantRemoving:Connect(function(p231)
			p228(p231, false)
		end)
	end

	return connection, connection2
end
function module.hook_ancestor(p232, p233)
	task.spawn(p233, p232.Parent)

	return p232.AncestryChanged:Connect(function(_, p235)
		p233(p235)
	end)
end
function module.raycast(p236, p237, p238, p239)
	local v602 = game.Workspace:Raycast(p236, p237, p238)

	if not v602 then
		return
	end

	if p239 then
		p239(v602)

		return
	end

	return v602
end
function module.reverse_angle(p240)
	local n1 = p240 + 3.141592653589793

	if n1 >= 6.283185307179586 then
		n1 -= 6.283185307179586
	end

	return n1
end
function module.inverse_inner(p241)
	local v606, v607, v608 = p241:ToOrientation()
	local cFrame = CFrame.new(-p241.X, p241.Y, p241.Z)
	local cFrameAngles = CFrame.Angles
	local v611 = module.reverse_angle(v607)
	local v612 = cFrameAngles(v606, v611, module.reverse_angle(v608))

	return cFrame * v612
end
function module.parts_on_ray(p242, p243, p244, p245, p246)
	local filterDescendantsInstances = p244 or {}
	local raycastParams = RaycastParams.new()

	raycastParams.FilterType = Enum.RaycastFilterType.Exclude
	raycastParams.FilterDescendantsInstances = filterDescendantsInstances

	while true do
		local v620 = if p246 then if typeof(p246) == "number" then game.Workspace:Spherecast(p242, p246, p243, raycastParams) else game.Workspace:Blockcast(p242, p246, p243, raycastParams) else game.Workspace:Raycast(p242, p243, raycastParams)

		if v620 then
			raycastParams:AddToFilter(v620.Instance)

			if p245 and p245(v620) == false then
				return
			end
		end

		if not v620 then
			return filterDescendantsInstances
		end
	end
end
function module.does_sphere_intersect_part(p247, p248, p249, p250)
	local v625 = p249:pointToObjectSpace(p247)
	local n1 = p250 * 0.5
	local v627 = math.clamp(v625.X, -n1.X, n1.X)
	local v628 = math.clamp(v625.Y, -n1.Y, n1.Y)
	local v629 = math.clamp(v625.Z, -n1.Z, n1.Z)
	local vector3 = Vector3.new(v627, v628, v629)

	v627 = p249:pointToWorldSpace(vector3)

	return (p247 - v627).Magnitude ^ 2 <= p248 ^ 2
end
function module.are_spheres_intersecting(p251, p252, p253, p254)
	return (p251 - p253).Magnitude <= p252 + p254
end
function module.intersect(p255, p256)
	local t14: {[any]: any} = {}

	for iterFirst, iterSecond in p255 do
		if table.find(p256, iterSecond) and not table.find(t14, iterSecond) then
			table.insert(t14, iterSecond)
		end
	end

	return t14
end
function module.cut_part_in_half(p257, p258)
	local t15: {[any]: any} = {}
	t15 = { p258.X, p258.Y, p258.Z }
	table.sort(t15)

	if t15[3] >= 1 then
		local vector3 = nil
		local v644 = nil
		local v645 = nil

		if t15[3] == p258.Z then
			vector3 = Vector3.new(p258.X, p258.Y, p258.Z * 0.5)

			local cFrame = CFrame.new(0, 0, p258.Z * 0.25)

			v644 = p257 * cFrame

			local cFrame2 = CFrame.new(0, 0, -p258.Z * 0.25)

			v645 = p257 * cFrame2
		elseif t15[3] == p258.Y then
			vector3 = Vector3.new(p258.X, p258.Y * 0.5, p258.Z)

			local cFrame = CFrame.new(0, p258.Y * 0.25, 0)

			v644 = p257 * cFrame

			local cFrame3 = CFrame.new(0, -p258.Y * 0.25, 0)

			v645 = p257 * cFrame3
		elseif t15[3] == p258.X then
			vector3 = Vector3.new(p258.X * 0.5, p258.Y, p258.Z)

			local cFrame = CFrame.new(p258.X * 0.25, 0, 0)

			v644 = p257 * cFrame

			local cFrame4 = CFrame.new(-p258.X * 0.25, 0, 0)

			v645 = p257 * cFrame4
		end

		return v644, v645, vector3
	end
end
local function base_penetrate(p259)
	local instance = p259.Instance
	local v654 = instance.Parent
	local v655 = instance:GetAttribute("Hard") or v654:GetAttribute("Hard")
	local u656: boolean = not instance:GetAttribute("Soft")

	if u656 then
		u656 = not v654:GetAttribute("Soft")

		if u656 then
			u656 = false

			if instance.CanCollide == true then
				u656 = instance.Transparency < 1
			end
		end
	end

	if not v655 and not u656 then
		return true
	end

	v654 = { instance.Size.X, instance.Size.Y, instance.Size.Z }
	table.sort(v654)

	if v654[2] >= 1.45 or (not not instance:HasTag("WallPart") or not not v655) and v654[2] > 0.5 then
		return false, 0
	end

	return true
end
function module.can_ray_penetrate(p260, p261, p262, p263)
	local raycastParams = RaycastParams.new()

	raycastParams.FilterType = Enum.RaycastFilterType.Exclude
	raycastParams.FilterDescendantsInstances = p262 or {}

	while true do
		local v662 = game.Workspace:Raycast(p260, p261 - p260, raycastParams)

		if v662 then
			raycastParams:AddToFilter(v662.Instance)

			local v663, v664 = (p263 or base_penetrate)(v662)

			if not v663 then
				return v664
			end
		end

		if not v662 then
			return 1
		end
	end
end
function module.validate_position(p264, p265, p266)
	if p265 then
		local v668 = p265.Y

		if p264.Y - p265.Y > 3 then
			v668 = p264.Y - 3
		elseif p265.Y - p264.Y > 3 then
			v668 = p264.Y + 3
		end

		local vector3 = Vector3.new(p264.X, v668, p264.Z)
		local vector33 = Vector3.new(p265.X, v668, p265.Z)
		local lookVector = CFrame.lookAt(vector3, vector33).LookVector
		local magnitude = (vector3 - vector33).Magnitude
		local v673 = math.min(3, magnitude)
		local v674 = workspace:Raycast(vector3, lookVector * v673, p266)

		if v674 then
			return v674.Position - lookVector * 0.1
		end

		if magnitude > 3 then
			return p265 - lookVector * (magnitude - 3)
		end

		return p265
	end

	return p264
end
function module.no_collide(part0, parent)
	if part0:IsA("BasePart") then
		local noCollisionConstraint: NoCollisionConstraint = Instance.new("NoCollisionConstraint")

		noCollisionConstraint.Part0 = part0
		noCollisionConstraint.Part1 = parent
		noCollisionConstraint.Parent = parent

		return
	end

	local humanoid = part0:FindFirstChild("Humanoid")

	for iterFirst, iterSecond in part0:GetDescendants() do
		if iterSecond:IsA("BasePart") and (not not iterSecond.CanCollide or not not humanoid and iterSecond == part0.PrimaryPart) then
			local noCollisionConstraint: NoCollisionConstraint = Instance.new("NoCollisionConstraint")

			noCollisionConstraint.Part0 = iterSecond
			noCollisionConstraint.Part1 = parent
			noCollisionConstraint.Parent = parent
		end
	end
end
function module.within_view(p269, p270)
	local CurrentCamera: Camera = workspace.CurrentCamera
	local n1 = p269 - CurrentCamera.CFrame.Position
	local magnitude = n1.Magnitude

	if magnitude < 0.01 then
		return true
	end

	if math.cos(p270 / magnitude) < CurrentCamera.CFrame.LookVector:Dot(n1.Unit) then
		return true
	end

	return false
end
function module.task_buffer(p271, ...)
	bufferingFunction.bf(function(p272, ...)
		local ok, result = pcall(p272, ...)

		if not ok then
			warn("[Client]", result)
		end
	end, "task_buffer")(p271, ...)
end
function module.rotate_movement_to_cframe(p273, p274)
	if p273.Magnitude == 0 then
		return Vector3.new(0, 0, 0)
	end

	local rightVector = p274.RightVector
	local n1 = Vector3.new(rightVector.X, 0, rightVector.Z) * p273.X + p274.LookVector * p273.Z

	if n1.Magnitude == 0 or n1.Magnitude ~= n1.Magnitude then
		return Vector3.new(0, 0, 0)
	end

	return n1
end
function module.rotate_humanoid_movement_to_cframe(p275, p276)
	if p275.Magnitude == 0 then
		return Vector3.new(0, 0, 0)
	end

	local lookVector = p276.LookVector
	local rightVector = p276.RightVector
	local vector3 = Vector3.new(lookVector.X, 0, lookVector.Z)

	vector3 = Vector3.new(rightVector.X, 0, rightVector.Z).Unit * p275.X + vector3.Unit * p275.Z

	if vector3.Magnitude == 0 or vector3.Magnitude ~= vector3.Magnitude then
		return Vector3.new(0, 0, 0)
	end

	local vector34 = Vector3.new(vector3.X, 0, vector3.Z)

	return vector34
end
function module.filter_text(p277, p278)
	local u700 = nil

	local ok, result = pcall(function()
		u700 = textService:FilterStringAsync(p277, p278)
	end)

	if ok then
		local ok2, result2 = pcall(function()
			return u700:GetNonChatStringForBroadcastAsync()
		end)

		if ok2 then
			return result2
		end

		return false, "Error filtering text"
	end

	return false, "Could not filter text"
end
function module.sanitize_text(p279)
	return (p279:gsub("[^a-zA-ZÁÄÉÖÜáäéöü ]", ""):sub(1, 12))
end
function module.can_interact(player, p281)
	if player.Character == nil or not player.Character:FindFirstChild("collision") then
		return
	end

	local v708 = nil

	if p281:IsA("Model") then
		v708 = p281:GetExtentsSize()
	elseif p281:IsA("BasePart") then
		v708 = p281.Size
	end

	local v709 = math.max(1.5, v708.Magnitude * 0.333)

	v708 = true

	if runService:IsClient() then
		local within_view = module.within_view
		local pivot = p281:GetPivot()

		v708 = within_view(pivot.Position, v709)
	end

	local v712: boolean = runService:IsServer()
	local v713 = player.Character.collision.Position
	local pivot = p281:GetPivot()

	return v708 and (v709 + 3) * (if v712 then 2 else 1) > (v713 - pivot.Position).Magnitude
end
function module.is_behind(p282, p283)
	return p282.LookVector:Dot((p283.Position - p282.Position).Unit) > 0
end
function module.can_ray_reach(p284, p285, p286, p287)
	local raycastParams = RaycastParams.new()

	raycastParams.FilterType = Enum.RaycastFilterType.Exclude
	raycastParams.FilterDescendantsInstances = p286 or {}
	raycastParams.CollisionGroup = p287 or "Default"

	while true do
		local v722 = game.Workspace:Raycast(p284, p285 - p284, raycastParams)

		if v722 then
			local instance = v722.Instance
			local instanceParent = instance.Parent

			raycastParams:AddToFilter(instance)

			if instance:GetAttribute("Hard") or instance.Parent:GetAttribute("Hard") then
				return false
			end

			if instance.CanCollide == true and instance.Transparency < 1 and (v722.Position - p285).Magnitude > 0.3 then
				local t16: {[any]: any} = { instance.Size.X, instance.Size.Y, instance.Size.Z }

				table.sort(t16)

				if t16[2] > 1 or instance:HasTag("WallPart") and t16[2] > 0.5 then
					return false
				end
			end
		end

		if not v722 then
			return true
		end
	end
end
function module.is_looking_towards(p288, p289, p290)
	local v729 = p288.LookVector:Dot((p289 - p288.Position).Unit)
	local v730 = math.acos(v729)

	v729 = math.rad(p290 or 90)

	return v730 <= v729
end
function module.watch_parent(p291, p292)
	p292(p291.Parent)

	return p291.AncestryChanged:Connect(function()
		p292(p291.Parent)
	end)
end
function module.wait_for_parent(p293, p294, p295)
	if p294 == p293.Parent then
		p295()

		return
	end

	local connection = nil

	connection = p293.AncestryChanged:Connect(function()
		if p293.Parent == p294 then
			p295()
			connection:Disconnect()
		end
	end)
end
function module.watch_property(p296, p297, p298)
	p298(p296[p297], p296[p297])

	local u740 = p296[p297]

	return p296:GetPropertyChangedSignal(p297):Connect(function()
		p298(p296[p297], u740)
		u740 = p296[p297]
	end)
end
function module.watch_attribute(p299, p300, p301)
	local attributeValue = p299:GetAttribute(p300)

	p301(attributeValue, p299:GetAttribute(p300))

	local attributeValue2 = p299:GetAttribute(p300)

	return p299:GetAttributeChangedSignal(p300):Connect(function()
		local attributeValue3 = p299:GetAttribute(p300)

		p301(attributeValue3, attributeValue2)
		attributeValue2 = p299:GetAttribute(p300)
	end)
end
function module.wait_for_property(p302, p303)
	while p302[p303] == nil do
		p302:GetPropertyChangedSignal(p303):Wait()
	end

	return p302[p303]
end
function module.wait_for_attribute(p304, p305)
	while true do
		if p304:GetAttribute(p305) ~= nil then
			break
		end

		p304:GetAttributeChangedSignal(p305):Wait()
	end

	return p304:GetAttribute(p305)
end
function module.create_sphere_attachment(p306, p307)
	local clone = script.SphereAttachment:Clone()

	clone.Parent = game.Workspace
	clone.CFrame = CFrame.new(p306)

	if p307 then
		module.debris(clone, p307)
	end

	return clone
end
function module.average(...)
	local v753 = table.pack(...)
	local n = v753.n

	if n == 0 then
		return 0
	end

	local n1 = 0

	for _, v in ipairs(v753) do
		n1 += v
	end

	return n1 / n
end
function module.calculate_rating_change(p308, p309, p310, p311, p312)
	local v763 = math.min(2500, p308)
	local v764 = math.min(2500, p309)
	local v765 = math.max(0, p312 or 25)
	local v766 = math.clamp(-(v763 - v764) / 50, -v765, v765)
	local v767

	if p310 then
		v767 = math.max(0, v765 + v766 + p311)
	else
		v767 = math.min(0, -v765 + v766 + p311)
	end

	return (math.round(v767))
end
function module.fit_part_in_space(p313, _, p315)
	local v771
	local v772
	local v773
	local v774
	local v775
	local v776
	local pivot = p313:GetPivot()
	local pivotPosition = pivot.Position
	local n1 = p315 * 0.5

	local function get_dist(p316, p317)
		local v855
		local u856 = nil

		module.parts_on_ray(pivotPosition, p316 * p317, nil, function(p318)
			if p318 and p318.Instance and (p318.Instance.CollisionGroup ~= "Default" or p318.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p318.Instance.CanCollide and p318.Instance.Transparency < 1 then
				u856 = p318

				return false
			end
		end)
		v855 = p317

		return v855
	end

	local x = n1.X
	local u782 = nil

	module.parts_on_ray(pivotPosition, pivot.RightVector * x, nil, function(p319)
		if p319 and p319.Instance and (p319.Instance.CollisionGroup ~= "Default" or p319.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p319.Instance.CanCollide and p319.Instance.Transparency < 1 then
			u782 = p319

			return false
		end
	end)
	v771 = x

	local v783 = n1.X
	local u784 = nil

	module.parts_on_ray(pivotPosition, -pivot.RightVector * v783, nil, function(p320)
		if p320 and p320.Instance and (p320.Instance.CollisionGroup ~= "Default" or p320.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p320.Instance.CanCollide and p320.Instance.Transparency < 1 then
			u784 = p320

			return false
		end
	end)
	v772 = v783

	local y = n1.Y
	local u786 = nil

	module.parts_on_ray(pivotPosition, pivot.UpVector * y, nil, function(p321)
		if p321 and p321.Instance and (p321.Instance.CollisionGroup ~= "Default" or p321.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p321.Instance.CanCollide and p321.Instance.Transparency < 1 then
			u786 = p321

			return false
		end
	end)
	v773 = y

	local v787 = n1.Y
	local u788 = nil

	module.parts_on_ray(pivotPosition, -pivot.UpVector * v787, nil, function(p322)
		if p322 and p322.Instance and (p322.Instance.CollisionGroup ~= "Default" or p322.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p322.Instance.CanCollide and p322.Instance.Transparency < 1 then
			u788 = p322

			return false
		end
	end)
	v774 = v787

	local z = n1.Z
	local u790 = nil

	module.parts_on_ray(pivotPosition, -pivot.LookVector * z, nil, function(p323)
		if p323 and p323.Instance and (p323.Instance.CollisionGroup ~= "Default" or p323.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p323.Instance.CanCollide and p323.Instance.Transparency < 1 then
			u790 = p323

			return false
		end
	end)
	v775 = z

	local v791 = n1.Z
	local u792 = nil

	module.parts_on_ray(pivotPosition, pivot.LookVector * v791, nil, function(p324)
		if p324 and p324.Instance and (p324.Instance.CollisionGroup ~= "Default" or p324.Instance.Size.Magnitude > p315.Magnitude * 0.5) and not not p324.Instance.CanCollide and p324.Instance.Transparency < 1 then
			u792 = p324

			return false
		end
	end)
	v776 = v791
	p313.Size = Vector3.new(v771 + v772, v773 + v774, v775 + v776)
	p313.PivotOffset = CFrame.new((v772 - v771) * 0.5, (v774 - v773) * 0.5, (v776 - v775) * 0.5)
	p313:PivotTo(pivot)

	return {
		posX = v771 / n1.X,
		negX = v772 / n1.X,
		posY = v773 / n1.Y,
		negY = v774 / n1.Y,
		posZ = v775 / n1.Z,
		negZ = v776 / n1.Z
	}
end
function module.resize_keep_relative_pivot(p325, p326)
	local pivot = p325:GetPivot()
	local v796 = p325.Size
	local pivotOffset = p325.PivotOffset
	local pivotOffsetPosition = pivotOffset.Position
	local pivotOffsetRotation = pivotOffset.Rotation
	local vector3 = Vector3.new(pivotOffsetPosition.X / v796.X, pivotOffsetPosition.Y / v796.Y, pivotOffsetPosition.Z / v796.Z)

	p325.Size = p326

	local vector35 = Vector3.new(vector3.X * p326.X, vector3.Y * p326.Y, vector3.Z * p326.Z)

	p325.PivotOffset = CFrame.new(vector35) * pivotOffsetRotation
	p325:PivotTo(pivot)
end
function module.sum(...)
	local n1 = 0

	for _, v in ipairs(table.pack(...)) do
		n1 += v
	end

	return n1
end
function module.can_damage(p327)
	return (p327:HasTag("Breakable") or p327.Parent:HasTag("Breakable")) and p327.CanCollide and p327.CanQuery
end
function module.get_breakable_instance(p328, p329)
	if p329 then
		if p328.Parent:HasTag("Breakable") then
			return p328.Parent
		end

		if p328:HasTag("Breakable") then
			return p328
		end
	else
		if p328:HasTag("Breakable") then
			return p328
		end

		if p328.Parent:HasTag("Breakable") then
			return p328.Parent
		end
	end
end
function module.is_player_alive(player)
	local Character = player.Character
	local v810 = Character and Character:IsDescendantOf(game.Workspace) and Character:FindFirstChild("Humanoid")

	if v810 and v810.Health > 0 then
		return true
	end

	return false
end
function module.create_red_point(p331, p332)
	local part: Part = Instance.new("Part")

	part.Shape = Enum.PartType.Ball
	part.Size = Vector3.new(0.15, 0.15, 0.15)
	part.Color = Color3.fromRGB(255, 0, 0)
	part.Anchored = true
	part.CanCollide = false
	part.CanQuery = false
	part.CanTouch = false
	part.Parent = game.Workspace
	part.CFrame = CFrame.new(p331)

	if p332 then
		module.debris(part, p332)
	end

	return part
end
function module.create_trail(p333, p334, p335)
	local trailPoint: Part = Instance.new("Part")

	trailPoint.Name = "TrailPoint"
	trailPoint.Color = Color3.fromRGB(255, 0, 0)
	trailPoint.Anchored = true
	trailPoint.CanCollide = false
	trailPoint.CanQuery = false
	trailPoint.Transparency = 0
	trailPoint.Size = Vector3.new(0.3, 0.3, 0.3)
	trailPoint.Shape = Enum.PartType.Ball
	trailPoint.Parent = game.Workspace
	trailPoint.CFrame = CFrame.new(p333)

	local attachment: Attachment = Instance.new("Attachment")

	attachment.Parent = trailPoint

	local clone: Instance = trailPoint:Clone()

	clone.Color = Color3.fromRGB(0, 125, 255)
	clone.Parent = game.Workspace
	clone.CFrame = CFrame.new(p334)
	module.debris(trailPoint, p335 or 0.5)
	module.debris(clone, p335 or 0.5)

	local beam: Beam = Instance.new("Beam")

	beam.Parent = trailPoint
	beam.Attachment0 = attachment
	beam.Attachment1 = clone.Attachment
	beam.FaceCamera = true

	local colorSequenceNew = ColorSequence.new
	local color3 = Color3.fromRGB(255, 0, 0)

	beam.Color = colorSequenceNew(color3, Color3.fromRGB(0, 125, 255))
	beam.Width0 = 0.2
	beam.Width1 = 0.2

	return trailPoint, clone
end
function module.load()
end

return module