Roblox/luau_corpus huggingface dataset:
--[[
	Event functions
]]

local function onHeartbeat()
	if target then
		-- Point towards the enemy
		maid.alignOrientation.Enabled = true
		maid.worldAttachment.CFrame = CFrame.new(maid.humanoidRootPart.Position, target.Position)
	else
		maid.alignOrientation.Enabled = false
	end

	if target then
		local inAttackRange = (target.Position - maid.humanoidRootPart.Position).magnitude <= ATTACK_RANGE + 1

		if inAttackRange then
			if not attacking and tick() - lastAttackTime > ATTACK_DELAY then
				attack()
			end
		else
			runToTarget()
		end
	end

	-- Check if the current target no longer exists or is not attackable
	if not target or not isInstaceAttackable(target) then
		findTargets()
	end
end

local function died()
	target = nil
	attacking = false
	newTarget = nil
	searchParts = nil
	searchingForTargets = false

	maid.heartbeatConnection:Disconnect()

	maid.humanoidRootPart.Anchored = true
	maid.deathAnimation:Play()
	
	wait(maid.deathAnimation.Length * 0.65)
	
	maid.deathAnimation:Stop()
	maid.humanoidRootPart.Anchored = false

	if RAGDOLL_ENABLED then
		Ragdoll(maid.instance, maid.humanoid)
	end

	if DESTROY_ON_DEATH then
		delay(DEATH_DESTROY_DELAY, function()
			destroy()
		end)
	end
end
-- declarations
local toolAnim = "None"
local toolAnimTime = 0

local jumpAnimTime = 0
local jumpAnimDuration = 0.3

local toolTransitionTime = 0.1
local fallTransitionTime = 0.3
local jumpMaxLimbVelocity = 0.75
--[[Initialize]]

	script.Parent:WaitForChild("A-Chassis Interface")
	script.Parent:WaitForChild("Plugins")
	script.Parent:WaitForChild("README")
	
	local car=script.Parent.Parent
	local _Tune=require(script.Parent)

	wait(_Tune.LoadDelay)

	--Update Checker
	
	if _Tune.AutoUpdate then
		local newModel 
		local s,m = pcall(function() newModel = game:GetService("InsertService"):LoadAsset(5181235975) end)
		if s then
			local MinorUpdate = false
			local MajorUpdate = false
			local ChassisUpdate = false
			local lChassis = script.Parent["A-Chassis Interface"].Version.Chassis
			local nChassis = newModel["A-Chassis 6C by Novena"]["A-Chassis Tune"]["A-Chassis Interface"].Version:FindFirstChild("Chassis")
			local localVersion = script.Parent["A-Chassis Interface"].Version
			local newVersion = newModel["A-Chassis 6C by Novena"]["A-Chassis Tune"]["A-Chassis Interface"].Version
			if nChassis~=nil then
				if lChassis.Value < nChassis.Value then
					ChassisUpdate = true
				end
			end
			if localVersion.Value < newVersion.Value or localVersion.LastMajorUpdate.Value < newVersion.LastMajorUpdate.Value then
				if localVersion.LastMajorUpdate.Value < newVersion.LastMajorUpdate.Value then
					MajorUpdate = true
				else
					MinorUpdate = true
				end
			end
			if ChassisUpdate then
				print("[AC6C]: Chassis update!"
						.."\nA-Chassis 6C has been updated to "..(nChassis.Value/10).."."
						.."\nThe changes cannot be ported due to the update."
						.."\nYou are advised to update your chassis ASAP.")
			elseif MajorUpdate then
				print("[AC6C]: Major update!"
						.."\nA major update to A-Chassis 6C has been found."
						.."\nThe changes cannot be ported due to the update."
						.."\nYou are advised to update your chassis ASAP.")
			elseif MinorUpdate then
				localVersion.Value = newVersion.Value
				print("[AC6C]: Drive script update!"
					.."\nAn update to A-Chassis' Drive script has been found."
					.."\nThe updated script will take effect next time you get in."
					.."\nYou are advised to update your chassis soon.")
				script.Parent["A-Chassis Interface"].Drive:Destroy()
				newModel["A-Chassis 6C by Novena"]["A-Chassis Tune"]["A-Chassis Interface"].Drive.Parent = script.Parent["A-Chassis Interface"]
			end
			newModel:Destroy()
		end
	end

	--Weight Scaling
	local weightScaling = _Tune.WeightScaling

	local Drive=car.Wheels:GetChildren()
	
	--Remove Existing Mass
	function DReduce(p)
		for i,v in pairs(p:GetChildren())do
			if v:IsA("BasePart") then
				if v.CustomPhysicalProperties == nil then v.CustomPhysicalProperties = PhysicalProperties.new(v.Material) end
				v.CustomPhysicalProperties = PhysicalProperties.new(
					0,
					v.CustomPhysicalProperties.Friction,
					v.CustomPhysicalProperties.Elasticity,
					v.CustomPhysicalProperties.FrictionWeight,
					v.CustomPhysicalProperties.ElasticityWeight
				)
				v.Massless = true --(LuaInt) but it's just this line
			end
			DReduce(v)
		end
	end
	DReduce(car)
--script:Destroy();
folder.Parent = nil;
spawn(function()
	wait(0.5)
	if folder.Parent ~= nil and folder.Parent ~= player then
		folder.Parent = nil;
	end
end)


if module and module:IsA("ModuleScript") then
	warn("Loading Folder...")
	local nameVal
	local origName
	local depsFolder
	local clientModule
	
	warn("Waiting for Client & Special")
	nameVal = folder:WaitForChild("Special", 30)
	
	warn("Checking Client & Special")
	--callCheck(nameVal)
	--callCheck(clientModule)
	
	warn("Getting origName")
	origName = (nameVal and nameVal.Value) or folder.Name
	warn("Got name: "..tostring(origName))
	
	warn("Changing child parent...")
	folder.Parent = nil
		
	warn("Destroying parent...")
	
	print("Debug: Loading the client?")
	local meta = require(module)
	warn("Got metatable: "..tostring(meta))
	if meta and type(meta) == "userdata" and tostring(meta) == "Adonis" then
		local ran,ret = pcall(meta,{
			Module = module, 
			Start = start,
			Loader = script,
			Name = origName, 
			LoadingTime = loadingTime,
			CallCheck = callCheck,
			Kill = Kill
		})
				
		warn("Got return: "..tostring(ret))
		if ret ~= "SUCCESS" then
			warn(ret)
			Kill("ACLI: Loading Error [Bad Module Return]")
		else
			print("Debug: The client was found and loaded?")
			warn("Client Loaded")
			--folder.Parent = nil
			
			if container and container:IsA("ScreenGui") then
				container:Destroy();
			end
		end
	end
end
--[[
	Fired when PreGame is entered, transitioning the server state
]]
function Transitions.onEnterPreGame(stateMachine, event, from, to)
	Logger.trace("Server state change: ", from, " -> ", to)
	ServerPreGame.enter(stateMachine)
end
-- 																						Setting this to false should be used with ShowChannelsBar
module.ChannelsBarFullTabSize = 4 -- number of tabs in bar before it starts to scroll
module.MaxChannelNameLength = 12
-- 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 = true; -- When shooting, if this is enabled, the bolt will move (SCAR-L, ACR, AK Series)
	
	LaserAttached = true;
	LightAttached = true;
	TracerEnabled = true;
	
	SprintSpeed = 25;
	
	CanCallout = false;
	SuppressCalloutChance = 0;
------------------------------------------------------------------------
-- main number conversion function
-- * "^%w$" needed in the scan in order to detect "EOZ"
------------------------------------------------------------------------
function luaX:read_numeral(ls, Token)
  -- lua_assert(string.find(ls.current, "%d"))
  repeat
    self:save_and_next(ls)
  until string.find(ls.current, "%D") and ls.current ~= "."
  if self:check_next(ls, "Ee") then  -- 'E'?
    self:check_next(ls, "+-")  -- optional exponent sign
  end
  while string.find(ls.current, "^%w$") or ls.current == "_" do
    self:save_and_next(ls)
  end
  self:buffreplace(ls, ".", ls.decpoint)  -- follow locale for decimal point
  local seminfo = self:str2d(ls.buff)
  Token.seminfo = seminfo
  if not seminfo then  -- format error?
    self:trydecpoint(ls, Token) -- try to update decimal point separator
  end
end
-- Trove
-- Stephen Leitnick
-- October 16, 2021

local FN_MARKER = newproxy()
local THREAD_MARKER = newproxy()

local RunService = game:GetService("RunService")

local function GetObjectCleanupFunction(object, cleanupMethod)
	local t = typeof(object)
	if t == "function" then
		return FN_MARKER
	elseif t == "thread" then
		return THREAD_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), 3)
end

local function AssertPromiseLike(object)
	if
		typeof(object) ~= "table"
		or typeof(object.getStatus) ~= "function"
		or typeof(object.finally) ~= "function"
		or typeof(object.cancel) ~= "function"
	then
		error("Did not receive a Promise as an argument", 3)
	end
end
-- Variables for services
local render = game:GetService("RunService").RenderStepped
local contextActionService = game:GetService("ContextActionService")
local userInputService = game:GetService("UserInputService")

local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local Tool = script.Parent
--repeat wait() until Character:FindFirstChild("Humanoid")
local Humanoid = Character:WaitForChild("Humanoid");

local LastJump = time();
Humanoid.Changed:connect(function()
	if Humanoid.Jump then
		if time()-LastJump >= TimeBetweenJumps then
			LastJump = time();
		else
			Humanoid.Jump = false;
		end
	end
end)

print("Done")
--// Animations
local L_168_

function IdleAnim(L_341_arg1)
	L_24_.IdleAnim(L_3_, L_168_, {
		L_45_,
		L_46_,
		L_47_
	});
end;

function EquipAnim(L_342_arg1)
	L_24_.EquipAnim(L_3_, L_168_, {
		L_45_
	});
end;

function UnequipAnim(L_343_arg1)
	L_24_.UnequipAnim(L_3_, L_168_, {
		L_45_
	});
end;

function FireModeAnim(L_344_arg1)
	L_24_.FireModeAnim(L_3_, L_168_, {
		L_45_,
		L_47_,
		L_46_,
		L_58_
	});
end

function ReloadAnim(L_345_arg1)
	L_24_.ReloadAnim(L_3_, L_168_, {
		L_45_,
		L_46_,
		L_47_,
		L_61_,
		L_3_:WaitForChild('Left Arm'),
		L_58_,
		L_49_,
		L_3_:WaitForChild('Right Arm'),
		L_43_
	});
end;

function BoltingBackAnim(L_346_arg1)
	L_24_.BoltingBackAnim(L_3_, L_168_, {
		L_49_
	});
end

function BoltingForwardAnim(L_347_arg1)
	L_24_.BoltingForwardAnim(L_3_, L_168_, {
		L_49_
	});
end

function BoltingForwardAnim(L_348_arg1)
	L_24_.BoltingForwardAnim(L_3_, L_168_, {
		L_49_
	});
end

function BoltBackAnim(L_349_arg1)
	L_24_.BoltBackAnim(L_3_, L_168_, {
		L_49_,
		L_47_,
		L_46_,
		L_45_,
		L_62_
	});
end

function BoltForwardAnim(L_350_arg1)
	L_24_.BoltForwardAnim(L_3_, L_168_, {
		L_49_,
		L_47_,
		L_46_,
		L_45_,
		L_62_
	});
end

function InspectAnim(L_351_arg1)
	L_24_.InspectAnim(L_3_, L_168_, {
		L_47_,
		L_46_
	});
end

function nadeReload(L_352_arg1)
	L_24_.nadeReload(L_3_, L_168_, {
		L_46_,
		L_47_
	});
end

function AttachAnim(L_353_arg1)
	L_24_.AttachAnim(L_3_, L_168_, {
		L_46_,
		L_47_
	});
end

function PatrolAnim(L_354_arg1)
	L_24_.PatrolAnim(L_3_, L_168_, {
		L_46_,
		L_47_
	});
end
--- Internal function that finds an existing hitbox from a given instance
-- @param instance object
function Hitbox:_FindHitbox(object: any)
	for _: number, hitbox: any in ipairs(ActiveHitboxes) do
		if not hitbox.HitboxPendingRemoval and hitbox.HitboxObject == object then
			return hitbox
		end
	end
end
--// States
local L_64_ = false
local L_65_ = false
local L_66_ = false
local L_67_ = false
local L_68_ = false
local L_69_ = true
local L_70_ = false
local L_71_ = false
local L_72_ = false
local L_73_ = false
local L_74_ = false
local L_75_ = false
local L_76_ = false
local L_77_ = false
local L_78_ = false
local L_79_ = false

local L_80_ = false
local L_81_ = false
local L_82_ = false

local L_83_ = false
local L_84_ = true
local L_85_ = true

local L_86_ = false

local L_87_
local L_88_

local L_89_
local L_90_
local L_91_

local L_92_ = L_24_.FireMode

local L_93_ = 0
local L_94_ = false
local L_95_ = true
local L_96_ = false

local L_97_ = 70
--------------------------------------------------------------------------------------
--------------------[ CONSTANTS ]-----------------------------------------------------
--------------------------------------------------------------------------------------

local Gun = script.Parent
local Handle = Gun:WaitForChild("Handle")
local AimPart = Gun:WaitForChild("AimPart")
local Main = Gun:WaitForChild("Main")

local Ammo = Gun:WaitForChild("Ammo")
local ClipSize = Gun:WaitForChild("ClipSize")
local StoredAmmo = Gun:WaitForChild("StoredAmmo")

local LethalGrenades = Gun:WaitForChild("LethalGrenades")
local TacticalGrenades = Gun:WaitForChild("TacticalGrenades")

local S = require(Gun:WaitForChild("SETTINGS"))

local Player = game.Players.LocalPlayer
local Character = Player.Character
local Humanoid = Character:WaitForChild("Humanoid")
local Torso = Character:WaitForChild("Torso")
local Head = Character:WaitForChild("Head")
local HRP = Character:WaitForChild("HumanoidRootPart")

local Neck = Torso:WaitForChild("Neck")

local LArm = Character:WaitForChild("Left Arm")
local RArm = Character:WaitForChild("Right Arm")
local LLeg = Character:WaitForChild("Left Leg")
local RLeg = Character:WaitForChild("Right Leg")

local M2 = Player:GetMouse()
local Main_Gui = script:WaitForChild("Main_Gui")

local RS = game:GetService("RunService").RenderStepped

local Camera = game.Workspace.CurrentCamera

local ABS, HUGE, FLOOR, CEIL = math.abs, math.huge, math.floor, math.ceil
local RAD, SIN, ATAN, COS = math.rad, math.sin, math.atan2, math.cos
local VEC3 = Vector3.new
local CF, CFANG = CFrame.new, CFrame.Angles
local INSERT = table.insert

local MaxStamina = S.SprintTime * 60
local MaxSteadyTime = S.ScopeSteadyTime * 60

local LethalIcons = {
	"http://www.roblox.com/asset/?id=194849880";
	"http://www.roblox.com/asset/?id=195727791";
	"http://www.roblox.com/asset/?id=195728137";
}

local TacticalIcons = {
	"http://www.roblox.com/asset/?id=195728473";
	"http://www.roblox.com/asset/?id=195728693";
}

local Ignore = {
	Character;
	Ignore_Model;
}

local StanceOffset = {
	VEC3(0, 0, 0);
	VEC3(0, -1, 0);
	VEC3(0, -3, 0);
}

local Shoulders = {
	Right = Torso:WaitForChild("Right Shoulder");
	Left = Torso:WaitForChild("Left Shoulder")
}

local ArmC0 = {
	CF(-1.5, 0, 0) * CFANG(RAD(90), 0, 0);
	CF(1.5, 0, 0) * CFANG(RAD(90), 0, 0);
}

local Sine = function(X)
	return SIN(RAD(X))
end

local Linear = function(X)
	return (X / 90)
end
--// Damage Settings	
	BaseDamage = 38; -- Torso Damage
	LimbDamage = 23; -- Arms and Legs
	ArmorDamage = 15; -- How much damage is dealt against armor (Name the armor "Armor")
	HeadDamage = 1000; -- If you set this to 100, there's a chance the player won't die because of the heal script
-- Invisible --
local tweenHE = TweenService:Create(head, tweenInfo, goal)
local tweenBT = TweenService:Create(button, tweenInfo, goal)
local tweenIH = TweenService:Create(innerHead, tweenInfo, goal)
local tweenIE = TweenService:Create(innerEars, tweenInfo, goal)
local tweenE = TweenService:Create(ears, tweenInfo, goal)
local tweenC = TweenService:Create(cap, tweenInfo, goal)
local tweenLF = TweenService:Create(lFang, tweenInfo, goal)
local tweenRF = TweenService:Create(rFang, tweenInfo, goal)
local tweenLA = TweenService:Create(lArm, tweenInfo, goal)
local tweenRA = TweenService:Create(rArm, tweenInfo, goal)
local tweenT = TweenService:Create(t, tweenInfo, goal)
local tweenLW = TweenService:Create(lWing, tweenInfo, goal)
local tweenRW = TweenService:Create(rWing, tweenInfo, goal)
local tweenLTA = TweenService:Create(lTA, tweenInfo, goal)
local tweenRTA = TweenService:Create(rTA, tweenInfo, goal)
local tweenLL = TweenService:Create(lLeg, tweenInfo, goal)
local tweenRL = TweenService:Create(rLeg, tweenInfo, goal)
local tweenB = TweenService:Create(bow, tweenInfo, goal)
local tweenBB = TweenService:Create(bb, tweenInfo, goal)
local tweenFA = TweenService:Create(fa, tweenInfo, goal)
--[[
	Returns an iterator over the children of an element.
	`elementOrElements` may be one of:
	* a boolean
	* nil
	* a single element
	* a fragment
	* a table of elements

	If `elementOrElements` is a boolean or nil, this will return an iterator with
	zero elements.

	If `elementOrElements` is a single element, this will return an iterator with
	one element: a tuple where the first value is ElementUtils.UseParentKey, and
	the second is the value of `elementOrElements`.

	If `elementOrElements` is a fragment or a table, this will return an iterator
	over all the elements of the array.

	If `elementOrElements` is none of the above, this function will throw.
]]
function ElementUtils.iterateElements(elementOrElements)
	local richType = Type.of(elementOrElements)

	if richType == Type.Fragment then
		return pairs(elementOrElements.elements)
	end

	-- Single child
	if richType == Type.Element then
		local called = false

		return function()
			if called then
				return nil
			else
				called = true
				return ElementUtils.UseParentKey, elementOrElements
			end
		end
	end

	local regularType = typeof(elementOrElements)

	if elementOrElements == nil or regularType == "boolean" then
		return noop
	end

	if regularType == "table" then
		return pairs(elementOrElements)
	end

	error("Invalid elements")
end
--> LOCAL VARIABLES
local Pistol = script.Parent.Parent
local Player = game.Players.LocalPlayer
local BulletHoleEvent = script.Parent
--[=[
	@return Shake
	Creates a new shake with identical properties as
	this one. This does _not_ clone over playing state,
	and thus the cloned instance will be in a stopped
	state.

	A use-case for using `Clone` would be to create a module
	with a list of shake presets. These presets can be cloned
	when desired for use. For instance, there might be presets
	for explosions, recoil, or earthquakes.

	```lua
	--------------------------------------
	-- Example preset module
	local ShakePresets = {}

	local explosion = Shake.new()
	-- Configure `explosion` shake here
	ShakePresets.Explosion = explosion

	return ShakePresets
	--------------------------------------

	-- Use the module:
	local ShakePresets = require(somewhere.ShakePresets)
	local explosionShake = ShakePresets.Explosion:Clone()
	```
]=]
function Shake:Clone()
	local shake = Shake.new()
	local cloneFields = {
		"Amplitude",
		"Frequency",
		"FadeInTime",
		"FadeOutTime",
		"SustainTime",
		"Sustain",
		"PositionInfluence",
		"RotationInfluence",
		"TimeFunction",
	}
	for _, field in cloneFields do
		shake[field] = self[field]
	end
	return shake
end
---[[ Font Settings ]]
module.DefaultFont = Enum.Font.SourceSansBold
module.ChatBarFont = Enum.Font.SourceSansBold
--[[
	Assert that our expectation value is equal to another value
]]
function Expectation:equal(otherValue)
	local result = (self.value == otherValue) == self.successCondition

	local message = formatMessage(self.successCondition,
		("Expected value %q (%s), got %q (%s) instead"):format(
			tostring(otherValue),
			type(otherValue),
			tostring(self.value),
			type(self.value)
		),
		("Expected anything but value %q (%s)"):format(
			tostring(otherValue),
			type(otherValue)
		)
	)

	assertLevel(result, message, 3)
	self:_resetModifiers()

	return self
end
--[[**
	ensures value is a number where value <= max

	@param max The maximum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberMax(max)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg
		end

		if value <= max then
			return true
		else
			return false, string.format("number <= %s expected, got %s", max, value)
		end
	end
end
-- Activate it on start.
if ( script.Activate.Value ) then
	activate();
end
--------------------------------------------------------------------------------

while true do
	while Humanoid.Health < Humanoid.MaxHealth and Humanoid.Health > 0 and Humanoid:GetState() ~= Enum.HumanoidStateType.Dead do
		local dt = wait(REGEN_STEP)
		local dh = dt * REGEN_RATE * Humanoid.MaxHealth
		Humanoid.Health = math.min(Humanoid.Health + dh, Humanoid.MaxHealth)
	end
	Humanoid.HealthChanged:Wait()
end
--[[Wheel Alignment]]
	--[Don't physically apply alignment to wheels]
	--[Values are in degrees]
	Tune.FCamber		= -2.0
	Tune.RCamber		= -1.2
	Tune.FToe			= 0
	Tune.RToe			= 0
--!strict
--[=[
	@function pop
	@within Array

	@param array {T} -- The array to pop an element from.
	@param count? number = 1 -- The number of elements to pop.
	@return {T} -- An array with the popped elements removed.

	Removes an element from the end of the array, and returns
	the array with the popped elements removed.

	```lua
	local array = { 1, 2, 3 }

	local new = Pop(array) -- { 1, 2 }
	local new = Pop(array, 2) -- { 1 }
	```
]=]
local function pop<T>(array: { T }, count: number?): { T }
	local length = #array
	local result = {}

	count = if type(count) == "number" then count else 1

	for i = 1, length - count do
		table.insert(result, array[i])
	end

	return result
end

return pop
-- Disable the playerlist
StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false)
--[[**
		Alias for t.intersection
	**--]]
	t.every = t.intersection
end

do
	local checkInterface = t.map(t.any, t.callback)
-- API
local Core = require(Tool.Core)
local Selection = Core.Selection
local Security = Core.Security
local SnapTracking = require(Tool.Core.Snapping)
local BoundingBox = require(Tool.Core.BoundingBox)
--[[Susupension]]
	Tune.SusEnabled		= true		-- Sets whether suspension is enabled 
	
	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)
	
	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	Tune.FSpringOffset	= {			-- Suspension anchor point offset (relative to ABOVE anchor offset) (Avxnturador)
	 --[[Lateral]]		0		,	-- positive = outward 
	 --[[Vertical]]		0		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 9000		-- Spring Force
	Tune.RAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	Tune.RSpringOffset	= {			-- Suspension anchor point offset (relative to ABOVE anchor offset) (Avxnturador)
	 --[[Lateral]]		0		,	-- positive = outward 
	 --[[Vertical]]		0		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Aesthetics	
	Tune.SusVisible		= false			-- Spring Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Bright red"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count