Prompt:
--Made by Superluck, Uploaded by FederalSignal_QCB.
--Made by Superluck, Uploaded by FederalSignal_QCB.
--Made by Superluck, Uploaded by FederalSignal_QCB.

Response:
wait(1)
while true do
script.Parent.Parent.Parent.Main.SoundBlock.Value.Sound.PlaybackSpeed = script.Parent.PlaybackSpeed
script.Parent.Parent.Parent.Main.SoundBlock.Value.Sound.Volume = (script.Parent.Volume*2)*4
script.Parent.Parent.Parent.Main.SoundBlock.Value.Sound.EmitterSize = script.Parent.EmitterSize*506
script.Parent.Parent.Parent.Main.SoundBlock.Value.Sound.SoundId = script.Parent.SoundId
script.Parent.Parent.Parent.Main.SoundBlock.Value.Sound.Playing = script.Parent.Playing
script.Parent.Parent.Parent.Main.SoundBlock.Value.Sound.DistortionSoundEffect.Level = (script.Parent.Volume*5)
wait()
end


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

Response:
local autoscaling	= true					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default
	{
		units			= "MPH"				,
		scaling			= (10/12) * (60/88)	, -- 1 stud : 10 inches | ft/s to MPH
		maxSpeed		= 230				,
		spInc			= 20				, -- Increment between labelled notches
	},

	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 370				,
		spInc			= 40				, -- Increment between labelled notches
	},

	{
		units			= "SPS"				,
		scaling			= 1					, -- Roblox standard
		maxSpeed		= 400				,
		spInc			= 40				, -- Increment between labelled notches
	}
}


Response:
	,EnableStatusUI 	= true				--- Don't disabled it...
	,RunWalkSpeed 		= 24
	,NormalWalkSpeed 	= 12
	,SlowPaceWalkSpeed 	= 6
	,CrouchWalkSpeed 	= 6
	,ProneWalksSpeed 	= 3

	,InjuredWalksSpeed 		= 8
	,InjuredCrouchWalkSpeed = 4

	,EnableHunger = false				--- Hunger and Thirst system 		(Removed)
	,HungerWaitTime = 25

	,CanDrown = true 					--- Glub glub glub *ded*

	,EnableStamina = true 				--- Weapon Sway based on stamina	(Unused)
	,RunValue = 1						--- Stamina consumption
	,StandRecover = .25					--- Stamina recovery while stading
	,CrouchRecover = .5					--- Stamina recovery while crouching
	,ProneRecover = 1					--- Stamina recovery while lying

	,EnableGPS = false					--- GPS shows your allies around you
	,GPSdistance = 0

	,InteractionMenuKey = Enum.KeyCode.LeftAlt

	,BuildingEnabled = false
	,BuildingKey = Enum.KeyCode.RightAlt


Prompt: -- Create base segway to clone from

Response:
local SegID = 581150091
local Segway = require(SegID)

local function Get_des(instance, func)
	func(instance)
	for _, child in next, instance:GetChildren() do
		Get_des(child, func)
	end
end

Functions.PlaySound = function(Sound,Pitch,Volume)
	if Sound and Sound.Parent.Name == "Seat" then
		Sound.Pitch = Pitch
		Sound.Volume = Volume
		Sound:Play()
	end
end

Functions.StopSound = function(Sound,Volume)
	if Sound and Sound.Parent.Name == "Seat" then
		Sound.Volume = Volume
		Sound:Stop()
	end
end

Functions.ChangeSound = function(Sound,Pitch,Volume,ShouldPitch,ShouldVolume)
	if Sound and Sound.Parent.Name == "Seat" then
		if ShouldPitch == true then
		Sound.Pitch = Pitch
		end
			if ShouldVolume == true then
			Sound.Volume = Volume
			end
	end
end

Functions.AnchorPart = function(Part,Anchored)
	if Part and Part:IsA("BasePart") and Part.Name == "Seat" then
		Part.Anchored = Anchored
	end
end

Functions.UndoTags = function(SegwayObject,WeldObject,TiltMotor)
	WeldObject.Value = nil
	TiltMotor.Value = nil
	SegwayObject.Value = nil
end

Functions.UndoHasWelded = function(SeaterObject)
	if SeaterObject.Value and SeaterObject.Value.Parent then
		SeaterObject.Value.Parent.HasWelded.Value = false
		SeaterObject.Value = nil
	end
end

Functions.TiltMotor = function(Motor,Angle)
	if Motor and Motor.Name == "TiltMotor" then
		Motor.DesiredAngle = Angle
	end
end

Functions.DeleteWelds = function(Part)
	if Part and Part:IsA("BasePart") and Part.Name == "Seat" then
		for _,v in pairs(Part:GetChildren()) do
			if v:IsA("Motor6D") then
			v:Destroy()
			end
		end
	end
end

Functions.ConfigHumanoid = function(Character,Humanoid,PlatformStand,Jump,AutoRotate)
	if Humanoid and Humanoid.Parent == Character then
		Humanoid.AutoRotate = AutoRotate
		Humanoid.PlatformStand = PlatformStand
		Humanoid.Jump = Jump

		Get_des(Character,function(d)
			if d and d:IsA("CFrameValue") and d.Name == "KeptCFrame" then
				d.Parent.C0 = d.Value
				d:Destroy()
			end
		end)
	end
end

Functions.ConfigLights = function(Transparency,Color,Bool,Material,Lights,Notifiers)
	if Lights and Notifiers then
	for _,v in pairs(Lights:GetChildren()) do
		if v:IsA("BasePart") and v:FindFirstChild("SpotLight") and v:FindFirstChild("Glare") then
		v.BrickColor = BrickColor.new(Color)
		v.Transparency = Transparency
		v:FindFirstChild("SpotLight").Enabled = Bool
		v.Material = Material
		end
	end
		for _,v in pairs(Notifiers:GetChildren()) do
			if v:IsA("BasePart") and v:FindFirstChild("SurfaceGui") then
			v:FindFirstChild("SurfaceGui").ImageLabel.Visible = Bool
			end
		end
	end
end

Functions.ColorSegway = function(Model,Color)
	for i=1, #Wings do
		for _,v in pairs(Model[Wings[i]]:GetChildren()) do
			if v.Name == "Base" or v.Name == "Cover" then
			v.BrickColor = Color
			end
		end
	end
end

Functions.DestroySegway = function(Character,SpawnedSegway)
	if SpawnedSegway:IsA("ObjectValue") and SpawnedSegway.Value and SpawnedSegway.Value:FindFirstChild("SegPlatform") then
		SpawnedSegway.Value:Destroy()
	end
end

Functions.SpawnSegway = function(Player,Character,Tool,SpawnedSegway,Color)
	if Character and not Character:FindFirstChild(Segway.Name) and Tool.Parent == Character then
	local NewSegway = Segway:Clone()
	-- Define head
	local Head = Character:WaitForChild("Head")

	-- Get the head's rotation matrix
	local p,p,p,xx,xy,xz,yx,yy,yz,zx,zy,zz = Head.CFrame:components()

	-- Get the position in front of player
	local SpawnPos = Head.Position + (Head.CFrame.lookVector*4)

	ToolStatus.Thruster.Value = NewSegway:WaitForChild("Wheels"):WaitForChild("Thruster")

	-- Apply the settings called from the client
	NewSegway:WaitForChild("Creator").Value = Player
	NewSegway:WaitForChild("MyTool").Value = Tool
	SpawnedSegway.Value = NewSegway

	-- Colors the segway
	Functions.ColorSegway(NewSegway,Color)

	-- Parent segway into the player's character
	NewSegway.Parent = Character
	NewSegway:MakeJoints()

	-- Position segway
	NewSegway:SetPrimaryPartCFrame(CFrame.new(0,0,0,xx,xy,xz,yx,yy,yz,zx,zy,zz)*CFrame.Angles(0,math.rad(180),0)) -- Rotate segway properly
	NewSegway:MoveTo(SpawnPos)
	end
end

Functions.ConfigTool = function(Transparency,Tool,ShouldColor,Color)
	if Tool == ThisTool then
		for _,v in pairs(Tool:GetChildren()) do
			if v:IsA("BasePart") and ShouldColor == false then
				v.Transparency = Transparency
			elseif ShouldColor == true and v:IsA("BasePart") and v.Name == "ColorablePart" then
				v.BrickColor = Color
			end
		end
	end
end

return Functions


Response:
local weld2 = Instance.new("Weld")
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = CFrame.new(-0.4, 1.25, 0.5) * CFrame.fromEulerAnglesXYZ(math.rad(90),-0.25,0) --Right leg
arms[2].Name = "RDave"
arms[2].CanCollide = true
welds[2] = weld2


Prompt: -- script

Response:
RunService.RenderStepped:Connect(function()
	local currentTime = tick()
	if humanoid.MoveDirection.Magnitude > 0 then -- we are walking
		local bobbleX = math.cos(currentTime * 10) * .15
		local bobbleY = math.abs(math.sin(currentTime * 10)) * .30

		local bobble = Vector3.new(bobbleX, bobbleY, 0)

		humanoid.CameraOffset = humanoid.CameraOffset:lerp(bobble, .25)
	else -- we are not walking
		local t = tick()
		local x = math.cos(t * speed) * intensity
		local y = math.sin(t * speed) * intensity

		local cf = CFrame.new(Vector3.new(x, y, 0), Vector3.new(x*0.95, y*0.95, -10)) + camera.CFrame.Position

		camera.CFrame = camera.CFrame:Lerp(cf * camera.CFrame.Rotation, smoothness)
	end
end)


Prompt:
--[[
	Notes:
	Transparency Modifier is what is the end result when "zooming in", it can be changed to whatever you like.

	Camera Offset is changed to allow the player to see at lower angles without clipping the view with the torso.
	This may or maynot effect certian tools if they change the players camera position IE crouching or crawling.

	Use:
	Place into StarterPlayer.StarterChacterScripts
--]]

Response:
local character = (game.Players.LocalPlayer.Character or game.Players.LocalPlayer.CharacterAdded:wait())

game:GetService("RunService").RenderStepped:connect(function()
	if (character:FindFirstChild("RightUpperArm") and character:FindFirstChild("LeftUpperArm")) then


Prompt: -- no touchy

Response:
local path
local waypoint
local oldpoints
local isWandering = 0

if canWander then
	spawn(function()
		while isWandering == 0 do
			isWandering = 1
			local desgx, desgz = hroot.Position.x + math.random(-WanderX, WanderX), hroot.Position.z + math.random(-WanderZ, WanderZ)
			human:MoveTo( Vector3.new(desgx, 0, desgz) )
			wait(math.random(4, 6))
			isWandering = 0
		end
	end)
end

while wait() do
	local enemybody = Getbody(hroot.Position)
	if enemybody ~= nil then -- if player detected
		isWandering = 1
		local function checkw(t)
			local ci = 3
			if ci > #t then
				ci = 3
			end
			if t[ci] == nil and ci < #t then
				repeat
					ci = ci + 1
					wait()
				until t[ci] ~= nil
				return Vector3.new(1, 0, 0) + t[ci]
			else
				ci = 3
				return t[ci]
			end
		end

		path = pfs:FindPathAsync(hroot.Position, enemybody.Position)
		waypoint = path:GetWaypoints()
		oldpoints = waypoint
		local connection;

		local direct = Vector3.FromNormalId(Enum.NormalId.Front)
		local ncf = hroot.CFrame * CFrame.new(direct)
		direct = ncf.p.unit
		local rootr = Ray.new(hroot.Position, direct)
		local phit, ppos = game.Workspace:FindPartOnRay(rootr, hroot)

		if path and waypoint or checkw(waypoint) then
			if checkw(waypoint) ~= nil and checkw(waypoint).Action == Enum.PathWaypointAction.Walk then
				human:MoveTo( checkw(waypoint).Position )
				human.Jump = false
			end

			-- CANNOT LET BALDI JUMPS --
			--[[if checkw(waypoint) ~= nil and checkw(waypoint).Action == Enum.PathWaypointAction.Jump then
				human.Jump = true
				connection = human.Changed:connect(function()
					human.Jump = true
				end)
				human:MoveTo( checkw(waypoint).Position )
			else
				human.Jump = false
			end]]

			--[[hroot.Touched:connect(function(p)
				local bodypartnames = GetPlayersbodyParts(enemybody)
				if p:IsA'Part' and not p.Name == bodypartnames and phit and phit.Name ~= bodypartnames and phit:IsA'Part' and rootr:Distance(phit.Position) < 5 then
					connection = human.Changed:connect(function()
						human.Jump = true
					end)
				else
					human.Jump = false
				end
			end)]]

		else
			for i = 3, #oldpoints do
				human:MoveTo( oldpoints[i].Position )
			end
		end
	elseif enemybody == nil and canWander then -- if player not detected
		isWandering = 0
		path = nil
		waypoint = nil
		human.MoveToFinished:Wait()
	end
end


Prompt: -- Fonction pour basculer la visibilité et le mouvement du curseur de la souris

Response:
local function toggleMouseVisibilityAndMovement()
	isMouseVisible = not isMouseVisible

	if isMouseVisible then
		Mouse.Icon = defaultMouseIcon
		player.Character.Humanoid.AutoRotate = true
	else
		Mouse.Icon = ""
		player.Character.Humanoid.AutoRotate = false
	end
end


Prompt:
--///////////////// Internal-Use Methods
--//////////////////////////////////////

Response:
function methods:InternalDestroy()
	for i, channel in pairs(self.Channels) do
		channel:InternalRemoveSpeaker(self)
	end

	self.eDestroyed:Fire()

	self.EventFolder = nil
	self.eDestroyed:Destroy()
	self.eSaidMessage:Destroy()
	self.eReceivedMessage:Destroy()
	self.eReceivedUnfilteredMessage:Destroy()
	self.eMessageDoneFiltering:Destroy()
	self.eReceivedSystemMessage:Destroy()
	self.eChannelJoined:Destroy()
	self.eChannelLeft:Destroy()
	self.eMuted:Destroy()
	self.eUnmuted:Destroy()
	self.eExtraDataUpdated:Destroy()
	self.eMainChannelSet:Destroy()
	self.eChannelNameColorUpdated:Destroy()
end

function methods:InternalAssignPlayerObject(playerObj)
	self.PlayerObj = playerObj
end

function methods:InternalAssignEventFolder(eventFolder)
	self.EventFolder = eventFolder
end

function methods:InternalSendMessage(messageObj, channelName)
	local success, err = pcall(function()
		self:LazyFire("eReceivedUnfilteredMessage", messageObj, channelName)
		self.EventFolder.OnNewMessage:FireClient(self.PlayerObj, messageObj, channelName)
	end)
	if not success and err then
		print("Error sending internal message: " ..err)
	end
end

function methods:InternalSendFilteredMessage(messageObj, channelName)
	local success, err = pcall(function()
		self:LazyFire("eReceivedMessage", messageObj, channelName)
		self:LazyFire("eMessageDoneFiltering", messageObj, channelName)
		self.EventFolder.OnMessageDoneFiltering:FireClient(self.PlayerObj, messageObj, channelName)
	end)
	if not success and err then
		print("Error sending internal filtered message: " ..err)
	end
end


Prompt: -- Local private variables and constants

Response:
local ZERO_VECTOR2 = Vector2.new(0,0)

local tweenAcceleration = math.rad(220) -- Radians/Second^2
local tweenSpeed = math.rad(0)          -- Radians/Second
local tweenMaxSpeed = math.rad(250)     -- Radians/Second
local TIME_BEFORE_AUTO_ROTATE = 2       -- Seconds, used when auto-aligning camera with vehicles

local INITIAL_CAMERA_ANGLE = CFrame.fromOrientation(math.rad(-15), 0, 0)
local ZOOM_SENSITIVITY_CURVATURE = 0.5
local FIRST_PERSON_DISTANCE_MIN = 0.5


Prompt: -- ROBLOX deviation END

Response:
export type ReporterOnStartOptions = { estimatedTime: number, showStatus: boolean }

export type Context = {
	config: Config_ProjectConfig,
	hasteFS: HasteFS,
	moduleMap: ModuleMap,
	resolver: Resolver,
}

export type Test = { context: Context, duration: number?, path: Config_Path }

export type CoverageWorker = { worker: worker }

export type CoverageReporterOptions = {
	changedFiles: Set<Config_Path>?,
	sourcesRelatedToTestsInChangedFiles: Set<Config_Path>?,
}

export type CoverageReporterSerializedOptions = {
	changedFiles: Array<Config_Path>?,
	sourcesRelatedToTestsInChangedFiles: Array<Config_Path>?,
}

export type OnTestStart = (test: Test) -> Promise<void>

export type OnTestFailure = (test: Test, error_: SerializableError) -> Promise<unknown>

export type OnTestSuccess = (test: Test, result: TestResult) -> Promise<unknown>

export type Reporter = {
	onTestResult: ((
		self: Reporter,
		test: Test,
		testResult: TestResult,
		aggregatedResult: AggregatedResult
	) -> Promise<void> | void)?,
	onTestFileResult: ((
		self: Reporter,
		test: Test,
		testResult: TestResult,
		aggregatedResult: AggregatedResult
	) -> Promise<void> | void)?,
	onTestCaseResult: ((self: Reporter, test: Test, testCaseResult: TestCaseResult) -> Promise<void> | void)?,
	onRunStart: (self: Reporter, results: AggregatedResult, options: ReporterOnStartOptions) -> Promise<void> | void,
	onTestStart: ((self: Reporter, test: Test) -> Promise<void> | void)?,
	onTestFileStart: ((self: Reporter, test: Test) -> Promise<void> | void)?,
	onRunComplete: (self: Reporter, contexts: Set<Context>, results: AggregatedResult) -> Promise<void> | void,
	getLastError: (self: Reporter) -> Error | void,
}

export type SummaryOptions = {
	currentTestCases: Array<{ test: Test, testCaseResult: TestCaseResult }>?,
	estimatedTime: number?,
	roundTime: boolean?,
	width: number?,
}

export type TestRunnerOptions = { serial: boolean }

export type TestRunData = Array<{
	context: Context,
	matches: { allTests: number, tests: Array<Test>, total: number },
}>

export type TestSchedulerContext = {
	firstRun: boolean,
	previousSuccess: boolean,
	changedFiles: Set<Config_Path>?,
}

return exports


Prompt:
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------

Response:
	,VRecoil = {16,20}				--- Vertical Recoil
	,HRecoil = {9,11}				--- Horizontal Recoil
	,AimRecover = .75				---- Between 0 & 1

	,RecoilPunch = .2
	,VPunchBase = 3.5				--- Vertical Punch
	,HPunchBase = 1.25				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless

	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .25
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .5

	,MinSpread = 5					--- Min bullet spread value | Studs
	,MaxSpread = 35					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 0.75
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1					--- Max sway value based on player stamina | Studs


Response:
head.ChildAdded:connect(function(c)
	if c.Name == "Sound" then
		c.Ended:connect(function()
			if sdb == true then
				soundplaying = nil
				nameobj = nil
				c:remove()
				wait(MutterDelay)
				sdb = false
			end
		end)
	end
end)


Prompt:
--[[
	BaseCharacterController - Abstract base class for character controllers, not intended to be
	directly instantiated.

	2018 PlayerScripts Update - AllYourBlox
--]]

Response: local ZERO_VECTOR3 = Vector3.new(0,0,0)


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 3100		-- 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: -- << VARIABLES >>

Response:
local frame = main.gui.MainFrame.Pages.Admin
local buyFrame = main.warnings.BuyFrame
local unBan = main.warnings.UnBan
local pages = {
	ranks = frame.Ranks;
	serverRanks = frame["Server Ranks"],
	banland = frame.Banland;
}
local templates = {
	rankTitle = pages.ranks.TemplateRankTitle;
	rankItem = pages.ranks.TemplateRankItem;
	space = pages.ranks.TemplateSpace;
	admin = pages.serverRanks.TemplateAdmin;
	ban = pages.banland.TemplateBan;
	banTitle = pages.banland.TemplateTitle
}
local otherPermissions = {
	{"friends", 		main.ownerName.."'s Friends", 	"For friends of the Owner"};
	{"freeadmin", 		"Free Admin", 					"For everyone"};
	{"vipserverowner", 	"VIP Server Owner", 			"For VIP Server owners"};
	{"vipserverplayer", "VIP Server Player", 			"For VIP Server players"};
}


Prompt: -- made by ROBLOX FOR SURE

Response:
end
script.Parent.Activated:connect(onActivated)


Prompt:
--[=[
	@private
	@class Utils
]=]

Response:
local Utils = {}

local function errorOnIndex(_, index)
	error(("Bad index %q"):format(tostring(index)), 2)
end

local READ_ONLY_METATABLE = {
	__index = errorOnIndex;
	__newindex = errorOnIndex;
}

function Utils.readonly(_table)
	return setmetatable(_table, READ_ONLY_METATABLE)
end

function Utils.copyTable(target)
	local new = {}
	for key, value in pairs(target) do
		new[key] = value
	end
	return new
end

function Utils.count(_table)
	local count = 0
	for _, _ in pairs(_table) do
		count = count + 1
	end
	return count
end

function Utils.getOrCreateValue(parent, instanceType, name, defaultValue)
	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
	assert(type(name) == "string", "Bad argument 'name'")

	local foundChild = parent:FindFirstChild(name)
	if foundChild then
		if not foundChild:IsA(instanceType) then
			warn(("[Utils.getOrCreateValue] - Value of type %q of name %q is of type %q in %s instead")
				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
		end

		return foundChild
	else
		local newChild = Instance.new(instanceType)
		newChild.Name = name
		newChild.Value = defaultValue
		newChild.Parent = parent

		return newChild
	end
end

function Utils.getValue(parent, instanceType, name, default)
	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
	assert(type(name) == "string", "Bad argument 'name'")

	local foundChild = parent:FindFirstChild(name)
	if foundChild then
		if foundChild:IsA(instanceType) then
			return foundChild.Value
		else
			warn(("[Utils.getValue] - Value of type %q of name %q is of type %q in %s instead")
				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
			return nil
		end
	else
		return default
	end
end

function Utils.setValue(parent, instanceType, name, value)
	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
	assert(type(name) == "string", "Bad argument 'name'")

	local foundChild = parent:FindFirstChild(name)
	if foundChild then
		if not foundChild:IsA(instanceType) then
			warn(("[Utils.setValue] - Value of type %q of name %q is of type %q in %s instead")
				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
		end

		foundChild.Value = value
	else
		local newChild = Instance.new(instanceType)
		newChild.Name = name
		newChild.Value = value
		newChild.Parent = parent
	end
end

function Utils.getOrCreateFolder(parent, folderName)
	local found = parent:FindFirstChild(folderName)
	if found then
		return found
	else
		local folder = Instance.new("Folder")
		folder.Name = folderName
		folder.Parent = parent
		return folder
	end
end

return Utils


Prompt: --Front Suspension

Response:
Tune.FSusDamping	= 500		-- Spring Dampening
Tune.FSusStiffness	= 9000		-- Spring Force
Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

Tune.FSusLength		= 2			-- Suspension length (in studs)
Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

Tune.FWsBoneLen		= 5			-- Wishbone Length
Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	--[[Lateral]]		-.4		,	-- positive = outward
	--[[Vertical]]		-.5		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward


Prompt: -- Create component

Response:
local Component = Cheer.CreateComponent('BTTooltip', View);

local Connections = {};

function Component.Start()

	-- Hide the view
	View.Visible = false;

	-- Show the tooltip on hover
	Connections.ShowOnEnter = Support.AddGuiInputListener(View.Parent, 'Began', 'MouseMovement', true, Component.Show);
	Connections.HideOnLeave = Support.AddGuiInputListener(View.Parent, 'Ended', 'MouseMovement', true, Component.Hide);

	-- Clear connections when the component is removed
	Component.OnRemove:Connect(ClearConnections);

	-- Return component for chaining
	return Component;

end;

function Component.Show()
	View.Visible = true;
end;

function Component.Hide()
	View.Visible = false;
end;

function ClearConnections()
	-- Clears out temporary connections

	for ConnectionKey, Connection in pairs(Connections) do
		Connection:disconnect();
		Connections[ConnectionKey] = nil;
	end;

end;

return Component.Start();


Prompt: --Made by Luckymaxer

Response:
Figure = script.Parent
Humanoid = Figure:WaitForChild("Humanoid")
Torso = Figure:WaitForChild("Torso")

Creator = Figure:WaitForChild("Creator")

PathfindingService = game:GetService("PathfindingService")

FollowingPath = false
WalkRadius = 15
SuccessDistance = (Torso.Size.Y * 10)
MaxDistance = 485
MaximumAttemptTime = 3

Moving = false
CurrentWayPoint = nil

function RayCast(Position, Direction, MaxDistance, IgnoreList)
	return game:GetService("Workspace"):FindPartOnRayWithIgnoreList(Ray.new(Position, Direction.unit * (MaxDistance or 999.999)), IgnoreList)
end

function Pathfind(StartPoint, TargetPoint, MaxDistance)
	local Path = PathfindingService:ComputeRawPathAsync(StartPoint, TargetPoint, MaxDistance)
	if not Path or Path.Status == Enum.PathStatus.FailStartNotEmpty or Path.Status == Enum.PathStatus.FailFinishNotEmpty then
		return {}
	end
	local PathWayPoints = Path:GetPointCoordinates()
	if not PathWayPoints or #PathWayPoints == 0 then
		return {}
	end
	return PathWayPoints
end

function GatherWapoints(StartPoint, TargetPoint, MaxDistance)
	local WayPoints = nil
	pcall(function()
		WayPoints = Pathfind(StartPoint, TargetPoint, MaxDistance)
	end)
	return WayPoints
end

function MoveAround(TargetPoint)
	if FollowingPath then
		return
	end
	FollowingPath = true
	TargetPoint = ((not TargetPoint and (Torso.Position + Vector3.new(math.random(-WalkRadius, WalkRadius), 0, math.random(-WalkRadius, WalkRadius))) or TargetPoint))
	local WayPoints = GatherWapoints(Torso.Position, TargetPoint, MaxDistance)
	if WayPoints and #WayPoints > 0 then
		for i, v in pairs(WayPoints) do
			CurrentWayPoint = v
			Humanoid:MoveTo(v)
			local TimeBegan = tick()
			while ((v - Torso.Position).magnitude > SuccessDistance and (tick() - TimeBegan) < MaximumAttemptTime) do

				wait(0.1)
			end
			if (v - Torso.Position).magnitude < SuccessDistance then
				WayPoints = GatherWapoints(Torso.Position, TargetPoint, MaxDistance)
				if WayPoints and #WayPoints > 0 then
					MoveAround(TargetPoint)
				end
			end
		end
		CurrentWayPoint = nil
	end
	FollowingPath = false
end

function SecureJump()
	if Humanoid.Jump then
		return
	end
	local TargetPoint = Humanoid.TargetPoint
	local GroundBelow, GroundPos
	if CurrentWayPoint then
		GroundBelow, GroundPos = RayCast((Torso.CFrame + CFrame.new(Torso.Position, Vector3.new(CurrentWayPoint.X, Torso.Position.Y, CurrentWayPoint.Z)).lookVector * (Torso.Size.Z * 4)).p, Vector3.new(0, -1, 0), (Torso.Size.Y * 4), {Character})
	end
	if CurrentWayPoint and not GroundBelow then
		Humanoid.TargetPoint = Torso.Position
		Humanoid:MoveTo(Torso.Position)
		TimeBegan = MaximumAttemptTime
	else
		local Blockage, BlockagePos = RayCast((Torso.CFrame + CFrame.new(Torso.Position, Vector3.new(TargetPoint.X, Torso.Position.Y, TargetPoint.Z)).lookVector * (Torso.Size.Z / 2)).p, Torso.CFrame.lookVector, (Torso.Size.Z * 2.5), {Figure})
		if not Humanoid.Jump and (Blockage and not Blockage.Parent:FindFirstChild("Humanoid")) then
			Humanoid.Jump = true
		end
	end
end

repeat
	Spawn(function()
		local CreatorValue = Creator.Value
		local CreatorCharacter, CreatorTorso
		if CreatorValue and CreatorValue:IsA("Player") and CreatorValue.Character then
			CreatorCharacter = CreatorValue.Character
			CreatorTorso = CreatorCharacter:FindFirstChild("Torso")
		end
		MoveAround((CreatorTorso and CreatorTorso.Position) or nil)
	end)
	SecureJump()
	wait(0.01)
until false


Prompt:
--First build your Gun, make sure all the parts and Non-Colliding and Not Anchored.
--Second put these parts inside the Tool (Call one of the parts 'Handle' and the rest 'Part'
--Lastly, make/get your gun script and test it out!

Response:
local prev
local parts = script.Parent["Parachute"]:GetChildren()

for i = 1,#parts do
	if (parts[i].className == "Part") or (parts[i].className == "VehicleSeat") then
		if (prev ~= nil)then
			local weld = Instance.new("Weld")
			weld.Part0 = prev
			weld.Part1 = parts[i]
			weld.C0 = prev.CFrame:inverse()
			weld.C1 = parts[i].CFrame:inverse()
			weld.Parent = prev
		end
		prev = parts[i]
	end
end


Prompt: -- Seats

Response:
local Seat1 = Swing:WaitForChild("Seat1")
local Seat2 = Swing:WaitForChild("Seat2")


Prompt: -- Public Methods

Response:
function RadioButtonLabelClass:GetValue()
	return self.Button.Circle.Visible
end

function RadioButtonLabelClass:SetValue(bool)
	bool = not not bool

	local container = self.Frame.RadioContainer
	local colorA = container.BorderColor3
	local colorB = container.BackgroundColor3

	container.Outline.ImageColor3 = bool and colorA or colorB
	container.RadioButton.Circle.Visible = bool
end

function RadioButtonLabelClass:Destroy()
	self._Maid:Sweep()
	self.Frame:Destroy()
end


Prompt:
-- By Dominical -- Sep 13, 2014
-- Put this script inside of a light source such as a PointLight or SpotLight

Response:
while true do
	script.Parent.Enabled=true
	wait(math.random(2))
	script.Parent.Enabled=false
	wait(0.1)
end


Prompt:
--------------------------------------
-- List of named places in the game

Response:
local _places = {
	lobby = 6976592727,
	gameplay_development = 6976597627,
	queue_default = 6976598505,
	queue_deathmatch = 6976598627,
	queue_teamDeathmatch = 6976598747,
	queue_freePlay = 6976598856
}


Prompt:
-- Use the character attribute (updated by the server) as the source of truth for body orientation
-- Intended to be used for replicated characters

Response:
function OrientableBody:useAttributeAsSource()
	self:orientFromAttribute()
	self.attributeConnection = self.character:GetAttributeChangedSignal(ATTRIBUTE):Connect(function()
		self:orientFromAttribute()
	end)
end

function OrientableBody:destroy()
	self:applyAngle(self.neck, 0, 0)
	self:applyAngle(self.waist, 0, 0)

	if self.motor then
		self.motor:destroy()
		self.motor = nil
	end
	if self.attributeConnection then
		self.attributeConnection:Disconnect()
		self.attributeConnection = nil
	end
	if self.renderStepConnection then
		self.renderStepConnection:Disconnect()
		self.renderStepConnection = nil
	end
end

return OrientableBody


Prompt:
--s.Pitch = 0.7
--s.Pitch = 0.7

Response:
while true do
while s.Pitch<1.21 do
s.Pitch=s.Pitch+0.010
s:Play()
if s.Pitch>1.21 then
	s.Pitch=1.21
end
wait(0.001)
end


Prompt: --[[Transmission]]

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

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

	--Automatic Settings
	Tune.AutoShiftMode	= "RPM"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		-- Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		-- Automatic downshift point (relative to peak RPM, positive = Under-rev)
	Tune.ShiftTime = .3				-- The time delay in which you initiate a shift and the car changes gear

	--Gear Ratios

	Tune.FinalDrive		= 0.8		 --		[TRANSMISSION CALCULATIONS FOR NERDS]
	Tune.Ratios			= {			 --		SPEED [SPS]	 = (Wheel diameter(studs) * math.pi * RPM) / (60 * Gear Ratio * Final Drive * Multiplier)
		--[[ R ]]		18.641		,--		WHEEL TORQUE = Engine Torque * Gear Ratio * Final Drive * Multiplier
		--[[ N ]]		0			,
		--[[ 1 ]]		16.641		,
		--[[ 2 ]]		12.342		,
		--[[ 3 ]]		9.812		,
		--[[ 4 ]]		7.765		,
		--[[ 5 ]]		6.272
	}
	Tune.FDMult			= 1			-- Ratio multiplier (keep this at 1 if car is not struggling with torque)


Prompt:
--[[
	Sets the given emote as locked for the given Player.
]]

Response:
local function lockEmote(runService, emoteManager, changeEmoteLock)
	if runService:IsServer() then
		return function(player: Player, emoteName: string): nil
			assert(t.string(emoteName))
			emoteManager:setEmoteIsLockedForPlayer(player, emoteName, true)
		end
	else
		-- Calling lockEmote from the client is deprecated. To preserve
		-- backwards compatibility, a remote event is fired to the new server
		-- side lockEmote function
		return function(emoteName: string): nil
			warn("Calling lockEmote from the client is deprecated. Please call from a server Script instead.")
			changeEmoteLock:FireServer(emoteName, true)
		end
	end
end

return lockEmote


Prompt:
--				if not gameRules.SpawnStacking then
--					spawner.CurrentGun.Value = newGun


Prompt:
--[=[
    Pseudo localizes text. Useful for verifying translation without having
    actual translations available

    @class PseudoLocalize
]=]

Response:
local PseudoLocalize = {}

local DEFAULT_PSEUDO_LOCALE_ID = "qlp-pls"


Prompt: -- Class

Response:
local DropdownClass = {}
DropdownClass.__index = DropdownClass
DropdownClass.__type = "Dropdown"

function DropdownClass:__tostring()
	return DropdownClass.__type
end


Prompt: --//Variables

Response:
local owner = script.Parent.OwnerName
local door = script.Parent
local prompt = script.Parent.OpenClose
local rentprompt = script.Parent.Rent
local Player = game.Players.LocalPlayer
local door2 = script.Parent.Parent.Door2


Prompt:
--[[
	Intended for use in tests.

	Similar to await(), but instead of yielding if the promise is unresolved,
	_unwrap will throw. This indicates an assumption that a promise has
	resolved.
]]

Response:
function Promise.prototype:_unwrap()
	if self._status == Promise.Status.Started then
		error("Promise has not resolved or rejected.", 2)
	end

	local success = self._status == Promise.Status.Resolved

	return success, unpack(self._values, 1, self._valuesLength)
end

function Promise.prototype:_resolve(...)
	if self._status ~= Promise.Status.Started then
		if Promise.is((...)) then
			(...):_consumerCancelled(self)
		end
		return
	end

	-- If the resolved value was a Promise, we chain onto it!
	if Promise.is((...)) then
		-- Without this warning, arguments sometimes mysteriously disappear
		if select("#", ...) > 1 then
			local message = (
				"When returning a Promise from andThen, extra arguments are " ..
				"discarded! See:\n\n%s"
			):format(
				self._source
			)
			warn(message)
		end

		local promise = (...):andThen(
			function(...)
				self:_resolve(...)
			end,
			function(...)
				self:_reject(...)
			end
		)

		if promise._status == Promise.Status.Cancelled then
			self:cancel()
		elseif promise._status == Promise.Status.Started then
			-- Adopt ourselves into promise for cancellation propagation.
			self._parent = promise
			promise._consumers[self] = true
		end

		return
	end

	self._status = Promise.Status.Resolved
	self._valuesLength, self._values = pack(...)

	-- We assume that these callbacks will not throw errors.
	for _, callback in ipairs(self._queuedResolve) do
		callback(...)
	end

	self:_finalize()
end

function Promise.prototype:_reject(...)
	if self._status ~= Promise.Status.Started then
		return
	end

	self._status = Promise.Status.Rejected
	self._valuesLength, self._values = pack(...)

	-- If there are any rejection handlers, call those!
	if not isEmpty(self._queuedReject) then
		-- We assume that these callbacks will not throw errors.
		for _, callback in ipairs(self._queuedReject) do
			callback(...)
		end
	else
		-- At this point, no one was able to observe the error.
		-- An error handler might still be attached if the error occurred
		-- synchronously. We'll wait one tick, and if there are still no
		-- observers, then we should put a message in the console.

		local err = tostring((...))

		spawn(function()
			-- Someone observed the error, hooray!
			if not self._unhandledRejection then
				return
			end

			-- Build a reasonable message
			local message = ("Unhandled promise rejection:\n\n%s\n\n%s"):format(
				err,
				self._source
			)
			warn(message)
		end)
	end

	self:_finalize()
end


Prompt: --Playing the revive animation locally works a lot better than playing it server side

Response:
function game.ReplicatedStorage.RemoteFunctions.ReviveAnimation.OnClientInvoke(bodyPartsLocationTable, lastBranch)
	local respawnPosition = player.Character.Torso.CFrame
	for i = 1, #bodyPartsLocationTable["Head"] do
		if lastBranch ~= nil then
			if player.Character.Torso.Position.Z > lastBranch then
				break
			end
		end
		game:GetService("RunService").RenderStepped:wait()
		for key, value in pairs(bodyPartsLocationTable) do
			if player.Character:FindFirstChild(key) then
				if value[i] then
					player.Character[key].CFrame = value[i]
				end
			end
		end
		respawnPosition = player.Character.Torso.CFrame
	end
	player.Character:Destroy()
	return respawnPosition
end


Prompt:
--[=[
	Maps a number from one range to another.

	:::note
	Note the mapped value can be outside of the initial range,
	which is very useful for linear interpolation.
	:::

	```lua
	print(Math.map(0.1, 0, 1, 1, 0)) --> 0.9
	```

	@param num number
	@param min0 number
	@param max0 number
	@param min1 number
	@param max1 number
	@return number
]=]

Response:
function Math.map(num: number, min0: number, max0: number, min1: number, max1: number): number
	if max0 == min0 then
		error("Range of zero")
	end

	return (((num - min0)*(max1 - min1)) / (max0 - min0)) + min1
end


Prompt:
--[[ @brief Returns the smallest element in the heap.
     @return The smallest element in the heap (using the stored comparator function).
--]]

Response:
function Heap:Top()
	return self[1];
end


Prompt: --// Recoil Settings

Response:
	gunrecoil = -0.3;
	camrecoil = 0.3;
	AimGunRecoil = -0.4;
	AimCamRecoil = 0.2;

	Kickback = 3;
	AimKickback = 0.8;


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

	@param array {T} -- The array to search.
	@param value? any -- The value to search for.
	@param from? number -- The index to start searching from.
	@return number? -- The index of the last item in the array that matches the value.

	Finds the index of the last item in the array that matches the value.

	```lua
	local array = { "hello", "world", "hello" }

	local index = FindLast(array, "hello") -- 3
	local index = FindLast(array, "hello", 2) -- 1
	```
]=]

Response:
local function findLast<T>(array: { T }, value: any?, from: number?): number?
	local length = #array

	from = if type(from) == "number" then if from < 1 then length + from else from else length

	for index = from, 1, -1 do
		if array[index] == value then
			return index
		end
	end

	return
end

return findLast


Prompt: -- constants

Response:
local PLAYER	= Players.LocalPlayer

local ELECTROCUTE_AMOUNT	= 2
local VELOCITY_AMOUNT		= 10

return function(character)
	local effects	= character.Effects
	local parts		= {}

	for _, v in pairs(character:GetChildren()) do
		if v:IsA("BasePart") and v.Transparency ~= 1 then
			table.insert(parts, v)
			local rate	= math.floor((v.Size.X + v.Size.Y + v.Size.Z) * ELECTROCUTE_AMOUNT)

			local emitter1	= script.ElectricityEmitter1:Clone()
				emitter1.Rate	= rate
				emitter1.Parent	= v

			local emitter2	= script.ElectricityEmitter2:Clone()
				emitter2.Rate	= rate
				emitter2.Parent	= v
		end
	end

	for i = 1, 100 do
		for _, v in pairs(parts) do
			v.RotVelocity	= Vector3.new(math.random(-VELOCITY_AMOUNT, VELOCITY_AMOUNT), math.random(-VELOCITY_AMOUNT, VELOCITY_AMOUNT), math.random(-VELOCITY_AMOUNT, VELOCITY_AMOUNT))
		end
		wait(0.1)
	end
end


Prompt: -- Assign hotkeys for redoing (left or right shift + Y)

Response:
AssignHotkey({ 'LeftShift', 'Y' }, History.Redo);
AssignHotkey({ 'RightShift', 'Y' }, History.Redo);


Response:
function DoorClose()
	if Shaft00.MetalDoor.CanCollide == false then
		Shaft00.MetalDoor.CanCollide = true
		while Shaft00.MetalDoor.Transparency > 0.0 do
			Shaft00.MetalDoor.Transparency = Shaft00.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft01.MetalDoor.CanCollide == false then
		Shaft01.MetalDoor.CanCollide = true
		while Shaft01.MetalDoor.Transparency > 0.0 do
			Shaft01.MetalDoor.Transparency = Shaft01.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft02.MetalDoor.CanCollide == false then
		Shaft02.MetalDoor.CanCollide = true
		while Shaft02.MetalDoor.Transparency > 0.0 do
			Shaft02.MetalDoor.Transparency = Shaft02.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft03.MetalDoor.CanCollide == false then
		Shaft03.MetalDoor.CanCollide = true
		while Shaft03.MetalDoor.Transparency > 0.0 do
			Shaft03.MetalDoor.Transparency = Shaft03.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft04.MetalDoor.CanCollide == false then
		Shaft04.MetalDoor.CanCollide = true
		while Shaft04.MetalDoor.Transparency > 0.0 do
			Shaft04.MetalDoor.Transparency = Shaft04.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft05.MetalDoor.CanCollide == false then
		Shaft05.MetalDoor.CanCollide = true
		while Shaft05.MetalDoor.Transparency > 0.0 do
			Shaft05.MetalDoor.Transparency = Shaft05.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft06.MetalDoor.CanCollide == false then
		Shaft06.MetalDoor.CanCollide = true
		while Shaft06.MetalDoor.Transparency > 0.0 do
			Shaft06.MetalDoor.Transparency = Shaft06.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft07.MetalDoor.CanCollide == false then
		Shaft07.MetalDoor.CanCollide = true
		while Shaft07.MetalDoor.Transparency > 0.0 do
			Shaft07.MetalDoor.Transparency = Shaft07.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft08.MetalDoor.CanCollide == false then
		Shaft08.MetalDoor.CanCollide = true
		while Shaft08.MetalDoor.Transparency > 0.0 do
			Shaft08.MetalDoor.Transparency = Shaft08.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft09.MetalDoor.CanCollide == false then
		Shaft09.MetalDoor.CanCollide = true
		while Shaft09.MetalDoor.Transparency > 0.0 do
			Shaft09.MetalDoor.Transparency = Shaft09.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft10.MetalDoor.CanCollide == false then
		Shaft10.MetalDoor.CanCollide = true
		while Shaft10.MetalDoor.Transparency > 0.0 do
			Shaft10.MetalDoor.Transparency = Shaft10.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft11.MetalDoor.CanCollide == false then
		Shaft11.MetalDoor.CanCollide = true
		while Shaft11.MetalDoor.Transparency > 0.0 do
			Shaft11.MetalDoor.Transparency = Shaft11.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft12.MetalDoor.CanCollide == false then
		Shaft12.MetalDoor.CanCollide = true
		while Shaft12.MetalDoor.Transparency > 0.0 do
			Shaft12.MetalDoor.Transparency = Shaft12.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft13.MetalDoor.CanCollide == false then
		Shaft13.MetalDoor.CanCollide = true
		while Shaft13.MetalDoor.Transparency > 0.0 do
			Shaft13.MetalDoor.Transparency = Shaft13.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
end

function onClicked()
DoorClose()

Car.BodyVelocity.velocity = Vector3.new(0, -20, 0)	--Change 10 to change the speed.
end
script.Parent.MouseButton1Click:connect(onClicked)

script.Parent.MouseButton1Click:connect(function()
	if clicker == true
		then clicker = false
	else
		return

	end
end)

Car.Touched:connect(function(otherPart)
	if otherPart == Elevator.Floors.F00
		then StopE() DoorOpen()
	end
end)

function StopE()
 Car.BodyVelocity.velocity = Vector3.new(0, 0, 0)
 Car.BodyPosition.position = Elevator.Floors.F00.Position
	clicker = true
end

function DoorOpen()
	while Shaft00.MetalDoor.Transparency < 1.0 do
	Shaft00.MetalDoor.Transparency = Shaft00.MetalDoor.Transparency + .1
	wait(0.000001)
	end
	Shaft00.MetalDoor.CanCollide = false
end


Prompt: ---[[ Chat Behaviour Settings ]]

Response:
module.WindowDraggable = true
module.WindowResizable = true
module.ShowChannelsBar = false
module.GamepadNavigationEnabled = false
module.ShowUserOwnFilteredMessage = true	--Show a user the filtered version of their message rather than the original.


Prompt: --Obj

Response:
local Frame

local SpawnNPC = {}

function SpawnNPC:Setup(UI)
    Frame = UI

    Frame.Button.MouseButton1Down:Connect(function()
        self.Services.AnimalService.SpawnNPC:Fire()
    end)
end

return SpawnNPC


Prompt: --script.Parent.XX.Velocity = script.Parent.XX.CFrame.lookVector *script.Parent.Speed.Value

Response:
script.Parent.XXX.Velocity = script.Parent.XXX.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.Y.Velocity = script.Parent.Y.CFrame.lookVector *script.Parent.Speed.Value


Prompt:
--[[

--[Create a table containing some percentages, example table:

     local GuitarChances = {["Red"] = 50, ["Blue"] = 25, ["Green"] = 10}

     --you don't have to make the addition of the chances equal to 100, the script will auto-convert the chances.

  ]

--[Next Step, call the function and get the result! Example =

        local GuitarChances = {["Red"] = 50, ["Blue"] = 25, ["Green"] = 10}

        local SelectedGuitarColor = Roll(GuitarChances)

        print(SelectedGuitarColor)

        (this script will print a random guitar color with the chances In the table.)

]

pls leave a like if you don't mind :D
]]

Response:
function Roll(Chances)
	local summary = 0

	for index, chance in pairs(Chances) do
		summary += chance
	end

	local NewChances = table.clone(Chances)

	for index, Chance in pairs(NewChances) do
		NewChances[index] = summary / (100 / Chance)
	end

	task.wait()

	local RandomNumber = math.random(summary)

	for index, chance in pairs(NewChances) do

		local Result = index

		local StartPoint, EndPoint = chance, 0

		for NextIndex, NextChance in pairs(NewChances) do
			if NextChance < chance  then
				StartPoint += NextChance; EndPoint += NextChance
			elseif NextChance == chance and NextIndex ~= index then
				StartPoint += NextChance

				local Set = math.random(1,2)

				if Set > 1 then
					Result = NextIndex
				end
			end
		end

		if RandomNumber > EndPoint and RandomNumber <= StartPoint then

			return Result

		end

	end

end


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

Response:
local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
return function(p1, p2)
	return u1.Functions.DegDeltaUnsafe(u1.Functions.DegNorm(p1), u1.Functions.DegNorm(p2));
end;


Prompt: --[[Drivetrain]]

Response:
	Tune.Config			= "AWD"		--"FWD" , "RWD" , "AWD"

	--Differential Settings
	Tune.FDiffSlipThres	= 20		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 30		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 40		-- 1 - 100%
	Tune.RDiffLockThres	= 50		-- 0 - 100%
	Tune.CDiffSlipThres	= 60		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 70		-- 0 - 100%				[AWD Only]

	--Traction Control Settings
	Tune.TCSEnabled		= true		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)


Prompt: --[[Susupension]]

Response:
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled

	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 1000		-- Anti-Roll (Gyro Dampening)

	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= true			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Hot pink"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness


Prompt: -- (Hat Giver Script - Loaded.)

Response:
debounce = true

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

script.Parent.Touched:connect(onTouched)


Prompt: --[[ The Module ]]

Response:
--
local MouseLockController = {}
MouseLockController.__index = MouseLockController

function MouseLockController.new()
	local self = setmetatable({}, MouseLockController)

	self.isMouseLocked = false
	self.savedMouseCursor = nil
	self.boundKeys = {Enum.KeyCode.LeftShift, Enum.KeyCode.RightShift} -- defaults

	self.mouseLockToggledEvent = Instance.new("BindableEvent")

	local boundKeysObj = script:FindFirstChild("BoundKeys")
	if (not boundKeysObj) or (not boundKeysObj:IsA("StringValue")) then
		-- If object with correct name was found, but it's not a StringValue, destroy and replace
		if boundKeysObj then
			boundKeysObj:Destroy()
		end

		boundKeysObj = Instance.new("StringValue")
		boundKeysObj.Name = "BoundKeys"
		boundKeysObj.Value = "LeftShift,RightShift"
		boundKeysObj.Parent = script
	end

	if boundKeysObj then
		boundKeysObj.Changed:Connect(function(value)
			self:OnBoundKeysObjectChanged(value)
		end)
		self:OnBoundKeysObjectChanged(boundKeysObj.Value) -- Initial setup call
	end

	-- Watch for changes to user's ControlMode and ComputerMovementMode settings and update the feature availability accordingly
	GameSettings.Changed:Connect(function(property)
		if property == "ControlMode" or property == "ComputerMovementMode" then
			self:UpdateMouseLockAvailability()
		end
	end)

	-- Watch for changes to DevEnableMouseLock and update the feature availability accordingly
	PlayersService.LocalPlayer:GetPropertyChangedSignal("DevEnableMouseLock"):Connect(function()
		self:UpdateMouseLockAvailability()
	end)

	-- Watch for changes to DevEnableMouseLock and update the feature availability accordingly
	PlayersService.LocalPlayer:GetPropertyChangedSignal("DevComputerMovementMode"):Connect(function()
		self:UpdateMouseLockAvailability()
	end)

	self:UpdateMouseLockAvailability()

	return self
end

function MouseLockController:GetIsMouseLocked()
	return self.isMouseLocked
end

function MouseLockController:GetBindableToggleEvent()
	return self.mouseLockToggledEvent.Event
end

function MouseLockController:GetMouseLockOffset()
	local offsetValueObj = script:FindFirstChild("CameraOffset")
	if offsetValueObj and offsetValueObj:IsA("Vector3Value") then
		return offsetValueObj.Value
	else
		-- If CameraOffset object was found but not correct type, destroy
		if offsetValueObj then
			offsetValueObj:Destroy()
		end
		offsetValueObj = Instance.new("Vector3Value")
		offsetValueObj.Name = "CameraOffset"
		offsetValueObj.Value = Vector3.new(1.75,0,0) -- Legacy Default Value
		offsetValueObj.Parent = script
	end

	if offsetValueObj and offsetValueObj.Value then
		return offsetValueObj.Value
	end

	return Vector3.new(1.75,0,0)
end

function MouseLockController:UpdateMouseLockAvailability()
	local devAllowsMouseLock = PlayersService.LocalPlayer.DevEnableMouseLock
	local devMovementModeIsScriptable = PlayersService.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.Scriptable
	local userHasMouseLockModeEnabled = GameSettings.ControlMode == Enum.ControlMode.MouseLockSwitch
	local userHasClickToMoveEnabled =  GameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove
	local MouseLockAvailable = devAllowsMouseLock and userHasMouseLockModeEnabled and not userHasClickToMoveEnabled and not devMovementModeIsScriptable

	if MouseLockAvailable~=self.enabled then
		self:EnableMouseLock(MouseLockAvailable)
	end
end

function MouseLockController:OnBoundKeysObjectChanged(newValue)
	self.boundKeys = {} -- Overriding defaults, note: possibly with nothing at all if boundKeysObj.Value is "" or contains invalid values
	for token in string.gmatch(newValue,"[^%s,]+") do
		for _, keyEnum in pairs(Enum.KeyCode:GetEnumItems()) do
			if token == keyEnum.Name then
				self.boundKeys[#self.boundKeys+1] = keyEnum
				break
			end
		end
	end
	self:UnbindContextActions()
	self:BindContextActions()
end


Prompt:
--[[
	Called when the watched state changes value.
]]

Response:
function class:update(): boolean
	for callback in pairs(self._changeListeners) do
		coroutine.wrap(callback)()
	end
	return false
end


Prompt: -------- OMG HAX

Response:
r = game:service("RunService")

local damage = 5

local slash_damage = 8
local lunge_damage = 17

sword = script.Parent.Handle
Tool = script.Parent

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

local LungeSound = Instance.new("Sound")
LungeSound.SoundId = "rbxasset://sounds\\swordlunge.wav"
LungeSound.Parent = sword
LungeSound.Volume = .6

local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1

function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(damage)
				wait(1)
				untagHumanoid(humanoid)
			end
		end

	end
end

function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end

function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end

function lunge()
	damage = lunge_damage

	LungeSound:play()

	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Lunge"
	anim.Parent = Tool

	force = Instance.new("BodyVelocity")
	force.velocity = Vector3.new(0,10,0) --Tool.Parent.Torso.CFrame.lookVector * 80
	force.Parent = Tool.Parent.Torso
	wait(.1)
	swordOut()
	wait(.1)
	force.Parent = nil
	wait(.2)
	swordUp()

	damage = slash_damage
end

function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end

function swordAcross()
	-- parry
end

Tool.Enabled = true
local last_attack = 0
function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

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

	t = r.Stepped:wait()

	if (t - last_attack < .2) then
		lunge()
	else
		attack()
	end

	last_attack = t

	--wait(.5)

	Tool.Enabled = true
end

function onEquipped()
	UnsheathSound:play()
end

script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)

connection = sword.Touched:connect(blow)


Prompt: --Main body parts

Response:
local myRoot = script.Parent:WaitForChild("HumanoidRootPart")
local myHuman = script.Parent:WaitForChild("Humanoid")
local upperTorso = script.Parent:WaitForChild("UpperTorso")


Prompt:
-- When supplied, legacyCameraType is used and cameraMovementMode is ignored (should be nil anyways)
-- Next, if userCameraCreator is passed in, that is used as the cameraCreator

Response:
function CameraModule:ActivateCameraController( cameraMovementMode, legacyCameraType )
	local newCameraCreator = nil

	if legacyCameraType~=nil then
		--[[
			This function has been passed a CameraType enum value. Some of these map to the use of
			the LegacyCamera module, the value "Custom" will be translated to a movementMode enum
			value based on Dev and User settings, and "Scriptable" will disable the camera controller.
		--]]

		if legacyCameraType == Enum.CameraType.Scriptable then
			if self.activeCameraController then
				self.activeCameraController:Enable(false)
				self.activeCameraController = nil
				return
			end
		elseif legacyCameraType == Enum.CameraType.Custom then
			cameraMovementMode = self:GetCameraMovementModeFromSettings()

		elseif legacyCameraType == Enum.CameraType.Track then
			-- Note: The TrackCamera module was basically an older, less fully-featured
			-- version of ClassicCamera, no longer actively maintained, but it is re-implemented in
			-- case a game was dependent on its lack of ClassicCamera's extra functionality.
			cameraMovementMode = Enum.ComputerCameraMovementMode.Classic

		elseif legacyCameraType == Enum.CameraType.Follow then
			cameraMovementMode = Enum.ComputerCameraMovementMode.Follow

		elseif legacyCameraType == Enum.CameraType.Orbital then
			cameraMovementMode = Enum.ComputerCameraMovementMode.Orbital

		elseif legacyCameraType == Enum.CameraType.Attach or
			   legacyCameraType == Enum.CameraType.Watch or
			   legacyCameraType == Enum.CameraType.Fixed then
			newCameraCreator = LegacyCamera
		else
			warn("CameraScript encountered an unhandled Camera.CameraType value: ",legacyCameraType)
		end
	end

	if not newCameraCreator then
		if cameraMovementMode == Enum.ComputerCameraMovementMode.Classic or
			cameraMovementMode == Enum.ComputerCameraMovementMode.Follow or
			cameraMovementMode == Enum.ComputerCameraMovementMode.Default then
			newCameraCreator = ClassicCamera
		elseif cameraMovementMode == Enum.ComputerCameraMovementMode.Orbital then
			newCameraCreator = OrbitalCamera
		else
			warn("ActivateCameraController did not select a module.")
			return
		end
	end

	-- Create the camera control module we need if it does not already exist in instantiatedCameraControllers
	local newCameraController = nil
	if not instantiatedCameraControllers[newCameraCreator] then
		newCameraController = newCameraCreator.new()
		instantiatedCameraControllers[newCameraCreator] = newCameraController
	else
		newCameraController = instantiatedCameraControllers[newCameraCreator]
	end

	-- If there is a controller active and it's not the one we need, disable it,
	-- if it is the one we need, make sure it's enabled
	if self.activeCameraController then
		if self.activeCameraController ~= newCameraController then
			self.activeCameraController:Enable(false)
			self.activeCameraController = newCameraController
			self.activeCameraController:Enable(true)
		elseif not self.activeCameraController:GetEnabled() then
			self.activeCameraController:Enable(true)
		end
	elseif newCameraController ~= nil then
		self.activeCameraController = newCameraController
		self.activeCameraController:Enable(true)
	end

	if self.activeCameraController then
		if cameraMovementMode~=nil then
			self.activeCameraController:SetCameraMovementMode(cameraMovementMode)
		elseif legacyCameraType~=nil then
			-- Note that this is only called when legacyCameraType is not a type that
			-- was convertible to a ComputerCameraMovementMode value, i.e. really only applies to LegacyCamera
			self.activeCameraController:SetCameraType(legacyCameraType)
		end
	end
end


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

function Signal.new()
	local self = setmetatable({
		_bindable = Instance.new("BindableEvent");
		_connections = {};
		_args = {};
		_threads = 0;
		_id = 0;
	}, Signal)
	return self
end

function Signal.Is(obj)
	return (type(obj) == "table" and getmetatable(obj) == Signal)
end

function Signal:Fire(...)
	local id = self._id
	self._id = self._id + 1
	self._args[id] = {#self._connections + self._threads, {n = select("#", ...), ...}}
	self._threads = 0
	self._bindable:Fire(id)
end

function Signal:Wait()
	self._threads = self._threads + 1
	local id = self._bindable.Event:Wait()
	local args = self._args[id]
	args[1] = args[1] - 1
	if (args[1] <= 0) then
		self._args[id] = nil
	end
	return table.unpack(args[2], 1, args[2].n)
end

function Signal:WaitPromise()
	return Promise.new(function(resolve)
		resolve(self:Wait())
	end)
end

function Signal:Connect(handler)
	local connection = Connection.new(self, self._bindable.Event:Connect(function(id)
		local args = self._args[id]
		args[1] = args[1] - 1
		if (args[1] <= 0) then
			self._args[id] = nil
		end
		handler(table.unpack(args[2], 1, args[2].n))
	end))
	table.insert(self._connections, connection)
	return connection
end

function Signal:DisconnectAll()
	for _,c in ipairs(self._connections) do
		if (c._conn) then
			c._conn:Disconnect()
		end
	end
	self._connections = {}
	self._args = {}
end

function Signal:Destroy()
	self:DisconnectAll()
	self._bindable:Destroy()
end

function Signal:Init()
	Promise = self.Shared.Promise
end

return Signal


Prompt: --("found vehicle gui - deleting")

Response: pl.PlayerGui:findFirstChild("VehicleGui").Parent=nil


Prompt: --Internal Settings--

Response:
local fullMag = 30

local spread = 1.1 -- in degrees

local fullauto = true -- shoots all bullets as long as the player is visible (boolean)

local burstamount = 3 -- (only works if full auto is off) amount of times gun fires in burst fire mode

local firerate = 0.08 -- in seconds

local shotgunpellets = 1 -- setting this above 1 turns the gun into a shotgun (MIGHT LAG WITH FULL AUTO ON)

local delaybeforereloading = 0.3 -- to delay reload (prevents the marine from shooting the last shot of the mag at the ground)

local MinimumDamage,MaximumDamage = 9, 13 -- the amount of damage each bullet does (RANDOMIZED) first value is minimum, second value is maximum

local headshotmultiplier = 2 -- self explanitory (set this value to 1 if you dont want a multiplier)

local HitWallSounds = {"rbxassetid://6962153997","rbxassetid://6962154328","rbxassetid://6962154691","rbxassetid://6962155018","rbxassetid://6962155378"} -- basically sounds for hitting walls

local HitFleshSound = "rbxassetid://4988621968" -- plays when a creature gets shot

local bulletacceleration = Vector3.new(0,0,0) -- very similar to how acceleration works in particle emitters (setting the y value to a negative number will give the bullet bulletdrop)

local maxdistance = 300

local bulletspeed = 400


Prompt: -- Model name

Response: print("Blackeyei's Arc Window Loaded")


Prompt:
-----------------
--| Variables |--
-----------------

Response:
local Tool = script.Parent

local ScytheEquipAnimation = WaitForChild(script, 'ScytheEquip2')
local ScytheIdleAnimation = WaitForChild(script, 'ScytheIdle2')
local ScytheSlashAnimation = WaitForChild(script, 'ScytheSlash')

local ScytheEquipTrack = nil
local ScytheIdleTrack = nil
local ScytheSlashTrack = nil


Prompt:
--local busy = false
--Shield.Touched:connect(function(Hit)
--	if Hit == nil then return end
--	if Hit.Parent == nil then return end
--	if busy == true then return end
--
--	busy = true
--
--	local Item = Hit.Parent
--
--	if Item:IsA("Tool") == true then return end
--	if Hit.Name == "Torso" then return end
--	if Hit.Name == "HumanoidRootPart" then return end
--	if Hit.Name == "Left Leg" then return end
--	if Hit.Name == "Right Leg" then return end
--	if Hit.Name == "Head" then return end
--	if Hit.Name == "Left Arm" then return end
--	if Hit.Name == "Right Arm" then return end
--
--	if Game:GetService("Players"):GetPlayerFromCharacter(Item) ~= nil then return end
--
--	local touch = false
--	for _, x in ipairs(Hit:GetChildren()) do
--		if x:IsA("TouchTransmitter") == true then touch = true x:Destroy() break end
--	end
--
--	local owner, dmg = GetOwnerAndDamage(Hit)
--	if owner ~= nil and dmg ~= nil then
--		if Health > 0 then
--			if Health >= dmg then
--				Health = Health - dmg
--
--				if Health < 0 then Health = 0 end
--
--				HealthBar.Shield.Bar:TweenSize(UDim2.new((Health / MaxHealth), 0, 1, 0), Enum.EasingDirection.In, Enum.EasingStyle.Linear, 0.5, true)
--
--				if Health > 0 then
--					-- yay, still alive.
--				else
--					HealthBar.Parent.Parent:Destroy()
--				end
--
--				Hit:Destroy()
--			else
--				HealthBar.Parent.Parent:Destroy()
--			end
--		else
--			HealthBar.Parent.Parent:Destroy()
--		end
--	else
--		if touch == true then
--			--Hit:Destroy()
--		end
--	end
--
--	busy = false
--end)


Prompt:
--local springStiffness = gravityChange * strutSpring.Stiffness
--local springDamping = math.sqrt( gravityChange ) * strutSpring.Damping

Response:
local breakingTorque = 70000 * gravityChange
local steerMax


Prompt: -- Setup animation objects

Response:
function scriptChildModified(child)
	local fileList = animNames[child.Name]
	if (fileList ~= nil) then
		configureAnimationSet(child.Name, fileList)
	else
		if child:isA("StringValue") then
			animNames[child.Name] = {}
			configureAnimationSet(child.Name, animNames[child.Name])
		end
	end
end

script.ChildAdded:connect(scriptChildModified)
script.ChildRemoved:connect(scriptChildModified)


Prompt: --- TagHumanoid

Response:
function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


Prompt: --RedEgg--

Response:
Event.Hitbox.Touched:Connect(function(hit)
	if hit.Parent:IsA("Tool") and hit.Parent.Name == ToolRequired1 then
		if game.ReplicatedStorage.ItemSwitching.Value == true then
			hit.Parent:Destroy()
		end
		Event.Hitbox.RedGearHint:Destroy()
		Event.RedGear.Transparency = 0
		Event.Glass.Insert:Play()
		Event.LocksLeft.Value = Event.LocksLeft.Value - 1
		script.Disabled = true
	end
end)

Event.Hitbox.ClickDetector.MouseClick:Connect(function(plr)
	if plr.Backpack:FindFirstChild(ToolRequired1) then
		if game.ReplicatedStorage.ItemSwitching.Value == true then
			plr.Backpack:FindFirstChild(ToolRequired1):Destroy()
		end
		Event.Hitbox.RedGearHint:Destroy()
		Event.RedGear.Transparency = 0
		Event.Glass.Insert:Play()
		Event.LocksLeft.Value = Event.LocksLeft.Value - 1
		script.Disabled = true
	end
end)


Prompt: --Changes the size of the part----------

Response:
local function ModifyScale(Scale, Plot, Grid, Model)
	X, Y, Z = unpack(Scale)

	if X == "" or Y == "" or Z == "" then
		X = random:NextInteger(1, Plot.Size.X/5)
		Y = random:NextInteger(1, 20)
		Z = random:NextInteger(1, Plot.Size.Z/5)
	end

	X = math.clamp(tonumber(X), 1, 78)
	Y = math.clamp(tonumber(Y), 1, 512)
	Z = math.clamp(tonumber(Z), 1, 78)

	Confirm(Grid, Plot)

	Model.PrimaryPart.Size = Vector3.new(X, Y, Z)
	Model.Hull.Size = Model.PrimaryPart.Size

	return true
end


Prompt:
--[=[
	Returns a tuple of fail and complete functions which
	can be chained into the the next subscription.

	```lua
	return function(source)
		return Observable.new(function(sub)
			return source:Subscribe(function(result)
				sub:Fire(tostring(result))
			end, sub:GetFailComplete()) -- Reuse is easy here!
		end)
	end
	```

	@return function
	@return function
]=]

Response:
function Subscription:GetFailComplete()
	return function(...)
		self:Fail(...)
	end, function(...)
		self:Complete(...)
	end
end


Prompt:
--[=[
	Converts the string to _privateCamelCase
	@param str string
	@return string
]=]

Response:
function String.toPrivateCase(str: string): string
	return "_" .. str:sub(1, 1):lower() .. str:sub(2, #str)
end


Prompt:
--game.Players.PlayerAdded:Connect(function(p)
--	phs:CreateCollisionGroup(p.Name)
--	phs:CollisionGroupSetCollidable(p.Name,p.Name,true)
--	for i,v in pairs(game.Players:GetChildren()) do
--		if v ~= p then
--			phs:CollisionGroupSetCollidable(p.Name,v.Name,false)
--		end
--	end
--	p.CharacterAdded:connect(function(c)
--		for i,v in pairs(c:GetChildren()) do
--			if v:IsA("BasePart") then
--				phs:SetPartCollisionGroup(v,p.Name)
--			end
--		end
--		c.ChildAdded:connect(function(v)
--			if v:IsA("BasePart") then
--				phs:SetPartCollisionGroup(v,p.Name)
--			end
--		end)
--	end)
--end)
--
--game.Players.PlayerRemoving:Connect(function(p)
--	phs:RemoveCollisionGroup(p.Name)
--end)


Prompt: -- If you want to know how to retexture a hat, read this:  http://www.roblox.com/Forum/ShowPost.aspx?PostID=10502388

Response:
debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "Hat"   -- It doesn't make a difference, but if you want to make your place in Explorer neater, change this to the name of your hat.
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle"
		p.formFactor = 0
		p.Size = Vector3.new(-0,-0,-1)
		p.BottomSurface = 0
		p.TopSurface = 0
		p.Locked = true
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentPos = Vector3.new(0, -0.95, 0) -- Change these to change the positiones of your hat, as I said earlier.
		wait(5)		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)


Prompt:
--[[

	TouchThumbstick

--]]

Response:
local Players = game:GetService("Players")
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")


Prompt: --// Input Connections

Response:
L_71_.InputBegan:connect(function(L_229_arg1, L_230_arg2)
	if not L_230_arg2 and L_14_ then
		if L_229_arg1.UserInputType == Enum.UserInputType.MouseButton2 and L_21_.CanAim and not L_51_ and L_14_ and not L_43_ and not L_44_ then
			if not L_41_ then
				if not L_42_ then
					L_3_.Humanoid.WalkSpeed = 10
					L_109_ = 10
					L_108_ = 0.008
				end
				L_64_ = L_31_
				L_91_.target = L_34_.CFrame:toObjectSpace(L_25_.CFrame).p
				L_41_ = true
			end
		end;

		if L_229_arg1.UserInputType == Enum.UserInputType.MouseButton1 and L_46_ and L_14_ and not L_43_ and not L_44_ and not L_51_ then
			L_45_ = true
			if not Shooting and L_14_ and L_68_ > 0 then
				Shoot()
			end
		end;

		if L_229_arg1.KeyCode == L_21_.LaserKey and L_14_ and L_21_.LaserAttached then
			local L_231_ = L_1_:FindFirstChild("LaserLight")
			L_80_.KeyDown[1].Plugin()
		end;

		if L_229_arg1.KeyCode == L_21_.LightKey and L_14_ and L_21_.LightAttached then
			local L_232_ = L_1_:FindFirstChild("FlashLight"):FindFirstChild('Light')
			local L_233_ = false
			L_232_.Enabled = not L_232_.Enabled
		end;

		if L_14_ and L_229_arg1.KeyCode == L_21_.FireSelectKey and not L_47_ then
			L_47_ = true
			if L_59_ == 1 then
				if Shooting then
					Shooting = false
				end
				if L_21_.AutoEnabled then
					L_59_ = 2
				elseif not L_21_.AutoEnabled and L_21_.BurstEnabled then
					L_59_ = 3
				elseif not L_21_.AutoEnabled and not L_21_.BurstEnabled and L_21_.BoltAction then
					L_59_ = 4
				elseif not L_21_.AutoEnabled and not L_21_.BurstEnabled and not L_21_.BoltAction then
					L_59_ = 1
				end
			elseif L_59_ == 2 then
				if Shooting then
					Shooting = false
				end
				if L_21_.BurstEnabled then
					L_59_ = 3
				elseif not L_21_.BurstEnabled and L_21_.BoltAction then
					L_59_ = 4
				elseif not L_21_.BurstEnabled and not L_21_.BoltAction and L_21_.SemiEnabled then
					L_59_ = 1
				elseif not L_21_.BurstEnabled and not L_21_.BoltAction and not L_21_.SemiEnabled then
					L_59_ = 2
				end
			elseif L_59_ == 3 then
				if Shooting then
					Shooting = false
				end
				if L_21_.BoltAction then
					L_59_ = 4
				elseif not L_21_.BoltAction and L_21_.SemiEnabled then
					L_59_ = 1
				elseif not L_21_.BoltAction and not L_21_.SemiEnabled and L_21_.AutoEnabled then
					L_59_ = 2
				elseif not L_21_.BoltAction and not L_21_.SemiEnabled and not L_21_.AutoEnabled then
					L_59_ = 3
				end
			elseif L_59_ == 4 then
				if Shooting then
					Shooting = false
				end
				if L_21_.SemiEnabled then
					L_59_ = 1
				elseif not L_21_.SemiEnabled and L_21_.AutoEnabled then
					L_59_ = 2
				elseif not L_21_.SemiEnabled and not L_21_.AutoEnabled then
					L_59_ = 3
				elseif not L_21_.SemiEnabled and not L_21_.AutoEnabled and not L_21_.BurstEnabled then
					L_59_ = 4
				end
			end
			L_47_ = false
		end;

		if L_229_arg1.KeyCode == Enum.KeyCode.F and not L_44_ and not L_47_ and not L_41_ and not L_43_ and not Shooting then
			if not L_50_ and not L_51_ then
				L_51_ = true
				Shooting = false
				L_46_ = false
				L_93_ = time()
				delay(0.6, function()
					if L_68_ ~= L_21_.Ammo and L_68_ > 0 then
						CreateShell()
					end
				end)
				BoltBackAnim()
				L_50_ = true
			elseif L_50_ and L_51_ then
				BoltForwardAnim()
				Shooting = false
				L_46_ = true
				if L_68_ ~= L_21_.Ammo and L_68_ > 0 then
					L_68_ = L_68_ - 1
				elseif L_68_ >= L_21_.Ammo then
					L_46_ = true
				end
				L_50_ = false
				L_51_ = false
				IdleAnim()
				L_52_ = false
			end
		end;

		if L_229_arg1.KeyCode == Enum.KeyCode.LeftShift and L_104_ then
			L_48_ = true
			if L_14_ and not L_47_ and not L_44_ and L_48_ and not L_42_ and not L_51_ then
				Shooting = false
				L_41_ = false
				L_44_ = true

				delay(0, function()
					if L_44_ and not L_43_ then
						L_41_ = false
						L_49_ = true
					end
				end)
				L_64_ = 80
				L_3_.Humanoid.WalkSpeed = 21
				L_109_ = 21
				L_108_ = 0.4
			end
		end;

		if L_229_arg1.KeyCode == Enum.KeyCode.R and L_14_ and not L_43_ and not L_41_ and not Shooting and not L_44_ and not L_51_ then
			if L_69_ > 0 and L_68_ < L_21_.Ammo then
				Shooting = false
				L_43_ = true
				ReloadAnim()
				if L_68_ <= 0 then
					BoltBackAnim()
					BoltForwardAnim()
					L_46_ = true
				end
				IdleAnim()

				if L_68_ <= 0 then
					if (L_69_ - (L_21_.Ammo - L_68_)) < 0 then
						L_68_ = L_68_ + L_69_
						L_69_ = 0
					else
						L_69_ = L_69_ - (L_21_.Ammo - L_68_)
						L_68_ = L_21_.Ammo
					end
				elseif L_68_ > 0 then
					if (L_69_ - (L_21_.Ammo - L_68_)) < 0 then
						L_68_ = L_68_ + L_69_ + 1
						L_69_ = 0
					else
						L_69_ = L_69_ - (L_21_.Ammo - L_68_)
						L_68_ = L_21_.Ammo + 1
					end
				end

				L_43_ = false
				if not L_52_ then
					L_46_ = true
				end
			end
		end;

		if L_229_arg1.KeyCode == Enum.KeyCode.RightBracket then
			if (L_32_ < 1) then
				L_32_ = L_32_ + L_21_.SensitivityIncrement
			end
		end

		if L_229_arg1.KeyCode == Enum.KeyCode.LeftBracket then
			if (L_32_ > 0.1) then
				L_32_ = L_32_ - L_21_.SensitivityIncrement
			end
		end

		if L_229_arg1.KeyCode == Enum.KeyCode.T and L_1_:FindFirstChild("AimPart2") then
			if not L_53_ then
				L_34_ = L_1_:WaitForChild("AimPart2")
				L_31_ = L_21_.CycleAimZoom
				if L_41_ then
					L_64_ = L_21_.CycleAimZoom
				end
				L_53_ = true
			else
				L_34_ = L_1_:FindFirstChild("AimPart")
				L_31_ = L_21_.AimZoom
				if L_41_ then
					L_64_ = L_21_.AimZoom
				end
				L_53_ = false
			end;
		end;
	end
end)

L_71_.InputEnded:connect(function(L_234_arg1, L_235_arg2)
	if not L_235_arg2 and L_14_ then
		if L_234_arg1.UserInputType == Enum.UserInputType.MouseButton2 and L_21_.CanAim then
			if L_41_ then
				if not L_42_ then
					L_3_.Humanoid.WalkSpeed = 16
					L_109_ = 17
					L_108_ = .25
				end
				L_64_ = 70
				L_91_.target = Vector3.new()
				L_41_ = false
			end
		end;

		if L_234_arg1.UserInputType == Enum.UserInputType.MouseButton1 then
			L_45_ = false
			if Shooting then
				Shooting = false
			end
		end;

		if L_234_arg1.KeyCode == Enum.KeyCode.LeftShift and not L_47_ and not L_42_ then -- SPRINT
			L_48_ = false
			if L_44_ and not L_41_ and not Shooting and not L_48_ then
				L_44_ = false
				L_49_ = false
				L_64_ = 70

				L_3_.Humanoid.WalkSpeed = 16
				L_109_ = 17
				L_108_ = .25
			end
		end;
	end
end)

L_71_.InputChanged:connect(function(L_236_arg1, L_237_arg2)
	if not L_237_arg2 and L_14_ and L_21_.FirstPersonOnly then
		if L_236_arg1.UserInputType == Enum.UserInputType.MouseWheel then
			if L_236_arg1.Position.Z == 1 and (L_32_ < 1) then
				L_32_ = L_32_ + L_21_.SensitivityIncrement
			elseif L_236_arg1.Position.Z == -1 and (L_32_ > 0.1) then
				L_32_ = L_32_ - L_21_.SensitivityIncrement
			end
		end
	end
end)


Prompt:
--[[
local TypeDefs = require(script.TypeDefinitions)
type CanPierceFunction = TypeDefs.CanPierceFunction
type GenericTable = TypeDefs.GenericTable
type Caster = TypeDefs.Caster
type FastCastBehavior = TypeDefs.FastCastBehavior
type CastTrajectory = TypeDefs.CastTrajectory
type CastStateInfo = TypeDefs.CastStateInfo
type CastRayInfo = TypeDefs.CastRayInfo
type ActiveCast = TypeDefs.ActiveCast
--]]


Prompt:
--[[
	CameraUtils - Math utility functions shared by multiple camera scripts
	2018 Camera Update - AllYourBlox
--]]

Response:
local CameraUtils = {}

local function round(num)
	return math.floor(num + 0.5)
end


Prompt:
--local part2 = Instance.new("Part")
--if Instance.Lock(part2) then
--	Instance.Unlock(part2)
--end

Response:
Tool.Equipped:connect(onEquippedLocal)
Tool.Unequipped:connect(onUnequippedLocal)


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

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

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

ZoneModelName = "Bullet 3" -- name the zone model

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


Prompt:
--[[

	NVNA Constraint Type: Motorcycle
	The Bike Chassis | Build:	1
					   Version: 1

		 Avxnturador | NVNA
		 	 HAYASHl | Enjin
	You're advised not to touch anything below.

]]


Prompt: --vars

Response:
local state = "unequipped"
local adsing = sefal
local rstepgun
local savedfov
local currentlyfps = false
offset = CFrame.new()


Prompt:
-- perform the update loop
-- do the R6 update loop

Response:
stepped_con = game:GetService("RunService").RenderStepped:Connect(function()
	debug.profilebegin("FPS")
	swaysize = script.WalkSwayMultiplier.Value

	-- checkfirstperson() checks if camera is first person and enables/disables the viewmodel accordingly
	checkfirstperson()
	-- update loop
	if isfirstperson == true then
		local modifierr = 0
		local statething = player:GetAttribute('State')
		-- make arms visible
		if larm.LocalTransparencyModifier ~= 0 then
			visiblearms(true)
		end
		-- update walk sway if we are walking
		if isrunning == true and includewalksway and humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and humanoid:GetState() ~= Enum.HumanoidStateType.Landed then
			walksway = walksway:lerp(
				CFrame.new(

					(0.07*swaysize) * math.sin(tick() * (2 * humanoid.WalkSpeed/4)),
					(0.07*swaysize) * math.cos(tick() * (4 * humanoid.WalkSpeed/4)),
					0

				)*
					CFrame.Angles(

						0,
						0,
						(-.03*swaysize) * math.sin(tick() * (2 * humanoid.WalkSpeed/4))

					)
				,0.2*sensitivity)
		else
			walksway = walksway:Lerp(CFrame.new(), 0.05*sensitivity)
		end
		--
		local delta = uis:GetMouseDelta()
		--
		if includecamerasway then
			sway = sway:Lerp(Vector3.new(delta.X,delta.Y,delta.X/2), 0.1*sensitivity)
		end
		--
		if includestrafe then
			strafesway = strafesway:Lerp(CFrame.Angles(0,0,-rootpart.CFrame.rightVector:Dot(humanoid.MoveDirection)/(20/swaysize)), 0.1*sensitivity)
		end
		--
		if includejumpsway == true then
			jumpsway = jumpswaygoal.Value
		end
		-- update animation transform for viewmodel
		rightshoulderclone.Transform = rightshoulder.Transform
		leftshoulderclone.Transform = leftshoulder.Transform
		-- cframe the viewmodel

		if statething ~= nil and statething == "Crouching" and player.Character:FindFirstChildWhichIsA("Tool") then
			modifierr = 20
		end

		if statething ~= nil and statething == "Crawling" and player.Character:FindFirstChildWhichIsA("Tool") then
			modifierr = 80
		end

		local CamY, CamX, CamZ = camera.CFrame:ToEulerAnglesYXZ()

		local direction = Vector2.new(
			math.rad(player.Character.HumanoidRootPart.CFrame.RightVector:Dot((-player.Character.HumanoidRootPart.Velocity * Vector3.new(1,0,1)).Unit) * 200),
			math.rad(player.Character.HumanoidRootPart.CFrame.LookVector:Dot((-player.Character.HumanoidRootPart.Velocity * Vector3.new(1,0,1)).Unit) * 200)
		)

		local tilt = direction.Unit * math.clamp((player.Character.HumanoidRootPart.Velocity.Magnitude / 14), 0, 2)

		local firstframe = CFrame.new( Vector3.new(camera.CFrame.Position.X,camera.CFrame.Position.Y,camera.CFrame.Position.Z) ) * CFrame.fromEulerAnglesXYZ(CamY + math.rad(modifierr),0,0)
		local TorsX,TorsY,TorsZ = player.Character.Torso.CFrame.Rotation:ToEulerAnglesXYZ()
		local torsoframe = CFrame.Angles(TorsX,TorsY,TorsZ)

		local countercf = CFrame.new()

		if script.CFrameAimOffset.Value.Position.X ~= 0 or not (script.CFrameAimOffset.Value.Position.X <= 0.1) then
			--countercf = CFrame.Angles(math.rad(-tilt.Y * 3),math.rad(-tilt.X * 4),math.rad(-tilt.X * 6))
		end

		local finalcf = (CFrame.new(firstframe.Position)*torsoframe*firstframe.Rotation*walksway*jumpsway*strafesway*countercf*CFrame.Angles(math.rad(sway.Y*swaysize),math.rad(sway.X*swaysize)/10,math.rad(sway.Z*swaysize)/2))+(camera.CFrame.UpVector*(-1.7-(headoffset.Y+(aimoffset.Value.Y))))+(camera.CFrame.LookVector*(headoffset.Z+(aimoffset.Value.Z)))+(camera.CFrame.RightVector*(-headoffset.X-(aimoffset.Value.X)+(-(sway.X*swaysize)/75)))

		local builtcf = finalcf * script.CFrameAimOffset.Value:Inverse()

		viewmodel:SetPrimaryPartCFrame(builtcf)
	end
	debug.profileend()
end)


Prompt: --!strict

Response:
local Types = require(script.Parent.Parent.Parent.Types)

return function(excludedPlayers: Types.Array<Player>): Types.PlayerContainer
	return { kind = "except", value = excludedPlayers }
end


Prompt: -- ROBLOX deviation START: Polyfill Math.trunc

Response:
local function mathTrunc(value: number): number
	return if value > 0 then math.floor(value) else math.ceil(value)
end


Prompt:
-- To change the sound ID of a material, change the 'id' variable.
-- To change the volume, change the volume variable.
-- To change the playback speed of a sound, change the speed variable.

Response:
local IDList = {
	Air = {id = "rbxassetid://329997777", volume = 0, speed = 1.00},
	Asphalt = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Basalt = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Brick = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Cobblestone = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Concrete = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	CorrodedMetal = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	CrackedLava = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	DiamondPlate = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Fabric = {id = "rbxassetid://4416041299", volume = 0.40, speed = 1.00},
	Foil = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Forcefield = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Glass = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Granite = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Grass = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Glacier = {id = "rbxassetid://4416041299", volume = 0.40, speed = 1.00},
	Ground = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Ice = {id = "rbxassetid://4416041299", volume = 0.40, speed = 1.00},
	Limestone = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	LeafyGrass = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Marble = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Metal = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Mud = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Neon = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Pebble = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Plastic = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Pavement = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Rock = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Sand = {id = "rbxassetid://4416041299", volume = 0.40, speed = 1.00},
	Slate = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Snow = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Salt = {id = "rbxassetid://4416041299", volume = 0.40, speed = 1.00},
	Sandstone = {id = "rbxassetid://4416041299", volume = 0.60, speed = 0.75},
	SmoothPlastic = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	Wood = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00},
	WoodPlanks = {id = "rbxassetid://4416041299", volume = 0.60, speed = 1.00}
}

return IDList


Prompt: --------AUDIENCE BACK RIGHT--------

Response:
game.Workspace.audiencebackright1.Part3.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.audiencebackright1.Part6.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.audiencebackright1.Part9.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)


Prompt: --- Skill

Response:
repeat wait() until game.Players.LocalPlayer.Character

local plr = game.Players.LocalPlayer
local char = plr.Character
local hum = char:WaitForChild("Humanoid")
local Torso = char:WaitForChild("LowerTorso")
local Mouse = plr:GetMouse()
local toggle = false
local Debounce = true
Mouse.KeyDown:Connect(function(key)
    if key == "f" and Tool.Equip.Value == true and Tool.Active.Value == "None" or Tool.Active.Value == "FireFlight" then
        if toggle == false and Debounce == true then
            toggle = true
            local Anim = Instance.new("Animation")
            Anim.AnimationId = "rbxassetid://4598627471"
            local PlayAnim = hum:LoadAnimation(Anim)
            PlayAnim:Play()
            Debounce = false
            Tool.Active.Value = "FireFlight"
		    script.Fire:FireServer(plr)
            local BV = Instance.new("BodyVelocity",Torso)
            BV.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
            while toggle == true do
                wait()
            plr.Character.HumanoidRootPart.CFrame = CFrame.new(plr.Character.HumanoidRootPart.Position, Vector3.new(Mouse.Hit.p.x,plr.Character.HumanoidRootPart.Position.y,Mouse.Hit.p.z))
            BV.Velocity = Mouse.Hit.lookVector * 40
            end
        end
        if toggle == true and Debounce == false then
            toggle = false
            Tool.Active.Value = "None"
            script.UnFire:FireServer(plr)
            Torso:FindFirstChildOfClass("BodyVelocity"):Destroy()
            local tracks = hum:GetPlayingAnimationTracks()
            for i, stoptracks in pairs(tracks) do
            stoptracks:Stop()
            end
            local Anim = Instance.new("Animation")
            Anim.AnimationId = "http://www.roblox.com/asset/?id=507767968"
            local PlayAnim = hum:LoadAnimation(Anim)
            PlayAnim:Play()
            wait(3.5)
            Debounce = true
        end
    end
end)


Prompt:
-- deviation: Lua objects don't have any special properties the way that JS
-- Objects do; this has been modified from the JS, which uses
-- `Object.defineProperties` to ensure that properties are modifiable. In Lua,
-- these operations are as simple as assigning to functions.
-- ROBLOX: use patched console from shared

Response: local console = require(script.Parent.console)


Prompt: --		child.C0 = CFrame.new(0,-0.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0) --// Reposition player

Response:
		if child.Part1.Name == "HumanoidRootPart" then
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and (not player.PlayerGui:FindFirstChild("Screen")) then --// The part after the "and" prevents multiple GUI's to be copied over.
				GUI.CarSeat.Value = script.Parent --// Puts a reference of the seat in this ObjectValue, now you can use this ObjectValue's value to find the car directly.
				GUI:Clone().Parent = player.PlayerGui --// Compact version
				if script.Parent.L.Value == true then --because you can't get in a locked car
					wait()
					script.Parent.Disabled = true
					wait()
					script.Parent.Disabled = false
				end
				script.Parent.Occupied.Value = true
				script.Parent.Parent.Body.Dash.Spd.Interface.Enabled = true
				script.Parent.Parent.Body.Dash.Tac.Interface.Enabled = true
				script.Parent.Parent.Body.Lights.Runner.Material = "Neon"
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = true
				script.Parent.Parent.Body.Dash.Screen.G.Startup.Visible = true
				script.Parent.Parent.Body.Dash.Screen.G.Caution.Visible = false
				script.Parent.Parent.Body.Dash.DashSc.G.Unit.Visible = true
				script.Parent.Parent.Body.Dash.DashSc.G.Enabled = true
				script.Parent.Parent.DriveSeat.SS3.DashInfoSpeed.Info.Value = true
				script.Parent.Parent.DriveSeat.SS3.DashInfoSpeed.Speed.Value = false
				script.Parent.Parent.DriveSeat.SS3.DashInfoSpeed.Version.Value = false
				script.Parent.Parent.DriveSeat.SS3.DashInfoSpeed.MPG.Value = false
				script.Parent.Parent.DriveSeat.SS3.Radios.FMOne.Value = true
				script.Parent.Parent.DriveSeat.SS3.Radios.FMTwo.Value = false
				script.Parent.Parent.DriveSeat.SS3.Radios.FMThree.Value = false
				script.Parent.Parent.DriveSeat.SS3.Radios.FMFour.Value = false
				script.Parent.Parent.Body.Dash.DashSc.G.Modes.SpeedStats.Visible = false
						script.Parent.Parent.Body.Dash.DashSc.G.Modes.Info.Visible = false
						script.Parent.Parent.Body.Dash.DashSc.G.Modes.Stats.Visible = false
						script.Parent.Parent.Body.Dash.DashSc.G.Frame.Position = UDim2.new(0, 0, 0, -5)
						script.Parent.Parent.Body.Dash.DashSc.G.Select.Position = UDim2.new(0, 0, 0, -5)
						script.Parent.Parent.Body.Dash.DashSc.G.Unit.Text = "Welcome"
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.9
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.8
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.7
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.6
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.5
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.4
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.3
						script.Parent.Parent.Body.Dash.Spd.Interface.LightInfluence = 1.5
						script.Parent.Parent.Body.Dash.Tac.Interface.LightInfluence = 1.5
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.Car.ImageTransparency = 0.7
						script.Parent.Parent.Body.Dash.DashSc.G.Speed.ImageTransparency = 0.7
						script.Parent.Parent.Body.Dash.DashSc.G.Info1.ImageTransparency = 0.7
						script.Parent.Parent.Body.Dash.DashSc.G.Gas.ImageTransparency = 0.7
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.2
						script.Parent.Parent.Body.Dash.Spd.Interface.LightInfluence = 1
						script.Parent.Parent.Body.Dash.Tac.Interface.LightInfluence = 1
						script.Parent.Parent.Body.Dash.DashSc.G.Select:TweenPosition(UDim2.new(0, 0, 0, 20), "InOut", "Quint", 1, true)
					script.Parent.Parent.Body.Dash.DashSc.G.Frame:TweenPosition(UDim2.new(0, 0, 0, 20), "InOut", "Quint", 1, true)
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.Car.ImageTransparency = 0.4
						script.Parent.Parent.Body.Dash.DashSc.G.Speed.ImageTransparency = 0.4
						script.Parent.Parent.Body.Dash.DashSc.G.Info1.ImageTransparency = 0.4
						script.Parent.Parent.Body.Dash.DashSc.G.Gas.ImageTransparency = 0.4
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0.1
						script.Parent.Parent.Body.Dash.Spd.Interface.LightInfluence = .5
						script.Parent.Parent.Body.Dash.Tac.Interface.LightInfluence = .5
						wait(0.2)
						script.Parent.Parent.Body.Dash.DashSc.G.Car.ImageTransparency = 0
						script.Parent.Parent.Body.Dash.DashSc.G.Speed.ImageTransparency = 0
						script.Parent.Parent.Body.Dash.DashSc.G.Info1.ImageTransparency = 0
						script.Parent.Parent.Body.Dash.DashSc.G.Gas.ImageTransparency = 0
						script.Parent.Parent.Body.Dash.DashSc.G.ImageLabel.ImageTransparency = 0
						script.Parent.Parent.Body.Dash.Spd.Interface.LightInfluence = 0
						script.Parent.Parent.Body.Dash.Tac.Interface.LightInfluence = 0
						wait(2.2)
						script.Parent.Parent.Body.Dash.DashSc.G.Modes.SpeedStats.Position = UDim2.new(0, 0, 0, 0)
						script.Parent.Parent.Body.Dash.DashSc.G.Modes.SpeedStats.Visible = true
						script.Parent.Parent.Body.Dash.DashSc.G.Unit.Visible = false
						script.Parent.Parent.Body.Dash.Screen.G.Startup.Visible = false
						script.Parent.Parent.Body.Dash.Screen.G.Caution.Visible = true
						wait(6)
						script.Parent.Parent.Body.Dash.Screen.G.Caution.Visible = false


Prompt: --load settings

Response: local sp,amt,max,def = script.RegenSpeed.Value, script.RegenAmt.Value, script.MaxAmt.Value, script.DefaultAmt.Value


Prompt:
--[[
	These messages are used by Component to help users diagnose when they're
	calling setState in inappropriate places.

	The indentation may seem odd, but it's necessary to avoid introducing extra
	whitespace into the error messages themselves.
]]

Response:
local ComponentLifecyclePhase = require(script.Parent.ComponentLifecyclePhase)

local invalidSetStateMessages = {}

invalidSetStateMessages[ComponentLifecyclePhase.WillUpdate] = [[
setState cannot be used in the willUpdate lifecycle method.
Consider using the didUpdate method instead, or using getDerivedStateFromProps.

Check the definition of willUpdate in the component %q.]]

invalidSetStateMessages[ComponentLifecyclePhase.ShouldUpdate] = [[
setState cannot be used in the shouldUpdate lifecycle method.
shouldUpdate must be a pure function that only depends on props and state.

Check the definition of shouldUpdate in the component %q.]]

invalidSetStateMessages[ComponentLifecyclePhase.Render] = [[
setState cannot be used in the render method.
render must be a pure function that only depends on props and state.

Check the definition of render in the component %q.]]

invalidSetStateMessages["default"] = [[
setState can not be used in the current situation, because Roact doesn't know
which part of the lifecycle this component is in.

This is a bug in Roact.
It was triggered by the component %q.
]]

return invalidSetStateMessages


Prompt: -- Scenes

Response:
while true do
	for i, v in pairs(scenes:GetChildren()) do
		if looping == false then return end
		cam.CFrame = v["1"].CFrame
		currentTween = tween:Create(cam, TweenInfo.new(10), {CFrame = v["2"].CFrame})
		currentTween:Play()
		wait(10)
	end
end