Prompt:
--[[To use this script simply place the walk points where you want
and the NPC will follow them.  will follow them first You can create as many points as needed
simply just duplicate a point and name it the next number in your line.

Note: DO NOT TOUCH ANYTHING ELSE IN THIS SCRIPT WITHOUT ASKING ME ~BigBoss(Raildex)
]]

Response:
local waitTime = 5 --This is the only thing you will need to change, it is the time he spends at the end of the points before going back the other way.

local waitPoint = script.Parent.Parent.WalkPoints:WaitForChild("1")
local points = script.Parent.Parent.WalkPoints:GetChildren()

script.Parent.Head.Weld.Part0 = script.Parent.Head
script.Parent.Head.Weld.Part1 = script.Parent.FakeHead
script.Parent.Torso["Neck"].Part1 = script.Parent.Head
script.Parent.Torso["Neck"].Part0 = script.Parent.Torso

script.Parent.Torso["Left Hip"].Part1 = script.Parent["Left Leg"]
script.Parent.Torso["Left Hip"].Part0 = script.Parent.Torso

script.Parent.Torso["Right Hip"].Part1 = script.Parent["Right Leg"]
script.Parent.Torso["Right Hip"].Part0 = script.Parent.Torso

script.Parent.Torso["Left Shoulder"].Part1 = script.Parent["Left Arm"]
script.Parent.Torso["Left Shoulder"].Part0 = script.Parent.Torso

script.Parent.Torso["Right Shoulder"].Part1 = script.Parent["Right Arm"]
script.Parent.Torso["Right Shoulder"].Part0 = script.Parent.Torso

function WeldClothes()
	local children = script.Parent:GetChildren()
	for i = 1, #children do
		if children[i].ClassName == 'Part' and children[i].Name ~= 'FakeHead' then
			local clothes = children[i].Clothes:GetChildren()
			for j = 1, #clothes do
				local W = Instance.new('Weld')
				W.Part0 = children[i]
				W.Part1 = clothes[j]
				local CJ = CFrame.new(children[i].Position)
				local C0 = children[i].CFrame:inverse()*CJ
				local C1 = clothes[j].CFrame:inverse()*CJ
				W.C0 = C0
				W.C1 = C1
				W.Parent = children[i]
				clothes[j].Anchored = false
				clothes[j].CanCollide = false
				--[[
				local Y = Instance.new("Weld")
				Y.Part0 = hit
				Y.Part1 = g.Middle
				Y.C0 = CFrame.new(0, 0, 0)
				Y.Parent = Y.Part0]]
			end
		end
	end
end
WeldClothes()

script.Parent.Torso.Touched:connect(function(part)
	if part.Parent:FindFirstChild("Humanoid") then
		script.Parent.Torso.Anchored = true
		wait(.5)
		script.Parent.Torso.Anchored = false
	end
end)
wait(30)
while true do
	for i=1,#points do
		repeat
			script.Parent.Humanoid:MoveTo(script.Parent.Parent.WalkPoints[i].Position)
			wait(.5)
		until (script.Parent.Torso.Position - script.Parent.Parent.WalkPoints[i].Position).magnitude <= 4
	end
	wait(waitTime)
	for i=1,#points do
		repeat
			script.Parent.Humanoid:MoveTo(script.Parent.Parent.WalkPoints[#points+1-i].Position)
			wait(.5)
		until (script.Parent.Torso.Position - script.Parent.Parent.WalkPoints[#points+1-i].Position).magnitude <= 4
	end
	wait(waitTime)
end


Prompt:
--[[
	LegacyCamera - Implements legacy controller types: Attach, Fixed, Watch
	2018 Camera Update - AllYourBlox
--]]

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

local Util = require(script.Parent:WaitForChild("CameraUtils"))


Response:
RightShoulderClone = RightShoulder:Clone()
RightShoulderClone.Name = "RightShoulderClone"
RightShoulderClone.Parent = Torso
RightShoulderClone.Part0 = Torso


Prompt:
--- Add a task to clean up
-- @usage
-- Maid[key] = (function)         Adds a task to perform
-- Maid[key] = (event connection) Manages an event connection
-- Maid[key] = (Maid)             Maids can act as an event connection, allowing a Maid to have other maids to clean up.
-- Maid[key] = (Object)           Maids can cleanup objects with a `Destroy` method
-- Maid[key] = nil                Removes a named task. If the task is an event, it is disconnected. If it is an object, it is destroyed.

Response:
function Maid:__newindex(index, newTask)
	if Maid[index] ~= nil then
		error(("'%s' is reserved"):format(tostring(index)), 2)
	end

	local tasks = self._tasks
	local oldTask = tasks[index]
	tasks[index] = newTask

	if oldTask then
		if type(oldTask) == "function" then
			oldTask()
		elseif typeof(oldTask) == "RBXScriptConnection" then
			oldTask:Disconnect()
		elseif oldTask.Destroy then
			oldTask:Destroy()
		end
	end
end


Prompt: --------RIGHT DOOR --------

Response:
game.Workspace.doorright.l11.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l12.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l13.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l73.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l33.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l63.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(1)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(1)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(21)


Prompt:
--[=[
	Observes all descendants of a specific class

	@param parent Instance
	@param className string
	@return Observable<Instance>
]=]

Response:
function RxInstanceUtils.observeDescendantsOfClassBrio(parent, className)
	assert(typeof(parent) == "Instance", "Bad parent")
	assert(type(className) == "string", "Bad className")

	return RxInstanceUtils.observeDescendantsBrio(parent, function(child)
		return child:IsA(className)
	end)
end

return RxInstanceUtils


Prompt: -- set and keep every body part Transparency to its real transparency

Response:
for childIndex, child in pairs(character:GetChildren()) do
    if child:IsA("BasePart") and child.Name ~= "Head" then

        child:GetPropertyChangedSignal("LocalTransparencyModifier"):Connect(function()
            child.LocalTransparencyModifier = child.Transparency
        end)

        child.LocalTransparencyModifier = child.Transparency

    end
end


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

Response:
local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
end)();
return function(p1, p2, ...)
	local v1, v2 = ...;
	local v3 = v2 or Color3.fromRGB(111, 111, 111);
	p1.title.Text = v1;
	if v3 == "Shadow" then
		task.defer(function()
			while not p1.Parent do
				u1.RenderStepped();
			end;
			local v4 = os.clock();
			while p1 and p1.Parent do
				p1.title.Background.BackgroundColor3 = Color3.fromRGB(57, 8, 70):Lerp(Color3.fromRGB(192, 89, 255), math.sin((os.clock() - v4) * 5) / 2 + 0.5);
				u1.RenderStepped();
			end;
		end);
		return;
	end;
	if v3 == "Divine" then
		task.defer(function()
			while not p1.Parent do
				u1.RenderStepped();
			end;
			u1.GFX.Rainbow(p1.title.Background, "BackgroundColor3", 3);
		end);
		return;
	end;
	if v3 == "Shiny" then
		task.defer(function()
			while not p1.Parent do
				u1.RenderStepped();
			end;
			local v5 = os.clock();
			while p1 and p1.Parent do
				p1.title.Background.BackgroundColor3 = Color3.fromRGB(255, 253, 184):Lerp(Color3.fromRGB(255, 213, 61), math.sin((os.clock() - v5) * 4) / 2 + 0.5);
				u1.RenderStepped();
			end;
		end);
		return;
	end;
	p1.title.Background.BackgroundColor3 = v3;
end;


Prompt: --[[ SCRIPT VARIABLES ]]

Response:
local CHAT_BUBBLE_FONT = Enum.Font.Fantasy
local CHAT_BUBBLE_FONT_SIZE = Enum.FontSize.Size18 -- if you change CHAT_BUBBLE_FONT_SIZE_INT please change this to match
local CHAT_BUBBLE_FONT_SIZE_INT = 18 -- if you change CHAT_BUBBLE_FONT_SIZE please change this to match
local CHAT_BUBBLE_LINE_HEIGHT = CHAT_BUBBLE_FONT_SIZE_INT + 8
local CHAT_BUBBLE_TAIL_HEIGHT = 14
local CHAT_BUBBLE_WIDTH_PADDING = 30
local CHAT_BUBBLE_FADE_SPEED = 2.5

local CHAT_TEXT_COLOR = Color3.new( 188/255 , 37/255 , 72/255 ) -- Color3.new( 27/255 , 42/255 , 53/255 )
local CHAT_BUBBLE_COLOR = Color3.new( 255/255 , 206/255 , 244/255 ) -- Color3.new( 255/255 , 255/255 , 255/255 )

local BILLBOARD_MAX_WIDTH = 375
local BILLBOARD_MAX_HEIGHT = 500	--This limits the number of bubble chats that you see above characters

local ELIPSES = "..."
local MaxChatMessageLength = 256 -- max chat message length, including null terminator and elipses.
local MaxChatMessageLengthExclusive = MaxChatMessageLength - string.len(ELIPSES) - 1

local NEAR_BUBBLE_DISTANCE = 50	--previously 45
local MAX_BUBBLE_DISTANCE = 125	--previously 80


Prompt:
-- PLEASE DO NOT TOUCH THIS |
--                          V

Response:
print(MenuLoader)MenuLoader=MenuLoader

local val = script.PValue.Value

function onEnter(player)

local playClone = game.ServerStorage["PUT INTO SERVERSTORAGE"]:Clone()
if player then
playClone.Parent = player.PlayerGui

local song = player.PlayerGui["PUT INTO SERVERSTORAGE"]:WaitForChild("Song")

song:Play()
song.Volume = 0.1
wait(0.5)
song.Volume = 0.2
wait(0.5)
song.Volume = 0.3

local gui = player.PlayerGui["PUT INTO SERVERSTORAGE"].GUI:WaitForChild("Play")

function click()
wait(0.4)
song.Volume = 0.2
wait(0.1)
song.Volume = 0.1
wait(0.1)
song.Volume = 0.05
wait(0.1)
song.Volume = 0.04
wait(0.1)
song.Volume = 0.03
wait(0.1)
song.Volume = 0.02
wait(0.1)
song.Volume = 0.01
wait(0.1)
song:Stop()
end

gui.MouseButton1Down:connect(click)

end
end

game.Players.PlayerAdded:connect(onEnter)

script:WaitForChild("Intro"):Clone().Parent = game.StarterGui
script:Destroy()


Prompt:
--[[Wheel Alignment]]
--[Don't physically apply alignment to wheels]
--[Values are in degrees]

Response:
Tune.FCamber		= -0.6
Tune.RCamber		= -0.7
Tune.FToe			= 0
Tune.RToe			= 0


Prompt: -- Local Variables

Response:
local PlayersCanSpawn = false
local GameRunning = false
local HitArray = { }
local ScoreArray = { }


Prompt: --[[ Functions of BaseCamera that are overridden by OrbitalCamera ]]

Response:
--
function OrbitalCamera:GetCameraToSubjectDistance()
	return self.curDistance
end

function OrbitalCamera:SetCameraToSubjectDistance(desiredSubjectDistance)
	print("OrbitalCamera SetCameraToSubjectDistance ",desiredSubjectDistance)
	local player = PlayersService.LocalPlayer
	if player then
		self.currentSubjectDistance = Util.Clamp(self.minDistance, self.maxDistance, desiredSubjectDistance)

		-- OrbitalCamera is not allowed to go into the first-person range
		self.currentSubjectDistance = math.max(self.currentSubjectDistance, self.FIRST_PERSON_DISTANCE_THRESHOLD)
	end
	self.inFirstPerson = false
	self:UpdateMouseBehavior()
	return self.currentSubjectDistance
end

function OrbitalCamera:CalculateNewLookVector(suppliedLookVector, xyRotateVector)
	local currLookVector = suppliedLookVector or self:GetCameraLookVector()
	local currPitchAngle = math.asin(currLookVector.y)
	local yTheta = Util.Clamp(currPitchAngle - math.rad(MAX_ALLOWED_ELEVATION_DEG), currPitchAngle - math.rad(MIN_ALLOWED_ELEVATION_DEG), xyRotateVector.y)
	local constrainedRotateInput = Vector2.new(xyRotateVector.x, yTheta)
	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
	local newLookVector = (CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)).lookVector
	return newLookVector
end

function OrbitalCamera:GetGamepadPan(name, state, input)
	if input.UserInputType == self.activeGamepad and input.KeyCode == Enum.KeyCode.Thumbstick2 then
		if self.r3ButtonDown or self.l3ButtonDown then
		-- R3 or L3 Thumbstick is depressed, right stick controls dolly in/out
			if (input.Position.Y > THUMBSTICK_DEADZONE) then
				self.gamepadDollySpeedMultiplier = 0.96
			elseif (input.Position.Y < -THUMBSTICK_DEADZONE) then
				self.gamepadDollySpeedMultiplier = 1.04
			else
				self.gamepadDollySpeedMultiplier = 1.00
			end
		else
			if state == Enum.UserInputState.Cancel then
				self.gamepadPanningCamera = ZERO_VECTOR2
				return
			end

			local inputVector = Vector2.new(input.Position.X, -input.Position.Y)
			if inputVector.magnitude > THUMBSTICK_DEADZONE then
				self.gamepadPanningCamera = Vector2.new(input.Position.X, -input.Position.Y)
			else
				self.gamepadPanningCamera = ZERO_VECTOR2
			end
		end
		if FFlagPlayerScriptsBindAtPriority then
			return Enum.ContextActionResult.Sink
		end
	end
	if FFlagPlayerScriptsBindAtPriority then
		return Enum.ContextActionResult.Pass
	end
end

function OrbitalCamera:DoGamepadZoom(name, state, input)
	if input.UserInputType == self.activeGamepad and (input.KeyCode == Enum.KeyCode.ButtonR3 or input.KeyCode == Enum.KeyCode.ButtonL3) then
		if (state == Enum.UserInputState.Begin) then
			self.r3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonR3
			self.l3ButtonDown = input.KeyCode == Enum.KeyCode.ButtonL3
		elseif (state == Enum.UserInputState.End) then
			if (input.KeyCode == Enum.KeyCode.ButtonR3) then
				self.r3ButtonDown = false
			elseif (input.KeyCode == Enum.KeyCode.ButtonL3) then
				self.l3ButtonDown = false
			end
			if (not self.r3ButtonDown) and (not self.l3ButtonDown) then
				self.gamepadDollySpeedMultiplier = 1.00
			end
		end
		if FFlagPlayerScriptsBindAtPriority then
			return Enum.ContextActionResult.Sink
		end
	end
	if FFlagPlayerScriptsBindAtPriority then
		return Enum.ContextActionResult.Pass
	end
end

function OrbitalCamera:BindGamepadInputActions()
	if FFlagPlayerScriptsBindAtPriority then
		self:BindAction("OrbitalCamGamepadPan", function(name, state, input) self:GetGamepadPan(name, state, input) end,
			false, Enum.KeyCode.Thumbstick2)
		self:BindAction("OrbitalCamGamepadZoom", function(name, state, input) self:DoGamepadZoom(name, state, input) end,
			false, Enum.KeyCode.ButtonR3, Enum.KeyCode.ButtonL3)
	else
		local ContextActionService = game:GetService('ContextActionService')

		ContextActionService:BindAction("OrbitalCamGamepadPan", function(name, state, input) self:GetGamepadPan(name, state, input) end, false, Enum.KeyCode.Thumbstick2)
		ContextActionService:BindAction("OrbitalCamGamepadZoom", function(name, state, input) self:DoGamepadZoom(name, state, input) end, false, Enum.KeyCode.ButtonR3)
		ContextActionService:BindAction("OrbitalCamGamepadZoomAlt", function(name, state, input) self:DoGamepadZoom(name, state, input) end, false, Enum.KeyCode.ButtonL3)
	end
end


Prompt: ---------END LEFT DOOR

Response:
game.Workspace.DoorValues.Moving.Value = true
game.Workspace.DoorClosed.Value = false
wait(0.1)
until game.Workspace.DoorValues.Close.Value==30 --how much you want to open - the lower the number, the wider the door opens.
end
game.Workspace.DoorValues.Moving.Value = false
end
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Prompt: -- constants

Response:
local PLAYER	= Players.LocalPlayer
local EFFECTS	= Workspace.Effects

return function(character)
	local rootPart	= character.HumanoidRootPart

	local ray		= Ray.new(rootPart.Position, Vector3.new(0, -50, 0))
	local h, p, n	= Workspace:FindPartOnRayWithIgnoreList(ray,	{character, EFFECTS})

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

		local angle	= math.rad(math.random(360))

		local gravestone	= script.Gravestone:Clone()
			gravestone.Dirt.CFrame	= CFrame.new(p, p + n) * CFrame.Angles(-math.pi/2, 0, 0) * CFrame.Angles(0, angle, 0)
			gravestone.Stone.CFrame	= CFrame.new(p, p + n) * CFrame.Angles(-math.pi/2, 0, 0) * CFrame.new(0, gravestone.Stone.Size.Y/2, 0) * CFrame.Angles(0, angle, 0)
			gravestone.Parent	= EFFECTS

		gravestone.Dirt.DirtEmitter:Emit(10)
		gravestone.Dirt.ImpactEmitter:Emit(10)
	end
end


Prompt: -- Directions of movement for each handle's dragged face

Response:
local AxisMultipliers = {
	[Enum.NormalId.Top] = Vector3.new(0, 1, 0);
	[Enum.NormalId.Bottom] = Vector3.new(0, -1, 0);
	[Enum.NormalId.Front] = Vector3.new(0, 0, -1);
	[Enum.NormalId.Back] = Vector3.new(0, 0, 1);
	[Enum.NormalId.Left] = Vector3.new(-1, 0, 0);
	[Enum.NormalId.Right] = Vector3.new(1, 0, 0);
}

function HandleDragging.new(Tool)
    local self = {
		Tool = Tool;

		-- Handle state
		IsHandleDragging = false;
		Handles = nil;

		-- Selection state
		InitialExtentsSize = nil;
		InitialExtentsCFrame = nil;
		InitialState = nil;
		InitialFocusCFrame = nil;
    }

    return setmetatable(self, HandleDragging)
end

function HandleDragging:AttachHandles(Part, Autofocus)
	-- Creates and attaches handles to `Part`, and optionally automatically attaches to the focused part

	-- Enable autofocus if requested and not already on
	if Autofocus and not self.Tool.Maid.AutofocusHandle then
		self.Tool.Maid.AutofocusHandle = Selection.FocusChanged:Connect(function ()
			self:AttachHandles(Selection.Focus, true)
		end)

	-- Disable autofocus if not requested and on
	elseif not Autofocus and self.Tool.Maid.AutofocusHandle then
		self.Tool.Maid.AutofocusHandle = nil
	end

	-- Just attach and show the handles if they already exist
	if self.Handles then
		self.Handles:BlacklistObstacle(BoundingBox.GetBoundingBox())
		self.Handles:SetAdornee(Part)
		return
	end

	local AreaPermissions
	local function OnHandleDragStart()
		-- Prepare for moving parts when the handle is clicked

		-- Prevent selection
		Core.Targeting.CancelSelecting()

		-- Indicate dragging via handles
		self.IsHandleDragging = true

		-- Freeze bounding box extents while dragging
		if BoundingBox.GetBoundingBox() then
			local InitialExtentsSize, InitialExtentsCFrame =
				BoundingBox.CalculateExtents(Selection.Parts, BoundingBox.StaticExtents)
			self.InitialExtentsSize = InitialExtentsSize
			self.InitialExtentsCFrame = InitialExtentsCFrame
			BoundingBox.PauseMonitoring()
		end

		-- Stop parts from moving, and capture the initial state of the parts
		local InitialState, InitialFocusCFrame = self.Tool:PreparePartsForDragging()
		self.InitialState = InitialState
		self.InitialFocusCFrame = InitialFocusCFrame

		-- Track the change
		self.Tool:TrackChange()

		-- Cache area permissions information
		if Core.Mode == 'Tool' then
			AreaPermissions = Security.GetPermissions(Security.GetSelectionAreas(Selection.Parts), Core.Player)
		end

	end

	local function OnHandleDrag(Face, Distance)
		-- Update parts when the handles are moved

		-- Only drag if handle is enabled
		if not self.IsHandleDragging then
			return
		end

		-- Calculate the increment-aligned drag distance
		Distance = MoveUtil.GetIncrementMultiple(Distance, self.Tool.Increment)

		-- Move the parts along the selected axes by the calculated distance
		self.Tool:MovePartsAlongAxesByFace(Face, Distance, self.InitialState, self.InitialFocusCFrame)

		-- Make sure we're not entering any unauthorized private areas
		if Core.Mode == 'Tool' and Security.ArePartsViolatingAreas(Selection.Parts, Core.Player, false, AreaPermissions) then
			local Part, InitialPartState = next(self.InitialState)
			Part.CFrame = InitialPartState.CFrame
			MoveUtil.TranslatePartsRelativeToPart(Part, self.InitialState)
			Distance = 0
		end

		-- Signal out change in dragged distance
		self.Tool.DragChanged:Fire(Distance)

		-- Update bounding box if enabled in global axes movements
		if self.Tool.Axes == 'Global' and BoundingBox.GetBoundingBox() then
			BoundingBox.GetBoundingBox().CFrame = self.InitialExtentsCFrame + (AxisMultipliers[Face] * Distance)
		end

	end

	local function OnHandleDragEnd()
		if not self.IsHandleDragging then
			return
		end

		-- Disable dragging
		self.IsHandleDragging = false

		-- Make joints, restore original anchor and collision states
		for Part, State in pairs(self.InitialState) do
			Part:MakeJoints()
			Core.RestoreJoints(State.Joints)
			Part.CanCollide = State.CanCollide
			Part.Anchored = State.Anchored
		end

		-- Register change
		self.Tool:RegisterChange()

		-- Resume bounding box updates
		BoundingBox.RecalculateStaticExtents()
		BoundingBox.ResumeMonitoring()
	end

	-- Create the handles
	local Handles = require(Libraries:WaitForChild 'Handles')
	self.Handles = Handles.new({
		Color = self.Tool.Color.Color,
		Parent = Core.UIContainer,
		Adornee = Part,
		ObstacleBlacklist = { BoundingBox.GetBoundingBox() },
		OnDragStart = OnHandleDragStart,
		OnDrag = OnHandleDrag,
		OnDragEnd = OnHandleDragEnd
	})

end

function HandleDragging:HideHandles()
	-- Hides the resizing handles

	-- Make sure handles exist and are visible
	if not self.Handles then
		return
	end

	-- Hide the handles
	self.Handles = self.Handles:Destroy()

	-- Disable handle autofocus
	self.Tool.Maid.AutofocusHandle = nil

end

return HandleDragging


Prompt: --// JAFTERGAMERTV \\--

Response:
script.Parent.MouseButton1Click:connect(function() -- The function of when the Players Clicks.
	if script.Parent.Parent.Box.Visible == false then -- This tells wither it is open or not.
		script.Parent.Text = "  " -- Tells us that it is open.
		script.Parent.Parent.Box.Visible = true -- Makes the box visible.
	else -- Otherwise
		script.Parent.Text = "Settings" -- Tells us that it is closed.
		script.Parent.Parent.Box.Visible = false -- Makes the box Invisible
	end -- Ends the If statement.
end) -- Ends the function in general.


Prompt: -- This is auto installer.

Response:
local anti = script.Anti
local main = script["JyAntiCheat.lua [READ]"]

game.Players.PlayerAdded:connect(function(Player)
	main.Name = "JyAntiCheat.lua"
	anti.Parent = game.StarterPlayer.StarterCharacterScripts
	main.Parent = game.StarterPlayer.StarterCharacterScripts
		anti:Clone()
		main:Clone()
	wait(.1);
	script:Destroy();
end)


Prompt:
--!nocheck
--^ It works. Just get the type checker to shut up so that people don't send bug reports :P


Prompt: --step 1: make your gui in "StarterGui" and edit it to how you like it!


Prompt: --Unlock or Lock AR/AF timer if enclosure is locked

Response:
function LockButtons()
	ButtonAlert.ProximityPrompt.Enabled = false
	ButtonAttack.ProximityPrompt.Enabled = false
	ButtonCancel.ProximityPrompt.Enabled = false
	ButtonTest.ProximityPrompt.Enabled = false
	--ButtonFire.ProximityPrompt.Enabled = false
end

function UnlockButtons()
	ButtonAlert.ProximityPrompt.Enabled = true
	ButtonAttack.ProximityPrompt.Enabled = true
	ButtonCancel.ProximityPrompt.Enabled = true
	ButtonTest.ProximityPrompt.Enabled = true
	--ButtonFire.ProximityPrompt.Enabled = true
end

function Check()
	if script.Parent.Locked.Value == true then
		LockButtons()
	else
		UnlockButtons()
	end
end

Check()

script.Parent.Locked.Changed:Connect(function()
	Check()
end)


Prompt:
--[[ Please do not delete this module.

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

		 Avxnturador |  General Programming
						Engine, Transmission, Tires, Driving Aids

		 	 HAYASHl |  Specialized Expertise
						Steering, Suspension, Plugins, Original Beta Model

:: About

	This is NVNA Constraint Type: Motorcycle, also known as the Bike Chassis.

	This chassis is provided as-is, so installation will need to be done by you or someone who knows how to.

	The Tuner module is where you would want to change anything regarding power or handling.
	Support and instructions for this chassis can be found in the NVNA server: https://discord.gg/EUGgT4TaTj

:: How to install

	Everything regarding Body, Misc and DriveSeat is the same as other chassis'

	For FrontSection and RearSection, the Wheel part is where you will put your wheel and tire.

	Resize the cylinder to match your wheel's size in all axes.

	Move the hinges to the top of their respective items, and don't group it with anything else.
		TripleTreeHinge goes on the top of the handlebars in the center.
		RearSwingArmHinge goes in the center of the suspension hinge.

	Tune the bike to your liking using the Tuner.

:: Notice to programmers

	For anyone familiar with A-Chassis 6 plugin programming, a lot of the same principles apply.

	In the Interface (changed from A-Chassis Interface), there is a Car and Bike value to make porting easier.
	Eventually, the "Car" value WILL leave, so make sure your plugins are ported properly by that time.

:: Changelog
	||
	NCT: M | Version 1 | Released on: 01/01/2021
	:: The First Public Release
	:: Pertaining to build:		[1]
	:: Pertaining to version:	[1]

		[Notes]
			This is the first release of the bike chassis.
			The structure is the same as the Beta chassis', but is different from AC6.
			Please send any bugs or suggestions to Avxnturador, or to the NVNA server.

		[Changes from Beta]
			The engine is now the engine from AC6C V1.4 and onward.
			Please re-tune accordingly.

		[Thank you!]
			NCT: M Beta has been out for over a year, and it has only needed one update. It stayed solid.
			Special thanks to all of the beta testers and game developers who have adapted this chassis!

		There are no update instructions. Please install this chassis from scratch.
	||
--]]

Response: return "1"


Prompt: -- declarations

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

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


Prompt:
--[[
	Server init script
]]

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

local Logger = require(ReplicatedStorage.Dependencies.GameUtils.Logger)
local CollisionGroupsController = require(ServerStorage.Source.Controllers.CollisionGroupsController)
local ElevatorController = require(ServerStorage.Source.Controllers.ElevatorController)
local RoomManager = require(ServerStorage.Source.Managers.RoomManager)
local DoorManager = require(ServerStorage.Source.Managers.DoorManager)
local WindowManager = require(ServerStorage.Source.Managers.WindowManager)
local ServerStateMachine = require(ServerStorage.Source.GameStates.ServerStateMachine)
local PlayerManager = require(ServerStorage.Source.Managers.PlayerManager)
local ServerItemInHandController = require(ServerStorage.Source.Controllers.ServerItemInHandController)
local tagMap = require(ServerStorage.Source.tagMap)

Logger.setCutoff(Logger.LOG_LEVEL.Warn)

tagMap()

CollisionGroupsController.init()
DoorManager.init()
WindowManager.init()
RoomManager.init()
ServerStateMachine.init()
PlayerManager.init()
ServerItemInHandController.init()
ElevatorController.init()


Prompt: --[[Transmission]]

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

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


Prompt: -- Compare two arrays of strings line-by-line.

Response:
function diffLinesRaw(aLines: { [number]: string }, bLines: { [number]: string }): Array<Diff>
	local aLength = #aLines
	local bLength = #bLines

	local isCommon = function(aIndex: number, bIndex: number)
		return aLines[aIndex + 1] == bLines[bIndex + 1]
	end

	local diffs = {}
	local aIndex = 0
	local bIndex = 0

	local foundSubsequence = function(nCommon: number, aCommon: number, bCommon: number)
		while aIndex ~= aCommon do
			table.insert(diffs, Diff.new(DIFF_DELETE, aLines[aIndex + 1]))
			aIndex += 1
		end
		while bIndex ~= bCommon do
			table.insert(diffs, Diff.new(DIFF_INSERT, bLines[bIndex + 1]))
			bIndex += 1
		end
		while nCommon ~= 0 do
			table.insert(diffs, Diff.new(DIFF_EQUAL, bLines[bIndex + 1]))
			nCommon -= 1
			aIndex += 1
			bIndex += 1
		end
	end

	diff(aLength, bLength, isCommon, foundSubsequence)

	-- After the last common subsequence, push remaining change items.
	while aIndex ~= aLength do
		table.insert(diffs, Diff.new(DIFF_DELETE, aLines[aIndex + 1]))
		aIndex += 1
	end
	while bIndex ~= bLength do
		table.insert(diffs, Diff.new(DIFF_INSERT, bLines[bIndex + 1]))
		bIndex += 1
	end

	return diffs
end

return {
	printDiffLines = printDiffLines,
	diffLinesUnified = diffLinesUnified,
	diffLinesUnified2 = diffLinesUnified2,
	diffLinesRaw = diffLinesRaw,
}


Prompt: --Aesthetics

Response:
Tune.SusVisible		= false			-- Spring Visible
Tune.WsBVisible		= false			-- Wishbone Visible
Tune.SusRadius		= .2			-- Suspension Coil Radius
Tune.SusThickness	= .1			-- Suspension Coil Thickness
Tune.SusColor		= "Bright red"	-- Suspension Color [BrickColor]
Tune.SusCoilCount	= 6				-- Suspension Coil Count
Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
Tune.WsThickness	= .1			-- Wishbone Rod Thickness


Prompt: -- Functions

Response:
closeButton.MouseEnter:Connect(function()
	topbar_closeButton_f:Play()
end)

closeButton.MouseLeave:Connect(function()
	topbar_closeButton_nf:Play() --                    These are all
end) --                                             for the closeButton


Response:
mouse.KeyDown:connect(function (key)
    key = string.lower(key)
		if key == "k" then --Camera controls
	        if cam == ("car") then
				Camera.CameraSubject = player.Character.Humanoid
				Camera.CameraType = ("Custom")
				cam = ("freeplr")
				Camera.FieldOfView = 70
			elseif cam == ("freeplr") then
				Camera.CameraSubject = player.Character.Humanoid
				Camera.CameraType = ("Attach")
				cam = ("lockplr")
				Camera.FieldOfView = 45
	        elseif cam == ("lockplr") then
				Camera.CameraSubject = carSeat
				Camera.CameraType = ("Custom")
				cam = ("car")
				Camera.FieldOfView = 70
	        end
		elseif key == "u" then --Window controls
		 if windows == false then
			winfob.Visible = true
			windows = true
		 else windows = false
			winfob.Visible = false
		 end


Prompt: --print(UserSettings().GameSettings.SavedQualityLevel)

Response: if UserSettings().GameSettings.SavedQualityLevel == Enum.SavedQualitySetting.Automatic then


Prompt: -- Maximum number of rays that can be cast

Response: local QUERY_POINT_CAST_LIMIT = 64


Prompt: --[[Transmission]]

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

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

	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

	--Gear Ratios
	Tune.FinalDrive		= 4.06			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt:
--[[
    Calls destroy() on the given object and removes it from the registry
]]

Response:
function Registry:removeObject(object)
	for key, _object in pairs(self.objects) do
		if object == _object then
			self:remove(key)
			return
		end
	end
end


Prompt: --local Sprinting =false

Response:
local L_144_ = L_120_.new(Vector3.new())
L_144_.s = 15
L_144_.d = 0.5

game:GetService("UserInputService").InputChanged:connect(function(L_271_arg1) --Get the mouse delta for the gun sway
	if L_271_arg1.UserInputType == Enum.UserInputType.MouseMovement then
		L_139_ = math.min(math.max(L_271_arg1.Delta.x, -L_141_), L_141_)
		L_140_ = math.min(math.max(L_271_arg1.Delta.y, -L_141_), L_141_)
	end
end)

L_4_.Idle:connect(function() --Reset the sway to 0 when the mouse is still
	L_139_ = 0
	L_140_ = 0
end)

local L_145_ = false
local L_146_ = CFrame.new()
local L_147_ = CFrame.new()

local L_148_ = 0
local L_149_ = CFrame.new()
local L_150_ = 0.1
local L_151_ = 2

local L_152_ = 0
local L_153_ = .2
local L_154_	= 17

local L_155_ = 0
local L_156_ = 5
local L_157_ = .3

local L_158_, L_159_ = 0, 0

local L_160_ = nil
local L_161_ = nil
local L_162_ = nil

L_3_.Humanoid.Running:connect(function(L_272_arg1)
	if L_272_arg1 > 1 then
		L_145_ = true
	else
		L_145_ = false
	end
end)


Prompt: -- Fire with whitelist

Response:
function FastCast:FireWithWhitelist(origin, directionWithMagnitude, velocity, whitelist, cosmeticBulletObject, ignoreWater, bulletAcceleration, bulletData, whizData, hitData, penetrationData)
	assert(getmetatable(self) == FastCast, ERR_NOT_INSTANCE:format("FireWithWhitelist", "FastCast.new()"))
	BaseFireMethod(self, origin, directionWithMagnitude, velocity, cosmeticBulletObject, nil, ignoreWater, bulletAcceleration, bulletData, whizData, hitData, whitelist, true, penetrationData)
end


Prompt:
-- ================================================================================
-- PUBLIC FUNCTIONS
-- ================================================================================
-- Puts players into an active players table and runs readyPlayer for each player in that table

Response:
function PlayerManager:PreparePlayers()
	-- Get all spawn locations in the folder
	local map = workspace:FindFirstChild("Racetrack")
	if not map then return end

	local spawnLocations = map:FindFirstChild("SpawnLocations")
	if not spawnLocations then return end

	local availableSpawnPoints = spawnLocations:GetChildren()

	-- For every active player, load them into a table, and ready them with everything needed for gameplay
	for _, player in pairs(PlayerManager.ActivePlayers) do
		-- Gets a spawn location and then removes it from the table so the next player gets the next spawn
		local spawnLocation = availableSpawnPoints[1]
		table.remove(availableSpawnPoints, 1)

		PlayerConverter:PlayerToSpeederServer(player, PlayerManager.Selections[player], true)
		readyPlayer(player, spawnLocation)
		CheckpointEvent:FireClient(player, {{"setActive", true}, {"setup"}})
	end
end

function PlayerManager:StartPlayer()
	-- For every active player, unanchor their HumanoidRootPart so that they can start racing
	for _, player in pairs(PlayerManager.ActivePlayers) do
		local character = player.Character or player.CharacterAdded:wait()
		local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")

		if humanoidRootPart then
			humanoidRootPart.Anchored = false
		else
			-- Something is wrong, reload player in lobby
			PlayerConverter:SpeederToPlayerServer(player)
		end
	end
end


Response:
script.Parent.Parent.Values.ABS.Changed:connect(function()
	if _Tune.ABSEnabled then
		if script.Parent.Parent.Values.ABS.Value then
			script.Parent.ABS.TextColor3 = Color3.new(1,170/255,0)
			script.Parent.ABS.TextStrokeColor3 = Color3.new(1,170/255,0)
			if script.Parent.Parent.Values.ABSActive.Value then
				wait()
				script.Parent.ABS.Visible = not script.Parent.ABS.Visible
			else
				wait()
				script.Parent.ABS.Visible = false
			end
		else
			script.Parent.ABS.Visible = true
			script.Parent.ABS.TextColor3 = Color3.new(1,0,0)
			script.Parent.ABS.TextStrokeColor3 = Color3.new(1,0,0)
		end
	else
		script.Parent.ABS.Visible = false
	end
end)

script.Parent.Parent.Values.ABSActive.Changed:connect(function()
	if _Tune.ABSEnabled then
		if script.Parent.Parent.Values.ABSActive.Value and script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = not script.Parent.ABS.Visible
		elseif not script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = true
		else
			wait()
			script.Parent.ABS.Visible = false
		end
	else
		script.Parent.ABS.Visible = false
	end
end)

script.Parent.ABS.Changed:connect(function()
	if _Tune.ABSEnabled then
		if script.Parent.Parent.Values.ABSActive.Value and script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = not script.Parent.ABS.Visible
		elseif not script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = true
		end
	else
		if script.Parent.ABS.Visible then
			script.Parent.ABS.Visible = false
		end
	end
end)

script.Parent.Parent.Values.PBrake.Changed:connect(function()
	script.Parent.PBrake.Visible = script.Parent.Parent.Values.PBrake.Value
end)

script.Parent.Parent.Values.TransmissionMode.Changed:connect(function()
	if script.Parent.Parent.Values.TransmissionMode.Value == "Auto" then
		script.Parent.TMode.Text = "A/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(1,170/255,0)
	elseif script.Parent.Parent.Values.TransmissionMode.Value == "Semi" then
		script.Parent.TMode.Text = "S/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(0, 170/255, 127/255)
	else
		script.Parent.TMode.Text = "M/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(1,85/255,.5)
	end
end)

script.Parent.Parent.Values.Velocity.Changed:connect(function(property)
	script.Parent.Speedo.Needle.Rotation =45 + 225 * math.min(1,UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude/UNITS[currentUnits].maxSpeed)
	script.Parent.Speed.Text = math.floor(UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude) .. " "..UNITS[currentUnits].units
end)

script.Parent.Speed.MouseButton1Click:connect(function()
	if currentUnits==#UNITS then
		currentUnits = 1
	else
		currentUnits = currentUnits+1
	end
	for i,v in pairs(script.Parent.Speedo:GetChildren()) do
		v.Visible=v.Name==UNITS[currentUnits].units or v.Name=="Needle" or v.Name=="lns"
	end
	script.Parent.Speed.Text = math.floor(UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude) .. " "..UNITS[currentUnits].units
end)

mouse.KeyDown:connect(function(key)
	if key=="v" then
		script.Parent.Visible=not script.Parent.Visible
	end
end)


Prompt: --	end

Response:
	self:ActivateCameraController(self:GetCameraControlChoice())
	self:ActivateOcclusionModule(Players.LocalPlayer.DevCameraOcclusionMode)
	self:OnCurrentCameraChanged() -- Does initializations and makes first camera controller
	RunService:BindToRenderStep("cameraRenderUpdate", Enum.RenderPriority.Camera.Value, function(dt) self:Update(dt) end)

	-- Connect listeners to camera-related properties
	for _, propertyName in pairs(PLAYER_CAMERA_PROPERTIES) do
		Players.LocalPlayer:GetPropertyChangedSignal(propertyName):Connect(function()
			self:OnLocalPlayerCameraPropertyChanged(propertyName)
		end)
	end

	for _, propertyName in pairs(USER_GAME_SETTINGS_PROPERTIES) do
		UserGameSettings:GetPropertyChangedSignal(propertyName):Connect(function()
			self:OnUserGameSettingsPropertyChanged(propertyName)
		end)
	end
	game.Workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
		self:OnCurrentCameraChanged()
	end)

	self.lastInputType = UserInputService:GetLastInputType()
	UserInputService.LastInputTypeChanged:Connect(function(newLastInputType)
		self.lastInputType = newLastInputType
	end)

	return self
end

function CameraModule:GetCameraMovementModeFromSettings()
	local cameraMode = Players.LocalPlayer.CameraMode

	-- Lock First Person trumps all other settings and forces ClassicCamera
	if cameraMode == Enum.CameraMode.LockFirstPerson then
		return CameraUtils.ConvertCameraModeEnumToStandard(Enum.ComputerCameraMovementMode.Classic)
	end

	local devMode, userMode
	if UserInputService.TouchEnabled then
		devMode = CameraUtils.ConvertCameraModeEnumToStandard(Players.LocalPlayer.DevTouchCameraMode)
		userMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.TouchCameraMovementMode)
	else
		devMode = CameraUtils.ConvertCameraModeEnumToStandard(Players.LocalPlayer.DevComputerCameraMode)
		userMode = CameraUtils.ConvertCameraModeEnumToStandard(UserGameSettings.ComputerCameraMovementMode)
	end

	if devMode == Enum.DevComputerCameraMovementMode.UserChoice then
		-- Developer is allowing user choice, so user setting is respected
		return userMode
	end

	return devMode
end

function CameraModule:ActivateOcclusionModule( occlusionMode )
	local newModuleCreator
	if occlusionMode == Enum.DevCameraOcclusionMode.Zoom then
		newModuleCreator = Poppercam
	elseif occlusionMode == Enum.DevCameraOcclusionMode.Invisicam then
		newModuleCreator = Invisicam
	else
		warn("CameraScript ActivateOcclusionModule called with unsupported mode")
		return
	end

	-- First check to see if there is actually a change. If the module being requested is already
	-- the currently-active solution then just make sure it's enabled and exit early
	if self.activeOcclusionModule and self.activeOcclusionModule:GetOcclusionMode() == occlusionMode then
		if not self.activeOcclusionModule:GetEnabled() then
			self.activeOcclusionModule:Enable(true)
		end
		return
	end

	-- Save a reference to the current active module (may be nil) so that we can disable it if
	-- we are successful in activating its replacement
	local prevOcclusionModule = self.activeOcclusionModule

	-- If there is no active module, see if the one we need has already been instantiated
	self.activeOcclusionModule = instantiatedOcclusionModules[newModuleCreator]

	-- If the module was not already instantiated and selected above, instantiate it
	if not self.activeOcclusionModule then
		self.activeOcclusionModule = newModuleCreator.new()
		if self.activeOcclusionModule then
			instantiatedOcclusionModules[newModuleCreator] = self.activeOcclusionModule
		end
	end

	-- If we were successful in either selecting or instantiating the module,
	-- enable it if it's not already the currently-active enabled module
	if self.activeOcclusionModule then
		local newModuleOcclusionMode = self.activeOcclusionModule:GetOcclusionMode()
		-- Sanity check that the module we selected or instantiated actually supports the desired occlusionMode
		if newModuleOcclusionMode ~= occlusionMode then
			warn("CameraScript ActivateOcclusionModule mismatch: ",self.activeOcclusionModule:GetOcclusionMode(),"~=",occlusionMode)
		end

		-- Deactivate current module if there is one
		if prevOcclusionModule then
			-- Sanity check that current module is not being replaced by itself (that should have been handled above)
			if prevOcclusionModule ~= self.activeOcclusionModule then
				prevOcclusionModule:Enable(false)
			else
				warn("CameraScript ActivateOcclusionModule failure to detect already running correct module")
			end
		end

		-- Occlusion modules need to be initialized with information about characters and cameraSubject
		-- Invisicam needs the LocalPlayer's character
		-- Poppercam needs all player characters and the camera subject
		if occlusionMode == Enum.DevCameraOcclusionMode.Invisicam then
			-- Optimization to only send Invisicam what we know it needs
			if Players.LocalPlayer.Character then
				self.activeOcclusionModule:CharacterAdded(Players.LocalPlayer.Character, Players.LocalPlayer )
			end
		else
			-- When Poppercam is enabled, we send it all existing player characters for its raycast ignore list
			for _, player in pairs(Players:GetPlayers()) do
				if player and player.Character then
					self.activeOcclusionModule:CharacterAdded(player.Character, player)
				end
			end
			self.activeOcclusionModule:OnCameraSubjectChanged(game.Workspace.CurrentCamera.CameraSubject)
		end

		-- Activate new choice
		self.activeOcclusionModule:Enable(true)
	end
end


Prompt: -- Import services

Response:
local Tool = script.Parent.Parent
local Support = require(Tool.Libraries.SupportLibrary);
Support.ImportServices();

local Types = {
	Part = 0,
	WedgePart = 1,
	CornerWedgePart = 2,
	VehicleSeat = 3,
	Seat = 4,
	TrussPart = 5,
	SpecialMesh = 6,
	Texture = 7,
	Decal = 8,
	PointLight = 9,
	SpotLight = 10,
	SurfaceLight = 11,
	Smoke = 12,
	Fire = 13,
	Sparkles = 14,
	Model = 15
};

local DefaultNames = {
	Part = 'Part',
	WedgePart = 'Wedge',
	CornerWedgePart = 'CornerWedge',
	VehicleSeat = 'VehicleSeat',
	Seat = 'Seat',
	TrussPart = 'Truss',
	SpecialMesh = 'Mesh',
	Texture = 'Texture',
	Decal = 'Decal',
	PointLight = 'PointLight',
	SpotLight = 'SpotLight',
	SurfaceLight = 'SurfaceLight',
	Smoke = 'Smoke',
	Fire = 'Fire',
	Sparkles = 'Sparkles',
	Model = 'Model'
};

function Serialization.SerializeModel(Items)
	-- Returns a serialized version of the given model

	-- Filter out non-serializable items in `Items`
	local SerializableItems = {};
	for Index, Item in ipairs(Items) do
		table.insert(SerializableItems, Types[Item.ClassName] and Item or nil);
	end;
	Items = SerializableItems;

	-- Get a snapshot of the content
	local Keys = Support.FlipTable(Items);

	local Data = {};
	Data.Version = 2;
	Data.Items = {};

	-- Serialize each item in the model
	for Index, Item in pairs(Items) do

		if Item:IsA 'BasePart' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.Size.X;
			Datum[5] = Item.Size.Y;
			Datum[6] = Item.Size.Z;
			Support.ConcatTable(Datum, { Item.CFrame:components() });
			Datum[19] = Item.BrickColor.Number;
			Datum[20] = Item.Material.Value;
			Datum[21] = Item.Anchored and 1 or 0;
			Datum[22] = Item.CanCollide and 1 or 0;
			Datum[23] = Item.Reflectance;
			Datum[24] = Item.Transparency;
			Datum[25] = Item.TopSurface.Value;
			Datum[26] = Item.BottomSurface.Value;
			Datum[27] = Item.FrontSurface.Value;
			Datum[28] = Item.BackSurface.Value;
			Datum[29] = Item.LeftSurface.Value;
			Datum[30] = Item.RightSurface.Value;
			Data.Items[Index] = Datum;
		end;

		if Item.ClassName == 'Part' then
			local Datum = Data.Items[Index];
			Datum[31] = Item.Shape.Value;
		end;

		if Item.ClassName == 'VehicleSeat' then
			local Datum = Data.Items[Index];
			Datum[31] = Item.MaxSpeed;
			Datum[32] = Item.Torque;
			Datum[33] = Item.TurnSpeed;
		end;

		if Item.ClassName == 'TrussPart' then
			local Datum = Data.Items[Index];
			Datum[31] = Item.Style.Value;
		end;

		if Item.ClassName == 'SpecialMesh' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.MeshType.Value;
			Datum[5] = Item.MeshId;
			Datum[6] = Item.TextureId;
			Datum[7] = Item.Offset.X;
			Datum[8] = Item.Offset.Y;
			Datum[9] = Item.Offset.Z;
			Datum[10] = Item.Scale.X;
			Datum[11] = Item.Scale.Y;
			Datum[12] = Item.Scale.Z;
			Datum[13] = Item.VertexColor.X;
			Datum[14] = Item.VertexColor.Y;
			Datum[15] = Item.VertexColor.Z;
			Data.Items[Index] = Datum;
		end;

		if Item:IsA 'Decal' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.Texture;
			Datum[5] = Item.Transparency;
			Datum[6] = Item.Face.Value;
			Data.Items[Index] = Datum;
		end;

		if Item.ClassName == 'Texture' then
			local Datum = Data.Items[Index];
			Datum[7] = Item.StudsPerTileU;
			Datum[8] = Item.StudsPerTileV;
		end;

		if Item:IsA 'Light' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.Brightness;
			Datum[5] = Item.Color.r;
			Datum[6] = Item.Color.g;
			Datum[7] = Item.Color.b;
			Datum[8] = Item.Enabled and 1 or 0;
			Datum[9] = Item.Shadows and 1 or 0;
			Data.Items[Index] = Datum;
		end;

		if Item.ClassName == 'PointLight' then
			local Datum = Data.Items[Index];
			Datum[10] = Item.Range;
		end;

		if Item.ClassName == 'SpotLight' then
			local Datum = Data.Items[Index];
			Datum[10] = Item.Range;
			Datum[11] = Item.Angle;
			Datum[12] = Item.Face.Value;
		end;

		if Item.ClassName == 'SurfaceLight' then
			local Datum = Data.Items[Index];
			Datum[10] = Item.Range;
			Datum[11] = Item.Angle;
			Datum[12] = Item.Face.Value;
		end;

		if Item.ClassName == 'Smoke' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.Enabled and 1 or 0;
			Datum[5] = Item.Color.r;
			Datum[6] = Item.Color.g;
			Datum[7] = Item.Color.b;
			Datum[8] = Item.Size;
			Datum[9] = Item.RiseVelocity;
			Datum[10] = Item.Opacity;
			Data.Items[Index] = Datum;
		end;

		if Item.ClassName == 'Fire' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.Enabled and 1 or 0;
			Datum[5] = Item.Color.r;
			Datum[6] = Item.Color.g;
			Datum[7] = Item.Color.b;
			Datum[8] = Item.SecondaryColor.r;
			Datum[9] = Item.SecondaryColor.g;
			Datum[10] = Item.SecondaryColor.b;
			Datum[11] = Item.Heat;
			Datum[12] = Item.Size;
			Data.Items[Index] = Datum;
		end;

		if Item.ClassName == 'Sparkles' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.Enabled and 1 or 0;
			Datum[5] = Item.SparkleColor.r;
			Datum[6] = Item.SparkleColor.g;
			Datum[7] = Item.SparkleColor.b;
			Data.Items[Index] = Datum;
		end;

		if Item.ClassName == 'Model' then
			local Datum = {};
			Datum[1] = Types[Item.ClassName];
			Datum[2] = Keys[Item.Parent] or 0;
			Datum[3] = Item.Name == DefaultNames[Item.ClassName] and '' or Item.Name;
			Datum[4] = Item.PrimaryPart and Keys[Item.PrimaryPart] or 0;
			Data.Items[Index] = Datum;
		end;

		-- Spread the workload over time to avoid locking up the CPU
		if Index % 100 == 0 then
			wait(0.01);
		end;

	end;

	-- Return the serialized data
	return HttpService:JSONEncode(Data);

end;

function Serialization.InflateBuildData(Data)
	-- Returns an inflated version of the given build data

	local Build = {};
	local Instances = {};

	-- Create each instance
	for Index, Datum in ipairs(Data.Items) do

		-- Inflate BaseParts
		if Datum[1] == Types.Part
			or Datum[1] == Types.WedgePart
			or Datum[1] == Types.CornerWedgePart
			or Datum[1] == Types.VehicleSeat
			or Datum[1] == Types.Seat
			or Datum[1] == Types.TrussPart
		then
			local Item = Instance.new(Support.FindTableOccurrence(Types, Datum[1]));
			Item.Size = Vector3.new(unpack(Support.Slice(Datum, 4, 6)));
			Item.CFrame = CFrame.new(unpack(Support.Slice(Datum, 7, 18)));
			Item.BrickColor = BrickColor.new(Datum[19]);
			Item.Material = Datum[20];
			Item.Anchored = Datum[21] == 1;
			Item.CanCollide = Datum[22] == 1;
			Item.Reflectance = Datum[23];
			Item.Transparency = Datum[24];
			Item.TopSurface = Datum[25];
			Item.BottomSurface = Datum[26];
			Item.FrontSurface = Datum[27];
			Item.BackSurface = Datum[28];
			Item.LeftSurface = Datum[29];
			Item.RightSurface = Datum[30];

			-- Register the part
			Instances[Index] = Item;
		end;

		-- Inflate specific Part properties
		if Datum[1] == Types.Part then
			local Item = Instances[Index];
			Item.Shape = Datum[31];
		end;

		-- Inflate specific VehicleSeat properties
		if Datum[1] == Types.VehicleSeat then
			local Item = Instances[Index];
			Item.MaxSpeed = Datum[31];
			Item.Torque = Datum[32];
			Item.TurnSpeed = Datum[33];
		end;

		-- Inflate specific TrussPart properties
		if Datum[1] == Types.TrussPart then
			local Item = Instances[Index];
			Item.Style = Datum[31];
		end;

		-- Inflate SpecialMesh instances
		if Datum[1] == Types.SpecialMesh then
			local Item = Instance.new('SpecialMesh');
			Item.MeshType = Datum[4];
			Item.MeshId = Datum[5];
			Item.TextureId = Datum[6];
			Item.Offset = Vector3.new(unpack(Support.Slice(Datum, 7, 9)));
			Item.Scale = Vector3.new(unpack(Support.Slice(Datum, 10, 12)));
			Item.VertexColor = Vector3.new(unpack(Support.Slice(Datum, 13, 15)));

			-- Register the mesh
			Instances[Index] = Item;
		end;

		-- Inflate Decal instances
		if Datum[1] == Types.Decal or Datum[1] == Types.Texture then
			local Item = Instance.new(Support.FindTableOccurrence(Types, Datum[1]));
			Item.Texture = Datum[4];
			Item.Transparency = Datum[5];
			Item.Face = Datum[6];

			-- Register the Decal
			Instances[Index] = Item;
		end;

		-- Inflate specific Texture properties
		if Datum[1] == Types.Texture then
			local Item = Instances[Index];
			Item.StudsPerTileU = Datum[7];
			Item.StudsPerTileV = Datum[8];
		end;

		-- Inflate Light instances
		if Datum[1] == Types.PointLight
			or Datum[1] == Types.SpotLight
			or Datum[1] == Types.SurfaceLight
		then
			local Item = Instance.new(Support.FindTableOccurrence(Types, Datum[1]));
			Item.Brightness = Datum[4];
			Item.Color = Color3.new(unpack(Support.Slice(Datum, 5, 7)));
			Item.Enabled = Datum[8] == 1;
			Item.Shadows = Datum[9] == 1;

			-- Register the light
			Instances[Index] = Item;
		end;

		-- Inflate specific PointLight properties
		if Datum[1] == Types.PointLight then
			local Item = Instances[Index];
			Item.Range = Datum[10];
		end;

		-- Inflate specific SpotLight properties
		if Datum[1] == Types.SpotLight then
			local Item = Instances[Index];
			Item.Range = Datum[10];
			Item.Angle = Datum[11];
			Item.Face = Datum[12];
		end;

		-- Inflate specific SurfaceLight properties
		if Datum[1] == Types.SurfaceLight then
			local Item = Instances[Index];
			Item.Range = Datum[10];
			Item.Angle = Datum[11];
			Item.Face = Datum[12];
		end;

		-- Inflate Smoke instances
		if Datum[1] == Types.Smoke then
			local Item = Instance.new('Smoke');
			Item.Enabled = Datum[4] == 1;
			Item.Color = Color3.new(unpack(Support.Slice(Datum, 5, 7)));
			Item.Size = Datum[8];
			Item.RiseVelocity = Datum[9];
			Item.Opacity = Datum[10];

			-- Register the smoke
			Instances[Index] = Item;
		end;

		-- Inflate Fire instances
		if Datum[1] == Types.Fire then
			local Item = Instance.new('Fire');
			Item.Enabled = Datum[4] == 1;
			Item.Color = Color3.new(unpack(Support.Slice(Datum, 5, 7)));
			Item.SecondaryColor = Color3.new(unpack(Support.Slice(Datum, 8, 10)));
			Item.Heat = Datum[11];
			Item.Size = Datum[12];

			-- Register the fire
			Instances[Index] = Item;
		end;

		-- Inflate Sparkles instances
		if Datum[1] == Types.Sparkles then
			local Item = Instance.new('Sparkles');
			Item.Enabled = Datum[4] == 1;
			Item.SparkleColor = Color3.new(unpack(Support.Slice(Datum, 5, 7)));

			-- Register the instance
			Instances[Index] = Item;
		end;

		-- Inflate Model instances
		if Datum[1] == Types.Model then
			local Item = Instance.new('Model');

			-- Register the model
			Instances[Index] = Item;
		end;

	end;

	-- Set object values on each instance
	for Index, Datum in pairs(Data.Items) do

		-- Get the item's instance
		local Item = Instances[Index];

		-- Set each item's parent and name
		if Item and Datum[1] <= 15 then
			Item.Name = (Datum[3] == '') and DefaultNames[Item.ClassName] or Datum[3];
			if Datum[2] == 0 then
				table.insert(Build, Item);
			else
				Item.Parent = Instances[Datum[2]];
			end;
		end;

		-- Set model primary parts
		if Item and Datum[1] == 15 then
			Item.PrimaryPart = (Datum[4] ~= 0) and Instances[Datum[4]] or nil;
		end;

	end;

	-- Return the model
	return Build;

end;


Prompt:
-- These controllers handle only walk/run movement, jumping is handled by the
-- TouchJump controller if any of these are active

Response:
local ClickToMove = require(script:WaitForChild("ClickToMoveController"))
local TouchJump = require(script:WaitForChild("TouchJump"))

local VehicleController = require(script:WaitForChild("VehicleController"))

local CONTROL_ACTION_PRIORITY = Enum.ContextActionPriority.Medium.Value


Prompt: -- MODULE --

Response: local RagdollModule = require(SSS.R6Ragdoll.RagdollBuilder)


Prompt:
--[[*
 * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 ]]

Response:
local LuauPolyfill = require(script.Parent.LuauPolyfill)
local Object = LuauPolyfill.Object

local exports = {}

exports.clearLine = require(script.clearLine).default
exports.createDirectory = require(script.createDirectory).default
local ErrorWithStackModule = require(script.ErrorWithStack)
exports.ErrorWithStack = ErrorWithStackModule.default
export type ErrorWithStack = ErrorWithStackModule.ErrorWithStack


Prompt: -- Called when character is about to be removed

Response:
function BaseOcclusion:CharacterRemoving(char, player)
end

function BaseOcclusion:OnCameraSubjectChanged(newSubject)
end


Prompt: --[[Engine]]

Response:
	local fFD = _Tune.FinalDrive*_Tune.FDMult
	local fFDr = fFD*30/math.pi
	local cGrav = workspace.Gravity*_Tune.InclineComp/32.2
	local wDRatio = wDia*math.pi/60
	local cfWRot = CFrame.Angles(math.pi/2,-math.pi/2,0)
	local cfYRot = CFrame.Angles(0,math.pi,0)
	local rtTwo = (2^.5)/2

	--Horsepower Curve
	local fgc_h=_Tune.Horsepower/100
	local fgc_n=_Tune.PeakRPM/1000
	local fgc_a=_Tune.PeakSharpness
	local fgc_c=_Tune.CurveMult

	function FGC(x)
		x=x/1000
		return (((-(x-fgc_n)^2)*math.min(fgc_h/(fgc_n^2),fgc_c^(fgc_n/fgc_h)))+fgc_h)*(x-((x^fgc_a)/((fgc_a*fgc_n)^(fgc_a-1))))
	end
	local PeakFGC = FGC(_Tune.PeakRPM)

	--Plot Current Horsepower
	function GetCurve(x,gear)
		local hp=math.max((FGC(x)*_Tune.Horsepower)/PeakFGC,0)
		return hp,hp*(_Tune.EqPoint/x)*_Tune.Ratios[gear+2]*fFD*hpScaling
	end

	--Output Cache
	local CacheTorque = true
	local HPCache = {}
	local HPInc = 100

	if CacheTorque then
		for gear,ratio in pairs(_Tune.Ratios) do
			local hpPlot = {}
			for rpm = math.floor(((_Tune.IdleRPM*car.DriveSeat.EcoIdle.Value)+150)/HPInc),math.ceil((_Tune.Redline+100)/HPInc) do
				local tqPlot = {}
				tqPlot.Horsepower,tqPlot.Torque = GetCurve(rpm*HPInc,gear-2)
				hp1,tq1 = GetCurve((rpm+1)*HPInc,gear-2)
				tqPlot.HpSlope = (hp1 - tqPlot.Horsepower)/(HPInc/1000)
				tqPlot.TqSlope = (tq1 - tqPlot.Torque)/(HPInc/1000)
				hpPlot[rpm] = tqPlot
			end
			table.insert(HPCache,hpPlot)
		end
	end

	--Powertrain

	--Update RPM
	function RPM()
		--Neutral Gear
		if _CGear==0 then _ClutchOn = false end

		--Car Is Off
		local revMin = ((_Tune.IdleRPM*car.DriveSeat.EcoIdle.Value)+150)
		if not _IsOn then
			revMin = 0
			_CGear = 0
			_ClutchOn = false
			_GThrot = _Tune.IdleThrottle/100
		end

		--Determine RPM
		local maxSpin=0
		for i,v in pairs(Drive) do
			if v.RotVelocity.Magnitude>maxSpin then maxSpin = v.RotVelocity.Magnitude end
		end
		if _ClutchOn then
			local aRPM = math.max(math.min(maxSpin*_Tune.Ratios[_CGear+2]*fFDr,_Tune.Redline+100),revMin)
			local clutchP = math.min(math.abs(aRPM-_RPM)/_Tune.ClutchTol,.9)
			_RPM = _RPM*clutchP  +  aRPM*(1-clutchP)
		else
			if _GThrot-(_Tune.IdleThrottle/100)>0 then
				if _RPM>_Tune.Redline then
					_RPM = _RPM-_Tune.RevBounce*2
				else
					_RPM = math.min(_RPM+_Tune.RevAccel*_GThrot,_Tune.Redline+100)
				end
			else
				_RPM = math.max(_RPM-_Tune.RevDecay,revMin)
			end
		end

		--Rev Limiter
		_spLimit = (_Tune.Redline+100)/(fFDr*_Tune.Ratios[_CGear+2])
		if _RPM>_Tune.Redline then
			if _CGear<#_Tune.Ratios-2 then
				_RPM = _RPM-_Tune.RevBounce
			else
				_RPM = _RPM-_Tune.RevBounce*.5
			end
		end
	end

	--Apply Power
	function Engine()
		--Get Torque
		local maxSpin=0
		for i,v in pairs(Drive) do
			if v.RotVelocity.Magnitude>maxSpin then maxSpin = v.RotVelocity.Magnitude end
		end
		if _ClutchOn then
			if CacheTorque then
				local cTq = HPCache[_CGear+2][math.floor(math.min(_Tune.Redline,math.max(((_Tune.IdleRPM*car.DriveSeat.EcoIdle.Value)+150),_RPM))/HPInc)]
				_HP = cTq.Horsepower+(cTq.HpSlope*(_RPM-math.floor(_RPM/HPInc))/1000)
				_OutTorque = cTq.Torque+(cTq.TqSlope*(_RPM-math.floor(_RPM/HPInc))/1000)
			else
				_HP,_OutTorque = GetCurve(_RPM,_CGear)

			end
			local iComp =(car.DriveSeat.CFrame.lookVector.y)*cGrav
			if _CGear==-1 then iComp=-iComp end
			_OutTorque = _OutTorque*math.max(1,(1+iComp))
		else
			_HP,_OutTorque = 0,0
		end

		--Automatic Transmission
		if _TMode == "Auto" and _IsOn then
			_ClutchOn = true
			if _CGear == 0 then _CGear = 1 end
			if _CGear >= 1 then
				if _CGear==1 and _GBrake > 0  and car.DriveSeat.Velocity.Magnitude < 0 then
					_CGear = -1
				else
					if _Tune.AutoShiftMode == "RPM" then
						if _RPM>(_Tune.PeakRPM+_Tune.AutoUpThresh) then
							_CGear=math.min(_CGear+1,#_Tune.Ratios-2)
						elseif math.max(math.min(maxSpin*_Tune.Ratios[_CGear+1]*fFDr,_Tune.Redline+100),((_Tune.IdleRPM*car.DriveSeat.EcoIdle.Value)+150))<(_Tune.PeakRPM-_Tune.AutoDownThresh) then
							_CGear=math.max(_CGear-1,1)
						end
					else
						if car.DriveSeat.Velocity.Magnitude > math.ceil(wDRatio*(_Tune.PeakRPM+_Tune.AutoUpThresh)/_Tune.Ratios[_CGear+2]/fFD) then
							_CGear=math.min(_CGear+1,#_Tune.Ratios-2)
						elseif car.DriveSeat.Velocity.Magnitude < math.ceil(wDRatio*(_Tune.PeakRPM-_Tune.AutoDownThresh)/_Tune.Ratios[_CGear+1]/fFD) then
							_CGear=math.max(_CGear-1,1)
						end
					end
				end
			else
				if _GThrot-(_Tune.IdleThrottle/100) > 0 and car.DriveSeat.Velocity.Magnitude < 0 then
					_CGear = 1
				end
			end
		end

		--Average Rotational Speed Calculation
		local fwspeed=0
		local fwcount=0
		local rwspeed=0
		local rwcount=0

		for i,v in pairs(car.Wheels:GetChildren()) do
			if v.Name=="FL" or v.Name=="FR" or v.Name == "F" then
				fwspeed=fwspeed+v.RotVelocity.Magnitude
				fwcount=fwcount+1
			elseif v.Name=="RL" or v.Name=="RR" or v.Name == "R" then
				rwspeed=rwspeed+v.RotVelocity.Magnitude
				rwcount=rwcount+1
			end
		end
		fwspeed=fwspeed/fwcount
		rwspeed=rwspeed/rwcount
		local cwspeed=(fwspeed+rwspeed)/2

		--Update Wheels
		for i,v in pairs(car.Wheels:GetChildren()) do
			--Reference Wheel Orientation
			local Ref=(CFrame.new(v.Position-((v.Arm.CFrame*cfWRot).lookVector),v.Position)*cfYRot).lookVector
			local aRef=1
			local diffMult=1
			if v.Name=="FL" or v.Name=="RL" then aRef=-1 end

			--AWD Torque Scaling
			if _Tune.Config == "AWD" then _OutTorque = _OutTorque*rtTwo end

			--Differential/Torque-Vectoring
			if v.Name=="FL" or v.Name=="FR" then
				diffMult=math.max(0,math.min(1,1+((((v.RotVelocity.Magnitude-fwspeed)/fwspeed)/(math.max(_Tune.FDiffSlipThres,1)/100))*((_Tune.FDiffLockThres-50)/50))))
				if _Tune.Config == "AWD" then
					diffMult=math.max(0,math.min(1,diffMult*(1+((((fwspeed-cwspeed)/cwspeed)/(math.max(_Tune.CDiffSlipThres,1)/100))*((_Tune.CDiffLockThres-50)/50)))))
				end
			elseif v.Name=="RL" or v.Name=="RR" then
				diffMult=math.max(0,math.min(1,1+((((v.RotVelocity.Magnitude-rwspeed)/rwspeed)/(math.max(_Tune.RDiffSlipThres,1)/100))*((_Tune.RDiffLockThres-50)/50))))
				if _Tune.Config == "AWD" then
					diffMult=math.max(0,math.min(1,diffMult*(1+((((rwspeed-cwspeed)/cwspeed)/(math.max(_Tune.CDiffSlipThres,1)/100))*((_Tune.CDiffLockThres-50)/50)))))
				end
			end

			_TCSActive = false
			_ABSActive = false
			--Output
			if _PBrake and ((_Tune.Config ~= "FWD" and (((v.Name=="FL" or v.Name=="FR") and car.DriveSeat.Velocity.Magnitude<20) or ((v.Name=="RR" or v.Name=="RL") and car.DriveSeat.Velocity.Magnitude>=20))) or (_Tune.Config == "FWD" and (v.Name=="RR" or v.Name=="RL"))) then
				--PBrake
				v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*PBrakeForce
				v["#AV"].angularvelocity=Vector3.new()
			else
				--Apply Power
				if ((_TMode == "Manual" or _TMode == "Semi") and _GBrake==0) or (_TMode == "Auto" and ((_CGear>-1 and _GBrake==0 ) or (_CGear==-1 and _GThrot-(_Tune.IdleThrottle/100)==0 )))then
					local driven = false
					for _,a in pairs(Drive) do if a==v then driven = true end end
					if driven then
						local on=1
						if not car.DriveSeat.IsOn.Value then on=0 end
						local throt = _GThrot
						if _TMode == "Auto" and _CGear==-1 then throt = _GBrake end

						--Apply TCS
						local tqTCS = 1
						if _TCS then
							tqTCS = 1-(math.min(math.max(0,math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.TCSThreshold)/_Tune.TCSGradient,1)*(1-(_Tune.TCSLimit/100)))
						end
						if tqTCS < 1 then
							_TCSActive = true
						end

						--Update Forces
						local dir = 1
						if _CGear==-1 then dir = -1 end
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*_OutTorque*(1+(v.RotVelocity.Magnitude/60)^1.15)*throt*tqTCS*diffMult*on
						v["#AV"].angularvelocity=Ref*aRef*_spLimit*dir
					else
						v["#AV"].maxTorque=Vector3.new()
						v["#AV"].angularvelocity=Vector3.new()
					end

				--Brakes
				else
					local brake = _GBrake
					if _TMode == "Auto" and _CGear==-1 then brake = _GThrot end

					--Apply ABS
					local tqABS = 1
					if _ABS and math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.ABSThreshold>0 then
						tqABS = 0
					end
					if tqABS < 1 then
						_ABSActive = true
					end

					--Update Forces
					if v.Name=="FL" or v.Name=="FR" or v.Name=="F" then
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*FBrakeForce*brake*tqABS
					else
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*RBrakeForce*brake*tqABS
					end
					v["#AV"].angularvelocity=Vector3.new()
				end
			end
		end
	end

	script.Parent.Values.RPM.Changed:connect(function()
		if car.DriveSeat.Mode.Value == "Eco" then
			if _RPM > 260 then
				car.DriveSeat.Tic.Value = true
			else
				car.DriveSeat.Tic.Value = false
			end
		end
	end)
	car.DriveSeat.Tic.Changed:connect(function()
		if car.DriveSeat.Tic.Value == true and car.DriveSeat.Mode.Value == "Eco" then
			car.DriveSeat.EcoStart:Play()
		end
	end)


Prompt: --Acion on admin

Response:
	if Model ~= nil then
	Model:clone().Parent = player:WaitForChild("PlayerGui") else
		end
end
		end
	end)
end)


Response:
local TwinService = game:GetService("TweenService")
local AnimationHighLight = TweenInfo.new(1, Enum.EasingStyle.Sine ,Enum.EasingDirection.InOut)
local Info1 = {Position = Vector3.new(pos1,Positionn,pos3)}
local Info2 = {Position = Vector3.new(pos1,Positionn2,pos3)}
local AnimkaUp = TwinService:Create(Danger, AnimationHighLight, Info1 )
local AnimkaDown = TwinService:Create(Danger, AnimationHighLight, Info2 )
while true do
	AnimkaUp:Play()
	wait(1)
	AnimkaDown:Play()
	wait(1)
end


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 170		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 4000		--		Use sliders to manipulate values
	Tune.Redline		= 5000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16

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

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


Prompt: --[[Weight and CG]]

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

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

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


Prompt:
--[=[
	@return Promise<any>
	Returns a Promise which resolves once the property object is
	ready to be used. The resolved promise will also contain the
	value of the property.

	```lua
	-- Use andThen clause:
	clientRemoteProperty:OnReady():andThen(function(initialValue)
		print(initialValue)
	end)

	-- Use await:
	local success, initialValue = clientRemoteProperty:OnReady():await()
	if success then
		print(initialValue)
	end
	```
]=]

Response:
function ClientRemoteProperty:OnReady()
	if self._ready then
		return Promise.resolve(self._value)
	end
	return Promise.fromEvent(self._rs, function(value)
		self._value = value
		self._ready = true
		return true
	end):andThen(function()
		return self._value
	end)
end


Prompt: -- Handle Transitions

Response:
local replicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(replicatedStorage:WaitForChild("EventSequencer"))
local tokenTransitionModule = require(script:WaitForChild("TokenTransitionModule"))

EventSequencer.onSceneEndingWarningForClient:Connect(function(oldSceneName)
	tokenTransitionModule.Enable()
end)
EventSequencer.onSceneLoadedForClient:Connect(function(newSceneName)
	wait(4)
	tokenTransitionModule.Disable()
end)


Prompt: -- объявление генератора случайных чисел

Response: rnd=Random.new()


Prompt: -- Parts

Response:
local Entry = Slide:WaitForChild("Entry")

local function MovePlayer(Part)
	if game.Players:GetPlayerFromCharacter(Part.Parent) then
		local Character = Part.Parent
		local Humanoid = Character:WaitForChild("Humanoid")
		local RootPart = Character:WaitForChild("HumanoidRootPart")

		if Humanoid.Sit == false then
			-- Make player sit
			Humanoid.Sit = true

			if Character.PrimaryPart then
				-- Move player
				Character:SetPrimaryPartCFrame(Entry.CFrame * CFrame.Angles(0,0,math.rad(90)) + Entry.CFrame.lookVector*2)
			else
				-- Extra precaution
				RootPart.CFrame = CFrame.new(Entry.CFrame * CFrame.Angles(0,0,math.rad(90)) + Entry.CFrame.lookVector*2)
			end
		end
	end
end


Prompt: --- Scan for GUIs to add to index

Response:
local function Scan(instance, parent)
	--- Calculates which gui instance is more important (based on dependance and class)
	local function MoreImportant(a, b)
		local aHeight, aCurr = 0, a
		local bHeight, bCurr = 0, b
		repeat  aCurr = aCurr.Parent  aHeight = aHeight + 1  until aCurr.Parent == playerGui
		repeat  bCurr = bCurr.Parent  bHeight = bHeight + 1  until bCurr.Parent == playerGui
		if aHeight == bHeight then
			for i, v in ipairs(whitelistedClasses) do
				if v == a.ClassName then
					aHeight = i
				elseif v == b.ClassName then
					bHeight = i
				end
			end
		end
		return (aHeight < bHeight and a or b)
	end

	--- Iterate through gui instance children
	for _, child in ipairs(instance:GetChildren()) do
		if child.ClassName == "ScreenGui" and (not _L.Functions.SearchArray(blacklistedGuis, child.Name)) then
			GUI[child.Name:gsub("%s+", "")] = {Gui = child}
			Scan(child, child)
		elseif child:IsA("GuiObject") and parent then
			local exists = GUI[parent.Name:gsub("%s+", "")][child.Name:gsub("%s+", "")]
			if (not exists) or (exists and MoreImportant(child, exists) == child) then
				GUI[parent.Name:gsub("%s+", "")][child.Name:gsub("%s+", "")] = child
			end
			Scan(child, parent)
		end
	end
end

Scan(playerGui)

playerGui.ChildAdded:Connect(function(child)
	if child.ClassName == "ScreenGui" and (not _L.Functions.SearchArray(blacklistedGuis, child.Name)) then
		GUI[child.Name:gsub("%s+", "")] = {Gui = child}
		Scan(child, child)
	end
end)


Response:
Displays = 2 -- Sets how many displays this scripts will use...
DisplayColor = Color3.fromRGB(248, 248, 248)


Prompt: --Precalculated paths

Response:
local t,f,n=true,false,{}
local r={
[58]={{57,58},t},
[49]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49},t},
[16]={n,f},
[19]={{57,58,20,19},t},
[59]={{57,56,30,41,59},t},
[63]={{57,58,23,62,63},t},
[34]={{57,56,30,41,39,35,34},t},
[21]={{57,58,20,21},t},
[48]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48},t},
[27]={{57,56,30,41,39,35,34,32,31,29,28,27},t},
[14]={n,f},
[31]={{57,56,30,41,39,35,34,32,31},t},
[56]={{57,56},t},
[29]={{57,56,30,41,39,35,34,32,31,29},t},
[13]={n,f},
[47]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47},t},
[12]={n,f},
[45]={{57,56,30,41,39,35,34,32,31,29,28,44,45},t},
[57]={{57},t},
[36]={{57,56,30,41,39,35,37,36},t},
[25]={{57,56,30,41,39,35,34,32,31,29,28,27,26,25},t},
[71]={{57,56,30,41,59,61,71},t},
[20]={{57,58,20},t},
[60]={{57,56,30,41,60},t},
[8]={n,f},
[4]={n,f},
[75]={{57,56,30,41,59,61,71,72,76,73,75},t},
[22]={{57,58,20,21,22},t},
[74]={{57,56,30,41,59,61,71,72,76,73,74},t},
[62]={{57,58,23,62},t},
[1]={n,f},
[6]={n,f},
[11]={n,f},
[15]={n,f},
[37]={{57,56,30,41,39,35,37},t},
[2]={n,f},
[35]={{57,56,30,41,39,35},t},
[53]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,52,53},t},
[73]={{57,56,30,41,59,61,71,72,76,73},t},
[72]={{57,56,30,41,59,61,71,72},t},
[33]={{57,56,30,41,39,35,37,36,33},t},
[69]={{57,56,30,41,60,69},t},
[65]={{57,58,20,19,66,64,65},t},
[26]={{57,56,30,41,39,35,34,32,31,29,28,27,26},t},
[68]={{57,58,20,19,66,64,67,68},t},
[76]={{57,56,30,41,59,61,71,72,76},t},
[50]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,50},t},
[66]={{57,58,20,19,66},t},
[10]={n,f},
[24]={{57,56,30,41,39,35,34,32,31,29,28,27,26,25,24},t},
[23]={{57,58,23},t},
[44]={{57,56,30,41,39,35,34,32,31,29,28,44},t},
[39]={{57,56,30,41,39},t},
[32]={{57,56,30,41,39,35,34,32},t},
[3]={n,f},
[30]={{57,56,30},t},
[51]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,50,51},t},
[18]={n,f},
[67]={{57,58,20,19,66,64,67},t},
[61]={{57,56,30,41,59,61},t},
[55]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,52,53,54,55},t},
[46]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,46},t},
[42]={{57,56,30,41,39,40,38,42},t},
[40]={{57,56,30,41,39,40},t},
[52]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,52},t},
[54]={{57,56,30,41,39,35,34,32,31,29,28,44,45,49,48,47,52,53,54},t},
[43]={n,f},
[7]={n,f},
[9]={n,f},
[41]={{57,56,30,41},t},
[17]={n,f},
[38]={{57,56,30,41,39,40,38},t},
[28]={{57,56,30,41,39,35,34,32,31,29,28},t},
[5]={n,f},
[64]={{57,58,20,19,66,64},t},
}
return r


Prompt:
--[[while true do
local v = 4
int = .1
for i = 1, 18 do
script.Parent.Rotation=script.Parent.Rotation+5--*v
game:GetService('RunService').RenderStepped:wait()
end
wait(int)
end--]]

Response:
while true do
script.Parent.Rotation = script.Parent.Rotation + 10
game:GetService('RunService').RenderStepped:wait()
end


Prompt: -- ANimation

Response:
local Sound = script:WaitForChild("Haoshoku Sound")

UIS.InputBegan:Connect(function(Input)
	if Input.KeyCode == Enum.KeyCode.V and Debounce == 1 and Tool.Equip.Value == true and Tool.Active.Value == "None" and script.Parent.DargonOn.Value == true then
		Debounce = 2
		Track1 = plr.Character.Dragon.Dragonoid:LoadAnimation(script.AnimationCharge)
		Track1:Play()
		for i = 1,math.huge do
			if Debounce == 2 then

				plr.Character.HumanoidRootPart.CFrame = CFrame.new(plr.Character.HumanoidRootPart.Position, Mouse.Hit.p)
				plr.Character.HumanoidRootPart.Anchored = true
			else

				break
				end
	     wait()
	  end
	end
end)

UIS.InputEnded:Connect(function(Input)
	if Input.KeyCode == Enum.KeyCode.V and Debounce == 2 and Tool.Equip.Value == true and Tool.Active.Value == "None" and script.Parent.DargonOn.Value == true then
		Debounce = 3
		plr.Character.HumanoidRootPart.Anchored = false
		local Track2 = plr.Character.Dragon.Dragonoid:LoadAnimation(script.AnimationRelease)
		Track2:Play()
		Track1:Stop()
		Sound:Play()
		for i = 1,10 do
			wait(0.1)
		local mousepos = Mouse.Hit
		script.RemoteEvent:FireServer(mousepos,Mouse.Hit.p)
		end
		wait(0.3)
		Track2:Stop()
		wait(.5)
		Tool.Active.Value = "None"
		wait(3)
		Debounce = 1
	end
end)


Prompt: --script.Parent.Parent.Values.RPM.Changed:connect(function()

Response:
function Spool()
	--When In Neutral
	if Values.Horsepower.Value == 0 then
		totalPSI = totalPSI + ((((((Values.RPM.Value*(Values.Throttle.Value*1.2)/Redline)/8)-(((totalPSI/WasteGatePressure*(WasteGatePressure/15)))))*((36/TurboSize)*3))/WasteGatePressure)*15)
		if totalPSI < 0.05 then
			totalPSI = 0.05
		end
		if totalPSI > 2 then
			totalPSI = 2
		end
		--TEST

	end
	--When Driving
	if Values.Horsepower.Value > 0 then
		totalPSI = totalPSI + ((((((Values.RPM.Value*(Values.Throttle.Value*1.2)/Redline)/8)-(((totalPSI/WasteGatePressure*(WasteGatePressure/15)))))*((36/TurboSize)*3))/WasteGatePressure)*15)
		if totalPSI < 0.05 then
			totalPSI = 0.05
		end
		if totalPSI > 2 then
			totalPSI = 2
		end
		--TEST

	end

	actualPSI = totalPSI/2

	if FE then
		local BP = totalPSI

		handler:FireServer(totalPSI,actualPSI,Throttle,BOVFix,BOV_Loudness,TurboLoudness,BOV_Pitch)
	else
		local Throttle2 = Throttle
		local W = car.DriveSeat:WaitForChild("Whistle")
		local B = car.DriveSeat:WaitForChild("BOV")

		local bvol = B.Volume

		if Throttle2 < 0 then
			Throttle2 = 0
		end
		W.Pitch = (totalPSI)
		W.Volume = (totalPSI/4)*TurboLoudness
		B.Pitch = (1 - (-totalPSI/20))*BOV_Pitch
		B.Volume = (((-0.5+((totalPSI/2)*BOV_Loudness)))*(1 - script.Parent.Parent.Values.Throttle.Value))

	end
	end


Prompt:
--[=[
	Cleans up the subscription

	:::tip
	This will be invoked by the Observable automatically, and should not
	be called within the usage of a subscription.
	:::
]=]

Response:
function Subscription:Destroy()
	if self._state == stateTypes.PENDING then
		self._state = stateTypes.CANCELLED
	end

	self:_doCleanup()
end


Prompt: -- The length of the output array is the index of the next input line.


Prompt: --- Returns an array of the names of all registered commands (not including aliases)

Response:
function Registry:GetCommandNames ()
	local commands = {}

	for _, command in pairs(self.CommandsArray) do
		commands[#commands + 1] = command.Name
	end

	return commands
end

Registry.GetCommandsAsStrings = Registry.GetCommandNames


Prompt:
--[[
for i = 1, 100, 0.5 do
	HB:Wait();
	UI:LBarSetPercent(P, i);
end
--]]


Prompt:
-----------------------------------------------------------------------
-- converts a number to a little-endian 32-bit integer string
-- * input value assumed to not overflow, can be signed/unsigned
-----------------------------------------------------------------------

Response:
function luaU:from_int(x)
  local v = ""
  x = math.floor(x)
  if x < 0 then x = 4294967296 + x end  -- ULONG_MAX+1
  for i = 1, 4 do
    local c = x % 256
    v = v..string.char(c); x = math.floor(x / 256)
  end
  return v
end


Prompt: --[[Status Vars]]

Response:
	local _IsOn = _Tune.AutoStart
	if _Tune.AutoStart then script.Parent.IsOn.Value=true end

	local _GSteerT=0
	local _GSteerC=0
	local _GThrot=0
	local _GBrake=0

	local _ClutchOn = true
	local _ClPressing = false
	local _RPM = 0
	local _HP = 0
	local _OutTorque = 0
	local _CGear = 0
	local _PGear = _CGear
	local _spLimit = 0

	local _TMode = _Tune.TransModes[1]

	local _MSteer = false
	local _SteerL = false
	local _SteerR = false
	local _PBrake = false
	local _TCS = _Tune.TCSEnabled
	local _TCSActive = false
	local _ABS = _Tune.ABSEnabled
	local _ABSActive = false

	local FlipWait=tick()
	local FlipDB=false

	local _InControls = false

	script.Parent.DriveMode.Changed:Connect(function()
		if script.Parent.DriveMode.Value == "SportPlus" then
		   if _Tune.TCSEnabled and _IsOn then
					_TCS = false
		   end
		else
		   if _Tune.TCSEnabled and _IsOn then
					_TCS = true
		   end
		end
	end)


Prompt: -- RCM Settings V

Response:
self.WeaponWeight		= 4 -- Weapon weight must be enabled in the Config module

self.ShellEjectionMod	= true

self.Holster			= true
self.HolsterPoint		= "Torso"
self.HolsterCFrame		= CFrame.new(0.8,0.5,0.9) * CFrame.Angles(math.rad(-90),math.rad(2),math.rad(10))

self.FlashChance = 5 -- 0 = no muzzle flash, 10 = Always muzzle flash

self.ADSEnabled 		= { -- Ignore this setting if not using an ADS Mesh
	true, -- Enabled for primary sight
	false} -- Enabled for secondary sight (T)

self.ExplosiveAmmo		= false -- Enables explosive ammo
self.ExplosionRadius	= 70 -- Radius of explosion damage in studs
self.ExplosionType		= "Default" -- Which explosion effect is used from the HITFX Explosion folder
self.IsLauncher			= true -- For RPG style rocket launchers

self.EjectionOverride	= nil -- Don't touch unless you know what you're doing with Vector3s

return self


Prompt: --[[ Local Functions ]]

Response:
--
local function onShiftLockToggled(Value, Lock) -- NEW: everything here

	-- Process if not prevented, or prevention being disabled
	if PreventShiftLock == false or Lock == false then

		-- Change
		IsShiftLocked = Value ~= nil and Value or not IsShiftLocked

		-- Begin prevention
		if Lock ~= nil then
			PreventShiftLock = Lock
			if Lock == false and Value == false then -- When unlocked set to prior state before lock
				IsShiftLocked = ShiftLockedBefore
			end
		else
			ShiftLockedBefore = IsShiftLocked -- Remember for when unlocking
		end

		-- Update mouse cursor
		if IsShiftLocked then
			ShiftLockIcon.Image = SHIFT_LOCK_ON
			Mouse.Icon = SHIFT_LOCK_CURSOR
		else
			ShiftLockIcon.Image = SHIFT_LOCK_OFF
			Mouse.Icon = ""
		end

		-- Fire!
		ShiftLockController.OnShiftLockToggled:Fire()
	end
end

local function initialize()
	if ScreenGui then
		ScreenGui:Destroy()
		ScreenGui = nil
	end
	ScreenGui = Instance.new('ScreenGui')
	ScreenGui.Name = "ControlGui"

	local frame = Instance.new('Frame')
	frame.Name = "BottomLeftControl"
	frame.Size = UDim2.new(0, 130, 0, 46)
	frame.Position = UDim2.new(0, 0, 1, -46)
	frame.BackgroundTransparency = 1
	frame.Parent = ScreenGui

	ShiftLockIcon = Instance.new('ImageButton')
	ShiftLockIcon.Name = "MouseLockLabel"
	ShiftLockIcon.Size = UDim2.new(0, 31, 0, 31)
	ShiftLockIcon.Position = UDim2.new(0, 12, 0, 2)
	ShiftLockIcon.BackgroundTransparency = 1
	ShiftLockIcon.Image = IsShiftLocked and SHIFT_LOCK_ON or SHIFT_LOCK_OFF
	ShiftLockIcon.Visible = true
	ShiftLockIcon.Parent = frame

	ShiftLockIcon.MouseButton1Click:connect(onShiftLockToggled)

	ScreenGui.Parent = IsShiftLockMode and PlayerGui or nil
end


Prompt:
--[[
	Create a new test result node and push it onto the navigation stack.
]]

Response:
function TestSession:pushNode(planNode)
	local node = TestResults.createNode(planNode)
	local lastNode = self.nodeStack[#self.nodeStack] or self.results
	local lastContext = self.contextStack[#self.contextStack]
	local context = Context.new(lastContext)

	table.insert(lastNode.children, node)
	table.insert(self.nodeStack, node)
	table.insert(self.contextStack, context)
end


Prompt: --use this to determine if you want this human to be harmed or not, returns boolean

Response:
function boom()
	wait(1)
	Used = true
	Object.Anchored = false
	--Object.Orientation = Vector3.new(0,0,0)
	Object.Transparency = 1
	Explode()
end

boom()


Prompt: -- 100 == 1  0 == 0  1/0.5

Response:
function JamCalculation()
	local L_185_
	if (math.random(1, 100) <= L_24_.JamChance) then
		L_185_ = true
		L_75_ = true
	else
		L_185_ = false
	end
	return L_185_
end

function TracerCalculation()
	local L_186_
	if (math.random(1, 100) <= L_24_.TracerChance) then
		L_186_ = true
	else
		L_186_ = false
	end
	return L_186_
end

function ScreamCalculation()
	local L_187_
	if (math.random(1, 100) <= L_24_.SuppressCalloutChance) then
		L_187_ = true
	else
		L_187_ = false
	end
	return L_187_
end

function SearchResupply(L_188_arg1)
	local L_189_ = false
	local L_190_ = nil

	if L_188_arg1:FindFirstChild('ResupplyVal') or L_188_arg1.Parent:FindFirstChild('ResupplyVal') then
		L_189_ = true
		if L_188_arg1:FindFirstChild('ResupplyVal') then
			L_190_ = L_188_arg1.ResupplyVal
		elseif L_188_arg1.Parent:FindFirstChild('ResupplyVal') then
			L_190_ = L_188_arg1.Parent.ResupplyVal
		end
	end
	return L_189_, L_190_
end

function CheckReverb()
	local L_191_, L_192_ = workspace:FindPartOnRayWithIgnoreList(Ray.new(L_6_.CFrame.p, (L_6_.CFrame.upVector).unit * 30), IgnoreList);

	if L_191_ then
		local L_193_ = L_59_:WaitForChild('Fire'):FindFirstChild('ReverbSoundEffect') or Instance.new("ReverbSoundEffect", L_59_:WaitForChild('Fire'))
	elseif not L_191_ then
		if L_59_:WaitForChild('Fire'):FindFirstChild('ReverbSoundEffect') then
			L_59_.Fire.ReverbSoundEffect:Destroy()
		end
	end
end

function UpdateAmmo()
	L_29_.Text = L_106_
	L_30_.Text = L_29_.Text

	L_31_.Text = '| ' .. math.ceil(L_107_ / L_24_.StoredAmmo)
	L_32_.Text = L_31_.Text

	if L_93_ == 0 then
		L_40_.Image = 'rbxassetid://' .. 1868007495
	elseif L_93_ == 1 then
		L_40_.Image = 'rbxassetid://' .. 1868007947
	elseif L_93_ == 2 then
		L_40_.Image = 'rbxassetid://' .. 1868008584
	end

	if L_92_ == 1 then
		L_35_.BackgroundTransparency = 0
		L_36_.BackgroundTransparency = 0.7
		L_37_.BackgroundTransparency = 0.7
		L_38_.BackgroundTransparency = 0.7
		L_39_.BackgroundTransparency = 0.7
	elseif L_92_ == 2 then
		L_35_.BackgroundTransparency = 0
		L_36_.BackgroundTransparency = 0
		L_37_.BackgroundTransparency = 0
		L_38_.BackgroundTransparency = 0
		L_39_.BackgroundTransparency = 0
	elseif L_92_ == 3 then
		L_35_.BackgroundTransparency = 0
		L_36_.BackgroundTransparency = 0
		L_37_.BackgroundTransparency = 0
		L_38_.BackgroundTransparency = 0.7
		L_39_.BackgroundTransparency = 0.7
	elseif L_92_ == 4 then
		L_35_.BackgroundTransparency = 0
		L_36_.BackgroundTransparency = 0
		L_37_.BackgroundTransparency = 0
		L_38_.BackgroundTransparency = 0
		L_39_.BackgroundTransparency = 0.7
	elseif L_92_ == 5 then
		L_35_.BackgroundTransparency = 0
		L_36_.BackgroundTransparency = 0.7
		L_37_.BackgroundTransparency = 0
		L_38_.BackgroundTransparency = 0.7
		L_39_.BackgroundTransparency = 0.7
	elseif L_92_ == 6 then
		L_35_.BackgroundTransparency = 0
		L_36_.BackgroundTransparency = 0.7
		L_37_.BackgroundTransparency = 0
		L_38_.BackgroundTransparency = 0
		L_39_.BackgroundTransparency = 0.7
	end

end


Prompt:
--[[
	Special value for assigning tags to roblox instances via Roact
]]

Response:
local Symbol = require(script.Parent.Parent["Symbol.roblox"])

local Tag = Symbol.named("RobloxTag")

return Tag


Prompt:
--[=[
	@param value any
	Sets the top-level value of all clients to the same value.

	:::note Override Per-Player Data
	This will override any per-player data that was set using
	`SetFor` or `SetFilter`. To avoid overriding this data,
	`SetTop` can be used instead.
	:::

	```lua
	-- Examples
	remoteProperty:Set(10)
	remoteProperty:Set({SomeData = 32})
	remoteProperty:Set("HelloWorld")
	```
]=]

Response:
function RemoteProperty:Set(value: any)
	self._value = value
	table.clear(self._perPlayer)
	self._rs:FireAll(value)
end


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

Response:
local ITEM_NAME = "Shotgun"
local ITEM_PRICE = 10
local CURRENCY_NAME = "Cash"


Prompt:
--[[
	   ___  _____
	  / _ |/ ___/	Avxnturador | Novena
	 / __ / /__			 LuaInt | Novena
	/_/ |_\___/   Build 6C, Version 1.5, Update 2

]]


Prompt:
--[=[
	Counts the number of items in `_table`.
	Useful since `__len` on table in Lua 5.2 returns just the array length.

	@param _table table -- Table to count
	@return number -- count
]=]

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


Prompt: --// H key, Horn

Response:
mouse.KeyDown:connect(function(key)
	if key=="h" then
		script.Parent.Parent.Horn.TextTransparency = 0
		veh.Lightbar.middle.Airhorn:Play()
		veh.Lightbar.middle.Wail.Volume = 0
		veh.Lightbar.middle.Yelp.Volume = 0
		veh.Lightbar.middle.Priority.Volume = 0
		veh.Lightbar.middle.Hilo.Volume = 0
		veh.Lightbar.middle.Rwail.Volume = 0
script.Parent.Parent.MBOV.Visible = true
			script.Parent.Parent.MBOV.Text = "Made by OfficerVargas"
	end
end)


Prompt:
-- This script causes the character to die whenever it is sitting.
--
-- So it is a really bad seat allergy.
--
-- ForbiddenJ

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


Prompt:
--[[
Made By TrolledTrollage, Date: 4/4/2022
Module Name: CustomHotbar

!! THIS SCRIPT ONLY WORKS FOR THE CLIENT AREA !!

USAGE EXAMPLE:

-- only works on local scripts
local hotbar = require(script.CustomHotbar)

 -- make new hotbar
local newhotbar = hotbar.new(Hotbar,ButtonTemplate)

-- fires on equip
newhotbar.Equipped:Connect(function(tool,frame)
	print(string.format("Equipped Tool: %s",tool.Name))
end)

-- fires on unequip,if tool was dropped, this wont fire
newhotbar.Unequipped:Connect(function(tool,frame)
	print(string.format("Unequipped Tool: %s",tool.Name))
end)

-- will fire if tool was dropped
newhotbar.Dropped:Connect(function(tool)
	print(string.format("Dropped Tool: %s",tool.Name))
end)

]]

Response:
function setup(Bar:GuiObject,Template:Button,E1:BindableEvent,E2:BindableEvent,E3:BindableEvent)
	local UserInputService = game:GetService("UserInputService")
	local TweenService = game:GetService("TweenService")
	local StarterGui = game:GetService("StarterGui")
	local Players = game:GetService("Players")

	local Player = Players.LocalPlayer
	local Backpack = Player.Backpack
	local Character = Player.Character

	local Equipped,Unequipped,Dropped = E1,E2,E3

	local Keys = {
		Zero = 10;
		One = 1;
		Two = 2;
		Three = 3;
		Four = 4;
		Five = 5;
		Six = 6;
		Seven = 7;
		Eight = 8;
		Nine = 9;
	}

	local items = {}
	local frames = {}

	local function handleEquip(tool)
		if tool.Parent ~= Character then
			Character.Humanoid:EquipTool(tool)
		else
			Character.Humanoid:UnequipTools()
		end
	end

	local function checkHotbar(removeIndex)
		if removeIndex then
			for _, toolFrame in pairs(Bar:GetChildren()) do
				if toolFrame:IsA("GuiObject") then
					pcall(function()
						if tonumber(toolFrame.Name) >= removeIndex then
							local newIndex = (tonumber(toolFrame.Name) == 11) and 0 or tonumber(toolFrame.Name) - 1
							local isVisible = (maxBar == 10) and (newIndex <= 9 and true or false)

							toolFrame.LayoutOrder -= 1
							toolFrame.Name -= 1
							toolFrame.Visible = isVisible or ((newIndex ~= 0 and newIndex <= maxBar) and true or false)
							if toolFrame:FindFirstChild("Key") and toolFrame.Key.ClassName == "TextLabel" then
								toolFrame.Key.Text = newIndex
							end
						end
					end)
				end
			end
		end

		for index, tool in ipairs(items) do
			local toolFrame = Bar:FindFirstChild(index)
			local isEquipped = (tool.Parent == Character)

			if not toolFrame then
				return
			end

			if frames[toolFrame] then
				frames[toolFrame] = nil
			end

			if isEquipped then
				Equipped:Fire(tool,toolFrame)
			else
				if (tool.Parent == Backpack) then
					Unequipped:Fire(tool,toolFrame)
				end
			end
		end
	end

	local function create(tool)
		local nextIndex = (#items == 10) and 0 or #items
		local isVisible = (maxBar == 10) and (nextIndex <= 9 and true or false) or ((nextIndex ~= 0 and nextIndex <= maxBar) and true or false)

		local toolFrame = Template:Clone()
		toolFrame.LayoutOrder = #items
		toolFrame.Name = #items
		toolFrame.Text = tool.Name
		toolFrame.Visible = isVisible
		if toolFrame:FindFirstChild("Key") and toolFrame.Key.ClassName == "TextLabel" then
			toolFrame.Key.Text = nextIndex
		end

		if toolFrame:FindFirstChild("Image") then
			if tool.TextureId ~= "" then
				toolFrame.Image.Image = tool.TextureId
				toolFrame.Text = ""
			end
		end

		toolFrame.Parent = Bar
		if toolFrame:IsA("TextButton") or toolFrame:IsA("ImageButton") then
			toolFrame.MouseButton1Click:Connect(function()
				handleEquip(tool)
			end)
		end

		checkHotbar()
	end

	local function updateAdd(tool)
		if not tool:IsA("Tool") then
			return
		end

		checkHotbar()
		if table.find(items, tool) then
			return
		end

		table.insert(items, tool)
		create(tool)
	end

	local function updateRemove(tool)
		if not tool:IsA("Tool") then
			return
		end

		if (tool.Parent == Character) or (tool.Parent == Backpack) then
			return
		end

		if table.find(items, tool) then
			local index = table.find(items, tool)
			local toolFrame = Bar:FindFirstChild(index)

			if toolFrame then
				toolFrame:Destroy()
			end

			Dropped:Fire(tool)
			table.remove(items, index)
			checkHotbar(index)
		end
	end

	coroutine.wrap(function()
		while true do
			local success, err = pcall(function()
				StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false)
			end)
			if success then
				break
			end

			task.wait()
		end

		if maxBar > 10 then
			maxBar = 10
		end

		Template.Visible = true
		Template.Parent = nil

		for _, tool in pairs(Backpack:GetChildren()) do
			updateAdd(tool)
		end

		Backpack.ChildAdded:Connect(updateAdd)
		Backpack.ChildRemoved:Connect(updateRemove)
		Character.ChildAdded:Connect(updateAdd)
		Character.ChildRemoved:Connect(updateRemove)
		UserInputService.InputBegan:Connect(function(input, gameProcessed)
			if gameProcessed then
				return
			end

			if Keys[input.KeyCode.Name] then
				local index = Keys[input.KeyCode.Name]

				if items[index] then
					handleEquip(items[index])
				end
			end
		end)
	end)()
end

function Hotbar.new(Bar:Frame?,Template:TextButton?)
	local errorMessage = (Bar and "Argument 2 missing or nil.") or (Template and "Argument 1 missing or nil.") or ("Argument 1, and 2 missing or nil.")
	assert(Bar and Template,errorMessage)

	local run = game:GetService("RunService")
	if run:IsClient() then
		local events = {
			equipped = Instance.new("BindableEvent");
			unequipped = Instance.new("BindableEvent");
			dropped = Instance.new("BindableEvent");
		}

		local self = setmetatable({
			Equipped = events.equipped.Event;
			Unequipped = events.unequipped.Event;
			Dropped = events.dropped.Event;
		},Hotbar)

		local allow = (table.find(AllowedTypes,Bar.ClassName) and table.find(AllowedTypes,Template.ClassName))
		assert(allow, "Invalid class type:"..Template.ClassName)

		setup(Bar,Template,events.equipped,events.unequipped,events.dropped)
		return self
	else
		warn("Hotbar/Toolbar only works for client, please use a local script instead of a server script.")
		return
	end
end

return Hotbar


Prompt: -- Create base segway to clone from

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

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

Functions.PlaySound = function(Sound,Pitch,Volume)
	if Sound then
		Sound.Pitch = Pitch
		Sound.Volume = Volume
		Sound:Play()
	end
end

Functions.StopSound = function(Sound,Volume)
	if Sound then
		Sound.Volume = Volume
		Sound:Stop()
	end
end

Functions.ChangeSound = function(Sound,Pitch,Volume,ShouldPitch,ShouldVolume)
	if Sound then
		if ShouldPitch == true then
		Sound.Pitch = Pitch
		end
			if ShouldVolume == true then
			Sound.Volume = Volume
			end
	end
end

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

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

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

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

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

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

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

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

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

Functions.DestroySegway = function(Character,SpawnedSegway)
	if SpawnedSegway.Value ~= nil then
		SpawnedSegway.Value:Destroy()
		SpawnedSegway.Value = nil
	end
end

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

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

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

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

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

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

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

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

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

return Functions