Response:
input.InputChanged:connect(function(inputObject)

	if inputObject.UserInputType == Enum.UserInputType.MouseMovement then
		local delta = Vector2.new(inputObject.Delta.x/Sensitivity,inputObject.Delta.y/Sensitivity) * Smoothness

		local X = TargetAngleX - delta.y
		TargetAngleX = (X >= 80 and 80) or (X <= -80 and -80) or X
		TargetAngleY = (TargetAngleY - delta.x) %360
	end

end)

input.InputBegan:connect(function(inputObject)

	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == CanToggleMouse.activationkey then
			if CanToggleMouse.allowed and freemouse == false then
				freemouse = true
			else
				freemouse = false
			end
		end
	end

	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == Enum.KeyCode.W then
			w = true
		end

		if inputObject.KeyCode == Enum.KeyCode.A then
			a = true
		end

		if inputObject.KeyCode == Enum.KeyCode.S then
			s = true
		end

		if inputObject.KeyCode == Enum.KeyCode.D then
			d = true
		end

		if inputObject.KeyCode == Enum.KeyCode.LeftShift then
			lshift = true
		end
	end
end)

input.InputEnded:connect(function(inputObject)
	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == Enum.KeyCode.W then
			w = false
		end

		if inputObject.KeyCode == Enum.KeyCode.A then
			a = false
		end

		if inputObject.KeyCode == Enum.KeyCode.S then
			s = false
		end

		if inputObject.KeyCode == Enum.KeyCode.D then
			d = false
		end

		if inputObject.KeyCode == Enum.KeyCode.LeftShift then
			lshift = false
		end
	end
end)


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

Response:
local v1 = {};
v1.__index = v1;
local u1 = {};
function v1.new(p1, p2)
	local v2 = setmetatable({}, v1);
	v2.Enabled = true;
	v2.LightningBolt = p1;
	v2.MaxSparkCount = p2 or 10;
	v2.MinSpeed = 4;
	v2.MaxSpeed = 6;
	v2.MinDistance = 3;
	v2.MaxDistance = 6;
	v2.MinPartsPerSpark = 8;
	v2.MaxPartsPerSpark = 10;
	v2.SparksN = 0;
	v2.SlotTable = {};
	v2.RefIndex = #u1 + 1;
	u1[v2.RefIndex] = v2;
	return v2;
end;
function v1.Destroy(p3)
	u1[p3.RefIndex] = nil;
	for v3, v4 in pairs(p3.SlotTable) do
		if v4.Parts[1].Parent == nil then
			p3.SlotTable[v3] = nil;
		end;
	end;
	p3 = nil;
end;
local u2 = Random.new();
function RandomVectorOffset(p4, p5)
	return (CFrame.lookAt(Vector3.new(), p4) * CFrame.Angles(0, 0, u2:NextNumber(0, 2 * math.pi)) * CFrame.Angles(math.acos(u2:NextNumber(math.cos(p5), 1)), 0, 0)).LookVector;
end;
local u3 = require(script.Parent);
game:GetService("RunService").Heartbeat:Connect(function()
	local v5, v6, v7 = pairs(u1);
	while true do
		local v8, v9 = v5(v6, v7);
		if not v8 then
			break;
		end;
		if v9.Enabled == true and v9.SparksN < v9.MaxSparkCount then
			local l__LightningBolt__10 = v9.LightningBolt;
			if l__LightningBolt__10.Parts[1].Parent == nil then
				v9:Destroy();
				return;
			end;
			local l__Parts__11 = l__LightningBolt__10.Parts;
			local v12 = #l__Parts__11;
			local v13 = {};
			for v14 = 1, #l__Parts__11 do
				if l__Parts__11[v14].Transparency < 0.3 then
					v13[#v13 + 1] = (v14 - 0.5) / v12;
				end;
			end;
			local v15 = nil;
			local v16 = nil;
			if #v13 ~= 0 then
				v15 = math.ceil(v13[1] * v9.MaxSparkCount);
				v16 = math.ceil(v13[#v13] * v9.MaxSparkCount);
			end;
			for v17 = 1, u2:NextInteger(1, v9.MaxSparkCount - v9.SparksN) do
				if #v13 == 0 then
					break;
				end;
				local v18 = {};
				for v19 = v15, v16 do
					if v9.SlotTable[v19] == nil then
						v18[#v18 + 1] = v19;
					end;
				end;
				if #v18 ~= 0 then
					local v20 = v18[u2:NextInteger(1, #v18)];
					local v21 = u2:NextNumber(-0.5, 0.5);
					local v22 = (v20 - 0.5 + v21) / v9.MaxSparkCount;
					local v23 = 10;
					local v24 = 1;
					for v25 = 1, #v13 do
						local v26 = math.abs(v13[v25] - v22);
						if v26 < v23 then
							v23 = v26;
							v24 = math.floor(v13[v25] * v12 + 0.5 + 0.5);
						end;
					end;
					local v27 = l__Parts__11[v24];
					local v28 = {};
					local v29 = {};
					v28.WorldPosition = v27.Position + v21 * v27.CFrame.RightVector * v27.Size.X;
					v29.WorldPosition = v28.WorldPosition + RandomVectorOffset(v27.CFrame.RightVector, math.pi / 4) * u2:NextNumber(v9.MinDistance, v9.MaxDistance);
					v28.WorldAxis = (v29.WorldPosition - v28.WorldPosition).Unit;
					v29.WorldAxis = v28.WorldAxis;
					local v30 = u3.new(v28, v29, u2:NextInteger(v9.MinPartsPerSpark, v9.MaxPartsPerSpark));
					v30.MinRadius = 0;
					v30.MaxRadius = 0.8;
					v30.AnimationSpeed = 0;
					v30.Thickness = v27.Size.Y / 2;
					v30.MinThicknessMultiplier = 1;
					v30.MaxThicknessMultiplier = 1;
					v30.PulseLength = 0.5;
					v30.PulseSpeed = u2:NextNumber(v9.MinSpeed, v9.MaxSpeed);
					v30.FadeLength = 0.25;
					local v31, v32, v33 = Color3.toHSV(v27.Color);
					v30.Color = Color3.fromHSV(v31, 0.5, v33);
					v9.SlotTable[v20] = v30;
				end;
			end;
		end;
		local v34 = 0;
		for v35, v36 in pairs(v9.SlotTable) do
			if v36.Parts[1].Parent ~= nil then
				v34 = v34 + 1;
			else
				v9.SlotTable[v35] = nil;
			end;
		end;
		v9.SparksN = v34;
	end;
end);
return v1;


Prompt: --// Recoil Settings

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

	CamShake = 2; -- THIS IS NEW!!!! CONTROLS CAMERA SHAKE WHEN FIRING
	AimCamShake = 3; -- THIS IS ALSO NEW!!!!

	Kickback = 0.2; -- Upward gun rotation when not aiming
	AimKickback = 0.2; -- Upward gun rotation when aiming


Prompt:
--[=[
	Shorthand for `Promise:andThen(nil, failureHandler)`.

	Returns a Promise that resolves if the `failureHandler` worked without encountering an additional error.

	:::warning
	Within the failure handler, you should never assume that the rejection value is a string. Some rejections within the Promise library are represented by [[Error]] objects. If you want to treat it as a string for debugging, you should call `tostring` on it first.
	:::

	@param failureHandler (...: any) -> ...any
	@return Promise<...any>
]=]

Response:
function Promise.prototype:catch(failureHandler)
	assert(failureHandler == nil or isCallable(failureHandler), string.format(ERROR_NON_FUNCTION, "Promise:catch"))
	return self:_andThen(debug.traceback(nil, 2), nil, failureHandler)
end


Prompt: -- Toggle Event

Response: ShiftLockController.OnShiftLockToggled = Instance.new('BindableEvent')


Prompt: --Var

Response:
local isOpen = false

local MainMenuOpen = {}

function MainMenuOpen:ManipUI()
    isOpen = not isOpen
    MainFrame.Visible = isOpen
end

function MainMenuOpen:Setup(UI, Main)
    Button = UI
    MainFrame = Main.MainMenu

    Button.MainToggle.MouseButton1Down:Connect(function()
        self:ManipUI()
    end)
end

return MainMenuOpen


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

	@param value The value to check against

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

Response: t.NumberRange = primitive("NumberRange")


Prompt: -- 																						Setting this to false should be used with ShowChannelsBar

Response:
module.ChannelsBarFullTabSize = 4 -- number of tabs in bar before it starts to scroll
module.MaxChannelNameLength = 12


Prompt: -- Variables (best not to touch these!)

Response:
local button = script.Parent.Parent
local car = script.Parent.Parent.Parent.Car.Value
local sound = script.Parent.Start
local st = script.Parent.Stall
st.Parent = car.DriveSeat
sound.Parent = car.DriveSeat -- What brick the start sound is playing from.
button.MouseButton1Click:connect(function() -- Event when the button is clicked
	if script.Parent.Parent.Text == "Engine: Off" then -- If the text says it's off then..
		sound:Play() -- Startup sound plays..
		wait(1.1) -- I don't know what to put for this
		script.Parent.Parent.Parent.IsOn.Value = true -- The car is is on, or in other words, start up the car.
		button.Text = "Engine: On"  -- You don't really need this, but I would keep it.
	else -- If it's on then when you click the button,
		st:play()
		script.Parent.Parent.Parent.IsOn.Value = false -- The car is turned off.
		button.Text = "Engine: Off"
	end -- Don't touch this.
end) -- And don't touch this either.


Response:
R = false
UIS.InputBegan:connect(function(i,GP) if not GP then if i.KeyCode == Enum.KeyCode.C then
if R == false then
script.Parent.Right.ImageColor3 = Color3.fromRGB(142, 255, 169)
R = true
else
script.Parent.Right.ImageColor3 = Color3.fromRGB(255,255,255)
R = false
end
end end end)


Prompt: --[[ Local Constants ]]

Response:
--
local UNIT_Z = Vector3.new(0,0,1)
local X1_Y0_Z1 = Vector3.new(1,0,1)	--Note: not a unit vector, used for projecting onto XZ plane

local DEFAULT_DISTANCE = 12.5	-- Studs
local PORTRAIT_DEFAULT_DISTANCE = 25		-- Studs
local FIRST_PERSON_DISTANCE_THRESHOLD = 1.0 -- Below this value, snap into first person


Prompt: --// If youre here to add your team go to the module and add it in there, just tryna to clean this up alittle

Response:
local WhiteListedTeams = require(game.ReplicatedStorage.MotionDetectorsWhitelist.StandartPermission)

Detector.Touched:Connect(
	function(boop)
		if boop.Parent:FindFirstChild("Humanoid") then
			local char = boop.Parent
			local Player = game:GetService("Players"):GetPlayerFromCharacter(char)
			if WhiteListedTeams[Player.Team] ==nil then
				if not isTouched then
					isTouched = true

					wait(0.1)
					script.Parent.Alarm:Play()
					Light.Enabled = true
					L1.BrickColor = BrickColor.new ("Persimmon")
					L12.BrickColor = BrickColor.new ("Persimmon")
					L2.BrickColor = BrickColor.new ("Persimmon")
					L22.BrickColor = BrickColor.new ("Persimmon")
					wait(5)
					L1.BrickColor = BrickColor.new ("Pastel yellow")
					L12.BrickColor = BrickColor.new ("Pastel yellow")
					L2.BrickColor = BrickColor.new ("Pastel yellow")
					L22.BrickColor = BrickColor.new ("Pastel yellow")
					Light.Enabled = false
					wait(RESET_SECONDS)
					isTouched = false
				end
			end
		end
	end
)


Prompt: --requires luaP, luaX, luaK

Response:
local luaY = {}
local luaX = require(script.Parent.LuaX)
local luaK = require(script.Parent.LuaK)(luaY)
local luaP = require(script.Parent.LuaP)


Prompt: --------LEFT DOOR --------

Response:
game.Workspace.doorleft.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l71.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)

game.Workspace.doorleft.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)


Prompt: --print("no building or player")

Response:
target = nil
targetType = nil
lastLock = tick()


Prompt:
-- Made by XandertjeKnal
--[[ Documentation:
This module can be used to make sure rates of Remotes are not exceeded.

FloodCheck:Check(Player_Object, Event, RatePerSec, Unique_Identifier) -- Will return false if the limit is exceeded, otherwise will return true.

- Player_Object
Reference the player that is making the request.

- Event
Reference the event that you are listening to.

- RatePerSec:
RatePerSec > 1
If the RatePerSec variable x is set higher than 1, it will allow x requests in the first second after the first request was made. E.g. if RatePerSec is set to 5, a player can send 5 consecutive requests in any time that is less than a second, for example within the first 200ms even. All other requests in that second will be blocked. After that second, the request count will be reset.
RatePerSec <= 1
If the RatePerSec variable x is set lower or equal to 1, it will only allow a consecutive request (1/x) seconds after the first request. E.g. if RatePerSec is set to 0.2, a player has to wait (1/0.2) = 5 seconds after sending the first request before any consecutive requests will be processed. All other requests in between will be blocked.
The RatePerSec should not be changed after the first request has been checked.
If left nil, the DefaultMaxRatePerSec will be used.

- Unique_Identifier:
This variable is optional to use and can most often be left nil. You only have to use this if there are multiple scripts listening to the same RemoteEvent/RemoteFunction.
E.g. 2 scripts are listening to an 'ExplodeTNT' event. You can set one Unique_Identifier to '1' and the other to '2'. If you are using clones of the same script (or packages) listening to the same event then you may want to use a random number or string that is randomized only once(!) per script as the Unique_Identifier instead.
This identifier is used to prevent multiple checks from filling up the flood check.
You could in theory also use this identifier to have different Rates for different scripts listening to the same remote. Example usage: throttle resource-intensive scripts more than the game-critical scripts, even if they are listening to the same event.

- Example usage:
local FloodCheck = require(game.ServerScriptService.RemoteFloodCheck) -- Reference this module
MyEvent.OnServerEvent:Connect(function(Player)
	if FloodCheck:Check(Player, MyEvent, 10) then
		-- Process the request
	end
end
--]]

Response:
local FloodCheck = {}

local Requests = {}

function FloodCheck:Check(Player_Object, Remote, RatePerSec, Unique_Identifier, Seconds)
    local Rate = RatePerSec or DefaultMaxRatePerSec
	local Identifier = Unique_Identifier or DefaultIdentifier

	if not Requests[Player_Object] then
		Requests[Player_Object] = {}
		local connection
		local function PlayerLeft(player)
			if player == Player_Object then
				Requests[Player_Object] = nil
				connection:Disconnect()
			end
		end
		connection = game.Players.PlayerRemoving:Connect(PlayerLeft)
	end
	if not Requests[Player_Object][Remote] then
		Requests[Player_Object][Remote] = {}
	end
	if not Requests[Player_Object][Remote][Identifier] then
		Requests[Player_Object][Remote][Identifier] = {}
	end

	if Rate > Seconds then
		if Requests[Player_Object][Remote][Identifier]["Count"] then
			local TimeElapsed = tick() - Requests[Player_Object][Remote][Identifier]["StartTime"]
			if TimeElapsed >= 1 then
				Requests[Player_Object][Remote][Identifier]["Count"] = 1
				Requests[Player_Object][Remote][Identifier]["StartTime"] = tick()
				return true
			else
				Requests[Player_Object][Remote][Identifier]["Count"] = Requests[Player_Object][Remote][Identifier]["Count"] + 1
				return Requests[Player_Object][Remote][Identifier]["Count"] <= Rate
			end
		else
			Requests[Player_Object][Remote][Identifier]["Count"] = 1
			Requests[Player_Object][Remote][Identifier]["StartTime"] = tick()
			return true
		end
	end
	if Rate <= Seconds then
		if Requests[Player_Object][Remote][Identifier]["LastTime"] then
			local TimeElapsed = tick() - Requests[Player_Object][Remote][Identifier]["LastTime"]
			if TimeElapsed >= (1/Rate) then
				Requests[Player_Object][Remote][Identifier]["LastTime"] = tick()
				return true
			else
				return false
			end
		else
			Requests[Player_Object][Remote][Identifier]["LastTime"] = tick()
			return true
		end
	end
end

return FloodCheck


Prompt:
------------------
--SPAWNING--
------------------

Response:
miked=script.Parent

itlh=miked.Torso:findFirstChild("Left Hip")
itlh.Part0=miked.Torso
itlh.Part1=miked:findFirstChild("Left Leg")
itlh.C0=CFrame.new(-1, -1, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)

itrh=miked.Torso:findFirstChild("Right Hip")
itrh.Part0=miked.Torso
itrh.Part1=miked:findFirstChild("Right Leg")
itrh.C0=CFrame.new(1, -1, 0, 0, 0, 1, 0, 1, 0, -1, 0, 0)

itls=miked.Torso:findFirstChild("Left Shoulder")
itls.Part1=miked.Torso
itls.C0=CFrame.new(2, 0.5, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
itls.Part0=miked:findFirstChild("Left Arm")

itrs=miked.Torso:findFirstChild("Right Shoulder")
itrs.Part1=miked.Torso
itrs.C0=CFrame.new(-2, 0.5, 0, 0, 0, 1, 0, 1, 0, -1, 0, 0)
itrs.Part0=miked:findFirstChild("Right Arm")

miked.Head:makeJoints()


Prompt: -- / Functions / --

Response:
EventModule.ActivateEvent = function()
	local RandomPlayer = PlayingTeam:GetPlayers()[math.random(1, #PlayingTeam:GetPlayers())]

	if RandomPlayer then
		local Character = RandomPlayer.Character or RandomPlayer.CharacterAdded:Wait()

		if Character then
			local Humanoid = Character:WaitForChild("Humanoid")

			if Humanoid then
				local HumanoidDescription = Humanoid:GetAppliedDescription()

				HumanoidDescription.HeadScale = 3

				Humanoid:ApplyDescription(HumanoidDescription)

				local Head = Character:WaitForChild("Head")

				if Head then
					Head.Massless = true
					Head.CanCollide = false
				end

			end
		end
	end
end


Prompt:
--local asdf = Instance.new("Part")
--asdf.Anchored = true
--asdf.Size = Vector3.new(2,2,2)
--asdf.CFrame = CFrame.new(pos)
--asdf.Parent = workspace

Response:
if part then
if part == workspace.Terrain and mat ~= Enum.Material.Water then


Prompt:
--[=[
	Cleans up all tasks and removes them as entries from the Maid.

	:::note
	Signals that are already connected are always disconnected first. After that
	any signals added during a cleaning phase will be disconnected at random times.
	:::

	:::tip
	DoCleaning() may be recursively invoked. This allows the you to ensure that
	tasks or other tasks. Each task will be executed once.

	However, adding tasks while cleaning is not generally a good idea, as if you add a
	function that adds itself, this will loop indefinitely.
	:::
]=]

Response:
function Maid:DoCleaning()
	local tasks = self._tasks

	-- Disconnect all events first as we know this is safe
	for index, job in pairs(tasks) do
		if typeof(job) == "RBXScriptConnection" then
			tasks[index] = nil
			job:Disconnect()
		end
	end

	-- Clear out tasks table completely, even if clean up tasks add more tasks to the maid
	local index, job = next(tasks)
	while job ~= nil do
		tasks[index] = nil
		if type(job) == "function" then
			job()
		elseif type(job) == "thread" then
			task.cancel(job)
		elseif typeof(job) == "RBXScriptConnection" then
			job:Disconnect()
		elseif job.Destroy then
			job:Destroy()
		end
		index, job = next(tasks)
	end
end


Prompt: --blah

Response:
else
script.Parent.Parent = nil
end
end
script.Parent.Touched:connect(onTouched)


Prompt:
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data

Response:
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	return plrData.Character.Purity.Value <= 50
end


Prompt: --game.StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.All, false)

Response:
currentCamera.FieldOfView = customMenuFieldOfView
currentCamera.CameraType = Enum.CameraType.Scriptable
currentCamera.CFrame = spawnItems.CameraPart.CFrame
gameVersion.Text = configuration.GameVersionInfo.Value.." "..game.PlaceVersion
versionOpen:Play()
blurOpen:Play()
fade.Visible = true
Sounds.MenuMusic.Playing = configuration.MenuMusic.Value
menuMusicOn:Play()
wait(longLength)
fadeOpen:Play()
wait(longLength * 0.5)
buttonsOpen:Play()
titleOpen:Play()


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 553		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16

	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)


Prompt:
--[[
	Package link auto-generated by Rotriever
]]

Response:
local PackageIndex = script.Parent.Parent.Parent._Index

local Package = require(PackageIndex["LuauPolyfill-2fca3173-0.3.4"]["LuauPolyfill"])

export type Array<T> = Package.Array<T>
export type AssertionError = Package.AssertionError
export type Error = Package.Error
export type Map<T, V> = Package.Map<T, V>
export type Object = Package.Object
export type PromiseLike<T> = Package.PromiseLike<T>
export type Promise<T> = Package.Promise<T>
export type Set<T> = Package.Set<T>
export type Symbol = Package.Symbol
export type Timeout = Package.Timeout
export type Interval = Package.Interval
export type WeakMap<T, V> = Package.WeakMap<T, V>

return Package


Response:
	,FastReload = true					--- Automatically operates the bolt on reload if needed
	,SlideLock = true
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = false
	,CanBreak = true					--- Weapon can jam?
	,JamChance = 800					--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = true		--- Include the chambered bullet on next reload
	,Chambered = true					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = true					--- You can check the magazine
	,ArcadeMode = false					--- You can see the bullets left in magazine
	,RainbowMode = false				--- Operation: Party Time xD
	,ModoTreino = false					--- Surrender enemies instead of killing them
	,GunSize = 1
	,GunFOVReduction = 5

	,BoltExtend = Vector3.new(0, 0, 0.225)
	,SlideExtend = Vector3.new(0, 0, 0.225)


Prompt: --[[ Controls State Management ]]

Response:
--
local onControlsChanged = nil
if IsTouchDevice then
	createTouchGuiContainer()
	onControlsChanged = function()
		local newModuleToEnable = nil
		if not IsUserChoice then
			if DevMovementMode == Enum.DevTouchMovementMode.Thumbstick then
				newModuleToEnable = ControlModules.Thumbstick
				isJumpEnabled = true
			elseif DevMovementMode == Enum.DevTouchMovementMode.Thumbpad then
				newModuleToEnable = ControlModules.Thumbpad
				isJumpEnabled = true
			elseif DevMovementMode == Enum.DevTouchMovementMode.DPad then
				newModuleToEnable = ControlModules.DPad
			elseif DevMovementMode == Enum.DevTouchMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = nil
			elseif DevMovementMode == Enum.DevTouchMovementMode.Scriptable then
				newModuleToEnable = nil
			end
		else
			if UserMovementMode == Enum.TouchMovementMode.Default or UserMovementMode == Enum.TouchMovementMode.Thumbstick then
				newModuleToEnable = ControlModules.Thumbstick
				isJumpEnabled = true
			elseif UserMovementMode == Enum.TouchMovementMode.Thumbpad then
				newModuleToEnable = ControlModules.Thumbpad
				isJumpEnabled = true
			elseif UserMovementMode == Enum.TouchMovementMode.DPad then
				newModuleToEnable = ControlModules.DPad
			elseif UserMovementMode == Enum.TouchMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = nil
			end
		end
		setClickToMove()
		if newModuleToEnable ~= CurrentControlModule then
			if CurrentControlModule then
				CurrentControlModule:Disable()
			end
			setJumpModule(isJumpEnabled)
			CurrentControlModule = newModuleToEnable
			if CurrentControlModule and not IsModalEnabled then
				CurrentControlModule:Enable()
				if isJumpEnabled then TouchJumpModule:Enable() end
			end
		end
	end
elseif UserInputService.KeyboardEnabled then
	onControlsChanged = function()
		-- NOTE: Click to move still uses keyboard. Leaving cases in case this ever changes.
		local newModuleToEnable = nil
		if not IsUserChoice then
			if DevMovementMode == Enum.DevComputerMovementMode.KeyboardMouse then
				newModuleToEnable = ControlModules.Keyboard
			elseif DevMovementMode == Enum.DevComputerMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = ControlModules.Keyboard
			end
		else
			if UserMovementMode == Enum.ComputerMovementMode.KeyboardMouse or UserMovementMode == Enum.ComputerMovementMode.Default then
				newModuleToEnable = ControlModules.Keyboard
			elseif UserMovementMode == Enum.ComputerMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = ControlModules.Keyboard
			end
		end
		if newModuleToEnable ~= CurrentControlModule then
			if CurrentControlModule then
				CurrentControlModule:Disable()
			end
			CurrentControlModule = newModuleToEnable
			if CurrentControlModule then
				CurrentControlModule:Enable()
			end
		end
	end
elseif UserInputService.GamepadEnabled then
	onControlsChanged = function()
		-- nil for now, probably needs some stuff later
	end
end


Prompt: --		print("2!!!",hum.Health)

Response:
		if hum.Health<1 then return end
	end

	if string.upper(Type) == "AOE" then
		-- AoE
		explosion = Instance.new("Explosion")
		explosion.Position = bullet.Position
		explosion.ExplosionType = ("NoCraters")
		-- 		find instigator tag
		--local creator = script.Parent:findFirstChild("creator")
		--if creator ~= nil then
		--	explosion.Hit:connect(function(part, distance)  onPlayerBlownUp(part, distance, creator) end)
		--end
		explosion.Parent = game.Workspace
	else -- SINGLE
		local hum = hit.Parent:FindFirstChild("Humanoid")
	    if hum~= nil then
	        hum:TakeDamage(damage)
	    end
	end

	connection:disconnect()
	wait(.1)
	bullet:remove()
end


Prompt: -- TODO: Optimize for vertical faces

Response:
function BitOps.getConnectivityForFace(connectivity, face)
	local result = 0

	local bitIndexes = BitOps.CONNECTIVITY_INDEXES_FOR_FACE[tostring(BitOps.normalizeVec3(face))]
	for _, index in ipairs(bitIndexes) do
		result = bit32.lshift(result, 1)
		result = bit32.bor(result, bit32.extract(connectivity, index))
	end

	return result
end

function BitOps.getVerticalFaceFromOccupancy(occupancy)
	local horizontalFace
	for _, face in pairs(BitOps.FACES) do
		horizontalFace = face.Y ~= 0
		if not horizontalFace and occupancy == BitOps.OCCUPANCY_FACE_MASK[tostring(face)] then
			return face
		end
	end

	return false
end

function BitOps.applyFaceOccupancy(targetOccupancy, targetFace, appliedOccupancy, appliedFace)
	local appliedOccupancyFaceBit = bit32.extract(appliedOccupancy, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(appliedFace))])
	if appliedOccupancyFaceBit == 1 then
		targetOccupancy =
			bit32.replace(targetOccupancy, appliedOccupancyFaceBit, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(targetFace))])
	end

	return targetOccupancy
end

function BitOps.removeFaceOccupancy(targetOccupancy, targetFace, appliedOccupancy, appliedFace)
	local appliedOccupancyFaceBit = bit32.extract(appliedOccupancy, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(appliedFace))])
	if appliedOccupancyFaceBit == 1 then
		targetOccupancy =
		bit32.replace(targetOccupancy, 0, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(targetFace))])
	end

	return targetOccupancy
end

function BitOps.applyFaceConnectivity(targetConnectivity, targetFace, appliedConnectivity, appliedFace)
	local appliedConnectivityFaceBits = BitOps.getConnectivityForFace(appliedConnectivity, appliedFace)
	local targetConnectivityFaceBits = BitOps.getConnectivityForFace(targetConnectivity, targetFace)
	local newTargetConnectivityFaceBits = bit32.bor(targetConnectivityFaceBits, appliedConnectivityFaceBits)

	targetConnectivity = BitOps.setFaceConnectivity(targetConnectivity, targetFace, newTargetConnectivityFaceBits)

	return targetConnectivity
end


Prompt: --//Setup//--

Response: Humanoid:SetStateEnabled(Enum.HumanoidStateType.Swimming, false)


Prompt: --Remove with FFlagPlayerScriptsBindAtPriority

Response:
function BaseCamera:OnKeyDown(input, processed)
	if not self.hasGameLoaded and VRService.VREnabled then
		return
	end

	if processed then
		return
	end

	if self.distanceChangeEnabled then
		if input.KeyCode == Enum.KeyCode.I then
			self:SetCameraToSubjectDistance( self.currentSubjectDistance - 5 )
		elseif input.KeyCode == Enum.KeyCode.O then
			self:SetCameraToSubjectDistance( self.currentSubjectDistance + 5 )
		end
	end

	if self.panBeginLook == nil and self.keyPanEnabled then
		if input.KeyCode == Enum.KeyCode.Left then
			self.turningLeft = true
		elseif input.KeyCode == Enum.KeyCode.Right then
			self.turningRight = true
		elseif input.KeyCode == Enum.KeyCode.Comma then
			local angle = Util.RotateVectorByAngleAndRound(self:GetCameraLookVector() * Vector3.new(1,0,1), -math.pi*0.1875, math.pi*0.25)
			if angle ~= 0 then
				self.rotateInput = self.rotateInput + Vector2.new(angle, 0)
				self.lastUserPanCamera = tick()
				self.lastCameraTransform = nil
			end
		elseif input.KeyCode == Enum.KeyCode.Period then
			local angle = Util.RotateVectorByAngleAndRound(self:GetCameraLookVector() * Vector3.new(1,0,1), math.pi*0.1875, math.pi*0.25)
			if angle ~= 0 then
				self.rotateInput = self.rotateInput + Vector2.new(angle, 0)
				self.lastUserPanCamera = tick()
				self.lastCameraTransform = nil
			end
		elseif input.KeyCode == Enum.KeyCode.PageUp then
			self.rotateInput = self.rotateInput + Vector2.new(0,math.rad(15))
			self.lastCameraTransform = nil
		elseif input.KeyCode == Enum.KeyCode.PageDown then
			self.rotateInput = self.rotateInput + Vector2.new(0,math.rad(-15))
			self.lastCameraTransform = nil
		end
	end
end


Prompt:
--[[Here are some suggested ID's for you, Note these are mostly club/Dubstep songs
	1.145060711
	2.146180801
	3.152357361
	4.152357361
	5.145579822
	6.148492408
	7.142720946
	8.142372565
	9.152779074
	10.145915908
	11.138855854
--]]


Prompt: --Purchase and receive gamepasses

Response:
main.marketplaceService.PromptGamePassPurchaseFinished:Connect(function(player,assetId,isPurchased)
	local pdata = main.pd[player]
	if isPurchased and pdata then
		local validGamepass = main.permissions.gamepasses[tostring(assetId)]
		if validGamepass and not main:GetModule("cf"):FindValue(pdata.Gamepasses, assetId) then
			main:GetModule("PlayerData"):InsertStat(player, "Gamepasses", assetId)
			main:GetModule("cf"):RankPlayerSimple(player, validGamepass.Rank)
			if not main:GetModule("cf"):FindValue(main.products, assetId) then
				main:GetModule("cf"):FormatAndFireNotice(player, "UnlockRank", main:GetModule("cf"):GetRankName(validGamepass.Rank))
			end
			main:GetModule("cf"):CheckAndRankToDonor(player, pdata, assetId)
		end
	end
end)

return module


Prompt:
--	====================
--	CAMERA SHAKING
--	Make user's camera shaking when shooting
--	====================

Response:
		CameraShakingEnabled = true;
		Intensity = 0.5; --In degree


Prompt: -- Set up the event handler for the GClippsly button

Response: btn.MouseButton1Click:Connect(toggleWindow)


Prompt: -- ProfileVersionQuery object:

Response:
local ProfileVersionQuery = {
	--[[
		_profile_store = profile_store,
		_profile_key = profile_key,
		_sort_direction = sort_direction,
		_min_date = min_date,
		_max_date = max_date,

		_query_pages = pages, -- [DataStoreVersionPages]
		_query_index = index, -- [number]
		_query_failure = false,

		_is_query_yielded = false,
		_query_queue = {},
	--]]
}
ProfileVersionQuery.__index = ProfileVersionQuery

function ProfileVersionQuery:_MoveQueue()
	while #self._query_queue > 0 do
		local queue_entry = table.remove(self._query_queue, 1)
		task.spawn(queue_entry)
		if self._is_query_yielded == true then
			break
		end
	end
end

function ProfileVersionQuery:NextAsync(_is_stacking) --> [Profile] or nil

	if self._profile_store == nil then
		return nil
	end

	local profile
	local is_finished = false

	local function query_job()

		if self._query_failure == true then
			is_finished = true
			return
		end

		-- First "next" call loads version pages:

		if self._query_pages == nil then

			self._is_query_yielded = true
			task.spawn(function()
				profile = self:NextAsync(true)
				is_finished = true
			end)

			local list_success, error_message = pcall(function()
				self._query_pages = self._profile_store._global_data_store:ListVersionsAsync(
					self._profile_key,
					self._sort_direction,
					self._min_date,
					self._max_date
				)
				self._query_index = 0
			end)

			if list_success == false or self._query_pages == nil then
				warn("[ProfileService]: Version query fail - " .. tostring(error_message))
				self._query_failure = true
			end

			self._is_query_yielded = false
			self:_MoveQueue()

			return

		end

		local current_page = self._query_pages:GetCurrentPage()
		local next_item = current_page[self._query_index + 1]

		-- No more entries:

		if self._query_pages.IsFinished == true and next_item == nil then
			is_finished = true
			return
		end

		-- Load next page when this page is over:

		if next_item == nil then

			self._is_query_yielded = true
			task.spawn(function()
				profile = self:NextAsync(true)
				is_finished = true
			end)

			local success = pcall(function()
				self._query_pages:AdvanceToNextPageAsync()
				self._query_index = 0
			end)

			if success == false or #self._query_pages:GetCurrentPage() == 0 then
				self._query_failure = true
			end

			self._is_query_yielded = false
			self:_MoveQueue()

			return

		end

		-- Next page item:

		self._query_index += 1
		profile = self._profile_store:ViewProfileAsync(self._profile_key, next_item.Version)
		is_finished = true

	end

	if self._is_query_yielded == false then
		query_job()
	else
		if _is_stacking == true then
			table.insert(self._query_queue, 1, query_job)
		else
			table.insert(self._query_queue, query_job)
		end
	end

	while is_finished == false do
		task.wait()
	end

	return profile

end


Prompt: --watch the video to know where to put it

Response:
local repStorage = game:GetService("ReplicatedStorage")
local remote = repStorage:FindFirstChild("Rebirth")

local button = script.Parent

local debounce = false

button.MouseButton1Click:Connect(function()
	local rebirths = game.Players.LocalPlayer.leaderstats:FindFirstChild("Rebirths")
	if not debounce then
		debounce = true
		local playerPoint = rebirths
		remote:FireServer(playerPoint)
		wait(0.001)
		debounce = false
	end
end)

repeat
	local rebirths = game.Players.LocalPlayer.leaderstats:FindFirstChild("Rebirths")
	local textButton = script.Parent
	textButton.Text = "".. tostring(1000000 * (rebirths.Value + 1)) .." Cash "
	wait(0.001)
until script.Parent == nil


Prompt:
--[[
INSTRUCTIONS: Place both teleporter1a and teleporter1b in the same directory
(e.g. both in workspace directly, or both directly in the same group or model)
Otherwise it wont work. Once youve done that, jump on the teleporter to teleport to the other.
If you want more than one set of teleporters I will be adding more types in the future.

Send me requests and ideas - miked.
--]]


Prompt: --!strict

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

local PostSimulation = RunService.Heartbeat

local OPT_INTERVAL_ATTRIBUTE = "Interval"
local OPT_INTERVAL = 3
local OPT_SWITCH_ATTRIBUTE = "Switch"
local OPT_SWITCH = false
local OPT_DEFAULT_MATERIAL = Enum.Material.SmoothPlastic
local OPT_SWITCH_MATERIAL = Enum.Material.ForceField

local Obstacle = {}

Obstacle.__index = Obstacle

function Obstacle.new(instance: Instance)
	local self = setmetatable({}, Obstacle)

	self._events = {}
	self._materialCache = {}
	self._lastTick = tick()

	self._instance = instance
	self._interval = instance:GetAttribute(OPT_INTERVAL_ATTRIBUTE) or OPT_INTERVAL
	self._switch = instance:GetAttribute(OPT_SWITCH_ATTRIBUTE) or OPT_SWITCH

	self:CachePartMaterials()

	table.insert(self._events, PostSimulation:Connect(function()
		local now = tick()

		if now - self._lastTick < self._interval then
			return
		end

		self._lastTick = now
		self:ToggleState()
	end))

	self:UpdateParts()

	return self
end

function Obstacle:GetAllParts(): {BasePart}
	local parts = {}

	if self._instance:IsA("BasePart") then
		table.insert(parts, self._instance::BasePart)
	end

	for _, child: BasePart in ipairs(self._instance:GetDescendants()) do
		if child:IsA("BasePart") then
			table.insert(parts, child)
		end
	end

	return parts
end

function Obstacle:CachePartMaterials()
	for _, part: BasePart in ipairs(self:GetAllParts()) do
		self._materialCache[part] = part.Material
	end
end

function Obstacle:GetSwitchState(): boolean
	return self._instance:GetAttribute(OPT_SWITCH_ATTRIBUTE) == true
end

function Obstacle:ToggleState()
	self._instance:SetAttribute(OPT_SWITCH_ATTRIBUTE, not self:GetSwitchState())
	self:UpdateParts()
end

function Obstacle:UpdateParts()
	for _, part in ipairs(self:GetAllParts()) do
		self:SetPartMaterial(part)
	end
end

function Obstacle:SetPartMaterial(part: BasePart)
	local switch = self:GetSwitchState()

	part.CanCollide = switch
	part.Material = switch and (self._materialCache[part] or OPT_DEFAULT_MATERIAL) or
		OPT_SWITCH_MATERIAL
end

function Obstacle:Destroy()
	for _, event: RBXScriptConnection in ipairs(self._events) do
		event:Disconnect()
	end
end

return Obstacle


Prompt: -- Create component

Response: local TextBox = Roact.PureComponent:extend 'TextBox'


Prompt: -- Encuentra el sonido llamado "hyperx" en el servicio de sonido

Response: local sound = soundService:FindFirstChild("final")


Response:
tool.Equipped:connect(function()
	equipped = true
	owner = game:GetService("Players"):GetPlayerFromCharacter(tool.Parent)
	character = owner.Character
	local rightarm = Instance.new("Weld", character.Torso)
	rightarm.Part0 = character.Torso
	rightarm.Part1 = character["Right Arm"]
	rightarm.C0 = CFrame.new(1.5,0,0)
	rightarm.Name = "RightArmWeldpunch"
	local leftarm = Instance.new("Weld", character.Torso)
	leftarm.Part0 = character.Torso
	leftarm.Part1 = character["Left Arm"]
	leftarm.C0 = CFrame.new(-1.5,0,0)
	leftarm.Name = "LeftArmWeldpunch"
	local head = Instance.new("Weld", character.Torso)
	head.Part0 = character.Torso
	head.Part1 = character.Head
	head.C0 = CFrame.new(0,1.5,0)
	head.Name = "HeadWeldpunch"
	local humanoidrootpart = Instance.new("Weld", character.HumanoidRootPart)
	humanoidrootpart.Part0 = character.HumanoidRootPart
	humanoidrootpart.Part1 = character.Torso
	humanoidrootpart.Name = "HumanoidRootPartWeldpunch"
	for i,v in pairs(script:GetChildren()) do
		if v.ClassName == "Sound" then
			v.Parent = character.HumanoidRootPart
		end
	end
	cananimate = true
	local savedchar = character
	local lasthp = character:findFirstChildOfClass("Humanoid").Health
	coroutine.wrap(function()
		local humhp = character:findFirstChildOfClass("Humanoid").Health
		while runservice.Stepped:wait() and equipped do
			if character:findFirstChildOfClass("Humanoid").Health < humhp then
				local thedamage = humhp - character:findFirstChildOfClass("Humanoid").Health
				character:findFirstChildOfClass("Humanoid").Health = character:findFirstChildOfClass("Humanoid").Health + thedamage/2.5
			end
			if cananimate then
				head.C0 = head.C0:lerp(CFrame.new(0,1.5,0),0.1)
				humanoidrootpart.C0 = humanoidrootpart.C0:lerp(CFrame.new(),0.2)
				leftarm.C0 = leftarm.C0:lerp(CFrame.new(-0.8,0.15,-0.5) * CFrame.fromEulerAnglesXYZ(math.pi-(math.rad(20)),0,math.rad(15)) * CFrame.new(0,-0.5,0),0.2)
				rightarm.C0 = rightarm.C0:lerp(CFrame.new(0.8,0.15,-0.5) * CFrame.fromEulerAnglesXYZ(math.pi-(math.rad(20)),0,math.rad(-15)) * CFrame.new(0,-0.5,0),0.2)
			end
			humhp = character:findFirstChildOfClass("Humanoid").Health
		end
	end)()
end)
tool.Unequipped:connect(function()
	equipped = false
	instancewhitelist = {}
	mouseclick = false
	cananimate = false
	for i,v in pairs(character.HumanoidRootPart:GetChildren()) do
		if v.ClassName == "Sound" then
			v.Parent = script
		end
	end
	if character.Torso:findFirstChild("LeftArmWeldpunch") then
		character.Torso:findFirstChild("LeftArmWeldpunch"):destroy()
	end
	if character.Torso:findFirstChild("RightArmWeldpunch") then
		character.Torso:findFirstChild("RightArmWeldpunch"):destroy()
	end
	if character.Torso:findFirstChild("HeadWeldpunch") then
		character.Torso:findFirstChild("HeadWeldpunch"):destroy()
	end
	if character:findFirstChild("HumanoidRootPart") then
		if character.HumanoidRootPart:findFirstChild("HumanoidRootPartWeldpunch") then
			character.HumanoidRootPart:findFirstChild("HumanoidRootPartWeldpunch"):destroy()
		end
	end
end)


Prompt:
-- Displays a hint to the player that the GUI auto-hides.
--
-- ForbiddenJ

Response:
IsGuiDisplayed = script.Parent.IsDisplayed
IsHiddenByOtherGUI = script.Parent.IsHiddenByOtherGUI
SpawnNotification = game.ReplicatedStorage.ClientStorage.SpawnNotification
SmallHint = script.Parent.SmallHint

HasShownLargeHint = false

function Update()
	SmallHint.Visible = not IsGuiDisplayed.Value

	if not HasShownLargeHint and not IsGuiDisplayed.Value and not IsHiddenByOtherGUI.Value then
		HasShownLargeHint = true

		local notification =
			SpawnNotification:Invoke("Hover mouse to show panel.", nil, -1)
		SmallHint.ImageTransparency = 0
		notification.TextStrokeColor3 = Color3.new(0.7, 0.7, 0.7)

		local tween = game.TweenService:Create(
			SmallHint,
			TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, math.huge),
		{ImageTransparency = 0.85})
		tween.Parent = SmallHint
		tween:Play()
		local tween2 = game.TweenService:Create(
			notification,
			TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, math.huge),
			{TextStrokeColor3 = Color3.new(0, 0, 0)})
		tween2.Parent = notification
		tween2:Play()

		local hintCleanedUp = false
		local function cleanupHint()
			if not hintCleanedUp then
				if notification.Parent ~= nil then
					notification.LifetimeLeft.Value = 0
				end
				tween:Cancel()
				tween:Destroy()
				SmallHint.ImageTransparency = 0.85

				hintCleanedUp = true
			end
		end

		delay(10, cleanupHint)
		IsGuiDisplayed.Changed:Wait()
		cleanupHint()
	end
end

IsGuiDisplayed.Changed:Connect(Update)

Update()


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

Response:
local v1 = {};
local v2 = require(game.ReplicatedStorage.Modules.Lightning);
local v3 = require(game.ReplicatedStorage.Modules.Xeno);
local v4 = require(game.ReplicatedStorage.Modules.CameraShaker);
local l__TweenService__5 = game.TweenService;
local l__Debris__6 = game.Debris;
local l__ReplicatedStorage__1 = game.ReplicatedStorage;
function v1.RunStompFx(p1, p2, p3, p4)
	local v7 = {};
	for v8 = 1, 15 do
		local v9 = l__ReplicatedStorage__1.KillFX[p1].Gate:Clone();
		v9.Parent = workspace.Ignored.Animations;
		local l__p__10 = p2.Parent.UpperTorso.CFrame.p;
		game.Debris:AddItem(v9, 6);
		v9.CFrame = CFrame.new(l__p__10.X + math.random(-35, 35), l__p__10.Y + math.random(17, 35), l__p__10.Z + math.random(-35, 35));
		v9.CFrame = CFrame.lookAt(v9.Position, p2.Position);
		table.insert(v7, v9);
		local v11 = math.random(-360, 360);
		v9.Middle.Cut.Rotation = NumberRange.new(v11, v11);
		task.delay(0.15, function()
			v9.Middle.Cut.Enabled = false;
			v9.Attachment.Effect.Enabled = true;
			v9.FF.Enabled = true;
			v9.Sound:Play();
		end);
		task.wait(0.06);
	end;
	local v12 = {};
	for v13, v14 in pairs(v7) do
		local v15 = l__ReplicatedStorage__1.KillFX[p1].Sword:Clone();
		v15.Parent = workspace.Ignored.Animations;
		game.Debris:AddItem(v15, 5);
		v15.CFrame = v14.CFrame * CFrame.new(0, 0, -1) * CFrame.Angles(-1.5707963267948966, math.rad(math.random(-360, 360)), 0);
		game.TweenService:Create(v15, TweenInfo.new(1, Enum.EasingStyle.Quint), {
			Size = v15.F.Value,
			CFrame = v14.CFrame * CFrame.new(0, 0, -3) * CFrame.Angles(-1.5707963267948966, math.rad(math.random(-360, 360)), 0)
		}):Play();
		table.insert(v12, v15);
		task.wait(0.04);
	end;
	task.wait(0.25);
	for v16, v17 in pairs(v7) do
		v17.FF.Enabled = false;
		v17.Attachment.Effect.Enabled = false;
	end;
	for v18, v19 in pairs(v12) do
		v19[math.random(1, 3)]:Play();
		local l__Position__20 = v19.Position;
		game.TweenService:Create(v19, TweenInfo.new(0.65, Enum.EasingStyle.Quint), {
			Position = (CFrame.new(p2.Position) * CFrame.new(0, math.random(-0.9, 0.1), 0)).Position
		}):Play();
		task.delay(1, function()
			v19.Charge.Enabled = false;
			game.TweenService:Create(v19, TweenInfo.new(1, Enum.EasingStyle.Quint), {
				Transparency = 1
			}):Play();
		end);
		task.wait(0.025);
	end;
	return nil;
end;
return v1;


Prompt: -- ROBLOX TODO: add type constraint <EachCallback extends Global.TestCallback>

Response:
local function default<EachCallback>(cb_: GlobalCallback?, supportsDone_: boolean?)
	local supportsDone = if supportsDone_ ~= nil then supportsDone_ else true
	local cb = cb_ or unavailableFn
	return function(
		table_: Global_EachTable,
		...: any --[[ ROBLOX comment: Upstream type: <Global.TemplateData> (Array<unknown>) ]]
	)
		local taggedTemplateData = if select("#", ...) > 0 then { ... } else {}

		local function eachBind(title: string, test: Global_EachTestFn<EachCallback>, timeout: number?): ()
			local ok, result = pcall(function()
				local tests = if isArrayTable(taggedTemplateData)
					then buildArrayTests(title, table_)
					else buildTemplateTests(title, table_, taggedTemplateData)

				return Array.forEach(tests, function(row)
					-- ROBLOX FIXME Luau: supports done is known to be a boolean at this point
					return cb(row.title, applyArguments(supportsDone, row.arguments, test), timeout)
				end) :: any
			end)

			if not ok then
				local error_ = ErrorWithStack.new(result.message, eachBind)
				return cb(title, function()
					error(error_)
				end)
			end

			return result
		end
		return eachBind
	end
end
exports.default = default

function isArrayTable(data: Global_TemplateData)
	return #data == 0
end

function buildArrayTests(title: string, table_: Global_EachTable): EachTests
	validateArrayTable(table_)
	return convertArrayTable(title, table_ :: Global_ArrayTable)
end

function buildTemplateTests(title: string, table_: Global_EachTable, taggedTemplateData: Global_TemplateData): EachTests
	local headings = getHeadingKeys((table_ :: Array<string>)[1] :: string)
	validateTemplateTableArguments(headings, taggedTemplateData)
	return convertTemplateTable(title, headings, taggedTemplateData)
end

function getHeadingKeys(headings: string): Array<string>
	return String.split(extractValidTemplateHeadings(headings):gsub("%s+", ""), "|")
end


Prompt:
--[=[
	@type ServerMiddleware {ServerMiddlewareFn}
	@within KnitServer
	An array of server middleware functions.
]=]

Response: type ServerMiddleware = {ServerMiddlewareFn}


Prompt: --Code--

Response:
local function PlayerTouched(Part)
	local Parent = Part.Parent
	if game.Players:GetPlayerFromCharacter(Parent) then
		Parent.Humanoid.Health = 1
		Parent.Humanoid.Walkspeed = 5
		wait(7.5)
		Parent.Humanoid.Walkspeed = 12
		wait(7.5)
		Parent.Humanoid.Walkspeed = 16
	end
end

Brick.Touched:connect(PlayerTouched)


Prompt: --		print("Wha " .. pose)

Response:
		stopAllAnimations()
		amplitude = 0.1
		frequency = 1
		setAngles = true
	end

	if (setAngles) then
		desiredAngle = amplitude * math.sin(time * frequency)

		RightShoulder:SetDesiredAngle(desiredAngle + climbFudge)
		LeftShoulder:SetDesiredAngle(desiredAngle - climbFudge)
		RightHip:SetDesiredAngle(-desiredAngle)
		LeftHip:SetDesiredAngle(-desiredAngle)
	end

	-- Tool Animation handling
	local tool = getTool()
	if tool then

		animStringValueObject = getToolAnim(tool)

		if animStringValueObject then
			toolAnim = animStringValueObject.Value
			-- message recieved, delete StringValue
			animStringValueObject.Parent = nil
			toolAnimTime = time + .3
		end

		if time > toolAnimTime then
			toolAnimTime = 0
			toolAnim = "None"
		end

		animateTool()
	else
		stopToolAnimations()
		toolAnim = "None"
		toolAnimTime = 0
	end
end


Prompt: --[[Steering]]

Response:
Tune.SteerInner		= 49		-- Inner wheel steering angle (in degrees)
Tune.SteerOuter		= 50		-- Outer wheel steering angle (in degrees)
Tune.SteerSpeed		= .02		-- Steering increment per tick (in degrees)
Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
Tune.SteerDecay		= 150		-- Speed of gradient cutoff (in SPS)
Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
Tune.MSteerExp		= 1			-- Mouse steering exponential degree

	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness


Prompt:
--Preforms a "soft shutdown". It will teleport players to a reserved server
--and teleport them back, with a new server. ORiginal version by Merely.
--Be aware this will hard shutdown reserved servers.

Response:
local PlaceId = game.PlaceId

local Players = game:GetService("Players")
local TeleportService = game:GetService("TeleportService")

local TeleportScreenCreator = script:WaitForChild("TeleportScreenCreator")
local CreateTeleportScreen = require(TeleportScreenCreator)

local SoftShutdownLocalScript = script:WaitForChild("SoftShutdownLocalScript")
TeleportScreenCreator.Parent = SoftShutdownLocalScript
SoftShutdownLocalScript.Parent = game:GetService("ReplicatedFirst")

local StartShutdown = Instance.new("RemoteEvent")
StartShutdown.Name = "StartShutdown"
StartShutdown.Parent = game.ReplicatedStorage

if not (game.VIPServerId ~= "" and game.VIPServerOwnerId == 0) then
	--If it is not a reserved server, bind the teleporting on close.
	game:BindToClose(function()
		--Return if there is no players.
		if #game.Players:GetPlayers() == 0 then
			return
		end

		--Return if the server instance is offline.
		if game.JobId == "" then
			return
		end

		--Send the shutdown message.
		StartShutdown:FireAllClients(true)
		wait(2)
		local ReservedServerCode = TeleportService:ReserveServer(PlaceId)

		--Create the teleport GUI.
		local ScreenGui = CreateTeleportScreen()
		local function TeleportPlayer(Player)
			TeleportService:TeleportToPrivateServer(PlaceId,ReservedServerCode,{Player},nil,{IsTemporaryServer=true,PlaceId = PlaceId},ScreenGui)
		end

		--Teleport players and try to keep the server alive until all players leave.
		for _,Player in pairs(Players:GetPlayers()) do
			TeleportPlayer(Player)
		end
		game.Players.PlayerAdded:connect(TeleportPlayer)
		while #Players:GetPlayers() > 0 do wait() end
	end)
end


Prompt: -- Inserts `v` into `t` at `i`. Also sets `Index` field in `v`.

Response:
local function insert(t,i,v)
	for n = #t,i,-1 do
		local v = t[n]
		v.Index = n+1
		t[n+1] = v
	end
	v.Index = i
	t[i] = v
end


Prompt: -- Listener for changes to workspace.CurrentCamera

Response:
function BaseCamera:OnCurrentCameraChanged()
	if UserInputService.TouchEnabled then
		if self.viewportSizeChangedConn then
			self.viewportSizeChangedConn:Disconnect()
			self.viewportSizeChangedConn = nil
		end

		local newCamera = game.Workspace.CurrentCamera

		if newCamera then
			self:OnViewportSizeChanged()
			self.viewportSizeChangedConn = newCamera:GetPropertyChangedSignal("ViewportSize"):Connect(function()
				self:OnViewportSizeChanged()
			end)
		end
	end

	-- VR support additions
	if self.cameraSubjectChangedConn then
		self.cameraSubjectChangedConn:Disconnect()
		self.cameraSubjectChangedConn = nil
	end

	local camera = game.Workspace.CurrentCamera
	if camera then
		self.cameraSubjectChangedConn = camera:GetPropertyChangedSignal("CameraSubject"):Connect(function()
			self:OnNewCameraSubject()
		end)
		self:OnNewCameraSubject()
	end
end

function BaseCamera:OnDynamicThumbstickEnabled()
	if UserInputService.TouchEnabled then
		self.isDynamicThumbstickEnabled = true
	end
end

function BaseCamera:OnDynamicThumbstickDisabled()
	self.isDynamicThumbstickEnabled = false
end

function BaseCamera:OnGameSettingsTouchMovementModeChanged()
	if player.DevTouchMovementMode == Enum.DevTouchMovementMode.UserChoice then
		if (UserGameSettings.TouchMovementMode == Enum.TouchMovementMode.DynamicThumbstick
			or UserGameSettings.TouchMovementMode == Enum.TouchMovementMode.Default) then
			self:OnDynamicThumbstickEnabled()
		else
			self:OnDynamicThumbstickDisabled()
		end
	end
end

function BaseCamera:OnDevTouchMovementModeChanged()
	if player.DevTouchMovementMode.Name == "DynamicThumbstick" then
		self:OnDynamicThumbstickEnabled()
	else
		self:OnGameSettingsTouchMovementModeChanged()
	end
end

function BaseCamera:OnPlayerCameraPropertyChange()
	-- This call forces re-evaluation of player.CameraMode and clamping to min/max distance which may have changed
	self:SetCameraToSubjectDistance(self.currentSubjectDistance)
end

function BaseCamera:GetCameraHeight()
	if VRService.VREnabled and not self.inFirstPerson then
		return math.sin(VR_ANGLE) * self.currentSubjectDistance
	end
	return 0
end

function BaseCamera:InputTranslationToCameraAngleChange(translationVector, sensitivity)
	if not FFlagUserDontAdjustSensitvityForPortrait then
		local camera = game.Workspace.CurrentCamera
		if camera and camera.ViewportSize.X > 0 and camera.ViewportSize.Y > 0 and (camera.ViewportSize.Y > camera.ViewportSize.X) then
			-- Screen has portrait orientation, swap X and Y sensitivity
			return translationVector * Vector2.new( sensitivity.Y, sensitivity.X)
		end
	end
	return translationVector * sensitivity
end

function BaseCamera:Enable(enable)
	if self.enabled ~= enable then
		self.enabled = enable
		if self.enabled then
			self:ConnectInputEvents()
			self:BindContextActions()

			if player.CameraMode == Enum.CameraMode.LockFirstPerson then
				self.currentSubjectDistance = 0.5
				if not self.inFirstPerson then
					self:EnterFirstPerson()
				end
			end
		else
			self:DisconnectInputEvents()
			self:UnbindContextActions()
			-- Clean up additional event listeners and reset a bunch of properties
			self:Cleanup()
		end
	end
end

function BaseCamera:GetEnabled()
	return self.enabled
end

function BaseCamera:OnInputBegan(input, processed)
	if input.UserInputType == Enum.UserInputType.Touch then
		self:OnTouchBegan(input, processed)
	elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
		self:OnMouse2Down(input, processed)
	elseif input.UserInputType == Enum.UserInputType.MouseButton3 then
		self:OnMouse3Down(input, processed)
	end
end

function BaseCamera:OnInputChanged(input, processed)
	if input.UserInputType == Enum.UserInputType.Touch then
		self:OnTouchChanged(input, processed)
	elseif input.UserInputType == Enum.UserInputType.MouseMovement then
		self:OnMouseMoved(input, processed)
	end
end

function BaseCamera:OnInputEnded(input, processed)
	if input.UserInputType == Enum.UserInputType.Touch then
		self:OnTouchEnded(input, processed)
	elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
		self:OnMouse2Up(input, processed)
	elseif input.UserInputType == Enum.UserInputType.MouseButton3 then
		self:OnMouse3Up(input, processed)
	end
end

function BaseCamera:OnPointerAction(wheel, pan, pinch, processed)
	if processed then
		return
	end

	if pan.Magnitude > 0 then
		local inversionVector = Vector2.new(1, UserGameSettings:GetCameraYInvertValue())
		local rotateDelta = self:InputTranslationToCameraAngleChange(PAN_SENSITIVITY*pan, MOUSE_SENSITIVITY)*inversionVector
		self.rotateInput = self.rotateInput + rotateDelta
	end

	local zoom = self.currentSubjectDistance
	local zoomDelta = -(wheel + pinch)

	if abs(zoomDelta) > 0 then
		local newZoom
		if self.inFirstPerson and zoomDelta > 0 then
			newZoom = FIRST_PERSON_DISTANCE_THRESHOLD
		else
			newZoom = zoom + zoomDelta*(1 + zoom*ZOOM_SENSITIVITY_CURVATURE)
		end

		self:SetCameraToSubjectDistance(newZoom)
	end
end

function BaseCamera:ConnectInputEvents()
	self.pointerActionConn = UserInputService.PointerAction:Connect(function(wheel, pan, pinch, processed)
		self:OnPointerAction(wheel, pan, pinch, processed)
	end)

	self.inputBeganConn = UserInputService.InputBegan:Connect(function(input, processed)
		self:OnInputBegan(input, processed)
	end)

	self.inputChangedConn = UserInputService.InputChanged:Connect(function(input, processed)
		self:OnInputChanged(input, processed)
	end)

	self.inputEndedConn = UserInputService.InputEnded:Connect(function(input, processed)
		self:OnInputEnded(input, processed)
	end)

	self.menuOpenedConn = GuiService.MenuOpened:connect(function()
		self:ResetInputStates()
	end)

	self.gamepadConnectedConn = UserInputService.GamepadDisconnected:connect(function(gamepadEnum)
		if self.activeGamepad ~= gamepadEnum then return end
		self.activeGamepad = nil
		self:AssignActivateGamepad()
	end)

	self.gamepadDisconnectedConn = UserInputService.GamepadConnected:connect(function(gamepadEnum)
		if self.activeGamepad == nil then
			self:AssignActivateGamepad()
		end
	end)

	self:AssignActivateGamepad()
	if not FFlagUserCameraToggle then
		self:UpdateMouseBehavior()
	end
end

function BaseCamera:BindContextActions()
	self:BindGamepadInputActions()
	self:BindKeyboardInputActions()
end

function BaseCamera:AssignActivateGamepad()
	local connectedGamepads = UserInputService:GetConnectedGamepads()
	if #connectedGamepads > 0 then
		for i = 1, #connectedGamepads do
			if self.activeGamepad == nil then
				self.activeGamepad = connectedGamepads[i]
			elseif connectedGamepads[i].Value < self.activeGamepad.Value then
				self.activeGamepad = connectedGamepads[i]
			end
		end
	end

	if self.activeGamepad == nil then -- nothing is connected, at least set up for gamepad1
		self.activeGamepad = Enum.UserInputType.Gamepad1
	end
end

function BaseCamera:DisconnectInputEvents()
	if self.inputBeganConn then
		self.inputBeganConn:Disconnect()
		self.inputBeganConn = nil
	end
	if self.inputChangedConn then
		self.inputChangedConn:Disconnect()
		self.inputChangedConn = nil
	end
	if self.inputEndedConn then
		self.inputEndedConn:Disconnect()
		self.inputEndedConn = nil
	end
end

function BaseCamera:UnbindContextActions()
	for i = 1, #self.boundContextActions do
		ContextActionService:UnbindAction(self.boundContextActions[i])
	end
	self.boundContextActions = {}
end

function BaseCamera:Cleanup()
	if self.pointerActionConn then
		self.pointerActionConn:Disconnect()
		self.pointerActionConn = nil
	end
	if self.menuOpenedConn then
		self.menuOpenedConn:Disconnect()
		self.menuOpenedConn = nil
	end
	if self.mouseLockToggleConn then
		self.mouseLockToggleConn:Disconnect()
		self.mouseLockToggleConn = nil
	end
	if self.gamepadConnectedConn then
		self.gamepadConnectedConn:Disconnect()
		self.gamepadConnectedConn = nil
	end
	if self.gamepadDisconnectedConn then
		self.gamepadDisconnectedConn:Disconnect()
		self.gamepadDisconnectedConn = nil
	end
	if self.subjectStateChangedConn then
		self.subjectStateChangedConn:Disconnect()
		self.subjectStateChangedConn = nil
	end
	if self.viewportSizeChangedConn then
		self.viewportSizeChangedConn:Disconnect()
		self.viewportSizeChangedConn = nil
	end
	if self.touchActivateConn then
		self.touchActivateConn:Disconnect()
		self.touchActivateConn = nil
	end

	self.turningLeft = false
	self.turningRight = false
	self.lastCameraTransform = nil
	self.lastSubjectCFrame = nil
	self.userPanningTheCamera = false
	self.rotateInput = Vector2.new()
	self.gamepadPanningCamera = Vector2.new(0,0)

	-- Reset input states
	self.startPos = nil
	self.lastPos = nil
	self.panBeginLook = nil
	self.isRightMouseDown = false
	self.isMiddleMouseDown = false

	self.fingerTouches = {}
	self.dynamicTouchInput = nil
	self.numUnsunkTouches = 0

	self.startingDiff = nil
	self.pinchBeginZoom = nil

	-- Unlock mouse for example if right mouse button was being held down
	if UserInputService.MouseBehavior ~= Enum.MouseBehavior.LockCenter then
		UserInputService.MouseBehavior = Enum.MouseBehavior.Default
	end
end


Prompt: -- Issue with play solo? (F6)

Response:
while not UserInputService.KeyboardEnabled and not UserInputService.TouchEnabled and not UserInputService.GamepadEnabled do
	wait()
end


Prompt: --// Firemode Functions

Response:
function CreateBullet(L_203_arg1)
	local L_204_ = L_59_.Position
	local L_205_ = (L_4_.Hit.p - L_204_).unit
	local L_206_ = CFrame.Angles(math.rad(math.random(-L_203_arg1, L_203_arg1)), math.rad(math.random(-L_203_arg1, L_203_arg1)), math.rad(math.random(-L_203_arg1, L_203_arg1)))
	L_205_ = L_206_ * L_205_
	local L_207_ = CFrame.new(L_204_, L_204_ + L_205_)

	local L_208_ = Instance.new("Part", L_104_)
	game.Debris:AddItem(L_208_, 10)
	L_208_.Shape = Enum.PartType.Ball
	L_208_.Size = Vector3.new(1, 1, 12)
	L_208_.Name = "Bullet"
	L_208_.TopSurface = "Smooth"
	L_208_.BottomSurface = "Smooth"
	L_208_.BrickColor = BrickColor.new("Bright green")
	L_208_.Material = "Neon"
	L_208_.CanCollide = false
		--Bullet.CFrame = FirePart.CFrame + (Grip.CFrame.p - Grip.CFrame.p)
	L_208_.CFrame = L_207_

	local L_209_ = Instance.new("Sound")
	L_209_.SoundId = "rbxassetid://341519743"
	L_209_.Looped = true
	L_209_:Play()
	L_209_.Parent = L_208_
	L_209_.Volume = 0.4
	L_209_.MaxDistance = 30

	L_208_.Transparency = 1
	local L_210_ = L_208_:GetMass()
	local L_211_ = Instance.new('BodyForce', L_208_)

	if not L_83_ then
		L_211_.Force = L_24_.BulletPhysics
		L_208_.Velocity = L_205_ * L_24_.BulletSpeed
	else
		L_211_.Force = L_24_.ExploPhysics
		L_208_.Velocity = L_205_ * L_24_.ExploSpeed
	end

	local L_212_ = Instance.new('Attachment', L_208_)
	L_212_.Position = Vector3.new(0.1, 0, 0)
	local L_213_ = Instance.new('Attachment', L_208_)
	L_213_.Position = Vector3.new(-0.1, 0, 0)

	local L_214_ = TracerCalculation()

	if L_24_.TracerEnabled == true and L_214_ then
		local L_215_ = Instance.new('Trail', L_208_)
		L_215_.Attachment0 = L_212_
		L_215_.Attachment1 = L_213_
		L_215_.Transparency = NumberSequence.new(L_24_.TracerTransparency)
		L_215_.LightEmission = L_24_.TracerLightEmission
		L_215_.TextureLength = L_24_.TracerTextureLength
		L_215_.Lifetime = L_24_.TracerLifetime
		L_215_.FaceCamera = L_24_.TracerFaceCamera
		L_215_.Color = ColorSequence.new(L_24_.TracerColor.Color)
	end

	if L_1_:FindFirstChild('Shell') and not L_83_ then
		CreateShell()
	end

	delay(0.2, function()
		L_208_.Transparency = 0
	end)

	return L_208_
end

function CheckForHumanoid(L_216_arg1)
	local L_217_ = false
	local L_218_ = nil
	if L_216_arg1 then
		if (L_216_arg1.Parent:FindFirstChild("Humanoid") or L_216_arg1.Parent.Parent:FindFirstChild("Humanoid")) then
			L_217_ = true
			if L_216_arg1.Parent:FindFirstChild('Humanoid') then
				L_218_ = L_216_arg1.Parent.Humanoid
			elseif L_216_arg1.Parent.Parent:FindFirstChild('Humanoid') then
				L_218_ = L_216_arg1.Parent.Parent.Humanoid
			end
		else
			L_217_ = false
		end
	end
	return L_217_, L_218_
end

function CastRay(L_219_arg1)
	local L_220_, L_221_, L_222_
	local L_223_ = L_56_.Position;
	local L_224_ = L_219_arg1.Position;
	local L_225_ = 0

	local L_226_ = L_83_

	while true do
		L_109_:wait()
		L_224_ = L_219_arg1.Position;
		L_225_ = L_225_ + (L_224_ - L_223_).magnitude
		L_220_, L_221_, L_222_ = workspace:FindPartOnRayWithIgnoreList(Ray.new(L_223_, (L_224_ - L_223_)), IgnoreList);
		local L_227_ = Vector3.new(0, 1, 0):Cross(L_222_)
		local L_228_ = math.asin(L_227_.magnitude) -- division by 1 is redundant
		if L_225_ > L_24_.BulletDecay then
			L_219_arg1:Destroy()
			break
		end
		if L_220_ and (L_220_ and L_220_.Transparency >= 1 or L_220_.CanCollide == false) and L_220_.Name ~= 'Right Arm' and L_220_.Name ~= 'Left Arm' and L_220_.Name ~= 'Right Leg' and L_220_.Name ~= 'Left Leg' and L_220_.Name ~= 'Armor' then
			table.insert(IgnoreList, L_220_)
		end

		if L_220_ then
			L_227_ = Vector3.new(0, 1, 0):Cross(L_222_)
			L_228_ = math.asin(L_227_.magnitude) -- division by 1 is redundant

			L_121_:FireServer(L_221_)

			local L_229_ = CheckForHumanoid(L_220_)
			if L_229_ == false then
				L_219_arg1:Destroy()
				L_116_:FireServer(L_221_, L_227_, L_228_, L_222_, "Part", L_220_)
			elseif L_229_ == true then
				L_219_arg1:Destroy()
				L_116_:FireServer(L_221_, L_227_, L_228_, L_222_, "Human", L_220_)
			end
		end

		if L_220_ and L_226_ then
			L_119_:FireServer(L_221_)
		end

		if L_220_ then
			local L_230_, L_231_ = CheckForHumanoid(L_220_)
			if L_230_ then
				L_114_:FireServer(L_231_)
				if L_24_.AntiTK then
					if game.Players:FindFirstChild(L_231_.Parent.Name) and game.Players:FindFirstChild(L_231_.Parent.Name).TeamColor ~= L_2_.TeamColor or L_231_.Parent:FindFirstChild('Vars') and game.Players:FindFirstChild(L_231_.Parent:WaitForChild('Vars'):WaitForChild('BotID').Value) and L_2_.TeamColor ~= L_231_.Parent:WaitForChild('Vars'):WaitForChild('teamColor').Value then
						if L_220_.Name == 'Head' then
							L_113_:FireServer(L_231_, L_24_.HeadDamage)
							local L_232_ = L_19_:WaitForChild('BodyHit'):clone()
							L_232_.Parent = L_2_.PlayerGui
							L_232_:Play()
							game:GetService("Debris"):addItem(L_232_, L_232_.TimeLength)
						end
						if L_220_.Name ~= 'Head' and not (L_220_.Parent:IsA('Accessory') or L_220_.Parent:IsA('Hat')) then
							if L_220_.Name ~= 'Torso' and L_220_.Name ~= 'HumanoidRootPart' and L_220_.Name ~= 'Armor' then
								L_113_:FireServer(L_231_, L_24_.LimbDamage)
							elseif L_220_.Name == 'Torso' or L_220_.Name == 'HumanoidRootPart' and L_220_.Name ~= 'Armor'  then
								L_113_:FireServer(L_231_, L_24_.BaseDamage)
							elseif L_220_.Name == 'Armor' then
								L_113_:FireServer(L_231_, L_24_.ArmorDamage)
							end
							local L_233_ = L_19_:WaitForChild('BodyHit'):clone()
							L_233_.Parent = L_2_.PlayerGui
							L_233_:Play()
							game:GetService("Debris"):addItem(L_233_, L_233_.TimeLength)
						end
						if (L_220_.Parent:IsA('Accessory') or L_220_.Parent:IsA('Hat')) then
							L_113_:FireServer(L_231_, L_24_.HeadDamage)
							local L_234_ = L_19_:WaitForChild('BodyHit'):clone()
							L_234_.Parent = L_2_.PlayerGui
							L_234_:Play()
							game:GetService("Debris"):addItem(L_234_, L_234_.TimeLength)
						end
					end
				else
					if L_220_.Name == 'Head' then
						L_113_:FireServer(L_231_, L_24_.HeadDamage)
						local L_235_ = L_19_:WaitForChild('BodyHit'):clone()
						L_235_.Parent = L_2_.PlayerGui
						L_235_:Play()
						game:GetService("Debris"):addItem(L_235_, L_235_.TimeLength)
					end
					if L_220_.Name ~= 'Head' and not (L_220_.Parent:IsA('Accessory') or L_220_.Parent:IsA('Hat')) then
						if L_220_.Name ~= 'Torso' and L_220_.Name ~= 'HumanoidRootPart' and L_220_.Name ~= 'Armor' then
							L_113_:FireServer(L_231_, L_24_.LimbDamage)
						elseif L_220_.Name == 'Torso' or L_220_.Name == 'HumanoidRootPart' and L_220_.Name ~= 'Armor' then
							L_113_:FireServer(L_231_, L_24_.BaseDamage)
						elseif L_220_.Name == 'Armor' then
							L_113_:FireServer(L_231_, L_24_.ArmorDamage)
						end
						local L_236_ = L_19_:WaitForChild('BodyHit'):clone()
						L_236_.Parent = L_2_.PlayerGui
						L_236_:Play()
						game:GetService("Debris"):addItem(L_236_, L_236_.TimeLength)
					end
					if (L_220_.Parent:IsA('Accessory') or L_220_.Parent:IsA('Hat')) then
						L_113_:FireServer(L_231_, L_24_.HeadDamage)
						local L_237_ = L_19_:WaitForChild('BodyHit'):clone()
						L_237_.Parent = L_2_.PlayerGui
						L_237_:Play()
						game:GetService("Debris"):addItem(L_237_, L_237_.TimeLength)
					end
				end
			end
		end

		if L_220_ and L_220_.Parent:FindFirstChild("Humanoid") then
			return L_220_, L_221_;
		end
		L_223_ = L_224_;
	end
end

function fireSemi()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true

		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_112_:FireServer()
		L_105_ = CreateBullet(L_24_.BulletSpread)
		L_106_ = L_106_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_238_, L_239_ = spawn(function()
			CastRay(L_105_)
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_106_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)

		wait(L_24_.Firerate)

		local L_240_ = JamCalculation()
		if L_240_ then
			L_69_ = false
		else
			L_69_ = true
		end
		Shooting = false
	end
end

function fireExplo()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true
		if L_54_ then
			L_54_:FireServer(L_60_:WaitForChild('Fire').SoundId, L_60_)
		else
			L_60_:WaitForChild('Fire'):Play()
		end
		L_112_:FireServer()
		L_105_ = CreateBullet(L_24_.BulletSpread)
		L_108_ = L_108_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_241_, L_242_ = spawn(function()
			CastRay(L_105_)
		end)

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)

		L_69_ = false
		Shooting = false
	end
end

function fireShot()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true
		RecoilFront = true
		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_112_:FireServer()
		for L_244_forvar1 = 1, L_24_.ShotNum do
			spawn(function()
				L_105_ = CreateBullet(L_24_.BulletSpread)
			end)
			local L_245_, L_246_ = spawn(function()
				CastRay(L_105_)
			end)
		end

		for L_247_forvar1, L_248_forvar2 in pairs(L_59_:GetChildren()) do
			if L_248_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_248_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_249_forvar1, L_250_forvar2 in pairs(L_59_:GetChildren()) do
				if L_250_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_250_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_106_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		L_106_ = L_106_ - 1
		UpdateAmmo()
		wait(L_24_.Firerate)

		L_76_ = true
		BoltBackAnim()
		BoltForwardAnim()
		IdleAnim()
		L_76_ = false

		local L_243_ = JamCalculation()
		if L_243_ then
			L_69_ = false
		else
			L_69_ = true
		end

		Shooting = false
	end
end

function fireBoltAction()
	if L_15_ then
		L_69_ = false
		Recoiling = true
		Shooting = true
		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_112_:FireServer()
		L_105_ = CreateBullet(L_24_.BulletSpread)
		L_106_ = L_106_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_251_, L_252_ = spawn(function()
			CastRay(L_105_)
		end)

		for L_254_forvar1, L_255_forvar2 in pairs(L_59_:GetChildren()) do
			if L_255_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_255_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_256_forvar1, L_257_forvar2 in pairs(L_59_:GetChildren()) do
				if L_257_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_257_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_106_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		wait(L_24_.Firerate)

		L_76_ = true
		BoltBackAnim()
		BoltForwardAnim()
		IdleAnim()
		L_76_ = false

		local L_253_ = JamCalculation()
		if L_253_ then
			L_69_ = false
		else
			L_69_ = true
		end

		Shooting = false
	end
end

function fireAuto()
	while not Shooting and L_106_ > 0 and L_68_ and L_69_ and L_15_ do
		L_69_ = false
		Recoiling = true
		--CheckReverb()
		if L_54_ then
			L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
		else
			L_59_:WaitForChild('Fire'):Play()
		end
		L_112_:FireServer()
		L_106_ = L_106_ - 1
		UpdateAmmo()
		Shooting = true
		RecoilFront = true
		L_105_ = CreateBullet(L_24_.BulletSpread)
		local L_258_, L_259_ = spawn(function()
			CastRay(L_105_)
		end)

		for L_261_forvar1, L_262_forvar2 in pairs(L_59_:GetChildren()) do
			if L_262_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_262_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_263_forvar1, L_264_forvar2 in pairs(L_59_:GetChildren()) do
				if L_264_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_264_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_106_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		wait(L_24_.Firerate)

		local L_260_ = JamCalculation()
		if L_260_ then
			L_69_ = false
		else
			L_69_ = true
		end

		Shooting = false
	end
end

function fireBurst()
	if not Shooting and L_106_ > 0 and L_68_ and L_15_ then
		for L_265_forvar1 = 1, L_24_.BurstNum do
			if L_106_ > 0 and L_68_ then
				L_69_ = false
				Recoiling = true
			--CheckReverb()
				if L_54_ then
					L_54_:FireServer(L_59_:WaitForChild('Fire').SoundId, L_59_)
				else
					L_59_:WaitForChild('Fire'):Play()
				end
				L_112_:FireServer()
				L_105_ = CreateBullet(L_24_.BulletSpread)
				local L_266_, L_267_ = spawn(function()
					CastRay(L_105_)
				end)

				for L_269_forvar1, L_270_forvar2 in pairs(L_59_:GetChildren()) do
					if L_270_forvar2.Name:sub(1, 7) == "FlashFX" then
						L_270_forvar2.Enabled = true
					end
				end

				delay(1 / 30, function()
					for L_271_forvar1, L_272_forvar2 in pairs(L_59_:GetChildren()) do
						if L_272_forvar2.Name:sub(1, 7) == "FlashFX" then
							L_272_forvar2.Enabled = false
						end
					end
				end)

				if L_24_.CanBolt == true then
					BoltingBackAnim()
					delay(L_24_.Firerate / 2, function()
						if L_24_.CanSlideLock == false then
							BoltingForwardAnim()
						elseif L_24_.CanSlideLock == true then
							if L_106_ > 0 then
								BoltingForwardAnim()
							end
						end
					end)
				end

				L_106_ = L_106_ - 1
				UpdateAmmo()
				RecoilFront = true
				delay(L_24_.Firerate / 2, function()
					Recoiling = false
					RecoilFront = false
				end)
				wait(L_24_.Firerate)

				local L_268_ = JamCalculation()
				if L_268_ then
					L_69_ = false
				else
					L_69_ = true
				end

			end
			Shooting = true
		end
		Shooting = false
	end
end

function Shoot()
	if L_15_ and L_69_ then
		if L_92_ == 1 then
			fireSemi()
		elseif L_92_ == 2 then
			fireAuto()
		elseif L_92_ == 3 then
			fireBurst()
		elseif L_92_ == 4 then
			fireBoltAction()
		elseif L_92_ == 5 then
			fireShot()
		elseif L_92_ == 6 then
			fireExplo()
		end
	end
end


Prompt: --== Init/config ==--

Response:
local car = script.Parent.Car.Value
local inputService = game:GetService("UserInputService")

local sts = script.Start

script:WaitForChild("Start")

local delayToStartEngine = 2.8 														-- The script will wait this many seconds to turn the car on
local delayToStopStartupSound = 0.1												-- The script will wait this many seconds after starting the car before stopping your ignition sound

local primaryKey 	= Enum.KeyCode.LeftShift												-- Which key on your keyboard will start your car?
local modifierKey	= Enum.KeyCode.K									-- I recommend using Right Shift - no conflicts with default AC6 keybinds, and most people never use it anyways
																							-- You could probably get away with Right Control as well


Prompt:
---Command types.
---Process a command as it is being typed. This allows for manipulation of the chat bar.

Response: local IN_PROGRESS_MESSAGE_PROCESSOR = 0


Prompt:
--[=[
	@tag Component Class
	@return Promise<ComponentInstance>

	Resolves a promise once the component instance is present on a given
	Roblox instance.

	An optional `timeout` can be provided to reject the promise if it
	takes more than `timeout` seconds to resolve. If no timeout is
	supplied, `timeout` defaults to 60 seconds.

	```lua
	local MyComponent = require(somewhere.MyComponent)

	MyComponent:WaitForInstance(workspace.SomeInstance):andThen(function(myComponentInstance)
		-- Do something with the component class
	end)
	```
]=]

Response:
function Component:WaitForInstance(instance: Instance, timeout: number?)
	local componentInstance = self:FromInstance(instance)
	if componentInstance then
		return Promise.resolve(componentInstance)
	end
	return Promise.fromEvent(self.Started, function(c)
		local match = c.Instance == instance
		if match then
			componentInstance = c
		end
		return match
	end):andThen(function()
		return componentInstance
	end):timeout(if type(timeout) == "number" then timeout else DEFAULT_TIMEOUT)
end


Prompt:
--------------------
--| Script Logic |--
--------------------

Response:
SwooshSound:Play()

Rocket.Touched:connect(OnTouched)


Prompt:
--[[
	Creates a new promise that receives the result of this promise.

	The given callbacks are invoked depending on that result.
]]

Response:
function Promise.prototype:_andThen(traceback, successHandler, failureHandler)
	self._unhandledRejection = false

	-- Create a new promise to follow this part of the chain
	return Promise._new(traceback, function(resolve, reject)
		-- Our default callbacks just pass values onto the next promise.
		-- This lets success and failure cascade correctly!

		local successCallback = resolve
		if successHandler then
			successCallback = createAdvancer(
				traceback,
				successHandler,
				resolve,
				reject
			)
		end

		local failureCallback = reject
		if failureHandler then
			failureCallback = createAdvancer(
				traceback,
				failureHandler,
				resolve,
				reject
			)
		end

		if self._status == Promise.Status.Started then
			-- If we haven't resolved yet, put ourselves into the queue
			table.insert(self._queuedResolve, successCallback)
			table.insert(self._queuedReject, failureCallback)
		elseif self._status == Promise.Status.Resolved then
			-- This promise has already resolved! Trigger success immediately.
			successCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Rejected then
			-- This promise died a terrible death! Trigger failure immediately.
			failureCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Cancelled then
			-- We don't want to call the success handler or the failure handler,
			-- we just reject this promise outright.
			reject(Error.new({
				error = "Promise is cancelled",
				kind = Error.Kind.AlreadyCancelled,
				context = "Promise created at\n\n" .. traceback,
			}))
		end
	end, self)
end

function Promise.prototype:andThen(successHandler, failureHandler)
	assert(
		successHandler == nil or type(successHandler) == "function" or successHandler.__call ~= nil,
		string.format(ERROR_NON_FUNCTION, "Promise:andThen")
	)
	assert(
		failureHandler == nil or type(failureHandler) == "function" or failureHandler.__call ~= nil,
		string.format(ERROR_NON_FUNCTION, "Promise:andThen")
	)

	return self:_andThen(debug.traceback(nil, 2), successHandler, failureHandler)
end


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 2500		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible

	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]

	Tune.AxleSize		= 2			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members


Prompt:
--[[
	Pops a node off of the navigation stack.
]]

Response:
function TestSession:popNode()
	assert(#self.nodeStack > 0, "Tried to pop from an empty node stack!")
	table.remove(self.nodeStack, #self.nodeStack)
	table.remove(self.contextStack, #self.contextStack)
	table.remove(self.expectationContextStack, #self.expectationContextStack)
end


Prompt: --Initialize Chassis

Response:
local ScriptsFolder = Car:FindFirstChild("Scripts")
local Chassis = require(ScriptsFolder:WaitForChild("Chassis"))
Chassis.InitializeDrivingValues()
Chassis.Reset()


Prompt: -- Connection class

Response:
local Connection = {}
Connection.__index = Connection

function Connection.new(signal, fn)
	return setmetatable({
		_connected = true,
		_signal = signal,
		_fn = fn,
		_next = false,
	}, Connection)
end

function Connection:Disconnect()
	self._connected = false

	-- Unhook the node, but DON'T clear it. That way any fire calls that are
	-- currently sitting on this node will be able to iterate forwards off of
	-- it, but any subsequent fire calls will not hit it, and it will be GCed
	-- when no more fire calls are sitting on it.
	if self._signal._handlerListHead == self then
		self._signal._handlerListHead = self._next
	else
		local prev = self._signal._handlerListHead
		while prev and prev._next ~= self do
			prev = prev._next
		end
		if prev then
			prev._next = self._next
		end
	end
end


Prompt:
--[[**
	asserts a given check

	@param check The function to wrap with an assert

	@returns A function that simply wraps the given check in an assert
**--]]

Response:
function t.strict(check)
	return function(...)
		assert(check(...))
	end
end

do
	local checkChildren = t.map(t.string, t.callback)


Prompt: --- Enables the "Mash to open" feature

Response:
function Cmdr:SetMashToEnable(isEnabled)
	self.MashToEnable = isEnabled

	if isEnabled then
		self:SetEnabled(false)
	end
end


Prompt:
--[[
               Manual Ignition Tool Roblox_MELIHCAN10
--]]

Response: wait(0.2) -- Removing this wait could break the script. Please do not touch this.


Prompt:
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------

Response:
function luaK:dischargevars(fs, e)
  local k = e.k
  if k == "VLOCAL" then
    e.k = "VNONRELOC"
  elseif k == "VUPVAL" then
    e.info = self:codeABC(fs, "OP_GETUPVAL", 0, e.info, 0)
    e.k = "VRELOCABLE"
  elseif k == "VGLOBAL" then
    e.info = self:codeABx(fs, "OP_GETGLOBAL", 0, e.info)
    e.k = "VRELOCABLE"
  elseif k == "VINDEXED" then
    self:freereg(fs, e.aux)
    self:freereg(fs, e.info)
    e.info = self:codeABC(fs, "OP_GETTABLE", 0, e.info, e.aux)
    e.k = "VRELOCABLE"
  elseif k == "VVARARG" or k == "VCALL" then
    self:setoneret(fs, e)
  else
    -- there is one value available (somewhere)
  end
end


Prompt:
--health.Changed:connect(function()
--root.Velocity = Vector3.new(0,5000,0)
--end)

Response:
local anims = {}
local lastAttack= tick()

local target,targetType

local lastLock = tick()

local fleshDamage = 25
local structureDamage = 20

local path = nil

for _,animObject in next,animations do
anims[animObject.Name] = hum:LoadAnimation(animObject)
end

function Attack(thing,dmg)
if tick()-lastAttack > 2 then
hum:MoveTo(root.Position)
lastAttack = tick()
anims.AntWalk:Stop()
anims.AntMelee:Play()

if thing.ClassName == "Player" then
root.FleshHit:Play()
ant:SetPrimaryPartCFrame(CFrame.new(root.Position,Vector3.new(target.Character.PrimaryPart.Position.X,root.Position.Y,target.Character.PrimaryPart.Position.Z)))

elseif thing.ClassName == "Model" then
root.StructureHit:Play()
end

rep.Events.NPCAttack:Fire(thing,dmg)
end
end

function Move(point)
hum:MoveTo(point)
if not anims.AntWalk.IsPlaying then
anims.AntWalk:Play()
end
end

function ScanForPoint()
local newPoint
local rayDir = Vector3.new(math.random(-100,100)/100,0,math.random(-100,100)/100)
local ray = Ray.new(root.Position,rayDir*math.random(10,50),ant)
local part,pos = workspace:FindPartOnRay(ray)
Move(pos)
enRoute = true
end


Prompt:
--[[
	Create a new TestPlan from a list of specification functions.

	These functions should call a combination of `describe` and `it` (and their
	variants), which will be turned into a test plan to be executed.

	Parameters:
		- modulesList - list of tables describing test modules {
			method, -- specification function described above
			path, -- array of parent entires, first element is the leaf that owns `method`
			pathStringForSorting -- a string representation of `path`, used for sorting of the test plan
		}
		- testNamePattern - Only tests matching this Lua pattern string will run. Pass empty or nil to run all tests
		- extraEnvironment - Lua table holding additional functions and variables to be injected into the specification
							function during execution
]]

Response:
function TestPlanner.createPlan(modulesList, testNamePattern, extraEnvironment)
	local plan = TestPlan.new(testNamePattern, extraEnvironment)

	table.sort(modulesList, function(a, b)
		return a.pathStringForSorting < b.pathStringForSorting
	end)

	for _, module in ipairs(modulesList) do
		plan:addRoot(module.path, module.method)
	end

	return plan
end

return TestPlanner


Prompt:
-- -- -- -- -- -- --
--DIRECTION SCROLL--
-- -- -- -- -- -- --

Response:
This.Parent.Parent.Parent.Parent.Parent:WaitForChild("Direction").Changed:connect(function(val)
    if val == 1 then
			SetDisplay(1,"U0")
    elseif val == -1 then
			SetDisplay(1,"D0")
	else
		SetDisplay(1,"NIL")
    end
end)


Response:
FakeTorso.Size = Torso.Size
FakeHumanoidRootPart.Size = HumanoidRootPart.Size
FakeTorso.CFrame = FakeHumanoidRootPart.CFrame
RootHipClone = RootHipJoint:Clone()
RootHipClone.Parent = FakeHumanoidRootPart
RootHipClone.Part0 = FakeHumanoidRootPart
RootHipClone.Part1 = FakeTorso


Prompt:
-- Reparents an instance and outputs helpful logging information so we can see
-- where instances are going at runtime.

Response:
local function move(instance: Instance, newParent: Instance)
    instance.Parent = newParent
    log("move", ("%s -> %s"):format(instance.Name, instance:GetFullName()))
end


Prompt: -- << VARIABLES >>

Response:
local topBar = main.gui.CustomTopBar
local coreToHide = {"Chat", "PlayerList"}
local originalCoreStates = {};
local cmdBar = main.gui.CmdBar
local currentProps = {}
local originalTopBarTransparency = 0.5
local originalTopBarVisibility = true
local mainProps
mainProps = {
	maxSuggestions = 5;
	mainParent = cmdBar;
	textBox = cmdBar.SearchFrame.TextBox;
	rframe = cmdBar.ResultsFrame;
	suggestionPos = 1;
	suggestionDisplayed = 0;
	forceExecute = false;
	highlightColor = Color3.fromRGB(50,50,50);
	otherColor = Color3.fromRGB(80,80,80);
	suggestionLabels = {};
	currentBarCommand = nil;
}


Prompt: --[[Engine]]

Response:
	local fFD = _Tune.FinalDrive*_Tune.FDMult
	local fFDr = fFD*30/math.pi
	local cGrav = workspace.Gravity*_Tune.InclineComp/32.2
	local wDRatio = wDia*math.pi/60
	local cfWRot = CFrame.Angles(math.pi/2,-math.pi/2,0)
	local cfYRot = CFrame.Angles(0,math.pi,0)
	local rtTwo = (2^.5)/2

	if _Tune.Aspiration == "Single" then
		_TCount = 1
		_TPsi = _Tune.Boost
	elseif _Tune.Aspiration == "Double" then
		_TCount = 2
		_TPsi = _Tune.Boost*2
	end

	--Horsepower Curve

	local HP=_Tune.Horsepower/100
	local HP_B=((_Tune.Horsepower*((_TPsi)*(_Tune.CompressRatio/10))/7.5)/2)/100
	local Peak=_Tune.PeakRPM/1000
	local Sharpness=_Tune.PeakSharpness
	local CurveMult=_Tune.CurveMult
	local EQ=_Tune.EqPoint/1000

	--Horsepower Curve

	function curveHP(RPM)
		RPM=RPM/1000
		return ((-(RPM-Peak)^2)*math.min(HP/(Peak^2),CurveMult^(Peak/HP))+HP)*(RPM-((RPM^Sharpness)/(Sharpness*Peak^(Sharpness-1))))
	end

	local PeakCurveHP = curveHP(_Tune.PeakRPM)

	function curvePSI(RPM)
		RPM=RPM/1000
		return ((-(RPM-Peak)^2)*math.min(HP_B/(Peak^2),CurveMult^(Peak/HP_B))+HP_B)*(RPM-((RPM^Sharpness)/(Sharpness*Peak^(Sharpness-1))))
	end
	local PeakCurvePSI = curvePSI(_Tune.PeakRPM)

	--Plot Current Horsepower
	function GetCurve(x,gear)
		local hp=(math.max(curveHP(x)/(PeakCurveHP/HP),0))*100
		return hp,((hp*(EQ/x))*_Tune.Ratios[gear+2]*fFD*hpScaling)*1000
	end

	--Plot Current Boost (addition to Horsepower)
	function GetPsiCurve(x,gear)
		local hp=(math.max(curvePSI(x)/(PeakCurvePSI/HP_B),0))*100
		return hp,((hp*(EQ/x))*_Tune.Ratios[gear+2]*fFD*hpScaling)*1000
	end

	--Output Cache
	local HPCache = {}
	local PSICache = {}

	if _Tune.CurveCache then
		for gear,ratio in pairs(_Tune.Ratios) do
			local nhpPlot = {}
			local bhpPlot = {}
			for rpm = math.floor(_Tune.IdleRPM/_Tune.CacheInc),math.ceil((_Tune.Redline+100)/_Tune.CacheInc) do
				local ntqPlot = {}
				local btqPlot = {}
				ntqPlot.Horsepower,ntqPlot.Torque = GetCurve(rpm*_Tune.CacheInc,gear-2)
				btqPlot.Horsepower,btqPlot.Torque = GetPsiCurve(rpm*_Tune.CacheInc,gear-2)
				hp1,tq1 = GetCurve((rpm+1)*_Tune.CacheInc,gear-2)
				hp2,tq2 = GetPsiCurve((rpm+1)*_Tune.CacheInc,gear-2)
				ntqPlot.HpSlope = (hp1 - ntqPlot.Horsepower)
				btqPlot.HpSlope = (hp2 - btqPlot.Horsepower)
				ntqPlot.TqSlope = (tq1 - ntqPlot.Torque)
				btqPlot.TqSlope = (tq2 - btqPlot.Torque)
				nhpPlot[rpm] = ntqPlot
				bhpPlot[rpm] = btqPlot
			end
			table.insert(HPCache,nhpPlot)
			table.insert(PSICache,bhpPlot)
		end
	end

	if _Tune.CurveCache then
		for gear,ratio in pairs(_Tune.Ratios) do
			for rpm = math.floor(_Tune.IdleRPM/_Tune.CacheInc),math.ceil((_Tune.Redline+100)/_Tune.CacheInc) do

			end
		end
	end

	--Powertrain
	wait()

	--Update RPM
	function RPM()
		--Neutral Gear
		if _CGear==0 then _ClutchOn = false end

		--Car Is Off
		local revMin = _Tune.IdleRPM
		if not _IsOn then
			revMin = 0
			_CGear = 0
			_ClutchOn = false
			_GThrot = _Tune.IdleThrottle/100
		end

		--Determine RPM
		local maxSpin=0
		for i,v in pairs(Drive) do
			if v.RotVelocity.Magnitude>maxSpin then maxSpin = v.RotVelocity.Magnitude end
		end
		if _ClutchOn then
			local aRPM = math.max(math.min(maxSpin*_Tune.Ratios[_CGear+2]*fFDr,_Tune.Redline+100),revMin)
			local clutchP = math.min(math.abs(aRPM-_RPM)/_Tune.ClutchTol,.87)
			_RPM = _RPM*clutchP  +  aRPM*(1-clutchP)
		else
			if _GThrot-(_Tune.IdleThrottle/100)>0 then
				if _RPM>_Tune.Redline then
					_RPM = _RPM-_Tune.RevBounce*2
				else
					_RPM = math.min(_RPM+_Tune.RevAccel*_GThrot,_Tune.Redline+100)
				end
			else
				_RPM = math.max(_RPM-_Tune.RevDecay,revMin)
			end
		end

		--Rev Limiter
		_spLimit = (_Tune.Redline+100)/(fFDr*_Tune.Ratios[_CGear+2])
		if _RPM>_Tune.Redline then
			if _CGear<#_Tune.Ratios-2 then
				_RPM = _RPM-_Tune.RevBounce
			else
				_RPM = _RPM-_Tune.RevBounce*.5
			end
		end

		local TPsi = _TPsi/_TCount
		if _CGear==0 then
			_Boost = _Boost + ((((((_RPM*(_GThrot*_GThrotShift*1.2)/_Tune.Redline)/8.5)-(((_Boost/TPsi*(TPsi/15)))))*((36/_Tune.TurboSize)*2))/TPsi)*15)
		else
			_Boost = _Boost + ((((((_HP*(_GThrot*_GThrotShift*1.2)/_Tune.Horsepower)/8)-(((_Boost/TPsi*(TPsi/15)))))*((36/_Tune.TurboSize)*2))/TPsi)*15)
		end
		if _Boost < 0.05 then _Boost = 0.05 elseif _Boost > 2 then _Boost = 2 end
	end

	--Automatic Transmission
	function Auto()
		local maxSpin=0
		for i,v in pairs(Drive) do if v.RotVelocity.Magnitude>maxSpin then maxSpin = v.RotVelocity.Magnitude end end
		if _IsOn then
			_ClutchOn = true
			if _CGear >= 1 then
				if _CGear==1 and _GBrake > 0  and car.DriveSeat.Velocity.Magnitude < 5 then
					_CGear = 1
				else
					if _Tune.AutoShiftMode == "RPM" then
						if _RPM>(_Tune.PeakRPM+_Tune.AutoUpThresh) then
							if (_CGear ~= 0) and (_CGear ~= #_Tune.Ratios-2) then
							end
							_CGear=math.min(_CGear+1,#_Tune.Ratios-2)
						elseif math.max(math.min(maxSpin*_Tune.Ratios[_CGear+1]*fFDr,_Tune.Redline+100),_Tune.IdleRPM)<(_Tune.PeakRPM-_Tune.AutoDownThresh) then
							if _CGear ~= 1 then
							end
							_CGear=math.max(_CGear-1,1)
						end
					else
						if car.DriveSeat.Velocity.Magnitude > math.ceil(wDRatio*(_Tune.PeakRPM+_Tune.AutoUpThresh)/_Tune.Ratios[_CGear+2]/fFD) then
							if (_CGear ~= 0) and (_CGear ~= #_Tune.Ratios-2) then
							end
							_CGear=math.min(_CGear+1,#_Tune.Ratios-2)
						elseif car.DriveSeat.Velocity.Magnitude < math.ceil(wDRatio*(_Tune.PeakRPM-_Tune.AutoDownThresh)/_Tune.Ratios[_CGear+1]/fFD) then
							if _CGear ~= 1 then
							end
							_CGear=math.max(_CGear-1,1)
						end
					end
				end
			end
		end
	end

	local tqTCS = 1
	--Apply Power
	function Engine()
		if _ClutchOn then
			if _Tune.CurveCache then
				local cTq = HPCache[_CGear+2][math.floor(math.min(_Tune.Redline,math.max(_Tune.IdleRPM,_RPM))/_Tune.CacheInc)]
				_NH = cTq.Horsepower+(cTq.HpSlope*((_RPM-math.floor(_RPM/_Tune.CacheInc))/1000)%1)
				_NT = cTq.Torque+(cTq.TqSlope*((_RPM-math.floor(_RPM/_Tune.CacheInc))/1000)%1)
			else
				_NH,_NT = GetCurve(_RPM,_CGear)
			end
			if _Tune.Aspiration ~= "Natural" then
				if _Tune.CurveCache then
					local bTq = PSICache[_CGear+2][math.floor(math.min(_Tune.Redline,math.max(_Tune.IdleRPM,_RPM))/_Tune.CacheInc)]
					_BH = bTq.Horsepower+(bTq.HpSlope*((_RPM-math.floor(_RPM/_Tune.CacheInc))/1000)%1)
					_BT = bTq.Torque+(bTq.TqSlope*((_RPM-math.floor(_RPM/_Tune.CacheInc))/1000)%1)
				else
					_BH,_BT = GetPsiCurve(_RPM,_CGear)
				end
				_HP = _NH + (_BH*(_Boost/2))
				_OutTorque = _NT + (_BT*(_Boost/2))
			else
				_HP = _NH
				_OutTorque = _NT
			end

			local iComp =(car.DriveSeat.CFrame.lookVector.y)*cGrav
			if _CGear==-1 then iComp=-iComp end
			_OutTorque = _OutTorque*math.max(1,(1+iComp))
		else
			_HP,_NH,_BH,_OutTorque,_NT,_BT = 0,0,0,0,0,0
		end

		local TPsi = _TPsi/_TCount

		if _Boost < 0.05 then _Boost = 0.05 elseif _Boost > 2 then _Boost = 2 end

		--Average Rotational Speed Calculation
		local fwspeed=0
		local fwcount=0
		local rwspeed=0
		local rwcount=0

		for i,v in pairs(car.Wheels:GetChildren()) do
			if v.Name=="FL" or v.Name=="FR" or v.Name == "F" then
				fwspeed=fwspeed+v.RotVelocity.Magnitude
				fwcount=fwcount+1
			elseif v.Name=="RL" or v.Name=="RR" or v.Name == "R" then
				rwspeed=rwspeed+v.RotVelocity.Magnitude
				rwcount=rwcount+1
			end
		end
		fwspeed=fwspeed/fwcount
		rwspeed=rwspeed/rwcount
		local cwspeed=(fwspeed+rwspeed)/2

		--Update Wheels
		for i,v in pairs(car.Wheels:GetChildren()) do
			--Reference Wheel Orientation
			local Ref=(CFrame.new(v.Position-((v.Arm.CFrame*cfWRot).lookVector),v.Position)*cfYRot).lookVector
			local aRef=1
			local diffMult=1
			if v.Name=="FL" or v.Name=="RL" then aRef=-1 end

			--AWD Torque Scaling
			if _Tune.Config == "AWD" then _OutTorque = _OutTorque*rtTwo end

			--Differential/Torque-Vectoring
			if v.Name=="FL" or v.Name=="FR" then
				diffMult=math.max(0,math.min(1,1+((((v.RotVelocity.Magnitude-fwspeed)/fwspeed)/(math.max(_Tune.FDiffSlipThres,1)/100))*((_Tune.FDiffLockThres-50)/50))))
				if _Tune.Config == "AWD" then
					diffMult=math.max(0,math.min(1,diffMult*(1+((((fwspeed-cwspeed)/cwspeed)/(math.max(_Tune.CDiffSlipThres,1)/100))*((_Tune.CDiffLockThres-50)/50)))))
				end
			elseif v.Name=="RL" or v.Name=="RR" then
				diffMult=math.max(0,math.min(1,1+((((v.RotVelocity.Magnitude-rwspeed)/rwspeed)/(math.max(_Tune.RDiffSlipThres,1)/100))*((_Tune.RDiffLockThres-50)/50))))
				if _Tune.Config == "AWD" then
					diffMult=math.max(0,math.min(1,diffMult*(1+((((rwspeed-cwspeed)/cwspeed)/(math.max(_Tune.CDiffSlipThres,1)/100))*((_Tune.CDiffLockThres-50)/50)))))
				end
			end

			_TCSActive = false
			_ABSActive = false
			--Output
			if _PBrake and ((_Tune.Config ~= "FWD" and (((v.Name=="FL" or v.Name=="FR") and car.DriveSeat.Velocity.Magnitude<20) or ((v.Name=="RR" or v.Name=="RL") and car.DriveSeat.Velocity.Magnitude>=20))) or (_Tune.Config == "FWD" and (v.Name=="RR" or v.Name=="RL"))) then
				--PBrake
				v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*PBrakeForce
				v["#AV"].angularvelocity=Vector3.new()
			else
				--Apply Power
				if ((_TMode == "Manual" or _TMode == "Semi" or _TMode == "Auto") and _GBrake==0)then
					local driven = false
					for _,a in pairs(Drive) do if a==v then driven = true end end
					if driven then
						local on=1
						if not script.Parent.IsOn.Value then on=0 end
						local throt = _GThrot * _GThrotShift

						--Apply TCS
						if _TCS then
							tqTCS = 1-(math.min(math.max(0,math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.TCSThreshold)/_Tune.TCSGradient,1)*(1-(_Tune.TCSLimit/100)))
						end
						if tqTCS < 1 then
							_TCSAmt = tqTCS
							_TCSActive = true
						end

						--Update Forces
						local dir = 1
						if _CGear==-1 then dir = -1 end
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*_OutTorque*(1+(v.RotVelocity.Magnitude/60)^1.15)*throt*tqTCS*diffMult*on
						v["#AV"].angularvelocity=Ref*aRef*_spLimit*dir
					else
						v["#AV"].maxTorque=Vector3.new()
						v["#AV"].angularvelocity=Vector3.new()
					end

				--Brakes
				else
					local brake = _GBrake

					--Apply ABS
					local tqABS = 1
					if _ABS and math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.ABSThreshold>0 then
						tqABS = 0
					end
					if tqABS < 1 then
						_ABSActive = true
					end

					--Update Forces
					if v.Name=="FL" or v.Name=="FR" or v.Name=="F" then
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*FBrakeForce*brake*tqABS
					else
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*RBrakeForce*brake*tqABS
					end
					v["#AV"].angularvelocity=Vector3.new()
				end
			end
		end
	end


Prompt: --Set up equipping and unequipping the tool.

Response:
Tool.Equipped:Connect(function()
	if not Equipped then
		Equipped = true

		CurrentCharacter = Tool.Parent
		CurrentPlayer = game.Players:GetPlayerFromCharacter(CurrentCharacter)
		EquipSound:Play()

		--Create the left hand rocket.
		local LeftGripAttachment = CurrentCharacter:FindFirstChild("LeftGripAttachment",true)
		if LeftGripAttachment then
			CurrentHandRocket = RocketCreator:CreateRocket(false)
			CurrentHandRocket.Name = "HandRocket"
			CurrentHandRocket.Transparency  = 1
			CurrentHandRocket.Parent = Tool

			local Weld = Instance.new("Weld")
			Weld.Part0 = LeftGripAttachment.Parent
			Weld.Part1 = CurrentHandRocket
			Weld.C0 = LeftGripAttachment.CFrame
			Weld.C1 = CFrame.Angles(0,math.pi,0)
			Weld.Parent = CurrentHandRocket
		end

		RocketBuffer:SetCurrentPlayer(CurrentPlayer)
	end
end)

Tool.Unequipped:Connect(function()
	if Equipped then
		Equipped = false

		CurrentCharacter = nil
		CurrentPlayer = nil
		EquipSound:Stop()
		if CurrentHandRocket then CurrentHandRocket:Destroy() end
		RocketBuffer:SetCurrentPlayer()
	end
end)


Prompt:
--[[**
	ensures Lua primitive table type

	@param value The value to check against

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

Response: t.table = primitive("table")


Response:
local  Paint = false

script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Khaki",Paint)
end)


Prompt: --	script.Parent.Menu.Visible=false

Response:
else
	-- старый
	script.Parent.History.Visible=false


Prompt: -- check for config values

Response:
local config = script:FindFirstChild(name)
if (config ~= nil) then