Prompt: --[[ By: Brutez. Script Fixed By Xcorrectgamermaster ]]

Response:
--
local JeffTheKillerScript=script;
repeat wait(0.1)until JeffTheKillerScript and JeffTheKillerScript.Parent and JeffTheKillerScript.Parent.ClassName=="Model"and JeffTheKillerScript.Parent:FindFirstChild("Head")and JeffTheKillerScript.Parent:FindFirstChild("Torso");
local JeffTheKiller=JeffTheKillerScript.Parent;
function raycast(Spos,vec,currentdist)
local hit2,pos2=game.Workspace:FindPartOnRay(Ray.new(Spos+(vec*.05),vec*currentdist),JeffTheKiller);
if hit2~=nil and pos2 then
if hit2.Name=="Handle" and not hit2.CanCollide or string.sub(hit2.Name,1,6)=="Effect"and not hit2.CanCollide then
local currentdist=currentdist-(pos2-Spos).magnitude;
return raycast(pos2,vec,currentdist);
end;
end;
return hit2,pos2;
end;
function RayCast(Position,Direction,MaxDistance,IgnoreList)
return game:GetService("Workspace"):FindPartOnRayWithIgnoreList(Ray.new(Position,Direction.unit*(MaxDistance or 999.999)),IgnoreList);
end;
local JeffTheKillerHumanoid;
for _,Child in pairs(JeffTheKiller:GetChildren())do
if Child and Child.ClassName=="Humanoid"and Child.Health~=0 then
JeffTheKillerHumanoid=Child;
end;
end;
local AttackDebounce=false;
local JeffTheKillerKnife=JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Knife");
local JeffTheKillerHead=JeffTheKiller:FindFirstChild("Head");
local JeffTheKillerHumanoidRootPart=JeffTheKiller:FindFirstChild("HumanoidRootPart");
local WalkDebounce=false;
local Notice=false;
local JeffLaughDebounce=false;
local MusicDebounce=false;
local NoticeDebounce=false;
local ChosenMusic;
JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Neck").C0=CFrame.new(0,1,0,-1,0,0,0,0,1,0,1,-0);
local OriginalC0=JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Neck").C0;
function FindNearestBae()
local NoticeDistance=70;
local TargetMain;
for _,TargetModel in pairs(game:GetService("Workspace"):GetChildren())do
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and TargetModel.className=="Model"and TargetModel~=JeffTheKiller and TargetModel.Name~=JeffTheKiller.Name and TargetModel:FindFirstChild("HumanoidRootPart")and TargetModel:FindFirstChild("Head")then
local TargetPart=TargetModel:FindFirstChild("HumanoidRootPart");
local FoundHumanoid;
for _,Child in pairs(TargetModel:GetChildren())do
if Child and Child.ClassName=="Humanoid"and Child.Health~=0 then
FoundHumanoid=Child;
end;
end;
if TargetModel and TargetPart and FoundHumanoid and FoundHumanoid.Health~=0 and(TargetPart.Position-JeffTheKillerHumanoidRootPart.Position).magnitude<NoticeDistance then
TargetMain=TargetPart;
NoticeDistance=(TargetPart.Position-JeffTheKillerHumanoidRootPart.Position).magnitude;
local hit,pos=raycast(JeffTheKillerHumanoidRootPart.Position,(TargetPart.Position-JeffTheKillerHumanoidRootPart.Position).unit,500)
if hit and hit.Parent and hit.Parent.ClassName=="Model"and hit.Parent:FindFirstChild("HumaniodRootPart")and hit.Parent:FindFirstChild("Head")then
if TargetModel and TargetPart and FoundHumanoid and FoundHumanoid.Health~=0 and(TargetPart.Position-JeffTheKillerHumanoidRootPart.Position).magnitude<9 and not AttackDebounce then
spawn(function()
AttackDebounce=true;
local SwingAnimation=JeffTheKillerHumanoid:LoadAnimation(JeffTheKiller:FindFirstChild("AttackAnimation"));
local SwingChoice=math.random(1,2);
local HitChoice=math.random(1,3);
SwingAnimation:Play();
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerKnife and JeffTheKillerKnife:FindFirstChild("Swing")then
local SwingSound=JeffTheKillerKnife:FindFirstChild("Swing");
SwingSound.Pitch=1+(math.random()*0.04);
SwingSound:Play();
end;
wait(0.2);
if TargetModel and TargetPart and FoundHumanoid and FoundHumanoid.Health~=0 and(TargetPart.Position-JeffTheKillerHumanoidRootPart.Position).magnitude<8 then
FoundHumanoid:TakeDamage(20);
if HitChoice==1 and JeffTheKillerScript and JeffTheKiller and JeffTheKillerKnife and JeffTheKillerKnife:FindFirstChild("Hit1")then
local HitSound=JeffTheKillerKnife:FindFirstChild("Hit1");
HitSound.Pitch=1+(math.random()*0.04);
HitSound:Play();
elseif HitChoice==2 and JeffTheKillerScript and JeffTheKiller and JeffTheKillerKnife and JeffTheKillerKnife:FindFirstChild("Hit2")then
local HitSound=JeffTheKillerKnife:FindFirstChild("Hit2");
HitSound.Pitch=1+(math.random()*0.04);
HitSound:Play();
elseif HitChoice==3 and JeffTheKillerScript and JeffTheKiller and JeffTheKillerKnife and JeffTheKillerKnife:FindFirstChild("Hit3")then
local HitSound=JeffTheKillerKnife:FindFirstChild("Hit3");
HitSound.Pitch=1+(math.random()*0.04);
HitSound:Play();
end;
end;
wait(1);
AttackDebounce=false;
end);
end;
end;
end;
end;
end;
return TargetMain;
end;
while wait(0.1)do
local TargetPoint=JeffTheKillerHumanoid.TargetPoint;
local Blockage,BlockagePos=RayCast((JeffTheKillerHumanoidRootPart.CFrame+CFrame.new(JeffTheKillerHumanoidRootPart.Position,Vector3.new(TargetPoint.X,JeffTheKillerHumanoidRootPart.Position.Y,TargetPoint.Z)).lookVector*(JeffTheKillerHumanoidRootPart.Size.Z/2)).p,JeffTheKillerHumanoidRootPart.CFrame.lookVector,(JeffTheKillerHumanoidRootPart.Size.Z*2.5),{JeffTheKiller,JeffTheKiller})
local Jumpable=false;
if Blockage then
Jumpable=true;
if Blockage and Blockage.Parent and Blockage.Parent.ClassName~="Workspace"then
local BlockageHumanoid;
for _,Child in pairs(Blockage.Parent:GetChildren())do
if Child and Child.ClassName=="Humanoid"and Child.Health~=0 then
BlockageHumanoid=Child;
end;
end;
if Blockage and Blockage:IsA("Terrain")then
local CellPos=Blockage:WorldToCellPreferSolid((BlockagePos-Vector3.new(0,2,0)));
local CellMaterial,CellShape,CellOrientation=Blockage:GetCell(CellPos.X,CellPos.Y,CellPos.Z);
if CellMaterial==Enum.CellMaterial.Water then
Jumpable=false;
end;
elseif BlockageHumanoid or Blockage.ClassName=="TrussPart"or Blockage.ClassName=="WedgePart"or Blockage.Name=="Handle"and Blockage.Parent.ClassName=="Hat"or Blockage.Name=="Handle"and Blockage.Parent.ClassName=="Tool" then
Jumpable=false;
end;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and not JeffTheKillerHumanoid.Sit and Jumpable then
wait(1)
JeffTheKillerHumanoid.Jump=true;
end;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHead and JeffTheKillerHumanoidRootPart and JeffTheKillerHead:FindFirstChild("Jeff_Step")and (JeffTheKillerHumanoidRootPart.Velocity-Vector3.new(0,JeffTheKillerHumanoidRootPart.Velocity.y,0)).magnitude>=5 and not WalkDebounce and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 then
spawn(function()
WalkDebounce=true;
local FiredRay=Ray.new(JeffTheKillerHumanoidRootPart.Position,Vector3.new(0,-4,0));
local RayTarget,endPoint=game:GetService("Workspace"):FindPartOnRay(FiredRay,JeffTheKiller);
if RayTarget then
local JeffTheKillerHeadFootStepClone=JeffTheKillerHead:FindFirstChild("Jeff_Step"):Clone();
JeffTheKillerHeadFootStepClone.Parent=JeffTheKillerHead;
JeffTheKillerHeadFootStepClone:Play();
JeffTheKillerHeadFootStepClone:Destroy();
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and JeffTheKillerHumanoid.WalkSpeed<17 then
wait(0.4);
elseif JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and JeffTheKillerHumanoid.WalkSpeed>17 then
wait(0.15);
end
end;
WalkDebounce=false;
end);
end;
local MainTarget=FindNearestBae();
local FoundHumanoid;
if MainTarget then
for _,Child in pairs(MainTarget.Parent:GetChildren())do
if Child and Child.ClassName=="Humanoid"and Child.Health~=0 then
FoundHumanoid=Child;
end;
end;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and MainTarget and MainTarget.Parent and FoundHumanoid and FoundHumanoid.Jump then
wait(1)
JeffTheKillerHumanoid.Jump=true;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and MainTarget and FoundHumanoid and FoundHumanoid.Health~=0 and(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).magnitude<99999999999999999999 then
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHead and JeffTheKillerHead:FindFirstChild("RakeTheme")and not JeffTheKillerHead:FindFirstChild("RakeTheme").IsPlaying then
JeffTheKillerHead:FindFirstChild("RakeTheme").Volume=JeffTheKiller:FindFirstChild("Configuration"):FindFirstChild("RakeThemeVolume").Value;
JeffTheKillerHead:FindFirstChild("RakeTheme"):Play();
end;
elseif JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and MainTarget and FoundHumanoid and FoundHumanoid.Health~=0 and(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).magnitude>9999999999999999999 then
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHead and JeffTheKillerHead:FindFirstChild("RakeTheme")and JeffTheKillerHead:FindFirstChild("RakeTheme").IsPlaying then
if not JeffLaughDebounce then
spawn(function()
JeffLaughDebounce=true;
repeat wait(0.1);if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHead and JeffTheKillerHead:FindFirstChild("RakeTheme")then JeffTheKillerHead:FindFirstChild("RakeTheme").Volume=JeffTheKillerHead:FindFirstChild("RakeTheme").Volume-0.1;else break;end;until JeffTheKillerHead:FindFirstChild("RakeTheme").Volume==0 or JeffTheKillerHead:FindFirstChild("RakeTheme").Volume<0;
JeffTheKillerHead:FindFirstChild("RakeTheme").Volume=0;
JeffTheKillerHead:FindFirstChild("RakeTheme"):Stop();
JeffLaughDebounce=false;
end);
end;
end;
end;
if not ChosenMusic and JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and MainTarget and FoundHumanoid and FoundHumanoid.Health~=0 and(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).magnitude<50 then
local MusicChoice=math.random(1,2);
if MusicChoice==1 and JeffTheKillerScript and JeffTheKiller and JeffTheKiller:FindFirstChild("Jeff_Scene_Sound1")then
ChosenMusic=JeffTheKiller:FindFirstChild("Jeff_Scene_Sound1");
elseif MusicChoice==2 and JeffTheKillerScript and JeffTheKiller and JeffTheKiller:FindFirstChild("Jeff_Scene_Sound2")then
ChosenMusic=JeffTheKiller:FindFirstChild("Jeff_Scene_Sound2");
end;
if JeffTheKillerScript and JeffTheKiller and ChosenMusic and not ChosenMusic.IsPlaying then
ChosenMusic.Volume=0.5;
ChosenMusic:Play();
end;
elseif JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 and MainTarget and FoundHumanoid and FoundHumanoid.Health~=0 and(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).magnitude>50 then
if JeffTheKillerScript and JeffTheKiller and ChosenMusic and ChosenMusic.IsPlaying then
if not MusicDebounce then
spawn(function()
MusicDebounce=true;
repeat wait(0.1);if JeffTheKillerScript and JeffTheKiller and ChosenMusic then ChosenMusic.Volume=ChosenMusic.Volume-0.01;else break;end;until ChosenMusic.Volume==0 or ChosenMusic.Volume<0;
if ChosenMusic then
ChosenMusic.Volume=0;
ChosenMusic:Stop();
end;
ChosenMusic=nil;
MusicDebounce=false;
end);
end;
end;
end;
if not MainTarget and not JeffLaughDebounce then
spawn(function()
JeffLaughDebounce=true;
repeat wait(0.1);if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHead and JeffTheKillerHead:FindFirstChild("RakeTheme")then JeffTheKillerHead:FindFirstChild("RakeTheme").Volume=JeffTheKillerHead:FindFirstChild("RakeTheme").Volume-0.1;else break;end;until JeffTheKillerHead:FindFirstChild("RakeTheme").Volume==0 or JeffTheKillerHead:FindFirstChild("RakeTheme").Volume<0;
JeffTheKillerHead:FindFirstChild("RakeTheme").Volume=0;
JeffTheKillerHead:FindFirstChild("RakeTheme"):Stop();
JeffLaughDebounce=false;
end);
end;
if not MainTarget and not MusicDebounce then
spawn(function()
MusicDebounce=true;
repeat wait(0.1);if JeffTheKillerScript and JeffTheKiller and ChosenMusic then ChosenMusic.Volume=ChosenMusic.Volume-0.01;else break;end;until ChosenMusic.Volume==0 or ChosenMusic.Volume<0;
if ChosenMusic then
ChosenMusic.Volume=0;
ChosenMusic:Stop();
end;
ChosenMusic=nil;
MusicDebounce=false;
end);
end;
if MainTarget then
Notice=true;
if Notice and not NoticeDebounce and JeffTheKillerScript and JeffTheKiller and JeffTheKillerHead and JeffTheKillerHead:FindFirstChild("Found")then
JeffTheKiller.Target.Value = true;
JeffTheKillerHead:FindFirstChild("Found"):Play();
wait(0.4);
JeffTheKillerHead:FindFirstChild("RakeScream"):Play();
NoticeDebounce=true;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 then
if MainTarget and FoundHumanoid and FoundHumanoid.Health~=0 and(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).magnitude>5 then
JeffTheKillerHumanoid.WalkSpeed=JeffTheKiller.Configuration.WalkSpeed.Value;
elseif MainTarget and FoundHumanoid and FoundHumanoid.Health~=0 and(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).magnitude<5 then
JeffTheKillerHumanoid.WalkSpeed=1;
end;
JeffTheKillerHumanoid:MoveTo(MainTarget.Position+(MainTarget.Position-JeffTheKillerHumanoidRootPart.Position).unit*2,game:GetService("Workspace"):FindFirstChild("Terrain"));
local NeckRotation=(JeffTheKiller:FindFirstChild("Torso").Position.Y-MainTarget.Parent:FindFirstChild("Head").Position.Y)/10;
if NeckRotation>-1.5 and NeckRotation<1.5 then
JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Neck").C0=OriginalC0*CFrame.fromEulerAnglesXYZ(NeckRotation,0,0);
end;
if NeckRotation<-1.5 then
JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Neck").C0=CFrame.new(0,1,0,-1,0,0,0,-0.4,0.1,0,0.1,0.9);
elseif NeckRotation>1.5 then
JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Neck").C0=CFrame.new(0,1,0,-1,0,0,0,0.1,0.08,0,0.08,-0.2);
end;
else
end;
else
Notice=false;
NoticeDebounce=false;
JeffTheKiller:FindFirstChild("Torso"):FindFirstChild("Neck").C0=CFrame.new(0,1,0,-1,0,0,0,0,1,0,1,-0);
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Health~=0 then
JeffTheKillerHumanoid.WalkSpeed=12;
JeffTheKiller.Target.Value=false;
end;
end;
spawn(function()
local AlreadyDo=false;
while wait(0.1) do
if JeffTheKiller.Target.Value==false and AlreadyDo==false then
JeffTheKiller.Wander.Disabled=false;
AlreadyDo=true;
wait(10);
AlreadyDo=false;
end;
if JeffTheKiller.Target.Value==true and AlreadyDo==false then
JeffTheKiller.Wander.Disabled=true;
AlreadyDo=true;
wait(10);
AlreadyDo=false;
end;
end;
end);
spawn(function()
while JeffTheKillerHumanoid.Health > 1 do
wait(1);
JeffTheKiller:FindFirstChild("Torso").Blood.Enabled = false;
JeffTheKiller:FindFirstChild("Torso").Blood2.Enabled = false;
JeffTheKillerHead.Eye1.BrickColor=BrickColor.new("Institutional white");
JeffTheKillerHead.Eye2.BrickColor=BrickColor.new("Institutional white");
end;
end);
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid then
JeffTheKillerHumanoid.DisplayDistanceType="None";
JeffTheKillerHumanoid.HealthDisplayDistance=0;
JeffTheKillerHumanoid.Name="NPC";
JeffTheKillerHumanoid.NameDisplayDistance=0;
JeffTheKillerHumanoid.NameOcclusion="EnemyOcclusion";
JeffTheKillerHumanoid.AutoJumpEnabled=true;
JeffTheKillerHumanoid.AutoRotate=true;
JeffTheKillerHumanoid.MaxHealth=2000;
JeffTheKillerHumanoid.JumpPower=80;
JeffTheKillerHumanoid.MaxSlopeAngle=89.9;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and not JeffTheKillerHumanoid.AutoJumpEnabled then
JeffTheKillerHumanoid.AutoJumpEnabled=true;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and not JeffTheKillerHumanoid.AutoRotate then
JeffTheKillerHumanoid.AutoRotate=true;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.PlatformStand then
JeffTheKillerHumanoid.PlatformStand=false;
end;
if JeffTheKillerScript and JeffTheKiller and JeffTheKillerHumanoid and JeffTheKillerHumanoid.Sit then
JeffTheKillerHumanoid.Sit=false;
end;
end;


Prompt: --// Handling Settings

Response:
	Firerate = 60 / 700;

	FireMode = 1;


Prompt: -- Create a function to make the bear follow the player

Response:
function followPlayer(player)
	local character = player.Character
	if character then
		local distance = (bear.PrimaryPart.Position - character.PrimaryPart.Position).Magnitude
		if distance < 2 then
			bear.Position = character.PrimaryPart.Position
		end
	end
end


Prompt: --// Functions

Response:
function Weld(L_35_arg1, L_36_arg2, L_37_arg3)
	local L_38_ = Instance.new("Motor6D", L_35_arg1)
	L_38_.Part0 = L_35_arg1
	L_38_.Part1 = L_36_arg2
	L_38_.Name = L_35_arg1.Name
	L_38_.C0 = L_37_arg3 or L_35_arg1.CFrame:inverse() * L_36_arg2.CFrame
	return L_38_
end


Prompt: --//Services//--

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


Prompt:
--- Sets whether the command is in a valid state or not.
-- Cannot submit if in invalid state.

Response:
function Window:SetIsValidInput(isValid, errorText)
	Entry.TextBox.TextColor3 = isValid and Color3.fromRGB(255, 255, 255) or Color3.fromRGB(255, 73, 73)
	self.Valid = isValid
	self._errorText = errorText
end

function Window:HideInvalidState()
	Entry.TextBox.TextColor3 = Color3.fromRGB(255, 255, 255)
end


Prompt: -- Keyboard controller is really keyboard and mouse controller

Response:
local computerInputTypeToModuleMap = {
	[Enum.UserInputType.Keyboard] = Keyboard,
	[Enum.UserInputType.MouseButton1] = Keyboard,
	[Enum.UserInputType.MouseButton2] = Keyboard,
	[Enum.UserInputType.MouseButton3] = Keyboard,
	[Enum.UserInputType.MouseWheel] = Keyboard,
	[Enum.UserInputType.MouseMovement] = Keyboard,
	[Enum.UserInputType.Gamepad1] = Gamepad,
	[Enum.UserInputType.Gamepad2] = Gamepad,
	[Enum.UserInputType.Gamepad3] = Gamepad,
	[Enum.UserInputType.Gamepad4] = Gamepad,
}

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

	-- The Modules above are used to construct controller instances as-needed, and this
	-- table is a map from Module to the instance created from it
	self.controllers = {}

	self.activeControlModule = nil	-- Used to prevent unnecessarily expensive checks on each input event
	self.activeController = nil
	self.touchJumpController = nil
	self.moveFunction = Players.LocalPlayer.Move
	self.humanoid = nil
	self.lastInputType = Enum.UserInputType.None

	-- For Roblox self.vehicleController
	self.humanoidSeatedConn = nil
	self.vehicleController = nil

	self.touchControlFrame = nil

	self.vehicleController = VehicleController.new(CONTROL_ACTION_PRIORITY)

	Players.LocalPlayer.CharacterAdded:Connect(function(char) self:OnCharacterAdded(char) end)
	Players.LocalPlayer.CharacterRemoving:Connect(function(char) self:OnCharacterRemoving(char) end)
	if Players.LocalPlayer.Character then
		self:OnCharacterAdded(Players.LocalPlayer.Character)
	end

	RunService:BindToRenderStep("ControlScriptRenderstep", Enum.RenderPriority.Input.Value, function(dt) self:OnRenderStepped(dt) end)

	UserInputService.LastInputTypeChanged:Connect(function(newLastInputType) self:OnLastInputTypeChanged(newLastInputType) end)

	local propertyChangeListeners = {
		UserGameSettings:GetPropertyChangedSignal("TouchMovementMode"):Connect(function() self:OnTouchMovementModeChange() end),
		Players.LocalPlayer:GetPropertyChangedSignal("DevTouchMovementMode"):Connect(function() self:OnTouchMovementModeChange() end),

		UserGameSettings:GetPropertyChangedSignal("ComputerMovementMode"):Connect(function() self:OnComputerMovementModeChange() end),
		Players.LocalPlayer:GetPropertyChangedSignal("DevComputerMovementMode"):Connect(function() self:OnComputerMovementModeChange() end),
	}

	--[[ Touch Device UI ]]--
	self.playerGui = nil
	self.touchGui = nil
	self.playerGuiAddedConn = nil

	if UserInputService.TouchEnabled then
		self.playerGui = Players.LocalPlayer:FindFirstChildOfClass("PlayerGui")
		if self.playerGui then
			self:CreateTouchGuiContainer()
			self:OnLastInputTypeChanged(UserInputService:GetLastInputType())
		else
			self.playerGuiAddedConn = Players.LocalPlayer.ChildAdded:Connect(function(child)
				if child:IsA("PlayerGui") then
					self.playerGui = child
					self:CreateTouchGuiContainer()
					self.playerGuiAddedConn:Disconnect()
					self.playerGuiAddedConn = nil
					self:OnLastInputTypeChanged(UserInputService:GetLastInputType())
				end
			end)
		end
	else
		self:OnLastInputTypeChanged(UserInputService:GetLastInputType())
	end

	return self
end


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

Response:
export type Computed<T> = PubTypes.Computed<T> & {
	_oldDependencySet: Set<PubTypes.Dependency>,
	_callback: () -> T,
	_value: T
}


Prompt:
------------------------------------------------------------------------
-- ORDER OP
------------------------------------------------------------------------

Response:
local i = 0
for v in string.gmatch([[
MOVE LOADK LOADBOOL LOADNIL GETUPVAL
GETGLOBAL GETTABLE SETGLOBAL SETUPVAL SETTABLE
NEWTABLE SELF ADD SUB MUL
DIV MOD POW UNM NOT
LEN CONCAT JMP EQ LT
LE TEST TESTSET CALL TAILCALL
RETURN FORLOOP FORPREP TFORLOOP SETLIST
CLOSE CLOSURE VARARG
]], "%S+") do
  local n = "OP_"..v
  luaP.opnames[i] = v
  luaP.OpCode[n] = i
  luaP.ROpCode[i] = n
  i = i + 1
end
luaP.NUM_OPCODES = i


Prompt: -- This module is a class with a new() constructor function

Response:
VehicleSeating.SetRemotesFolder(RemotesFolder)
VehicleSeating.SetBindableEventsFolder(BindableEventsFolder)

local CharacterRemovingConnection = nil

local DriverSeat = Chassis.GetDriverSeat()
local AdditionalSeats = Chassis.GetPassengerSeats()

local LEG_PARTS_TO_REMOVE = {"RightFoot", "RightLowerLeg", "LeftFoot", "LeftLowerLeg"}
local ATTACHMENTS_TO_REMOVE = {"BodyBackAttachment", "WaistBackAttachment", "HatAttachment"}

local function setHatsAndLegsTransparency(obj, transparency)
	if obj:IsA("Humanoid") then
		obj = obj.Parent
	elseif obj:IsA("Player") then
		obj = obj.Character
	end

	for _, child in ipairs(obj:GetChildren()) do
		if child:IsA("Accoutrement") then
			local handle = child:FindFirstChild("Handle")
			if handle then
				local shouldRemove = false
				for _, attachmentName in ipairs(ATTACHMENTS_TO_REMOVE) do
					if handle:FindFirstChild(attachmentName) then
						shouldRemove = true
					end
				end

				if shouldRemove then
					handle.Transparency = transparency
				end
			end
		end
	end

	for _, legName in ipairs(LEG_PARTS_TO_REMOVE) do
		local legPart = obj:FindFirstChild(legName)
		if legPart then
			legPart.Transparency = transparency
		end
	end
end

local function onExitSeat(obj, seat)
	if obj:IsA("Player") then
		RemotesFolder.ExitSeat:FireClient(obj, false)

		local playerGui = obj:FindFirstChildOfClass("PlayerGui")
		if playerGui then
			local scriptContainer = playerGui:FindFirstChild(UniqueName .. "_ClientControls")
			if scriptContainer then
				scriptContainer:Destroy()
			end
		end
	end

	setHatsAndLegsTransparency(obj, 0)

	if obj:IsA("Humanoid") then
		obj.Sit = false
	end

	if CharacterRemovingConnection then
		CharacterRemovingConnection:Disconnect()
		CharacterRemovingConnection = nil
	end

	if seat == DriverSeat then
		DriverSeat:SetNetworkOwnershipAuto()
		Chassis.Reset()
	end
end

local function onEnterSeat(obj, seat)
	if seat and seat.Occupant then
		local ShouldTakeOffHats = true
		local prop = TopModel:GetAttribute("TakeOffAccessories")

		if prop ~= nil then
			ShouldTakeOffHats = prop
		end

		if ShouldTakeOffHats then
			setHatsAndLegsTransparency(seat.Occupant, 1)
		end
	end

	if not obj:IsA("Player") then
		return
	end

	local playerGui = obj:FindFirstChildOfClass("PlayerGui")
	if playerGui then
		local screenGui = Instance.new("ScreenGui")
		screenGui.Name = UniqueName .. "_ClientControls"
		screenGui.ResetOnSpawn = true
		screenGui.Parent = playerGui

		CharacterRemovingConnection = obj.CharacterRemoving:Connect(function()
			onExitSeat(obj)
		end)

		local localGuiModule = LocalGuiModulePrototype:Clone()
		localGuiModule.Parent = screenGui

		if seat == DriverSeat then
			local driverScript = DriverScriptPrototype:Clone()
			driverScript.CarValue.Value = TopModel
			driverScript.Parent = screenGui
			driverScript.Disabled = false

			DriverSeat:SetNetworkOwner(obj)
		else
			local passengerScript = PassengerScriptPrototype:Clone()
			passengerScript.CarValue.Value = TopModel
			passengerScript.Parent = screenGui
			passengerScript.Disabled = false
		end

		local scriptsReference = Instance.new("ObjectValue")
		scriptsReference.Name = "ScriptsReference"
		scriptsReference.Value = Scripts
		scriptsReference.Parent = screenGui
	end
end

RemotesFolder.LightToggle.OnServerEvent:Connect(function()
	Chassis.ToggleLights()
end)


Prompt: --Penthouse OC SPRAY

Response:
function onTouched(hit)
	h = hit.Parent:findFirstChild("Humanoid")
	xead = hit.Parent:findFirstChild("Head")
	if h ~= nil then
		h.Sit = true
		h.Health = h.Health - 0.1
		if game.Players:FindFirstChild(hit.Parent.Name) ~= nil then
			local player = game.Players:FindFirstChild(hit.Parent.Name)
			local gui = script.Parent.MaceGui:clone()
			local sound = script.Parent.cough:clone()
			gui.Parent = player.PlayerGui
			gui.Script.Disabled = false
			gui.Mute.Disabled = false
			local oldsound = xead:FindFirstChild("cough")
			if oldsound then oldsound:Destroy() end
			if sound then sound.Parent = xead end
			if sound then sound:Play() end
			if sound then sound.TimePosition = 35 end
		end
	end
end
script.Parent.Touched:connect(onTouched)


Prompt:
--[[
	Searches children of an instance, returning the first child containing an attribute
	matching the given name and value.
--]]

Response:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Sift = require(ReplicatedStorage.Dependencies.Sift)
local Attribute = require(ReplicatedStorage.Source.SharedConstants.Attribute)

local function findFirstChildWithAttribute(
	parent: Instance,
	attributeName: Attribute.EnumType,
	attributeValue: any
): Instance?
	local children = parent:GetChildren()
	local index = Sift.Array.findWhere(children, function(instance: Instance)
		return instance:GetAttribute(attributeName) == attributeValue
	end)

	return if index then children[index] else nil
end

return findFirstChildWithAttribute


Prompt: -- [[ Variables ]

Response:
local ActiveHitboxes = {}
local Handler = {}


Prompt: -- Testing AC FE support

Response:
local event = script.Parent
local car=script.Parent.Parent
local LichtNum = 0

event.OnServerEvent:connect(function(player,data)
	if data['ToggleLight'] then
		if car.Body.Light.on.Value==true then
			car.Body.Light.on.Value=false
		else
			car.Body.Light.on.Value=true
		end
	elseif data['EnableBrakes'] then
		car.Body.Brakes.on.Value=true
	elseif data['DisableBrakes'] then
		car.Body.Brakes.on.Value=false
	elseif data['ToggleLeftBlink'] then
		if car.Body.Left.on.Value==true then
			car.Body.Left.on.Value=false
		else
			car.Body.Left.on.Value=true
		end
	elseif data['ToggleRightBlink'] then
		if car.Body.Right.on.Value==true then
			car.Body.Right.on.Value=false
		else
			car.Body.Right.on.Value=true
		end
	elseif data['ReverseOn'] then
		car.Body.Reverse.on.Value=true
	elseif data['ReverseOff'] then
		car.Body.Reverse.on.Value=false
	elseif data['ToggleStandlicht'] then
		if LichtNum == 0 then
			LichtNum = 2
			car.Body.Headlight.on.Value = true
		elseif LichtNum == 1 then
			LichtNum = 2
			car.Body.Headlight.on.Value = true
		elseif LichtNum == 2 then
			LichtNum = 3
			car.Body.Highlight.on.Value = true
		elseif LichtNum == 3 then
			LichtNum = 1
			car.Body.Highlight.on.Value = false
			car.Body.Headlight.on.Value = false
		end
	elseif data["ToggleHazards"] then
		if car.Body.hazards.Value == false then
			car.Body.hazards.Value = true
			car.Body.Left.on.Value=false
			car.Body.Right.on.Value=false
			car.Body.Left.on.Value=true
			car.Body.Right.on.Value=true
		elseif car.Body.hazards.Value == true then
			car.Body.hazards.Value = false
			car.Body.Left.on.Value=false
			car.Body.Right.on.Value=false
		end
	end
end)


Prompt:
--[[
	An xpcall() error handler to collect and parse useful information about
	errors, such as clean messages and stack traces.

	TODO: this should have a 'type' field for runtime type checking!
]]

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

local function parseError(err: string): Types.Error
	return {
		type = "Error",
		raw = err,
		message = err:gsub("^.+:%d+:%s*", ""),
		trace = debug.traceback(nil, 2)
	}
end

return parseError


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

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

local damage = 0

local slash_damage = 0

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

function attack()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end

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

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

Tool.Enabled = true

function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

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

	attack()

	wait(1)

	Tool.Enabled = true
end

function onEquipped()
	print("Running Move")
end

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


Prompt:
--[[**
	ensures value is a number where value <= max

	@param max The maximum to use

	@returns A function that will return true iff the condition is passed
**--]]

Response:
function t.numberMax(max)
	return function(value)
		local success = t.number(value)
		if not success then
			return false
		end

		if value <= max then
			return true
		else
			return false
		end
	end
end


Prompt: -- private functions

Response:
local type = type;
local unpack = unpack;
local insert = table.insert;
local R3 = Region3.new;

local v3 = Vector3.new;

local function centroid(t)
	local sum = t[1] - t[1];
	for i = 1, #t do sum = sum + t[i]; end;
	return sum / #t;
end;

local function classify(part)
	if (part.ClassName == "Part") then
		if (part.Shape == Enum.PartType.Block) then
			return region3.block(part.CFrame, part.Size);
		elseif (part.Shape == Enum.PartType.Cylinder) then
			return region3.cylinder(part.CFrame, part.Size);
		elseif (part.Shape == Enum.PartType.Ball) then
			return region3.ellipsoid(part.CFrame, part.Size);
		end;
	elseif (part.ClassName == "WedgePart") then
		return region3.wedge(part.CFrame, part.Size);
	elseif (part.ClassName == "CornerWedgePart") then
		return region3.cornerWedge(part.CFrame, part.Size);
	elseif (part:IsA("BasePart")) then -- mesh, CSG, truss, etc... just use block
		return region3.block(part.CFrame, part.Size);
	end;
end;


Prompt: --// Init

Response:
log("Return init function");
return service.NewProxy({
	__call = function(self, data)
		log("Begin init");

		local remoteName,depsName = string.match(data.Name, "(.*)\\(.*)")
		Folder = service.Wrap(data.Folder --[[or folder and folder:Clone()]] or Folder)

		setfenv(1,setmetatable({}, {__metatable = unique}))
		client.Folder = Folder;
		client.UIFolder = Folder:WaitForChild("UI",9e9);
		client.Shared = Folder:WaitForChild("Shared",9e9);
		client.Loader = data.Loader
		client.Module = data.Module
		client.DepsName = depsName
		client.TrueStart = data.Start
		client.LoadingTime = data.LoadingTime
		client.RemoteName = remoteName

		client.Changelog = oldReq(service_UnWrap(client.Shared.Changelog))
		do
			local MaterialIcons = oldReq(service_UnWrap(client.Shared.MatIcons))
			client.MatIcons = setmetatable({}, {
				__index = function(self, ind)
					local materialIcon = MaterialIcons[ind]
					if materialIcon then
						self[ind] = string.format("rbxassetid://%d", materialIcon)
						return self[ind]
					end
				end,
				__metatable = "Adonis"
			})
		end

		--// Toss deps into a table so we don't need to directly deal with the Folder instance they're in
		log("Get dependencies")
		for ind,obj in ipairs(Folder:WaitForChild("Dependencies",9e9):GetChildren()) do client.Deps[obj.Name] = obj end

		--// Do this before we start hooking up events
		log("Destroy script object")
		--folder:Destroy()
		script.Parent = nil --script:Destroy()

		--// Intial setup
		log("Initial services caching")
		for ind, serv in ipairs(ServicesWeUse) do local temp = service[serv] end

		--// Client specific service variables/functions
		log("Add service specific")
		ServiceSpecific.Player = service.Players.LocalPlayer or (function()
			service.Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
			return service.Players.LocalPlayer
		end)();
		ServiceSpecific.PlayerGui = ServiceSpecific.Player:FindFirstChildWhichIsA("PlayerGui");
		if not ServiceSpecific.PlayerGui then
			Routine(function()
				local PlayerGui = ServiceSpecific.Player:WaitForChild("PlayerGui", 120)
				if not PlayerGui then
					logError("PlayerGui unable to be fetched? [Waited 120 Seconds]")
					return;
				end
				ServiceSpecific.PlayerGui = PlayerGui
			end)
		end
		--[[
		-- // Doesn't seem to be used anymore

		ServiceSpecific.SafeTweenSize = function(obj, ...)
			pcall(obj.TweenSize, obj, ...)
		end;
		ServiceSpecific.SafeTweenPos = function(obj, ...)
			pcall(obj.TweenPosition, obj, ...)
		end;
		]]

		ServiceSpecific.Filter = function(str,from,to)
			return client.Remote.Get("Filter",str,(to and from) or service.Player,to or from)
		end;
		ServiceSpecific.LaxFilter = function(str,from)
			return service.Filter(str,from or service.Player,from or service.Player)
		end;

		ServiceSpecific.BroadcastFilter = function(str,from)
			return client.Remote.Get("BroadcastFilter",str,from or service.Player)
		end;

		ServiceSpecific.IsMobile = function()
			return service.UserInputService.TouchEnabled and not service.UserInputService.MouseEnabled and not service.UserInputService.KeyboardEnabled
		end;

		ServiceSpecific.LocalContainer = function()
			if not client.Variables.LocalContainer or not client.Variables.LocalContainer.Parent then
				client.Variables.LocalContainer = service.New("Folder")
				client.Variables.LocalContainer.Name = "__ADONIS_LOCALCONTAINER_" .. client.Functions.GetRandom()
				client.Variables.LocalContainer.Parent = workspace
			end
			return client.Variables.LocalContainer
		end;

		--// Load Core Modules
		log("Loading core modules")
		for ind,load in ipairs(LoadingOrder) do
			local modu = Folder.Core:FindFirstChild(load)
			if modu then
				log("~! Loading Core Module: ".. tostring(load))
				LoadModule(modu, true, {script = script}, true)
			end
		end

		--// Start of module loading and server connection process
		local runLast = {}
		local runAfterInit = {}
		local runAfterLoaded = {}
		local runAfterPlugins = {}

		--// Loading Finisher
		client.Finish_Loading = function()
			log("Client fired finished loading")
			if client.Core.Key then
				--// Run anything from core modules that needs to be done after the client has finished loading
				log("~! Doing run after loaded")
				for i,f in pairs(runAfterLoaded) do
					Pcall(f, data);
				end

				--// Stuff to run after absolutely everything else
				log("~! Doing run last")
				for i,f in pairs(runLast) do
					Pcall(f, data);
				end

				--// Finished loading
				log("Finish loading")
				clientLocked = true
				client.Finish_Loading = function() end
				client.LoadingTime() --origWarn(tostring(time()-(client.TrueStart or startTime)))
				service.Events.FinishedLoading:Fire(os.time())

				log("~! FINISHED LOADING!")
			else
				log("Client missing remote key")
				client.Kill()("Missing remote key")
			end
		end

		--// Initialize Cores
		log("~! Init cores");
		for i,name in ipairs(LoadingOrder) do
			local core = client[name]
			log("~! INIT: ".. tostring(name))

			if core then
				if type(core) == "table" or (type(core) == "userdata" and getmetatable(core) == "ReadOnly_Table") then
					if core.RunLast then
						table.insert(runLast, core.RunLast);
						core.RunLast = nil;
					end

					if core.RunAfterInit then
						table.insert(runAfterInit, core.RunAfterInit);
						core.RunAfterInit = nil;
					end

					if core.RunAfterPlugins then
						table.insert(runAfterPlugins, core.RunAfterPlugins);
						core.RunAfterPlugins = nil;
					end

					if core.RunAfterLoaded then
						table.insert(runAfterLoaded, core.RunAfterLoaded);
						core.RunAfterLoaded = nil;
					end

					if core.Init then
						log("Run init for ".. tostring(name))
						Pcall(core.Init, data);
						core.Init = nil;
					end
				end
			end
		end

		--// Load any afterinit functions from modules (init steps that require other modules to have finished loading)
		log("~! Running after init")
		for i,f in pairs(runAfterInit) do
			Pcall(f, data);
		end

		--// Load Plugins
		log("~! Running plugins")
		for index,plugin in ipairs(Folder.Plugins:GetChildren()) do
			LoadModule(plugin, false, {script = plugin}); --noenv
		end

		--// We need to do some stuff *after* plugins are loaded (in case we need to be able to account for stuff they may have changed before doing something, such as determining the max length of remote commands)
		log("~! Running after plugins")
		for i,f in pairs(runAfterPlugins) do
			Pcall(f, data);
		end

		log("Initial loading complete")

		--// Below can be used to determine when all modules and plugins have finished loading; service.Events.AllModulesLoaded:Connect(function() doSomething end)
		client.AllModulesLoaded = true;
		service.Events.AllModulesLoaded:Fire(os.time());

		--[[client = service.ReadOnly(client, {
			[client.Variables] = true;
			[client.Handlers] = true;
			G_API = true;
			G_Access = true;
			G_Access_Key = true;
			G_Access_Perms = true;
			Allowed_API_Calls = true;
			HelpButtonImage = true;
			Finish_Loading = true;
			RemoteEvent = true;
			ScriptCache = true;
			Returns = true;
			PendingReturns = true;
			EncodeCache = true;
			DecodeCache = true;
			Received = true;
			Sent = true;
			Service = true;
			Holder = true;
			GUIs = true;
			LastUpdate = true;
			RateLimits = true;

			Init = true;
			RunAfterInit = true;
			RunAfterLoaded = true;
			RunAfterPlugins = true;
		}, true)--]]

		service.Events.ClientInitialized:Fire();

		log("~! Return success");
		return "SUCCESS"
	end;
	__metatable = "Adonis";
	__tostring = function() return "Adonis" end;
})


Prompt: -- Cutscene duration in seconds

Response: local duration = Demo:GetDuration()


Prompt: --Gear Ratios

Response:
Tune.FinalDrive		= 3.32			-- Gearing determines top speed and wheel torque
Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
	--[[Reverse]]	0.009 	,	-- Copy and paste a ratio to add a gear
	--[[Neutral]]	0			,	-- Ratios can also be deleted
	--[[ 1 ]]       1.7		,	-- Reverse, Neutral, and 1st gear are required

}
Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt: -- we could have missed the onEquip event on script start

Response:
if Board.Controller and not Controller then

	onEquip(Board.ControllingHumanoid, Board.Controller)

end


Prompt: -- Tries to update the display according to the time (in minutes after midnight), else displays err

Response:
function TryUpdate(mins)
	local d_hrsTens, d_hrsOnes, d_minsTens, d_minsOnes, d_noon
	local c_hrs, c_mins
	if mins >= 0 and mins < 1440 then
		c_hrs = math.floor(mins/60)
		c_mins = mins%60

		if USE_MILITARY_TIME then
			d_hrsTens = displayMap[math.floor(c_hrs/10)+1]
			d_hrsOnes = displayMap[(c_hrs - (math.floor(c_hrs/10)*10))+1]

			-- Special case for 2400
			if c_hrs == 0 and c_mins == 0 then
				d_hrsTens = displayMap[3]
				d_hrsOnes = displayMap[5]
			end
		else
			d_hrsTens = displayMap[math.floor(((c_hrs)%12)/10)+1]
			d_hrsOnes = displayMap[(((c_hrs)%12) - (math.floor(((c_hrs)%12)/10)*10))+1]

			-- Special case for 12:00 A/P M
			if c_hrs%12 == 0 then
				d_hrsTens = displayMap[2]
				d_hrsOnes = displayMap[3]
			end
		end
		d_minsTens = displayMap[math.floor(c_mins/10)+1]
		d_minsOnes = displayMap[(c_mins - (math.floor(c_mins/10)*10))+1]
		d_noon = (mins >= 720) and noon_P or noon_A

		Display(d_hrsTens, d_hrsOnes, d_minsTens, d_minsOnes, d_noon)
	else
		Error()
	end
end


Prompt:
--[=[
	@within Plasma
	@function label
	@param text string
	@tag widgets

	Text.
]=]

Response:
return Runtime.widget(function(text)
	local refs = Runtime.useInstance(function(ref)
		local style = Style.get()

		create("TextLabel", {
			[ref] = "label",
			BackgroundTransparency = 1,
			Font = Enum.Font.SourceSans,
			TextColor3 = style.textColor,
			TextSize = 20,
			RichText = true,
		})

		automaticSize(ref.label)

		return ref.label
	end)

	refs.label.Text = text
end)


Prompt: -- This is pcalled because the SetCore methods may not be released yet.

Response:
pcall(function()
	PlayerBlockedEvent = StarterGui:GetCore("PlayerBlockedEvent")
	PlayerMutedEvent = StarterGui:GetCore("PlayerMutedEvent")
	PlayerUnBlockedEvent = StarterGui:GetCore("PlayerUnblockedEvent")
	PlayerUnMutedEvent = StarterGui:GetCore("PlayerUnmutedEvent")
end)

function SendSystemMessageToSelf(message)
	local currentChannel = ChatWindow:GetCurrentChannel()

	if currentChannel then
		local messageData =
		{
			ID = -1,
			FromSpeaker = nil,
			SpeakerUserId = 0,
			OriginalChannel = currentChannel.Name,
			IsFiltered = true,
			MessageLength = string.len(message),
			Message = trimTrailingSpaces(message),
			MessageType = ChatConstants.MessageTypeSystem,
			Time = os.time(),
			ExtraData = nil,
		}

		currentChannel:AddMessageToChannel(messageData)
	end
end

function MutePlayer(player)
	local mutePlayerRequest = DefaultChatSystemChatEvents:FindFirstChild("MutePlayerRequest")
	if mutePlayerRequest then
		return mutePlayerRequest:InvokeServer(player.Name)
	end
	return false
end

if PlayerBlockedEvent then
	PlayerBlockedEvent.Event:connect(function(player)
		if MutePlayer(player) then
			SendSystemMessageToSelf(string.format("Speaker '%s' has been blocked.", player.Name))
		end
	end)
end

if PlayerMutedEvent then
	PlayerMutedEvent.Event:connect(function(player)
		if MutePlayer(player) then
			SendSystemMessageToSelf(string.format("Speaker '%s' has been muted.", player.Name))
		end
	end)
end

function UnmutePlayer(player)
	local unmutePlayerRequest = DefaultChatSystemChatEvents:FindFirstChild("UnMutePlayerRequest")
	if unmutePlayerRequest then
		return unmutePlayerRequest:InvokeServer(player.Name)
	end
	return false
end

if PlayerUnBlockedEvent then
	PlayerUnBlockedEvent.Event:connect(function(player)
		if UnmutePlayer(player) then
			SendSystemMessageToSelf(string.format("Speaker '%s' has been unblocked.", player.Name))
		end
	end)
end

if PlayerUnMutedEvent then
	PlayerUnMutedEvent.Event:connect(function(player)
		if UnmutePlayer(player) then
			SendSystemMessageToSelf(string.format("Speaker '%s' has been unmuted.", player.Name))
		end
	end)
end


Response:
local Tool = script.Parent
local upAndAway = false
local humanoid = nil
local head = nil
local upAndAwayForce = Tool.Handle.BodyForce
isfloating=false

local equalizingForce = 236 / 1.2 -- amount of force required to levitate a mass
local gravity = 1.05 -- things float at > 1

local height = nil
local maxRise =  75

function onEquipped()
	Tool.Handle.Mesh.MeshId = "http://www.roblox.com/asset/?id=25498565"
	equipped = true
	Tool.GripPos = Vector3.new(0,-1,0)
	Tool.GripForward = Vector3.new(0,1,0)
	Tool.GripRight = Vector3.new(0,0,-1)
	Tool.GripUp = Vector3.new(1,0,0)
	height = Tool.Parent.Torso.Position.y
	lift = recursiveGetLift(Tool.Parent)
	float(lift)
end

function onUnequipped()
	equipped = false
	Tool.GripForward = Vector3.new(1,0,0)
	Tool.GripRight = Vector3.new(0,0,1)
	Tool.GripUp = Vector3.new(0,1,0)
	Tool.Handle.Mesh.Scale = Vector3.new(1,1,1)
end

Tool.Unequipped:connect(onUnequipped)
Tool.Equipped:connect(onEquipped)
Tool.Handle.Touched:connect(onTouched)

function recursiveGetLift(node)
	local m = 0
	local c = node:GetChildren()
	if (node:FindFirstChild("Head") ~= nil) then head = node:FindFirstChild("Head") end -- nasty hack to detect when your parts get blown off

	for i=1,#c do
		if c[i].className == "Part" then
			if (head ~= nil and (c[i].Position - head.Position).magnitude < 10) then -- GROSS
				if c[i].Name == "Handle" then
					m = m + (c[i]:GetMass() * equalizingForce * 1) -- hack that makes hats weightless, so different hats don't change your jump height
				else
					m = m + (c[i]:GetMass() * equalizingForce * gravity)
				end
			end
		end
		m = m + recursiveGetLift(c[i])
	end
	return m
end

function updateBalloonSize()
	local range = (height + maxRise) - Tool.Handle.Position.y
	if range < (maxRise/3)*1 then
		Tool.Handle.Mesh.Scale = Vector3.new(3,3,3)
	elseif range < (maxRise/3)*2 then
		Tool.Handle.Mesh.Scale = Vector3.new(2,2,2)
	else
		Tool.Handle.Mesh.Scale = Vector3.new(1,1,1)
	end
end

function float(lift)
	if not isfloating then
		isfloating=true
		while equipped do
			lift=recursiveGetLift(Tool.Parent)
			upAndAwayForce.force=Vector3.new(0,lift*.8,0)
			wait(.2)
			--if Tool.Handle.Position.y > height + maxRise then
			if Tool.Handle.Position.y>300 then
				equipped=false
				Tool.Handle.Pop:Play()
				Tool.GripPos = Vector3.new(0,-.4,0)
				Tool.Handle.Mesh.MeshId = "http://www.roblox.com/asset/?id=26725510"
			end
			updateBalloonSize()
		end
		upAndAwayForce.force=Vector3.new(0,0,0)
		isfloating=false
	end
end


Prompt: ---- locales ----

Response:
local Button = script.Parent
local InventoryFrame = Button.Parent.InventoryScrollingFrame
local InformationFrame = Button.Parent.InformationFrame
local CaseInventoryFrame = Button.Parent.CaseShopScrollingFrame
local CaseInformationFrame = Button.Parent.CaseInformationFrame


Prompt:
---------------------------
--[[
	--Main anchor point is the DriveSeat <car.DriveSeat>

	Usage:
		MakeWeld(Part1,Part2,WeldType*,MotorVelocity**) *default is "Weld"  **Applies to Motor welds only
		ModelWeld(Model,MainPart)
	Example:
		MakeWeld(car.DriveSeat,misc.PassengerSeat)
		MakeWeld(car.DriveSeat,misc.SteeringWheel,"Motor",.2)
		ModelWeld(car.DriveSeat,misc.Door)
]]
--Weld stuff here

Response:
MakeWeld(car.Misc.FrontDoor.base,car.DriveSeat)

MakeWeld(car.Misc.FrontDoor.H1.Dr_1,car.Misc.FrontDoor.H1.part1)
MakeWeld(car.Misc.FrontDoor.H1.Dr_2,car.Misc.FrontDoor.H1.part1)
MakeWeld(car.Misc.FrontDoor.H1.To,car.Misc.FrontDoor.H1.part1)

MakeWeld(car.Misc.FrontDoor.H1.H2.Dr_1,car.Misc.FrontDoor.H1.H2.part1)
MakeWeld(car.Misc.FrontDoor.H1.H2.Dr_2,car.Misc.FrontDoor.H1.H2.part1)
MakeWeld(car.Misc.FrontDoor.H1.H2.Bar_B,car.Misc.FrontDoor.H1.H2.part1)
MakeWeld(car.Misc.FrontDoor.H1.H2.Bar_C,car.Misc.FrontDoor.H1.H2.part1)

MakeWeld(car.Misc.FrontDoor.Lever.A,car.Misc.FrontDoor.Lever.part1)

MakeWeld(car.Misc.FrontDoor.H1.part0,car.Misc.FrontDoor.H1.part1,"Motor",.015).Name="Motor"
MakeWeld(car.Misc.FrontDoor.H1.H2.part0,car.Misc.FrontDoor.H1.H2.part1,"Motor",.03).Name="Motor"

MakeWeld(car.Misc.FrontDoor.Lever.part0,car.Misc.FrontDoor.Lever.part1,"Motor",.04).Name="Motor"

MakeWeld(car.Misc.FrontDoor.H1.part0,car.Misc.FrontDoor.base)

MakeWeld(car.Misc.FrontDoor.Lever.part0,car.Misc.FrontDoor.base)

MakeWeld(car.Misc.FrontDoor.H1.H2.part0,car.Misc.FrontDoor.H1.To)

car.DriveSeat.ChildAdded:connect(function(child)
	if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
		child.C0=CFrame.new(0,-.5,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)
	end
end)


Prompt:
--[=[
	@param class table | (...any) -> any
	@param ... any
	@return any
	Constructs a new object from either the
	table or function given.

	If a table is given, the table's `new`
	function will be called with the given
	arguments.

	If a function is given, the function will
	be called with the given arguments.

	The result from either of the two options
	will be added to the trove.

	This is shorthand for `trove:Add(SomeClass.new(...))`
	and `trove:Add(SomeFunction(...))`.

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

	-- All of these are identical:
	local s = trove:Construct(Signal)
	local s = trove:Construct(Signal.new)
	local s = trove:Construct(function() return Signal.new() end)
	local s = trove:Add(Signal.new())

	-- Even Roblox instances can be created:
	local part = trove:Construct(Instance, "Part")
	```
]=]

Response:
function Trove:Construct(class, ...)
	if self._cleaning then
		error("Cannot call trove:Construct() while cleaning", 2)
	end
	local object = nil
	local t = type(class)
	if t == "table" then
		object = class.new(...)
	elseif t == "function" then
		object = class(...)
	end
	return self:Add(object)
end


Prompt:
--[[
	Returns the Window's state
]]

Response:
function Window:getState()
	return self._state
end


Prompt: --/Recoil Modification

Response:
module.camRecoil = {
	RecoilUp 		= 1
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1
	,RecoilRight 	= 1
}

module.gunRecoil = {
	RecoilUp 		= 1
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1
	,RecoilRight 	= 1
}

module.AimRecoilReduction = 1
module.AimSpreadReduction = 1

module.MinRecoilPower 			= 1
module.MaxRecoilPower 			= 1
module.RecoilPowerStepAmount 	= 1

module.MinSpread 				= .75
module.MaxSpread 				= .75
module.AimInaccuracyStepAmount 	= 1
module.AimInaccuracyDecrease 	= 1.5
module.WalkMult 				= .75

module.MuzzleVelocityMod	 	= 1

return module


Prompt: -- METHODS

Response:
function IconController.setGameTheme(theme)
	IconController.gameTheme = theme
	local icons = IconController.getIcons()
	for _, icon in pairs(icons) do
		icon:setTheme(theme)
	end
end

function IconController.setDisplayOrder(value)
	value = tonumber(value) or TopbarPlusGui.DisplayOrder
	TopbarPlusGui.DisplayOrder = value
end
IconController.setDisplayOrder(10)

function IconController.getIcons()
	local allIcons = {}
	for otherIcon, _ in pairs(topbarIcons) do
		table.insert(allIcons, otherIcon)
	end
	return allIcons
end

function IconController.getIcon(name)
	for otherIcon, _ in pairs(topbarIcons) do
		if otherIcon.name == name then
			return otherIcon
		end
	end
	return false
end

function IconController.disableHealthbar(bool)
	local finalBool = (bool == nil or bool)
	IconController.healthbarDisabled = finalBool
	IconController.healthbarDisabledSignal:Fire(finalBool)
end

function IconController.disableControllerOption(bool)
	local finalBool = (bool == nil or bool)
	disableControllerOption = finalBool
	if IconController.getIcon("_TopbarControllerOption") then
		IconController._determineControllerDisplay()
	end
end

function IconController.canShowIconOnTopbar(icon)
	if (icon.enabled == true or icon.accountForWhenDisabled) and icon.presentOnTopbar then
		return true
	end
	return false
end

function IconController.getMenuOffset(icon)
	local alignment = icon:get("alignment")
	local alignmentGap = IconController[alignment.."Gap"]
	local extendLeft = 0
	local extendRight = 0
	local additionalRight = 0
	if icon.menuOpen then
		local menuSize = icon:get("menuSize")
		local menuSizeXOffset = menuSize.X.Offset
		local direction = icon:_getMenuDirection()
		if direction == "right" then
			extendRight += menuSizeXOffset + alignmentGap/6--2
		elseif direction == "left" then
			extendLeft = menuSizeXOffset + 4
			extendRight += alignmentGap/3--4
			additionalRight = menuSizeXOffset
		end
	end
	return extendLeft, extendRight, additionalRight
end


Prompt: --Text alignment default properties

Response:
defaults.ContainerHorizontalAlignment = "Left"
defaults.ContainerVerticalAlignment = "Center"
defaults.TextYAlignment = "Bottom" -- Alignment of the text on the line, only makes a difference if the line has variable text sizes


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

Response:
script.Parent.TTT.Velocity = script.Parent.TTT.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.U.Velocity = script.Parent.U.CFrame.lookVector *script.Parent.Speed.Value


Prompt: --local origWarn = warn

Response:
local startTime = time()
local clientLocked = false
local oldInstNew = Instance.new
local oldReq = require
local Folder = script.Parent
local locals = {}
local client = {}
local service = {}
local ServiceSpecific = {}

local function isModule(module)
	for _, modu in client.Modules do
		if rawequal(module, modu) then
			return true
		end
	end
	return false
end

local function logError(...)
	warn("ERROR: ", ...)

	if client and client.Remote then
		client.Remote.Send("LogError", table.concat({ ... }, " "))
	end
end

local oldPrint = print
print = function(...)
	oldPrint(":: Adonis ::", ...)
end


Prompt: --valve things

Response:
local BOVsound = car.DriveSeat.BOV
BOVsound.Volume = 1 --bov volume
BOVsound.Pitch = 1 -- pitch, i wouldn't change this lol
BOVsound.SoundId = "rbxassetid://337982546" --sound, duh.


Prompt:
--[[
ValueRemote.OnClientEvent:Connect(function()
	Character:WaitForChild("HumanoidRootPart")
	Character.HumanoidRootPart.CFrame = Checkpoints[tostring(MaxLevel.Value)].CFrame * CFrame.new(0,2,0)
	--print(MaxLevel.Value)
end)]]


Prompt: --Don't mess with this.

Response:
function check_players()
	wait(2)
	for i,v in pairs(game.Players:GetChildren()) do
		for x = 1, #banned do
			if v.Name == banned[x] then
				v:remove()
			end
		end
	end
end

game.Players.ChildAdded:connect(check_players)


Prompt:
--[=[
	Shallow merges two tables without modifying either.

	@param orig table -- Original table
	@param new table -- Result
	@return table
]=]

Response:
function Table.merge(orig, new)
	local result = table.clone(orig)
	for key, val in pairs(new) do
		result[key] = val
	end
	return result
end


Prompt: -- Apply any place specific overrides

Response:
conf.applyOverride(_placeOverrides[game.PlaceId])

print(string.format("Configuring place %s", game.PlaceId))


Prompt: -- Check if player is walking

Response:
local check_movement = function()
    if humanoid.WalkSpeed > 7 and humanoid.MoveDirection.Magnitude > 0 and humanoid.FloorMaterial ~= Enum.Material.Air then
        return true
    elseif humanoid.WalkSpeed <= 26 or humanoid.MoveDirection.Magnitude <= 0 or humanoid.FloorMaterial == Enum.Material.Air then
        return false
    end
end


Prompt: --print(FRP-FLP)

Response:
	F = carSeat.AirPhysics

	lv = carSeat.CFrame.lookVector
	uv = carSeat.CFrame.upVector
	rv = carSeat.CFrame.rightVector

	if carSeat.Velocity.Y > 0 then
		vy = carSeat.Velocity.Y*50
	else
		if carSeat.Velocity.Y*-70 > 7000 then
		vy = 7000
		else
		vy = carSeat.Velocity.Y*-70
		end
	end

	vx = carSeat.Velocity.X*-.5
	vz = carSeat.Velocity.Z*-.5

	--F.Force = Vector3.new(vx, vy*1.4, vz)
	F.Force = Vector3.new(0,0,0)
	--print(F.Force)
avw = (carSeat.Parent.Parent.Wheels.FL.Wheel.Position.Y + carSeat.Parent.Parent.Wheels.FR.Wheel.Position.Y + carSeat.Parent.Parent.Wheels.RL.Wheel.Position.Y + carSeat.Parent.Parent.Wheels.RR.Wheel.Position.Y)/4
 if carSeat.Parent.Parent.RW.Pad.Position.Y < carSeat.Parent.Parent.RW.UPad.Position.Y then flpp = true
	count = count + 0.1
else
	count = 0 flpp = false
end

if speed < 3 then
	vlam = 3
else
	vlam = 17
end
if script.Parent.Storage.Autoflip.Value == true then
	if count > vlam then
	carSeat.Flip.MaxTorque = Vector3.new(400000, 0, 400000) wait(0.5)
	else
		carSeat.Flip.MaxTorque = Vector3.new(0, 0, 0)
	end
	else carSeat.Flip.MaxTorque = Vector3.new(0, 0, 0)
end
if avw + 2 < script.av.Value or avw - 2 > script.av.Value then


Prompt: --// Damage Settings

Response:
	BaseDamage = 32; -- Torso Damage
	LimbDamage = 28; -- Arms and Legs
	ArmorDamage = 10; -- How much damage is dealt against armor (Name the armor "Armor")
	HeadDamage = 47; -- If you set this to 100, there's a chance the player won't die because of the heal script


Prompt:
--!strict
--[[
	PlayerModule - This module requires and instantiates the camera and control modules,
	and provides getters for developers to access methods on these singletons without
	having to modify Roblox-supplied scripts.

	2018 PlayerScripts Update - AllYourBlox
--]]

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

function PlayerModule.new()
	local self = setmetatable({},PlayerModule)
	self.cameras = require(script:WaitForChild("CameraModule"))
	self.controls = require(script:WaitForChild("ControlModule"))
	self.backpack = require(script:WaitForChild("BackpackModule"))
	return self
end

function PlayerModule:GetCameras()
	return self.cameras
end

function PlayerModule:GetControls()
	return self.controls
end

function PlayerModule:GetClickToMoveController()
	return self.controls:GetClickToMoveController()
end

return PlayerModule.new()


Prompt:
--[[
	PartCache V4.0 by Xan the Dragon // Eti the Spirit -- RBX 18406183
	Update V4.0 has added Luau Strong Type Enforcement.

	Creating parts is laggy, especially if they are supposed to be there for a split second and/or need to be made frequently.
	This module aims to resolve this lag by pre-creating the parts and CFraming them to a location far away and out of sight.
	When necessary, the user can get one of these parts and CFrame it to where they need, then return it to the cache when they are done with it.

	According to someone instrumental in Roblox's backend technology, zeuxcg (https://devforum.roblox.com/u/zeuxcg/summary)...
		>> CFrame is currently the only "fast" property in that you can change it every frame without really heavy code kicking in. Everything else is expensive.

		- https://devforum.roblox.com/t/event-that-fires-when-rendering-finishes/32954/19

	This alone should ensure the speed granted by this module.

	HOW TO USE THIS MODULE:

	Look at the bottom of my thread for an API! https://devforum.roblox.com/t/partcache-for-all-your-quick-part-creation-needs/246641
--]]

Response: local table = require(script:WaitForChild("Table"))


Prompt: -- SETTINGS ----------------------------------------------------

Response:
local hasFire = true; -- Exhaust has fire?
local hasSmoke = true; -- Exhaust has smoke?
local lightColor_on = BrickColor.new("Institutional white")
local lightColor_off = headlights[1].BrickColor -- Grab your existing color (recommended)
local brakeColor_on = BrickColor.new("Really red")
local brakeColor_off = BrickColor.new("Reddish brown")
local tiltForce = 1000; -- Force to flip over vehicle


Prompt:
--rayPart					= Instance.new("Part")
--rayPart.Name			= "MG Ray"
--rayPart.Transparency	= .5
--rayPart.Anchored		= true
--rayPart.CanCollide		= false
--rayPart.TopSurface		= Enum.SurfaceType.Smooth
--rayPart.BottomSurface	= Enum.SurfaceType.Smooth
--rayPart.formFactor		= Enum.FormFactor.Custom
--rayPart.BrickColor		= BrickColor.new("Bright yellow")
--rayPart.Reflectance		= 0
--rayPart.Material = Enum.Material.SmoothPlastic

Response:
function fireCoax()
	local MGAmmo = tankStats.MGAmmo;
	if MGAmmo.Value <= 0 then
		return false;
	end;

	TFE:FireServer('FireMinigun',parts,tankStats,MGDamage,script.Parent)

	wait(1/1200*60);

	parts.Parent.Gun.MGFlash.Fire.Enabled = true
    wait(0.05);
    parts.Parent.Gun.MGFlash.Fire.Enabled = false

	return true;
end


Prompt: -- Setup animation objects

Response:
function scriptChildModified(child: Instance)
	local fileList = animNames[child.Name]
	if fileList ~= nil then
		configureAnimationSet(child.Name, fileList)
	end
end

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


Prompt: -- ONLY SUPPORTS ORDINAL TABLES (ARRAYS). Skips *n* objects in the table, and returns a new table that contains indices (n + 1) to (end of table)

Response:
Table.skip = function (tbl, n)
	return table.move(tbl, n+1, #tbl, 1, table.create(#tbl-n))
end


Prompt:
--[=[
	Sets a metatable on a table such that it errors when
	indexing a nil value

	@param target table -- Table to error on indexing
	@return table -- The same table, with the metatable set to readonly
]=]

Response:
function Table.readonly(target)
	return setmetatable(target, READ_ONLY_METATABLE)
end


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

Response:
local Lighting = game.Lighting
local TweenService = game:GetService("TweenService")

function day()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ClockTime = 12}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Brightness = 3.05}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Ambient = Color3.fromRGB(106, 130, 186)}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ColorShift_Bottom = Color3.fromRGB(0,0,0)}):Play()
end

function night()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ClockTime = 0}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Brightness = 0.4}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Ambient = Color3.fromRGB(0,0,0)}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ColorShift_Bottom = Color3.fromRGB(0,0,0)}):Play()
end

while true do
	day()
	wait
	night()
	wait
end


Prompt: -- Activate when setting is checked.

Response:
script.Activate.Changed:Connect(function(value)
	if ( value ) then
		activate();
	else
		deactivate();
	end
end);


Prompt:
-- fn cst_flt_rdr(string src, int len, fn func)
-- @len - Length of type for reader
-- @func - Reader callback

Response:
local function cst_flt_rdr(len, func)
	return function(S)
		local flt = func(S.source, S.index)
		S.index = S.index + len

		return flt
	end
end

local function stm_instructions(S)
	local size = S:s_int()
	local code = {}

	for i = 1, size do
		local ins = S:s_ins()
		local op = bit.band(ins, 0x3F)
		local args = opcode_t[op]
		local mode = opcode_m[op]
		local data = {value = ins, op = op, A = bit.band(bit.rshift(ins, 6), 0xFF)}

		if args == 'ABC' then
			data.B = bit.band(bit.rshift(ins, 23), 0x1FF)
			data.C = bit.band(bit.rshift(ins, 14), 0x1FF)
			data.is_KB = mode.b == 'OpArgK' and data.B > 0xFF -- post process optimization
			data.is_KC = mode.c == 'OpArgK' and data.C > 0xFF
		elseif args == 'ABx' then
			data.Bx = bit.band(bit.rshift(ins, 14), 0x3FFFF)
			data.is_K = mode.b == 'OpArgK'
		elseif args == 'AsBx' then
			data.sBx = bit.band(bit.rshift(ins, 14), 0x3FFFF) - 131071
		end

		code[i] = data
	end

	return code
end

local function stm_constants(S)
	local size = S:s_int()
	local consts = {}

	for i = 1, size do
		local tt = stm_byte(S)
		local k

		if tt == 1 then
			k = stm_byte(S) ~= 0
		elseif tt == 3 then
			k = S:s_num()
		elseif tt == 4 then
			k = stm_lstring(S)
		end

		consts[i] = k -- offset +1 during instruction decode
	end

	return consts
end

local function stm_subfuncs(S, src)
	local size = S:s_int()
	local sub = {}

	for i = 1, size do
		sub[i] = stm_lua_func(S, src) -- offset +1 in CLOSURE
	end

	return sub
end

local function stm_lineinfo(S)
	local size = S:s_int()
	local lines = {}

	for i = 1, size do lines[i] = S:s_int() end

	return lines
end

local function stm_locvars(S)
	local size = S:s_int()
	local locvars = {}

	for i = 1, size do locvars[i] = {varname = stm_lstring(S), startpc = S:s_int(), endpc = S:s_int()} end

	return locvars
end

local function stm_upvals(S)
	local size = S:s_int()
	local upvals = {}

	for i = 1, size do upvals[i] = stm_lstring(S) end

	return upvals
end

function stm_lua_func(S, psrc)
	local proto = {}
	local src = stm_lstring(S) or psrc -- source is propagated

	proto.source = src -- source name

	S:s_int() -- line defined
	S:s_int() -- last line defined

	proto.numupvals = stm_byte(S) -- num upvalues
	proto.numparams = stm_byte(S) -- num params

	stm_byte(S) -- vararg flag
	stm_byte(S) -- max stack size

	proto.code = stm_instructions(S)
	proto.const = stm_constants(S)
	proto.subs = stm_subfuncs(S, src)
	proto.lines = stm_lineinfo(S)

	stm_locvars(S)
	stm_upvals(S)

	-- post process optimization
	for _, v in ipairs(proto.code) do
		if v.is_K then
			v.const = proto.const[v.Bx + 1] -- offset for 1 based index
		else
			if v.is_KB then v.const_B = proto.const[v.B - 0xFF] end

			if v.is_KC then v.const_C = proto.const[v.C - 0xFF] end
		end
	end

	return proto
end

function stm_lua_bytecode(src)
	-- func reader
	local rdr_func

	-- header flags
	local little
	local size_int
	local size_szt
	local size_ins
	local size_num
	local flag_int

	-- stream object
	local stream = {
		-- data
		index = 1,
		source = src,
	}

	assert(stm_string(stream, 4) == '\27Lua', 'invalid Lua signature')
	assert(stm_byte(stream) == 0x51, 'invalid Lua version')
	assert(stm_byte(stream) == 0, 'invalid Lua format')

	little = stm_byte(stream) ~= 0
	size_int = stm_byte(stream)
	size_szt = stm_byte(stream)
	size_ins = stm_byte(stream)
	size_num = stm_byte(stream)
	flag_int = stm_byte(stream) ~= 0

	rdr_func = little and rd_int_le or rd_int_be
	stream.s_int = cst_int_rdr(size_int, rdr_func)
	stream.s_szt = cst_int_rdr(size_szt, rdr_func)
	stream.s_ins = cst_int_rdr(size_ins, rdr_func)

	if flag_int then
		stream.s_num = cst_int_rdr(size_num, rdr_func)
	elseif float_types[size_num] then
		stream.s_num = cst_flt_rdr(size_num, float_types[size_num][little and 'little' or 'big'])
	else
		error('unsupported float size')
	end

	return stm_lua_func(stream, '@virtual')
end

local function close_lua_upvalues(list, index)
	for i, uv in pairs(list) do
		if uv.index >= index then
			uv.value = uv.store[uv.index] -- store value
			uv.store = uv
			uv.index = 'value' -- self reference
			list[i] = nil
		end
	end
end

local function open_lua_upvalue(list, index, stack)
	local prev = list[index]

	if not prev then
		prev = {index = index, store = stack}
		list[index] = prev
	end

	return prev
end

local function wrap_lua_variadic(...) return select('#', ...), {...} end

local function on_lua_error(exst, err)
	local src = exst.source
	local line = exst.lines[exst.pc - 1]
	local psrc, pline, pmsg = err:match('^(.-):(%d+):%s+(.+)')
	local fmt = '%s:%i: [%s:%i] %s'

	line = line or '0'
	psrc = psrc or '?'
	pline = pline or '0'
	pmsg = pmsg or err

	error(string.format(fmt, src, line, psrc, pline, pmsg), 0)
end

local function exec_lua_func(exst)
	-- localize for easy lookup
	local code = exst.code
	local subs = exst.subs
	local env = exst.env
	local upvs = exst.upvals
	local vargs = exst.varargs

	-- state variables
	local stktop = -1
	local openupvs = {}
	local stack = exst.stack
	local pc = exst.pc

	while true do
		local inst = code[pc]
		local op = inst.op
		pc = pc + 1

		if op < 19 then
			if op < 9 then
				if op < 4 then
					if op < 2 then
						if op < 1 then
							--[[0 MOVE]]
							stack[inst.A] = stack[inst.B]
						else
							--[[1 LOADK]]
							stack[inst.A] = inst.const
						end
					elseif op > 2 then
						--[[3 LOADNIL]]
						for i = inst.A, inst.B do stack[i] = nil end
					else
						--[[2 LOADBOOL]]
						stack[inst.A] = inst.B ~= 0

						if inst.C ~= 0 then pc = pc + 1 end
					end
				elseif op > 4 then
					if op < 7 then
						if op < 6 then
							--[[5 GETGLOBAL]]
							stack[inst.A] = env[inst.const]
						else
							--[[6 GETTABLE]]
							local index

							if inst.is_KC then
								index = inst.const_C
							else
								index = stack[inst.C]
							end

							stack[inst.A] = stack[inst.B][index]
						end
					elseif op > 7 then
						--[[8 SETUPVAL]]
						local uv = upvs[inst.B]

						uv.store[uv.index] = stack[inst.A]
					else
						--[[7 SETGLOBAL]]
						env[inst.const] = stack[inst.A]
					end
				else
					--[[4 GETUPVAL]]
					local uv = upvs[inst.B]

					stack[inst.A] = uv.store[uv.index]
				end
			elseif op > 9 then
				if op < 14 then
					if op < 12 then
						if op < 11 then
							--[[10 NEWTABLE]]
							stack[inst.A] = {}
						else
							--[[11 SELF]]
							local A = inst.A
							local B = inst.B
							local index

							if inst.is_KC then
								index = inst.const_C
							else
								index = stack[inst.C]
							end

							stack[A + 1] = stack[B]
							stack[A] = stack[B][index]
						end
					elseif op > 12 then
						--[[13 SUB]]
						local lhs, rhs

						if inst.is_KB then
							lhs = inst.const_B
						else
							lhs = stack[inst.B]
						end

						if inst.is_KC then
							rhs = inst.const_C
						else
							rhs = stack[inst.C]
						end

						stack[inst.A] = lhs - rhs
					else
						--[[12 ADD]]
						local lhs, rhs

						if inst.is_KB then
							lhs = inst.const_B
						else
							lhs = stack[inst.B]
						end

						if inst.is_KC then
							rhs = inst.const_C
						else
							rhs = stack[inst.C]
						end

						stack[inst.A] = lhs + rhs
					end
				elseif op > 14 then
					if op < 17 then
						if op < 16 then
							--[[15 DIV]]
							local lhs, rhs

							if inst.is_KB then
								lhs = inst.const_B
							else
								lhs = stack[inst.B]
							end

							if inst.is_KC then
								rhs = inst.const_C
							else
								rhs = stack[inst.C]
							end

							stack[inst.A] = lhs / rhs
						else
							--[[16 MOD]]
							local lhs, rhs

							if inst.is_KB then
								lhs = inst.const_B
							else
								lhs = stack[inst.B]
							end

							if inst.is_KC then
								rhs = inst.const_C
							else
								rhs = stack[inst.C]
							end

							stack[inst.A] = lhs % rhs
						end
					elseif op > 17 then
						--[[18 UNM]]
						stack[inst.A] = -stack[inst.B]
					else
						--[[17 POW]]
						local lhs, rhs

						if inst.is_KB then
							lhs = inst.const_B
						else
							lhs = stack[inst.B]
						end

						if inst.is_KC then
							rhs = inst.const_C
						else
							rhs = stack[inst.C]
						end

						stack[inst.A] = lhs ^ rhs
					end
				else
					--[[14 MUL]]
					local lhs, rhs

					if inst.is_KB then
						lhs = inst.const_B
					else
						lhs = stack[inst.B]
					end

					if inst.is_KC then
						rhs = inst.const_C
					else
						rhs = stack[inst.C]
					end

					stack[inst.A] = lhs * rhs
				end
			else
				--[[9 SETTABLE]]
				local index, value

				if inst.is_KB then
					index = inst.const_B
				else
					index = stack[inst.B]
				end

				if inst.is_KC then
					value = inst.const_C
				else
					value = stack[inst.C]
				end

				stack[inst.A][index] = value
			end
		elseif op > 19 then
			if op < 29 then
				if op < 24 then
					if op < 22 then
						if op < 21 then
							--[[20 LEN]]
							stack[inst.A] = #stack[inst.B]
						else
							--[[21 CONCAT]]
							local str = stack[inst.B]

							for i = inst.B + 1, inst.C do str = str .. stack[i] end

							stack[inst.A] = str
						end
					elseif op > 22 then
						--[[23 EQ]]
						local lhs, rhs

						if inst.is_KB then
							lhs = inst.const_B
						else
							lhs = stack[inst.B]
						end

						if inst.is_KC then
							rhs = inst.const_C
						else
							rhs = stack[inst.C]
						end

						if (lhs == rhs) ~= (inst.A ~= 0) then pc = pc + 1 end
					else
						--[[22 JMP]]
						pc = pc + inst.sBx
					end
				elseif op > 24 then
					if op < 27 then
						if op < 26 then
							--[[25 LE]]
							local lhs, rhs

							if inst.is_KB then
								lhs = inst.const_B
							else
								lhs = stack[inst.B]
							end

							if inst.is_KC then
								rhs = inst.const_C
							else
								rhs = stack[inst.C]
							end

							if (lhs <= rhs) ~= (inst.A ~= 0) then pc = pc + 1 end
						else
							--[[26 TEST]]
							if (not stack[inst.A]) == (inst.C ~= 0) then pc = pc + 1 end
						end
					elseif op > 27 then
						--[[28 CALL]]
						local A = inst.A
						local B = inst.B
						local C = inst.C
						local params
						local sz_vals, l_vals

						if B == 0 then
							params = stktop - A
						else
							params = B - 1
						end

						sz_vals, l_vals = wrap_lua_variadic(stack[A](unpack(stack, A + 1, A + params)))

						if C == 0 then
							stktop = A + sz_vals - 1
						else
							sz_vals = C - 1
						end

						for i = 1, sz_vals do stack[A + i - 1] = l_vals[i] end
					else
						--[[27 TESTSET]]
						local A = inst.A
						local B = inst.B

						if (not stack[B]) == (inst.C ~= 0) then
							pc = pc + 1
						else
							stack[A] = stack[B]
						end
					end
				else
					--[[24 LT]]
					local lhs, rhs

					if inst.is_KB then
						lhs = inst.const_B
					else
						lhs = stack[inst.B]
					end

					if inst.is_KC then
						rhs = inst.const_C
					else
						rhs = stack[inst.C]
					end

					if (lhs < rhs) ~= (inst.A ~= 0) then pc = pc + 1 end
				end
			elseif op > 29 then
				if op < 34 then
					if op < 32 then
						if op < 31 then
							--[[30 RETURN]]
							local A = inst.A
							local B = inst.B
							local vals = {}
							local size

							if B == 0 then
								size = stktop - A + 1
							else
								size = B - 1
							end

							for i = 1, size do vals[i] = stack[A + i - 1] end

							close_lua_upvalues(openupvs, 0)
							return size, vals
						else
							--[[31 FORLOOP]]
							local A = inst.A
							local step = stack[A + 2]
							local index = stack[A] + step
							local limit = stack[A + 1]
							local loops

							if step == math.abs(step) then
								loops = index <= limit
							else
								loops = index >= limit
							end

							if loops then
								stack[inst.A] = index
								stack[inst.A + 3] = index
								pc = pc + inst.sBx
							end
						end
					elseif op > 32 then
						--[[33 TFORLOOP]]
						local A = inst.A
						local func = stack[A]
						local state = stack[A + 1]
						local index = stack[A + 2]
						local base = A + 3
						local vals

						stack[base + 2] = index
						stack[base + 1] = state
						stack[base] = func

						vals = {func(state, index)}

						for i = 1, inst.C do stack[base + i - 1] = vals[i] end

						if stack[base] ~= nil then
							stack[A + 2] = stack[base]
						else
							pc = pc + 1
						end
					else
						--[[32 FORPREP]]
						local A = inst.A
						local init, limit, step

						init = assert(tonumber(stack[A]), '`for` initial value must be a number')
						limit = assert(tonumber(stack[A + 1]), '`for` limit must be a number')
						step = assert(tonumber(stack[A + 2]), '`for` step must be a number')

						stack[A] = init - step
						stack[A + 1] = limit
						stack[A + 2] = step

						pc = pc + inst.sBx
					end
				elseif op > 34 then
					if op < 36 then
						--[[35 CLOSE]]
						close_lua_upvalues(openupvs, inst.A)
					elseif op > 36 then
						--[[37 VARARG]]
						local A = inst.A
						local size = inst.B

						if size == 0 then
							size = vargs.size
							stktop = A + size - 1
						end

						for i = 1, size do stack[A + i - 1] = vargs.list[i] end
					else
						--[[36 CLOSURE]]
						local sub = subs[inst.Bx + 1] -- offset for 1 based index
						local nups = sub.numupvals
						local uvlist

						if nups ~= 0 then
							uvlist = {}

							for i = 1, nups do
								local pseudo = code[pc + i - 1]

								if pseudo.op == 0 then -- @MOVE
									uvlist[i - 1] = open_lua_upvalue(openupvs, pseudo.B, stack)
								elseif pseudo.op == 4 then -- @GETUPVAL
									uvlist[i - 1] = upvs[pseudo.B]
								end
							end

							pc = pc + nups
						end

						stack[inst.A] = wrap_lua_func(sub, env, uvlist)
					end
				else
					--[[34 SETLIST]]
					local A = inst.A
					local C = inst.C
					local size = inst.B
					local tab = stack[A]
					local offset

					if size == 0 then size = stktop - A end

					if C == 0 then
						C = inst[pc].value
						pc = pc + 1
					end

					offset = (C - 1) * FIELDS_PER_FLUSH

					for i = 1, size do tab[i + offset] = stack[A + i] end
				end
			else
				--[[29 TAILCALL]]
				local A = inst.A
				local B = inst.B
				local params

				if B == 0 then
					params = stktop - A
				else
					params = B - 1
				end

				close_lua_upvalues(openupvs, 0)
				return wrap_lua_variadic(stack[A](unpack(stack, A + 1, A + params)))
			end
		else
			--[[19 NOT]]
			stack[inst.A] = not stack[inst.B]
		end

		exst.pc = pc
	end
end

function wrap_lua_func(state, env, upvals)
	local st_code = state.code
	local st_subs = state.subs
	local st_lines = state.lines
	local st_source = state.source
	local st_numparams = state.numparams

	local function exec_wrap(...)
		local stack = {}
		local varargs = {}
		local sizevarg = 0
		local sz_args, l_args = wrap_lua_variadic(...)

		local exst
		local ok, err, vals

		for i = 1, st_numparams do stack[i - 1] = l_args[i] end

		if st_numparams < sz_args then
			sizevarg = sz_args - st_numparams
			for i = 1, sizevarg do varargs[i] = l_args[st_numparams + i] end
		end

		exst = {
			varargs = {list = varargs, size = sizevarg},
			code = st_code,
			subs = st_subs,
			lines = st_lines,
			source = st_source,
			env = env,
			upvals = upvals,
			stack = stack,
			pc = 1,
		}

		ok, err, vals = pcall(exec_lua_func, exst, ...)

		if ok then
			return unpack(vals, 1, err)
		else
			on_lua_error(exst, err)
		end

		return -- explicit "return nothing"
	end

	return exec_wrap
end

return function(BCode, Env)
	return wrap_lua_func(stm_lua_bytecode(BCode), Env or getfenv(0))
end


Prompt: -- Modules

Response:
local ModuleScripts = ReplicatedStorage.ModuleScripts
local GameSettings = require(ModuleScripts:WaitForChild("GameSettings"))
local PlayerManagement = ServerScriptService.PlayerManagement
local PlayerManagementModules = PlayerManagement.ModuleScripts
local ParticleController = require(PlayerManagementModules.ParticleController)
local Data = ServerScriptService.Data
local DataStore = require(Data.Modules.DataStore)
local UpgradeManager = require(Data.Modules.UpgradeManager)


Prompt:
--Click to Equip Script
--Unless you know what you're doing, do not modify this script.

Response:
local tool = script.Parent.Parent --This indicates the tool for the handle.
script.Parent.Parent = tool.Parent --This removes the "Touch to Equip" function for the handle.
script.Parent.ClickDetector.MouseClick:Connect(function(plr) --This detects a click on the handle.
	local character = plr.Character --This identifies the player's character.
	local humanoid = character:FindFirstChild("Humanoid") --This identifies "Humanoid".
	if humanoid ~= nil then --This ensures that "Humanoid" exists inside the player's character.
		tool.Parent = character --This causes the character to equip the tool.
		script.Parent.Parent = tool --This puts the handle inside the tool.
		tool.AncestryChanged:Connect(function(item) --This detects a change in the tool's ancestry.
			local parent = item.Parent --This identifies the parent of the tool.
			if parent.Name ~= "Backpack" and parent ~= character and script.Parent.Parent == tool then
				--The code above ensures the parent isn't the player's backpack or character, and the handle is inside the tool.
				script.Parent.Parent = tool.Parent --This ensures that "Touch to Equip" is disabled.
			end
		end)
	end
end)


Prompt: -- main program

Response:
local nextTime = 0
local runService = game:service("RunService");

while Figure.Parent~=nil do
	time = runService.Stepped:wait()
	if time > nextTime then
		move(time)
		nextTime = time + 0.1
	end
end


Prompt:
-- On Startup
-- Tell the server we've entered the game

Response: PlayerEnteredGame:FireServer()


Prompt:
--[[
for i = 1, 5 do
IN.Belly.Mesh.Scale  = IN.Belly.Mesh.Scale - Vector3.new(.1, .1, .1)
wait(.1)
end
]]


Prompt: -- Catch any FX unloaded descendants

Response:
fxFolder.DescendantAdded:Connect(function(instance)
	configureVisualEffect(instance, adPortal.Status == Enum.AdUnitStatus.Active)
end)


Prompt: -- << SETUP >>

Response:
main:GetModule("PageAbout"):UpdateRankName()
main:GetModule("PageAbout"):UpdateProfileIcon()
main:GetModule("PageAbout"):CreateUpdates()
main:GetModule("PageAbout"):UpdateContributors()
main:GetModule("PageAbout"):CreateCredits()
main:GetModule("PageCommands"):CreateCommands()
main:GetModule("PageCommands"):CreateMorphs()
main:GetModule("PageCommands"):CreateDetails()
main:GetModule("PageSpecial"):SetupDonorCommands()
main:GetModule("PageAdmin"):SetupRanks()
main:GetModule("GUIs"):DisplayPagesAccordingToRank()


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

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

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

ZoneModelName = "Bone nuke" -- name the zone model

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


Prompt:
--[=[
	Utilities involving signals
	@class SignalUtils
]=]

Response: local SignalUtils = {}


Prompt: --[[ Last synced 8/15/2021 08:04                                                                                RoSync Loader ]]

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


Prompt: -------------------------------------Gun info

Response:
ToolName="Revolver"
ClipSize=6
ReloadTime=1
Firerate=.2
MinSpread=0.000001
MaxSpread=0.00001
SpreadRate=0
BaseDamage=25
automatic=false
burst=false
shot=false			--Shotgun
BarrlePos=Vector3.new(0,0,0)
Cursors={"rbxasset://textures\\GunCursor.png"}
ReloadCursor="rbxasset://textures\\GunWaitCursor.png"


Prompt:
-- A new implementation of RBXScriptSignal that uses proper Lua OOP.
-- This was explicitly made to transport other OOP objects.
-- I would be using BindableEvents, but they don't like cyclic tables (part of OOP objects with __index)


Prompt: -- this will need to be worked into a client schema later

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

local taggedButtons = CollectionService:GetTagged("LightupButton")

local buttons = {}
local characters = {}

for _, button in pairs(taggedButtons) do
	buttons[button] = {
		active = false
	}
end

local function onPlayerAdded(player)
	player.CharacterAdded:Connect(function(character)
		repeat task.wait(.2) until character and character.PrimaryPart and character.Humanoid

		characters[player] = character
	end)
	player.CharacterRemoving:Connect(function(character)
		characters[player] = nil
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

for _, player in pairs(Players:GetChildren()) do
	onPlayerAdded(player)
end

while true do
	local taggedButtons = CollectionService:GetTagged("LightupButton")

	for _, button in pairs(taggedButtons) do
		if buttons[button] == nil then
			buttons[button] = {
				active = false
			}
		end
	end

	for _, button in pairs(buttons) do
		button.active = false
	end

	for player, character in pairs(characters) do
		if character and character.PrimaryPart and character.Humanoid then
			local raycastParams = RaycastParams.new()
			raycastParams.FilterDescendantsInstances = taggedButtons
			raycastParams.FilterType = Enum.RaycastFilterType.Whitelist
			local raycastResult = workspace:Raycast(character.PrimaryPart.Position, Vector3.new(0, -6, 0), raycastParams)

			if raycastResult and raycastResult.Instance then
				if buttons[raycastResult.Instance] then
					buttons[raycastResult.Instance].active = true
				end
			end
		end
	end

	task.wait()

	for instance, button in pairs(buttons) do
		if button.active then
			instance.Material = Enum.Material.Neon
		else
			instance.Material = Enum.Material.Plastic
		end
	end
end


Prompt: --	print("filter.Value=",filter.Value)

Response:
end

me.Activated:Connect(onButtonActivated)


Prompt: -- Making a CFrame value from an origin position and unit direction:

Response:
function Util.makeOrientation(sourcePos, dir)
    -- Construct CFrame to rotate parts from x-axis alignment (where they are constructed) to
    -- the world orientation of the arc from a quaternion rotation that describes the
    -- rotation of ux-->axis
    dir = dir.unit

    -- Proportionate angle between ux and direction:
    local angleUxAxis = dot(ux, dir)

    if (angleUxAxis > 0.99999) then
        return cframe(sourcePos, sourcePos - uz)
    elseif (angleUxAxis < -0.99999) then
        return cframe(sourcePos, sourcePos + uz)
    else
        local q = cross(ux, dir)
        local qw = 1 + angleUxAxis
        local qnorm = sqrt(q.magnitude ^ 2 + qw * qw)
        q = q / qnorm
        qw = qw / qnorm
        return cframe(sourcePos.x, sourcePos.y, sourcePos.z, q.x, q.y, q.z, qw)
    end
end

return Util


Prompt: -- Made by https://www.roblox.com/users/130644198/profile


Prompt: --Keybinds & Main Lean Script

Response:
UIS.InputBegan:Connect(function(key, isTyping)
	if key.KeyCode == Enum.KeyCode.E then
		tweenService:Create(humanoid ,ti, {CameraOffset = Vector3.new(2,0,0)}):Play()
	end
	if key.KeyCode == Enum.KeyCode.Q then
		tweenService:Create(humanoid ,ti, {CameraOffset = Vector3.new(-2,0,0)}):Play()
	end

end)

UIS.InputEnded:Connect(function(key)
	if key.KeyCode == Enum.KeyCode.E or key.KeyCode == Enum.KeyCode.Q then
		tweenService:Create(humanoid ,ti, {CameraOffset = Vector3.new(0,0,0)}):Play()
	end
end)


Prompt: --[[[Default Controls]]

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

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

	--Control Mapping
	Tune.Controls = {

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

		--Primary Controls
		Throttle				= Enum.KeyCode.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.LeftShift					,

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

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


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

Response:
script.Parent.IIII.Velocity = script.Parent.IIII.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.J.Velocity = script.Parent.J.CFrame.lookVector *script.Parent.Speed.Value


Prompt: -- Initialize the tool

Response:
local TextureTool = {

	Name = 'Texture Tool';
	Color = BrickColor.new 'Bright violet';

	-- Default options
	Type = 'Decal';
	Face = Enum.NormalId.Front;

};


Prompt: -- CONFIG

Response:
local defaultRegionHeight = 20
local displayBoundParts = false

local Zone = {}
Zone.__index = Zone

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

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

	self._bindableEvent = Instance.new("BindableEvent")
	self._argData = nil
	self._argCount = nil -- Prevent edge case of :Fire("A", nil) --> "A" instead of "A", nil

	return self
end

function Signal:Fire(...)
	self._argData = {...}
	self._argCount = select("#", ...)
	self._bindableEvent:Fire()
	self._argData = nil
	self._argCount = nil
end

function Signal:Connect(handler)
	if not (type(handler) == "function") then
		error(("connect(%s)"):format(typeof(handler)), 2)
	end

	return self._bindableEvent.Event:Connect(function()
		handler(unpack(self._argData, 1, self._argCount))
	end)
end

function Signal:Wait()
	self._bindableEvent.Event:Wait()
	assert(self._argData, "Missing arg data, likely due to :TweenSize/Position corrupting threadrefs.")
	return unpack(self._argData, 1, self._argCount)
end

function Signal:Disconnect()
	if self._bindableEvent then
		self._bindableEvent:Destroy()
		self._bindableEvent = nil
	end

	self._argData = nil
	self._argCount = nil
end

function Zone.new(group, regionHeight)
	local self = {}
	setmetatable(self, Zone)

	self.Group = group
	self.RegionHeight = regionHeight or defaultRegionHeight
	self.DisplayBoundParts = displayBoundParts
	self.GroupParts = {}
	self.Region = self:getRegion()
	self.PreviousPlayers = {}
	self.PlayerAdded = Signal.new()
	self.PlayerRemoving = Signal.new()

	return self
end

function Zone:getRegion()
	local bounds = {["Min"] = {}, ["Max"] = {}}
	for boundType, details in pairs(bounds) do
		details.Values = {}
		function details.parseCheck(v, currentValue)
			if boundType == "Min" then
				return (v <= currentValue)
			elseif boundType == "Max" then
				return (v >= currentValue)
			end
		end
		function details:parse(valuesToParse)
			for i,v in pairs(valuesToParse) do
				local currentValue = self.Values[i] or v
				if self.parseCheck(v, currentValue) then
					self.Values[i] = v
				end
			end
		end
	end
	for _, part in pairs(self.Group:GetDescendants()) do
		if part:isA("BasePart") then
			table.insert(self.GroupParts, part)
			local sizeHalf = part.Size * 0.5
			local corners = {
				part.CFrame * CFrame.new(-sizeHalf.X, -sizeHalf.Y, -sizeHalf.Z),
				part.CFrame * CFrame.new(-sizeHalf.X, -sizeHalf.Y, sizeHalf.Z),
				part.CFrame * CFrame.new(-sizeHalf.X, sizeHalf.Y, -sizeHalf.Z),
				part.CFrame * CFrame.new(-sizeHalf.X, sizeHalf.Y, sizeHalf.Z),
				part.CFrame * CFrame.new(sizeHalf.X, -sizeHalf.Y, -sizeHalf.Z),
				part.CFrame * CFrame.new(sizeHalf.X, -sizeHalf.Y, sizeHalf.Z),
				part.CFrame * CFrame.new(sizeHalf.X, sizeHalf.Y, -sizeHalf.Z),
				part.CFrame * CFrame.new(sizeHalf.X, sizeHalf.Y, sizeHalf.Z),
			}
			for _, cornerCFrame in pairs(corners) do
				local x, y, z = cornerCFrame:GetComponents()
				local values = {x, y, z}
				bounds.Min:parse(values)
				bounds.Max:parse(values)
			end
		end
	end
	local boundMin = Vector3.new(unpack(bounds.Min.Values))
	local boundMax = Vector3.new(unpack(bounds.Max.Values)) + Vector3.new(0, self.RegionHeight, 0)
	if self.DisplayBoundParts then
		local boundParts = {BoundMin = boundMin, BoundMax = boundMax}
		for boundName, boundCFrame in pairs(boundParts) do
			local part = Instance.new("Part")
			part.Anchored = true
			part.CanCollide = false
			part.Transparency = 0.5
			part.Size = Vector3.new(4,4,4)
			part.Color = Color3.fromRGB(255,0,0)
			part.CFrame = CFrame.new(boundCFrame)
			part.Name = boundName
			part.Parent = self.Group
		end
	end
	local region = Region3.new(boundMin, boundMax)
	return region
end

function Zone:getPlayersInRegion()
	local players = Players:GetPlayers()
	local playerCharacters = {}
	for _, player in pairs(players) do
		local char = player.Character
		local hrp = char and char:FindFirstChild("HumanoidRootPart")
		if hrp then
			table.insert(playerCharacters, hrp)
		end
	end
	local partsInRegion = workspace:FindPartsInRegion3WithWhiteList(self.Region, playerCharacters, #players)
	local charsChecked = {}
	local playersInRegion = {}
	if #partsInRegion > 0 then
		for _, part in pairs(partsInRegion) do
			local char = part.Parent
			if not charsChecked[char] then
				charsChecked[char] = true
				local player = Players:GetPlayerFromCharacter(char)
				if player then
					--table.insert(playersInRegion, player)
					playersInRegion[player] = true
				end
			end
		end
	end
	return playersInRegion
end

function Zone:getPlayer(player)
	local char = player.Character
	local hrp = char and char:FindFirstChild("HumanoidRootPart")
	if hrp then
		local origin = hrp.Position + Vector3.new(0, 4, 0)
		local lookDirection = origin + Vector3.new(0, -1, 0)
		local ray = Ray.new(origin, (lookDirection - origin).unit * (self.RegionHeight))
		local groupPart = workspace:FindPartOnRayWithWhitelist(ray, self.GroupParts)
		if groupPart then
			return true
		end
	end
end

function Zone:getPlayers()
	local playersInRegion = self:getPlayersInRegion()
	local playersInZone = {}
	for _, player in pairs(playersInRegion) do
		if self:getPlayer(player) then
			if not self.PreviousPlayers[player] then
				self.PlayerAdded:Fire(player)
			end
			table.insert(playersInZone, player)
		elseif self.PreviousPlayers[player] then
			self.PlayerRemoving:Fire(player)
		end
	end
	self.PreviousPlayers = playersInZone
	return playersInZone
end

function Zone:initLoop(loopDelay)
	loopDelay = tonumber(loopDelay) or 0.5
	local loopId = HttpService:GenerateGUID(false)
	self.currentLoop = loopId
	if not self.loopInitialized then
		self.loopInitialized = true
		coroutine.wrap(function()
			while self.currentLoop == loopId do
				wait(loopDelay)
				self:getPlayers()
			end
		end)()
	end
end

function Zone:endLoop()
	self.currentLoop = nil
end

return Zone


Prompt: -- Services

Response:
local playerService = game:GetService("Players")

playerService.PlayerAdded:Connect(function (plr)
	plr.CharacterAdded:Connect(function (char)
		local humanoid = char:WaitForChild("Humanoid")
		humanoid.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.None
	end)
end)


Prompt: --		debug.profilebegin("AI Offload Loop")

Response:
		local activate, deactivate = {}, {}
		local num = 0
		for _,critter in next,workspace.Critters:GetChildren() do
			num = num + 1
			if critter.PrimaryPart and character and character.PrimaryPart then
				local distance = (character.PrimaryPart.Position - critter.PrimaryPart.Position).magnitude

				if distance < ACTIVATE_AI_RANGE then
					table.insert(activate, critter)
				else
					table.insert(deactivate, critter)
				end
			end

			if num % 10 == 0 then
				RS.Heartbeat:Wait()
			end
		end
		Rep.Relay.AI.AIUpdated:FireServer(activate, deactivate)
		elapsed = 0


Prompt: -- Very inefficient, but provides all available info

Response:
function Util.debugPrint(tbl, indent)
	local out = ""

	indent = indent or "  "
	local vStr
	local kStr

	for k,v in pairs(tbl) do
		local t = type(v)

		local kConversionSuccess, kConversionResult = pcall(function() return tostring(k) end)
		if kConversionSuccess then
			kStr = kConversionResult
		else
			kStr = "[" .. type(k) .. "]"
		end

		if t == "table" then
			vStr = string.format("\n%s%s", "", Util.debugPrint(v, indent .. "  "))
		else
			local vConversionSuccess, vConversionResult = pcall(function() return tostring(v) end)
			if vConversionSuccess then
				vStr = vConversionResult
			else
				vStr = "[" .. type(v) .. "]"
			end
		end

		out = string.format("%s%s%s: %s\n", out, indent, kStr, vStr)
	end

	return out
end

function Util.tableToString(tbl, indent)
	local out = ""

	indent = indent or "  "
	local vStr

	for k,v in pairs(tbl) do
		local t = type(v)

		if t == "table" then
			vStr = string.format("\n%s%s", "", Util.tableToString(v, indent .. "  "))

		elseif t == "nil" then
			vStr = "[nil]"

		elseif t == "string" then
			vStr = string.format("\"%s\"", v)

		elseif t == "boolean" then
			vStr = Util.boolToString(v)

		elseif t == "userdata" then
			vStr = "[USERDATA]"

		elseif t == "function" then
			vStr = "[FUNCTION]"

		else
			vStr = v
		end

		k = tostring(k)

		out = string.format("%s%s%s: %s\n", out, indent, k, vStr)
	end

	return out
end

function Util.newRemoteEvent(name, parent)
	local existing = parent:FindFirstChild(name)

	if existing then
		Log.Warn.Util("RemoteEvent %s under %s already exists", name, parent.Name)

		return existing
	end

	local event = Instance.new("RemoteEvent", parent)
	event.Name = name

	return event
end

function Util.isPlayerInGroup(player, groups)
	for _, groupId in ipairs(groups) do
		if player:IsInGroup(groupId) then
			return true
		end
	end
end

function Util.isPlayerIDInTable(player, ids)
	for _, id in ipairs(ids) do
		if player.UserId == id then
			return true
		end
	end
end

function Util.lerp(start, stop, t)
	return start * (1 - t) + stop * t
end

function Util.getClientFocus()
	return CollectionService:GetTagged(Util._clientFocusTag)[1]
end

function Util.setClientFocus(instance)
	if RunService:IsClient() then
		-- Remove any tags
		for _, obj in ipairs(CollectionService:GetTagged(Util._clientFocusTag)) do
			CollectionService:RemoveTag(obj, Util._clientFocusTag)
		end

		-- Tag the specified object
		CollectionService:AddTag(instance, Util._clientFocusTag)
	end
end

Util.highestBotNum = 150
function Util.playerIsBot(player)
	local numOnEnd = tonumber(string.sub(player.Name, 11))
	if numOnEnd ~= nil and
	   string.len(player.Name) > 10 and
	   string.sub(player.Name, 1, 10) == "rbxreftest" and
	   numOnEnd <= Util.highestBotNum and
	   numOnEnd >= 1
	then
		return true
	end
	return false
end

function Util.playerIsAlive(player)
	if player and player.Character then
		local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
		if humanoid and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
			return true
		end
	end
	return false
end

function Util.ancestorHasTag(instance, tag)
	local currentInstance = instance
	while currentInstance do
		if CollectionService:HasTag(currentInstance, tag) then
			return true
		elseif not currentInstance.Parent then
			return false
		else
			currentInstance = currentInstance.Parent
		end
	end

	return false
end

function Util.getTableKeys(tbl)
	local keys = {}

	for k in pairs(tbl) do
		table.insert(keys, k)
	end

	return keys
end

function Util.loadCharacter(player)
	if Conf.force_rthro then
		local avatars = Conf.avatarOutfits
		local effectiveId = player.UserId
		local outfitId = avatars[(effectiveId % (#avatars - 1)) + 1]

		local playerDesc = Players:GetHumanoidDescriptionFromUserId(player.UserId)
		local desc = Players:GetHumanoidDescriptionFromOutfitId(outfitId)

		-- Load animations from configuration
		for property, value in pairs(Conf.avatarAnimations) do
			desc[property] = value
		end

		local emotes = playerDesc:GetEquippedEmotes()
		desc:SetEquippedEmotes(emotes)

		player:LoadCharacterWithHumanoidDescription(desc)
	else
		player:LoadCharacter()
	end
end