Roblox/luau_corpus huggingface dataset:
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,VRecoil = {7,14}				--- Vertical Recoil
	,HRecoil = {4.5,12}				--- Horizontal Recoil
	,AimRecover = .65				---- Between 0 & 1
	
	,RecoilPunch = .15
	,VPunchBase = 2.55				--- Vertical Punch
	,HPunchBase = 1.6				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .5
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 0.95				--- Min bullet spread value | Studs
	,MaxSpread = 47					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = .75
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1.5					--- Max sway value based on player stamina | Studs
--- Gamepass purchase prompted!
_L.MarketplaceService.PromptGamePassPurchaseFinished:Connect(function(player, gamepassId, purchased)
	if player then
		--- Did player complete transaction?
		if purchased == true then
			--- Player bought gamepass! WHAT A MASSIVE LEGEND
			AddGamepass(player, gamepassId)
			
			--- Let client know purchase went through
			_L.Network.Fire("Gamepass Bought", player, gamepassId)
		end
	end
end)
--- The dispatcher handles creating and running commands during the game.
local Dispatcher = {
	Cmdr = nil;
	Registry = nil;
}
--- Skip forwards in now
-- @param delta now to skip forwards
function Spring:TimeSkip(delta)
	local now = self._clock()
	local position, velocity = self:_positionVelocity(now+delta)
	self._position0 = position
	self._velocity0 = velocity
	self._time0 = now
end

function Spring:__index(index)
	if Spring[index] then
		return Spring[index]
	elseif index == "Value" or index == "Position" or index == "p" then
		local position, _ = self:_positionVelocity(self._clock())
		return position
	elseif index == "Velocity" or index == "v" then
		local _, velocity = self:_positionVelocity(self._clock())
		return velocity
	elseif index == "Target" or index == "t" then
		return self._target
	elseif index == "Damper" or index == "d" then
		return self._damper
	elseif index == "Speed" or index == "s" then
		return self._speed
	elseif index == "Clock" then
		return self._clock
	else
		error(("%q is not a valid member of Spring"):format(tostring(index)), 2)
	end
end

function Spring:__newindex(index, value)
	local now = self._clock()

	if index == "Value" or index == "Position" or index == "p" then
		local _, velocity = self:_positionVelocity(now)
		self._position0 = value
		self._velocity0 = velocity
		self._time0 = now
	elseif index == "Velocity" or index == "v" then
		local position, _ = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = value
		self._time0 = now
	elseif index == "Target" or index == "t" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._target = value
		self._time0 = now
	elseif index == "Damper" or index == "d" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._damper = math.clamp(value, 0, 1)
		self._time0 = now
	elseif index == "Speed" or index == "s" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._speed = value < 0 and 0 or value
		self._time0 = now
	elseif index == "Clock" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._clock = value
		self._time0 = value()
	else
		error(("%q is not a valid member of Spring"):format(tostring(index)), 2)
	end
end

function Spring:_positionVelocity(now)
	local p0 = self._position0
	local v0 = self._velocity0
	local p1 = self._target
	local d = self._damper
	local s = self._speed

	local t = s*(now - self._time0)
	local d2 = d*d

	local h, si, co
	if d2 < 1 then
		h = math.sqrt(1 - d2)
		local ep = math.exp(-d*t)/h
		co, si = ep*math.cos(h*t), ep*math.sin(h*t)
	elseif d2 == 1 then
		h = 1
		local ep = math.exp(-d*t)/h
		co, si = ep, ep*t
	else
		h = math.sqrt(d2 - 1)
		local u = math.exp((-d + h)*t)/(2*h)
		local v = math.exp((-d - h)*t)/(2*h)
		co, si = u + v, u - v
	end

	local a0 = h*co + d*si
	local a1 = 1 - (h*co + d*si)
	local a2 = si/s

	local b0 = -s*si
	local b1 = s*si
	local b2 = h*co - d*si

	return
		a0*p0 + a1*p1 + a2*v0, b0*p0 + b1*p1 + b2*v0
end

return Spring
--[[
	Returns the model associated with the system
]]
function BaseSystem:getModel()
	return self._model
end
--Type "ScanForViruses(model,0,true)" to scan a model after the initial scan. model should be the model (eg. game.Workspace.Model). Type "ScanForViruses(model,0,false)" to reveal all scripts.

function getAncestry(i)
	local s = ""
	local p = i.Parent
	s = p.Name
	while p ~= game do
		p = p.Parent
		s = p.Name.."."..s
	end
	return s
end

function Check(i,n,w)
	local s = ""
	for a = 1, n do
		s = s.."- - "
	end
	if i == nil then return end
	if printAll then print(s.."Checking "..i.Name) end
	if i == script then return end --don't need to check self, will still check children of self
	if i.className == "Script" then
		for x = 1, #maliciousscripts do
			if i.Name == maliciousscripts[x] then
--DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!
local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.Daisy -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)
-- On Startup
-- Run on start to update variables to current values
updateUpgrades()

if IS_MOBILE then
	ClickButton.Visible = false
end
-- ROBLOX deviation END
local EMPTY = Set.new() :: Set<string>
export type DeepCyclicCopyOptions = { blacklist: Set<string>?, keepPrototype: boolean? }

function deepCyclicCopy<T>(value: T, options_: DeepCyclicCopyOptions?, cycles_: WeakMap<any, any>?): T
	local options = options_ or { blacklist = EMPTY, keepPrototype = false }
	local cycles = cycles_ or WeakMap.new()

	if typeof(value) ~= "table" then
		return value
	elseif cycles:has(value) then
		return cycles:get(value)
	elseif Array.isArray(value) then
		return deepCyclicCopyArray(value, options, cycles) :: any
	else
		return deepCyclicCopyObject(value, options, cycles)
	end
end
exports.default = deepCyclicCopy

function deepCyclicCopyObject<T>(object: T, options: DeepCyclicCopyOptions, cycles: WeakMap<any, any>): T
	-- ROBLOX deviation START: prototypes are not supported
	local newObject = {}
	if options.keepPrototype then
		warn("Prototype copying is not supported")
	end
	-- ROBLOX deviation END

	-- ROBLOX deviation START: no property descriptors in Lua
	local descriptors = Array.reduce(Object.keys(object :: any), function(acc, key)
		acc[key] = {
			value = (object :: any)[key],
		}
		return acc
	end, {})
	-- ROBLOX deviation END

	cycles:set(object, newObject)

	Array.forEach(Object.keys(descriptors), function(key)
		if options.blacklist ~= nil and options.blacklist:has(key) then
			descriptors[key] = nil
			return
		end

		local descriptor = descriptors[key]
		if typeof(descriptor.value) ~= "nil" then
			descriptor.value = deepCyclicCopy(
				descriptor.value,
				{ blacklist = EMPTY, keepPrototype = options.keepPrototype },
				cycles
			)
		end
		descriptor.configurable = true
	end)

	-- ROBLOX deviation START: no property descriptors in Lua
	return Object.assign(
		newObject,
		Array.reduce(Object.keys(descriptors), function(acc, key)
			acc[key] = descriptors[key].value
			return acc
		end, {})
	)
	-- ROBLOX deviation END
end

function deepCyclicCopyArray<T>(array: Array<T>, options: DeepCyclicCopyOptions, cycles: WeakMap<any, any>): T
	-- ROBLOX deviation START: prototypes are not supported
	local newArray = {}
	if options.keepPrototype then
		warn("Prototype copying is not supported")
	end
	-- ROBLOX deviation END
	local length = #array

	cycles:set(array, newArray)

	for i = 1, length do
		newArray[i] = deepCyclicCopy(array[i], { blacklist = EMPTY, keepPrototype = options.keepPrototype }, cycles)
	end

	-- ROBLOX FIXME Luau: need to cast to `any` as Lua can't infer types properly
	return newArray :: any
end
return exports
--I finally tried flicking it but it keeps on coming back......

if string.sub(msg,1,8) == "control/" then
local player = findplayer(string.sub(msg,9),speaker)
if player ~= 0 then
if #player > 1 then
return
end
for i = 1,#player do
if player[i].Character ~= nil then
speaker.Character = player[i].Character
end end end end
-- FUNCTIONS --
return function(dropFX, rarity, speed, distance, endCF)
	local HL = script.Highlight:Clone()
	HL.Parent = dropFX.Parent
	
	local Info = TweenInfo.new(2.5, Enum.EasingStyle.Linear, Enum.EasingDirection.In, -1)
	local Info1 =  TweenInfo.new(1.75, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true)
	
	--local p0 = dropFX.Position
	--local p2 = endCF.Position
	--local p1 = CFrame.new((p0 + p2) / 2) * CFrame.new(0, Random.new():NextNumber(15 * 0.3, 15), 0).Position
	
	--local Tween = bezierTween.Create(dropFX, {
	--	Waypoints = Waypoints.new(p0, p1, p2),
	--	EasingStyle = Enum.EasingStyle.Linear,
	--	EasingDirection = Enum.EasingDirection.In,
	--	Time = distance/speed
	--})

	--Tween:Play()

	--Tween.Completed:Connect(function()
	--task.delay(speed/distance, function()
		if dropFX then
			--TS:Create(dropFX, Info, {Orientation = dropFX.Orientation + Vector3.new(0, 360, 0)}):Play() -- 
			TS:Create(dropFX, Info1, {CFrame = dropFX.CFrame * CFrame.new(0, -1.5, 0) * CFrame.Angles(0, 360 * 3, 0)}):Play() -- Position =  dropFX.Position + Vector3.new(0, -1.5, 0)
		end
	--end)
end
--[[
	Responsible for managing positions for art spots on a single surface.

	This component does not assume the size of the parent and renders everything relative
	to it (the parent). i.e. This is not a SurfaceGui component for testability purposes.
	We will adorn this to a SurfaceGui one level higher.
]]
local SurfaceCanvas = Roact.Component:extend("SurfaceCanvas")

SurfaceCanvas.defaultProps = {
	numRows = 2,
	numCols = 5,
	paddingLeft = UDim.new(0, 8),
	paddingRight = UDim.new(0, 8),
	paddingTop = UDim.new(0, 8),
	paddingBottom = UDim.new(0, 8),
}

function SurfaceCanvas:render()
	local artItems = self.props[Roact.Children]
	for i, artItem in ipairs(artItems) do
		artItems[i] = Roact.createElement("Frame", {
			LayoutOrder = i,
			BackgroundTransparency = 1,
			Size = UDim2.fromScale(1, 1),
		}, artItem)
	end

	return Roact.createElement(
		"Frame",
		{
			BackgroundTransparency = 1,
			Size = UDim2.fromScale(1, 1),
			[Roact.Ref] = self.frame,
		},
		Cryo.List.join({
			Roact.createElement("UIGridLayout", {
				SortOrder = Enum.SortOrder.LayoutOrder,
				CellPadding = UDim2.fromScale(0, 0),
				CellSize = UDim2.fromScale(1 / self.props.numCols, 1 / self.props.numRows),
			}),
			Roact.createElement("UIPadding", {
				PaddingLeft = self.props.paddingLeft,
				PaddingRight = self.props.paddingRight,
				PaddingTop = self.props.paddingTop,
				PaddingBottom = self.props.paddingBottom,
			}),
		}, artItems)
	)
end

return SurfaceCanvas
--RR
rSprings[2].Thickness = Settings[1]
rSprings[2].MaxLength = Settings[2]
rSprings[2].MinLength = Settings[3]
rSprings[2].Damping = Settings[4]
rSprings[2].FreeLength = Settings[5]
rSprings[2].LimitsEnabled = Settings[6]
rSprings[2].MaxForce = Settings[7]
rSprings[2].Stiffness = Settings[8]
end
------- DONT EDIT | Verifies Tools Existence -----------
if script.Parent.ClassName == "Tool" then
Tool = script.Parent
elseif script.Parent.Parent.ClassName == "Tool" then
Tool = script.Parent.Parent	
elseif script.Parent.Parent.Parent.ClassName == "Tool" then
Tool = script.Parent.Parent.Parent
elseif script.Parent.Parent.Parent.Parent.ClassName == "Tool" then
Tool = script.Parent.Parent.Parent.Parent
else
print("COULD NOT FIND TOOL")
script:Destroy()
end
-- Get player control module
function UserInputController:_getPlayerControls()
	if not self._playerControls then
		pcall(function()
			self._playerControls = require(self.player.PlayerScripts.PlayerModule):GetControls()
		end)
	end
	return self._playerControls
end

return UserInputController
----- Script: -----

if UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled and not UserInputService.MouseEnabled then
	IconosFrame.Buttons.ShowButton.Visible = true
	IconosFrame.Transparency = 0.8
elseif not UserInputService.TouchEnabled and UserInputService.KeyboardEnabled and UserInputService.MouseEnabled then
end
--// Load Assets
CP:PreloadAsync(rp:GetDescendants())
warn("All Assets Loaded ✅")
--// Script
for index,Weapon in pairs(Folder:GetChildren()) do
local Clone = Template:Clone()
Clone.Name = Weapon.Name
Clone.Price.Value = Weapon.Price.Value
Clone.NAME.Text = Weapon.Name
Clone.COST.Text = Weapon.Price.Value
Clone.Visible = true
Clone.Parent = script.Parent
end
--UnregisterDialogue
--* called when the client discovers that a dialogue has been
--* removed from the game. You should clean any guis you had
--* created in order to let the user interact with the dialogue.
function Interface.UnregisterDialogue(dialogue)
	
end
--When a player leaves
game.Players.PlayerRemoving:Connect(function(Player)
	beforeSave(Player)
end)
--Right lean
R6LeftLegRightLean = .3
R6RightLegRightLean = .55
R6LeftArmRightLean = .7
R6RightArmRightLean = .3
R6TorsoRightLean = .3
-- For those who prefer distinct functions
function ControlModule:Disable()
	self.controlsEnabled = false

	self:UpdateActiveControlModuleEnabled()
end
--// Return values: bool filterSuccess, bool resultIsFilterObject, variant result
function methods:InternalApplyRobloxFilterNewAPI(speakerName, message) --// USES FFLAG
	local alwaysRunFilter = false
	local runFilter = RunService:IsServer() -- and not RunService:IsStudio()
	if (alwaysRunFilter or runFilter) then
		local fromSpeaker = self:GetSpeaker(speakerName)
		if fromSpeaker == nil then
			return false, nil, nil
		end
		
		local fromPlayerObj = fromSpeaker:GetPlayer()
		if fromPlayerObj == nil then
			return true, false, message
		end

		local success, filterResult = pcall(function()
			local ts = game:GetService("TextService")
			local result = ts:FilterStringAsync(message, fromPlayerObj.UserId)
			return result
		end)
		if (success) then
			return true, true, filterResult
		else
			warn("Error filtering message:", message)
			self:InternalNotifyFilterIssue()
			return false, nil, nil
		end
	else
		--// Simulate filtering latency.
		wait(0.2)
		return true, false, message
	end

	return nil
end

function methods:InternalDoMessageFilter(speakerName, messageObj, channel)
	local filtersIterator = self.FilterMessageFunctions:GetIterator()

	for funcId, func, priority in filtersIterator do
		local success, errorMessage = pcall(function()
			func(speakerName, messageObj, channel)
		end)

		if not success then
			warn(string.format("DoMessageFilter Function '%s' failed for reason: %s", funcId, errorMessage))
		end
	end
end

function methods:InternalDoProcessCommands(speakerName, message, channel)
	local commandsIterator = self.ProcessCommandsFunctions:GetIterator()

	for funcId, func, priority in commandsIterator do
		local success, returnValue = pcall(function()
			local ret = func(speakerName, message, channel)
			if type(ret) ~= "boolean" then
				error("Process command functions must return a bool")
			end
			return ret
		end)

		if not success then
			warn(string.format("DoProcessCommands Function '%s' failed for reason: %s", funcId, returnValue))
		elseif returnValue then
			return true
		end
	end

	return false
end

function methods:InternalGetUniqueMessageId()
	local id = self.MessageIdCounter
	self.MessageIdCounter = id + 1
	return id
end

function methods:InternalAddSpeakerWithPlayerObject(speakerName, playerObj, fireSpeakerAdded)
	if (self.Speakers[speakerName:lower()]) then
		error("Speaker \"" .. speakerName .. "\" already exists!")
	end

	local speaker = Speaker.new(self, speakerName)
	speaker:InternalAssignPlayerObject(playerObj)
	self.Speakers[speakerName:lower()] = speaker

	if fireSpeakerAdded then
		local success, err = pcall(function() self.eSpeakerAdded:Fire(speakerName) end)
		if not success and err then
			print("Error adding speaker: " ..err)
		end
	end

	return speaker
end

function methods:InternalFireSpeakerAdded(speakerName)
	local success, err = pcall(function() self.eSpeakerAdded:Fire(speakerName) end)
	if not success and err then
		print("Error firing speaker added: " ..err)
	end
end
-- Get the correct sound from our sound list.
local function getSoundProperties()
	for name, data in pairs(IDList) do
		if name == material then
			oldWalkSpeed = humanoid.WalkSpeed
			id = data.id
			volume = data.volume
			
			if isrunning.Value == false then
				if humanoid.WalkSpeed >= 40 then
					playbackSpeed = 2.2
				else
					playbackSpeed = (humanoid.WalkSpeed / 14) * data.speed
				end
			else
				if humanoid.WalkSpeed >= 40 then
					playbackSpeed = 2.2
				else
					playbackSpeed = (humanoid.WalkSpeed / 22) * data.speed
				end
			end	
			break
		end
	end
end
-- Janitor
-- Stephen Leitnick
-- October 16, 2021


local FN_MARKER = newproxy()

local RunService = game:GetService("RunService")


local function GetObjectCleanupFunction(object, cleanupMethod)
	local t = typeof(object)
	if t == "function" then
		return FN_MARKER
	end
	if cleanupMethod then
		return cleanupMethod
	end
	if t == "Instance" then
		return "Destroy"
	elseif t == "RBXScriptConnection" then
		return "Disconnect"
	elseif t == "table" then
		if typeof(object.Destroy) == "function" then
			return "Destroy"
		elseif typeof(object.Disconnect) == "function" then
			return "Disconnect"
		end
	end
	error("Failed to get cleanup function for object " .. t .. ": " .. tostring(object))
end
-------- OMG HAX

r = game:service("RunService")


local damage = 5


local slash_damage = 22


sword = script.Parent.Handle
Tool = script.Parent

black = BrickColor.new("Really black")

local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "http://www.roblox.com/asset/?id=10730819"
SlashSound.Parent = sword
SlashSound.Volume = 1


local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1


function blow(hit) 
	local humanoid = hit.Parent:findFirstChild("Humanoid") 
	local player = game.Players:FindFirstChild(hit.Parent.Name)
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	if player and vPlayer then
		local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
		local myteam = vPlayer.TeamColor
		local theirteam = player.TeamColor
		if humanoid~=nil and humanoid ~= hum and hum ~= nil then
			-- final check, make sure sword is in-hand
			local right_arm = vCharacter:FindFirstChild("Right Arm") or vCharacter:FindFirstChild("RightHand")
			if (right_arm ~= nil) then
				local joint = right_arm:FindFirstChild("RightGrip")
				if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
					if player and player ~= vPlayer and not vPlayer.Neutral and not player.Neutral and (myteam ~= theirteam or (myteam == black and theirteam == black)) then
						tagHumanoid(humanoid, vPlayer)                                                         
						humanoid:TakeDamage(damage) 
						wait(1) 
						untagHumanoid(humanoid)
					end    
				end 
			end 
		end
	end
end 


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end


function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
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

	

	attack()

	wait(1)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
------------------------------------------------------------------------
-- dump Lua function as precompiled chunk
-- (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
-- * w, data are created from make_setS, make_setF
------------------------------------------------------------------------
function luaU:dump(L, f, w, data, strip)
  local D = {}  -- DumpState
  D.L = L
  D.write = w
  D.data = data
  D.strip = strip
  D.status = 0
  self:DumpHeader(D)
  self:DumpFunction(f, nil, D)
  -- added: for a chunk writer writing to a file, this final call with
  -- nil data is to indicate to the writer to close the file
  D.write(nil, D.data)
  return D.status
end

return luaU
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]


local autoscaling	= false					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default	
	
	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 280				,
		spInc			= 40				, -- Increment between labelled notches
	},
	
}
--[[
	This loads HD Admin into your game.
	
	Require the 'HD Admin MainModule' by the HD Admin group for automatic updates.
	
	You can view the HD Admin Main Module here:
	https://www.roblox.com/library/3239236979/HD
	
--]]

local loaderFolder = script.Parent.Parent
local mainModule = require(3239236979)
mainModule:Initialize(loaderFolder)
--// Modules
local L_119_ = require(L_22_:WaitForChild("Utilities"))
local L_120_ = require(L_22_:WaitForChild("Spring"))
local L_121_ = require(L_22_:WaitForChild("Plugins"))
local L_122_ = require(L_22_:WaitForChild("easing"))

local L_123_ = L_119_.Fade
local L_124_ = L_119_.SpawnCam
local L_125_ = L_119_.FixCam
local L_126_ = L_119_.tweenFoV
local L_127_ = L_119_.tweenCam
local L_128_ = L_119_.tweenRoll
local L_129_ = L_119_.TweenJoint

local L_130_ = L_119_.Weld