Pinkstack/roblox-luau-corpus-text huggingface dataset:
----------------------------------------------------------------------------------------------------
--------------------=[ CFRAME ]=--------------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,EnableHolster = false
	,HolsterTo = 'Torso'				 -- Put the name of the body part you wanna holster to
	,HolsterPos = CFrame.new(0,0,0) * CFrame.Angles(math.rad(0),math.rad(0),math.rad(0))
	
	,RightArmPos = CFrame.new(-.875, -0.2, -1.25) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Server
	,LeftArmPos = CFrame.new(1.2,-0.05,-1.65) * CFrame.Angles(math.rad(-120),math.rad(35),math.rad(-25))	--server
	
	,ServerGunPos = CFrame.new(-.3, -1, -0.4) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))
	,GunPos = CFrame.new(0.15, -0.15, 1) * CFrame.Angles(math.rad(90), math.rad(0), math.rad(0))

	,RightPos = CFrame.new(-.875, -0.2, -1.25) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Client
	,LeftPos = CFrame.new(0.85, 0.5,-2.2) * CFrame.Angles(math.rad(-120),math.rad(20),math.rad(-25))	--Client
}

return Config
--local Velocity = HumanoidRootPart.Velocity


Humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, not Down.Value)
if Down.Value == true then
	Humanoid:ChangeState(Enum.HumanoidStateType.Physics, Down.Value)
elseif Down.Value == false then
	Humanoid:ChangeState(Enum.HumanoidStateType.GettingUp, true)
end
-------------------------------------------


local weld2 = Instance.new("Weld")
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = CFrame.new(-0.5, 1, 0.6) * CFrame.fromEulerAnglesXYZ(math.rad(90),-0.1,-0.1)
arms[2].Name = "RDave"
arms[2].CanCollide = true
welds[2] = weld2
--Working lightswitch.



function ToggleLight()
	if script.Parent.Parent.Parent.LightState.Value == false then
		script.Parent.Parent.Parent.LightState.Value = true
		script.Parent.BrickColor = BrickColor.new("Sea green")
		script.Parent.Parent.Parent.Lamp.Light.BrickColor = BrickColor.new("White")
		script.Parent.Parent.Parent.Lamp.Light.SpotLight.Enabled = true
	else
		script.Parent.Parent.Parent.LightState.Value = false
		script.Parent.BrickColor = BrickColor.new("Bright red")
		script.Parent.Parent.Parent.Lamp.Light.BrickColor = BrickColor.new("Black")
		script.Parent.Parent.Parent.Lamp.Light.SpotLight.Enabled = false
	end
end

script.Parent.ClickDetector.MouseClick:connect(ToggleLight)
--[[
	Constructs a new state object which can listen for updates on another state
	object.

	FIXME: enabling strict types here causes free types to leak
]]



local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)
local Types = require(Package.Types)
local initDependency = require(Package.Dependencies.initDependency)

type Set<T> = {[T]: any}

local class = {}
local CLASS_METATABLE = {__index = class}
--// All global vars will be wiped/replaced except script



return function(data)
	local playergui = service.PlayerGui
	local localplayer = service.Players.LocalPlayer
	local gui = service.New("ScreenGui")
	local toggle = service.New("ImageButton", gui)
	local gTable = client.UI.Register(gui)

	if client.UI.Get("HelpButton", gui, true) then
		gui:Destroy()
		gTable:Destroy()
		return nil
	end

	gTable.Name = "HelpButton"
	gTable.CanKeepAlive = false

	toggle.Name = "Toggle"
	toggle.BackgroundTransparency = 1
	toggle.Position = UDim2.new(1, -45, 1, -45)
	toggle.Size = UDim2.new(0, 40, 0, 40)
	toggle.Image = "http://www.roblox.com/asset/?id=7059706594"
	toggle.ImageTransparency = 0

	--if client.UI.Get("Chat") then
	--	toggle.Position = UDim2.new(1, -(45+40),1, -45)
	--end

	toggle.MouseButton1Down:Connect(function()
		local found = client.UI.Get("UserPanel",nil,true)
		if found then
			found.Object:Destroy()
		else
			client.UI.Make("UserPanel",{})
		end
	end)

	gTable:Ready()
end
--[[
	Dispatch an action to the store. This allows the store's reducer to mutate
	the state of the application by creating a new copy of the state.

	Listeners on the changed event of the store are notified when the state
	changes, but not necessarily on every Dispatch.
]]


function Store:dispatch(action)
	if typeof(action) == "table" then
		if action.type == nil then
			error("action does not have a type field", 2)
		end

		self._state = self._reducer(self._state, action)
		self._mutatedSinceFlush = true
	else
		error(("actions of type %q are not permitted"):format(typeof(action)), 2)
	end
end
--[[
	
	Specialized library for the plane's camera.
	
	Note my inconsistency by using "." accessors
	for methods instead of ":" accessors. Sorry.
	
	
	CamLock.Update()   [Should be called every RenderStep]
	
	CamLock.Lock(planeModel)
	CamLock.Unlock()
	CamLock.SwitchView([reversed])
	CamLock.SetMobileDeviceBank(bank)
	CamLock.SetRotation(horizontalRadians, verticalRadians)
	CamLock.DeltaRotation(deltaHorizontalRadians, deltaVerticalRadians)
	CamLock.ResetRotation()
	
--]]
--Rescripted by Luckymaxer



Tool = script.Parent.Parent
Handle = Tool:WaitForChild("Handle")

Players = game:GetService("Players")

Gravity = 196.20
JumpHeightPercentage = 0.25

ToolEquipped = false

function GetAllConnectedParts(Object)
	local Parts = {}
	local function GetConnectedParts(Object)
		for i, v in pairs(Object:GetConnectedParts()) do
			local Ignore = false
			for ii, vv in pairs(Parts) do
				if v == vv then
					Ignore = true
				end
			end
			if not Ignore then
				table.insert(Parts, v)
				GetConnectedParts(v)
			end
		end
	end
	GetConnectedParts(Object)
	return Parts
end

function SetGravityEffect()
	if not GravityEffect or not GravityEffect.Parent then
		GravityEffect = Instance.new("BodyForce")
		GravityEffect.Name = "GravityCoilEffect"
		GravityEffect.Parent = Torso
	end
	local TotalMass = 0
	local ConnectedParts = GetAllConnectedParts(Torso)
	for i, v in pairs(ConnectedParts) do
		if v:IsA("BasePart") then
			TotalMass = (TotalMass + v:GetMass())
		end
	end
	local TotalMass = (TotalMass * 196.20 * (1 - JumpHeightPercentage))
	GravityEffect.force = Vector3.new(0, TotalMass, 0)
end

function HandleGravityEffect(Enabled)
	if not CheckIfAlive() then
		return
	end
	for i, v in pairs(Torso:GetChildren()) do
		if v:IsA("BodyForce") then
			v:Destroy()
		end
	end
	for i, v in pairs({ToolUnequipped, DescendantAdded, DescendantRemoving}) do
		if v then
			v:disconnect()
		end
	end
	if Enabled then
		CurrentlyEquipped = true
		ToolUnequipped = Tool.Unequipped:connect(function()
			CurrentlyEquipped = false
		end)
		SetGravityEffect()
		DescendantAdded = Character.DescendantAdded:connect(function()
			wait()
			if not CurrentlyEquipped or not CheckIfAlive() then
				return
			end
			SetGravityEffect()
		end)
		DescendantRemoving = Character.DescendantRemoving:connect(function()
			wait()
			if not CurrentlyEquipped or not CheckIfAlive() then
				return
			end
			SetGravityEffect()
		end)
	end
end

function CheckIfAlive()
	return (((Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Torso and Torso.Parent and Player and Player.Parent) and true) or false)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Humanoid = Character:FindFirstChild("Humanoid")
	Torso = Character:FindFirstChild("Torso") or Character:FindFirstChild("UpperTorso")
	Player = Players:GetPlayerFromCharacter(Character)
	if not CheckIfAlive() then
		return
	end
	if HumanoidDied then
		HumanoidDied:disconnect()
	end
	HumanoidDied = Humanoid.Died:connect(function()
		if GravityEffect and GravityEffect.Parent then
			GravityEffect:Destroy()
		end
	end)
	HandleGravityEffect(true)
	ToolEquipped = true
end

function Unequipped()
	if HumanoidDied then
		HumanoidDied:disconnect()
	end
	HandleGravityEffect(false)
	ToolEquipped = false
end

Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)
--[[Steering]]


	Tune.SteerInner		= 49		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 50		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .02		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 150		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree
	
	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness
-- Function to bind to equip event


local function equip()
	local character = player.Character
	local humanoid = character.Humanoid
	
	-- Setup joint variables
	if humanoid.RigType == Enum.HumanoidRigType.R6 then
		local torso = character.Torso
		neck = torso.Neck	
		shoulder = torso["Right Shoulder"]
		
	elseif humanoid.RigType == Enum.HumanoidRigType.R15 then
		neck = character.Head.Neck
		shoulder = character.RightUpperArm.RightShoulder
	end
	
	oldNeckC0 = neck.C0
	oldShoulderC0 = shoulder.C0
	
	-- Remember old mouse icon and update current
	oldIcon = mouse.Icon
	mouse.Icon = "http://www.roblox.com/asset/?id=79658449"
	
	-- Bind TouchMoved event if on mobile. Otherwise connect to renderstepped
	if userInputService.TouchEnabled then
		connection = userInputService.TouchMoved:connect(mobileFrame)
	else
		connection = render:connect(pcFrame)
	end
	
	-- Bind TouchStarted and TouchEnded. Used to determine if character should rotate
	-- during touch input
	userInputService.TouchStarted:connect(function(touch, processed)
		mobileShouldTrack = not processed
	end)	
	userInputService.TouchEnded:connect(function(touch, processed)
		mobileShouldTrack = false
	end)

	-- If game uses filtering enabled then need to update server while tool is
	-- held by character.
	if workspace.FilteringEnabled then
		while connection and connection.Connected do
			wait()
			game.ReplicatedStorage.ROBLOX_RocketUpdateEvent:FireServer(neck.C0, shoulder.C0)
		end
	end
end
--------------------------------------------------------------------------------------------------------------------------------------


function PressL(key)				
	if (key== "l") then
if (Activate==false) then
game.Players.LocalPlayer.Character.Helmet.LS.Light.Enabled=true
game.Players.LocalPlayer.Character.Helmet.Flashlight.Material = "Neon"
game.Players.LocalPlayer.Character.Helmet.Flashlight.BrickColor = BrickColor.new("Brick yellow")
Activate = true
elseif (Activate==true) then
	
game.Players.LocalPlayer.Character.Helmet.LS.Light.Enabled=false	
game.Players.LocalPlayer.Character.Helmet.Flashlight.Material = "SmoothPlastic"
game.Players.LocalPlayer.Character.Helmet.Flashlight.BrickColor = BrickColor.new("Black")
	Activate=false
		end
	end
end
Mouse.KeyDown:connect(PressL)
-- (Hat Giver Script - Loaded.)



debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "TopHat"
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(0,-0.25,0) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentPos = Vector3.new(0, 0.6, -0.170)
		wait(5)
		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
--[[
    Returns a new object of the registry's class and indexes it with the given key
]]


function Registry:add(key, ...)
	if self.objects[key] then
		warn(string.format("[Registry] - object already exists for key %s", tostring(key)))
		self:remove(key)
	end
	local object = self.class.new(key, ...)
	self.objects[key] = object
	return object
end
--Weld stuff here



MakeWeld(misc.Hood.Hinge,car.DriveSeat,"Motor",.1)
ModelWeld(misc.Hood.Parts,misc.Hood.Hinge)

MakeWeld(car.Misc.Wheel.W,car.DriveSeat,"Motor").Name="W"
ModelWeld(car.Misc.Wheel.Parts,car.Misc.Wheel.W)


car.DriveSeat.ChildAdded:connect(function(child)
	if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
		child.C0=CFrame.new(0,-.5,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)*CFrame.Angles(math.rad(13),0,0)
	end
end)
--------------------------UTIL LIBRARY-------------------------------


local Utility = {}
do
	local function FindCharacterAncestor(part)
		if part then
			local humanoid = part:FindFirstChildOfClass("Humanoid")
			if humanoid then
				return part, humanoid
			else
				return FindCharacterAncestor(part.Parent)
			end
		end
	end
	Utility.FindCharacterAncestor = FindCharacterAncestor

	local function Raycast(ray, ignoreNonCollidable: boolean, ignoreList: {Model})
		ignoreList = ignoreList or {}
		local hitPart, hitPos, hitNorm, hitMat = Workspace:FindPartOnRayWithIgnoreList(ray, ignoreList)
		if hitPart then
			if ignoreNonCollidable and hitPart.CanCollide == false then
				-- We always include character parts so a user can click on another character
				-- to walk to them.
				local _, humanoid = FindCharacterAncestor(hitPart)
				if humanoid == nil then
					table.insert(ignoreList, hitPart)
					return Raycast(ray, ignoreNonCollidable, ignoreList)
				end
			end
			return hitPart, hitPos, hitNorm, hitMat
		end
		return nil, nil
	end
	Utility.Raycast = Raycast
end

local humanoidCache = {}
local function findPlayerHumanoid(player: Player)
	local character = player and player.Character
	if character then
		local resultHumanoid = humanoidCache[player]
		if resultHumanoid and resultHumanoid.Parent == character then
			return resultHumanoid
		else
			humanoidCache[player] = nil -- Bust Old Cache
			local humanoid = character:FindFirstChildOfClass("Humanoid")
			if humanoid then
				humanoidCache[player] = humanoid
			end
			return humanoid
		end
	end
end
--[[
	The base part of a system component. A BaseSystem can be turned on and off, with a health amount. 
]]


local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
local CollectionService = game:GetService("CollectionService")
local TweenService = game:GetService("TweenService")

local ClassUtils = require(ReplicatedStorage.Dependencies.LuaUtils.ClassUtils)
local Logger = require(ReplicatedStorage.Dependencies.GameUtils.Logger)
local Constants = require(ReplicatedStorage.Source.Common.Constants)
local sendAlert = require(ServerStorage.Source.Common.sendAlert)
local translate = require(ReplicatedStorage.Dependencies.GameUtils.TranslateUtils).translate

local remotesFolder = ReplicatedStorage.Remotes
local CreateMarker = remotesFolder.CreateMarker
local DestroyMarker = remotesFolder.DestroyMarker

local DEFAULT_STARTING_HEALTH = 100
local DEFAULT_TOOLKIT_HEALING_AMOUNT = 45
local MONSTER_DAMAGE = 20
local MONSTER_DEBOUNCE_TIME = 4

local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Bounce, Enum.EasingDirection.Out)
-- ScreenSpace -> WorldSpace. Taking a screen width that you want that object to be
-- and a world width that is the size of that object, and returning the position to
-- put that object at to satisfy those.


function ScreenSpace.ScreenToWorldByWidth(x, y, screenWidth, worldWidth)
	local aspectRatio = ScreenSpace.AspectRatio()
	local hfactor = math.tan(math.rad(Workspace.CurrentCamera.FieldOfView)/2)
	local wfactor = aspectRatio*hfactor
	local sx, sy = ScreenSpace.ViewSizeX(), ScreenSpace.ViewSizeY()
	--
	local depth = - (sx * worldWidth) / (screenWidth * 2 * wfactor)
	--
	local xf, yf = x/sx*2 - 1, y/sy*2 - 1
	local xpos = xf * -wfactor * depth
	local ypos = yf *  hfactor * depth
	--
	return Vector3.new(xpos, ypos, depth)
end

return ScreenSpace
--[[
	If it exists, will remove the cached player character appearance of specified userId
]]


function CharacterAppearanceCache.removeCachedAppearance(userId)
	if not appearanceCache[tostring(userId)] then
		Logger.warn("Cannot remove cached appearance for user ", userId, " as it is does not exist")
		return
	end

	appearanceCache[userId] = nil
end

return CharacterAppearanceCache
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------




_L.Services.MarketplaceService.ProcessReceipt = function(receiptInfo)
	--- Reciept info
	local playerId = receiptInfo.PlayerId
	local productId, purchaseId = receiptInfo.ProductId, receiptInfo.PurchaseId
	local currencySpent, currencyType = receiptInfo.CurrencySpent, receiptInfo.CurrencyType
	local placeId = receiptInfo.PlaceIdWherePurchased
	
	--- Find the player instance from playerId (scans several times just in case)
	local function FindPlayer()
		local player = game.Players:GetPlayerByUserId(playerId)
		local attempts = 0
		while (not player) and attempts < 20 do
			wait(.2)
			player = game.Players:GetPlayerByUserId(playerId)
			attempts = attempts + 1
		end
		return player
	end
	
	--- Process product reciept
	local player = FindPlayer()
	if player then
		--print(productId)
		local productDir = Products.GetDir(productId)
		--print(productDir)
		local playerStats = _L.Saving.Get(player)
		if productDir and playerStats then
			--- Reward the player for purchasing this product based on the callback!
			local pass = false
			local pass2 = pcall(function()
				pass = productDir.Callback(player, receiptInfo)
			end)
			
			--- Success!
			if pass and pass2 then
				pcall(function()
					_L.Network.Fire("Product Bought", player, receiptInfo)
					_L.Signal.Fire("Product Bought", player, receiptInfo)
					_L.Analytics.Purchase("product", player.Name, productId)
				end)
				return Enum.ProductPurchaseDecision.PurchaseGranted
			end
		end
	end
	
	--- Failed, for some reason. Attempt to let the player know (if they are in the server)
	pcall(function()
		if player then
			_L.Network.Fire("Product Failed", player, receiptInfo)
			print("[bold]HUGE ISSUE: Failed to process product purchase! (plr: " .. player.Name .. " | id: " .. productId .. ") [/bold]", true)
		else
			print("[bold]HUGE ISSUE: Failed to process product purchase, could not find player! (plr: " .. playerId .. " | id: " .. productId .. ") [/bold]", true)
		end
	end)
	
	--
	return Enum.ProductPurchaseDecision.NotProcessedYet
end
--AGAIN DO NOT MESS WITH ANYTHING UNLESS YOU KNOW WHAT YOU'RE DOING
-- wat3r_l3g3nds


repeat wait() until game:GetService("Players").LocalPlayer.Character ~= nil
local runService = game:GetService("RunService")
local input = game:GetService("UserInputService")
local players = game:GetService("Players")

CanToggleMouse = {allowed = true; activationkey = Enum.KeyCode.F;} 	

local cam = game.Workspace.CurrentCamera
local player = players.LocalPlayer
local m = player:GetMouse()
m.Icon = "http://www.roblox.com/asset/?id=569021388" -- replaces mouse icon

local running = true
local freemouse = false
-- Body Movers:


MainPart.BodyPosition.MaxForce = Vector3.new(0,math.huge,0)
MainPart.BodyPosition.Position = Vector3.new(0,MainPart.Position.Y,0)
MainPart.BodyGyro.CFrame = MainPart.CFrame
MainPart.BodyGyro.MaxTorque = Vector3.new(math.huge,math.huge,math.huge)
MainPart.BodyVelocity.MaxForce = Vector3.new(math.huge,0,math.huge)
--		child.C0 = CFrame.new(0,-0.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0) --// Reposition player


		if child.Part1.Name == "HumanoidRootPart" then
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and (not player.PlayerGui:FindFirstChild("Screen")) then --// The part after the "and" prevents multiple GUI's to be copied over.
				GUI.CarSeat.Value = script.Parent --// Puts a reference of the seat in this ObjectValue, now you can use this ObjectValue's value to find the car directly.
				GUI:Clone().Parent = player.PlayerGui --// Compact version
				script.Parent.Parent.Body.Lights.RunL.Material = "Neon"
				script.Parent.Parent.Body.Lights.RunR.Material = "Neon"
				script.Parent.Parent.Body.Lights.RunL.BrickColor = BrickColor.new("Pearl")
				script.Parent.Parent.Body.Lights.RunR.BrickColor = BrickColor.new("Pearl")
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = true
				script.Parent.Parent.Body.Dash.DashSc.G.Enabled = true
			end
		end
	end
end)

script.Parent.ChildRemoved:connect(function(child)
	if child:IsA("Weld") then
		if child.Part1.Name == "HumanoidRootPart" then
			game.Workspace.CurrentCamera.FieldOfView = 70
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and player.PlayerGui:FindFirstChild("SS3") then
				player.PlayerGui:FindFirstChild("SS3"):Destroy()
				script.Parent.Parent.Body.Lights.RunL.Material = "SmoothPlastic"
				script.Parent.Parent.Body.Lights.RunR.Material = "SmoothPlastic"
				script.Parent.Parent.Body.Lights.RunL.BrickColor = BrickColor.new("Pearl")
				script.Parent.Parent.Body.Lights.RunR.BrickColor = BrickColor.new("Pearl")
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = false
				script.Parent.Parent.Body.Dash.DashSc.G.Enabled = false
			end
		end
	end	
end)
--[=[
	Queues up a wipe of all values. Data must load before it can be wiped.
]=]


function DataStoreStage:Wipe()
	return self._loadParent:Load(self._loadName, {})
		:Then(function(data)
			for key, _ in pairs(data) do
				if self._stores[key] then
					self._stores[key]:Wipe()
				else
					self:_doStore(key, DataStoreDeleteToken)
				end
			end
		end)
end

function DataStoreStage:Store(name, value)
	if self._takenKeys[name] then
		error(("[DataStoreStage] - Already have a writer for %q"):format(name))
	end

	if value == nil then
		value = DataStoreDeleteToken
	end

	self:_doStore(name, value)
end
--[[Drivetrain]]

	
	Tune.Config			= "AWD"		--"FWD" , "RWD" , "AWD"
	Tune.TorqueVector	= 0.1			--AWD ONLY, "-1" has a 100% front bias, "0" has a 50:50 bias, and "1" has a 100% rear bias. Can be any number between that range.
	
	--Differential Settings	
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 80		-- 1 - 100%
	Tune.RDiffLockThres	= 20		-- 0 - 100%
	Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]
	
	--Traction Control Settings
	Tune.TCSEnabled		= true		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)
--weld2


function module.weld2(base,target,tim)
	local weld = Instance.new("Weld")
	weld.Part0 = base
	weld.Part1 = target
	weld.C0 = target.CFrame:inverse() * base.CFrame
	weld.Parent = weld.Part1
	
	game.Debris:AddItem(target,tim)
end