Prompt: -- Release all loaded profiles when the server is shutting down:

Response:
task.spawn(function()
	WaitForLiveAccessCheck()
	Madwork.ConnectToOnClose(
		function()
			ProfileService.ServiceLocked = true
			-- 1) Release all active profiles: --
			-- Clone AutoSaveList to a new table because AutoSaveList changes when profiles are released:
			local on_close_save_job_count = 0
			local active_profiles = {}
			for index, profile in ipairs(AutoSaveList) do
				active_profiles[index] = profile
			end
			-- Release the profiles; Releasing profiles can trigger listeners that release other profiles, so check active state:
			for _, profile in ipairs(active_profiles) do
				if profile:IsActive() == true then
					on_close_save_job_count = on_close_save_job_count + 1
					task.spawn(function() -- Save profile on new thread
						SaveProfileAsync(profile, true)
						on_close_save_job_count = on_close_save_job_count - 1
					end)
				end
			end
			-- 2) Yield until all active profile jobs are finished: --
			while on_close_save_job_count > 0 or ActiveProfileLoadJobs > 0 or ActiveProfileSaveJobs > 0 do
				task.wait()
			end
			return -- We're done!
		end,
		UseMockDataStore == false -- Always run this OnClose task if using Roblox API services
	)
end)

return ProfileService


Prompt: --[[Engine (Avxnturador)]]

Response:
	-- Everything below can be illustrated and tuned with the graph below.
	-- https://www.desmos.com/calculator/oishj9m1tq
	-- This includes everything, from the engines, to boost, to electric.

	-- To import engines prior to AC6C V1.3, consult the README.

	-- Naturally Aspirated Engine
	Tune.Engine 		= true

		Tune.Horsepower		= 249	-- Naturally aspirated horsepower, before adding forced induction
		Tune.IdleRPM		= 650	-- Engine idle
		Tune.PeakRPM		= 4800	-- Where horsepower reaches peak
		Tune.Redline		= 6000	-- Your engine's rev limiter
		Tune.PeakSharpness	= 45	-- How fast power drops off past peak horsepower
		Tune.CurveMult		= .5	-- Higher values mean a peakier power curve, lower values being smoother
		Tune.EqPoint		= 5252	-- Standardized, do not touch

		Tune.CompressionRatio	= 8.5 -- Only affects cars with forced induction, Google this value

	-- Electric Engine
	Tune.Electric		= false

		Tune.E_Redline	= 12700
		Tune.E_Trans1	= 4000
		Tune.E_Trans2	= 7000
		-- Horsepower
		Tune.E_Horsepower	= 223
		Tune.EH_FrontMult	= 0.15
		Tune.EH_EndMult		= 2.9
		Tune.EH_EndPercent	= 7
		-- Torque
		Tune.E_Torque		= 286
		Tune.ET_EndMult		= 1.505
		Tune.ET_EndPercent	= 27.5

	-- Turbocharger
	Tune.Turbochargers	= 2				-- Number of turbochargers in the engine, set to 0 for no turbochargers

		Tune.T_Boost		= 7
		Tune.T_BoostLag		= 125		-- Turbo lag overall
		Tune.T2_BoostLag	= 250		-- (ONLY ACTIVE ON TWIN TURBO CARS) Second turbo lag, equal to the first turbo lag or greater if you're using sequential turbos

	-- Supercharger
	Tune.Superchargers	= 0				-- Number of superchargers in the engine
										-- Set to 0 for no superchargers
		Tune.S_Boost		= 7
		Tune.S_Sensitivity	= 0.05		-- Supercharger responsiveness/sensitivity, applied per tick (recommended values between 0.05 to 0.1)

	--Misc
	Tune.ThrotAccel		= .05		-- Throttle acceleration, applied per tick (recommended values between 0.05 to 0.1)
	Tune.ThrotDecel		= .2		-- Throttle deceleration, applied per tick (recommended values between 0.1 to 0.3)

	Tune.BrakeAccel		= .2		-- Brake acceleration, applied per tick
	Tune.BrakeDecel		= .5		-- Brake deceleration, applied per tick

	Tune.RevAccel		= 250		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 250		-- RPM kickback from redline

	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.Flywheel		= 500		-- Flywheel weight (higher = faster response, lower = more stable RPM)

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


Prompt:
--[[
	Given a reactive object, updates all dependent reactive objects.
	Objects are only ever updated after all of their dependencies are updated,
	are only ever updated once, and won't be updated if their dependencies are
	unchanged.
]]

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

local function updateAll(ancestor: Types.Dependency<any>)
	--[[
		First things first, we need to mark all indirect dependents as needing
		an update. This means we can ignore any dependencies that aren't related
		to the current update operation.
	]]

	-- set of all dependents that still need to be updated
	local needsUpdateSet: Types.Set<Types.Dependent<any>> = {}
	-- the dependents to be processed now
	local processNow: {Types.Dependent<any>} = {}
	local processNowSize = 0
	-- the dependents of the open set to be processed next
	local processNext: {Types.Dependent<any>} = {}
	local processNextSize = 0

	-- initialise `processNow` with dependents of ancestor
	for dependent in pairs(ancestor.dependentSet) do
		processNowSize += 1
		processNow[processNowSize] = dependent
	end

	repeat
		-- if we add to `processNext` this will be false, indicating we need to
		-- process more dependents
		local processingDone = true

		for _, member in ipairs(processNow) do
			-- mark this member as needing an update
			needsUpdateSet[member] = true

			-- add the dependents of the member for processing
			if member.dependentSet ~= nil then
				for dependent in pairs(member.dependentSet) do
					processNextSize += 1
					processNext[processNextSize] = dependent
					processingDone = false
				end
			end
		end

		-- swap in the next dependents to be processed
		processNow, processNext = processNext, processNow
		processNowSize, processNextSize = processNextSize, 0
		table.clear(processNext)
	until processingDone

	--[[
		`needsUpdateSet` is now set up. Now that we have this information, we
		can iterate over the dependents once more and update them only when the
		relevant dependencies have been updated.
	]]

	-- re-initialise `processNow` similar to before
	processNowSize = 0
	table.clear(processNow)
	for dependent in pairs(ancestor.dependentSet) do
		processNowSize += 1
		processNow[processNowSize] = dependent
	end

	repeat
		-- if we add to `processNext` this will be false, indicating we need to
		-- process more dependents
		local processingDone = true

		for _, member in ipairs(processNow) do
			-- mark this member as no longer needing an update
			needsUpdateSet[member] = nil

			--FUTURE: should this guard against errors?
			local didChange = member:update()

			-- add the dependents of the member for processing
			-- optimisation: if nothing changed, then we don't need to add these
			-- dependents, because they don't need processing.
			if didChange and member.dependentSet ~= nil then
				for dependent in pairs(member.dependentSet) do
					-- don't add dependents that have un-updated dependencies
					local allDependenciesUpdated = true
					for dependentDependency in pairs(dependent.dependencySet) do
						if needsUpdateSet[dependentDependency] then
							allDependenciesUpdated = false
							break
						end
					end

					if allDependenciesUpdated then
						processNextSize += 1
						processNext[processNextSize] = dependent
						processingDone = false
					end
				end
			end
		end

		if not processingDone then
			-- swap in the next dependents to be processed
			processNow, processNext = processNext, processNow
			processNowSize, processNextSize = processNextSize, 0
			table.clear(processNext)
		end
	until processingDone

	--[[
		The update is now complete!
	]]
end

return updateAll


Prompt: --	W.C0 = C0

Response:
	--W.C1 = C1
	W.Parent = x

end

local anim = nil
local handle = nil
local namehide = Instance.new("BoolValue")
namehide.Name = "HideName"
			handle = Tool.Handle

Tool.Equipped:connect(function()

			Tool.Handle.Sound:Play()
			handle.Parent = char
			weldTogether(handle, char.Torso)
			namehide.Parent = hum.Effects
			if anim ~= nil then
				anim:Stop()
			end
			anim = hum:LoadAnimation(script.BoxHide)
			anim:Play()

end)

Tool.Unequipped:connect(function()
		if anim ~= nil then
				anim:Stop()
		end
		handle.Parent = Tool
		namehide.Parent = nil

end)


Response:
local FOV = 10					-- HOW MUCH YOU WANT CAMERA TO ZOOM IN.  70 IS DEFAULT.  SMALLER NUMBER = MORE ZOOM
local cooldowntime = .0		-- HOW LONG BEFORE THEY CAN ZOOM IN/OUT AGAIN.
local KEYBIND = Enum.KeyCode.R	-- CHANGE E TO WHATEVER KEY YOU WANT THEM TO PRESS TO ZOOM.


Prompt: --// Services

Response:
local L_98_ = game:GetService('RunService').RenderStepped
local L_99_ = game:GetService('UserInputService')


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

Response:
local v1 = {};
local v2 = {};
v2.__index = v2;
function v2.GetInstance(p1, p2)
	if p1.InstancePoolsByClass[p2] == nil then
		p1.InstancePoolsByClass[p2] = {};
	end;
	local v3 = #p1.InstancePoolsByClass[p2];
	if not (v3 > 0) then
		return Instance.new(p2);
	end;
	table.remove(p1.InstancePoolsByClass[p2]);
	return p1.InstancePoolsByClass[p2][v3];
end;
function v2.ReturnInstance(p3, p4)
	if p3.InstancePoolsByClass[p4.ClassName] == nil then
		p3.InstancePoolsByClass[p4.ClassName] = {};
	end;
	if not (#p3.InstancePoolsByClass[p4.ClassName] < p3.PoolSizePerType) then
		p4:Destroy();
		return;
	end;
	table.insert(p3.InstancePoolsByClass[p4.ClassName], p4);
end;
function v1.new(p5)
	local v4 = setmetatable({}, v2);
	v4.InstancePoolsByClass = {};
	v4.Name = "ObjectPool";
	v4.PoolSizePerType = p5;
	return v4;
end;
return v1;


Prompt:
--[[This is the main teleporter script. From here we find the other teleporter, tell all clients to
	do a funky animation effect and teleport the player.
]]


Response:
local tool = script.Parent
local player = game.Players.LocalPlayer
while player.Character == nil do wait() end
local char = player.Character
while char:FindFirstChild("Humanoid") == nil do wait() end
local hum = char:FindFirstChild("Humanoid")
local mouse = player:GetMouse()

local going = false
local enabled = true
local equipped = false

function stoppedGoing(mouse)
	if going then
		going = false
		script.Parent.Stopped:FireServer()
		wait(RELOAD_TIME)
		if equipped then
			mouse.Icon = "rbxasset://textures\\GunCursor.png"
		end
		enabled = true
	end
end

tool.Selected:connect(function(mouse)
	equipped = true
	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	mouse.Button1Down:connect(function()
		if hum == nil then return end
		if hum.Health <= 0 then return end
		if mouse == nil then return end
		if enabled then
			if not going then
				if mouse.Hit ~= nil then
					enabled = false
					going = true
					script.Parent.Start:FireServer(mouse.Hit.p)
					mouse.Icon = "rbxasset://textures\\GunWaitCursor.png"
				end
			end
		end
	end)
	mouse.Button1Up:connect(function()
		stoppedGoing(mouse)
	end)
end)

tool.Deselected:connect(function()
	equipped = false
	stoppedGoing(mouse)
end)


Prompt:
--SigmaTech converted this script to a Module script
--Script was originally broken because ROBLOX discontinues Hopper Bins


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

Response:
local DebrisService = Game:GetService('Debris')
local PlayersService = Game:GetService('Players')

local MyPlayer = PlayersService.LocalPlayer

local Tool = script.Parent
local ToolHandle = Tool.Handle

local RocketScript = WaitForChild(script, 'Rocket')
local SwooshSound = WaitForChild(script, 'Swoosh')
local BoomSound = WaitForChild(script, 'Boom')


Prompt: -- constants

Response:
local PLAYER	= Players.LocalPlayer

return function(character)
	local rootPart	= character.UpperTorso

	for _, v in pairs(character:GetDescendants()) do
		if v:IsA("BasePart") then
			v.Transparency	= 1
		elseif v:IsA("Decal") then
			v.Transparency	= 1
		end
	end

	local emitter	= script.TicketEmitter:Clone()
		emitter.Parent	= rootPart

	emitter:Emit(60)
end


Prompt: --Player leaving > save data and remove server data about player

Response:
function module:RemovePlayerData(player)
	if main.pd[player] then
		savePlayerData(player, true)
	end
	main.pd[player] = nil
end


Prompt: -- Simulate a hitscan

Response:
local function SimulateHitscan(cast: ActiveCast, origin: Vector3, direction: Vector3, initialVelocity: Vector3, distance: number)
	local targetWorldRoot = cast.RayInfo.WorldRoot
	local resultOfCast = targetWorldRoot:Raycast(origin, direction * distance, cast.RayInfo.Parameters)
	local point = origin + direction * distance
	local part: Instance? = nil
	local material = Enum.Material.Air
	local normal = Vector3.new()
	if resultOfCast then
		point = resultOfCast.Position
		part = resultOfCast.Instance
		material = resultOfCast.Material
		normal = resultOfCast.Normal
	end
	table.insert(cast.StateInfo.TweenTable, {
		origin = origin,
		direction = CFrame.new(origin, point),
		lastPoint = origin,
		s = 0,
		ready = false,
		l = (origin - point).Magnitude
	})
	if part and part ~= cast.RayInfo.CosmeticBulletObject then
		if cast.RayInfo.CanPenetrateCallback == nil or (cast.RayInfo.CanPenetrateCallback ~= nil and cast.RayInfo.CanPenetrateCallback(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject) == false) then
			PrintDebug("Penetrating function is nil or it returned FALSE to not penetrate this hit.")

			if cast.RayInfo.CanHitCallback == nil or (cast.RayInfo.CanHitCallback ~= nil and cast.RayInfo.CanHitCallback(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject) == false) then
				PrintDebug("Hit was successful. Terminating.")
				SendRayFinalHit(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject)
				DbgVisualizeHit(CFrame.new(point), false)
			else
				SendRayHit(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject) -- This may result in CancelHighResCast being set to true.
				local vis = DbgVisualizeHit(CFrame.new(point), true)
				if (vis ~= nil) then vis.Color3 = Color3.new(1, 0.113725, 0.588235) end
				SimulateHitscan(cast, point, cast.RayInfo.ModifiedDirection, initialVelocity, distance)
			end
		else
			PrintDebug("Penetrating function returned TRUE to penetrate this part.")
			DbgVisualizeHit(CFrame.new(point), true)

			local params = cast.RayInfo.Parameters
			local alteredParts = {}
			local currentPenetrationTestCount = 0
			local originalFilter = params.FilterDescendantsInstances
			local brokeFromSolidObject = false

			while true do
				-- So now what I need to do is redo this entire cast, just with the new filter list

				-- Catch case: Is it terrain?
				if resultOfCast.Instance:IsA("Terrain") then
					if material == Enum.Material.Water then
						-- Special case: Penetrated on water?
						cast:Terminate()
						error("Do not add Water as a piercable material. If you need to penetrate water, set cast.RayInfo.Parameters.IgnoreWater = true instead", 0)
					end
					warn("WARNING: The penetrate callback for this cast returned TRUE on Terrain! This can cause severely adverse effects.")
				end

				if params.FilterType == Enum.RaycastFilterType.Blacklist then
					-- blacklist
					-- DO NOT DIRECTLY TABLE.INSERT ON THE PROPERTY
					local filter = params.FilterDescendantsInstances
					table.insert(filter, resultOfCast.Instance)
					table.insert(alteredParts, resultOfCast.Instance)
					params.FilterDescendantsInstances = filter
				else
					-- whitelist
					-- method implemeneted by custom table system
					-- DO NOT DIRECTLY TABLE.REMOVEOBJECT ON THE PROPERTY
					local filter = params.FilterDescendantsInstances
					table.removeObject(filter, resultOfCast.Instance)
					table.insert(alteredParts, resultOfCast.Instance)
					params.FilterDescendantsInstances = filter
				end

				-- List has been updated, so let's cast again.
				resultOfCast = targetWorldRoot:Raycast(origin, direction, params)

				-- No hit? No simulation. Break.
				if resultOfCast == nil then
					break
				end

				if currentPenetrationTestCount >= MAX_PENETRATION_TEST_COUNT then
					warn("WARNING: Exceeded maximum penetrate test budget for a single ray segment (attempted to test the same segment " .. MAX_PENETRATION_TEST_COUNT .. " times!)")
					break
				end
				currentPenetrationTestCount = currentPenetrationTestCount + 1;

				if cast.RayInfo.CanPenetrateCallback(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject) == false then
					brokeFromSolidObject = true
					break
				end
			end

			-- Restore the filter to its default state.
			cast.RayInfo.Parameters.FilterDescendantsInstances = originalFilter

			if brokeFromSolidObject then
				if cast.RayInfo.CanHitCallback == nil or (cast.RayInfo.CanHitCallback ~= nil and cast.RayInfo.CanHitCallback(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject) == false) then
					PrintDebug("Broke because the ray hit something solid (" .. tostring(resultOfCast.Instance) .. ") while testing for a penetration. Terminating the cast.")
					SendRayFinalHit(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject)
					DbgVisualizeHit(CFrame.new(resultOfCast.Position), false)
				else
					-- Recalculating hit something hittable instead.
					SendRayHit(cast, origin, direction, resultOfCast, initialVelocity, cast.RayInfo.CosmeticBulletObject) -- This may result in CancelHighResCast being set to true.
					local vis = DbgVisualizeHit(CFrame.new(point), true)
					if (vis ~= nil) then vis.Color3 = Color3.new(1, 0.113725, 0.588235) end
					SimulateHitscan(cast, point, cast.RayInfo.ModifiedDirection, initialVelocity, distance)
				end
			else
				SimulateHitscan(cast, point + (direction * 0.01), direction, initialVelocity, distance - ((origin - point).Magnitude))
			end

			-- And exit the function here too.
		end
	end
end


Prompt:
--[[
	ROBLOX deviation: ReactFiberHostConfig captures singleton state across the
	whole workspace. This file and the modules it requires were moved from React
	to untangle a cyclic workspace member dependency.

	Before:
	* ReactFiberHostConfig (and the 5 associated modules) lived in React
	* React had a dependency on Shared
	* Shared reached into React source to re-export ReactFiberHostConfig (cycle)

	After:
	* ReactFiberHostConfig (and the 5 associated modules) live in Shared
	* React depends on Shared
	* Shared has no intra-workspace dependencies (no cycles)
]]


Prompt: --// Animations

Response:
local L_165_

function IdleAnim(L_335_arg1)
	L_24_.IdleAnim(L_3_, L_165_, {
		L_45_,
		L_46_,
		L_47_
	});
end;

function EquipAnim(L_336_arg1)
	L_24_.EquipAnim(L_3_, L_165_, {
		L_45_
	});
end;

function UnequipAnim(L_337_arg1)
	L_24_.UnequipAnim(L_3_, L_165_, {
		L_45_
	});
end;

function FireModeAnim(L_338_arg1)
	L_24_.FireModeAnim(L_3_, L_165_, {
		L_45_,
		L_47_,
		L_46_,
		L_55_
	});
end

function ReloadAnim(L_339_arg1)
	L_24_.ReloadAnim(L_3_, L_165_, {
		L_45_,
		L_46_,
		L_47_,
		L_58_,
		L_3_:WaitForChild('Left Arm'),
		L_55_,
		L_49_,
		L_3_:WaitForChild('Right Arm'),
		L_43_
	});
end;

function BoltingBackAnim(L_340_arg1)
	L_24_.BoltingBackAnim(L_3_, L_165_, {
		L_49_
	});
end

function BoltingForwardAnim(L_341_arg1)
	L_24_.BoltingForwardAnim(L_3_, L_165_, {
		L_49_
	});
end

function BoltingForwardAnim(L_342_arg1)
	L_24_.BoltingForwardAnim(L_3_, L_165_, {
		L_49_
	});
end

function BoltBackAnim(L_343_arg1)
	L_24_.BoltBackAnim(L_3_, L_165_, {
		L_49_,
		L_47_,
		L_46_,
		L_45_,
		L_59_
	});
end

function BoltForwardAnim(L_344_arg1)
	L_24_.BoltForwardAnim(L_3_, L_165_, {
		L_49_,
		L_47_,
		L_46_,
		L_45_,
		L_59_
	});
end

function InspectAnim(L_345_arg1)
	L_24_.InspectAnim(L_3_, L_165_, {
		L_47_,
		L_46_
	});
end

function nadeReload(L_346_arg1)
	L_24_.nadeReload(L_3_, L_165_, {
		L_46_,
		L_47_
	});
end

function AttachAnim(L_347_arg1)
	L_24_.AttachAnim(L_3_, L_165_, {
		L_46_,
		L_47_
	});
end

function PatrolAnim(L_348_arg1)
	L_24_.PatrolAnim(L_3_, L_165_, {
		L_46_,
		L_47_
	});
end


Prompt: --Connect our event. The function wants to know the start and end teleporter, and the part that triggered the teleport.

Response:
networking.StartEffect.OnClientEvent:connect(function(part,tele1,tele2)
	local parts = {}
	getAssemblyParts(part,parts) --Get the entire assembly

	local soundPart1 = tele1:clone()
	soundPart1.Transparency = 1
	soundPart1.Parent = camera

	local soundPart2 = tele2:clone()
	soundPart2.Transparency = 1
	soundPart2.Parent = camera

	soundPart1.Teleport:play()
	soundPart2.Teleport:play()

	local effect1 = {}
	local effect2 = {}

	for _,pt in pairs(parts) do
		local part = pt:clone()
		part.Anchored = true
		part.CanCollide = false
		part.Transparency = 1
		part.Material = Enum.Material.Neon
		pcall(function() part.FormFactor = Enum.FormFactor.Custom end)
		part.Size = part.Size * 1.1
		part.Parent = camera
		effect1[part] = pt.CFrame

		local part = pt:clone()
		part.Anchored = true
		part.CanCollide = false
		part.Transparency = 1
		part.Material = Enum.Material.Neon
		pcall(function() part.FormFactor = Enum.FormFactor.Custom end)
		part.Size = part.Size * 1.1
		part.Parent = camera
		effect2[part] = tele2.CFrame * tele1.CFrame:toObjectSpace(pt.CFrame)
	end

	local start = tick()
	while tick() < start+4 do
		wait()
		local t = tick()-start
		local x = t*(2.31/4)

		local trans = -0.7*x^3 + 2.6*x^2 - 2.7*x + 1
		tele1.Parent.Glow.Transparency = 1 - math.pow((x - 2.25) / 2.25,2)
		tele2.Parent.Glow.Transparency = 1 - math.pow((x - 2.25) / 2.25,2)

		for k,v in pairs(effect1) do
			k.CFrame = v
			k.Transparency = trans
		end
		for k,v in pairs(effect2) do
			k.CFrame = v
			k.Transparency = trans
		end
	end
	local tele1color = tele1.Parent.Glow.BrickColor
	local tele2color = tele2.Parent.Glow.BrickColor

	tele1.Parent.Glow.BrickColor = BrickColor.new("Pastel light blue")
	tele2.Parent.Glow.BrickColor = BrickColor.new("Pastel light blue")

	wait(0.05)

	tele1.Parent.Glow.BrickColor = tele1color
	tele2.Parent.Glow.BrickColor = tele2color

	wait(0.45)

	local start = tick()
	while tick() < start+1 do
		wait()
		local t = tick()-start
		local trans = t

		tele1.Parent.Glow.Transparency = 1-t

		for k,v in pairs(effect1) do
			k.Size = k.Size * 1.01
			k.CFrame = v
			k.Transparency = trans
		end
		for k,v in pairs(effect2) do
			k.Size = k.Size * 1.01
			k.CFrame = v
			k.Transparency = trans
		end
	end

	for k,v in pairs(effect1) do k:Destroy() end
	for k,v in pairs(effect2) do k:Destroy() end

	tele1.Parent.Glow.Transparency = 0

	soundPart1:Destroy()
	soundPart2:Destroy()
end)


Prompt: -- custom font class (this is what the player interacts with)

Response:
local customFont = {};

function customFont.new(fontName, class, isButton)
	local self = event.new {};

	local exists = not (type(class) == "string");
	local child = exists and class or instance(class);
	local fontModule = fonts:FindFirstChild(fontName);
	--local folder = instance("Folder", child);

	local settings = settings.new(require(aa), self, child);
	settings:preload();

	local events = {};
	local properties = {};
	local propertyobjects = {};
	local drawncharacters = {};

	self.FontName = fontName;
	self.Style = settings.style;
	self.TextTransparency = child.TextTransparency;
	self.TextStrokeTransparency = child.TextStrokeTransparency;
	self.BackgroundTransparency = child.BackgroundTransparency;
	self.TextFits = false;

	-- create the physical representation of the custom properties
	for name, _ in next, customProperties do
		local property = self[name];
		local t = type(property);
		local className = upper(sub(t, 1, 1)) .. sub(t, 2) .. "Value";
		local physicalProperty = Instance.new(className, child);

		physicalProperty.Name = name;
		physicalProperty.Value = property;

		physicalProperty.Changed:connect(function(newValue)
			self[name] = newValue;
		end);

		propertyobjects[physicalProperty.Name] = physicalProperty;
		properties[physicalProperty] = true;
	end;

	local background = newBackground(child, isButton and "TextButton");
	defaultHide(child);

	-- common function

	local function drawText()
		background:ClearAllChildren();
		drawncharacters = drawLines(child.Text, settings, background);
	end;

	-- custom events

	self:connect("FontName", function(value) drawText(); end);
	self:connect("TextStrokeTransparency", function(value) drawText(); end);

	self:connect("BackgroundTransparency", function(value)
		background.BackgroundTransparency = value;
	end);

	self:connect("Style", function(value)
		settings.style = value;
		propertyobjects["Style"].Value = value;
		drawText();
	end);

	self:connect("TextTransparency", function(value)
		for i = 1, #drawncharacters do
			drawncharacters[i].ImageTransparency = value;
		end;
	end);

	self:connect("FontName", function(value)
		local fontModule = fonts:FindFirstChild(value);
		settings = settings.new(require(aa), self, child);
		settings:preload();
		propertyobjects["FontName"].Value = value;
		if (not child.TextScaled) then
			settings.size = child.TextSize;
		end;
		settings.style = self.Style;
		drawText();
	end);

	-- real events

	insert(events, child.Changed:connect(function(property)
		if (overwrites[property]) then
			if (child[property] ~= 2) then
				self[property] = child[property]
			end;
			child[property] = 2;
		elseif (property == "TextSize") then
			settings.size = child[property];
			drawText();
		elseif (property == "TextColor3") then
			for _, sprite in next, drawncharacters do
				sprite.ImageColor3 = child[property];
			end;
		elseif (property == "ZIndex") then
			background.ZIndex = child[property];
			for _, sprite in next, drawncharacters do
				sprite.ZIndex = child[property];
			end;
		elseif (property == "Text") then
			drawText();
		elseif (redraws[property]) then
			if (property == "TextScaled" and not child[property]) then
				settings.size = child.TextSize;
			end;
			drawText();
		elseif (not match(property, "Text") and not noReplicate[property]) then
			pcall(function() background[property] = child[property]; end);
		end;
	end));

	if (child:IsA("TextBox")) then
		insert(events, child.Focused:connect(function()
			if (child.ClearTextOnFocus) then
				child.Text = "";
			end;
		end));
	end;

	-- methods

	function self:Revert()
		for _, property in next, propertyobjects do property:Destroy(); end;
		for _, event in next, events do event:disconnect(); end;
		background:Destroy();
		child.TextTransparency = self.TextTransparency;
		child.BackgroundTransparency = self.BackgroundTransparency;
		self, properties, propertyobjects, events = nil, nil, nil, nil;
		return child;
	end;

	function self:GetChildren()
		local children = {};
		for _, kid in next, child:GetChildren() do
			if (kid ~= background and not properties[kid]) then
				insert(children, kid);
			end;
		end;
		return children;
	end;

	function self:ClearAllChildren()
		for _, kid in next, child:GetChildren() do
			if (kid ~= background and not properties[kid]) then
				kid:Destroy();
			end;
		end;
	end;

	function self:Destroy()
		self:Revert():Destroy();
	end;

	-- return
	drawText();
	return wrapper(child, self);
end;


Prompt: --//hood

Response:
local hd = Instance.new("Motor", script.Parent.Parent.Misc.HD.SS)
hd.MaxVelocity = 0.03
hd.Part0 = script.Parent.HD
hd.Part1 = hd.Parent


Prompt: -- Existance in this list signifies that it is an emote, the value indicates if it is a looping emote

Response:
local emoteNames = { wave = false, point = false, dance = true, dance2 = true, dance3 = true, laugh = false, cheer = false}

local PreloadAnimsUserFlag = false
local PreloadedAnims = {}
local successPreloadAnim, msgPreloadAnim = pcall(function()
	PreloadAnimsUserFlag = UserSettings():IsUserFeatureEnabled("UserPreloadAnimations")
end)
if not successPreloadAnim then
	PreloadAnimsUserFlag = false
end

math.randomseed(tick())

function findExistingAnimationInSet(set, anim)
	if set == nil or anim == nil then
		return 0
	end

	for idx = 1, set.count, 1 do
		if set[idx].anim.AnimationId == anim.AnimationId then
			return idx
		end
	end

	return 0
end

function configureAnimationSet(name, fileList)
	if (animTable[name] ~= nil) then
		for _, connection in pairs(animTable[name].connections) do
			connection:disconnect()
		end
	end
	animTable[name] = {}
	animTable[name].count = 0
	animTable[name].totalWeight = 0
	animTable[name].connections = {}

	local allowCustomAnimations = true

	local success, msg = pcall(function() allowCustomAnimations = game:GetService("StarterPlayer").AllowCustomAnimations end)
	if not success then
		allowCustomAnimations = true
	end

	-- check for config values
	local config = script:FindFirstChild(name)
	if (allowCustomAnimations and config ~= nil) then
		table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
		table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))

		local idx = 0
		for _, childPart in pairs(config:GetChildren()) do
			if (childPart:IsA("Animation")) then
				local newWeight = 1
				local weightObject = childPart:FindFirstChild("Weight")
				if (weightObject ~= nil) then
					newWeight = weightObject.Value
				end
				animTable[name].count = animTable[name].count + 1
				idx = animTable[name].count
				animTable[name][idx] = {}
				animTable[name][idx].anim = childPart
				animTable[name][idx].weight = newWeight
				animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
				table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
				table.insert(animTable[name].connections, childPart.ChildAdded:connect(function(property) configureAnimationSet(name, fileList) end))
				table.insert(animTable[name].connections, childPart.ChildRemoved:connect(function(property) configureAnimationSet(name, fileList) end))
			end
		end
	end

	-- fallback to defaults
	if (animTable[name].count <= 0) then
		for idx, anim in pairs(fileList) do
			animTable[name][idx] = {}
			animTable[name][idx].anim = Instance.new("Animation")
			animTable[name][idx].anim.Name = name
			animTable[name][idx].anim.AnimationId = anim.id
			animTable[name][idx].weight = anim.weight
			animTable[name].count = animTable[name].count + 1
			animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
		end
	end

	-- preload anims
	if PreloadAnimsUserFlag then
		for i, animType in pairs(animTable) do
			for idx = 1, animType.count, 1 do
				if PreloadedAnims[animType[idx].anim.AnimationId] == nil then
					Humanoid:LoadAnimation(animType[idx].anim)
					PreloadedAnims[animType[idx].anim.AnimationId] = true
				end
			end
		end
	end
end


Prompt: -- Hook up CreateIndicator bindable function

Response:
bfCreateIndicator.OnInvoke = function (position, time, radius)
	assert(position, "requires arg #1 position")
	assert(time, "requires arg #2 time")
	assert(radius, "requires arg #3 radius")
	return Indicator:new{time = time; position = position; radius = radius}
end


Prompt:
--[=[
	@param serviceName string
	@return Service
	Gets the service by name. Throws an error if the service is not found.
]=]

Response:
function KnitServer.GetService(serviceName: string): Service
	assert(type(serviceName) == "string", "ServiceName must be a string; got " .. type(serviceName))
	return assert(services[serviceName], "Could not find service \"" .. serviceName .. "\"") :: Service
end


Prompt:
--[[
	Fired when state is left
]]

Response:
function Transitions.onLeavePreGame(stateMachine, event, from, to)
	ServerPreGame.leave(stateMachine)
end


Prompt:
--create the dustcloud object
--[[local prt = Instance.new("Part")
prt.Size = Vector3.new(1,1,1)
prt.BrickColor = BrickColor.new(217)
prt.Anchored = true
prt.CanCollide = false
script.Parent.CloudMesh.Parent = prt]]
--[[local msh = Instance.new("SpecialMesh")
msh.MeshId = "http://www.roblox.com/asset/?id=1095708"
msh.MeshType = 5
msh.Parent = prt]]

Response:
function WaitForChild(obj, ch_n)
	local t = time()
	while not obj:FindFirstChild(ch_n) and time() - t < 10 do wait(0.1) end
	return obj:FindFirstChild(ch_n)
end


Prompt: -- connect up

Response:
function stopLoopedSounds()
	sRunning:Stop()
	sClimbing:Stop()
	sSwimming:Stop()
end

Humanoid.Died:connect(onDied)
Humanoid.Running:connect(onRunning)
Humanoid.Swimming:connect(onSwimming)
Humanoid.Climbing:connect(onClimbing)
Humanoid.Jumping:connect(function(state) onStateNoStop(state, sJumping) prevState = "Jump" end)
Humanoid.GettingUp:connect(function(state) stopLoopedSounds() onStateNoStop(state, sGettingUp) prevState = "GetUp" end)
Humanoid.FallingDown:connect(function(state) stopLoopedSounds() onStateNoStop(state, sFallingDown) prevState = "Falling" end)
Humanoid.StateChanged:connect(function(old, new)
	if not (new.Name == "Dead" or
			new.Name == "Running" or
			new.Name == "RunningNoPhysics" or
			new.Name == "Swimming" or
			new.Name == "Jumping" or
			new.Name == "GettingUp" or
			new.Name == "FallingDown") then
		stopLoopedSounds()
	end
end)


Prompt:
--[[
	CameraModule - This ModuleScript implements a singleton class to manage the
	selection, activation, and deactivation of the current camera controller,
	character occlusion controller, and transparency controller. This script binds to
	RenderStepped at Camera priority and calls the Update() methods on the active
	controller instances.

	The camera controller ModuleScripts implement classes which are instantiated and
	activated as-needed, they are no longer all instantiated up front as they were in
	the previous generation of PlayerScripts.

	2018 PlayerScripts Update - AllYourBlox
--]]

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

local FFlagUserRemoveTheCameraApi do
	local success, result = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserRemoveTheCameraApi")
	end)
	FFlagUserRemoveTheCameraApi = success and result
end


Prompt:
---------------
--// Functions
---------------

Response:
local function resetGUI()
	for i,v in pairs(script.Parent:GetChildren()) do
		if v:IsA("Frame") and v.Name ~= "Template" and v.Name ~= "A" then
			v:Destroy()
		end
	end
end

local function loadGUI(plr)
	for i,v in pairs(Players:GetPlayers()) do
		local clone = script.Parent.Template:Clone()
		clone.Parent = script.Parent
		clone.Name = ""
		clone.ImageLabel.Image = "rbxthumb://type=AvatarHeadShot&id="..plr.UserId.."&w=150&h=150"
		clone.Usernaame.Text = v.Name
		clone.TextButton.MouseButton1Down:Connect(function()
			if debounce == false then
				debounce = true
				local plot = workspace.Plots.Plot:FindFirstChild("Plot"..plr:GetAttribute("Plot"))
				local tween = TweenService:Create(LocalPlayer.Character.HumanoidRootPart, TweenInfo.new(.1), {["CFrame"] = plot.Pos.CFrame, })
				tween:Play()
				tween.Completed:Wait()
				task.wait(.5)
				debounce = false
			end
		end)
	end
end

local function updateGUI()
	resetGUI()
	loadGUI()
end


Prompt:
-- How many velocities we want to store in our velocity history. Each velocity is stored per frame.
-- Used to ensure we have a correct recent velocity.

Response:
local MAX_VELOCITY_HISTORY_COUNT = 5

local previousVelocities = {}

local function getAverageVelocity()
	local averageVelocity = Vector3.new()

	for _, v in pairs(previousVelocities) do
		averageVelocity = averageVelocity + v
	end

	averageVelocity = averageVelocity / #previousVelocities
	return averageVelocity
end

local counter = 1


Prompt: --Gets called on both client and server

Response:
function ChickynoidStyle:Setup(simulation)

    --Dont need to set anything, the defaults should basically be this
end

return ChickynoidStyle


Prompt:
-- Replacements for RootCamera:RotateCamera() which did not actually rotate the camera
-- suppliedLookVector is not normally passed in, it's used only by Watch camera

Response:
function BaseCamera:CalculateNewLookCFrame(suppliedLookVector)
	local currLookVector = suppliedLookVector or self:GetCameraLookVector()
	local currPitchAngle = math.asin(currLookVector.y)
	local yTheta = Util.Clamp(-MAX_Y + currPitchAngle, -MIN_Y + currPitchAngle, self.rotateInput.y)
	local constrainedRotateInput = Vector2.new(self.rotateInput.x, yTheta)
	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
	local newLookCFrame = CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)
	return newLookCFrame
end
function BaseCamera:CalculateNewLookVector(suppliedLookVector)
	local newLookCFrame = self:CalculateNewLookCFrame(suppliedLookVector)
	return newLookCFrame.lookVector
end

function BaseCamera:CalculateNewLookVectorVR()
	local subjectPosition = self:GetSubjectPosition()
	local vecToSubject = (subjectPosition - game.Workspace.CurrentCamera.CFrame.p)
	local currLookVector = (vecToSubject * X1_Y0_Z1).unit
	local vrRotateInput = Vector2.new(self.rotateInput.x, 0)
	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
	local yawRotatedVector = (CFrame.Angles(0, -vrRotateInput.x, 0) * startCFrame * CFrame.Angles(-vrRotateInput.y,0,0)).lookVector
	return (yawRotatedVector * X1_Y0_Z1).unit
end

function BaseCamera:GetHumanoid()
	local player = Players.LocalPlayer
	local character = player and player.Character
	if character then
		local resultHumanoid = self.humanoidCache[player]
		if resultHumanoid and resultHumanoid.Parent == character then
			return resultHumanoid
		else
			self.humanoidCache[player] = nil -- Bust Old Cache
			local humanoid = character:FindFirstChildOfClass("Humanoid")
			if humanoid then
				self.humanoidCache[player] = humanoid
			end
			return humanoid
		end
	end
	return nil
end

function BaseCamera:GetHumanoidPartToFollow(humanoid, humanoidStateType)
	if humanoidStateType == Enum.HumanoidStateType.Dead then
		local character = humanoid.Parent
		if character then
			return character:FindFirstChild("Head") or humanoid.Torso
		else
			return humanoid.Torso
		end
	else
		return humanoid.Torso
	end
end

function BaseCamera:UpdateGamepad()
	local gamepadPan = self.gamepadPanningCamera
	if gamepadPan and (self.hasGameLoaded or not VRService.VREnabled) then
		gamepadPan = Util.GamepadLinearToCurve(gamepadPan)
		local currentTime = tick()
		if gamepadPan.X ~= 0 or gamepadPan.Y ~= 0 then
			self.userPanningTheCamera = true
		elseif gamepadPan == ZERO_VECTOR2 then
			self.lastThumbstickRotate = nil
			if self.lastThumbstickPos == ZERO_VECTOR2 then
				self.currentSpeed = 0
			end
		end

		local finalConstant = 0

		if self.lastThumbstickRotate then
			if VRService.VREnabled then
				self.currentSpeed = self.vrMaxSpeed
			else
				local elapsedTime = (currentTime - self.lastThumbstickRotate) * 10
				self.currentSpeed = self.currentSpeed + (self.maxSpeed * ((elapsedTime*elapsedTime)/self.numOfSeconds))

				if self.currentSpeed > self.maxSpeed then self.currentSpeed = self.maxSpeed end

				if self.lastVelocity then
					local velocity = (gamepadPan - self.lastThumbstickPos)/(currentTime - self.lastThumbstickRotate)
					local velocityDeltaMag = (velocity - self.lastVelocity).magnitude

					if velocityDeltaMag > 12 then
						self.currentSpeed = self.currentSpeed * (20/velocityDeltaMag)
						if self.currentSpeed > self.maxSpeed then self.currentSpeed = self.maxSpeed end
					end
				end
			end

			finalConstant = UserGameSettings.GamepadCameraSensitivity * self.currentSpeed
			self.lastVelocity = (gamepadPan - self.lastThumbstickPos)/(currentTime - self.lastThumbstickRotate)
		end

		self.lastThumbstickPos = gamepadPan
		self.lastThumbstickRotate = currentTime

		return Vector2.new( gamepadPan.X * finalConstant, gamepadPan.Y * finalConstant * self.ySensitivity * UserGameSettings:GetCameraYInvertValue())
	end

	return ZERO_VECTOR2
end


Prompt: --// Graphing functions \\--

Response:
local function graphPoint(t : number, ... : Vector3) : Vector3
	assert(t >= 0 and t <= 1, t .. "t is not between 0 and 1.")
	local points = {...}
	local n : number = #points - 1
	local p : Vector3 = nil
	for i = 0, n do
		local x = binomial(n,i)*(1 - t)^(n-i) * t^i * points[i+1]
		p = p and p + x or x
	end
	return p
end


Prompt: --[[[Default Controls]]

Response:
	--Peripheral Deadzones
	Tune.Peripherals = {
		MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
		MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)

		ControlLDZone			= 5			,	-- Controller steering L-deadzone (0 - 100%)
		ControlRDZone			= 5			,	-- Controller steering R-deadzone (0 - 100%)
	}

	--Control Mapping
	Tune.Controls = {

	--Keyboard Controls
		--Mode Toggles
		ToggleTCS				= Enum.KeyCode.T					,
		ToggleABS				= Enum.KeyCode.Y					,
		ToggleTransMode			= Enum.KeyCode.M					,
		ToggleMouseDrive		= Enum.KeyCode.R					,

		--Primary Controls
		Throttle				= Enum.KeyCode.W					,
		Brake					= Enum.KeyCode.S					,
		SteerLeft				= Enum.KeyCode.A					,
		SteerRight				= Enum.KeyCode.D   				    ,

		--Secondary Controls
		Throttle2				= Enum.KeyCode.B 					,
		Brake2					= Enum.KeyCode.N					,
		SteerLeft2				= Enum.KeyCode.M 	 				,
		SteerRight2				= Enum.KeyCode.V					,

		--Manual Transmission
		ShiftUp					= Enum.KeyCode.E					,
		ShiftDown				= Enum.KeyCode.Q					,
		Clutch					= Enum.KeyCode.LeftShift     			,

		--Handbrake
		PBrake					= Enum.KeyCode.P			,

	--Mouse Controls
		MouseThrottle			= Enum.UserInputType.MouseButton1	,
		MouseBrake				= Enum.UserInputType.MouseButton2	,
		MouseClutch				= Enum.KeyCode.W					,
		MouseShiftUp			= Enum.KeyCode.E					,
		MouseShiftDown			= Enum.KeyCode.Q					,
		MousePBrake				= Enum.KeyCode.LeftShift			,

	--Controller Mapping
		ContlrThrottle			= Enum.KeyCode.ButtonR2				,
		ContlrBrake				= Enum.KeyCode.ButtonL2				,
		ContlrSteer				= Enum.KeyCode.Thumbstick1			,
		ContlrShiftUp			= Enum.KeyCode.ButtonY				,
		ContlrShiftDown			= Enum.KeyCode.ButtonX				,
		ContlrClutch			= Enum.KeyCode.ButtonR1				,
		ContlrPBrake			= Enum.KeyCode.ButtonL1				,
		ContlrToggleTMode		= Enum.KeyCode.DPadUp				,
		ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
		ContlrToggleABS			= Enum.KeyCode.DPadRight			,
	}


Prompt: -- Bind tool events

Response:
Tool.Equipped:connect(equip)
Tool.Unequipped:connect(unequip)


Prompt:
---Misfire reduces turbo Lag when it happens and also might increace your car boost -----
----Misfire advanced settings are in it's own plugin
--- Messing with them is at your own risk only do if you know how things work :spicy:
---Come back In the next version For SuperCharger Support Maybe ----
--[[Misc]]

Response:
	Tune.LoadDelay		= .1		-- Delay before initializing chassis (in seconds)
	Tune.AutoStart		= true		-- Set to false if using manual ignition plugin
	Tune.AutoFlip		= true		-- Set to false if using manual flip plugin


Prompt: --// Probabilities

Response:
	JamChance = 0; -- This is percent scaled. For 100% Chance of jamming, put 100, for 0%, 0; and everything inbetween
	TracerChance = 17; -- This is the percen scaled. For 100% Chance of showing tracer, put 100, for 0%, 0; and everything inbetween


Prompt: --	print("CurrentAnim ", currentAnim, " ", frameName)

Response:
	if (frameName == "End") then
		if currentAnim == "walk" then
			runAnimTrack.TimePosition = 0.0
			currentAnimTrack.TimePosition = 0.0
		else
	--		print("Keyframe : ".. frameName)

			local repeatAnim = currentAnim
			-- return to idle if finishing an emote
			if (emoteNames[repeatAnim] ~= nil and emoteNames[repeatAnim] == false) then
				repeatAnim = "idle"
			end

			local animSpeed = currentAnimSpeed
			playAnimation(repeatAnim, 0.15, Humanoid)
			setAnimationSpeed(animSpeed)
		end
	end
end

function rollAnimation(animName)
	local roll = math.random(1, animTable[animName].totalWeight)
	local origRoll = roll
	local idx = 1
	while (roll > animTable[animName][idx].weight) do
		roll = roll - animTable[animName][idx].weight
		idx = idx + 1
	end
	return idx
end

function playToyAnimation(AnimName)
	local ToyObject = Figure:FindFirstChild("Toy");

	if ( ToyObject and ToyObject:FindFirstChild("AnimationController") ) then

		local AnimController = ToyObject.AnimationController;
		local AnimObject = ToyObject.AnimationObjects:FindFirstChild(AnimName);
		if ( AnimObject ) then

			if ( CurrentToyAnimation ~= nil ) then
				CurrentToyAnimation:Stop();
				CurrentToyAnimation:Destroy();
				CurrentToyAnimation = nil;
			end

			local AnimTrack = AnimController.Animator:LoadAnimation( AnimObject );
			AnimTrack:Play();
			CurrentToyAnimation = AnimTrack;
		end

	end

end

function playAnimation(animName, transitionTime, humanoid)

	local idx = rollAnimation(animName)


Prompt:
---------------------------------------------------------------
--
-- крутим лопастями
--
---------------------------------------------------------------

Response:
local Players = game:GetService("Players") -- берём ссылку на список игроков

me=script.Parent
plr=Players:FindFirstChild(me.Owner.Value)

angle=0 -- угол поворота
DELTA=me.Config.SpeedAttack.Value + me.Config.SpeedAttackAdd.Value * plr.VAR.turSpeed.Value

local hits=script.Hit:Clone()


Prompt: --attack function

Response:
function attack()
	for i,v in pairs(workspace:GetChildren()) do
		if v:FindFirstChild("Humanoid") then
			if v ~= script.Parent then
				if (v.Head.Position - script.Parent.Head.Position).Magnitude < damagerange then
					v.Humanoid:TakeDamage(damage)
				end
			end
		end
	end
	wait(0.3)
end
function heardetect(part)
	local target = nil
	local Beam = Instance.new("Part", script.debris)
	Beam.Anchored = true
	Beam.CanCollide = false
	Beam.Color = Color3.fromRGB(255, 150, 150)
	Beam.Material = Enum.Material.Neon
	Beam.Name = "LaserBeam"
	Beam.Transparency = 1
	local Object = script.Parent.Head
	local Raycast = Ray.new(Object.CFrame.p, CFrame.new(Object.CFrame.Position, part.Position).LookVector * distance)
	local Part, Position = game.Workspace:FindPartOnRayWithIgnoreList(Raycast, {Object, Beam, script.debris}, false, true)
	local Distance = (Object.CFrame.p - Position).Magnitude
	if visibleray == true then
		Beam.Size = Vector3.new(0.1, 0.1, Distance)
		Beam.CFrame = CFrame.new(Object.CFrame.Position, part.Position) * CFrame.new(0, 0, -Distance/2)
		Beam.Transparency = 0
	else
		Beam:Destroy()
	end
	if Part ~= nil then
		if game.Players:GetPlayerFromCharacter(Part.Parent) or game.Players:GetPlayerFromCharacter(Part.Parent.Parent) then
			--script.Parent.Humanoid:MoveTo(Part.Position)
			GoTo(part.Position)
			if (part.Position - script.Parent.Head.Position).Magnitude < damagerange then
				attack()
			end
			Beam.BrickColor = BrickColor.new("Bright blue")
		else
			Beam.BrickColor = BrickColor.new("Really red")
		end
	else
		Beam.BrickColor = BrickColor.new("White")
	end
	wait()
end
while wait() do
	local maxDistance = distance
	for i,v in pairs(workspace:GetChildren()) do
		if v:FindFirstChild("Humanoid") then
			if (v.Head.Position-script.Parent.Head.Position).magnitude < maxDistance then
				if v ~= script.Parent then
					heardetect(v.Head)
				end
			else
				wander()
			end
		end
	end
end


Prompt: --- Creates callbacks and sets up initial state.

Response:
function ScopeHierarchyItemButton:init()
    self.Maid = Maid.new()
    self.LayoutRef = Roact.createRef()
    self.ContainerSize, self.UpdateContainerSize = Roact.createBinding(UDim2.new(0, 0, 1, 0))

    --- Processes clicks, triggers scope change
    function self.OnClicked()
        self.props.SetScopeFromButton(self.props.Instance)
    end

    -- Set initial state
    self:UpdateInstanceState()
end

local ClassIconPositions = {
    Part = Vector2.new(2, 1);
    MeshPart = Vector2.new(4, 8);
    UnionOperation = Vector2.new(4, 8);
    NegateOperation = Vector2.new(3, 8);
    VehicleSeat = Vector2.new(6, 4);
    Seat = Vector2.new(6, 4);
    TrussPart = Vector2.new(2, 1);
    CornerWedgePart = Vector2.new(2, 1);
    WedgePart = Vector2.new(2, 1);
    SpawnLocation = Vector2.new(6, 3);
    Model = Vector2.new(3, 1);
    Folder = Vector2.new(8, 8);
    Tool = Vector2.new(8, 2);
    Workspace = Vector2.new(10, 2);
    Accessory = Vector2.new(3, 4);
    Accoutrement = Vector2.new(3, 4);
}


Prompt: -- returns the angles needed to have the npc look at a target

Response:
local function lookAt(target)
	local eye = (hrp.CFrame * CFrame.new(0, 3, 0)):pointToObjectSpace(target).unit;
	local horizontal = -math.atan2(eye.x, -eye.z);
	local vertical = math.asin(eye.y);

	local goal = Vector3.new();
	if not (math.abs(horizontal) > settings.horizontalRange or math.abs(vertical) > settings.verticalRange) then
		local hsign, habs = math.sign(horizontal), math.abs(horizontal);
		local hneck, hwaist = habs*0.5, habs*0.5;

		if (hwaist > settings.maxHorizontalWaist) then
			local remainder = hwaist - settings.maxHorizontalWaist;
			hwaist = settings.maxHorizontalWaist;
			hneck = math.clamp(hneck + remainder, 0, settings.maxHorizontalHead);
		end

		goal = Vector3.new(hsign*hneck, hsign*hwaist, vertical);
	end

	return goal;
end


Prompt: -- Anything parented to this script's parent will be lit up!

Response:
MaxFlickerWait = 30
MinFlickerWait = 10
Allow = false
function Change(Mode)
    for _,i in pairs (script.Parent:GetChildren()) do
        if i:IsA("BasePart") then
            if Mode then
                i.Material = "Neon"
            else
                i.Material = "SmoothPlastic"
            end
        elseif i:IsA("Model") then
            for _,i in pairs (i:GetChildren()) do
                if Mode then
                    i.Material = "Neon"
                else
                    i.Material = "SmoothPlastic"
                end
            end
        end
    end
end
script.On.Changed:connect(function()
    if script.On.Value then
        Allow = true
        Change(true)
    else
        Allow = false
        Change(false)
    end
end)
while wait(math.random(MinFlickerWait,MaxFlickerWait)) do
    if Allow then
        local function Check() if not Allow then return end end
        local WaitTime = .5
        Change(false)
        wait(WaitTime/2); Check();
        Change(true)
        wait(WaitTime); Check()
        Change(false)
        wait(WaitTime*1.5); Check()
        Change(true)
        wait(WaitTime); Check()
        Change(false)
        wait(WaitTime/5); Check()
        Change(true)
        wait(WaitTime); Check()
        Change(false)
        wait(WaitTime/8); Check()
        Change(true)
    end
end


Prompt: --// Event for making player say chat message.

Response:
function chatBarFocusLost(enterPressed, inputObject)
	DoBackgroundFadeIn()
	chatBarFocusChanged:Fire(false)

	if (enterPressed) then
		local message = ChatBar:GetTextBox().Text

		if ChatBar:IsInCustomState() then
			local customMessage = ChatBar:GetCustomMessage()
			if customMessage then
				message = customMessage
			end
			local messageSunk = ChatBar:CustomStateProcessCompletedMessage(message)
			ChatBar:ResetCustomState()
			if messageSunk then
				return
			end
		end

		ChatBar:GetTextBox().Text = ""

		if message ~= "" then
			--// Sends signal to eventually call Player:Chat() to handle C++ side legacy stuff.
			moduleApiTable.MessagePosted:fire(message)

			if not CommandProcessor:ProcessCompletedChatMessage(message, ChatWindow) then
				if ChatSettings.DisallowedWhiteSpace then
					for i = 1, #ChatSettings.DisallowedWhiteSpace do
						if ChatSettings.DisallowedWhiteSpace[i] == "\t" then
							message = string.gsub(message, ChatSettings.DisallowedWhiteSpace[i], " ")
						else
							message = string.gsub(message, ChatSettings.DisallowedWhiteSpace[i], "")
						end
					end
				end
				message = string.gsub(message, "\n", "")
				message = string.gsub(message, "[ ]+", " ")

				local targetChannel = ChatWindow:GetTargetMessageChannel()
				if targetChannel then
					MessageSender:SendMessage(message, targetChannel)
				else
					MessageSender:SendMessage(message, nil)
				end
			end
		end

	end
end

local ChatBarConnections = {}
function setupChatBarConnections()
	for i = 1, #ChatBarConnections do
		ChatBarConnections[i]:Disconnect()
	end
	ChatBarConnections = {}

	local focusLostConnection = ChatBar:GetTextBox().FocusLost:connect(chatBarFocusLost)
	table.insert(ChatBarConnections, focusLostConnection)

	local focusGainedConnection = ChatBar:GetTextBox().Focused:connect(chatBarFocused)
	table.insert(ChatBarConnections, focusGainedConnection)
end

setupChatBarConnections()
ChatBar.GuiObjectsChanged:connect(setupChatBarConnections)

function getEchoMessagesInGeneral()
	if ChatSettings.EchoMessagesInGeneralChannel == nil then
		return true
	end
	return ChatSettings.EchoMessagesInGeneralChannel
end

EventFolder.OnMessageDoneFiltering.OnClientEvent:connect(function(messageData)
	if not ChatSettings.ShowUserOwnFilteredMessage then
		if messageData.FromSpeaker == LocalPlayer.Name then
			return
		end
	end

	local channelName = messageData.OriginalChannel
	local channelObj = ChatWindow:GetChannel(channelName)
	if channelObj then
		channelObj:UpdateMessageFiltered(messageData)
	end

	if getEchoMessagesInGeneral() and ChatSettings.GeneralChannelName and channelName ~= ChatSettings.GeneralChannelName then
		local generalChannel = ChatWindow:GetChannel(ChatSettings.GeneralChannelName)
		if generalChannel then
			generalChannel:UpdateMessageFiltered(messageData)
		end
	end
end)

EventFolder.OnNewMessage.OnClientEvent:connect(function(messageData, channelName)
	local channelObj = ChatWindow:GetChannel(channelName)
	if (channelObj) then
		channelObj:AddMessageToChannel(messageData)

		if (messageData.FromSpeaker ~= LocalPlayer.Name) then
			ChannelsBar:UpdateMessagePostedInChannel(channelName)
		end

		if getEchoMessagesInGeneral() and ChatSettings.GeneralChannelName and channelName ~= ChatSettings.GeneralChannelName then
			local generalChannel = ChatWindow:GetChannel(ChatSettings.GeneralChannelName)
			if generalChannel then
				generalChannel:AddMessageToChannel(messageData)
			end
		end

		moduleApiTable.MessageCount = moduleApiTable.MessageCount + 1
		moduleApiTable.MessagesChanged:fire(moduleApiTable.MessageCount)

		DoFadeInFromNewInformation()
	end
end)

EventFolder.OnNewSystemMessage.OnClientEvent:connect(function(messageData, channelName)
	channelName = channelName or "System"

	local channelObj = ChatWindow:GetChannel(channelName)
	if (channelObj) then
		channelObj:AddMessageToChannel(messageData)

		ChannelsBar:UpdateMessagePostedInChannel(channelName)

		moduleApiTable.MessageCount = moduleApiTable.MessageCount + 1
		moduleApiTable.MessagesChanged:fire(moduleApiTable.MessageCount)

		DoFadeInFromNewInformation()

		if getEchoMessagesInGeneral() and ChatSettings.GeneralChannelName and channelName ~= ChatSettings.GeneralChannelName then
			local generalChannel = ChatWindow:GetChannel(ChatSettings.GeneralChannelName)
			if generalChannel then
				generalChannel:AddMessageToChannel(messageData)
			end
		end
	else
		warn(string.format("Just received system message for channel I'm not in [%s]", channelName))
	end
end)

function HandleChannelJoined(channel, welcomeMessage, messageLog, channelNameColor, addHistoryToGeneralChannel,
	addWelcomeMessageToGeneralChannel)
	if ChatWindow:GetChannel(channel) then
		--- If the channel has already been added, remove it first.
		ChatWindow:RemoveChannel(channel)
	end

	if (channel == ChatSettings.GeneralChannelName) then
		DidFirstChannelsLoads = true
	end

	if channelNameColor then
		ChatBar:SetChannelNameColor(channel, channelNameColor)
	end

	local channelObj = ChatWindow:AddChannel(channel)

	if (channelObj) then
		if (channel == ChatSettings.GeneralChannelName) then
			DoSwitchCurrentChannel(channel)
		end

		if (messageLog) then
			local startIndex = 1
			if #messageLog > ChatSettings.MessageHistoryLengthPerChannel then
				startIndex = #messageLog - ChatSettings.MessageHistoryLengthPerChannel
			end

			for i = startIndex, #messageLog do
				channelObj:AddMessageToChannel(messageLog[i])
			end

			if getEchoMessagesInGeneral() and addHistoryToGeneralChannel then
				if ChatSettings.GeneralChannelName and channel ~= ChatSettings.GeneralChannelName then
					local generalChannel = ChatWindow:GetChannel(ChatSettings.GeneralChannelName)
					if generalChannel then
						generalChannel:AddMessagesToChannelByTimeStamp(messageLog, startIndex)
					end
				end
			end
		end

		if (welcomeMessage ~= "") then
			local welcomeMessageObject = {
				ID = -1,
				FromSpeaker = nil,
				SpeakerUserId = 0,
				OriginalChannel = channel,
				IsFiltered = true,
				MessageLength = string.len(welcomeMessage),
				MessageLengthUtf8 = utf8.len(utf8.nfcnormalize(welcomeMessage)),
				Message = trimTrailingSpaces(welcomeMessage),
				MessageType = ChatConstants.MessageTypeWelcome,
				Time = os.time(),
				ExtraData = nil,
			}
			channelObj:AddMessageToChannel(welcomeMessageObject)

			if getEchoMessagesInGeneral() and addWelcomeMessageToGeneralChannel and not ChatSettings.ShowChannelsBar then
				if channel ~= ChatSettings.GeneralChannelName then
					local generalChannel = ChatWindow:GetChannel(ChatSettings.GeneralChannelName)
					if generalChannel then
						generalChannel:AddMessageToChannel(welcomeMessageObject)
					end
				end
			end
		end

		DoFadeInFromNewInformation()
	end

end

EventFolder.OnChannelJoined.OnClientEvent:connect(function(channel, welcomeMessage, messageLog, channelNameColor)
	HandleChannelJoined(channel, welcomeMessage, messageLog, channelNameColor, false, true)
end)

EventFolder.OnChannelLeft.OnClientEvent:connect(function(channel)
	ChatWindow:RemoveChannel(channel)

	DoFadeInFromNewInformation()
end)

EventFolder.OnMuted.OnClientEvent:connect(function(channel)
	--// Do something eventually maybe?
	--// This used to take away the chat bar in channels the player was muted in.
	--// We found out this behavior was inconvenient for doing chat commands though.
end)

EventFolder.OnUnmuted.OnClientEvent:connect(function(channel)
	--// Same as above.
end)

EventFolder.OnMainChannelSet.OnClientEvent:connect(function(channel)
	DoSwitchCurrentChannel(channel)
end)

coroutine.wrap(function()
	-- ChannelNameColorUpdated may not exist if the client version is older than the server version.
	local ChannelNameColorUpdated = DefaultChatSystemChatEvents:WaitForChild("ChannelNameColorUpdated", 5)
	if ChannelNameColorUpdated then
		ChannelNameColorUpdated.OnClientEvent:connect(function(channelName, channelNameColor)
			ChatBar:SetChannelNameColor(channelName, channelNameColor)
		end)
	end
end)()


Prompt:
--[=[
	@within Signal
	@type ConnectionFn (...any) -> ()

	A function connected to a signal.
]=]


Prompt: -- map to proximity prompt

Response: local lobbyProximityPrompt = workspace.Level_Geo.Lobby.LobbyConsole.ProximityPrompt


Prompt: --character welds

Response:
local larmw
local rarmw
local llegw
local rlegw
local headw
local torsow


Response:
	script.Parent.Handle3.Hinge1.Transparency = 1
	script.Parent.Handle3.Interactive1.Transparency = 1
	script.Parent.Handle3.Part1.Transparency = 1
	wait(0.03)
end

script.Parent.Push.ClickDetector.MouseClick:connect(toiletHandle)


Response:
end
else
print("sh")
end
else
print("arms")
end
end
function Key(key)
if key then
key = string.lower(key)
if (key=="x") then
if on == 1 then
on = 0
elseif on == 0 then
on = 1
end
Crouch(on)
end
end
end
function Equip(mouse)
mouse.KeyDown:connect(Key)
end
script.Parent.Equipped:connect(Equip)


Prompt: -- Note: The active transparency controller could be made to listen for this event itself.

Response:
function CameraModule:OnCameraSubjectChanged()
	local camera = workspace.CurrentCamera
	local cameraSubject = camera and camera.CameraSubject

	if self.activeTransparencyController then
		self.activeTransparencyController:SetSubject(cameraSubject)
	end

	if self.activeOcclusionModule then
		self.activeOcclusionModule:OnCameraSubjectChanged(cameraSubject)
	end

	self:ActivateCameraController(nil, camera.CameraType)
end

function CameraModule:OnCameraTypeChanged(newCameraType: Enum.CameraType)
	if newCameraType == Enum.CameraType.Scriptable then
		if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
			UserInputService.MouseBehavior = Enum.MouseBehavior.Default
		end
	end

	-- Forward the change to ActivateCameraController to handle
	self:ActivateCameraController(nil, newCameraType)
end


Response:
local function queryPoint(origin, unitDir, dist, lastPos)
	debug.profilebegin("queryPoint")

	local originalSize = #blacklist

	dist = dist + nearPlaneZ
	local target = origin + unitDir*dist

	local softLimit = inf
	local hardLimit = inf
	local movingOrigin = origin

	repeat
		local entryPart, entryPos = workspace:FindPartOnRayWithIgnoreList(ray(movingOrigin, target - movingOrigin), blacklist, false, true)

		if entryPart then
			if canOcclude(entryPart) then
				local wl = {entryPart}
				local exitPart = workspace:FindPartOnRayWithWhitelist(ray(target, entryPos - target), wl, true)

				local lim = (entryPos - origin).Magnitude

				if exitPart then
					local promote = false
					if lastPos then
						promote =
							workspace:FindPartOnRayWithWhitelist(ray(lastPos, target - lastPos), wl, true) or
							workspace:FindPartOnRayWithWhitelist(ray(target, lastPos - target), wl, true)
					end

					if promote then
						-- Ostensibly a soft limit, but the camera has passed through it in the last frame, so promote to a hard limit.
						hardLimit = lim
					elseif dist < softLimit then
						-- Trivial soft limit
						softLimit = lim
					end
				else
					-- Trivial hard limit
					hardLimit = lim
				end
			end

			blacklist[#blacklist + 1] = entryPart
			movingOrigin = entryPos - unitDir*1e-3
		end
	until hardLimit < inf or not entryPart

	eraseFromEnd(blacklist, originalSize)

	debug.profileend()
	return softLimit - nearPlaneZ, hardLimit - nearPlaneZ
end

local function queryViewport(focus, dist)
	debug.profilebegin("queryViewport")

	local fP =  focus.p
	local fX =  focus.rightVector
	local fY =  focus.upVector
	local fZ = -focus.lookVector

	local viewport = camera.ViewportSize

	local hardBoxLimit = inf
	local softBoxLimit = inf

	-- Center the viewport on the PoI, sweep points on the edge towards the target, and take the minimum limits
	for viewX = 0, 1 do
		local worldX = fX*((viewX - 0.5)*projX)

		for viewY = 0, 1 do
			local worldY = fY*((viewY - 0.5)*projY)

			local origin = fP + nearPlaneZ*(worldX + worldY)
			local lastPos = camera:ViewportPointToRay(
				viewport.x*viewX,
				viewport.y*viewY
			).Origin

			local softPointLimit, hardPointLimit = queryPoint(origin, fZ, dist, lastPos)

			if hardPointLimit < hardBoxLimit then
				hardBoxLimit = hardPointLimit
			end
			if softPointLimit < softBoxLimit then
				softBoxLimit = softPointLimit
			end
		end
	end
	debug.profileend()

	return softBoxLimit, hardBoxLimit
end

local function testPromotion(focus, dist, focusExtrapolation)
	debug.profilebegin("testPromotion")

	local fP = focus.p
	local fX = focus.rightVector
	local fY = focus.upVector
	local fZ = -focus.lookVector

	do
		-- Dead reckoning the camera rotation and focus
		debug.profilebegin("extrapolate")

		local SAMPLE_DT = 0.0625
		local SAMPLE_MAX_T = 1.25

		local maxDist = (getCollisionPoint(fP, focusExtrapolation.posVelocity*SAMPLE_MAX_T) - fP).Magnitude
		-- Metric that decides how many samples to take
		local combinedSpeed = focusExtrapolation.posVelocity.magnitude

		for dt = 0, min(SAMPLE_MAX_T, focusExtrapolation.rotVelocity.magnitude + maxDist/combinedSpeed), SAMPLE_DT do
			local cfDt = focusExtrapolation.extrapolate(dt) -- Extrapolated CFrame at time dt

			if queryPoint(cfDt.p, -cfDt.lookVector, dist) >= dist then
				return false
			end
		end

		debug.profileend()
	end

	do
		-- Test screen-space offsets from the focus for the presence of soft limits
		debug.profilebegin("testOffsets")

		for _, offset in ipairs(SCAN_SAMPLE_OFFSETS) do
			local scaledOffset = offset
			local pos = getCollisionPoint(fP, fX*scaledOffset.x + fY*scaledOffset.y)
			if queryPoint(pos, (fP + fZ*dist - pos).Unit, dist) == inf then
				return false
			end
		end

		debug.profileend()
	end

	debug.profileend()
	return true
end

local function Popper(focus, targetDist, focusExtrapolation)
	debug.profilebegin("popper")

	subjectRoot = subjectPart and subjectPart:GetRootPart() or subjectPart

	local dist = targetDist
	local soft, hard = queryViewport(focus, targetDist)
	if hard < dist then
		dist = hard
	end
	if soft < dist and testPromotion(focus, targetDist, focusExtrapolation) then
		dist = soft
	end

	subjectRoot = nil

	debug.profileend()
	return dist
end

return Popper


Prompt:
--[[
	Hides all ScreenGuis and CoreGuis shown. If the callback `hideOtherGuis`
	is defined then that function is called instead.
]]

Response:
function GuiController:hideGuis()
	if self.hideOtherGuis and self.hideOtherGuis.isCallbackSet() then
		self.hideOtherGuis.fireCallback()
		return
	end

	-- hideGuis has already been called, no need to hide again until
	-- showGuis is called
	if #Cryo.Dictionary.keys(self.disabledGuis) ~= 0 then
		return
	end

	-- Hide ScreenGuis
	self.disabledGuis = self:_getOtherScreenGuis()
	for _, gui in ipairs(self.disabledGuis) do
		gui.Enabled = false
	end

	-- Hide CoreGuis
	self.disabledCoreGuis = self:_getShownCoreGuis()
	for _, gui in ipairs(self.disabledCoreGuis) do
		self.StarterGui:SetCoreGuiEnabled(gui, false)
	end

	-- Hide mobile controls
	self.modalEnabled = self.UserInputService.ModalEnabled
	self.UserInputService.ModalEnabled = true
end


Prompt: -- Services

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

wait()
starterGui:SetCore("ResetButtonCallback", false)


Prompt:
--[[if player.Character:FindFirstChild('WhiteButterfly') == nil then
	script.Parent.Parent.Parent.Parent.ItemFrame.Visible = false
end]]


Response:
function Sword:Initialize()
	Sword:Connect()
end


Prompt:
-----------------------------------------------------------------------------------------------------------
-- API:

Response:
function API:GetDataStore(name, scope)
	assert(type(name) == "string", "DataStore name must be a string; got" .. type(name))
	assert(type(scope) == "string" or scope == nil, "DataStore scope must be a string; got" .. type(scope))
	scope = (scope or "global")
	if (allStores[scope] and allStores[scope][name]) then
		return allStores[scope][name]
	end
	local data = {}
	local d = {}
	local updateListeners = {}
	function d.SetAsync(_s, k, v)
		assert(v ~= nil, "Value cannot be nil")
		data[k] = v
		if (updateListeners[k]) then
			for _,f in ipairs(updateListeners[k]) do
				spawn(function() f(v) end)
			end
		end
	end
	function d.UpdateAsync(_s, k, func)
		local v = func(data[k])
		assert(v ~= nil, "Value cannot be nil")
		data[k] = v
		if (updateListeners[k]) then
			for _,f in ipairs(updateListeners[k]) do
				spawn(function() f(v) end)
			end
		end
	end
	function d.GetAsync(_s, k)
		return data[k]
	end
	function d.RemoveAsync(_s, k)
		data[k] = nil
		if (updateListeners[k]) then
			for _,f in ipairs(updateListeners[k]) do
				spawn(function() f(nil) end)
			end
		end
	end
	function d.IncrementAsync(_s, k, delta)
		if (delta == nil) then delta = 1 end
		assert(type(delta) == "number", "Can only increment numbers")
		_s:UpdateAsync(k, function(num)
			if (num == nil) then
				return num
			end
			assert(type(num) == "number", "Can only increment numbers")
			return (num + delta)
		end)
	end
	function d.OnUpdate(_s, k, onUpdateFunc)
		assert(type(onUpdateFunc) == "function", "Update function argument must be a function")
		if (not updateListeners[k]) then
			updateListeners[k] = {onUpdateFunc}
		else
			table.insert(updateListeners[k], onUpdateFunc)
		end
	end
	if (not allStores[scope]) then
		allStores[scope] = {}
	end
	allStores[scope][name] = d
	return d
end

function API:GetGlobalDataStore()
	return self:GetDataStore("global", "global")
end

function API:GetOrderedDataStore(name, scope)
	local dataStore = self:GetDataStore(name, scope)
	local allData = {}
	local d = {}
	function d.GetAsync(_s, k)
		return dataStore:GetAsync(k)
	end
	function d.SetAsync(_s, k, v)
		assert(type(v) == "number", "Value must be a number")
		dataStore:SetAsync(k, v)
		allData[k] = v
	end
	function d.UpdateAsync(_s, k, func)
		dataStore:UpdateAsync(k, function(oldValue)
			local v = func(oldValue)
			assert(type(v) == "number", "Value must be a number")
			allData[k] = v
			return v
		end)
	end
	function d.IncrementAsync(_s, k, delta)
		dataStore:IncrementAsync(k, delta)
		allData[k] = ((allData[k] or 0) + delta)
	end
	function d.RemoveAsync(_s, k)
		dataStore:RemoveAsync(k)
		allData[k] = nil
	end
	function d.GetSortedAsync(_s, isAscending, pageSize, minValue, maxValue)
		assert(type(pageSize) == "number" and math.floor(pageSize) > 0, "PageSize must be an integer and greater than 0")
		assert(minValue == nil or type(minValue) == "number", "MinValue must be a number")
		assert(maxValue == nil or type(maxValue) == "number", "MaxValue must be a number")
		if (minValue and maxValue) then
			assert(minValue <= maxValue, "MinValue must be less or equal to MaxValue")
		end
		local data = {}
		for k,v in pairs(allData) do
			local pass = ((not minValue or v >= minValue) and (not maxValue or v <= maxValue))
			if (pass) then
				table.insert(data, {key = k, value = v})
			end
		end
		table.sort(data,
			(isAscending and
				function(a, b) return (a.value < b.value) end
			or
				function(a, b) return (b.value < a.value) end
			)
		)
		pageSize = math.floor(pageSize)
		local pages = {IsFinished = false}
		for i,v in pairs(data) do
			local pageNum = math.ceil(i / pageSize)
			local page = pages[pageNum]
			if (not page) then
				page = {}
				pages[pageNum] = page
			end
			local index = (((i - 1) % pageSize) + 1)
			page[index] = v
		end
		do
			local currentPage = 1
			function pages.GetCurrentPage(p)
				return p[currentPage]
			end
			function pages.AdvanceToNextPageAsync(p)
				local numPages = #pages
				if (currentPage < numPages) then
					currentPage = (currentPage + 1)
				end
				p.IsFinished = (currentPage >= numPages)
			end
		end
		return pages
	end
	return d
end

function API:GetRequestBudgetForRequestType(requestType)
	return realDataStoreService:GetRequestBudgetForRequestType(requestType)
end


Prompt: --#Constants

Response:
local rate = 0.2
local minSpeed, topSpeed = configuration.AcceleratedWalking.MinSpeed.Value, configuration.AcceleratedWalking.MaxSpeed.Value
local increment = configuration.AcceleratedWalking.Increment.Value
local noMovement = Vector3.new(0,0,0)


Prompt: -- config

Response:
local config = {
	position = 0, -- 0 = Horizontal, 1 = Vertical
	padding = 5
}


Prompt: -- functions

Response:
function stopAllAnimations()
	local oldAnim = currentAnim

	-- return to idle if finishing an emote
	if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
		oldAnim = "idle"
	end

	currentAnim = ""
	currentAnimInstance = nil
	if (currentAnimKeyframeHandler ~= nil) then
		currentAnimKeyframeHandler:disconnect()
	end

	if (currentAnimTrack ~= nil) then
		currentAnimTrack:Stop()
		currentAnimTrack:Destroy()
		currentAnimTrack = nil
	end

	-- clean up walk if there is one
	if (runAnimKeyframeHandler ~= nil) then
		runAnimKeyframeHandler:disconnect()
	end

	if (runAnimTrack ~= nil) then
		runAnimTrack:Stop()
		runAnimTrack:Destroy()
		runAnimTrack = nil
	end

	return oldAnim
end

local smallButNotZero = 0.0001
function setRunSpeed(speed)
	if speed < 0.33 then
		currentAnimTrack:AdjustWeight(1.0)
		runAnimTrack:AdjustWeight(smallButNotZero)
	elseif speed < 0.66 then
		local weight = ((speed - 0.33) / 0.33)
		currentAnimTrack:AdjustWeight(1.0 - weight + smallButNotZero)
		runAnimTrack:AdjustWeight(weight + smallButNotZero)
	else
		currentAnimTrack:AdjustWeight(smallButNotZero)
		runAnimTrack:AdjustWeight(1.0)
	end

	local speedScaled = speed * 1.25
	runAnimTrack:AdjustSpeed(speedScaled)
	currentAnimTrack:AdjustSpeed(speedScaled)

	if ( CurrentToyAnimation ~= nil ) then
		CurrentToyAnimation:AdjustSpeed(speedScaled)
	end

end

function setAnimationSpeed(speed)

	-- Check difference
	local MaxDifference = .5;
	local Difference = math.abs(( currentAnimSpeed - speed ));

	if ( Difference < MaxDifference ) then
		return;
	end

	if speed ~= currentAnimSpeed then
		currentAnimSpeed = speed
		if currentAnim == "walk" then
			setRunSpeed(speed)
		else
			currentAnimTrack:AdjustSpeed(currentAnimSpeed)
		end
	end
end

function keyFrameReachedFunc(frameName)


Prompt:
-- turn off console glow by default
--welcomeConsoleGlow.Brightness = 0


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

Response:
module.WindowDraggable = false
module.WindowResizable = true
module.ShowChannelsBar = false
module.GamepadNavigationEnabled = false
module.AllowMeCommand = true -- Me Command will only be effective when this set to true
module.ShowUserOwnFilteredMessage = true	--Show a user the filtered version of their message rather than the original.


Prompt: --	print(animName .. " " .. idx .. " [" .. origRoll .. "]")

Response:
	local anim = animTable[animName][idx].anim

	-- switch animation
	if (anim ~= currentAnimInstance) then

		if (currentAnimTrack ~= nil) then
			currentAnimTrack:Stop(transitionTime)
			currentAnimTrack:Destroy()
		end

		if (runAnimTrack ~= nil) then
			runAnimTrack:Stop(transitionTime)
			runAnimTrack:Destroy()
		end

		currentAnimSpeed = 1.0

		-- load it to the humanoid; get AnimationTrack
		currentAnimTrack = humanoid:LoadAnimation(anim)

		-- play the animation
		currentAnimTrack:Play(transitionTime)
		currentAnim = animName
		currentAnimInstance = anim

		-- set up keyframe name triggers
		if (currentAnimKeyframeHandler ~= nil) then
			currentAnimKeyframeHandler:disconnect()
		end
		currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)

		-- check to see if we need to blend a walk/run animation
		if animName == "walk" then
			local runAnimName = "run"
			local runIdx = rollAnimation(runAnimName)

			runAnimTrack = humanoid:LoadAnimation(animTable[runAnimName][runIdx].anim)
			runAnimTrack:Play(transitionTime)

			if (runAnimKeyframeHandler ~= nil) then
				runAnimKeyframeHandler:disconnect()
			end
			runAnimKeyframeHandler = runAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)
		end

		if ( animName == "walk" ) then
			playToyAnimation("Run");
		elseif ( animName == "idle" ) then
			playToyAnimation("Idle");
		end

	end

end


Prompt: --// Holstering

Response:
	HolsteringEnabled = false;
	HolsterPos = CFrame.new(0.140751064, 0, -0.616261482, -4.10752676e-08, -0.342020065, 0.939692616, -1.49501727e-08, 0.939692557, 0.342020094, -0.99999994, 0, -4.37113847e-08);


Prompt: -- A state object whose value is derived from other objects using a callback.

Response:
export type ForValues<K, VO> = StateObject<{ [K]: VO }> & Dependent & {
	-- kind: "ForKeys" (add this when Luau supports singleton types)
}