Roblox/luau_corpus huggingface dataset:
--Weld stuff here

MakeWeld(misc.Trunk.Hinge,car.DriveSeat,"Motor",.03)
ModelWeld(misc.Trunk.Parts,misc.Trunk.Hinge)

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)
-- local script inside the tool 
local tool = script.Parent
local player = game.Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local isAdmin = true -- change this to true if the player is an admin
local normalHealth = humanoid.MaxHealth
local adminHealth = 1000

local function onEquipped()
	if isAdmin then
		humanoid.MaxHealth = adminHealth
		humanoid.Health = adminHealth
	end
end

local function onUnequipped()
	if isAdmin then
		humanoid.MaxHealth = normalHealth
		humanoid.Health = normalHealth
	end
end

tool.Equipped:Connect(onEquipped)
tool.Unequipped:Connect(onUnequipped)
-- ROBLOX deviation: skipping path
-- local path = require("path")
-- ROBLOX FIXME: make proper platform check
-- local win32 = process.platform == "win32"
local win32 = false
local Constants = require(CurrentModule.constants)
--494sox @ //INSPARE
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local UserInputService = game:GetService("UserInputService")
local on = 0

script:WaitForChild("DownShiftSound")

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end
for i,v in pairs(script:GetChildren()) do
	v.Parent=car.DriveSeat
end
function DealWithInput(input,IsRobloxFunction)	
	if (input.KeyCode == Enum.KeyCode.Q) and (script.Parent.Values.RPM.Value>=4500) and input.UserInputState == Enum.UserInputState.Begin then
		car.DriveSeat.DownShiftSound:Play()
		car.DriveSeat.Rev.Volume=3
		wait(1.9)
		car.DriveSeat.Rev.Volume=5
	end	
end
UserInputService.InputBegan:connect(DealWithInput)
UserInputService.InputChanged:connect(DealWithInput)
UserInputService.InputEnded:connect(DealWithInput)
------//Low Ready Animations
self.RightLowReady 	= CFrame.new(-1, 0.5, -1.25) * CFrame.Angles(math.rad(-60), math.rad(0), math.rad(0));
self.LeftLowReady 	= CFrame.new(1.25,1.15,-1.35) * CFrame.Angles(math.rad(-60),math.rad(35),math.rad(-25));
--[[ The Module ]]--
local BaseOcclusion = require(script.Parent:WaitForChild("BaseOcclusion"))
local Poppercam = setmetatable({}, BaseOcclusion)
Poppercam.__index = Poppercam

function Poppercam.new()
	local self = setmetatable(BaseOcclusion.new(), Poppercam)
	self.focusExtrapolator = TransformExtrapolator.new()
	return self
end

function Poppercam:GetOcclusionMode()
	return Enum.DevCameraOcclusionMode.Zoom
end

function Poppercam:Enable(enable)
	self.focusExtrapolator:Reset()
end

function Poppercam:Update(renderDt, desiredCameraCFrame, desiredCameraFocus, cameraController)
	local rotatedFocus = CFrame.new(desiredCameraFocus.p, desiredCameraCFrame.p)*CFrame.new(
		0, 0, 0,
		-1, 0, 0,
		0, 1, 0,
		0, 0, -1
	)
	local extrapolation = self.focusExtrapolator:Step(renderDt, rotatedFocus)
	local zoom = ZoomController.Update(renderDt, rotatedFocus, extrapolation)
	return rotatedFocus*CFrame.new(0, 0, zoom), desiredCameraFocus
end
-- Constants
local RootModel = script:FindFirstAncestorOfClass("Model")
local EffectsToPlay = script.EffectsToPlay
local WeaponDefinition = WeaponDefinitionLoader.GetWeaponDefintionByName(RootModel:GetAttribute("WeaponName"))
local OwnerID = RootModel:GetAttribute("OwnerID")
local GrenadeFuseTime = WeaponDefinition:GetFuseTime()
local owningPlayer = PlayersService:GetPlayerByUserId(OwnerID)

wait(GrenadeFuseTime)
-- ROBLOX FIXME: Can we define ClientChatModules statically in the project config
pcall(function() ChatLocalization = require((game:GetService("Chat") :: any).ClientChatModules.ChatLocalization :: any) end)
if ChatLocalization == nil then ChatLocalization = {} function ChatLocalization:Get(key,default) return default end end

function ProcessMessage(message, ChatWindow, ChatSettings)
	local LocalPlayer = game:GetService("Players").LocalPlayer
	if LocalPlayer and LocalPlayer.UserId < 0 and not RunService:IsStudio() then

		local channelObj = ChatWindow:GetCurrentChannel()
		if channelObj then
			util:SendSystemMessageToSelf(
				ChatLocalization:Get("GameChat_SwallowGuestChat_Message","Create a free account to get access to chat permissions!"), 
				channelObj, 
				{}
			)
		end

		return true
	end
	return false
end

return {
	[util.KEY_COMMAND_PROCESSOR_TYPE] = util.COMPLETED_MESSAGE_PROCESSOR,
	[util.KEY_PROCESSOR_FUNCTION] = ProcessMessage
}
--// F key, Horn
mouse.KeyUp:connect(function(key)
	if key=="f" then 
		veh.Lightbar.middle.Airhorn:Stop()
		veh.Lightbar.middle.Wail.Volume = 3.5
		veh.Lightbar.middle.Yelp.Volume = 3.5
		veh.Lightbar.middle.Priority.Volume = 3.5
		veh.Lightbar.middle.Manual.Volume = 3.5
	end
end)










mouse.KeyDown:connect(function(key)
	if key=="j" then 
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.RemoteEvent:FireServer(true)
	end
end)

mouse.KeyDown:connect(function(key)
	if key=="]" then 
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.TD.RemoteEvent:FireServer(true)
	end
end)
-------- OMG HAX

r = game:service("RunService")


Tool = script.Parent

local equalizingForce = 236 / 1.2 -- amount of force required to levitate a mass
local gravity = .75 -- things float at > 1

local ghostEffect = nil
local massCon1 = nil
local massCon2 = nil
local myCharacter
local myPlayer


local head = nil
function recursiveGetLift(node)
	local m = 0
	local c = node:GetChildren()
	if (node:FindFirstChild("Head") ~= nil) then head = node:FindFirstChild("Head") end -- nasty hack to detect when your parts get blown off

	for i=1,#c do
		if c[i]:IsA("BasePart") then	
			if (head ~= nil and (c[i].Position - head.Position).magnitude < 10) then -- GROSS
				if c[i].Name == "Handle" then
					m = m + (c[i]:GetMass() * equalizingForce * 1) -- hack that makes hats weightless, so different hats don't change your jump height
				else
					m = m + (c[i]:GetMass() * equalizingForce * gravity)
				end
			end
		end
		m = m + recursiveGetLift(c[i])
	end
	return m
end


function onMassChanged(child, char)
	print("Mass changed:" .. child.Name .. "    " .. char.Name)
	if (ghostEffect ~= nil) then
		ghostEffect.force = Vector3.new(0, recursiveGetLift(char) ,0)
	end
end



function UpdateGhostState(isUnequipping)

	if isUnequipping == true then
		ghostEffect:Remove()
		ghostEffect = nil
		massCon1:disconnect()
		massCon2:disconnect()
	else
		if ghostEffect == nil then
			local char = Tool.Parent
			if char == nil then return end
			ghostEffect = Instance.new("BodyForce")
			ghostEffect.Name = "GravityCoilEffect"
			ghostEffect.force = Vector3.new(0, recursiveGetLift(char) ,0)
			ghostEffect.Parent = char.Head
			ghostChar = char
			massCon1 = char.ChildAdded:connect(function(child)  onMassChanged(child, char) end)
			massCon2 = char.ChildRemoved:connect(function(child)  onMassChanged(child, char) end)
		end
	end
	

end



function onEquipped()
	myCharacter = Tool.Parent
	UpdateGhostState(false)
	Tool.Handle.CoilSound:Play()
end

function onUnequipped()
	UpdateGhostState(true)
end


script.Parent.Equipped:connect(onEquipped)
script.Parent.Unequipped:connect(onUnequipped)
--Tune--
local StockHP = 350		--Power output desmos: https://www.desmos.com/calculator/wezfve8j90 (does not come with torque curve)
local TurboCount = 2	--(1 = SingleTurbo),(2 = TwinTurbo),(if bigger then it will default to 2 turbos)
local TurboSize = 45	--bigger the turbo, the more lag it has
local WasteGatePressure = 10	--Max PSI for each turbo (if twin and running 10 PSI, thats 10PSI for each turbo)
local CompressionRatio = 9/1	--Compression of your car (look up the compression of the engine you are running)
local AntiLag = True	--if true basically keeps the turbo spooled up so less lag

local BOV_Loudness = 10	--volume of the BOV (not exact volume so you kinda have to experiment with it)
local TurboLoudness = 1 --volume of the Turbo (not exact volume so you kinda have to experiment with it also)
--Loop For Making Rays For The Bullet's Trajectory
for i = 1, 30 do
	--print("Travelling")
	local thisOffset = offset + Vector3.new(0, yOffset*(i-1), 0)
	local travelRay = Ray.new(point1,thisOffset)
	
	acceptable = false
	while not acceptable do
		hit, position = workspace:FindPartOnRayWithIgnoreList(travelRay, ignoreList)
		if hit then
			--print(hit.Name)
			if hit.Name == "FakeTrack" or hit.Name == "Flash" then
				ignoreList[#ignoreList+1] = hit
				--print("Un-Acceptable")
			else
				--print("Acceptable")
				acceptable = true
			end
		else
			--print("Acceptable")
			acceptable = true
		end
	end

	local distance 		= (position - point1).magnitude
	round.Size			= Vector3.new(0.6, distance, 0.6)
	round.CFrame		= CFrame.new(position, point1)
							* CFrame.new(0, 0, -distance/2)
							* CFrame.Angles(math.rad(90),0,0)
	round.Parent		= Workspace
	point1				= point1 + thisOffset
	
	allied = false
	if hit and hit.Parent then --if we hit something
		
		--print("Bullet Hit Something")
			
		if hit.Parent.Parent then --look if what we hit is a tank
			tank = hit.Parent.Parent:findFirstChild("Tank")
			
			if not tank and hit.Parent.Parent.Parent then
				tank = hit.Parent.Parent.Parent:findFirstChild("Tank")
					
				if not tank and hit.Parent.Parent.Parent.Parent then
					local tank = hit.Parent.Parent.Parent.Parent:findFirstChild("Tank")
					
					if not tank and hit.Parent.Parent.Parent.Parent.Parent then
						local tank = hit.Parent.Parent.Parent.Parent.Parent:findFirstChild("Tank")
					end
				end
			end
		end
			
		if tank then --if it is a tank
			--print("Hit a Tank")
			if tank.Value == BrickColor.new("Bright red") then --if we hit an ally
				allied = true
				--print("Tank is an ally")
			end
		end
	
		if not allied then
			round:remove()
			local e = Instance.new("Explosion")
			e.BlastRadius = 4
			e.BlastPressure = 1700
			e.ExplosionType = Enum.ExplosionType.NoCraters
			e.DestroyJointRadiusPercent = 1.3
			e.Position = position
			e.Parent = Workspace
			local impactPos = CFrame.new(point1,point1 + thisOffset)-point1+position
			for angle = 1, 360, 40 do
				ray(angle,1.5, impactPos)
				ray(angle,3, impactPos)
				--wait()
			end
			round:remove()
			break
		elseif hit and allied then
			round:remove()
			break
		end
	end
	wait()
end

if round then
	round:remove()
end

script:remove()
-------------------------
function onClicked()
R.Function1.Disabled = false
R.loop.Disabled = true
R.BrickColor = BrickColor.new("Really red")
R.Function2.Disabled = true

end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
-- << COMMANDS >>
local module = {
	
	-----------------------------------
	{
	Name = "";
	Aliases	= {};
	Prefixes = {settings.Prefix};
	Rank = 1;
	RankLock = false;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	Function = function(speaker, args)
		
	end;
	UnFunction = function(speaker, args)
		
	end;
	--
	};
	
	
	
	
	-----------------------------------
	{
	Name = "bad";
	Aliases	= {};
	Prefixes = {settings.Prefix};
	Rank = 1;
	RankLock = false;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {"Player"};
	ClientCommand = true;
	FireAllClients = true;
	--[[
	ClientCommand = true;
	FireAllClients = true;
	BlockWhenPunished = true;
	PreFunction = function(speaker, args)
		
	end;
	Function = function(speaker, args)
		wait(1)
	end;
	--]]
	--
	};
	
	
	
	
	-----------------------------------
	
};



return module
--TABS

function activedeactive(thing, val)
	for _,i in pairs (thing:GetChildren()) do
		if i:IsA("ImageButton") or i:IsA("TextButton") then
			i.Active = val
			activedeactive(lights,true)
			activedeactive(siren,true)
			activedeactive(seats,true)
		end
	end
end
--> LOCAL VARIABLES
local Flare = script.Parent
local FlareBullet = Flare:WaitForChild("FlareAmmunition")
local ClickedEvent = Flare:WaitForChild("PlayerClicked")
local FlareBulletScript = script:WaitForChild("FlareBulletScript")
local ReloadTime = Flare:WaitForChild("Customisation"):WaitForChild("ReloadTime").Value
local BulletVelocity = Flare:WaitForChild("Customisation"):WaitForChild("BulletVelocity")
local Reloading = false
-- Looking for how exactly to set up your background music? Open the Readme/Instructions script!


local settings = {}

settings.UseGlobalBackgroundMusic = true  -- If you want to play Global Background Music for everyone in your game, set this to true.

settings.UseMusicZones = false  -- If you are using the Background Music Zones to play specific music in certain areas, set this to true.
------------------------------------------------------------------------
-- leaves a code unit, close any upvalues
------------------------------------------------------------------------
function luaY:leaveblock(fs)
  local bl = fs.bl
  fs.bl = bl.previous
  self:removevars(fs.ls, bl.nactvar)
  if bl.upval then
    luaK:codeABC(fs, "OP_CLOSE", bl.nactvar, 0, 0)
  end
  -- a block either controls scope or breaks (never both)
  assert(not bl.isbreakable or not bl.upval)
  assert(bl.nactvar == fs.nactvar)
  fs.freereg = fs.nactvar  -- free registers
  luaK:patchtohere(fs, bl.breaklist)
end
--This is a Join Trigger
if (not game:IsLoaded()) then game.Loaded:Wait() end
repeat wait() until game.Workspace.CurrentCamera
if game.Players.CharacterAutoLoads then
	repeat wait() until game.Players.LocalPlayer.Character
end

local EasingStyles = {
	["Linear"] = Enum.EasingStyle.Linear,
	["Sine"] = Enum.EasingStyle.Sine,
	["Back"] = Enum.EasingStyle.Back,
	["Quad"] = Enum.EasingStyle.Quad,
	["Quart"] = Enum.EasingStyle.Quart,
	["Quint"] = Enum.EasingStyle.Quint,
	["Bounce"] = Enum.EasingStyle.Bounce,
	["Elastic"] = Enum.EasingStyle.Elastic,
	["Exponential"] = Enum.EasingStyle.Exponential,
	["Circular"] = Enum.EasingStyle.Circular,
	["Cubic"] = Enum.EasingStyle.Cubic
}

local EasingDirections = {
	["In"] = Enum.EasingDirection.In,
	["InOut"] = Enum.EasingDirection.InOut,
	["Out"] = Enum.EasingDirection.Out
}

local cutsceneinfo = script.CutsceneInfo
local currentcameramode = game.Workspace.CurrentCamera.CameraType

game.Workspace.CurrentCamera.CameraType = Enum.CameraType.Scriptable

local camera = game.Workspace.CurrentCamera
--[[**
	ensures Roblox Instance type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Instance = t.typeof("Instance")
--------LEFT DOOR 8--------
game.Workspace.doorleft.l71.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l72.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l63.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l52.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l51.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l43.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l42.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l33.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l22.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l13.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l12.BrickColor = BrickColor.new(135)

game.Workspace.doorleft.l11.BrickColor = BrickColor.new(102)
------ lOCAL -----

local Button = script.Parent
local Events = game:GetService("ReplicatedStorage").Events.GiveTools
local Frame = Button.Parent.Parent
--Modules
local internalclient: any = require(ReplicatedStorage:WaitForChild("Systems").InternalSystem.internalclient)
-- Unequip logic here
function OnUnequipped()
	Handle.UnequipSound:Play()
	Handle.EquipSound:Stop()
	Handle.EquipSound2:Stop()
	LeftButtonDown = false
	flare.MuzzleFlash.Enabled = false
	Reloading = false
	MyCharacter = nil
	MyHumanoid = nil
	MyTorso = nil
	MyPlayer = nil
	MyMouse = nil
	if OnFireConnection then
		OnFireConnection:disconnect()
	end
	if OnReloadConnection then
		OnReloadConnection:disconnect()
	end
	if FlashHolder then
		FlashHolder = nil
	end
	if WeaponGui then
		WeaponGui.Parent = nil
		WeaponGui = nil
	end
	if RecoilTrack then
		RecoilTrack:Stop()
	end
	if ReloadTrack then
		ReloadTrack:Stop()
	end
end

local function SetReticleColor(color)
	if WeaponGui and WeaponGui:FindFirstChild('Crosshair') then
		for _, line in pairs(WeaponGui.Crosshair:GetChildren()) do
			if line:IsA('Frame') then
				line.BorderColor3 = color
			end
		end
	end
end


Tool.Equipped:connect(OnEquipped)
Tool.Unequipped:connect(OnUnequipped)

while true do
	wait(0.033)
	if WeaponGui and WeaponGui:FindFirstChild('Crosshair') and MyMouse then
		WeaponGui.Crosshair.Position = UDim2.new(0, MyMouse.X, 0, MyMouse.Y)
		SetReticleColor(NeutralReticleColor)

		local target = MyMouse.Target
		if target and target.Parent then
			local player = PlayersService:GetPlayerFromCharacter(target.Parent)
			if player then
				if MyPlayer.Neutral or player.TeamColor ~= MyPlayer.TeamColor then
					SetReticleColor(EnemyReticleColor)
				else
					SetReticleColor(FriendlyReticleColor)
				end
			end
		end
	end
	if Spread and not IsShooting then
		local currTime = time()
		if currTime - LastSpreadUpdate > FireRate * 2 then
			LastSpreadUpdate = currTime
			Spread = math.max(MinSpread, Spread - AimInaccuracyStepAmount)
			UpdateCrosshair(Spread, MyMouse)
		end
	end
end
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 10 -- cooldown for use of the tool again

ZoneModelName = "virus" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage
-- connect events
Humanoid.Died:connect(onDied)
Humanoid.Running:connect(onRunning)
Humanoid.Jumping:connect(onJumping)
Humanoid.Climbing:connect(onClimbing)
Humanoid.GettingUp:connect(onGettingUp)
Humanoid.FreeFalling:connect(onFreeFall)
Humanoid.FallingDown:connect(onFallingDown)
Humanoid.Seated:connect(onSeated)
Humanoid.PlatformStanding:connect(onPlatformStanding)
Humanoid.Swimming:connect(onSwimming)
local runService = game:GetService("RunService");
playAnimation("idle", 0.1, Humanoid)
pose = "Standing"
while true do
wait(0)
local _,time = wait(0)
move(time)
end
-- Resolve a promise once the signal is fired once
function Signal:Promise(predicate)
	return Promise.FromEvent(self, predicate)
end


function Signal:Destroy()
	self:DisconnectAll()
	local proxyHandler = rawget(self, "_proxyHandler")
	if proxyHandler then
		proxyHandler:Disconnect()
	end
end
--------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------MELEE---------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------

local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "rbxasset://sounds\\swordslash.wav"
SlashSound.Parent = Tool.Handle
SlashSound.Volume = .7

function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	if not humanoid then return end
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid ~= hum and hum ~= nil and game.Players:playerFromCharacter(humanoid.Parent) and game.Players:playerFromCharacter(humanoid.Parent).TeamColor~=cc then
		tagHumanoid(humanoid, vPlayer)
		humanoid:TakeDamage(160)
		wait(1)
		untagHumanoid(humanoid)
	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 lunge()
	SlashSound:play()

	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Lunge"
	anim.Parent = Tool
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local on = 0

script:WaitForChild("Rev")

if not FE then
	for i,v in pairs(car.DriveSeat:GetChildren()) do
		for _,a in pairs(script:GetChildren()) do
			if v.Name==a.Name then v:Stop() wait() v:Destroy() end
		end
	end
	for i,v in pairs(script:GetChildren()) do
		v.Parent=car.DriveSeat
	end
	
	car.DriveSeat.Rev:Play()
	
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value
		
		if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		car.DriveSeat.Rev.Pitch = (car.DriveSeat.Rev.SetPitch.Value + car.DriveSeat.Rev.SetRev.Value*_RPM/_Tune.Redline)*on^2
	end
else
	local handler = car.AC6_FE_Sounds
	handler:FireServer("newSound","Rev",car.DriveSeat,script.Rev.SoundId,0,script.Rev.Volume,true)
	handler:FireServer("playSound","Rev")
	local pitch=0
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value
		
		if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		pitch = (script.Rev.SetPitch.Value + script.Rev.SetRev.Value*_RPM/_Tune.Redline)*on^2
		handler:FireServer("updateSound","Rev",script.Rev.SoundId,pitch,script.Rev.Volume)
	end
end
--!strict

return function (system, particleRef)
	warn("Particle Died, Info Follows")
	warn("CFrame:", particleRef.CFrame)
	warn("Color:", particleRef.Color)
	warn("Children:", particleRef.Children)
end
--NOTE: We create the rocket once and then clone it when the player fires
local Rocket = Instance.new('Part') do
	-- Set up the rocket part
	Rocket.Name = 'Rocket'
	Rocket.FormFactor = Enum.FormFactor.Custom --NOTE: This must be done before changing Size
	Rocket.Size = ROCKET_PART_SIZE
	Rocket.CanCollide = false

	-- Add the mesh
	local mesh = Instance.new('SpecialMesh', Rocket)
	mesh.MeshId = MISSILE_MESH_ID
	mesh.Scale = MISSILE_MESH_SCALE

	-- Add fire
	local fire = Instance.new('Fire', Rocket)
	fire.Heat = 5
	fire.Size = 2

	-- Add a force to counteract gravity
	local bodyForce = Instance.new('BodyForce', Rocket)
	bodyForce.Name = 'Antigravity'
	bodyForce.force = Vector3.new(0, Rocket:GetMass() * GRAVITY_ACCELERATION, 0)

	-- Clone the sounds and set Boom to PlayOnRemove
	local swooshSoundClone = SwooshSound:Clone()
	swooshSoundClone.Parent = Rocket
	local boomSoundClone = BoomSound:Clone()
	boomSoundClone.PlayOnRemove = true
	boomSoundClone.Parent = Rocket

	-- Finally, clone the rocket script and enable it
-- declarations

local head = script.Parent
local sound = head:findFirstChild("Victory")

function onTouched(part)
	local h = part.Parent:findFirstChild("Humanoid")
	if h~=nil then
sound:play()
if part.Parent:findFirstChild("Head"):findFirstChild("face").Texture == nil then return end
part.Parent:findFirstChild("Head"):findFirstChild("face").Texture="717dea9c5a1659640155f77c84892c "	end
end

script.Parent.Touched:connect(onTouched)