Roblox/luau_corpus huggingface dataset:
---------------
-- Constants --
---------------

local FADE_TARGET = 0.75
local FADE_RATE = 0.1

local MODE = {
	CUSTOM = 1, -- Whatever you want!
	LIMBS = 2, -- Track limbs
	MOVEMENT = 3, -- Track movement
	CORNERS = 4, -- Char model corners
	CIRCLE1 = 5, -- Circle of casts around character
	CIRCLE2 = 6, -- Circle of casts around character, camera relative
	LIMBMOVE = 7, -- LIMBS mode + MOVEMENT mode
}

Invisicam.MODE = MODE

local STARTING_MODE = MODE.LIMBS

local LIMB_TRACKING_SET = {
	['Head'] = true,
	['Left Arm'] = true,
	['Right Arm'] = true,
	['Left Leg'] = true,
	['Right Leg'] = true,
	['LeftLowerArm'] = true,
	['RightLowerArm'] = true,
	['LeftLowerLeg'] = true,
	['RightLowerLeg'] = true
}

local CORNER_FACTORS = {
	Vector3.new(1, 1, -1),
	Vector3.new(1, -1, -1),
	Vector3.new(-1, -1, -1),
	Vector3.new(-1, 1, -1)
}

local CIRCLE_CASTS = 10
local MOVE_CASTS = 3
--wr2.MaxVelocity = 0.007
--wr2.Part0 = script.Parent.Parent.Misc.RR.Door.WD
--wr2.Part1 = wr2.Parent

sw.MaxVelocity = 0.1
sw.Part0 = script.Parent.SW
sw.Part1 = sw.Parent

TK.MaxVelocity = 0.03
TK.Part0 = script.Parent.TK
TK.Part1 = TK.Parent
--Made by Luckymaxer

Debris = game:GetService("Debris")

Character = script.Parent
Humanoid = Character:FindFirstChild("Humanoid")

Duration = script:FindFirstChild("Duration")

Rate = (1 / 60)

function DestroyScript()
	Debris:AddItem(script, 0.5)
	script:Destroy()
end

if not Humanoid or Humanoid.Health == 0 or not Duration or Duration.Value <= 0 then
	DestroyScript()
	return
end

while Humanoid.Health > 0 and Duration.Value > 0 do
	if Humanoid then
		Humanoid.WalkSpeed = 6
	end
	local Time = wait(Rate)
	Duration.Value = (Duration.Value - Time)
end

if Humanoid then
	Humanoid.WalkSpeed = 16
end

DestroyScript()
------------------------------------------------------------
local TwinService = game:GetService("TweenService")
local AnimationHighLight = TweenInfo.new(1.5, Enum.EasingStyle.Sine ,Enum.EasingDirection.InOut)
local Info1 = {Position = Vector3.new(pos1,Positionn,pos3)}
local Info2 = {Position = Vector3.new(pos1,Positionn2,pos3)}
local AnimkaUp = TwinService:Create(Danger, AnimationHighLight, Info1 )
local AnimkaDown = TwinService:Create(Danger, AnimationHighLight, Info2 )
while true do
	AnimkaUp:Play()
	wait(1.5)
	AnimkaDown:Play()
	wait(1.5)
end
--Stickmasterluke

sp=script.Parent
framerate=30

frames=1
running=false
direction=1


function waitForChild(instance,name)
	while not instance:FindFirstChild(name) do
		instance.ChildAdded:wait()
	end
end

waitForChild(sp,"Bottom")
waitForChild(sp.Bottom,"OpenDoor")
waitForChild(sp.Bottom,"Configuration")


function checkframes()
	if sp:FindFirstChild("Bottom") then
		local config=sp.Bottom:FindFirstChild("Configuration")
		if config then
			frames=math.floor(config.TimeToMove.Value*framerate)+1
		end
	end
end
sp.Bottom.Configuration.TimeToMove.Changed:connect(checkframes)
checkframes()


function updatedoor(frame)
	local percentage=frame/frames
	if sp:FindFirstChild("Bottom") then
		local hingedist=1.9
		local hinge1=sp.Bottom:FindFirstChild("Door1")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(-hingedist,-hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(hingedist,hingedist,0)
		end
		local hinge1=sp.Bottom:FindFirstChild("Door2")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(-hingedist,hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(hingedist,-hingedist,0)
		end
		local hinge1=sp.Bottom:FindFirstChild("Door3")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(hingedist,hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(-hingedist,-hingedist,0)
		end
		local hinge1=sp.Bottom:FindFirstChild("Door4")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(hingedist,-hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(-hingedist,hingedist,0)
		end
	end
end

function runloop()
	if not running then
		running=true
		while true do
			if sp:FindFirstChild("Bottom") then
				local frame=sp.Bottom:FindFirstChild("Frame")
				if frame then
					frame.Value=frame.Value+direction
					if frame.Value>frames then
						frame.Value=frames
					end
					if frame.Value<=0 then
						frame.Value=0
					end
					updatedoor(frame.Value)
					wait(1/framerate)
					if frame then
						if (frame.Value<=0 and direction==-1) or (frame.Value>=frames and direction==1) then
							break
						end
					end
				else
					break
				end
			else
				break
			end
		end
		running=false
	end
end

function check(val)
	if val>.5 then
		direction=1
	else
		direction=-1
	end
	runloop()
end

sp.Bottom.OpenDoor.SourceValueChanged:connect(check)
check(sp.Bottom.OpenDoor:GetCurrentValue())
-- Make the HotbarFrame, which holds only the Hotbar Slots
HotbarFrame = NewGui('Frame', 'Hotbar')
HotbarFrame.BackgroundTransparency = 0.7

local grad = script.UIGradient:Clone()
grad.Parent = HotbarFrame

HotbarFrame.Parent = MainFrame
--------SIDE SQUARES--------

game.Workspace.sidesquares.l11.BrickColor = BrickColor.new(1023)
game.Workspace.sidesquares.l12.BrickColor = BrickColor.new(1023)
game.Workspace.sidesquares.l21.BrickColor = BrickColor.new(1023)
game.Workspace.sidesquares.l31.BrickColor = BrickColor.new(1023)

game.Workspace.rightpalette.l11.BrickColor = BrickColor.new(1023)
game.Workspace.rightpalette.l12.BrickColor = BrickColor.new(1023)
game.Workspace.rightpalette.l21.BrickColor = BrickColor.new(1023)
game.Workspace.rightpalette.l22.BrickColor = BrickColor.new(1023)

game.Workspace.sidesquares.l13.BrickColor = BrickColor.new(106)
game.Workspace.sidesquares.l23.BrickColor = BrickColor.new(106)
game.Workspace.sidesquares.l33.BrickColor = BrickColor.new(106)
game.Workspace.sidesquares.l34.BrickColor = BrickColor.new(106)

game.Workspace.rightpalette.l13.BrickColor = BrickColor.new(106)
game.Workspace.rightpalette.l23.BrickColor = BrickColor.new(106)
game.Workspace.rightpalette.l14.BrickColor = BrickColor.new(106)
game.Workspace.rightpalette.l24.BrickColor = BrickColor.new(106)

game.Workspace.sidesquares.l14.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l15.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l24.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l25.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l35.BrickColor = BrickColor.new(1013)

game.Workspace.rightpalette.l15.BrickColor = BrickColor.new(1013)
game.Workspace.rightpalette.l25.BrickColor = BrickColor.new(1013)
game.Workspace.rightpalette.l16.BrickColor = BrickColor.new(1013)
game.Workspace.rightpalette.l26.BrickColor = BrickColor.new(1013)
-- KEYBINDS HERE

local bind1 = Enum.KeyCode.LeftShift -- This is the keybind this script is set to by default
local bind2 = Enum.KeyCode.RightShift -- This is the second keybind this script is set to by default
--BasedWeld2.0
function MakeWeld(x,y,type,s) 
	local W=Instance.new(type) 
	W.Part0=x W.Part1=y 
	W.C0=x.CFrame:inverse()*x.CFrame 
	W.C1=y.CFrame:inverse()*x.CFrame 
	W.Parent=x 
	if type=="Motor" and s~=nil then 
		W.MaxVelocity=s 
	end 
	return W	
end
function ModelWeld(a,b) 
	if a:IsA("BasePart") then 
		MakeWeld(b,a,"Weld") 
	elseif a:IsA("Model") then 
		for i,v in pairs(a:GetChildren()) do 
			ModelWeld(v,b) 
		end 
	end 
end
function UnAnchor(a) 
	if a:IsA("BasePart") then a.Anchored=false elseif a:IsA("Model") then for i,v in pairs(a:GetChildren()) do UnAnchor(v) end end 
end
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 580		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 4.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
-- Variables

local b_close = script.Parent

local tpMenu = script.Parent.Parent
--- Connect a new handler to the event. Returns a connection object that can be disconnected.
-- @tparam function handler Function handler called with arguments passed when `:Fire(...)` is called
-- @treturn Connection Connection object that can be disconnected
function Signal:Connect(handler)
	if not (type(handler) == "function") then
		error(("connect(%s)"):format(typeof(handler)), 2)
	end

	return self._bindableEvent.Event:Connect(function()
		handler(unpack(self._argData, 1, self._argCount))
	end)
end
--Feel free to change other properties
trail.Parent = script.Parent.HumanoidRootPart
att0.Parent = script.Parent.HumanoidRootPart
att1.Parent = script.Parent.HumanoidRootPart
trail.Attachment0 = att0
trail.Attachment1 = att1
trail.Enabled = true
att0.Position = Vector3.new(.5, 0, 0)
att1.Position = Vector3.new(-.5, 0, 0)
-----RandomDebris-----
local Colors = {
	Color3.fromRGB(91, 91, 91),
}
local Materials = {
	Enum.Material.Plastic,
}
--[[
	Function called when leaving the state
]]
function PlayerPostGame.onLeave(stateMachine, serverPlayer, event, from, to)
end

return PlayerPostGame
-- Builds a set of runnable Tweens from a table of instances and values
local function BuildTweens(root, tweenTable)
	local tweens = {}

	VisitAllInstances(root, tweenTable, function(instance, props)
		for prop, values in pairs(props) do
			local keyframes = values.Keyframes
			local lastTime = 0
			for _, keyframe in ipairs(keyframes) do
				local tweenInfo = TweenInfo.new(keyframe.Time - lastTime,
					keyframe.EasingStyle,keyframe.EasingDirection, 0, false, 0)
				local propTable = {
					[prop] = keyframe.Value
				}
				local tween = TweenService:Create(instance, tweenInfo, propTable)
				table.insert(tweens, {
					Tween = tween,
					DelayTime = lastTime,
				})
				lastTime = keyframe.Time
			end
		end
	end)

	return tweens
end

local TweenUtilities = {}
TweenUtilities.__index = TweenUtilities

function TweenUtilities.new(root, tweenTable)
	local self = {
		running = false,
		root = root,
		tweenTable = tweenTable,
		tweens = BuildTweens(root, tweenTable),
	}
	setmetatable(self, TweenUtilities)
	return self
end

function TweenUtilities:ResetValues()
	VisitAllInstances(self.root, self.tweenTable, function(instance, props)
		for prop, values in pairs(props) do
			local initialValue = values.InitialValue
			instance[prop] = initialValue
		end
	end)
end

function TweenUtilities:PlayTweens(callback)
	if self.running then
		self:PauseTweens()
	end
	self.running = true

	local delayedTweens = {}
	for _, props in pairs(self.tweens) do
		local tween = props.Tween
		local delayTime = props.DelayTime
		if delayTime == 0 then
			tween:Play()
		else
			table.insert(delayedTweens, {
				Tween = tween,
				DelayTime = delayTime,
				Playing = false,
			})
		end
	end

	local heartbeatConnection
	local start = tick()
	local tweensDone = false
	heartbeatConnection = RunService.Heartbeat:Connect(function()
		local now = tick() - start
		if not self.running then
			self.running = false
			heartbeatConnection:Disconnect()
			if callback then
				callback()
			end
			return
		end
		if tweensDone then
			local allDone = true
			for _, props in pairs(self.tweens) do
				local tween = props.Tween
				if tween.PlaybackState == Enum.PlaybackState.Playing then
					allDone = false
				end
			end
			if allDone then
				self.running = false
				heartbeatConnection:Disconnect()
				if callback then
					callback()
				end
				return
			end
		else
			local allPlaying = true
			for _, props in pairs(delayedTweens) do
				if not props.Playing then
					if now > props.DelayTime then
						props.Playing = true
						props.Tween:Play()
					else
						allPlaying = false
					end
				end
			end
			tweensDone = allPlaying
		end
	end)
end

function TweenUtilities:PauseTweens()
	self.running = false
	for _, props in pairs(self.tweens) do
		local tween = props.Tween
		tween:Cancel()
	end
end

return TweenUtilities
---------------------------------------Function end here.
end


Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		return
	end

	--Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	if (check()) then
	fire(script.Parent.Parent["Humanoid"].TargetPoint)
	wait(0.0)
	onActivated()
	end
	return

	--Tool.Enabled = true
end


script.Parent.Activated:connect(onActivated)
-- OTHER VARIABLES --
local player = game:GetService("Players").LocalPlayer
local char = player.Character or player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
local humanoid = char:WaitForChild("Humanoid")
--[[Weight and CG]]
	Tune.Weight			= 100000		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= 5		-- Front Wheel Density
	Tune.RWheelDensity	= 5		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 5			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= 1		-- Density of structural members
--// Set up
for L_18_forvar1, L_19_forvar2 in pairs(game.Players:GetChildren()) do
	if L_19_forvar2:IsA('Player') and L_19_forvar2.Character and L_19_forvar2.Character.Head and L_19_forvar2.Character.Humanoid and L_19_forvar2.Character.Humanoid.Health > 0 then
		if L_19_forvar2.TeamColor == L_1_.TeamColor then
			if L_19_forvar2.Character.Saude.FireTeam.SquadName.Value ~= '' then
				spawnTag(L_19_forvar2.Character, L_19_forvar2.Character.Saude.FireTeam.SquadColor.Value)
			else
				spawnTag(L_19_forvar2.Character, Color3.fromRGB(255,255,255))
			end
		end;
	end;
end
----------------------------------
-----------CONNECTIONS------------
----------------------------------

SeatWeldConnection = nil

function MakeSeatConnections()
	SeatWeldConnection = SeatWeld.Changed:connect(WeldChanged)
end
function BreakSeatConnections()
	SeatWeldConnection:disconnect()
end

Piano.Bench.Seat.Changed:Connect(function()
	Piano.Bench.Seat.Changed:Wait()
	if Piano.Bench.Seat.Occupant == nil or Piano.Bench.Seat.Changed == "" or not Piano.Bench.Seat.Changed then
		Shutdown()
	end
end)

Seat.ChildAdded:connect(ChildAdded)
--[=[
	An observable that never completes.
	@prop NEVER Observable<()>
	@readonly
	@within Rx
]=]
local Rx = {
	EMPTY = Observable.new(function(sub)
		sub:Complete()
	end);
	NEVER = Observable.new(function(_)

	end);
}
--[=[
	@return Mouse

	Constructs a new mouse input capturer.

	```lua
	local mouse = Mouse.new()
	```
]=]
function Mouse.new()

	local self = setmetatable({}, Mouse)

	self._trove = Trove.new()

	self.LeftDown = self._trove:Construct(Signal)
	self.LeftUp = self._trove:Construct(Signal)
	self.RightDown = self._trove:Construct(Signal)
	self.RightUp = self._trove:Construct(Signal)
	self.Scrolled = self._trove:Construct(Signal)

	self._trove:Connect(UserInputService.InputBegan, function(input, processed)
		if processed then return end
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			self.LeftDown:Fire()
		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
			self.RightDown:Fire()
		end
	end)

	self._trove:Connect(UserInputService.InputEnded, function(input, processed)
		if processed then return end
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			self.LeftUp:Fire()
		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
			self.RightUp:Fire()
		end
	end)

	self._trove:Connect(UserInputService.InputChanged, function(input, processed)
		if processed then return end
		if input.UserInputType == Enum.UserInputType.MouseWheel then
			self.Scrolled:Fire(input.Position.Z)
		end
	end)

	return self

end
--[[
	Calls the bound function every interval until shouldContinueCallback doesn't return true
]]
return function(interval, boundFunction, shouldContinueCallback)
	spawn(
		function()
			while shouldContinueCallback do
				boundFunction()
				wait(interval)
			end
		end
	)
end
--Script made by Shaakra--

function waitForChild( parent, childName )
	while true do
		local child = parent:findFirstChild( childName )
		if child then return child end
		parent.ChildAdded:wait()
	end
end

local Figure = script.Parent
local Head = waitForChild( Figure, "Head" )
local Humanoid = waitForChild( Figure, "Humanoid" )
Humanoid.Health = 200

while true do
	local s = wait( 4 )
	local Health = Humanoid.Health
	if Health > 0 and Health < Humanoid.MaxHealth then
		Health = Health + 0.08 * s * Humanoid.MaxHealth
		if Health * 1.05 < Humanoid.MaxHealth then
			Humanoid.Health = Health
		else
			Humanoid.Health = Humanoid.MaxHealth
		end
	end
end
-- Require Shime
local shimmer = require(game.ReplicatedStorage.Shime)
--gman9544--
pod = script.Parent

function onTouched(part)
	part.BrickColor = BrickColor.new("Medium blue")
	wait(0)
	part.Reflectance = 1 
	wait(0)
	part.Reflectance = 1
	wait(0)				
	part.Reflectance = 1
	wait(0)
	part.Reflectance = 1
        part.Anchored = true
part.Material = "Ice"
	wait(0)
end

connection = pod.Touched:connect(onTouched)
--[[
	
	CameraShakePresets.Bump
	CameraShakePresets.Explosion
	CameraShakePresets.Earthquake
	CameraShakePresets.GentleSway
	CameraShakePresets.BadTrip
	CameraShakePresets.HandheldCamera
	CameraShakePresets.Vibration
	CameraShakePresets.RoughDriving
	
--]]



local CameraShakeInstance = require(script.Parent.CameraShakeInstance)

local CameraShakePresets = {
	
	
	-- A high-magnitude, short, yet smooth shake.
	-- Should happen once.
	Bump = function()
		local c = CameraShakeInstance.new(2.5, 4, 0.1, 0.75)
		c.PositionInfluence = Vector3.new(0.15, 0.15, 0.15)
		c.RotationInfluence = Vector3.new(1, 1, 1)
		return c
	end;
	
	
	-- An intense and rough shake.
	-- Should happen once.
	Explosion = function()
		local c = CameraShakeInstance.new(5, 10, 0, 1.5)
		c.PositionInfluence = Vector3.new(0.25, 0.25, 0.25)
		c.RotationInfluence = Vector3.new(4, 1, 1)
		return c
	end;
	
	
	-- A continuous, rough shake
	-- Sustained.
	Earthquake = function()
		local c = CameraShakeInstance.new(0.6, 3.5, 2, 10)
		c.PositionInfluence = Vector3.new(0.25, 0.25, 0.25)
		c.RotationInfluence = Vector3.new(1, 1, 4)
		return c
	end;
	
	
	-- A gentle left/right/up/down sway. Good for intro screens/landscapes.
	-- Sustained.
	GentleSway = function()
		local c = CameraShakeInstance.new(0.65, 0.08, 0.1, 0.75)
		c.PositionInfluence = Vector3.new(1.20, 0.35, 0.05)
		c.RotationInfluence = Vector3.new(0.02, 0.02, 0.02)
		return c
	end;
	
	
	-- A bizarre shake with a very high magnitude and low roughness.
	-- Sustained.
	BadTrip = function()
		local c = CameraShakeInstance.new(10, 0.15, 5, 10)
		c.PositionInfluence = Vector3.new(0, 0, 0.15)
		c.RotationInfluence = Vector3.new(2, 1, 4)
		return c
	end;
	
	
	-- A subtle, slow shake.
	-- Sustained.
	HandheldCamera = function()
		local c = CameraShakeInstance.new(1, 0.25, 5, 10)
		c.PositionInfluence = Vector3.new(0, 0, 0)
		c.RotationInfluence = Vector3.new(1, 0.5, 0.5)
		return c
	end;
	
	
	-- A very rough, yet low magnitude shake.
	-- Sustained.
	Vibration = function()
		local c = CameraShakeInstance.new(0.4, 20, 2, 2)
		c.PositionInfluence = Vector3.new(0, 0.15, 0)
		c.RotationInfluence = Vector3.new(1.25, 0, 4)
		return c
	end;
	
	
	-- A slightly rough, medium magnitude shake.
	-- Sustained.
	RoughDriving = function()
		local c = CameraShakeInstance.new(1, 2, 1, 1)
		c.PositionInfluence = Vector3.new(0, 0, 0)
		c.RotationInfluence = Vector3.new(1, 1, 1)
		return c
	end;
	
	
}


return setmetatable({}, {
	__index = function(t, i)
		local f = CameraShakePresets[i]
		if (type(f) == "function") then
			return f()
		end
		error("No preset found with index \"" .. i .. "\"")
	end;
})
--------RIGHT DOOR --------

game.Workspace.doorright.l53.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(1023)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]


local autoscaling	= false					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default	
	{
		units			= "MPH"				,
		scaling			= (10/12) * (60/88)	, -- 1 stud : 10 inches | ft/s to MPH
		maxSpeed		= 140				,
		spInc			= 20				, -- Increment between labelled notches
	},
	
	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 220				,
		spInc			= 40				, -- Increment between labelled notches
	},
	
	{
		units			= "SPS"				,
		scaling			= 1					, -- Roblox standard
		maxSpeed		= 280				,
		spInc			= 40				, -- Increment between labelled notches
	}
}
-- Compare two arrays of strings line-by-line. Format as comparison lines.
local function diffLinesUnified(
	aLines: { [number]: string },
	bLines: { [number]: string },
	options: DiffOptions?
): string
	if isEmptyString(aLines) then
		aLines = {}
	end
	if isEmptyString(bLines) then
		bLines = {}
	end

	return printDiffLines(diffLinesRaw(aLines, bLines), normalizeDiffOptions(options))
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {};
local l__ReplicatedStorage__2 = game.ReplicatedStorage;
local v3 = require(game.ReplicatedStorage.Modules.Lightning);
local v4 = require(game.ReplicatedStorage.Modules.Xeno);
local l__TweenService__5 = game.TweenService;
local l__Debris__6 = game.Debris;
local u1 = require(game.ReplicatedStorage.Modules.CameraShaker);
function v1.RunStompFx(p1, p2, p3, p4)
	local v7 = game.ReplicatedStorage.KillFX["Primary Bomb"].Explosion:Clone();
	v7.Position = p2.Position;
	v7.Parent = workspace.Ignored.Animations;
	v7["1"]:Play();
	task.delay(0.5, function()
		v7.click:Play();
		v7.Star.Enabled = true;
		task.wait(0.25);
		v7.Star.Enabled = false;
		v7["2"]:Play();
		if (p4.Character.PrimaryPart.Position - p2.Position).Magnitude < 25 then
			local v8 = Instance.new("ColorCorrectionEffect", game.Lighting);
			v8.TintColor = Color3.fromRGB(255, 144, 17);
			game.TweenService:Create(v8, TweenInfo.new(1), {
				TintColor = Color3.fromRGB(255, 255, 255)
			}):Play();
			game.Debris:AddItem(v8, 1);
			local v9 = u1.new(Enum.RenderPriority.Camera.Value, function(p5)
				workspace.CurrentCamera.CFrame = workspace.CurrentCamera.CFrame * p5;
			end);
			v9:Start();
			v9:Shake(u1.Presets.Bump);
		end;
		for v10, v11 in pairs(v7.Attachment:GetChildren()) do
			v11.Enabled = true;
		end;
		for v12, v13 in pairs(p2.Parent:GetDescendants()) do
			if v13:IsA("BasePart") then
				v13.Transparency = 1;
			end;
		end;
		task.wait(0.4);
		for v14, v15 in pairs(v7.Attachment:GetChildren()) do
			v15.Enabled = false;
		end;
	end);
	return nil;
end;
return v1;
--[=[
	@within TableUtil
	@function Shuffle
	@param tbl table
	@param rngOverride Random?
	@return table

	Shuffles the table.

	```lua
	local t = {1, 2, 3, 4, 5, 6, 7, 8, 9}
	local shuffled = TableUtil.Shuffle(t)
	print(shuffled) --> e.g. {9, 4, 6, 7, 3, 1, 5, 8, 2}
	```

	:::note Arrays only
	This function works on arrays, but not dictionaries.
]=]
local function Shuffle(tbl: Table, rngOverride: Random?): Table
	assert(type(tbl) == "table", "First argument must be a table")
	local shuffled = table.clone(tbl)
	local random = if typeof(rngOverride) == "Random" then rngOverride else rng
	for i = #tbl, 2, -1 do
		local j = random:NextInteger(1, i)
		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
	end
	return shuffled
end
-- Initialize:
Player.CameraMode = Enum.CameraMode.LockFirstPerson

RunService.Stepped:Connect(function()
	
	
	
end)

return nil