Roblox/luau_corpus huggingface dataset:
--[=[
	Instantiates a new Janitor object.
	@return Janitor
]=]
function Janitor.new()
	return setmetatable({
		CurrentlyCleaning = false;
		[IndicesReference] = nil;
	}, Janitor)
end

export type Janitor = typeof(Janitor.new())
return Janitor
--// All global vars will be wiped/replaced except script

return function(data, env)
	if env then
		setfenv(1, env)
	end
	
	local playergui = service.PlayerGui
	local localplayer = service.Players.LocalPlayer
	local scr = client.UI.Prepare(script.Parent.Parent)
	local main = scr.Main
	local t1 = main.Title
	local t2 = main.Message
	local msg = data.Message
	local color = data.Color

	local found = client.UI.Get("Output")
	if found then
		for i,v in pairs(found) do
			local p = v.Object
			if p and p.Parent then
				p.Main.Position = UDim2.new(0, 0, 0.35, p.Main.Position.Y.Offset+50)
			end
		end
	end

	t2.Text = msg
	
	spawn(function()
		local sound = Instance.new("Sound",service.LocalContainer())
		sound.SoundId = "rbxassetid://7152562261"
		sound.Volume = 0.1
		sound:Play()
		wait(0.8)
		sound:Destroy()
	end)

	main.Size = UDim2.new(1, 0, 0, 0)
	gTable.Ready()
	main:TweenSize(UDim2.new(1, 0, 0, 50), Enum.EasingDirection.Out, Enum.EasingStyle.Quad, 0.1)
	wait(5)
	gTable.Destroy()
end
--Close MainFrame
function module:CloseMainFrame()
	TopBarButton.ImageRectOffset = Vector2.new(0,0)
	mainFrame.Visible = false
end
module:CloseMainFrame()
updateDragBar()
--[=[
	Gets the value in the children

	@param parent Instance
	@param instanceType string
	@param name string
	@param default any?
	@return any
]=]
function ValueBaseUtils.getValue(parent, instanceType, name, default)
	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
	assert(type(name) == "string", "Bad argument 'name'")

	local foundChild = parent:FindFirstChild(name)
	if foundChild then
		if foundChild:IsA(instanceType) then
			return foundChild.Value
		else
			warn(("[ValueBaseUtils.getValue] - Value of type %q of name %q is of type %q in %s instead")
				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
			return nil
		end
	else
		return default
	end
end
--[[
	Indents a list of strings and then concatenates them together with newlines
	into a single string.
]]
local function indentLines(lines, indentLevel)
	local outputBuffer = {}

	for _, line in ipairs(lines) do
		table.insert(outputBuffer, indent(line, indentLevel))
	end

	return table.concat(outputBuffer, "\n")
end

local logInfoMetatable = {}
-- functions

local function ProcessReceipt(receiptInfo)
	local player	= Players:GetPlayerByUserId(receiptInfo.PlayerId)
	if player then
		if receiptInfo.ProductId == TIER_SKIP_ID then
			print(player.Name .. " skipped a tier")
			local success	= script.Parent.Ranking.RankingScript.SkipTier:Invoke(player)
			if success then
				return Enum.ProductPurchaseDecision.PurchaseGranted
			else
				return Enum.ProductPurchaseDecision.NotProcessedYet
			end
		elseif CURRENCY_IDS[receiptInfo.ProductId] then
			local tickets		= CURRENCY_IDS[receiptInfo.ProductId]
			local playerData	= PLAYER_DATA:FindFirstChild(player.Name)
			
			if playerData then
				print(player, "purchased", tickets, "tickets")
				playerData.Currency.Tickets.Value	= playerData.Currency.Tickets.Value + tickets
				local success	= script.Parent.DataScript.SaveData:Invoke(player)
				if success then
					return Enum.ProductPurchaseDecision.PurchaseGranted
				else
					return Enum.ProductPurchaseDecision.NotProcessedYet
				end
			else
				return Enum.ProductPurchaseDecision.NotProcessedYet
			end
		end
	else
		return Enum.ProductPurchaseDecision.NotProcessedYet
	end
end
-- ================================================================================
-- LOCAL FUNCTIONS
-- ================================================================================
-- Apply Gamepad Deadzone
local function ApplyDeadzone(n)
	if math.abs(n) < GAMEPAD_DEADZONE then return 0 end
	return (n + (n > 0 and -GAMEPAD_DEADZONE or GAMEPAD_DEADZONE)) / (1 - GAMEPAD_DEADZONE)
end -- ApplyDeadzone()

local function UpdateBoost(boost, step)	
	-- Update boost amount
	if boost and boostAmount > step then
		boostAmount = boostAmount - step
	elseif ((boostAmount >= 0) and (boostAmount < maxBoostAmount)) then
		-- Restore boost when boost is off (restores at half speed of use rate)
		boostAmount = boostAmount + step/2
		boost = false 
	end
	
	return boost
end
-- Basic settings
local ROTATION_SPEED = math.pi * 4.5

local plr = game.Players.LocalPlayer
local tweenService = game:GetService("TweenService")

game.ReplicatedStorage.Interactions.Client.BeginKnifeThrow.OnClientEvent:connect(function(knife, rotateAxis, velocity)
	
	-- Connect end knife throw
	local stopLoop = false
	local finalCFrame = nil
	local endEvent = game.ReplicatedStorage.Interactions.Client.EndKnifeThrow.OnClientEvent:connect(function(otherKnife, cframe)
		if otherKnife == knife then
			stopLoop = true
			finalCFrame = cframe
		end
	end)
	
	-- Make knife move smoothly
	local currentTween = nil
	while not stopLoop do
	
		-- Wait
		local waitTime = wait()
		
		-- Tween
		local rotateAmt = rotateAxis * (-ROTATION_SPEED) * waitTime
		local goal = {
			CFrame = (knife.CFrame + (velocity * waitTime)) * CFrame.fromEulerAnglesXYZ(rotateAmt.X, rotateAmt.Y, rotateAmt.Z)
		}
		currentTween = tweenService:Create(knife, TweenInfo.new(waitTime, Enum.EasingStyle.Linear, Enum.EasingDirection.Out), goal)
		currentTween:Play()
		
	end
	
	-- Disconnect event
	endEvent:disconnect()
	
	-- End tween
	if currentTween ~= nil then
		currentTween:Cancel()
	end
	
	-- Set final CFrame
	if knife.Parent ~= nil and finalCFrame ~= nil then
		knife.CFrame = finalCFrame
	end
	
end)
-- Modifies an array of path parts in place by interpreting "." and ".." segments
function Path:_normalizeArray(parts: Array<string>, isrelative: boolean)
	local skip = 0
	for i = #parts, 1, -1 do
		local part = parts[i]
		if part == "." then
			table.remove(parts, i)
		elseif part == ".." then
			table.remove(parts, i)
			skip = skip + 1
		elseif skip > 0 then
			table.remove(parts, i)
			skip = skip - 1
		end
	end
	if isrelative then
		while skip > 0 do
			table.insert(parts, 1, "..")
			skip = skip - 1
		end
	end
end

function Path:_splitBySeparators(filepath: string)
	local parts = {}
	for part in filepath:gmatch("[^" .. self.sep .. "]+") do
		parts[#parts + 1] = part
	end
	return parts
end

function Path:normalize(filepath: string)
	filepath = self:normalizeSeparators(filepath)
	local is_absolute = self:isAbsolute(filepath)
	local root = is_absolute and self:getRoot(filepath) or nil
	local trailing_slash = filepath:sub(#filepath) == self.sep

	if root then
		filepath = filepath:sub(root:len() + 1)
	end

	local parts = self:_splitBySeparators(filepath)
	self:_normalizeArray(parts, not is_absolute)
	filepath = table.concat(parts, self.sep)

	if #filepath == 0 then
		if is_absolute then
			return root
		end
		return "."
	end
	if trailing_slash then
		filepath = filepath .. self.sep
	end
	if is_absolute then
		filepath = root .. filepath
	end
	return filepath
end

function Path:_filterparts(parts: Array<string>)
	local filteredparts = {}
	-- filter out empty parts
	for i, part in ipairs(parts) do
		if part and part ~= "" then
			table.insert(filteredparts, part)
		end
	end
	for i, part in ipairs(filteredparts) do
		-- Strip leading slashes on all but first item
		if i > 1 then
			while part:sub(1, 1) == self.sep do
				part = part:sub(2)
			end
		end
		-- Strip trailing slashes on all but last item
		if i < #filteredparts then
			while part:sub(#part) == self.sep do
				part = part:sub(1, #part - 1)
			end
		end
		filteredparts[i] = part
	end
	return filteredparts
end

function Path:_rawjoin(parts: Array<string>)
	return table.concat(parts, self.sep)
end

function Path:_filteredjoin(...: string)
	local parts: Array<string> = { ... }
	for i, part in ipairs(parts) do
		parts[i] = self:normalizeSeparators(part)
	end
	local filteredparts = self:_filterparts(parts)
	local joined = self:_rawjoin(filteredparts)
	return joined, filteredparts
end

function Path:join(...: string)
	local joined = self:_filteredjoin(...)
	return self:normalize(joined)
end
----------------//
UIS.InputBegan:connect(function(i,GP) if not GP then if i.KeyCode == KeyCode then Inn:play() end end end)
UIS.InputEnded:connect(function(i,GP) if not GP then if i.KeyCode == KeyCode then Out:play() end end end)
-- ROBLOX TODO: Not sure how to model this, upstream: https://github.com/facebook/flow/blob/main/tests/react_instance/class.js#L10
-- ROBLOX FIXME Luau: if I make this Object, we run into normalization issues: '{| current: React_ElementRef<any>? |}' could not be converted into '(((?) -> any) | {| current: ? |})?
export type React_ElementRef<C> = C

export type React_Ref<ElementType> =
	{ current: React_ElementRef<ElementType> | nil }
	| ((React_ElementRef<ElementType> | nil) -> ())
-- Note: Overrides base class GetIsJumping with get-and-clear behavior to do a single jump
-- rather than sustained jumping. This is only to preserve the current behavior through the refactor.
function DynamicThumbstick:GetIsJumping()
	local wasJumping = self.isJumping
	self.isJumping = false
	return wasJumping
end

function DynamicThumbstick:Enable(enable: boolean?, uiParentFrame): boolean?
	if enable == nil then return false end			-- If nil, return false (invalid argument)
	enable = enable and true or false				-- Force anything non-nil to boolean before comparison
	if self.enabled == enable then return true end	-- If no state change, return true indicating already in requested state

	if enable then
		-- Enable
		if not self.thumbstickFrame then
			self:Create(uiParentFrame)
		end

		self:BindContextActions()
	else
		ContextActionService:UnbindAction(DYNAMIC_THUMBSTICK_ACTION_NAME)
		-- Disable
		self:OnInputEnded() -- Cleanup
	end

	self.enabled = enable
	self.thumbstickFrame.Visible = enable
	return nil
end
--- Skill
local UIS = game:GetService("UserInputService")
local plr = game.Players.LocalPlayer
local Mouse = plr:GetMouse()
local Debounce = true
Player = game.Players.LocalPlayer
local Track1 : Animation = script:WaitForChild("Anim01")
Track1 = Player.Character:WaitForChild("Humanoid"):LoadAnimation(script.Anim01)
local PrevWalkSpeed = nil
local Tween = game:GetService("TweenService")
local Gui = Player.PlayerGui:WaitForChild("Mochi_Skill_List".. Player.Name):WaitForChild("Frame")

local Cooldown = 5

UIS.InputBegan:Connect(function(Input)
	if Input.KeyCode == Enum.KeyCode.X and Debounce == true and Tool.Equip.Value == true and Tool.Active.Value == "None" then
		Tool.Active.Value = "2BurningDough"
		PrevWalkSpeed = Player.Character:WaitForChild("Humanoid").WalkSpeed
		Gui:FindFirstChild(Tool.Active.Value).Frame.Size = UDim2.new(1, 0, 1, 0)
		Player.Character:WaitForChild("Humanoid").WalkSpeed = 5
		Track1:Play()
		Track1:AdjustSpeed(0)
		wait(0.15)
		script.Fire:FireServer("hold")
	end
end)

UIS.InputEnded:Connect(function(Input)
	if Input.KeyCode == Enum.KeyCode.X and Debounce == true and Tool.Equip.Value == true and Tool.Active.Value == "2BurningDough" then
		Debounce = false
		Tool.Active.Value = "2BurningDough"
		Track1:AdjustSpeed(1)
		wait(0.1)
		script.Fire:FireServer(plr)
		local hum =  Player.Character.Humanoid
		for i = 1,10 do
			wait()
			hum.CameraOffset = Vector3.new(
				math.random(-1,1),
				math.random(-1,1),
				math.random(-1,1))
		end
		hum.CameraOffset = Vector3.new(0,0,0)
		Tween:Create(Gui:FindFirstChild(Tool.Active.Value).Frame, TweenInfo.new(Cooldown), {Size = UDim2.new(0, 0, 1, 0)}):Play()
		Tool.Active.Value = "None"
		Player.Character:WaitForChild("Humanoid").WalkSpeed = PrevWalkSpeed
		wait(Cooldown)
		Debounce = true
	end
end)
-- connect up

function stopLoopedSounds()
	sRunning:Stop() 
	sClimbing:Stop()
	sSwimming:Stop()
end

if hasPlayer == nil then
	Humanoid.Died:connect(onDied)
	Humanoid.Running:connect(onRunning)
	Humanoid.Swimming:connect(onSwimming)
	Humanoid.Climbing:connect(onClimbing)
	Humanoid.Jumping:connect(function(state) onStateNoStop(state, sJumping) prevState = "Jump" end)
	Humanoid.GettingUp:connect(function(state) stopLoopedSounds() onStateNoStop(state, sGettingUp) prevState = "GetUp" end)
	Humanoid.FreeFalling:connect(function(state) stopLoopedSounds() onStateFall(state, sFreeFalling) prevState = "FreeFall" end)
	Humanoid.FallingDown:connect(function(state) stopLoopedSounds() end)
	Humanoid.StateChanged:connect(function(old, new) 
		if not (new.Name == "Dead" or 
				new.Name == "Running" or 
				new.Name == "RunningNoPhysics" or 
				new.Name == "Swimming" or 
				new.Name == "Jumping" or 
				new.Name == "GettingUp" or 
				new.Name == "Freefall" or 
				new.Name == "FallingDown") then
			stopLoopedSounds()
		end
	end)
end
--[[
{Madwork}

-[RateLimiter]---------------------------------------
	Prevents RemoteEvent spamming; Player references are automatically removed as they leave
	
	Members:
	
		RateLimiter.Default   [RateLimiter]
	
	Functions:
	
		RateLimiter.NewRateLimiter(rate) --> [RateLimiter]
			rate   [number] -- Events per second allowed; Excessive events are dropped
			
	Methods [RateLimiter]:
	
		RateLimiter:CheckRate(source) --> is_to_be_processed [bool] -- Whether event should be processed
			source   [any]
			
		RateLimiter:CleanSource(source) -- Forgets about the source - must be called for any object that
			has been passed to RateLimiter:CheckRate() after that object is no longer going to be used;
			Does not have to be called for Player instances!
			
		RateLimiter:Cleanup() -- Forgets all sources
		
		RateLimiter:Destroy() -- Make the RateLimiter module forget about this RateLimiter object
	
--]]

local SETTINGS = {
	DefaultRateLimiterRate = 120,
}
--[=[
	@param observer (any) -> nil
	@return Connection
	Observes the value of the property. The observer will
	be called right when the value is first ready, and
	every time the value changes. This is safe to call
	immediately (i.e. no need to use `IsReady` or `OnReady`
	before using this method).

	Observing is essentially listening to `Changed`, but
	also sends the initial value right away (or at least
	once `OnReady` is completed).

	```lua
	local function ObserveValue(value)
		print(value)
	end

	clientRemoteProperty:Observe(ObserveValue)
	```
]=]
function ClientRemoteProperty:Observe(observer: (any) -> nil)
	if self._ready then
		task.defer(observer, self._value)
	end
	return self.Changed:Connect(observer)
end
-- Color shortcuts: you can use these strings instead of defining exact color values
richText.ColorShortcuts = {}
richText.ColorShortcuts.White = Color3.new(1, 1, 1)
richText.ColorShortcuts.Black = Color3.new(0, 0, 0)
richText.ColorShortcuts.Red = Color3.new(1, 0.4, 0.4)
richText.ColorShortcuts.Green = Color3.new(0.4, 1, 0.4)
richText.ColorShortcuts.Blue = Color3.new(0.4, 0.4, 1)
richText.ColorShortcuts.Cyan = Color3.new(0.4, 0.85, 1)
richText.ColorShortcuts.Orange = Color3.new(1, 0.5, 0.2)
richText.ColorShortcuts.Yellow = Color3.new(1, 0.9, 0.2)
--Stoppie tune
local StoppieD = 15
local StoppieTq = 65
local StoppieP = 10
local StoppieMultiplier = 1
local StoppieDivider = 2

local clock = .0667 --How fast your wheelie script refreshes
--// Ammo Settings			
	Ammo = 6;
	StoredAmmo = 6;
	MagCount = math.huge; --  If you want infinate ammo, set to math.huge EX. MagCount = math.huge;
	ExplosiveAmmo = 0;
--adjustspeed
function module.adjustSpeed(anim, hum ,speed)
	local animation = hum.Animator:LoadAnimation(animFold[anim])
	animation:Play()
	animation:AdjustSpeed(speed)
	
end
--Itochu Code Panel Script
Codes = {1234,1337,9001} --Your code(Support multiple codes)
Input = ""

InputDisabled = false
Code = true

Panel = script.Parent

if Code then Panel.Code.Material = "Neon" end

function DoInput(Data)
	if InputDisabled or not Code then return end
	if string.len(Input) ~= 4 then
		Input = Input..Data
	end
	if string.len(Input) == 4 then
		local Accepted = false
		for _,l in pairs(Codes) do
			if tostring(l) == Input then Accepted = true end
		end
		if Accepted then 
			Panel.Code.Material = "SmoothPlastic"
			Panel.Access.Material = "Neon"
			YourFunc()
		else
			Panel.Code.Material = "SmoothPlastic"
			Panel.Denied.Material = "Neon"
		end
		wait(2)
		Input = ""
		if Code then
			Panel.Code.Material = "Neon"
		end
		Panel.Access.Material = "SmoothPlastic"
			Panel.Denied.Material = "SmoothPlastic"
	end
end

function YourFunc() --Script your function here
	script.Parent.Parent.Open.Value = true --For Teknikk Automatic Door
end

for _,l in pairs(script.Parent:GetChildren()) do
	if l.Name:sub(1,3) == "BTN" then
		l.ClickDetector.mouseClick:connect(function()
			DoInput(tonumber(l.Name:sub(4)))	
		end)	
	end
end


for _,l in pairs(script.Parent:GetChildren()) do
	if l.Name:sub(1,2) == "BT" then
		l.ClickDetector.mouseClick:connect(function()
			Panel.Main.Beep:Play()
		end)	
	end
end
--	local gateControlNewClone = gateControlNew:Clone()
--	gateControlNewClone.Parent = touchToClaim
--	gateControlNewClone.Disabled = false
			
		--local gateControlNewClone = gateControlNew:Clone()
		--gateControlNewClone.Parent = touchToClaim
		--gateControlNewClone.Disabled = false
--[[
	Server Module
--]]

local Settings = { --, not ; ? | server module!!
	 BulletHoleTexture = 'http://www.roblox.com/asset/?id=64291961'
	,Damage = {40, 60}
	,OneHanded = false --DONT USE YET
	,FakeArms = true
    ,FakeArmTransparency = 0
    ,RightPos = CFrame.new(-1,0.7,0.45) * CFrame.Angles(math.rad(-90), 0, 0)
	,LeftPos = CFrame.new(0.8,0.8,0.3) * CFrame.Angles(math.rad(-90), math.rad(45), 0)
}

return Settings
-- Customization
	AntiTK = false; -- Set to false to allow TK and damaging of NPC, true for no TK. (To damage NPC, this needs to be false)
	
	MouseSense = 0.5;

	CanAim = true; -- Allows player to aim
	CanBolt = false; -- When shooting, if this is enabled, the bolt will move (SCAR-L, ACR, AK Series)
	
	LaserAttached = false;
	LightAttached = false;
	TracerEnabled = false;
	
	SprintSpeed = 0;
	
	CanCallout = false;
	SuppressCalloutChance = 0;
--Categorises a model based on the location of the start and end points of the path in the model
function RoomPackager:CategoriseModel(pathModel)
	if pathModel:FindFirstChild("EndParts") then
		return game.ReplicatedStorage.PathModules.Branch
	elseif pathModel.ObjectPrimaryPart.PathName.Value == "Start" then
		return game.ReplicatedStorage.PathModules.StartModule
	elseif pathModel.Start.Position.Y < pathModel.End.Position.Y - 5 then
		return game.ReplicatedStorage.PathModules.GoingUp
	elseif pathModel.Start.Position.Y > pathModel.End.Position.Y + 5 then
		return game.ReplicatedStorage.PathModules.GoingDown
	else
		return game.ReplicatedStorage.PathModules.SameHeight
	end
end

local function addBehavioursRecur(model, behaviourFolder)
	local children = model:GetChildren()
	for i = 1, #children do
		if children[i]:isA("BasePart") then
			behaviourFolder:Clone().Parent = children[i]
		else
			addBehavioursRecur(children[i], behaviourFolder)
		end
	end
end

RoomPackager.setUpBehaviours = function(roomModel)
	if roomModel:FindFirstChild("Behaviours") then
		addBehavioursRecur(roomModel, roomModel.Behaviours)
		return
	end
	local children = roomModel:GetChildren()
	for i = 1, #children do
		RoomPackager.setUpBehaviours(children[i])
	end
end

function RoomPackager:PackageRoom(roomBasePlate)
	local roomModel = Instance.new("Model")
	roomModel.Name = roomBasePlate.PathName.Value
	roomModel.Parent = game.ReplicatedStorage.PathModules
	
	local region = self:RegionFromBasePlate(roomBasePlate)
	local modelFound = false
	
	--Repeatedly finds 100 parts in the region, if the parts are seperated into different models more than 100 parts can be used
	while true do
		local parts = game.Workspace:FindPartsInRegion3(region, nil, 100)
		for _, part in pairs(parts) do	
			if part.Name == "End" and roomModel:FindFirstChild("End") then
				local endsModel = Instance.new("Model") --Used for branching the path
				endsModel.Name = "EndParts"
				endsModel.Parent = roomModel
				part.Parent = endsModel
				roomModel:FindFirstChild("End").Parent = endsModel
			elseif part.Name == "End" and roomModel:FindFirstChild("EndParts") then
				part.Parent = roomModel:FindFirstChild("EndParts")
			else
				local topLevelParent = closestParentToWorkspace(part)
				if topLevelParent ~= nil then
					if topLevelParent ~= part.Parent then
						--A model has been found, this means we will search again for more parts in the region
						modelFound = true
					end
					topLevelParent.Parent = roomModel
				end
			end
		end
		if modelFound == false then
			break
		else
			modelFound = false
		end
	end
	
	--Set-up model for use in the path (parts for locating the path are made transparent)
	roomModel.ObjectPrimaryPart.Transparency = 1
	roomModel.Start.Transparency = 1
	if roomModel:FindFirstChild("EndParts") then
		local ends = roomModel:FindFirstChild("EndParts"):GetChildren()
		for i = 1, #ends do
			ends[i].Transparency = 1	
		end
	else		
		roomModel.End.Transparency = 1
	end
	roomModel.PrimaryPart = roomModel.ObjectPrimaryPart
	roomModel.Parent = self:CategoriseModel(roomModel)
	RoomPackager.setUpBehaviours(roomModel)
	return roomModel
end

return RoomPackager
----------------------------------------------------------------------------------------------------
------------------=[ Status UI ]=-------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,EnableStatusUI 	= true				--- Don't disabled it...
	,RunWalkSpeed 		= 24
	,NormalWalkSpeed 	= 12
	,SlowPaceWalkSpeed 	= 6	
	,CrouchWalkSpeed 	= 6
	,ProneWalksSpeed 	= 3
	
	,InjuredWalksSpeed 		= 8
	,InjuredCrouchWalkSpeed = 4

	,EnableHunger = true				--- Hunger and Thirst system 		(Removed)
	,HungerWaitTime = 25

	,CanDrown = true 					--- Glub glub glub *ded*
	
	,EnableStamina = true 				--- Weapon Sway based on stamina	(Unused)
	,RunValue = 1						--- Stamina consumption
	,StandRecover = .25					--- Stamina recovery while stading
	,CrouchRecover = .5					--- Stamina recovery while crouching
	,ProneRecover = 1					--- Stamina recovery while lying

	,EnableGPS = true					--- GPS shows your allies around you
	,GPSdistance = 150

	,InteractionMenuKey = Enum.KeyCode.LeftAlt
	
	,BuildingEnabled = true
	,BuildingKey = Enum.KeyCode.RightAlt
--Hinge Creation--

local wheelFL = Instance.new("HingeConstraint", FL)
wheelFL.Attachment0 = FL.Attachment
wheelFL.Attachment1 = xSSL.Attachment
wheelFL.ActuatorType = "Motor"
wheelFL.MotorMaxTorque = 200000

local wheelFR = Instance.new("HingeConstraint", FR)
wheelFR.Attachment0 = FR.Attachment
wheelFR.Attachment1 = xSSR.Attachment
wheelFR.ActuatorType = "Motor"
wheelFR.MotorMaxTorque = 200000

local wheelRL = Instance.new("HingeConstraint", RL)
wheelRL.Attachment0 = RL.Attachment
wheelRL.Attachment1 = zBRL.Wheel
wheelRL.ActuatorType = "Motor"
wheelRL.MotorMaxTorque = 200000

local wheelRR = Instance.new("HingeConstraint", RR)
wheelRR.Attachment0 = RR.Attachment
wheelRR.Attachment1 = zBRR.Wheel
wheelRR.ActuatorType = "Motor"
wheelRR.MotorMaxTorque = 200000