-- ModuleScript Camera (via bytefall decompiler)
-- Decompiled using ByteFall
-- discord.gg/pHTnqmmWzk
local contextActionService: ContextActionService = game:GetService("ContextActionService")
local guiService: GuiService = game:GetService("GuiService")
local players: Players = game:GetService("Players")
local runService: RunService = game:GetService("RunService")
local userInputService: UserInputService = game:GetService("UserInputService")
local workspace: Workspace = game:GetService("Workspace")
local spring = require(script:WaitForChild("Spring"))
local spectate = require(script:WaitForChild("Spectate"))
local fighters = require(script:WaitForChild("Fighters"))
local fades = require(script:WaitForChild("Fades"))
local aimAssist = require(script:WaitForChild("AimAssist"))
local spectateKeys = require(script:WaitForChild("SpectateKeys"))
local smoothing = require(script:WaitForChild("Smoothing"))
local occlusion = require(script:WaitForChild("Occlusion"))
local firstPerson = require(script:WaitForChild("FirstPerson"))
local guards = require(script:WaitForChild("Guards"))
local simulation = require(script.Parent:WaitForChild("Simulation"))
local finite = require(script:WaitForChild("Finite"))

finite.Authority = tostring(simulation.Authority)

local keybinds = require(script.Parent:WaitForChild("Keybinds"))
local module: {[any]: any} = { PadLook = require(script:WaitForChild("PadLook")) }
local v21: boolean = runService:IsClient()

if v21 then
	v21 = not runService:IsServer()
end

local LocalPlayer: Player = players.LocalPlayer
local n1 = 0
local n2 = -0.20943951023931956
local n3: number = 1
local u26: boolean = false
local n4 = 50
local n5 = 70
local n6 = 10.5
local n7 = 1
local u31 = true
local u32: boolean = false
local t2: {[any]: any} = {}
local t3: {[any]: any} = {}
local t4: {[any]: any} = {}
local t5: {[any]: any} = {}
local t6: {[any]: any} = {}
local v38 = spring.new(70, 3.2, 1)
local v39 = spring.new(10.5, 3.5, 1)
local v40 = spring.new(2.9, 3.5, 1)
local v41 = spring.new(Vector3.new(0, 0, 0), 4, 1)
local v42 = spring.new(0, 5, 1)
local v43 = spring.new(0, 3.2, 0.45)
local v44 = spring.new(Vector3.new(0, 0, 0), 5, 0.75)
local n8 = 0
local n9 = 0
local n10: number = 0
local u48 = os.clock()
local n11 = 0
local u50: boolean = false
local u51 = nil
local n12 = 0
local n13: number = 0
local n14 = 1.6666666666666667
local n15 = 0
local u56 = nil
local cFrame = CFrame.new()
local n16 = 70
local u59 = nil
local u60 = nil
local u61: boolean = false
local u62: boolean = false
local u63 = false
local u64 = false
local CFrame2 = nil
local n17 = 70
local n18 = 1
local u68 = nil
local u69: boolean = false
local n19 = 1
local vector2Zero = Vector2.zero
local u72 = Vector2.zero
local n20 = 0
local n21: number = 0
local t7: {[any]: any} = {}
local u76 = nil
local s1 = "none"
local cFrame2 = CFrame.new()
local n22 = 70
local u80 = nil
local u81 = nil
local n23 = 70
local n24 = 1
local cFrame3 = CFrame.new()
local n25 = 70
local u86 = nil

local function wrapAngle(p1)
	return (p1 + 3.141592653589793) % 6.283185307179586 - 3.141592653589793
end
local function smoothstep(p2)
	local v169 = math.clamp(p2, 0, 1)

	return v169 * v169 * (3 - v169 * 2)
end

local t8: {[any]: any} = { amount = 0, t0 = 0, rise = 0.05, fall = 0.2 }

local function fovKickNow()
	local v170: {[any]: any} = t8

	if v170.amount == 0 then
		return 0
	end

	local n1 = os.clock() - v170.t0

	if n1 < v170.rise then
		local amount = v170.amount
		local v173 = math.clamp(n1 / v170.rise, 0, 1)

		return amount * (v173 * v173 * (3 - v173 * 2))
	end

	local n2 = (n1 - v170.rise) / v170.fall

	if n2 >= 1 then
		v170.amount = 0

		return 0
	end

	local v175 = v170.amount
	local v176 = math.clamp(n2, 0, 1)

	return v175 * (1 - v176 * v176 * (3 - v176 * 2))
end
local function isMouseUnlocked()
	local u177: boolean = true

	if next(t2) == nil then
		u177 = guiService.MenuIsOpen
	end

	return u177
end
local function combatModeOn()
	local combatMode: any = LocalPlayer:GetAttribute("CombatMode")

	if combatMode == nil then
		return LocalPlayer:GetAttribute("State") == "Match"
	end

	return combatMode == true
end
local function getCharacterParts()
	local localPlayerCharacter = LocalPlayer and LocalPlayer.Character

	if not localPlayerCharacter then
		return nil, nil, nil
	end

	local humanoidRootPart = localPlayerCharacter:FindFirstChild("HumanoidRootPart")
	local humanoid = localPlayerCharacter:FindFirstChildOfClass("Humanoid")
	local v182 = humanoidRootPart and humanoidRootPart:IsA("BasePart")

	return localPlayerCharacter, v182 and humanoidRootPart or nil, humanoid
end
local function yawOf(p3)
	local lookVector = p3.LookVector

	return (math.atan2(-lookVector.X, -lookVector.Z))
end
local function drawnCharacter(p4)
	return smoothing.DrawnModel() or p4
end

local t9: {[any]: any} = {}
local u97: boolean = true
local n26 = 0
local u99 = nil
local u100: boolean = true
local t10: {[any]: any} = { "FX", "Projectiles" }

local function markIgnoreDirty()
	u97 = true
end
local function ignoreList(p5)
	local v187 = os.clock()

	if u97 or p5 ~= u99 or v187 - n26 > 2 then
		table.clear(t9)

		if p5 then
			table.insert(t9, p5)
		end

		for key, value in t10 do
			local foundChild: Instance = workspace:FindFirstChild(value)

			if foundChild then
				table.insert(t9, foundChild)
			end
		end

		for iterFirst, iterSecond in players:GetPlayers() do
			if iterSecond.Character and p5 ~= iterSecond.Character then
				table.insert(t9, iterSecond.Character)
			end
		end

		fighters.EachTagged(function(p6)
			if p6 ~= p5 then
				table.insert(t9, p6)
			end
		end)
		u97 = false
		u99 = p5
		n26 = v187
		occlusion.IgnoreChanged()
		u100 = true
	end

	return t9
end
local function watchPlayerForIgnore(player)
	player.CharacterAdded:Connect(markIgnoreDirty)
	player.CharacterRemoving:Connect(markIgnoreDirty)
end
local function castDistance(p8, p9, p10)
	return occlusion.Cast(p8, p9, p10)
end

local t11: {[any]: any} = {}
local u107: boolean = true
local t12: {[any]: any} = {}
local n27: number = -1
local n28 = -1
local u111: boolean = false
local u112: boolean = false
local bindableEvent: BindableEvent = Instance.new("BindableEvent")
local u114 = nil
local n29 = 0

local function isHeadAccessoryPart(p11, p12)
	for iterFirst, iterSecond in p11:GetChildren() do
		if iterSecond:IsA("Attachment") and p12:FindFirstChild(iterSecond.Name) then
			return true
		end
	end

	return false
end
local function rebuildFadeEntries(p13)
	table.clear(t11)

	local head = p13:FindFirstChild("Head")

	for iterFirst, iterSecond in p13:GetDescendants() do
		if iterSecond:IsA("BasePart") or iterSecond:IsA("Decal") then
			local u205 = false

			if head and head:IsA("BasePart") then
				if iterSecond == head or head == iterSecond.Parent then
					u205 = true
				elseif iterSecond:IsA("BasePart") and iterSecond.Parent and iterSecond.Parent:IsA("Accessory") then
					u205 = isHeadAccessoryPart(iterSecond, head)
				end
			end

			table.insert(t11, { inst = iterSecond, head = u205 })
		end
	end

	u107 = false
end
local function restoreAll(p14)
	for iterFirst, iterSecond in p14 do
		local inst = iterSecond.inst

		if inst.Parent and inst.LocalTransparencyModifier ~= 0 then
			inst.LocalTransparencyModifier = 0
		end
	end
end
local function setCharacterFade(p15, p16: number, p17, p18)
	if p16 < 0.01 then
		p16 = 0
	end

	local v214 = math.max(p16, p17 or 0)

	if v214 < 0.01 then
		v214 = 0
	end

	if p15 ~= u114 then
		for key, value in t11 do
			local inst = value.inst

			if inst.Parent and inst.LocalTransparencyModifier ~= 0 then
				inst.LocalTransparencyModifier = 0
			end
		end

		for key2, value2 in t12 do
			value2:Disconnect()
		end

		table.clear(t12)
		table.clear(t11)
		u114 = p15
		u107 = true
		n27 = -1
		n28 = -1
		u111 = false

		if p15 then
			table.insert(t12, p15.DescendantAdded:Connect(function(p19)
				u107 = true

				if p19:IsA("BasePart") or p19:IsA("Decal") then
					p19.LocalTransparencyModifier = if u111 then 1 else math.max(n27, 0)
				end
			end))
			table.insert(t12, p15.DescendantRemoving:Connect(function()
				u107 = true
			end))
		end
	end

	if not p15 then
		return
	end

	local v220: boolean = u107

	if u107 then
		rebuildFadeEntries(p15)
	end

	local v221 = os.clock()
	local v222: boolean = v220 or v221 - n29 > 0.25
	local u223: boolean = true

	if not (math.abs(p16 - n27) >= 0.02) then
		u223 = true

		if not (math.abs(v214 - n28) >= 0.02) then
			if p16 == 0 then
				u223 = true

				if n27 == 0 then
					if v214 == 0 then
						u223 = true

						if n28 == 0 then
							u223 = p18 == true ~= u111
						end
					else
						u223 = p18 == true ~= u111
					end
				end
			elseif v214 == 0 then
				u223 = true

				if n28 == 0 then
					u223 = p18 == true ~= u111
				end
			else
				u223 = p18 == true ~= u111
			end
		end
	end

	if not v222 and not u223 then
		return
	end

	n29 = v221
	n27 = p16
	n28 = v214
	u111 = p18 == true

	for key3, value3 in t11 do
		local v226 = value3.inst

		if v226.Parent then
			local localTransparencyModifier = if u111 then 1 else if value3.head then v214 else p16

			if math.abs(v226.LocalTransparencyModifier - localTransparencyModifier) > 0.001 then
				v226.LocalTransparencyModifier = localTransparencyModifier
			end
		end
	end
end

local t13: {[any]: any} = {}
local t14: {[any]: any} = { High = 1, Medium = 2, Low = 4 }
local n30 = 1
local n31: number = 0
local t15: {[any]: any} = {}
local v125 = OverlapParams.new()

v125.FilterType = Enum.RaycastFilterType.Exclude

local function clearPropFade()
	for iterValue in t13 do
		if iterValue.Parent then
			iterValue.LocalTransparencyModifier = 0
		end
	end

	table.clear(t13)
end
local function boxDistance(p20, p21)
	local v231 = p20.CFrame:PointToObjectSpace(p21)
	local n1 = p20.Size * 0.5
	local absoluteValue = math.abs(v231.X)
	local v234 = math.max(absoluteValue - n1.X, 0)
	local absoluteValue2 = math.abs(v231.Y)
	local v236 = math.max(absoluteValue2 - n1.Y, 0)
	local absoluteValue3 = math.abs(v231.Z)
	local v238 = math.max(absoluteValue3 - n1.Z, 0)

	return Vector3.new(v234, v236, v238).Magnitude
end
local function propFadeable(p22)
	if p22.Transparency >= 1 or p22:HasTag("Foliage") or p22.Size.Magnitude >= 80 then
		return false
	end

	local v240 = p22.Size
	local v241 = math.min(v240.X, v240.Y)
	local v242 = math.max(v240.X, v240.Y)
	local v243 = math.min(v242, v240.Z)

	if math.max(v241, v243) >= 6 then
		return false
	end

	local v244 = p22:FindFirstAncestorWhichIsA("Model")

	while v244 do
		if v244:FindFirstChildOfClass("Humanoid") or v244:HasTag("BearTrap") then
			return false
		end

		v244 = v244:FindFirstAncestorWhichIsA("Model")
	end

	return true
end
local function markProp(p23)
	t15[p23] = true

	if not t13[p23] then
		t13[p23] = true
		p23.LocalTransparencyModifier = 0.7
	end
end

local raycastParams = RaycastParams.new()

raycastParams.FilterType = Enum.RaycastFilterType.Exclude

local function updatePropFade(p24, p25, filterDescendantsInstances)
	if u100 then
		v125.FilterDescendantsInstances = filterDescendantsInstances
		u100 = false
	end

	table.clear(t15)

	local ok, result = pcall(function()
		return workspace:GetPartBoundsInRadius(p24, 4.2, v125)
	end)

	if ok then
		for iterFirst, iterSecond in result do
			if iterSecond.Position.Y + iterSecond.Size.Y / 2 > p24.Y - 1 and propFadeable(iterSecond) and boxDistance(iterSecond, p24) <= (if t13[iterSecond] then 0.7 else 0) + 3.5 then
				t15[iterSecond] = true

				if not t13[iterSecond] then
					t13[iterSecond] = true
					iterSecond.LocalTransparencyModifier = 0.7
				end
			end
		end
	end

	if p25 then
		raycastParams.FilterDescendantsInstances = filterDescendantsInstances

		local v253 = p24

		for _ = 1, 4 do
			local n1 = p25 - v253

			if n1.Magnitude < 0.05 then
				break
			end

			local v256 = workspace:Raycast(v253, n1, raycastParams)

			if not v256 then
				break
			end

			n1 = v256.Instance

			if n1:IsA("BasePart") and occlusion.Classify(n1) == 2 and propFadeable(n1) then
				t15[n1] = true

				if not t13[n1] then
					t13[n1] = true
					n1.LocalTransparencyModifier = 0.7
				end
			end

			raycastParams:AddToFilter(n1)
			v253 = v256.Position
		end
	end

	for iterValue in t13 do
		if not t15[iterValue] then
			t13[iterValue] = nil

			if iterValue.Parent then
				iterValue.LocalTransparencyModifier = 0
			end
		end
	end
end
local function totalModifier()
	local n1 = 0
	local n2 = 0
	local vectorValue = Vector3.new(0, 0, 0)
	local n3 = 1

	for key, value in t5 do
		n1 += value.fov or 0
		n2 += value.distance or 0
		vectorValue += value.pivot or Vector3.new(0, 0, 0)
		n3 *= value.sensitivity or 1
	end

	return n1, n2, vectorValue, n3
end
local function applyMouseBehavior()
	if u31 and not u63 then
		local u264: boolean = true

		if next(t2) == nil then
			u264 = guiService.MenuIsOpen
		end

		if u264 then
			if userInputService.MouseBehavior ~= Enum.MouseBehavior.Default then
				userInputService.MouseBehavior = Enum.MouseBehavior.Default
			end

			if not userInputService.MouseIconEnabled then
				userInputService.MouseIconEnabled = true

				return
			end
		else
			if userInputService.MouseBehavior ~= Enum.MouseBehavior.LockCenter then
				userInputService.MouseBehavior = Enum.MouseBehavior.LockCenter
			end

			if userInputService.MouseIconEnabled then
				userInputService.MouseIconEnabled = false
			end
		end

		return
	end
end
local function releaseAutoRotate(_)
	u61 = false

	if u62 then
		simulation.SetFacing(nil)
		u62 = false
	end
end

local t16: {[any]: any} = {
	[Enum.HumanoidStateType.Running] = true,
	[Enum.HumanoidStateType.RunningNoPhysics] = true,
	[Enum.HumanoidStateType.Jumping] = true,
	[Enum.HumanoidStateType.Freefall] = true,
	[Enum.HumanoidStateType.Landed] = true,
	[Enum.HumanoidStateType.GettingUp] = true
}

local function updateCharacterRotation(p28, p29, p30, p31)
	local u270: boolean = not p31

	if u270 then
		u270 = false

		if next(t4) == nil then
			u270 = false

			if p30.Health > 0 then
				u270 = not p29.Anchored

				if u270 then
					u270 = false

					if t16[p30:GetState()] == true then
						u270 = false

						if p30.Sit == false then
							u270 = p30.PlatformStand == false
						end
					end
				end
			end
		end
	end

	if not u270 then
		u61 = false

		if u62 then
			simulation.SetFacing(nil)
			u62 = false
		end

		return
	end

	u62 = true

	local v271, v272, v273 = smoothing.SimCFrame(p29):ToEulerAnglesYXZ()
	local n3 = (n1 - v272 + 3.141592653589793) % 6.283185307179586 - 3.141592653589793
	local u275: boolean = p30.MoveDirection.Magnitude > 0.05

	u270 = p29.Parent ~= nil and p29.Parent:FindFirstChildOfClass("Tool") ~= nil

	local u276: boolean = u275 or u270 or u26 or u112

	if not u276 then
		if math.abs(n3) > 1.7453292519943295 then
			u61 = true
		end

		if u61 and math.abs(n3) < 0.06981317007977318 then
			u61 = false
		end

		u276 = u61
	else
		u61 = false
	end

	if not u276 then
		simulation.SetFacing(v272)

		return
	end

	local n2: number = -(if u112 then 40 else if not u26 and not u270 then if u275 then 18 else 12 else 30)
	local v278 = math.max(p28, 0.016666666666666666)
	local v279 = math.exp(n2 * v278)

	simulation.SetFacing(v272 + n3 * (1 - v279))
end

local t17: {[any]: any} = {
	Vector3.new(-1, -1, -1),
	Vector3.new(-1, -1, 1),
	Vector3.new(-1, 1, -1),
	Vector3.new(-1, 1, 1),
	Vector3.new(1, -1, -1),
	Vector3.new(1, -1, 1),
	Vector3.new(1, 1, -1),
	Vector3.new(1, 1, 1)
}

local function headCrowdsCrosshair(p32, p33)
	local n1 = p32.ViewportSize / 2
	local v283 = math.max(p32.ViewportSize.Y, 200)
	local n2 = (if p33 then 40 else 16) * v283 / 768

	for key, value in t11 do
		local inst = value.inst

		if value.head and inst:IsA("BasePart") and inst.Parent then
			local instCFrame = inst.CFrame
			local n3 = inst.Size / 2
			local n4 = math.huge
			local n5 = math.huge
			local n6 = -math.huge
			local n7 = -math.huge

			for key2, value2 in t17 do
				local v296 = p32:WorldToViewportPoint(instCFrame:PointToWorldSpace(n3 * value2))

				if v296.Z > 0 then
					n4 = math.min(n4, v296.X)
					n6 = math.max(n6, v296.X)
					n5 = math.min(n5, v296.Y)
					n7 = math.max(n7, v296.Y)
				end
			end

			if n4 <= n6 then
				local v297 = math.max(n4 - n1.X, 0, n1.X - n6)
				local v298 = math.max(n5 - n1.Y, 0, n1.Y - n7)

				if v297 * v297 + v298 * v298 < n2 * n2 then
					return true
				end
			end
		end
	end

	return false
end
local function frameSubject(p34, p35, p36, p37)
	if not finite.Vector(p36) then
		return cFrame3, cFrame3.Position + cFrame3.LookVector * 10
	end

	if p35 ~= u60 or u59 == nil or (p36 - u59).Magnitude > 40 then
		v42:Snap(p36.Y)
		occlusion.Reset()
		u60 = p35
	end

	u59 = p36
	v42.target = p36.Y
	v42:Update(p34)

	local v303 = math.clamp(v42.value, p36.Y - 1.5, p36.Y + 1.5)

	v42.value = v303

	local v304 = CFrame.fromEulerAnglesYXZ(0, n1, 0)
	local n4 = v44.value + module.SlowRecoil.value
	local v306 = CFrame.fromEulerAnglesYXZ(n2 + n4.X, n1 + n4.Y, n4.Z)
	local lookVector = v306.LookVector
	local value = v39.value
	local vector3 = Vector3.new(p36.X, v303 + 3.1 + v43.value, p36.Z)
	local v310 = v304:VectorToWorldSpace(v41.value)
	local vector32 = Vector3.new(p36.X, p36.Y + 0.5, p36.Z)
	local v312, v313, v314 = occlusion.Frame(p34, vector32, vector3 + v310, v304.RightVector, lookVector, v40.value, value, p37)

	n19 = occlusion.Side(v314, v304.RightVector, 2.9, n3, p37)

	return CFrame.new(v312) * v306.Rotation, v313
end
local function applyShake(p38, p39, p40)
	local n1 = 0

	for i = #t6, 1, -1 do
		local v320 = t6[i]

		v320.t = v320.t + p39

		if v320.t >= v320.duration then
			table.remove(t6, i)
		else
			local n2 = 1 - v320.t / v320.duration

			n1 += v320.intensity * n2 * n2
		end
	end

	if n1 <= 0 then
		return p38
	end

	local n3 = math.min(n1, 3) * (p40 or 1)
	local n4 = os.clock() * 17
	local n5 = n3 * 0.022689280275926284
	local v325 = math.noise(n4, 0.37, 1.1)
	local v326 = math.noise(3.1, n4, 7.3)
	local v327 = math.noise(9.2, 4.4, n4)
	local v328 = math.noise(n4, 11.3, 2.9)
	local v329 = math.noise(5.5, n4, 13.7)
	local cFrame4 = CFrame.new(v328 * 0.12 * n3, v329 * 0.12 * n3, 0)
	local v331 = CFrame.Angles(v325 * 2 * n5, v326 * 2 * n5, v327 * 1.2 * n5)

	return p38 * cFrame4 * v331
end
local function focusPointOf(p41)
	local head = p41:FindFirstChild("Head")

	if head and head:IsA("BasePart") then
		return head.Position - Vector3.new(0, 0.6, 0)
	end

	local humanoidRootPart = p41:FindFirstChild("HumanoidRootPart")

	if humanoidRootPart and humanoidRootPart:IsA("BasePart") then
		return humanoidRootPart.Position + Vector3.new(0, 1, 0)
	end

	return nil
end

local v142 = OverlapParams.new()

v142.FilterType = Enum.RaycastFilterType.Exclude
v142.RespectCanCollide = true

local function spotIsFree(p42, filterDescendantsInstances)
	v142.FilterDescendantsInstances = filterDescendantsInstances

	local ok, result = pcall(function()
		return workspace:GetPartBoundsInRadius(p42, 0.6, v142)
	end)

	return ok and #result == 0
end

local u144 = nil
local u145 = nil
local n32 = 0

local function sees(p44, p45, p46)
	return occlusion.Cast(p44, p45, p46) >= (p45 - p44).Magnitude - 0.5
end
local function pickDeathSpot(p47, p48, filterDescendantsInstances)
	local v345 = u145

	if v345 and occlusion.Cast(v345, p48, filterDescendantsInstances) >= (p48 - v345).Magnitude - 0.5 then
		return v345
	end

	local vector3 = Vector3.new(p47.X - p48.X, 0, p47.Z - p48.Z)

	vector3 = if vector3.Magnitude > 0.1 then vector3.Unit else Vector3.new(0, 0, 1)

	for index, value in {
		p47,
		p47 + Vector3.new(0, 7, 0),
		p47 + Vector3.new(0, 14, 0),
		p48 + vector3 * 16 + Vector3.new(0, 8, 0),
		p48 + vector3 * 11 + Vector3.new(0, 4, 0),
		p48 + vector3 * 14 + Vector3.new(0, 18, 0)
	}, nil, nil do
		if occlusion.Cast(value, p48, filterDescendantsInstances) >= (p48 - value).Magnitude - 0.5 then
			if index == 1 then
				return value
			end

			v142.FilterDescendantsInstances = filterDescendantsInstances

			local ok, result = pcall(function()
				return workspace:GetPartBoundsInRadius(value, 0.6, v142)
			end)

			if ok and #result == 0 then
				return value
			end
		end
	end

	return p47 + Vector3.new(0, 10, 0)
end
local function deathView(p50)
	local v352 = spectate.DeathElapsed()
	local v353 = math.clamp(v352 / 0.35, 0, 1)
	local n1 = v353 * v353 * (3 - v353 * 2)

	v352 = cFrame2
	v353 = spectate.GetKiller()

	local v355 = if v353 and v353.Parent then focusPointOf(v353) else nil
	local v356 = n5
	local v357

	if v355 then
		local v358 = os.clock()

		if u145 == nil or v358 - n32 > 0.25 then
			n32 = v358

			local v359 = v352.Position
			local v360 = ignoreList(LocalPlayer.Character)

			u145 = pickDeathSpot(v359, v355, v360)
		end

		v357 = u145
	else
		v357 = v352.Position + Vector3.new(0, 3, 0)
		v355 = spectate.GetDeathPosition() or v352.Position + v352.LookVector * 10
	end

	if u144 == nil then
		u144 = v352.Position
	end

	local v361 = u144
	local v362 = math.exp(p50 * -5)

	u144 = v361:Lerp(v357, 1 - v362)

	local v363 = u144

	v361 = v355

	if v353 and v353.Parent then
		local v364 = math.max((v361 - v363).Magnitude, 1)
		local v365 = math.atan(9 / v364)
		local v366 = math.deg(v365)

		v356 = math.clamp(v366 * 2, 35, n5)
	end

	if u80 == nil then
		u80 = v361
	else
		local v367 = u80
		local v368 = math.exp(p50 * -8)

		u80 = v367:Lerp(v361, 1 - v368)
	end

	v361 = u80

	local v369

	if (v361 - v363).Magnitude > 0.1 then
		v369 = CFrame.lookAt(v363, v361)
	else
		v369 = CFrame.new(v363) * v352.Rotation
	end

	return v352.Rotation:Lerp(v369.Rotation, n1) + v363, n22 + (v356 - n22) * n1
end
local function readLookInput(p51, p52, p53)
	local n6 = n7 * p53

	if u26 then
		local v374 = math.clamp(n4 / n5, 0.35, 1)

		n6 *= v374
	end

	if not p52 then
		if userInputService.MouseBehavior == Enum.MouseBehavior.LockCenter and userInputService:GetLastInputType() ~= Enum.UserInputType.Touch then
			local v375: Vector2 = userInputService:GetMouseDelta()
			local n8 = 0.006283185307179587 * n6

			n1 -= v375.X * n8
			n2 -= v375.Y * n8
		end

		local v377 = u72
		local v378 = aimAssist.TakeInjected()

		u72 = v377 + v378

		local v379, v380 = module.PadLook.Step(vector2Zero, p51, u26)

		v378 = v380 * (n6 / n7)
		v377 = v379 * (n6 / n7) - u72.X * 0.01745 * n6

		local n3 = -u72.Y * 0.01745 * 0.66 * n6

		if n3 * n2 > 0 then
			local absoluteValue = math.abs(n2)
			local v383 = math.min(absoluteValue, 1.5707963267948966)

			n3 *= (1 - (v383 * 2 / 3.141592653589793) ^ 0.75) * 0.75 + 0.25
		end

		local aimAssistApply = aimAssist.Apply
		local v385 = n1
		local v386 = n2
		local combatMode: any = LocalPlayer:GetAttribute("CombatMode")
		local u388: boolean = if combatMode == nil then LocalPlayer:GetAttribute("State") == "Match" else combatMode == true
		local v389 = ignoreList(LocalPlayer.Character)
		local v390, v391 = aimAssistApply(p51, v377, v378 + n3, v385, v386, u388, v389, u26, n4, t5.CombatDraw ~= nil)

		n1 += v390
		n2 += v391

		local v392: number = n20
		local absoluteValue = math.abs(u72.X)
		local absoluteValue4 = math.abs(u72.Y)

		n20 = v392 + (absoluteValue + absoluteValue4)
	end

	u72 = Vector2.zero
	n1 = (n1 + 3.141592653589793) % 6.283185307179586 - 3.141592653589793
	n6 = 1.361356816555577

	for key, value in t5 do
		if value.maxPitch and n6 > value.maxPitch then
			n6 = value.maxPitch
		end
	end

	if n6 < n2 then
		local v397 = n2
		local n9 = n6 - n2
		local v399 = math.exp(p51 * -5)

		n2 = v397 + n9 * (1 - v399)
	end

	n2 = math.clamp(n2, -1.3962634015954636, 1.361356816555577)
end
local function resetToOwnCharacter()
	local localPlayerCharacter = LocalPlayer and LocalPlayer.Character
	local v401

	if not localPlayerCharacter then
		v401 = nil
	else
		local humanoidRootPart = localPlayerCharacter:FindFirstChild("HumanoidRootPart")

		localPlayerCharacter:FindFirstChildOfClass("Humanoid")
		v401 = humanoidRootPart and humanoidRootPart:IsA("BasePart") and humanoidRootPart or nil
	end

	if v401 then
		local lookVector = v401.CFrame.LookVector

		n1 = math.atan2(-lookVector.X, -lookVector.Z)
		n2 = -0.20943951023931956
	end

	u59 = nil
	u60 = nil
	u80 = nil
	u81 = nil
	n24 = 1
	u86 = nil
end
local function setLobby(p54, p55, cameraSubject)
	u63 = p54

	local localPlayerCharacter = LocalPlayer and LocalPlayer.Character
	local v408

	if not localPlayerCharacter then
		v408 = nil
	else
		local humanoidRootPart = localPlayerCharacter:FindFirstChild("HumanoidRootPart")

		localPlayerCharacter:FindFirstChildOfClass("Humanoid")
		v408 = humanoidRootPart and humanoidRootPart:IsA("BasePart") and humanoidRootPart or nil
	end

	if u69 then
		CFrame2 = p55.CFrame
		n17 = p55.FieldOfView
		n18 = 0
		u68 = v408 and v408.Position
	end

	module.PopMouseUnlock("FreeCursor")

	if p54 then
		u26 = false
		table.clear(t6)
		v44:Snap(Vector3.new(0, 0, 0))
		module.SlowRecoil:Snap(Vector3.new(0, 0, 0))
		module.SlowRecoilStay = Vector3.new(0, 0, 0)
		v43:Snap(0)
		u61 = false

		if u62 then
			simulation.SetFacing(nil)
			u62 = false
		end

		local n3: number = 0

		if n3 < 0.01 then
			n3 = 0
		end

		if math.max(n3, 0) < 0.01 then
		end

		if u114 ~= nil then
			for key, value in t11 do
				local inst = value.inst

				if inst.Parent and inst.LocalTransparencyModifier ~= 0 then
					inst.LocalTransparencyModifier = 0
				end
			end

			for key2, value2 in t12 do
				value2:Disconnect()
			end

			table.clear(t12)
			table.clear(t11)
			u114 = nil
			u107 = true
			n27 = -1
			n28 = -1
			u111 = false
		end

		for iterValue in t13 do
			if iterValue.Parent then
				iterValue.LocalTransparencyModifier = 0
			end
		end

		table.clear(t13)

		if cameraSubject and cameraSubject ~= p55.CameraSubject then
			p55.CameraSubject = cameraSubject
		end

		p55.CameraType = Enum.CameraType.Custom
		userInputService.MouseBehavior = Enum.MouseBehavior.Default
		userInputService.MouseIconEnabled = true

		return
	end

	local lookVector = p55.CFrame.LookVector

	n1 = math.atan2(-lookVector.X, -lookVector.Z)

	local v418 = math.clamp(lookVector.Y, -1, 1)
	local v419 = math.asin(v418)

	n2 = math.clamp(v419, -0.6981317007977318, 0.4363323129985824)
	u59 = nil
	u60 = nil
	u61 = false
end
local function updateLobby(p57, p58, p59, cameraSubject)
	if next(t3) == nil then
		if cameraSubject and cameraSubject.Parent and cameraSubject ~= p58.CameraSubject then
			p58.CameraSubject = cameraSubject
		end

		if p58.CameraType == Enum.CameraType.Scriptable then
			p58.CameraType = Enum.CameraType.Custom
		end

		u72 = Vector2.zero

		local v424 = totalModifier()

		v38.target = n5 + v424
		v38:Update(p57)
		v424 = math.clamp(v38.value, 20, 110)

		local v425 = p58.CFrame

		if u64 then
			u64 = false

			local FocusPosition = p58.Focus.Position
			local v427 = math.clamp((v425.Position - FocusPosition).Magnitude, 6, 40)
			local cFrame5 = CFrame.new(FocusPosition)
			local v429 = CFrame.fromEulerAnglesYXZ(n2, n1, 0)
			local cFrame6 = CFrame.new(0, 0, v427)

			v425 = cFrame5 * v429 * cFrame6
			p58.CFrame = v425
		else
			local lookVector = v425.LookVector

			n1 = math.atan2(-lookVector.X, -lookVector.Z)

			local v432 = math.clamp(lookVector.Y, -1, 1)

			n2 = math.asin(v432)
		end

		if n18 < 1 and CFrame2 then
			if p59 and u68 and (p59.Position - u68).Magnitude > 40 then
				n18 = 1
			else
				n18 = math.min(1, n18 + p57 / 0.5)

				local v433 = math.clamp(n18, 0, 1)
				local n3 = v433 * v433 * (3 - v433 * 2)

				v433 = CFrame2:Lerp(v425, n3)
				v424 = n17 + (v424 - n17) * n3
				p58.CFrame = v433
			end
		end

		local v435 = smoothing.CameraOffset()

		if v435 ~= Vector3.new(0, 0, 0) then
			p58.CFrame = p58.CFrame + v435
			p58.Focus = p58.Focus + v435
		end

		local cFrame = occlusion.AboveWater(p58.CFrame)

		if cFrame ~= p58.CFrame then
			p58.CFrame = cFrame
		end

		p58.FieldOfView = v424
		cFrame3 = cFrame
		n25 = v424
		u69 = true

		return
	end

	p58.CameraType = Enum.CameraType.Scriptable
	u72 = Vector2.zero
end
local function update(p61)
	guards.Step()

	if not u31 then
		u112 = false

		return
	end

	local v438 = if p61 == p61 and p61 > 0 then math.min(p61, 0.1) else 0.016666666666666666
	local CurrentCamera: Camera = workspace.CurrentCamera

	if not CurrentCamera then
		return
	end

	local localPlayerCharacter = LocalPlayer and LocalPlayer.Character
	local v441
	local v442
	local v443

	if not localPlayerCharacter then
		v441 = nil
		v442 = nil
		v443 = nil
	else
		local humanoidRootPart = localPlayerCharacter:FindFirstChild("HumanoidRootPart")
		local humanoid = localPlayerCharacter:FindFirstChildOfClass("Humanoid")

		v441 = localPlayerCharacter
		v442 = humanoidRootPart and humanoidRootPart:IsA("BasePart") and humanoidRootPart or nil
		v443 = humanoid
	end

	u112 = false

	local v446 = if v442 then v442.Position else nil

	if v446 and not finite.Vector(v446) then
		finite.Say("own root")
		v446 = nil
	end

	local v447 = s1

	s1 = spectate.Step(v446 or u59)

	if v447 ~= s1 then
		if s1 == "death" then
			cFrame2 = cFrame3
			n22 = n25
			u80 = nil
			u144 = nil
			u145 = nil
			u26 = false
			table.clear(t6)
		elseif s1 == "follow" then
			u81 = cFrame3
			n23 = n25
			n24 = 0
			u86 = nil
		else
			local character = LocalPlayer and LocalPlayer.Character
			local v449

			if not character then
				v449 = nil
			else
				local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")

				character:FindFirstChildOfClass("Humanoid")
				v449 = humanoidRootPart and humanoidRootPart:IsA("BasePart") and humanoidRootPart or nil
			end

			if v449 then
				local lookVector = v449.CFrame.LookVector

				n1 = math.atan2(-lookVector.X, -lookVector.Z)
				n2 = -0.20943951023931956
			end

			u59 = nil
			u60 = nil
			u80 = nil
			u81 = nil
			n24 = 1
			u86 = nil
		end

		if s1 == "follow" then
			module.PushMouseUnlock("Spectate")
		else
			module.PopMouseUnlock("Spectate")
		end

		spectateKeys.SetActive(s1 == "follow", module.SpectateNext)
		n18 = 1
	end

	v447 = false

	if s1 == "none" then
		local combatMode: any = LocalPlayer:GetAttribute("CombatMode")

		v447 = not (if combatMode == nil then LocalPlayer:GetAttribute("State") == "Match" else combatMode == true)

		if v447 then
			v447 = false

			if n13 == 0 then
				v447 = n12 == 0
			end
		end
	end

	if v447 ~= u63 then
		setLobby(v447, CurrentCamera, v443)
	end

	if u63 then
		updateLobby(v438, CurrentCamera, v442, v443)
		fades.ClearAllies()

		local v453 = smoothing.DrawnModel() or v441
		local v454 = v453 and v453:FindFirstChild("Head")
		local fadesUpdateDecor = fades.UpdateDecor
		local CFramePosition = CurrentCamera.CFrame.Position
		local v457 = v454 and v454:IsA("BasePart")

		fadesUpdateDecor(CFramePosition, if v457 then v454.Position else nil)

		return
	end

	if CurrentCamera.CameraType ~= Enum.CameraType.Scriptable then
		CurrentCamera.CameraType = Enum.CameraType.Scriptable
	end

	applyMouseBehavior()

	local u458: boolean = true

	if next(t2) == nil then
		u458 = guiService.MenuIsOpen
	end

	local v459, v460, v461, v462 = totalModifier()

	if s1 == "none" and next(t3) == nil then
		readLookInput(v438, u458, v462)
	else
		u72 = Vector2.zero
	end

	if not finite.Number(n1) then
		finite.Say("yaw")
		n1 = 0
	end

	if not finite.Number(n2) then
		finite.Say("pitch")
		n2 = -0.20943951023931956
	end

	finite.HealSpring(v38, 70, "fov")
	finite.HealSpring(v39, 10.5, "distance")
	finite.HealSpring(v40, 2.9, "shoulder")
	finite.HealSpring(v41, Vector3.new(0, 0, 0), "pivot")
	finite.HealSpring(v42, if v446 then v446.Y else 0, "height")
	finite.HealSpring(v43, 0, "dip")
	finite.HealSpring(v44, Vector3.new(0, 0, 0), "recoil")
	finite.HealSpring(module.SlowRecoil, Vector3.new(0, 0, 0), "slow recoil")

	local u463: boolean = s1 ~= "none"

	v38.target = if u26 then n4 else if u463 then n5 else n5 + v459
	v39.target = if u26 then math.clamp(50 / n4, 1, 1.6) * 8 + v460 else if u463 then 10.5 else n6 + v460
	v40.target = (if u26 then 2.8 else 2.9) * n19
	v41.target = if u463 then Vector3.new(0, 0, 0) else v461
	v38:Update(v438)
	v39:Update(v438)
	v40:Update(v438)
	v41:Update(v438)
	v43:Update(v438)
	v44:Update(v438)

	local slowRecoil = module.SlowRecoil
	local slowRecoilTarget = slowRecoil.target
	local v466 = math.exp(-v438 / module.SLOW_RECOIL_FADE)

	slowRecoil.target = slowRecoilTarget * v466
	slowRecoil:Update(v438)

	local slowRecoilStay = module.SlowRecoilStay

	if slowRecoilStay.Magnitude > 0.00001 then
		local v468 = math.exp(-v438 * 14)
		local n20 = slowRecoilStay * (1 - v468)

		n2 = math.clamp(n2 + n20.X, -1.3962634015954636, 1.361356816555577)
		n1 = (n1 + n20.Y + 3.141592653589793) % 6.283185307179586 - 3.141592653589793
		module.SlowRecoilStay = slowRecoilStay - n20
	else
		module.SlowRecoilStay = Vector3.new(0, 0, 0)
	end

	local v471
	local v473
	local n21

	if s1 == "death" then
		local v476, v477 = deathView(v438)

		v471 = v476
		v473 = v477
		n21 = v471.Position + v471.LookVector * 10
		u61 = false

		if u62 then
			simulation.SetFacing(nil)
			u62 = false
		end

		local v478 = smoothing.DrawnModel()

		setCharacterFade(v478 or v441, 0, 0)
	elseif s1 == "follow" then
		local v479 = spectate.GetTarget()
		local v480 = v479

		if v480 then
			v480 = v479:FindFirstChild("HumanoidRootPart")
		end

		u61 = false

		if u62 then
			simulation.SetFacing(nil)
			u62 = false
		end

		local v481 = smoothing.DrawnModel()

		setCharacterFade(v481 or v441, 0, 0)

		if v479 and v480 and v480:IsA("BasePart") and (not not finite.Vector(v480.Position) and not not finite.Vector(v480.CFrame.LookVector) or not not finite.Say("follow root")) then
			if v479 ~= u86 then
				if u86 ~= nil then
					u81 = cFrame3
					n23 = n25
					n24 = 0
				end

				u86 = v479

				local v482 = v480.CFrame.LookVector

				n1 = math.atan2(-v482.X, -v482.Z)
				n2 = -0.17453292519943295
			end

			local v483 = n1
			local v484 = v480.CFrame.LookVector
			local n3 = (math.atan2(-v484.X, -v484.Z) - n1 + 3.141592653589793) % 6.283185307179586 - 3.141592653589793
			local v486 = math.exp(v438 * -4)

			n1 = (v483 + n3 * (1 - v486) + 3.141592653589793) % 6.283185307179586 - 3.141592653589793

			local v487 = n2

			v483 = -0.17453292519943295 - n2
			n3 = math.exp(v438 * -3)
			n2 = v487 + v483 * (1 - n3)
			v487 = ignoreList(v479)

			local v488, v489 = frameSubject(v438, v479, v480.Position, v487)

			v471 = v488
			n21 = v489
			v473 = math.clamp(v38.value, 20, 110)
		else
			v471 = cFrame3
			v473 = n25
			n21 = v471.Position + v471.LookVector * 10
		end

		if n24 < 1 and u81 then
			n24 = math.min(1, n24 + v438 / 0.45)

			local v490 = math.clamp(n24, 0, 1)
			local n26 = v490 * v490 * (3 - v490 * 2)

			v471 = u81:Lerp(v471, n26)
			v473 = n23 + (v473 - n23) * n26
		end
	else
		if not v442 or not v441 or not v446 then
			return
		end

		if v443 then
			updateCharacterRotation(v438, v442, v443, u458)
		end

		local v492 = ignoreList(v441)
		local v493 = finite.Offset(smoothing)
		local n27 = v446 + v493
		local v494, v495 = frameSubject(v438, v441, n27, v492)
		local v496 = v494

		n21 = v495
		v492 = firstPerson.Step(v438, n13 == 0 and n12 == 0 and v443 ~= nil and v443.Health > 0)
		u112 = v492 >= 0.5

		if v492 > 0 then
			local head = v441:FindFirstChild("Head")
			local firstPersonStepBob = firstPerson.StepBob
			local u499 = v443 ~= nil and v443.FloorMaterial ~= Enum.Material.Air
			local sliding = v441:GetAttribute("Sliding")

			firstPersonStepBob(v438, n27, u499, sliding == true)

			local v501, v502 = firstPerson.CameraBob()
			local firstPersonEye = firstPerson.Eye
			local v504 = head and head:IsA("BasePart")

			u499 = firstPersonEye(v438, n27, v442, if v504 then head else nil, v496.LookVector)

			local vector3 = Vector3.new(0, v43.value * 0.5 + v501, 0)
			local n28 = u499 + vector3

			u499 = CFrame.new(n28) * v496.Rotation

			local v507 = CFrame.Angles(0, 0, v502)
			local n7 = u499 * v507
			local v509 = firstPerson.Eased()

			if v509 >= 1 then
				v496 = n7
			else
				v496 = v496:Lerp(n7, v509)
			end

			n21 = n21:Lerp(n28 + v496.LookVector * 10, v509)
		end

		v471 = applyShake(v496, v438, if u112 then 0.6 else 1)
		v473 = math.clamp(v38.value, 20, 110)

		if n18 < 1 and CFrame2 then
			if u68 and (v442.Position - u68).Magnitude > 40 then
				n18 = 1
			else
				n18 = math.min(1, n18 + v438 / 0.5)

				local v510 = math.clamp(n18, 0, 1)
				local n8 = v510 * v510 * (3 - v510 * 2)

				v471 = CFrame2:Lerp(v471, n8)
				v473 = n17 + (v473 - n17) * n8
			end
		end
	end

	if n13 > 0 then
		local n9 = os.clock() - n15
		local u513: boolean = n9 > 0.5 and next(t2) == nil and (not u51 or not u51.untilStopped)
		local u514: boolean = true

		if v441 == u56 then
			u514 = false

			if v443 ~= nil then
				u514 = v443.Health <= 0
			end
		end

		if u513 or u514 or n9 > 120 then
			n13 = 0
			n14 = 2.5
		end
	end

	if n13 > n12 then
		n12 = math.min(n13, n12 + v438 * n14)
	elseif n13 < n12 then
		n12 = math.max(n13, n12 - v438 * n14)
	end

	local v515 = u51

	if v515 then
		cFrame = v515.cf
		n16 = v515.fov or n16
	end

	if n12 > 0 then
		local v516 = math.clamp(n12, 0, 1)
		local n10 = v516 * v516 * (3 - v516 * 2)

		v471 = v471:Lerp(cFrame, n10)
		v473 += (n16 - v473) * n10
	elseif n13 == 0 then
		u51 = nil
	end

	if n12 <= 0 then
		v471 = occlusion.AboveWater(v471)
	end

	local v518 = fovKickNow()
	local v519 = math.clamp(v473 + v518, 20, 110)

	if not finite.Vector(v471.Position) or not finite.Vector(v471.LookVector) or not finite.Number(v519) then
		finite.Say("view " .. s1)
		v471 = cFrame3
		v519 = n25
		n21 = v471.Position + v471.LookVector * 10
	elseif not finite.Vector(n21) then
		n21 = v471.Position + v471.LookVector * 10
	end

	CurrentCamera.CFrame = v471
	CurrentCamera.Focus = CFrame.new(if n12 > 0.5 then cFrame.Position else n21)
	CurrentCamera.FieldOfView = v519
	cFrame3 = v471
	n25 = v519
	u69 = true

	if s1 == "none" then
		local v520 = smoothing.DrawnModel() or v441
		local v521 = v446 or v471.Position
		local v522 = finite.Offset(smoothing)
		local v523 = v520

		if v523 then
			v523 = v520:FindFirstChild("Head")
		end

		local v524 = if v523 and v523:IsA("BasePart") then v523.Position else v521 + v522 + Vector3.new(0, 1.5, 0)
		local magnitude = (v471.Position - v524).Magnitude

		v523 = 0

		if magnitude < 2.6 then
			v523 = math.clamp((2.6 - magnitude) / 1.6, 0, 0.85)
		end

		if v515 and v515.hide then
			v523 = math.max(v523, n12)
		end

		local n29: number = 0

		if v441 and n12 < 0.5 and not u112 and headCrowdsCrosshair(CurrentCamera, u50) then
			n29 = 0.6
		end

		u50 = n29 > 0
		v522 = n11

		local n32: number = n29 - n11
		local v528 = math.exp(v438 * -12)

		n11 = v522 + n32 * (1 - v528)

		if n29 == 0 and n11 < 0.02 then
			n11 = 0
		end

		setCharacterFade(v520, if u112 then 0 else v523, n11, u112)
		fades.UpdateAllies(v471.Position, v524, v441)
		fades.UpdateDecor(v471.Position, v524)
		n31 += 1

		if n31 >= n30 then
			n31 = 0

			local v529 = v471.Position
			local v530 = ignoreList(v441)

			updatePropFade(v529, v524, v530)
		end

		return
	end

	n31 += 1

	if n31 >= n30 then
		n31 = 0

		local v531 = v471.Position
		local v532 = ignoreList(v441)

		updatePropFade(v531, n21, v532)
	end

	fades.ClearAllies()
	fades.UpdateDecor(v471.Position, n21)
end
local function countTouches()
	local n1: number = 0

	for iterValue in t7 do
		n1 += 1
	end

	return n1
end
local function inThumbstickArea(p62)
	local playerGui: Instance = LocalPlayer:FindFirstChildOfClass("PlayerGui")
	local touchGui: Instance = playerGui and playerGui:FindFirstChild("TouchGui")
	local touchControlFrame

	if touchGui and touchGui:IsA("ScreenGui") and touchGui.Enabled then
		touchControlFrame = touchGui:FindFirstChild("TouchControlFrame")
	else
		touchControlFrame = nil
	end

	local u539: boolean = false

	for iterFirst, value in { "DynamicThumbstickFrame", "ThumbstickFrame" }, nil, nil do
		local v542 = touchControlFrame and touchControlFrame:FindFirstChild(value)

		if v542 and v542:IsA("GuiObject") and v542.Visible then
			u539 = true

			local absolutePosition = v542.AbsolutePosition
			local n1 = absolutePosition + v542.AbsoluteSize

			if p62.X >= absolutePosition.X and p62.Y >= absolutePosition.Y and p62.X <= n1.X and p62.Y <= n1.Y then
				return true
			end
		end
	end

	if u539 then
		return false
	end

	local CurrentCamera: Camera = workspace.CurrentCamera

	return CurrentCamera ~= nil and p62.X < CurrentCamera.ViewportSize.X * 0.4 and p62.Y > CurrentCamera.ViewportSize.Y / 3
end

local u157 = nil

local function onInputBegan(input, p64)
	if input.UserInputType == Enum.UserInputType.Touch and not p64 then
		local v548 = if u157 then u157.UserInputState else nil

		if v548 == Enum.UserInputState.End or v548 == Enum.UserInputState.Cancel then
			u157 = nil
		end

		if not u157 and inThumbstickArea(input.Position) then
			u157 = input
			n21 += 1

			return
		end

		t7[input] = true
		u76 = nil

		return
	end
end
local function onInputChanged(input, _)
	if input.UserInputType == Enum.UserInputType.Touch then
		if not t7[input] then
			return
		end

		guards.PruneTouches(t7)

		local n1: number = 0

		for iterValue in t7 do
			n1 += 1
		end

		if n1 == 1 then
			local v553 = u72
			local vector2 = Vector2.new(input.Delta.X, input.Delta.Y)

			u72 = v553 + vector2

			return
		end

		if n1 == 2 then
			local v555 = nil
			local v556 = nil

			for iterValue2 in t7 do
				if not v555 then
					v555 = iterValue2
				else
					v556 = iterValue2
				end
			end

			if v555 and v556 then
				local vector2 = Vector2.new(v555.Position.X, v555.Position.Y)
				local vector22 = Vector2.new(v556.Position.X, v556.Position.Y)
				local magnitude = (vector2 - vector22).Magnitude

				if u76 then
					n6 = math.clamp(n6 - (magnitude - u76) * 0.03, 7, 14)
				end

				u76 = magnitude

				return
			end
		end
	elseif input.KeyCode == Enum.KeyCode.Thumbstick2 then
		vector2Zero = Vector2.new(input.Position.X, input.Position.Y)
	end
end
local function onInputEnded(input, _)
	if input.UserInputType == Enum.UserInputType.Touch then
		if input == u157 then
			u157 = nil
		end

		t7[input] = nil
		u76 = nil
	elseif input.KeyCode == Enum.KeyCode.Thumbstick2 then
		vector2Zero = Vector2.zero
	end
end
local function start()
	if not not u32 or not v21 then
		return
	end

	u32 = true
	spectate.Start()
	smoothing.Start()
	pcall(function()
		LocalPlayer.CameraMinZoomDistance = 6
		LocalPlayer.CameraMaxZoomDistance = 40
	end)
	task.spawn(function()
		local playerScripts: Instance = LocalPlayer:WaitForChild("PlayerScripts", 30)

		if not playerScripts then
			return
		end

		local characterQualityLevel: any = playerScripts:GetAttribute("CharacterQualityLevel")

		n30 = t14[characterQualityLevel] or 1
		playerScripts:GetAttributeChangedSignal("CharacterQualityLevel"):Connect(function()
			local characterQualityLevel2: any = playerScripts:GetAttribute("CharacterQualityLevel")

			n30 = t14[characterQualityLevel2] or 1
		end)
	end)

	local CurrentCamera: Camera = workspace.CurrentCamera

	if CurrentCamera then
		local lookVector = CurrentCamera.CFrame.LookVector

		n1 = math.atan2(-lookVector.X, -lookVector.Z)
	end

	for iterFirst, iterSecond in players:GetPlayers() do
		iterSecond.CharacterAdded:Connect(markIgnoreDirty)
		iterSecond.CharacterRemoving:Connect(markIgnoreDirty)
	end

	players.PlayerAdded:Connect(function(player: Player)
		player.CharacterAdded:Connect(markIgnoreDirty)
		player.CharacterRemoving:Connect(markIgnoreDirty)
		u97 = true
	end)
	players.PlayerRemoving:Connect(markIgnoreDirty)
	fighters.OnTaggedChanged(markIgnoreDirty)
	userInputService.InputBegan:Connect(onInputBegan)
	userInputService.InputChanged:Connect(onInputChanged)
	userInputService.InputEnded:Connect(onInputEnded)
	task.spawn(function()
		local textChatService: TextChatService = game:GetService("TextChatService")
		local v713: Instance = textChatService:FindFirstChildOfClass("ChatInputBarConfiguration") or textChatService:WaitForChild("ChatInputBarConfiguration", 10)

		if v713 and v713:IsA("ChatInputBarConfiguration") then
			guards.SetChatConfig(v713)
			v713:GetPropertyChangedSignal("IsFocused"):Connect(function()
				if v713.IsFocused then
					module.PushMouseUnlock("ChatFocus")

					return
				end

				module.PopMouseUnlock("ChatFocus")
			end)
		end
	end)
	userInputService.TextBoxFocused:Connect(function()
		module.PushMouseUnlock("TextBox")
	end)
	userInputService.TextBoxFocusReleased:Connect(function()
		module.PopMouseUnlock("TextBox")
	end)

	local function bindKeys()
		local v714 = keybinds.Inputs("FreeCursor")

		if #v714 == 0 then
			contextActionService:UnbindAction("TribesFreeCursor")
		else
			contextActionService:BindActionAtPriority("TribesFreeCursor", function(_, p71, p72)
				if p71 == Enum.UserInputState.Begin then
					guards.FreeKeyDown(p72)
				elseif p71 == Enum.UserInputState.End then
					if guards.FreeKeyUp() and not u63 then
						if t2.FreeCursor then
							module.PopMouseUnlock("FreeCursor")
						else
							module.PushMouseUnlock("FreeCursor")
						end
					end
				else
					guards.FreeKeyCancel()
				end

				return Enum.ContextActionResult.Pass
			end, false, Enum.ContextActionPriority.Low.Value, table.unpack(v714))
		end

		contextActionService:BindActionAtPriority("TribesShoulderSwap", function(_, p74)
			if p74 == Enum.UserInputState.Begin then
				local u742: boolean = true

				if next(t2) == nil then
					u742 = guiService.MenuIsOpen
				end

				if not u742 and not u63 then
					module.SetShoulderSide(-n3)
				end
			end

			return Enum.ContextActionResult.Pass
		end, false, Enum.ContextActionPriority.Low.Value, Enum.KeyCode.ButtonR3, table.unpack(keybinds.Inputs("Shoulder")))
		contextActionService:BindActionAtPriority("TribesFirstPerson", function(_, p76)
			if p76 == Enum.UserInputState.Begin then
				local u745: boolean = true

				if next(t2) == nil then
					u745 = guiService.MenuIsOpen
				end

				if not u745 and not u63 and s1 == "none" then
					module.ToggleFirstPerson()
				end
			end

			return Enum.ContextActionResult.Pass
		end, false, Enum.ContextActionPriority.Low.Value, Enum.KeyCode.DPadUp, table.unpack(keybinds.Inputs("View")))
	end

	bindKeys()
	keybinds.Changed:Connect(function(p77)
		for iterFirst, iterSecond in p77 do
			if iterSecond == "FreeCursor" or iterSecond == "Shoulder" or iterSecond == "View" then
				bindKeys()

				return
			end
		end
	end)
	LocalPlayer.CharacterAdded:Connect(function(character: Model)
		n13 = 0
		n12 = 0
		u51 = nil
		n11 = 0

		local n3: number = 0

		if n3 < 0.01 then
			n3 = 0
		end

		if math.max(n3, 0) < 0.01 then
		end

		if u114 ~= nil then
			for key, value in t11 do
				local inst = value.inst

				if inst.Parent and inst.LocalTransparencyModifier ~= 0 then
					inst.LocalTransparencyModifier = 0
				end
			end

			for key2, value2 in t12 do
				value2:Disconnect()
			end

			table.clear(t12)
			table.clear(t11)
			u114 = nil
			u107 = true
			n27 = -1
			n28 = -1
			u111 = false
		end

		for iterFirst, iterSecond in character:GetDescendants() do
			if iterSecond:IsA("BasePart") or iterSecond:IsA("Decal") then
				iterSecond.LocalTransparencyModifier = 0
			end
		end

		u59 = nil
		u60 = nil
		u61 = false
		u62 = false
		simulation.SetFacing(nil)
		u114 = nil
		u26 = false
		table.clear(t6)
		v44:Snap(Vector3.new(0, 0, 0))
		module.SlowRecoil:Snap(Vector3.new(0, 0, 0))
		module.SlowRecoilStay = Vector3.new(0, 0, 0)
		v43:Snap(0)
		n18 = 1
		module.PopMouseUnlock("FreeCursor")

		local humanoidRootPart: Instance = character:WaitForChild("HumanoidRootPart", 5)

		if humanoidRootPart and humanoidRootPart:IsA("BasePart") then
			local lookVector = humanoidRootPart.CFrame.LookVector

			n1 = math.atan2(-lookVector.X, -lookVector.Z)
			n2 = -0.20943951023931956
			u64 = u63

			local v729 = os.clock()
			local humanoidRootPartPosition = humanoidRootPart.Position

			task.spawn(function()
				while true do
					if not (os.clock() - v729 < 1.5) or not humanoidRootPart.Parent then
						break
					end

					task.wait(0.05)

					if (humanoidRootPart.Position - humanoidRootPartPosition).Magnitude > 40 then
						local lookVector = humanoidRootPart.CFrame.LookVector

						n1 = math.atan2(-lookVector.X, -lookVector.Z)
						n2 = -0.20943951023931956
						u64 = u63
					end

					humanoidRootPartPosition = humanoidRootPart.Position
				end
			end)
		end
	end)
	guards.Start({
		lookLocks = t3,
		unlockReasons = t2,
		touches = t7,
		popLookLock = function(p79)
			module.PopLookLock(p79)
		end,
		popUnlock = function(p80)
			module.PopMouseUnlock(p80)
		end,
		blockers = function()
			return module.GetLookBlockers()
		end
	})
	runService:BindToRenderStep("TribesCamera", Enum.RenderPriority.Camera.Value + 1, function(p81)
		local v734 = os.clock()

		update(p81)
		simulation.SetLook(n1)

		local n2 = os.clock() - v734

		n8 += n2
		n10 += 1
		n9 = math.max(n9, n2)
	end)
end
function module.SetAiming(p82, p83)
	u26 = p82 == true and s1 == "none"

	if u26 then
		n4 = if typeof(p83) == "number" then math.clamp(p83, 20, 90) else 50
	end
end
function module.IsAiming()
	return u26
end
function module.GetAimRay()
	local CurrentCamera: Camera = workspace.CurrentCamera

	if not CurrentCamera then
		return Ray.new(Vector3.new(0, 0, 0), Vector3.new(0, 0, -1))
	end

	local currentCameraCFrame: CFrame = CurrentCamera.CFrame

	return Ray.new(currentCameraCFrame.Position, currentCameraCFrame.LookVector)
end
function module.GetAimPoint(p84, p85)
	local v574 = module.GetAimRay()
	local localPlayerCharacter = LocalPlayer and LocalPlayer.Character
	local v576 = v574.Origin
	local character = LocalPlayer and LocalPlayer.Character
	local v578

	if not character then
		v578 = nil
	else
		local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")

		character:FindFirstChildOfClass("Humanoid")
		v578 = humanoidRootPart and humanoidRootPart:IsA("BasePart") and humanoidRootPart or nil
	end

	if v578 then
		local v580 = (v578.Position - v576):Dot(v574.Direction)

		if v580 > 0 then
			local direction = v574.Direction
			local v582 = math.max(0, v580 - 1.5)

			v576 += direction * v582
		end
	end

	local t18 = {}

	if localPlayerCharacter then
		table.insert(t18, localPlayerCharacter)
	end

	for key, value in t10 do
		local foundChild: Instance = workspace:FindFirstChild(value)

		if foundChild then
			table.insert(t18, foundChild)
		end
	end

	if p85 then
		for iterFirst, iterSecond in p85 do
			table.insert(t18, iterSecond)
		end
	end

	local raycastParams2 = RaycastParams.new()

	raycastParams2.FilterType = Enum.RaycastFilterType.Exclude
	raycastParams2.FilterDescendantsInstances = t18
	raycastParams2.IgnoreWater = true
	t18 = (p84 or 1000) - (v576 - v574.Origin).Magnitude

	local v590 = workspace:Raycast(v576, v574.Direction * t18, raycastParams2)

	if v590 then
		return v590.Position, v590
	end

	return v576 + v574.Direction * t18, nil
end
function module.FovKick(p86, p87, p88)
	if typeof(p86) == "number" and p86 == p86 then
		t8.amount = math.clamp(p86, -20, 20)
		t8.t0 = os.clock()
		t8.rise = math.max(p87 or 0.05, 0.01)
		t8.fall = math.max(p88 or 0.2, 0.01)

		return
	end
end
function module.Shake(p89, p90)
	if typeof(p89) ~= "number" or typeof(p90) ~= "number" then
		return
	end

	if p89 <= 0 or p90 <= 0 then
		return
	end

	if #t6 > 24 then
		table.remove(t6, 1)
	end

	local v596 = math.min(p89, 3)
	local v597 = math.min(p90, 5)

	table.insert(t6, { t = 0, intensity = v596, duration = v597 })
end
function module.Recoil(p91, p92, p93)
	local v601 = math.rad(p91)
	local v602 = math.rad(p92 or 0)
	local v603 = math.rad(p93 or 0)
	local vector3 = Vector3.new(v601, v602, v603)

	v44:Impulse(vector3 * 12)
end

module.SlowRecoil = spring.new(Vector3.new(0, 0, 0), 8, 1)
module.SlowRecoilStay = Vector3.new(0, 0, 0)
module.SLOW_RECOIL_FADE = 0.3

function module.RecoilSlow(p94, p95, p96, p97)
	local slowRecoil = module.SlowRecoil
	local slowRecoilTarget = slowRecoil.target
	local v611 = math.rad(p94)
	local v612 = math.rad(p95 or 0)
	local vector3 = Vector3.new(v611, v612, 0)
	local n1 = slowRecoilTarget + vector3
	local v615 = math.clamp(n1.X, -0.4363323129985824, 0.4363323129985824)

	v611 = math.clamp(n1.Y, -0.4363323129985824, 0.4363323129985824)
	slowRecoil.target = Vector3.new(v615, v611, 0)

	local v616: {[any]: any} = module
	local slowRecoilStay = v616.SlowRecoilStay

	v612 = math.rad(p96 or 0)

	local v618 = math.rad(p97 or 0)
	local vector33 = Vector3.new(v612, v618, 0)

	v616.SlowRecoilStay = slowRecoilStay + vector33
end
function module.Dip(p98)
	if typeof(p98) == "number" then
		local v621 = math.clamp(p98, -3, 3)

		v43:Impulse(-v621 * 6)

		return
	end
end
function module.PushMouseUnlock(p99)
	local text: string = tostring(p99)

	t2[text] = true

	if u32 then
		applyMouseBehavior()
	end
end
function module.PopMouseUnlock(p100)
	local text: string = tostring(p100)

	t2[text] = nil

	if u32 then
		applyMouseBehavior()
	end
end
function module.PushLookLock(p101, p102)
	local text: string = tostring(p101)

	t3[text] = true
	guards.LockPushed(text, p102)
end
function module.PopLookLock(p103)
	local text: string = tostring(p103)

	t3[text] = nil
	guards.LockPopped(text)
end
function module.IsLookLocked()
	return next(t3) ~= nil
end
function module.GetLookBlockers()
	local t19: {[any]: any} = {}

	if not u31 then
		table.insert(t19, "disabled")
	end

	if u63 then
		table.insert(t19, "lobby")
	end

	if s1 ~= "none" then
		table.insert(t19, "spectate:" .. s1)
	end

	if n13 > 0 or n12 > 0 then
		table.insert(t19, "cinematic")
	end

	for iterValue in t3 do
		table.insert(t19, "lock:" .. iterValue)
	end

	for iterValue2 in t2 do
		table.insert(t19, "unlock:" .. iterValue2)
	end

	if guiService.MenuIsOpen then
		table.insert(t19, "robloxMenu")
	end

	table.sort(t19)

	return t19
end
function module.IsMouseUnlocked()
	local u634: boolean = true

	if next(t2) == nil then
		u634 = guiService.MenuIsOpen
	end

	return u634
end
function module.GetMode()
	if u63 then
		return "lobby"
	end

	return "combat"
end
function module.GetUnlockReasons()
	local t20: {[any]: any} = {}

	for iterValue in t2 do
		table.insert(t20, iterValue)
	end

	return t20
end
function module.GetShoulderSide()
	return n3
end

module.FirstPersonChanged = bindableEvent.Event

function module.SetFirstPerson(p104)
	local u638: boolean = p104 == true
	local v639 = firstPerson.Get()

	if u638 ~= v639 then
		firstPerson.Set(u638)
		bindableEvent:Fire(u638)
	end
end
function module.IsFirstPerson()
	return firstPerson.Get()
end
function module.ToggleFirstPerson()
	local setFirstPerson = module.SetFirstPerson
	local v641 = firstPerson.Get()

	setFirstPerson(not v641)
end
function module.InFirstPerson()
	return u112
end
function module.SetViewBobbing(p105)
	firstPerson.SetBobbing(p105)
end
function module.GetViewBobbing()
	return firstPerson.GetBobbing()
end
function module.GetViewBob()
	return firstPerson.Bob()
end
function module.SetShoulderSide(p106)
	n3 = if p106 < 0 then -1 else 1
	n19 = n3
	occlusion.Reset()
end
function module.SetModifier(p107, p108)
	t5[p107] = p108
end
function module.SuspendCharacterRotation(p109)
	local text: string = tostring(p109)

	t4[text] = true
end
function module.ResumeCharacterRotation(p110)
	local text: string = tostring(p110)

	t4[text] = nil
end
function module.FaceCamera()
	local localPlayerCharacter = LocalPlayer and LocalPlayer.Character
	local v651
	local v652

	if not localPlayerCharacter then
		v651 = nil
		v652 = nil
	else
		local humanoidRootPart = localPlayerCharacter:FindFirstChild("HumanoidRootPart")
		local humanoid = localPlayerCharacter:FindFirstChildOfClass("Humanoid")

		v651 = humanoidRootPart and humanoidRootPart:IsA("BasePart") and humanoidRootPart or nil
		v652 = humanoid
	end

	if v651 and v652 and v652.Health > 0 and u63 == false then
		u62 = true
		simulation.SetFacing(n1)
	end
end
function module.GetAimAssistShot()
	if aimAssist.IsEnabled() then
		local combatMode: any = LocalPlayer:GetAttribute("CombatMode")

		if not (if combatMode == nil then LocalPlayer:GetAttribute("State") == "Match" else combatMode == true) then
			return nil
		end

		local aimAssistShot = aimAssist.Shot
		local v657 = ignoreList(LocalPlayer.Character)

		return aimAssistShot(v657, n1, n2, u26, n4, t5.CombatDraw ~= nil)
	end

	return nil
end
function module.GetAimAssist(p111)
	local v659 = module.GetAimAssistShot()

	if v659 and (p111 == nil or not (p111 < v659.deg)) then
		return v659.model, v659.part, v659.deg
	end

	return nil, nil, nil
end
function module.IsAssistedInput()
	return aimAssist.IsAssistedInput()
end
function module.GetAimAssistInput()
	return aimAssist.InputKind()
end
function module.Nudge(p112, p113)
	if typeof(p112) ~= "number" or p112 ~= p112 then
		return
	end

	if (p113 or 0) <= 0 then
		n1 = (n1 + p112 + 3.141592653589793) % 6.283185307179586 - 3.141592653589793

		return
	end

	aimAssist.Nudge(p112, p113)
end
function module.SetAimAssist(p114)
	aimAssist.SetEnabled(p114)
end
function module.GetAimAssistEnabled()
	return aimAssist.IsEnabled()
end
function module.AimAssistDebug(p115, ...)
	return aimAssist.Debug(p115, ...)
end
function module.GetYaw()
	return n1
end
function module.GetPitch()
	return n2
end
function module.SetLook(p116, p117)
	n1 = (p116 + 3.141592653589793) % 6.283185307179586 - 3.141592653589793

	if p117 then
		n2 = math.clamp(p117, -1.3962634015954636, 1.361356816555577)
	end

	u64 = u63
end
function module.SetSensitivity(p118)
	if typeof(p118) == "number" then
		n7 = math.clamp(p118, 0.05, 5)
	end
end
function module.AddTouchLook(p119)
	u72 += p119
end
function module.GetSensitivity()
	return n7
end
function module.SetFOV(p120)
	if typeof(p120) == "number" then
		n5 = math.clamp(p120, 60, 100)
	end
end
function module.GetFOV()
	return n5
end
function module.SetZoom(p121)
	if typeof(p121) == "number" then
		n6 = math.clamp(p121, 7, 14)
	end
end
function module.SpectateNext(p122)
	local spectateNext = spectate.Next
	local typeName: string = typeof(p122)

	spectateNext(if typeName == "number" and p122 < 0 then -1 else 1)
end
function module.GetSpectateTarget()
	return spectate.GetTarget()
end
function module.GetSpectateMode()
	return spectate.GetMode()
end
function module.GetKiller()
	return spectate.GetKiller()
end

module.SpectateChanged = spectate.Changed

function module.PlayCinematic(p123, p124, p125)
	if typeof(p123) == "CFrame" then
		local t21 = p125 or {}
		local t22: {[any]: any} = {
			cf = p123,
			fov = if typeof(p124) == "number" then math.clamp(p124, 20, 100) else nil,
			hide = t21.hideCharacter ~= false,
			untilStopped = t21.untilStopped == true
		}

		u51 = t22
		n13 = 1
		n14 = 1 / math.max(0.05, t21.duration or 0.6)
		n15 = os.clock()
		u56 = LocalPlayer and LocalPlayer.Character

		if not t22.fov then
			n16 = workspace.CurrentCamera and workspace.CurrentCamera.FieldOfView or n5
		end

		return
	end
end
function module.StopCinematic(p126)
	n13 = 0
	n14 = 1 / math.max(0.05, p126 or 0.5)
end
function module.IsCinematic()
	return n13 > 0
end
function module.SetEnabled(p127)
	u31 = p127

	local CurrentCamera: Camera = workspace.CurrentCamera

	if not p127 then
		if CurrentCamera then
			CurrentCamera.CameraType = Enum.CameraType.Custom
			CurrentCamera.FieldOfView = n5
		end

		userInputService.MouseBehavior = Enum.MouseBehavior.Default
		userInputService.MouseIconEnabled = true

		local localPlayerCharacter = LocalPlayer and LocalPlayer.Character

		if localPlayerCharacter then
			local humanoidRootPart = localPlayerCharacter:FindFirstChild("HumanoidRootPart")
			local humanoid = localPlayerCharacter:FindFirstChildOfClass("Humanoid")

			if not humanoidRootPart or not humanoidRootPart:IsA("BasePart") or not humanoidRootPart then
			end
		end

		u61 = false

		if u62 then
			simulation.SetFacing(nil)
			u62 = false
		end

		u112 = false
		firstPerson.Step(0, false)
		setCharacterFade(u114, 0, 0)

		for iterValue in t13 do
			if iterValue.Parent then
				iterValue.LocalTransparencyModifier = 0
			end
		end

		table.clear(t13)
		fades.ClearAllies()
		fades.ClearDecor()

		return
	end

	u59 = nil
end
function module.IsEnabled()
	return u31
end
function module.DebugOcclusion(p128)
	return occlusion.Debug(p128)
end
function module.GetDrawnRoot()
	return smoothing.DrawnCFrame()
end
function module.Drawn(p129)
	return smoothing.Drawn(p129)
end
function module.GetDrawnModel()
	return smoothing.DrawnModel()
end

module.DrawnChanged = smoothing.DrawnChanged

function module.SmoothingTrace(p130)
	local v688 = smoothing.Trace(p130)

	if v688 then
		return (game:GetService("HttpService"):JSONEncode(v688))
	end

	return nil
end
function module.DebugStats()
	local v689 = os.clock()
	local v690 = math.max(0.001, v689 - u48)
	local t23: {[any]: any} = { msPerSec = n8 * 1000 / v690, msPerFrame = n1 }
	local n1 = if n10 > 0 then n8 * 1000 / n10 else 0

	t23.maxFrameMs = n9 * 1000
	t23.fps = n10 / v690
	t23.touchLookPx = n20
	t23.touchesIgnored = n21
	n8 = 0
	n9 = 0
	n10 = 0
	u48 = v689

	for iterFirst, iterSecond in fades.Stats() do
		t23[iterFirst] = iterSecond
	end

	for iterFirst2, iterSecond2 in aimAssist.Stats() do
		t23[iterFirst2] = iterSecond2
	end

	for iterFirst3, iterSecond3 in smoothing.Stats() do
		t23[iterFirst3] = iterSecond3
	end

	for iterFirst4, iterSecond4 in occlusion.Debug("stats") do
		t23["occ_" .. iterFirst4] = iterSecond4
	end

	for iterFirst5, iterSecond5 in guards.Stats() do
		t23["guard_" .. iterFirst5] = iterSecond5
	end

	if runService:IsStudio() and simulation.WriteGuardStats then
		for iterFirst6, iterSecond6 in simulation.WriteGuardStats() do
			t23["wg_" .. iterFirst6] = iterSecond6
		end
	end

	t23.firstPerson = u112
	t23.waterLifts = occlusion.WaterLifts()

	return t23
end

if v21 and LocalPlayer then
	local tribesCameraBridge: Instance = LocalPlayer:FindFirstChild("TribesCameraBridge")

	if tribesCameraBridge and tribesCameraBridge:IsA("BindableFunction") then
		for key, value in module do
			if type(value) == "function" then
				module[key] = function(...)
					return tribesCameraBridge:Invoke(key, ...)
				end
			end
		end
	else
		local tribesCameraBridge: BindableFunction = Instance.new("BindableFunction")

		tribesCameraBridge.Name = "TribesCameraBridge"

		local v166 = table.clone(module)

		function tribesCameraBridge.OnInvoke(p131, ...)
			local v706 = v166[p131]

			if type(v706) == "function" then
				return v706(...)
			end

			return nil
		end

		tribesCameraBridge.Parent = LocalPlayer
		start()
	end
end

return module