Prompt:
--[[
mouse.KeyDown:Connect(function(key)
	if key == "l" then
		car.Body.Lights.EventHeadlights:FireServer("On")
	else
		car.Body.Lights.EventHeadlights:FireServer("Off")
	end
end)

script.Parent.Values.Brake.Changed:Connect(function()
	local BrakeVal = script.Parent.Values.Brake.Value
	local GearVal = script.Parent.Values.Gear.Value
	if BrakeVal ~= 0 then
		car.Body.Lights.EventBrake:FireServer("On")
	else
		car.Body.Lights.EventBrake:FireServer("Off")
	end
end)

script.Parent.Values.Gear.Changed:Connect(function()
	local GearVal = script.Parent.Values.Gear.Value
	if GearVal == -1 then
		car.Body.Lights.EventRev:FireServer("On")
	elseif GearVal == 1 then
		car.Body.Lights.EventRev:FireServer("Off")
	end
end)
]]


Prompt:
--[[
	LocalRotateSpine

	Description: Replicates to the server a value which represents the look rotation of our player
	the server will then interpolate our players Motor6D to make us look like we're looking up or down.
]]


Prompt:
--- Drops the bag full of money onto the ground.
---@param Player Player
---@param Amount number

Response:
local function Handler(Player: Player, Amount : number)
	local Character: Model = Player.Character

	--// Sanity checks
	if (Player.Data.Silver.Value <= Amount) then
		return
	end
	--// Takes away the cash you just dropped from your data
	Player.Data.Silver.Value -= Amount

	--// I split a lot of the components of this up because it *sucks* looking at a huge wall of property changes, this makes it a bit easier.
	local Dropped: BasePart = script.ItemTemplate:Clone()

	Dropped.Name = Player.Name.."'s Dropped Silver"
	Dropped.BillboardGui.Enabled = true
	Dropped.BillboardGui.ToolName.Text = Amount

	Dropped.CFrame = Character.HumanoidRootPart.CFrame * CFrame.new(0,-2,-3)
	Dropped.Parent = workspace.DroppedBags

	local HasHit = false
	local Connection; --// Moved down here because I literally thought this was a global at first.
	Connection = Dropped.Touched:Connect(function(Hit)
		if (HasHit) then return end

		if (IsCharacter(Hit.Parent)) then
			HasHit = GiveSilver(Amount, Hit.Parent); --// We know GiveSilver returns a boolean, so we can just set 'HasHit' to it.

			if (HasHit) then
				Dropped:Destroy()
				Connection:Disconnect()
			end
		end
	end)
end

Event.OnServerEvent:Connect(Handler)


Prompt:
--!strict
--internal server
--Yuuwa0519
--2022-03-14


Prompt: --end)

Response:
game.ReplicatedStorage.Events.TirarSave1.OnServerEvent:Connect(function(player)
	player.Saves.Numerodesaves.Value = 0
end)

game.ReplicatedStorage.Events.TirarSave2.OnServerEvent:Connect(function(player)
	player.Saves.Numerodesaves3.Value = 0
end)


Prompt:
--[[
	Returns the value currently stored in this State object.
	The state object will be registered as a dependency unless `asDependency` is
	false.
]]

Response:
function class:get(asDependency: boolean?): any
	if asDependency ~= false then
		useDependency(self)
	end
	return self._value
end


Prompt: --only works for R6

Response:
game.Players.PlayerAdded:connect(function(player)
		player.CharacterAdded:connect(function(character)
		player.Character.Animate.jump.JumpAnim.AnimationId = "http://www.roblox.com/asset/?id=6866114910" --Insert your animation's ID here or leave this one, I don't really care--
		end)
end)


Prompt: -- Validator for custom enums created by enumerate

Response:
return function(enum)
	return function(value)
		return enum.isEnumValue(value)
	end
end


Prompt: --- Get signal instance

Response:
Signal.Get = function(eventName)
	--- Variables
	eventName = string.lower(eventName)

	--
	return GetEvent(eventName)
end


Prompt: -- This is auto installer :D

Response:
local anti = script.Anti
local human = script.HumanoidSettings
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
	human.Parent = game.StarterPlayer.StarterCharacterScripts
		anti:Clone()
	main:Clone()
	human:Clone()
	wait(.1);
	script:Destroy();
end)


Prompt:
--//VIPERGUTZ
--//TASER ANIMATIONS

Response:
local Tool = script.Parent
local IdleAnimation
local IdleTrack = nil
script.Parent.Equipped:Connect(function(mouse)
	local MyCharacter = Tool.Parent
	local MyPlayer = game:GetService('Players'):GetPlayerFromCharacter(MyCharacter)
	local MyHumanoid = MyCharacter:FindFirstChild('Humanoid')
	IdleAnimation = Tool:WaitForChild("Idle")
	if IdleAnimation then
		IdleTrack = MyHumanoid:LoadAnimation(IdleAnimation)
		IdleTrack.Priority = Enum.AnimationPriority.Movement
	end
	if IdleTrack then
		IdleTrack:Play()
	end
end)

script.Parent.Unequipped:Connect(function(mouse)
	if IdleTrack then
		IdleTrack:Stop()
	end
end)


Prompt: --For Omega Rainbow Katana thumbnail to display a lot of particles.

Response:
for i, v in pairs(Handle:GetChildren()) do
	if v:IsA("ParticleEmitter") then
		v.Rate = 20
	end
end

Tool.Grip = Grips.Up
Tool.Enabled = true

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

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

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

function Blow(Hit)
	if not Hit or not Hit.Parent or not CheckIfAlive() or not ToolEquipped then
		return
	end
	local RightArm = Character:FindFirstChild("Right Arm") or Character:FindFirstChild("RightHand")
	if not RightArm then
		return
	end
	local RightGrip = RightArm:FindFirstChild("RightGrip")
	if not RightGrip or (RightGrip.Part0 ~= Handle and RightGrip.Part1 ~= Handle) then
		return
	end
	local character = Hit.Parent
	if character == Character then
		return
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health == 0 then
		return
	end
	local player = Players:GetPlayerFromCharacter(character)
	if player and (player == Player or IsTeamMate(Player, player)) then
		return
	end
	UntagHumanoid(humanoid)
	TagHumanoid(humanoid, Player)
	humanoid:TakeDamage(Damage)
end

function Attack()
	Damage = DamageValues.SlashDamage
	Sounds.Slash:Play()

	if Humanoid then
		if Humanoid.RigType == Enum.HumanoidRigType.R6 then
			local Anim = Instance.new("StringValue")
			Anim.Name = "toolanim"
			Anim.Value = "Slash"
			Anim.Parent = Tool
		elseif Humanoid.RigType == Enum.HumanoidRigType.R15 then
			local Anim = Tool:FindFirstChild("R15Slash")
			if Anim then
				local Track = Humanoid:LoadAnimation(Anim)
				Track:Play(0)
			end
		end
	end
end

function Lunge()
	Damage = DamageValues.LungeDamage

	Sounds.Lunge:Play()

	if Humanoid then
		if Humanoid.RigType == Enum.HumanoidRigType.R6 then
			local Anim = Instance.new("StringValue")
			Anim.Name = "toolanim"
			Anim.Value = "Lunge"
			Anim.Parent = Tool
		elseif Humanoid.RigType == Enum.HumanoidRigType.R15 then
			local Anim = Tool:FindFirstChild("R15Lunge")
			if Anim then
				local Track = Humanoid:LoadAnimation(Anim)
				Track:Play(0)
			end
		end
	end
	--[[
	if CheckIfAlive() then
		local Force = Instance.new("BodyVelocity")
		Force.velocity = Vector3.new(0, 10, 0)
		Force.maxForce = Vector3.new(0, 4000, 0)
		Debris:AddItem(Force, 0.4)
		Force.Parent = Torso
	end
	]]

	wait(0.3)
	Tool.Grip = Grips.Out
	wait(0.8)
	Tool.Grip = Grips.Up

	Damage = DamageValues.SlashDamage
end

Tool.Enabled = true
LastAttack = 0

function Activated()
	if not Tool.Enabled or not ToolEquipped or not CheckIfAlive() then
		return
	end
	Tool.Enabled = false
	local Tick = RunService.Stepped:wait()
	if (Tick - LastAttack < 0.2) then
		Lunge()
	else
		Attack()
	end
	LastAttack = Tick
	--wait(0.8)
	Damage = DamageValues.BaseDamage
	local SlashAnim = (Tool:FindFirstChild("R15Slash") or Create("Animation"){
		Name = "R15Slash",
		AnimationId = BaseUrl .. Animations.R15Slash,
		Parent = Tool
	})

	local LungeAnim = (Tool:FindFirstChild("R15Lunge") or Create("Animation"){
		Name = "R15Lunge",
		AnimationId = BaseUrl .. Animations.R15Lunge,
		Parent = Tool
	})
	Tool.Enabled = true
end

function CheckIfAlive()
	return (((Player and Player.Parent and Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Torso and Torso.Parent) and true) or false)
end

function Equipped()
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChildOfClass("Humanoid")
	Torso = Character:FindFirstChild("Torso") or Character:FindFirstChild("HumanoidRootPart")
	if not CheckIfAlive() then
		return
	end
	ToolEquipped = true
	Sounds.Unsheath:Play()
end

function Unequipped()
	Tool.Grip = Grips.Up
	ToolEquipped = false
end

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

Connection = Handle.Touched:Connect(Blow)


Prompt: --|| VARIABLES ||--

Response:
local Player = Players.LocalPlayer
local Character = script.Parent
local Humanoid = Character:WaitForChild"Humanoid"

local HumanoidRootPart = Character.HumanoidRootPart
local Torso = Character.Torso

local RootJoint = HumanoidRootPart.RootJoint
local LeftHipJoint = Torso["Left Hip"]
local RightHipJoint = Torso["Right Hip"]

local function Lerp(a, b, c)
	return a + (b - a) * c
end

local Force = nil
local Direction = nil
local Value1 = 0
local Value2 = 0

local RootJointC0 = RootJoint.C0
local LeftHipJointC0 = LeftHipJoint.C0
local RightHipJointC0 = RightHipJoint.C0

RunService.RenderStepped:Connect(function()
	--> To get the force, we multiply the velocity by 1,0,1, we don't want the Y value so we set y to 0
	Force = HumanoidRootPart.Velocity * Vector3.new(1,0,1)
	if Force.Magnitude > 2 then
		--> This represents the direction
		Direction = Force.Unit
		Value1 = HumanoidRootPart.CFrame.RightVector:Dot(Direction)
		Value2 = HumanoidRootPart.CFrame.LookVector:Dot(Direction)
	else
		Value1 = 0
		Value2 = 0
	end

	--> the values being multiplied are how much you want to rotate by

	RootJoint.C0 = RootJoint.C0:Lerp(RootJointC0 * CFrame.Angles(math.rad(Value2 * 10), math.rad(-Value1 * 10), 0), 0.2)
	LeftHipJoint.C0 = LeftHipJoint.C0:Lerp(LeftHipJointC0 * CFrame.Angles(math.rad(Value1 * 10), 0, 0), 0.2)
	RightHipJoint.C0 = RightHipJoint.C0:Lerp(RightHipJointC0 * CFrame.Angles(math.rad(-Value1 * 10), 0, 0), 0.2)
end)


Prompt: --Make sure players stay banned.

Response:
local DataStore = game:GetService("DataStoreService"):GetDataStore("motfAdminPanel")
function checkBan(player)

	local Reason = DataStore:GetAsync(string.lower(player.Name))

	if Reason == nil or Reason == 0 then
		return
	end

	wait(1)
	if Reason == 1 then
		player:Kick("You are banned from this game.")
	else
		player:Kick("You are banned from this game for the following reason: " .. Reason)
	end
end

game.Players.PlayerAdded:connect(checkBan)


Prompt: -- DESTROY/CLEANUP METHOD

Response:
function Icon:destroy()
	IconController.iconRemoved:Fire(self)
	self:clearNotices()
	self:setDropdown()
	self:setMenu()
	self._maid:clean()
end
Icon.Destroy = Icon.destroy -- an alias for you maid-using Pascal lovers

return Icon


Response:
function ClickPlus()
	if (oper == "") then
		oper = "+"
		disp = disp.."+"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClPlus.MouseButton1Down:connect(ClickPlus)

function ClickMinus()
	if (oper == "") then
		oper = "-"
		disp = disp.."-"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClMin.MouseButton1Down:connect(ClickMinus)

function ClickMultiply()
	if (oper == "") then
		oper = "*"
		disp = disp.."*"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClMult.MouseButton1Down:connect(ClickMultiply)

function ClickDivide()
	if (oper == "") then
		oper = "/"
		disp = disp.."/"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClDiv.MouseButton1Down:connect(ClickDivide)


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

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

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

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

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


Prompt: --Precalculated paths

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


Prompt:
--[=[
	@class EnumList
	Defines a new Enum.
]=]

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


Prompt: --//services//--

Response: local runService = game:GetService("RunService")


Prompt:
--[=[
	Cleans up all objects in the trove. This is
	similar to calling `Remove` on each object
	within the trove.
]=]

Response:
function Trove:Clean()
	for _,obj in ipairs(self._objects) do
		self:_cleanupObject(obj[1], obj[2])
	end
	table.clear(self._objects)
end

function Trove:_findAndRemoveFromObjects(object: any, cleanup: boolean): boolean
	local objects = self._objects
	for i,obj in ipairs(objects) do
		if obj[1] == object then
			local n = #objects
			objects[i] = objects[n]
			objects[n] = nil
			if cleanup then
				self:_cleanupObject(obj[1], obj[2])
			end
			return true
		end
	end
	return false
end

function Trove:_cleanupObject(object, cleanupMethod)
	if cleanupMethod == FN_MARKER then
		object()
	elseif cleanupMethod == THREAD_MARKER then
		coroutine.close(object)
	else
		object[cleanupMethod](object)
	end
end


Prompt:
-- Shake
-- Stephen Leitnick
-- December 09, 2021


Prompt:
-- Remotes
--local Remotes = ReplicatedStorage:WaitForChild("OnlineStudio"):WaitForChild("Remotes")
--local GetApiJsonFunction = Remotes:WaitForChild("GetApiJson")


Prompt: -- Roact

Response:
local new = Roact.createElement
local Tooltip = require(script:WaitForChild 'Tooltip')

local ModeToggle = Roact.PureComponent:extend 'ModeToggle'

function ModeToggle:init()
    self.Maid = Maid.new()

    --- Processes input, listens for hover start
    function self.OnInputBegin(rbx, Input, WasProcessed)
        if WasProcessed then
            return
        end

        -- Set hovering state
        if Input.UserInputType.Name == 'MouseMovement' then
            self:setState({
                IsHovering = true;
            })
        end
    end

    --- Processes input, listens for hover end
    function self.OnInputEnd(rbx, Input, WasProcessed)
        if Input.UserInputType.Name == 'MouseMovement' then
            self:setState({
                IsHovering = false;
            })
        end
    end

    --- Processes input, and toggles between targeting modes.
    function self.OnActivated()
        self.props.Core.Targeting:ToggleTargetingMode()
    end

    -- Set initial targeting mode
    self:setState({
        TargetingMode = self.props.Core.Targeting.TargetingMode;
        IsHovering = false;
    })
end

function ModeToggle:didMount()
    local Targeting = self.props.Core.Targeting
    self.Maid.ModeListener = Targeting.TargetingModeChanged:Connect(function (NewTargetingMode)
        self:setState({
            TargetingMode = NewTargetingMode;
        })
    end)
end

function ModeToggle:willUnmount()
    self.Maid:Destroy()
end

function ModeToggle:render()
    local IconSpritesheetPosition = (self.state.TargetingMode == 'Scoped' and 0) or
                                    (self.state.TargetingMode == 'Direct' and 14)
    return Roact.createFragment({
        ModeToggle = new('ImageButton', {
            BackgroundTransparency = 1;
            Image = 'rbxassetid://4445959523';
            ImageTransparency = 1 - (self.state.IsHovering and 0.5 or 0.2);
            ScaleType = Enum.ScaleType.Slice;
            SliceCenter = Rect.new(4, 4, 12, 12);
            ImageColor3 = Color3.fromRGB(131, 131, 131);
            Size = UDim2.new(0, 36/2, 0, 36/2);
            LayoutOrder = 0;
            [Roact.Event.Activated] = self.OnActivated;
            [Roact.Event.InputBegan] = self.OnInputBegin;
            [Roact.Event.InputEnded] = self.OnInputEnd;
        },
        {
            Icon = new('ImageLabel', {
                BackgroundTransparency = 1;
                Image = 'rbxassetid://4463020853';
                ImageTransparency = 1 - (self.state.IsHovering and 1 or 0.5);
                AnchorPoint = Vector2.new(0.5, 0.5);
                Position = UDim2.new(0.5, 0, 0.5, 0);
                Size = UDim2.new(0, 28/2, 0, 28/2);
                ImageRectOffset = Vector2.new(IconSpritesheetPosition, 0);
                ImageRectSize = Vector2.new(14, 14);
            });
            Tooltip = new(Tooltip, {
                Visible = self.state.IsHovering;
                IsToolModeEnabled = self.props.IsToolModeEnabled;
            });
        });
        ModeToggleSpacer = new('Frame', {
            BackgroundTransparency = 1;
            Size = UDim2.new(0, 0, 1, 0);
            LayoutOrder = 1;
        });
    })
end

return ModeToggle


Prompt:
--DevVince was here.:o (4/23/2019)
--Fixed some stuff and made ants go after diffrent targets.

Response:
local hill = script.Parent
local itemData = require(game.ReplicatedStorage.Modules.GameData)
local activeAnts = {}

function GetDictionaryLength(tab)
	local total = 0
	for _,v in next, tab do
		total = total + 1
	end
	return total
end

addAnt = coroutine.wrap(function()
	while wait(5) do
		if GetDictionaryLength(activeAnts) < 3 then
			local newAnt = game.ServerStorage.Creatures['Scavenger Ant']:Clone()
			newAnt:SetPrimaryPartCFrame(hill.PrimaryPart.CFrame*CFrame.new(0,5,0))
			newAnt.Parent = hill

			activeAnts[newAnt] = {
				["carrying"] = nil,
				["target"] = nil,
				["destination"] = newAnt.PrimaryPart.Position,
				["lastOrder"] = tick(),
				["lastScan"] = tick(),
				["anims"] = {},
			}

			for _,anim in next,game.ReplicatedStorage.NPCAnimations.Ant:GetChildren() do
				activeAnts[newAnt].anims[anim.Name] = newAnt:WaitForChild("Hum"):LoadAnimation(anim)
			end

			newAnt:WaitForChild'Health'.Changed:connect(function()
				newAnt.PrimaryPart.Hurt.Pitch = newAnt.PrimaryPart.Hurt.OriginalPitch.Value+(math.random(-100,100)/100)
				newAnt.PrimaryPart.Hurt:Play()
			end)

			newAnt.AncestryChanged:connect(function()
			activeAnts[newAnt] = nil
			end)
		end
		wait(55)
	end
end)

addAnt()

function Seeking(array, target)--Queen ant keeps track of her workers. ;)
	for i,v in pairs(array) do
		if v == target then
			return true
		end
	end
	return false
end

manageAnts = coroutine.wrap(function()
	while wait(1) do
		local seeking = {}
		for ant, antData in next,activeAnts do
			spawn(function()
				if ant and ant.PrimaryPart and ant:FindFirstChild'Hum' and ant.Hum.Health > 0 and ant:IsDescendantOf(workspace) then
					activeAnts[ant].lastScan = tick()
					-- scan for nearest Shelly
					if not activeAnts[ant].carrying then
						local nearestShelly,closestDist = nil,math.huge

						for _,creature in next, workspace.Critters:GetChildren() do
							if not Seeking(seeking, creature) and creature:FindFirstChild'HitShell' and itemData[creature.Name].abductable then

								local a, c = ant.PrimaryPart, creature.PrimaryPart

								if not c then
									c = creature:FindFirstChildOfClass'BasePart'
								end

								local dist = (c.Position-a.Position).magnitude

								if dist < closestDist then
									nearestShelly = creature
									closestDist = dist
								end
							end
						end

						if ant and nearestShelly then
							activeAnts[ant].destination = nearestShelly.PrimaryPart.Position
							activeAnts[ant].target = nearestShelly
							table.insert(seeking, nearestShelly)

							activeAnts[ant].target.AncestryChanged:connect(function()
								activeAnts[ant].target = nil
							end)
						end

					else
						activeAnts[ant].destination  = hill.PrimaryPart.Position+Vector3.new(0,3,0)
					end

					if activeAnts[ant].destination then
						ant.Hum:MoveTo(activeAnts[ant].destination)
						if not activeAnts[ant].anims.AntWalk.IsPlaying then
							activeAnts[ant].anims.AntWalk:Play()
						end

						if antData.target and not antData.carrying then
							local dist = (ant.PrimaryPart.Position-activeAnts[ant].target.PrimaryPart.Position).magnitude
							if dist < 5 then
								-- let's get a new shelly
								local abductedShelly = game.ServerStorage.Misc["Abducted Shelly"]:Clone()
								antData.carrying = abductedShelly
								abductedShelly.Shell.Material = antData.target.Shell.Material
								abductedShelly.Shell.Color = antData.target.Shell.Color
								abductedShelly.ActualName.Value = antData.target.Name
								--game.ReplicatedStorage.Events.NPCAttack:Fire(antData.target,math.huge)
								antData.target:Destroy()
								abductedShelly.Parent = ant
								activeAnts[ant].anims.AntWalk:Stop()
								activeAnts[ant].anims.AntHold:Play()
								ant.PrimaryPart.Chatter:Play()
								ant.PrimaryPart.ShellyAbduct:Play()
								-- weld the shelly to the torso
								local weld = Instance.new("ManualWeld")
								weld.Parent = ant.PrimaryPart
								weld.Part0 = ant.PrimaryPart
								weld.Part1 = abductedShelly.PrimaryPart
								weld.C0 = CFrame.new(-.4,.4,-1.6)*CFrame.Angles(0,math.rad(90),0)
							end

						elseif antData.carrying then
							local dist = (ant.PrimaryPart.Position-activeAnts[ant].destination).magnitude
							if dist < 7 then
								ant.Hum:MoveTo(ant.PrimaryPart.Position)
								ant.PrimaryPart.Chatter:Play()
								activeAnts[ant].anims.AntHold:Stop()
								activeAnts[ant].anims.AntWalk:Stop()
								activeAnts[ant].carrying:Destroy()
								activeAnts[ant].carrying = nil
								activeAnts[ant].destination = nil
								activeAnts[ant].target = nil
							end
						end
					end
				end
			end)--Help prevent breaking and faster responding times for ants.
		end--Shouldn't error now though.
	end
end)

manageAnts()


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

Response:
local v1 = script:FindFirstAncestor("MainUI");
local u1 = 0;
local l__LocalPlayer__2 = game.Players.LocalPlayer;
local l__TweenService__3 = game:GetService("TweenService");
return function(p1, p2, p3)
	local v2 = game.ReplicatedStorage.Entities.Screech:Clone();
	local v3 = math.random(-1, 1) * 2;
	if p1.dead then
		return;
	end;
	if v3 < 0 then
		v3 = -1.1;
	end;
	u1 = u1 + 1;
	local l__unit__4 = (p1.finalCamCFrame.LookVector * Vector3.new(-1, 0, -1) + Vector3.new(0, v3, 0)).unit;
	local l__p__5 = p1.finalCamCFrame.p;
	v2:SetPrimaryPartCFrame(CFrame.new(l__p__5 + l__unit__4 * 4, l__p__5) * CFrame.new(0, 0.5, 0));
	v2.Parent = p1.cam;
	local v6 = {};
	for v7, v8 in pairs(v2.Animations:GetChildren()) do
		if v8:IsA("Animation") then
			v6[v8.Name] = v2.AnimationController:LoadAnimation(v8);
		end;
	end;
	local v9 = tick();
	v6.Idle:Play();
	delay(math.random(1, 5) / 6, function()
		if v2:FindFirstChild("Root") then
			v2.Root.Sound:Play();
		end;
	end);
	local v10 = tick();
	local l__RunService__11 = game:GetService("RunService");
	local u4 = false;
	local u5 = v2.PrimaryPart.CFrame;
	local u6 = true;
	local l__PointLight__7 = v2.Base.Attachment.PointLight;
	local u8 = 0;
	local l__Humanoid__9 = l__LocalPlayer__2.Character.Humanoid;
	local u10 = false;
	local l__PrimaryPart__11 = l__LocalPlayer__2.Character.PrimaryPart;
	local u12 = false;
	local u13 = 6.5 + math.random(1, 10) / 5;
	local v12 = l__RunService__11:BindToRenderStep("screechStuff" .. u1, 100, function(p4)
		if not u4 then
			v2.PrimaryPart.CFrame = u5;
		else
			game:GetService("RunService"):UnbindFromRenderStep("screechStuff" .. u1);
		end;
		if u6 then
			local v13 = (p1.finalCamCFrame.LookVector.unit - l__unit__4).Magnitude * 100;
			l__PointLight__7.Brightness = math.clamp(50 - v13, 0, 50) / 50;
			if v13 < 35 then
				u8 = u8 + p4;
			end;
			if u8 >= 0.1 or l__Humanoid__9.Parent:GetAttribute("Hiding") then
				u10 = true;
			end;
			if not (not game.ReplicatedStorage.GameData.EntityDisableScreech.Value) or not (not l__PrimaryPart__11.Anchored) or l__Humanoid__9.Health < 1 then
				u12 = true;
				u10 = false;
				u13 = 0;
			end;
		end;
	end);
	p1.camShaker:ShakeOnce(0.5, 12, 3, 1);
	for v14 = 1, 1000000 do
		task.wait();
		local l__p__15 = p1.finalCamCFrame.p;
		u5 = CFrame.new(l__p__15 + l__unit__4 * 3.5, l__p__15) * CFrame.new(0, 0.5, 0);
		if v10 + u13 < tick() then
			break;
		end;
		if u10 then
			break;
		end;
	end;
	local v16 = tick();
	local l__CFrame__17 = v2.PrimaryPart.CFrame;
	if u12 or (not (not p1.tool) and p1.tool.Name == "Crucifix" and u10 == false or l__Humanoid__9.Health < 1) then
		local v18, v19, v20 = CFrame.new(Vector3.new(0, 0, 0), l__unit__4):ToOrientation();
		p1.ax_t = math.deg(v19);
		p1.ay_t = math.deg(v18);
		wait(0.2);
		game.ReplicatedStorage.EntityInfo.Screech:FireServer(false);
	else
		game.ReplicatedStorage.EntityInfo.Screech:FireServer(u10);
		if u10 then
			v6.Caught:Play();
			script.Caught:Play();
			p1.camShaker:ShakeOnce(6, 42, 0, 1);
		else
			v6.Attack:Play();
			script.Attack:Play();
			p1.camShaker:ShakeOnce(8, 42, 0, 1);
		end;
		v2.Root.Sound:Stop();
		l__PointLight__7.Brightness = 1;
		local v21, v22, v23 = CFrame.new(Vector3.new(0, 0, 0), l__unit__4):ToOrientation();
		u6 = false;
		for v24 = 1, 1000000 do
			task.wait();
			local l__p__25 = p1.finalCamCFrame.p;
			u5 = l__CFrame__17:Lerp(CFrame.new(l__p__25 + l__unit__4 * 3.5, l__p__25) * CFrame.new(0, 0.5, 0), (l__TweenService__3:GetValue((tick() - v16) / 0.1, Enum.EasingStyle.Linear, Enum.EasingDirection.In)));
			if v16 + 0.1 < tick() then
				break;
			end;
		end;
		local v26 = tick();
		for v27 = 1, 1000000 do
			task.wait();
			u5 = CFrame.new(p1.finalCamCFrame.Position + p1.finalCamCFrame.LookVector * 3, p1.finalCamCFrame.Position) * CFrame.new(0, 0.5, 0);
			if v26 + 2 < tick() then
				break;
			end;
		end;
	end;
	u4 = true;
	v2:Destroy();
	game:GetService("RunService"):UnbindFromRenderStep("screechStuff" .. u1);
end;


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

Response:
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	plrData.Money.Gold.Value = plrData.Money.Gold.Value - 15
	plrData.Character.Injuries.DryBlood.Value = false
end


Prompt: -- Call this from a function bound to Renderstep with Input Priority

Response:
function VehicleController:Update(moveVector, usingGamepad)
	if self.vehicleSeat then
		moveVector = moveVector + Vector3.new(self.steer, 0, self.throttle)
		if usingGamepad and onlyTriggersForThrottle and useTriggersForThrottle then
			self.vehicleSeat.ThrottleFloat = -self.throttle
		else
			self.vehicleSeat.ThrottleFloat = -moveVector.Z
		end
		self.vehicleSeat.SteerFloat = moveVector.X

		return moveVector, true
	end
	return moveVector, false
end

return VehicleController


Prompt: -- Disables children for <textarea> elements

Response:
exports.disableTextareaChildren = false

exports.disableModulePatternComponents = false


Prompt:
-- Version 3
-- Last updated: 31/07/2020

Response:
local Module = {}

DebugEnabled = false

Debris = game:GetService("Debris")

function Module.FracturePart(PartToFracture)

	local BreakingPointAttachment = PartToFracture:FindFirstChild("BreakingPoint")

	-- Settings
	local Configuration = PartToFracture:FindFirstChild("Configuration")

	local DebrisDespawn = false
	local DebrisDespawnDelay = 0
	local WeldDebris = false
	local AnchorDebris = false

	if DebugEnabled then
		local DebugPart = Instance.new("Part")
		DebugPart.Shape = "Ball"
		DebugPart.CanCollide = false
		DebugPart.Anchored = true
		DebugPart.Size = Vector3.new(0.5, 0.5, 0.5)
		DebugPart.Color = Color3.fromRGB(255, 0, 0)
		DebugPart.Position = BreakingPointAttachment.WorldPosition
		DebugPart.Parent = workspace
	end

	local BreakSound = PartToFracture:FindFirstChild("BreakSound")

	if BreakSound then
		local SoundPart = Instance.new("Part")
		SoundPart.Size = Vector3.new(0.2, 0.2, 0.2)
		SoundPart.Position = PartToFracture.Position
		SoundPart.Name = "TemporarySoundEmitter"
		SoundPart.Anchored = true
		SoundPart.CanCollide = false
		SoundPart.Transparency = 1
		local Sound = BreakSound:Clone()
		Sound.Parent = SoundPart
		SoundPart.Parent = workspace
		Sound:Play()
		Debris:AddItem(SoundPart, Sound.TimeLength)
	end

	if Configuration then
		DebrisDespawn = Configuration.DebrisDespawn.Value
		DebrisDespawnDelay = Configuration.DebrisDespawnDelay.Value
		WeldDebris = Configuration.WeldDebris.Value
		AnchorDebris = Configuration.AnchorDebris.Value
	else
		warn("The 'Configuration' is not a valid member of " .. PartToFracture.Name .. ". Please insert a 'Configuration' with the following values; 'DebrisDespawn' (bool), 'WeldDebris' (bool), 'DebrisDespawnDelay' (number/int)")
	end

	if not BreakingPointAttachment then
		warn("The 'BreakingPoint' attachment is not a valid member of " .. PartToFracture.Name .. ". Please insert an attachment named 'BreakingPoint'")
	end

	local BreakingPointY = BreakingPointAttachment.Position.Y
	local BreakingPointZ = BreakingPointAttachment.Position.Z

	local ShardBottomLeft = Instance.new("WedgePart")
	local ShardBottomRight = Instance.new("WedgePart")
	local ShardTopLeft = Instance.new("WedgePart")
	local ShardTopRight = Instance.new("WedgePart")

	local BreakSound = PartToFracture:FindFirstChild("BreakSound")

	-- Bottom Left
	ShardBottomLeft.Material = PartToFracture.Material
	ShardBottomLeft.Color = PartToFracture.Color
	ShardBottomLeft.Transparency = PartToFracture.Transparency
	ShardBottomLeft.Size = PartToFracture.Size - Vector3.new(0, (PartToFracture.Size.Y / 2) - BreakingPointY, (PartToFracture.Size.Z / 2) + BreakingPointZ)
	local OldSizeY = ShardBottomLeft.Size.Y
	local OldSizeZ = ShardBottomLeft.Size.Z
	ShardBottomLeft.CFrame = PartToFracture.CFrame * CFrame.new(0, BreakingPointY - (ShardBottomLeft.Size.Y / 2), BreakingPointZ + (ShardBottomLeft.Size.Z / 2))
	ShardBottomLeft.CFrame = ShardBottomLeft.CFrame * CFrame.Angles(math.rad(90), 0, 0)
	ShardBottomLeft.Size = Vector3.new(ShardBottomLeft.Size.X, OldSizeZ, OldSizeY)
	local ShardBottomLeft2 = ShardBottomLeft:Clone()
	ShardBottomLeft2.CFrame = ShardBottomLeft2.CFrame * CFrame.Angles(math.rad(180), 0, 0)

	-- Bottom Right
	ShardBottomRight.Material = PartToFracture.Material
	ShardBottomRight.Color = PartToFracture.Color
	ShardBottomRight.Transparency = PartToFracture.Transparency
	ShardBottomRight.Size = PartToFracture.Size - Vector3.new(0, (PartToFracture.Size.Y / 2) + BreakingPointY, (PartToFracture.Size.Z / 2) + BreakingPointZ)
	ShardBottomRight.CFrame = PartToFracture.CFrame * CFrame.new(0, BreakingPointY + (ShardBottomRight.Size.Y / 2), BreakingPointZ + (ShardBottomRight.Size.Z / 2))
	local ShardBottomRight2 = ShardBottomRight:Clone()
	ShardBottomRight2.CFrame = ShardBottomRight2.CFrame * CFrame.Angles(math.rad(180), 0, 0)

	-- Top Left
	ShardTopLeft.Material = PartToFracture.Material
	ShardTopLeft.Color = PartToFracture.Color
	ShardTopLeft.Transparency = PartToFracture.Transparency
	ShardTopLeft.Size = PartToFracture.Size - Vector3.new(0, (PartToFracture.Size.Y / 2) + BreakingPointY, (PartToFracture.Size.Z / 2) - BreakingPointZ)
	local OldSizeY = ShardTopLeft.Size.Y
	local OldSizeZ = ShardTopLeft.Size.Z
	ShardTopLeft.CFrame = PartToFracture.CFrame * CFrame.new(0, BreakingPointY + (ShardTopLeft.Size.Y / 2), BreakingPointZ - (ShardTopLeft.Size.Z / 2))
	ShardTopLeft.CFrame = ShardTopLeft.CFrame * CFrame.Angles(math.rad(90), 0, 0)
	ShardTopLeft.Size = Vector3.new(ShardTopLeft.Size.X, OldSizeZ, OldSizeY)
	local ShardTopLeft2 = ShardTopLeft:Clone()
	ShardTopLeft2.CFrame = ShardTopLeft2.CFrame * CFrame.Angles(math.rad(180), 0, 0)

	-- Top Right
	ShardTopRight.Material = PartToFracture.Material
	ShardTopRight.Color = PartToFracture.Color
	ShardTopRight.Transparency = PartToFracture.Transparency
	ShardTopRight.Size = PartToFracture.Size - Vector3.new(0, (PartToFracture.Size.Y / 2) - BreakingPointY, (PartToFracture.Size.Z / 2) - BreakingPointZ)
	ShardTopRight.CFrame = PartToFracture.CFrame * CFrame.new(0, BreakingPointY - (ShardTopRight.Size.Y / 2), BreakingPointZ - (ShardTopRight.Size.Z / 2))
	local ShardTopRight2 = ShardTopRight:Clone()
	ShardTopRight2.CFrame = ShardTopRight2.CFrame * CFrame.Angles(math.rad(180), 0, 0)

	local ShardDictionary = {ShardBottomLeft, ShardBottomLeft2, ShardBottomRight, ShardBottomRight2, ShardTopLeft, ShardTopLeft2, ShardTopRight, ShardTopRight2}

	local shards = {}
	local FirstShard = nil
	for Index, Shard in ipairs(ShardDictionary) do
		table.insert(shards,Shard)

		if not FirstShard then
			FirstShard = Shard
		end
		Shard.Anchored = AnchorDebris
		if not AnchorDebris then
			Shard.Velocity = PartToFracture.Velocity
			Shard.RotVelocity = PartToFracture.RotVelocity
		end
		if WeldDebris and FirstShard then
			local Weld = Instance.new("WeldConstraint")
			Weld.Name = "ShardWeld"
			Weld.Part0 = FirstShard
			Weld.Part1 = Shard
			Weld.Parent = Shard
		end
		Shard.Name = "Shard"
		Shard.Parent = PartToFracture.Parent
		if DebrisDespawn then
			Debris:AddItem(Shard, DebrisDespawnDelay)
		end
	end
	PartToFracture:Destroy()

	return shards
end

return Module


Prompt: -- Functions

Response:
function MapManager:SaveMap()
	for _, child in ipairs(workspace:GetChildren()) do
		if not child:IsA('Camera') and not child:IsA('Terrain') and not child:IsA('Folder') then
			local copy = child:Clone()
			if copy then
				copy.Parent = MapSave
			end
		end
	end
end

function MapManager:ClearMap()
	for _, child in ipairs(workspace:GetChildren()) do
		if not child:IsA('Camera') and not child:IsA('Terrain') and not child:IsA('Folder') then
			child:Destroy()
		end
	end
end

function MapManager:LoadMap()
	spawn(function()
		for _, child in ipairs(MapSave:GetChildren()) do
			local copy = child:Clone()
			copy.Parent = workspace
		end
	end)
end

return MapManager


Response:
script.Parent:WaitForChild("Speedo")
script.Parent:WaitForChild("Tach")
script.Parent:WaitForChild("ln")
script.Parent:WaitForChild("Gear")
script.Parent:WaitForChild("Speed")

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

local car = script.Parent.Parent.Car.Value
car.DriveSeat.HeadsUpDisplay = false

local _Tune = require(car["A-Chassis Tune"])

local _pRPM = _Tune.PeakRPM
local _lRPM = _Tune.Redline

local currentUnits = 1
local revEnd = math.ceil(_lRPM/1000)

local intach = car.Body.Dash.Tac.G.Needle


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Auto", "Semi", "Manual"}								--[[
	[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 ]]		2.66		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		1.78		,
		--[[ 3 ]]		1.30		,
		--[[ 4 ]]		1.0		,
		--[[ 5 ]]		0.74		,
		--[[ 6 ]]		0.50		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt:
-- To preserve the "Pause on caught exceptions" behavior of the debugger, we
-- replay the begin phase of a failed component inside invokeGuardedCallback.

Response: exports.replayFailedUnitOfWorkWithInvokeGuardedCallback = _G.__DEV__


Prompt:
--Shield.Touched:connect(function(Hit)
--	if Hit == nil then return end
--	if Hit.Parent == nil then return end
--
--	local Item = Hit.Parent
--
--	if Item:IsA("Tool") == true then return end
--	if Hit.Name == "Torso" then return end
--	if Hit.Name == "HumanoidRootPart" then return end
--	if Hit.Name == "Left Leg" then return end
--	if Hit.Name == "Right Leg" then return end
--	if Hit.Name == "Head" then return end
--	if Hit.Name == "Left Arm" then return end
--	if Hit.Name == "Right Arm" then return end
--	if Hit:FindFirstChild("Pierce") ~= nil then return end
--
--	if Game:GetService("Players"):GetPlayerFromCharacter(Item) ~= nil then return end
--
--	for _, x in ipairs(Hit:GetChildren()) do
--		if x:IsA("TouchTransmitter") == true then x:Destroy() break end
--	end
--end)

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

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

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

while true do
	for _, item in ipairs(FindNear(Shield, 15)) do
		if item:IsA("BasePart") == true then
			local own, dmg = GetOwnerAndDamage(item)

			if own ~= nil and dmg ~= nil and item:FindFirstChild("Pierce") == nil then
				if (item.Position - Shield.Position).magnitude <= 15 and item ~= Shield then
					item:Destroy()
				end
			end
		end
	end

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


Response:
spawn(function() -- this is for the server
	while true do
		gun.Seat.Script.aim:InvokeServer(mouse.Hit.p+Vector3.new(0,0,-0.52))
		wait(0.1)
	end
end)
while rs:wait() do -- render the turret client side anyways to keep turret feeling responsive
	aimpos = mouse.Hit.p
	--gun.gun.Seat.Script.aim:InvokeServer(mouse.Hit.p)

	if (aimpos-gun.base.Position).magnitude>3 then

	local c = aimpos
	local x = (gun.gun:GetPrimaryPartCFrame()*CFrame.new(0, 0, -100000)).x
	local y = (SPAWN*CFrame.new(0, 0, -100000)).y
	local z = (gun.gun:GetPrimaryPartCFrame()*CFrame.new(0, 0, -100000)).z
	A = Vector3.new(x,
					y,
					z
					)
	if c then
		gun.gun:SetPrimaryPartCFrame(
			CFrame.new(gun.body:GetPrimaryPartCFrame().p,
			c)
		)
		gun.body:SetPrimaryPartCFrame(
			CFrame.new(
				SPAWN.p,
				A
			)
		)
	else
		gun:SetPrimaryPartCFrame(gun.body:GetPrimaryPartCFrame())
		gun.body:SetPrimaryPartCFrame(
			CFrame.new(
				SPAWN.p,
				A
			)
		)
		end
	end
end


Prompt: -- Connect to the current and all future cameras

Response:
workspace:GetPropertyChangedSignal("CurrentCamera"):connect(OnCurrentCameraChanged)
OnCurrentCameraChanged()

Player.CharacterAdded:connect(OnCharacterAdded)
if Player.Character then
	OnCharacterAdded(Player.Character)
end

Behaviors[MODE.CUSTOM] = function() end -- (Does nothing until SetCustomBehavior)
Behaviors[MODE.LIMBS] = LimbBehavior
Behaviors[MODE.MOVEMENT] = MoveBehavior
Behaviors[MODE.CORNERS] = CornerBehavior
Behaviors[MODE.CIRCLE1] = CircleBehavior
Behaviors[MODE.CIRCLE2] = CircleBehavior
Behaviors[MODE.LIMBMOVE] = LimbMoveBehavior
Behaviors[MODE.SMART_CIRCLE] = SmartCircleBehavior
Behaviors[MODE.CHAR_OUTLINE] = CharacterOutlineBehavior

Invisicam:SetMode(STARTING_MODE)

return Invisicam


Prompt: -- Function to change walkspeed

Response:
local function setWalkspeed(speed)
	if character and character:IsA("Model") then
		local humanoid = character:FindFirstChild("Humanoid")
		if humanoid then
			humanoid.WalkSpeed = speed
		end
	end
end


Prompt:
--[[
--local scale = hit.Parent.Hair.Handle.Belly.Mesh.Scale.Vector3.x
IN.Belly.Mesh.Scale = Vector3.new(0,0,0)
IN.Belly2.Mesh.Scale = Vector3.new(0,0,0)
IN.Front1.Mesh.Scale = Vector3.new(0,0,0)
IN.Back1.Mesh.Scale = Vector3.new(0,0,0)
IN.Front2.Mesh.Scale = Vector3.new(0,0,0)
IN.Back2.Mesh.Scale = Vector3.new(0,0,0)
wait (1)
]]

Response:
--

local Inf = 0.9
		for i = 1, (Inf*0.9) do
										--From front: Vector3(+,-(Right,Left)(Up,Down)(Forward,Back))
			--Belly rate
			local bel = .1
		IN.Belly.Mesh.Scale  = IN.Belly.Mesh.Scale + Vector3.new(bel,bel,bel)
		IN.Belly2.Mesh.Scale = IN.Belly2.Mesh.Scale + Vector3.new(bel,bel,bel)
		IN.Belly.Mesh.Offset  = IN.Belly.Mesh.Offset + Vector3.new(0, 0,bel/2)
		IN.Belly2.Mesh.Offset = IN.Belly2.Mesh.Offset + Vector3.new(0, 0,bel/2)

			--Front rate
			local boo = .1
		IN.Front1.Mesh.Scale = IN.Front1.Mesh.Scale + Vector3.new(boo, boo, boo)
		IN.Front11.Mesh.Scale = IN.Front11.Mesh.Scale + Vector3.new(boo, boo, boo)
		IN.Front2.Mesh.Scale = IN.Front2.Mesh.Scale + Vector3.new(boo, boo, boo)
		IN.Front21.Mesh.Scale = IN.Front21.Mesh.Scale + Vector3.new(boo, boo, boo)
		IN.Front1.Mesh.Offset = IN.Front1.Mesh.Offset + Vector3.new(-boo/5, 0, boo/2.5)
		IN.Front11.Mesh.Offset = IN.Front11.Mesh.Offset + Vector3.new(-boo/5, 0, boo/2.5)
		IN.Front2.Mesh.Offset = IN.Front2.Mesh.Offset + Vector3.new(boo/5, 0, boo/2.5)
		IN.Front21.Mesh.Offset = IN.Front21.Mesh.Offset + Vector3.new(boo/5, 0, boo/2.5)

			--Back rate
			local back = .1
		IN.Back1.Mesh.Scale = IN.Back1.Mesh.Scale + Vector3.new(back, back, back)
		IN.Back2.Mesh.Scale = IN.Back2.Mesh.Scale + Vector3.new(back, back, back)
		IN.Back1.Mesh.Offset = IN.Back1.Mesh.Offset + Vector3.new(-back/5, 0, -back/4)
		IN.Back2.Mesh.Offset = IN.Back2.Mesh.Offset + Vector3.new(back/5, 0, -back/4)

			--Speed
			local spe = .004
		hit.Parent.Humanoid.WalkSpeed = (hit.Parent.Humanoid.WalkSpeed - spe)

end


Prompt: --Rescripted by Luckymaxer

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

Players = game:GetService("Players")

Sounds = {
	CoilSound = Handle:WaitForChild("CoilSound"),
}

Gravity = 196.20
JumpHeightPercentage = 0.25

ToolEquipped = false

function GetAllConnectedParts(Object)
	local Parts = {}
	local function GetConnectedParts(Object)
		for i, v in pairs(Object:GetConnectedParts()) do
			local Ignore = false
			for ii, vv in pairs(Parts) do
				if v == vv then
					Ignore = true
				end
			end
			if not Ignore then
				table.insert(Parts, v)
				GetConnectedParts(v)
			end
		end
	end
	GetConnectedParts(Object)
	return Parts
end

function SetGravityEffect()
	if not GravityEffect or not GravityEffect.Parent then
		GravityEffect = Instance.new("BodyForce")
		GravityEffect.Name = "GravityCoilEffect"
		GravityEffect.Parent = Torso
	end
	local TotalMass = 0
	local ConnectedParts = GetAllConnectedParts(Torso)
	for i, v in pairs(ConnectedParts) do
		if v:IsA("BasePart") then
			TotalMass = (TotalMass + v:GetMass())
		end
	end
	local TotalMass = (TotalMass * 196.20 * (1 - JumpHeightPercentage))
	GravityEffect.force = Vector3.new(0, TotalMass, 0)
end

function HandleGravityEffect(Enabled)
	if not CheckIfAlive() then
		return
	end
	for i, v in pairs(Torso:GetChildren()) do
		if v:IsA("BodyForce") then
			v:Destroy()
		end
	end
	for i, v in pairs({ToolUnequipped, DescendantAdded, DescendantRemoving}) do
		if v then
			v:disconnect()
		end
	end
	if Enabled then
		CurrentlyEquipped = true
		ToolUnequipped = Tool.Unequipped:connect(function()
			CurrentlyEquipped = false
		end)
		SetGravityEffect()
		DescendantAdded = Character.DescendantAdded:connect(function()
			wait()
			if not CurrentlyEquipped or not CheckIfAlive() then
				return
			end
			SetGravityEffect()
		end)
		DescendantRemoving = Character.DescendantRemoving:connect(function()
			wait()
			if not CurrentlyEquipped or not CheckIfAlive() then
				return
			end
			SetGravityEffect()
		end)
	end
end

function CheckIfAlive()
	return (((Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Torso and Torso.Parent and Player and Player.Parent) and true) or false)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Humanoid = Character:FindFirstChild("Humanoid")
	Torso = Character:FindFirstChild("HumanoidRootPart")
	Player = Players:GetPlayerFromCharacter(Character)
	if not CheckIfAlive() then
		return
	end
	if HumanoidDied then
		HumanoidDied:disconnect()
	end
	HumanoidDied = Humanoid.Died:connect(function()
		if GravityEffect and GravityEffect.Parent then
			GravityEffect:Destroy()
		end
	end)
	Sounds.CoilSound:Play()
	HandleGravityEffect(true)
	ToolEquipped = true
end

function Unequipped()
	if HumanoidDied then
		HumanoidDied:disconnect()
	end
	HandleGravityEffect(false)
	ToolEquipped = false
end

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


Prompt:
--[=[
	Reimplementation of Player:GetUserThumbnailAsync but as a promise with
	retry logic.

	@class PlayerThumbnailUtils
]=]

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

local Players = game:GetService("Players")

local Promise = require("Promise")

local MAX_TRIES = 5

local PlayerThumbnailUtils = {}


Prompt:
-- ================================================================================
-- LOCAL FUNCTIONS
-- ================================================================================

Response:
function Reset()
	down = {}
	state = {}
end -- Reset()

function GetState()
	-- Map KeyCodes to corresponding InputObjects on the gamepad:
	local inputObjects = UserInputService:GetGamepadState(GAMEPAD1)
	for _,inputObject in pairs(inputObjects) do
		state[inputObject.KeyCode] = inputObject
	end
end -- GetState()

function InputBegan(input, processed)
	if input.UserInputType == GAMEPAD1 then
		down[input.KeyCode] = true
		buttonDown:Fire(input.KeyCode)
	end
end -- InputBegan()

function InputEnded(input, processed)
	if input.UserInputType == GAMEPAD1 then
		down[input.KeyCode] = false
		buttonUp:Fire(input.KeyCode)
	end
end -- InputEnded()

function InputChanged(input, processed)
	if input.UserInputType == GAMEPAD1 then
		changed:Fire(input.KeyCode)
	end
end -- InputChanged()

function GamepadConnected(gamepad)
	if gamepad == GAMEPAD1 then
		Gamepad.IsConnected = true
		GetState()
		connected:Fire()
	end
end -- GamepadConnected

function GamepadDisconnected(gamepad)
	if gamepad == GAMEPAD1 then
		Gamepad.IsConnected = false
		Reset()
		disconnected:Fire()
	end
end -- GamepadDisconnected


Prompt: ----------------------This is just an example-----------------------------

Response:
local ammo = script.Parent.Values.Ammo
local ammo2 = script.Parent.Values.Ammo2


Prompt: -- Use Handle.AlignPosition to float behind, up, and to the side of the player, like a minion

Response:
AlignPosition.Attachment0 = Attachment0
AlignPosition.Attachment1 = Attachment1
AlignOrientation.Attachment0 = Attachment0
AlignOrientation.Attachment1 = Attachment1


Prompt: -- This makes the loading bar fill up. Don't touch anything here!

Response:
local prog = 0

while wait() do
	prog = prog + 0.5
	script.Parent.Size = UDim2.new(prog/100, 0, 0.1, 0)
	script.Parent.Parent.LoadingLabel.Text = ("Loading...   " ..math.floor(prog*2).. "%")
	if prog == 50 then
		wait(1)
		script.Parent.Parent.Parent:Destroy()
	end
end


Prompt: --//Main Function

Response:
ProximityPrompt.Triggered:Connect(function(Player)
	local Character = Player.Character
	local Head = Character:WaitForChild("Head")
	ProximityPrompt.ActionText = ""
	if Character:FindFirstChild(script.Parent.Parent.Parent.Name) then
		Character[script.Parent.Parent.Parent.Name]:Destroy()
	else
		local NewArmor = Armor:Clone()
		NewArmor:SetPrimaryPartCFrame(Head.CFrame)
		NewArmor.PrimaryPart:Destroy()
		ProximityPrompt.ActionText = ""
		for _, part in pairs (NewArmor:GetChildren()) do
			if part:IsA("BasePart") then
				WeldParts(Head, part)
				part.CanCollide = false
				part.Anchored = false
			end
		end
		NewArmor.Parent = Character
	end
end)


Prompt: --// # key, ManOff

Response:
mouse.KeyUp:connect(function(key)
	if key=="f" then
		veh.Lightbar.middle.Man:Stop()
		veh.Lightbar.middle.Wail.Volume = 8
		veh.Lightbar.middle.Yelp.Volume = 8
		veh.Lightbar.middle.Priority.Volume = 8
		script.Parent.Parent.Sirens.Man.BackgroundColor3 = Color3.fromRGB(62, 62, 62)
		veh.Lightbar.MAN.Transparency = 1
	end
end)


Prompt:
--[[
	Novena Constraint Type: Motorcycle
			The Bike Chassis

				SecondLogic | Inspare (thanks!)
				Avxnturador | Novena
--]]

Response:
local autoscaling	= true					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default
	{
		units			= "MPH"				,
		scaling			= (10/12) * (60/88)	, -- 1 stud : 10 inches | ft/s to MPH
		maxSpeed		= 230				,
		spInc			= 20				, -- Increment between labelled notches
	},

	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 370				,
		spInc			= 40				, -- Increment between labelled notches
	},

	{
		units			= "SPS"				,
		scaling			= 1					, -- Roblox standard
		maxSpeed		= 400				,
		spInc			= 40				, -- Increment between labelled notches
	}
}


Response:
function Tween(instance,tweeninformation,goals)
	TweenService:Create(instance,tweeninformation,goals):Play()
end
LightGroup = script.Parent.Lights:GetChildren()
while true do
	wait(0)
	if script.Parent.on.Value then
		for i = 1,#LightGroup do
			Tween(LightGroup[i],TweenInfo.new(deltatime),{Transparency = 0})
			Tween(LightGroup[i].Light,TweenInfo.new(deltatime),{Brightness = 2})
		end
	else
		for i = 1,#LightGroup do
			Tween(LightGroup[i],TweenInfo.new(deltatime),{Transparency = 1})
			Tween(LightGroup[i].Light,TweenInfo.new(deltatime),{Brightness = 0})
		end
	end
end


Prompt: -- new shat

Response:
RightHip.MaxVelocity = 0.1
LeftHip.MaxVelocity = 0.1


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 1100		-- 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: -- excluding the `+` and `*` character, since findOr tests and graphql use them explicitly

Response:
local luaPatternCharacters = "([" .. ("$%^()-[].?"):gsub("(.)", "%%%1") .. "])"

local function includes(str: string, substring: string, position: (string | number)?): boolean
	local strLen, invalidBytePosition = utf8.len(str)
	assert(strLen ~= nil, ("string `%s` has an invalid byte at position %s"):format(str, tostring(invalidBytePosition)))
	if strLen == 0 then
		return false
	end

	if #substring == 0 then
		return true
	end

	local startIndex = 1
	if position ~= nil then
		startIndex = tonumber(position) or 1
		if startIndex > strLen then
			return false
		end
	end

	if startIndex < 1 then
		startIndex = 1
	end

	local init = utf8.offset(str, startIndex)
	local value = substring:gsub(luaPatternCharacters, "%%%1")
	local iStart, _ = string.find(str, value, init)
	return iStart ~= nil
end

return includes


Prompt:
-- Manages the cleaning of events and other things.
-- Useful for encapsulating state and make deconstructors easy
-- @classmod Maid
-- @see Signal

Response:
local Maid = {}
Maid.ClassName = "Maid"


Prompt: --// Core

Response:
return function()
	local Functions, Admin, Anti, Core, HTTP, Logs, Remote, Process, Variables, Settings, Deps
	local function Init()
		Functions = server.Functions;
		Admin = server.Admin;
		Anti = server.Anti;
		Core = server.Core;
		HTTP = server.HTTP;
		Logs = server.Logs;
		Remote = server.Remote;
		Process = server.Process;
		Variables = server.Variables;
		Settings = server.Settings;
		Deps = server.Deps

		Logs:AddLog("Script", "Core Module Initialized")
	end;

	server.Core = {
		Init = Init;
		DataQueue = {};
		DataCache = {};
		ExecuteScripts = {};
		LastDataSave = 0;
		PanicMode = false;
		ScriptCache = {};
		Connections = {};
		Variables = {
			TimeBans = {};
		};

		Panic = function(reason)
			local hint = Instance.new("Hint", service.Workspace)
			hint.Text = "-= Adonis PanicMode Enabled: "..tostring(reason).." =~"
			Core.PanicMode = true;

			warn("SOMETHING SEVERE HAPPENED; ENABLING PANIC MODE; REASON BELOW;")
			warn(tostring(reason))
			warn("ENABLING CHAT MODE AND DISABLING CLIENT CHECKS;")
			warn("MODS NOW HAVE ACCESS TO PANIC COMMANDS SUCH AS :SHUTDOWN")

			--[[
			for i,v in pairs(service.Players:GetPlayers()) do
				cPcall(function()
					v.Chatted:connect(function(msg)
						Process.Chat(v,msg)
					end)
				end)
			end
			--]]

			Logs.AddLog(Logs.Script,{
				Text = "ENABLED PANIC MODE";
				Desc = tostring(reason);
			})
		end;

		MakeEvent = function()
			local ran,error = pcall(function()
				if Anti.RLocked(service.JointsService) then
					Core.Panic("JointsService RobloxLocked")
				elseif server.Running then
					if Core.RemoteEvent then
						Core.RemoteEvent.Security:Disconnect()
						Core.RemoteEvent.Event:Disconnect()
						Core.RemoteEvent.DecoySecurity1:Disconnect()
						Core.RemoteEvent.DecoySecurity2:Disconnect()
						pcall(function() service.Delete(Core.RemoteEvent.Object) end)
						pcall(function() service.Delete(Core.RemoteEvent.Decoy1) end)
						pcall(function() service.Delete(Core.RemoteEvent.Decoy2) end)
					end

					Core.RemoteEvent = {}

					local event = service.New("RemoteEvent")
					local decoy1 = event:Clone()
					local decoy2 = event:Clone()

					event.Name = Core.Name--..Functions.GetRandom() -- Core.Name
					decoy1.Name = Core.Name..Functions.GetRandom()
					decoy2.Name = Core.Name..Functions.GetRandom()

					event.Archivable = false
					decoy1.Archivable = false
					decoy2.Archivable = false

					Core.RemoteEvent.Object = event
					Core.RemoteEvent.Decoy1 = decoy1
					Core.RemoteEvent.Decoy2 = decoy2

					event.Parent = service.JointsService
					--decoy1.Parent = service.JointsService
					--decoy2.Parent = service.JointsService

					local function secure(ev)
						return service.RbxEvent(ev.Changed, function(p)
							if p=="Name" then
								event.Name = Core.Name--..Functions.GetRandom()--Core.Name
							else
								Core.MakeEvent()
							end
						end)
					end

					Core.RemoteEvent.Event = service.RbxEvent(event.OnServerEvent, Process.Remote)
					service.RbxEvent(decoy1.OnServerEvent, function(p,modu,com,sub)
						local keys = Remote.Clients[tostring(p.userId)]
						if keys and com == "TrustCheck" and modu == keys.Module then
							decoy1:FireClient(p,"TrustCheck",keys.Decoy1)
						end
					end)

					service.RbxEvent(decoy2.OnServerEvent, function(p,modu,com,sub)
						local keys = Remote.Clients[tostring(p.userId)]
						if keys and com == "TrustCheck" and modu == keys.Module then
							decoy1:FireClient(p,"TrustCheck",keys.Decoy2)
						end
					end)

					Core.RemoteEvent.Security = secure(event)
					Core.RemoteEvent.DecoySecurity1 = secure(decoy1)
					Core.RemoteEvent.DecoySecurity2 = secure(decoy2)
					Logs.AddLog(Logs.Script,{
						Text = "Created RemoteEvent";
						Desc = "RemoteEvent was successfully created";
					})
				end
			end)

			if error then
				warn(error)
				Core.Panic("Error while making RemoteEvent")
			end
		end;

		CheckAllClients = function()
			if Settings.CheckClients and not Core.PanicMode and server.Running then
				Logs.AddLog(Logs.Script,{
					Text = "Checking Clients";
					Desc = "Making sure all clients are active";
				})
				local parent = service.NetworkServer or service.Players
				local net = service.NetworkServer or false
				for ind,p in next,parent:GetChildren() do
					if net then p = p:GetPlayer() end
					if p then
						if Anti.ObjRLocked(p) then
							Anti.Detected(p, "kick", "RobloxLocked")
						else
							local client = Remote.Clients[tostring(p.userId)]
							if client and client.LoadingStatus == "READY" then
								local lastTime = client.LastUpdate
								if lastTime and tick()-lastTime > 60*5 then
									Anti.Detected(p, "kick","Client Not Responding [Client hasn't checked in >5 minutes]")
								end
							end
						end
					end
				end
			end
		end;

		UpdateConnections = function()
			if service.NetworkServer then
				for i,cli in next,service.NetworkServer:GetChildren() do
					Core.Connections[cli] = cli:GetPlayer()
				end
			end
		end;

		UpdateConnection = function(p)
			if service.NetworkServer then
				for i,cli in next,service.NetworkServer:GetChildren() do
					if cli:GetPlayer() == p then
						Core.Connections[cli] = p
					end
				end
			end
		end;

		GetNetworkClient = function(p)
			if service.NetworkServer then
				for i,v in pairs(service.NetworkServer:GetChildren()) do
					if v:GetPlayer() == p then
						return v
					end
				end
			end
		end;

		SetupEvent = function(p)
			local key = tostring(p.userId)
			local keys = Remote.Clients[key]
			if keys and keys.EventName and p and not Anti.ObjRLocked(p) then
				local event = Instance.new("RemoteEvent")
				event.Name = keys.EventName
				event.Changed:connect(function()
					if Anti.RLocked(event) or not event or event.Parent ~= p then
						service.Delete(event)
						Core.SetupEvent(p)
					end
				end)
				event.OnServerEvent:connect(function(np,...)
					if np == p then
						Process.Remote(np,...)
					end
				end)
				event.Parent = p
			else
				p:Kick("Locked")
			end
		end;

		PrepareClient = function()
			if service.NetworkServer and server.Running then
				local ran,err = pcall(function()
					if Core.ClientLoader then
						pcall(function() Core.ClientLoaderEvent:Disconnect() service.Delete(Core.ClientLoader) end)
					end
					local loader = Deps.ClientLoader:Clone()
					loader.Archivable = false
					loader.Name = "\0"
					loader.Parent = service.ReplicatedFirst
					loader.Disabled = false

					Core.ClientLoader = loader
					Core.ClientLoaderEvent = loader.Changed:connect(function()
						Core.PrepareClient()
					end)
				end)

				if err or not ran then
					Core.Panic("Cannot load ClientLoader "..tostring(err))
				end
			end
		end;

		HookClient = function(p)
			local key = tostring(p.userId)
			local keys = Remote.Clients[key]
			if keys then
				local depsName = Functions:GetRandom()
				local eventName = Functions:GetRandom()
				local folder = server.Client:Clone()
				local client = folder.Client

				folder.Name = "Adonis_Client" --Core.Name.."\\"..depsName

				local specialVal = service.New("StringValue")
				specialVal.Value = Core.Name.."\\"..depsName
				specialVal.Name = "Special"
				specialVal.Parent = folder

				keys.Loader = Core.ClientLoader
				keys.Special = depsName
				keys.EventName = eventName
				keys.Module = client

				service.Events[p.userId.."_CLIENTLOADER"]:connectOnce(function()
					if folder.Parent == p then
						folder:Destroy()
					end
				end)

				local ok,err = pcall(function()
					folder.Parent = p
				end)

				if not Core.PanicMode and not ok then
					p:Kick("Loading Error [HookClient Error: "..tostring(err).."]")
					return false
				else
					return true
				end
			else
				if p then p:Kick("Loading Error [HookClient: Keys Missing]") end
			end
		end;

		LoadClientLoader = function(p)
			local loader = Deps.ClientLoader:Clone()
			loader.Name = math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)..math.random(0,9)
			loader.Parent = p:WaitForChild("Backpack")
			loader.Disabled = false
		end;

		LoadExistingPlayer = function(p)
			Core.LoadClientLoader(p)
			Process.PlayerAdded(p)
		end;

		MakeClient = function()
			local ran,error = pcall(function()
				if Anti.RLocked(service.StarterPlayer) then
					Core.Panic("StarterPlayer RobloxLocked")
				else
					local starterScripts = service.StarterPlayer:FindFirstChild(Core.Name)
					if not starterScripts then
						starterScripts = service.New("StarterPlayerScripts",service.StarterPlayer)
						starterScripts.Name = Core.Name
						starterScripts.Changed:connect(function(p)
							if p=="Parent" then
								Core.MakeClient()
							elseif p=="Name" then
								starterScripts.Name = Core.Name
							elseif p=="RobloxLocked" and Anti.RLocked(starterScripts) then
								Core.Panic("PlayerScripts RobloxLocked")
							end
						end)
						starterScripts.ChildAdded:connect(function(c)
							if c.Name~=Core.Name then
								wait(0.5)
								c:Destroy()
							end
						end)
					end
					starterScripts:ClearAllChildren()
					if Anti.RLocked(starterScripts) then
						Core.Panic("StarterPlayerScripts RobloxLocked")
					else
						if Core.Client then
							local cli = Core.Client
							if Anti.ObjRLocked(cli.Object) then
								Core.Panic("Client RobloxLocked")
							else
								Core.Client.Security:disconnect()
								pcall(function() Core.Client.Object:Destroy() end)
							end
						end
						Core.Client = {}
						local client = Deps.Client:clone()
						client.Name = Core.Name
						server.ClientDeps:Clone().Parent = client
						client.Parent = starterScripts
						client.Disabled = false
						Core.Client.Object = client
						Core.Client.Security = client.Changed:connect(function(p)
							if p == "Parent" or p == "RobloxLocked" then
								Core.MakeClient()
							end
						end)
					end
				end
			end)
			if error then
				print(error)
				Core.Panic("Error while making client")
			end
		end;

		ExecutePermission = function(scr, code, isLocal)
			for i,val in next,Core.ExecuteScripts do
				if not isLocal or (isLocal and val.Type == "LocalScript") then
					if (service.UnWrap(val.Script) == service.UnWrap(scr) or code == val.Code) and (not val.runLimit or (val.runLimit ~= nil and val.Executions <= val.runLimit)) then
						val.Executions = val.Executions+1
						return {
							Source = val.Source;
							noCache = val.noCache;
							runLimit = val.runLimit;
							Executions = val.Executions;
						}
					end
				end
			end
		end;

		GetScript = function(scr,code)
			for i,val in next,Core.ExecuteScripts do
				if val.Script == scr or code == val.Code then
					return val,i
				end
			end
		end;

		UnRegisterScript = function(scr)
			for i,dat in next,Core.ExecuteScripts do
				if dat.Script == scr or dat == scr then
					table.remove(Core.ExecuteScripts, i)
					return dat
				end
			end
		end;

		RegisterScript = function(data)
			data.Executions = 0
			data.Time = os.time()
			data.Type = data.Script.ClassName
			data.Wrapped = service.Wrap(data.Script)
			data.Wrapped:SetSpecial("Clone",function()
				return Core.RegisterScript {
					Script = service.UnWrap(data.Script):Clone();
					Code = data.Code;
					Source = data.Source;
					noCache = data.noCache;
					runLimit = data.runLimit;
				}
			end)

			for ind,scr in next,Core.ExecuteScripts do
				if scr.Script == data.Script then
					return scr.Wrapped or scr.Script
				end
			end

			if not data.Code then
				data.Code = Functions.GetRandom()
			end

			table.insert(Core.ExecuteScripts,data)
			return data.Wrapped
		end;

		Loadstring = function(str, env)
			return require(Deps.Loadstring:Clone())(str, env)
		end;

		Bytecode = function(str)
			local f,buff = Core.Loadstring(str)
			return buff
		end;

		NewScript = function(type,source,allowCodes,noCache,runLimit)
			local ScriptType
			local execCode = Functions.GetRandom()

			if type == 'Script' then
				ScriptType = Deps.ScriptBase:Clone()
			elseif type == 'LocalScript' then
				ScriptType = Deps.LocalScriptBase:Clone()
			end

			if ScriptType then
				ScriptType.Name = type

				if allowCodes then
					local exec = Instance.new("StringValue",ScriptType)
					exec.Name = "Execute"
					exec.Value = execCode
				end

				local wrapped = Core.RegisterScript {
					Script = ScriptType;
					Code = execCode;
					Source = Core.Bytecode(source);
					noCache = noCache;
					runLimit = runLimit;
				}

				return wrapped or ScriptType, ScriptType, execCode
			end
		end;

		DoSave = function(data)
			local type = data.Type
			if type == "ClearSettings" then
				Core.SetData("SavedSettings",{})
				Core.SetData("SavedTables",{})
			elseif type == "SetSetting" then
				local setting = data.Setting
				local value = data.Value
				Core.UpdateData("SavedSettings", function(settings)
					settings[setting] = value
					return settings
				end)
			elseif type == "TableRemove" then
				local tab = data.Table
				local value = data.Value
				data.Time = os.time()
				Core.UpdateData("SavedTables", function(sets)
					sets = sets or {}
					for i,v in next,sets do
						if tab == v.Table then
							if Functions.CheckMatch(v.Value,value) then
								table.remove(sets,i)
							end
						end
					end
					data.Action = "Remove"
					table.insert(sets,data)
					return sets
				end)
			elseif type == "TableAdd" then
				local tab = data.Table
				local value = data.Value
				data.Time = os.time()
				Core.UpdateData("SavedTables", function(sets)
					sets = sets or {}
					for i,v in next,sets do
						if tab == v.Table then
							if Functions.CheckMatch(v.Value,value) then
								table.remove(sets,i)
							end
						end
					end
					data.Action = "Add"
					table.insert(sets,data)
					return sets
				end)
			end

			Logs.AddLog(Logs.Script,{
				Text = "Saved setting change to datastore";
				Desc = "A setting change was issued and saved";
			})
		end;

		SavePlayer = function(p,data)
			local key = tostring(p.userId)
			Remote.PlayerData[key] = data
		end;

		DefaultData = function(p)
			return {
				Donor = {
					Cape = {
						Image = '0';
						Color = 'White';
						Material = 'Neon';
					};
					Enabled = false;
				};
				Banned = false;
				TimeBan = false;
				AdminNotes = {};
				Keybinds = {};
				Client = {};
				Warnings = {};
				AdminPoints = 0;
			};
		end;

		GetPlayer = function(p)
			local key = tostring(p.userId)
			local PlayerData = Core.DefaultData(p)

			if not Remote.PlayerData[key] then
				Remote.PlayerData[key] = PlayerData
				if Core.DataStore then
					local data = Core.GetData(key)
					if data and type(data) == "table" then
						for i,v in next,data do
							PlayerData[i] = v
						end
					end
				end
			else
				PlayerData = Remote.PlayerData[key]
			end
			return PlayerData
		end;

		ClearPlayer = function(p)
			Remote.PlayerData[tostring(p.userId)] = Core.DefaultData(p);
		end;

		SavePlayerData = function(p)
			local key = tostring(p.userId)
			local data = Remote.PlayerData[key]
			if data and Core.DataStore then
				data.LastChat = nil
				data.AdminLevel = nil
				data.LastLevelUpdate = nil
				Core.SetData(key, data)
				Remote.PlayerData[key] = nil
				Logs.AddLog(Logs.Script,{
					Text = "Saved data for "..tostring(p);
					Desc = "Player data was saved to the datastore";
				})
			end
		end;

		GetDataStore = function()
			local lastUpdate = 0
			local keyCache = {}
			local saveCache = {}
			local updateCache = {}
			local ran,store = pcall(function() return service.DataStoreService:GetDataStore(Settings.DataStore:sub(1,50),"Adonis") end)

			--[[

			--// Todo:
			--// Implement reru's idea
			--// AutoAssign a server to handle datastore updates
			--// Cache all datastore updates
			--// Update everything using one UpdateAsync per server every 30-60 seconds
			--// Have main server handle check for new data and update datastore keys accordingly

			if ran and store then
				local original = store:GetObject()
				local prepareTable; prepareTable = function(tab)
					if true then return tab end
					if type(tab) == "table" then
						local tabUpdates = {}
						for i,v in next,tab do
							tab[i] = prepareTable(v)
						end

						return setmetatable(tab,{
							__newindex = function(old, ind, val)
								table.insert(tabUpdates,{

								})
							end
						}), tabUpdates
					else
						return tab
					end
				end

				store:SetSpecial("SetAsync", function(wrapped, key, value)
					table.insert(updateCache, {
						Key = key;
						Time = os.time;
						Value = value;
					})

					keyCache[key] = value
				end)

				store:SetSpecial("UpdateAsync", function(wrapped, key, func)
					original:UpdateAsync(key, function(data)
						local metaTab,tabUpdates = prepareTable(data)
						local returns = func(metaTab)
						if type(data) == "table" and tabUpdates then

						end
					end)
				end)

				store:SetSpecial("GetAsync", function(wrapped, key)
					if not keyCache[key] then
						keyCache[key] = original:GetAsync(key)
					end

					return keyCache[key]
				end)

				store:SetSpecial("Update", function(wrapped)
					lastUpdate = os.time()
					keyCache = {}
				end)

				service.StartLoop("DataUpdate",30,store.Update,true)
			end--]]

			return ran and store
		end;

		DataStoreEncode = function(key)
			return Functions.Base64Encode(Remote.Encrypt(tostring(key), Settings.DataStoreKey))
		end;

		SaveData = function(...)
			return Core.SetData(...)
		end;

		SetData = function(key, value)
			if Core.DataStore then
				local ran, ret = pcall(Core.DataStore.SetAsync, Core.DataStore, Core.DataStoreEncode(key), value)
				if ran then
					Core.DataCache[key] = value
					return ret
				else
					logError("DataStore SetAsync Failed: ".. tostring(ret))
				end
			end
		end;

		UpdateData = function(key, func)
			if Core.DataStore then
				local ran, ret = pcall(Core.DataStore.UpdateAsync, Core.DataStore, Core.DataStoreEncode(key), func)
				if ran then
					return ret
				else
					logError("DataStore UpdateAsync Failed: ".. tostring(ret))
				end
			end
		end;

		GetData = function(key)
			if Core.DataStore then
				local ran, ret = pcall(Core.DataStore.GetAsync, Core.DataStore, Core.DataStoreEncode(key))
				if ran then
					Core.DataCache[key] = ret
					return ret
				else
					logError("DataStore GetAsync Failed: ".. tostring(ret))
					return Core.DataCache[key]
				end
			end
		end;

		LoadData = function(key, data)
			local SavedSettings
			local SavedTables
			local Blacklist = {DataStoreKey = true;}
			if Core.DataStore and Settings.DataStoreEnabled then
				if not key then
					SavedSettings = Core.GetData("SavedSettings")
					SavedTables = Core.GetData("SavedTables")
				elseif key and not data then
					if key == "SavedSettings" then
						SavedSettings = Core.GetData("SavedSettings")
					elseif key == "SavedTables" then
						SavedTables = Core.GetData("SavedTables")
					end
				elseif key and data then
					if key == "SavedSettings" then
						SavedSettings = data
					elseif key == "SavedTables" then
						SavedTables = data
					end
				end

				if not key and not data then
					if not SavedSettings then
						SavedSettings = {}
						Core.SaveData("SavedSettings",{})
					end

					if not SavedTables then
						SavedTables = {}
						Core.SaveData("SavedTables",{})
					end
				end

				if SavedSettings then
					for setting,value in next,SavedSettings do
						if not Blacklist[setting] then
							if setting == 'Prefix' or setting == 'AnyPrefix' or setting == 'SpecialPrefix' then
								local orig = Settings[setting]
								for i,v in pairs(server.Commands) do
									if v.Prefix == orig then
										v.Prefix = value
									end
								end
							end

							Settings[setting] = value
						end
					end
				end

				if SavedTables then
					for ind,tab in next,SavedTables do
						local parentTab = (tab.Parent == "Variables" and Core.Variables) or Settings
						if (not Blacklist[tab.Table]) and parentTab[tab.Table] ~= nil then
							if tab.Action == "Add" then
								local tabl = parentTab[tab.Table]
								if tabl then
									for i,v in next,tabl do
										if Functions.CheckMatch(v,tab.Value) then
											table.remove(parentTab[tab.Table],i)
										end
									end
								end

								Logs.AddLog("Script",{
									Text = "Added to "..tostring(tab.Table);
									Desc = "Added "..tostring(tab.Value).." to "..tostring(tab.Table).." from datastore";
								})
								table.insert(parentTab[tab.Table],tab.Value)
							elseif tab.Action == "Remove" then
								local tabl = parentTab[tab.Table]
								if tabl then
									for i,v in next,tabl do
										if Functions.CheckMatch(v,tab.Value) then
											Logs.AddLog("Script",{
												Text = "Removed from "..tostring(tab.Table);
												Desc = "Removed "..tostring(tab.Value).." from "..tostring(tab.Table).." from datastore";
											})
											table.remove(parentTab[tab.Table],i)
										end
									end
								end
							end
						end
					end

					if Core.Variables.TimeBans then
						for i,v in next, Core.Variables.TimeBans do
							if v.EndTime-os.time() <= 0 then
								table.remove(Core.Variables.TimeBans, i)
								Core.DoSave({
									Type = "TableRemove";
									Table = "TimeBans";
									Parent = "Variables";
									Value = v;
								})
							end
						end
					end
				end

				Logs.AddLog(Logs.Script,{
					Text = "Loaded saved data";
					Desc = "Data was retrieved from the datastore and loaded successfully";
				})
			end
		end;

		StartAPI = function()
			local _G = _G
			local setmetatable = setmetatable
			local rawset = rawset
			local rawget = rawget
			local type = type
			local error = error
			local print = print
			local warn = warn
			local pairs = pairs
			local next = next
			local table = table
			local getfenv = getfenv
			local setfenv = setfenv
			local require = require
			local tostring = tostring
			local server = server
			local service = service
			local Routine = Routine
			local cPcall = cPcall
			local API_Special = {
				AddAdmin = Settings.Allowed_API_Calls.DataStore;
				RemoveAdmin = Settings.Allowed_API_Calls.DataStore;
				RunCommand = Settings.Allowed_API_Calls.Core;
				SaveTableAdd = Settings.Allowed_API_Calls.DataStore and Settings.Allowed_API_Calls.Settings;
				SaveTableRemove = Settings.Allowed_API_Calls.DataStore and Settings.Allowed_API_Calls.Settings;
				SaveSetSetting = Settings.Allowed_API_Calls.DataStore and Settings.Allowed_API_Calls.Settings;
				ClearSavedSettings = Settings.Allowed_API_Calls.DataStore and Settings.Allowed_API_Calls.Settings;
				SetSetting = Settings.Allowed_API_Calls.Settings;
			}

			setfenv(1,setmetatable({}, {__metatable = getmetatable(getfenv())}))

			local API_Specific = {
				API_Specific = {
					Test = function()
						print("We ran the api specific stuff")
					end
				};
				Settings = Settings;
				Service = service;
			}

			local API = {
				Access = service.MetaFunc(function(...)
					local args = {...}
					local key = args[1]
					local ind = args[2]
					local targ

					if API_Specific[ind] then
						targ = API_Specific[ind]
					elseif server[ind] and Settings.Allowed_API_Calls[ind] then
						targ = server[ind]
					end

					if Settings.G_Access and key == Settings.G_Access_Key and targ and Settings.Allowed_API_Calls[ind] == true then
						if type(targ) == "table" then
							return service.NewProxy {
								__index = function(tab,inde)
									if targ[inde] ~= nil and API_Special[inde] == nil or API_Special[inde] == true then
										if targ[inde]~=nil and type(targ[inde]) == "table" and Settings.G_Access_Perms == "Read" then
											return service.ReadOnly(targ[inde])
										else
											return targ[inde]
										end
										Logs.AddLog(Logs.Script,{
											Text = "Access to "..tostring(inde).." was granted";
											Desc = "A server script was granted access to "..tostring(inde);
										})
									elseif API_Special[inde] == false then
										Logs.AddLog(Logs.Script,{
											Text = "Access to "..tostring(inde).." was denied";
											Desc = "A server script attempted to access "..tostring(inde).." via _G.Adonis.Access";
										})
										error("Access Denied: "..tostring(inde))
									else
										error("Could not find "..tostring(inde))
									end
								end;
								__newindex = function(tabl,inde,valu)
									if Settings.G_Access_Perms == "Read" then
										error("Read-only")
									elseif Settings.G_Access_Perms == "Write" then
										tabl[inde] = valu
									end
								end;
								__metatable = true;
							}
						end
					else
						error("Incorrect key or G_Access is disabled")
					end
				end);

				Scripts = service.ReadOnly({
					ExecutePermission = function(code)
						local exists;

						if not Settings.CodeExecution then
							return nil
						end

						for i,v in pairs(Core.ScriptCache) do
							if v.Script == getfenv(2).script then
								exists = v
							end
						end

						if exists and exists.noCache ~= true and (not exists.runLimit or (exists.runLimit and exists.Executions <= exists.runLimit)) then
							exists.Executions = exists.Executions+1
							return exists.Source, exists.Loadstring
						end

						local data = Core.ExecutePermission(getfenv(2).script,code)
						if data and data.Source then
							local module;
							if not exists then
								module = require(Deps.Loadstring.Rerubi:Clone())
								table.insert(Core.ScriptCache,{
									Script = getfenv(2).script;
									Source = data.Source;
									Loadstring = module;
									noCache = data.noCache;
									runLimit = data.runLimit;
									Executions = data.Executions;
								})
							else
								module = exists.Loadstring
								exists.Source = data.Source
							end
							return data.Source, module
						end
					end;

					ReportLBI = function(scr, origin)
						if origin == "Server" then
							return true
						end
					end;
				}, nil, nil, true);

				CheckAdmin = service.MetaFunc(Admin.CheckAdmin);

				CheckDonor = service.MetaFunc(Admin.CheckDonor);

				GetLevel = service.MetaFunc(Admin.GetLevel);

				CheckAgent = service.MetaFunc(HTTP.Trello.CheckAgent);

				SetLighting = service.MetaFunc(Functions.SetLighting);

				SetPlayerLighting = service.MetaFunc(Remote.SetLighting);

				NewParticle = service.MetaFunc(Functions.NewParticle);

				RemoveParticle = service.MetaFunc(Functions.RemoveParticle);

				NewLocal = service.MetaFunc(Remote.NewLocal);

				MakeLocal = service.MetaFunc(Remote.MakeLocal);

				MoveLocal = service.MetaFunc(Remote.MoveLocal);

				RemoveLocal = service.MetaFunc(Remote.RemoveLocal);

				Hint = service.MetaFunc(Functions.Hint);

				Message = service.MetaFunc(Functions.Message);
			}

			local AdonisGTable = service.NewProxy({
				__index = function(tab,ind)
					if Settings.G_API then
						return API[ind]
					elseif ind == "Scripts" then
						return API.Scripts
					else
						error("_G API is disabled")
					end
				end;
				__newindex = function(tabl,ind,new)
					error("Read-only")
				end;
				__metatable = true;
			})

			if not _G.Adonis then
				rawset(_G,"Adonis",AdonisGTable)
				Routine(service.StartLoop,"APICheck",1,function()
					rawset(_G,"Adonis",AdonisGTable)
				end)
			end

			Logs.AddLog(Logs.Script,{
				Text = "Started _G API";
				Desc = "_G API was initialized and is ready to use";
			})

		end;
	};
end


Prompt:
--print("Front"..autoF-1)
--print("Back"..autoR)

Response:
if autoF - 2 > autoR then
	shf = false
else
	if math.abs(orderch - 50) < speed then
		shf = true
	else
		if carSeat.Storage.Mode.Value ~= "Snow" then
		shf = false
		end
	end
end

if autoF - 1 > autoR and script.Parent.Storage.TransmissionType.Value == "HPattern" and currentgear.Value <= 3 then
	if speed < 20 then
		if clutch.Clutch.Value > 0.3 and clutch.Clutch.Value < 0.6 and script.Parent.Storage.Throttle.Throttle.Value > 0.2 then
			script.Parent.Functions.Clutch.Value = 0.0001
			script.Parent.Functions.Clutch.Override.Value = true script.Parent.Functions.Clutch.Freeze.Value = true
		 else script.Parent.Functions.Clutch.Override.Value = false script.Parent.Functions.Clutch.Freeze.Value = false end
	 else script.Parent.Functions.Clutch.Override.Value = false script.Parent.Functions.Clutch.Freeze.Value = false end
 else script.Parent.Functions.Clutch.Override.Value = false script.Parent.Functions.Clutch.Freeze.Value = false end


Prompt:
--local Equip = Humanoid:LoadAnimation(AnimationsFolder.equip)
--local Hold = Humanoid:LoadAnimation(AnimationsFolder.idle)
--local Unlock1 = Humanoid:LoadAnimation(AnimationsFolder.use)
--local Unlock2 = Humanoid:LoadAnimation(AnimationsFolder.usefinish)

Response: script.Parent.Equipped:Connect(function()


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

Response:
if game:GetService("ReplicatedStorage"):WaitForChild("GameData"):WaitForChild("InGame").Value == true then
	require(script:WaitForChild("Main_Game"));
	return;
end;
require(script:WaitForChild("Main_Lobby"));


Prompt:
-- ================================================================================
-- LOCAL FUNCTIONS
-- ================================================================================

Response:
local function statusChanged()
	local raceStatus = RaceManager:GetRaceStatus()

	-- Hide GUI when round is in session and player is a speeder
	if raceStatus == RaceManager.Status.RoundInProgress then
		CheckpointFrame.Visible = true
	else
		CheckpointFrame.Visible = false
	end
end -- statusChanged()


Prompt: -- RemoteEvent

Response:
local Events = ReplicatedStorage:FindFirstChild("Events")
local AddActivePlayer = Events:FindFirstChild("AddActivePlayer")
local RemoveActivePlayer = Events:FindFirstChild("RemoveActivePlayer")
local DisplayRoundResult = Events:FindFirstChild("DisplayRoundResult")
local CheckpointEvent = Events:FindFirstChild("CheckpointEvent")


Prompt: --		child.C0 = CFrame.new(0,-0.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0) --// Reposition player

Response:
		if child.Part1.Name == "HumanoidRootPart" then
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and (not player.PlayerGui:FindFirstChild("Screen")) then --// The part after the "and" prevents multiple GUI's to be copied over.
				GUI.CarSeat.Value = script.Parent --// Puts a reference of the seat in this ObjectValue, now you can use this ObjectValue's value to find the car directly.
				GUI:Clone().Parent = player.PlayerGui --// Compact version
				script.Parent.Occupied.Value = true
				script.Parent.Parent.Misc.FL.Mirror.SS.Motor.DesiredAngle = 0
               script.Parent.Parent.Misc.FR.Mirror.SS.Motor.DesiredAngle = 0
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = true
				script.Parent.Parent.Body.Dash.DashSc.G.Enabled = true
				script.Parent.Parent.Body.Dash.DashSc2.G.Enabled = true
				if script.Parent.L.Value == true then
					if player.Name == script.Parent.Parent.Owner.Value then
						script.Parent.L.Value = false
					else
						wait()
						script.Parent.Disabled = true
						wait()
						script.Parent.Disabled = false
					end
				end
			end
		end
	end
end)

script.Parent.ChildRemoved:connect(function(child)
	if child:IsA("Weld") then
		if child.Part1.Name == "HumanoidRootPart" then
			game.Workspace.CurrentCamera.FieldOfView = 70
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and player.PlayerGui:FindFirstChild("SS3") then
				player.PlayerGui:FindFirstChild("SS3"):Destroy()
				script.Parent.Occupied.Value = false
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = false
					script.Parent.Parent.Body.Dash.DashSc.G.Enabled = false
					script.Parent.Parent.Body.Dash.DashSc2.G.Enabled = false

			end
		end
	end
end)


Prompt: --now, get to playing the music

Response:
local FadeoutTime = settings.MusicFadeoutTime

function PlaySound(sounddata)
	if sounddata == nil then return end
	local sound = Instance.new("Sound")
	sound.Looped = true
	sound.SoundId = sounddata.SoundId
	sound.Volume = musicon and sounddata.Volume or 0
	local v = Instance.new("NumberValue",sound)
	v.Name = "OriginalVolume"
	v.Value = sounddata.Volume
	sound.Pitch = sounddata.Pitch
	sound.Name = "BGM"
	sound.Parent = script
	sound:Play()
end

function FadeOutSound(sound)
	local basevol = sound.Volume
	local count = math.ceil(30*FadeoutTime)
	if count < 1 then
		count = 1
	end
	for i=1,count do
		if sound then
			sound.Volume = sound.Volume - (basevol / count)
			wait(1/30)
		end
	end
	if sound then
		sound:Stop()
		sound:Destroy()
	end
end

if settings.UseGlobalBackgroundMusic == true and settings.UseMusicZones == false then
	if #music[globali] == 1 then --global BGM with just 1 song? ez pz
		PlaySound(music[1][1])
		return
	elseif #music[globali] == 0 then --there's no music to play...?
		return
	end
end

local recentindices = {} --keeps track of recently selected indicies, so as not to play repeat music tracks
math.randomseed(tick())
local currentzone
local zoneplayingmusic

function CheckIfRecent(i)
	for _,v in pairs(recentindices) do
		if v == i then
			return true
		end
	end
	return false
end

function SelectRandomMusic(musiclist) --select a random number, excluding ones that were already used recently
	if musiclist == nil or #musiclist == 0 then return end
	local possiblenumbers = {}
	local selectedindex
	for i=1,#musiclist do
		if not CheckIfRecent(i) then
			table.insert(possiblenumbers,i)
		end
	end
	local selectedindex = possiblenumbers[math.random(1,#possiblenumbers)]
	table.insert(recentindices,selectedindex)
	if #recentindices > math.ceil(#musiclist / 2) then
		table.remove(recentindices,1)
	end
	return musiclist[selectedindex]
end

function IsInZone(zonedata)
	if torso and torso.Parent ~= nil then
		local p = torso.Position
		for _,data in pairs(zonedata["Parts"]) do
			if data["Coordinates"] then
				local t = data["Coordinates"]
				if (p.x > t.lx and p.x < t.mx and p.y > t.ly and p.y < t.my and p.z > t.lz and p.z < t.mz) then --is the character within all the coordinates of the zone?
					return true
				end
			elseif data["Part"] then --complex part? create a clone of the part and check if it's touching the character's torso
				local part = data["Part"]:clone()
				part.Anchored = true
				part.Parent = workspace.CurrentCamera or workspace
				part.CanCollide = true
				local touching = part:GetTouchingParts()
				part:Destroy()
				for _,v in pairs(touching) do
					if v == torso then
						return true
					end
				end
			end
		end
		return false
	end
end

function CalculateCurrentZone()
	local priority = -math.huge
	local oldzone = currentzone
	local selectedzone
	if currentzone then
		if IsInZone(currentzone) then
			selectedzone = currentzone
			priority = currentzone["Priority"]
		end
	end
	for _,zone in pairs(zones) do
		if zone["Priority"] > priority and IsInZone(zone) then
			priority = zone["Priority"]
			selectedzone = zone
		end
	end
	currentzone = selectedzone
	if currentzone ~= oldzone and (currentzone ~= nil or settings.UseGlobalBackgroundMusic == true) then
		recentindices = {}
	end
	return currentzone,oldzone
end

function RunCycle() --the main cycle which will continuously run, checking which zones (if any) the character is in and playing new music when necessary
	local bgm = script:FindFirstChild("BGM")
	if settings.UseMusicZones == true then
		local zone,oldzone = CalculateCurrentZone()
		if zone ~= oldzone and zone ~= zoneplayingmusic and bgm then
			if (zone == nil and (settings.UseGlobalBackgroundMusic == true or settings.MusicOnlyPlaysWithinZones == true)) or zone ~= nil then
				FadeOutSound(bgm)
				return
			end
		elseif zone and bgm == nil then
			PlaySound(SelectRandomMusic(zone["Music"]))
			zoneplayingmusic = zone
			return
		elseif zone == nil and oldzone and settings.MusicOnlyPlaysWithinZones == false and settings.UseGlobalBackgroundMusic == false and bgm == nil then
			PlaySound(SelectRandomMusic(oldzone["Music"]))
			zoneplayingmusic = oldzone
			return
		elseif zoneplayingmusic and settings.MusicOnlyPlaysWithinZones == false and settings.UseGlobalBackgroundMusic == false and bgm == nil then
			PlaySound(SelectRandomMusic(zoneplayingmusic["Music"]))
			return
		elseif settings.UseGlobalBackgroundMusic == true and bgm == nil then
			PlaySound(SelectRandomMusic(music[globali]))
			zoneplayingmusic = nil
			return
		end
	elseif bgm == nil and settings.UseGlobalBackgroundMusic == true then
		PlaySound(SelectRandomMusic(music[globali]))
		return
	end

	if bgm and (settings.UseGlobalBackgroundMusic == true and zoneplayingmusic == nil and #music[globali] > 1) or (zoneplayingmusic and #zoneplayingmusic["Music"] > 1) then
		local length = bgm.TimeLength
		local pos = bgm.TimePosition
		if length ~= 0 and length - pos < FadeoutTime + .5 then
			FadeOutSound(bgm)
		end
	end
end

while wait(.5) do
	RunCycle()
end


Prompt: -- Preload animations

Response:
function playAnimation(animName, transitionTime, humanoid)
	if (animName ~= currentAnim) then

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

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


Prompt: --Door Open and Close Sound

Response:
Door.Changed:connect(function()
if Door.Value == "Opening" then
Car.Platform.DO:Play()
return end
if Door.Value == "Closing" then
Car.Platform.DC:Play()
return end
end)


Prompt:
--DEBUG
--local function UnderObject(pos, l)
--	l = l or 120
--	-- raycast
--	local hit, position = Workspace:FindPartOnRayWithIgnoreList(Ray.new(pos, UpVec * l), ignoreList)
--	if hit then
--		return (hit.Transparency ~= 1 and not string.find(hit.Name, "Droplet") and not string.find(hit.Name, "Extrusion")) and true or UnderObject(position + UpVec, l - (pos - position).Magnitude)
--	else
--		return false
--	end
--end


Prompt:
-- Implements Javascript's `Array.prototype.every` as defined below
-- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every

Response:
return function<T, U>(t: Array<T>, callback: callbackFn<T> | callbackFnWithThisArg<T, U>, thisArg: U?): boolean
	if typeof(t) ~= "table" then
		error(string.format("Array.every called on %s", typeof(t)))
	end
	if typeof(callback) ~= "function" then
		error("callback is not a function")
	end

	local len = #t
	local k = 1

	while k <= len do
		local kValue = t[k]
		local testResult

		if kValue ~= nil then
			if thisArg ~= nil then
				testResult = (callback :: callbackFnWithThisArg<T, U>)(thisArg, kValue, k, t)
			else
				testResult = (callback :: callbackFn<T>)(kValue, k, t)
			end

			if not testResult then
				return false
			end
		end
		k += 1
	end
	return true
end


Prompt:
--[=[
	@interface EnumItem
	.Name string
	.Value number
	.EnumType EnumList
	@within EnumList
]=]

Response:
type EnumItem = {
	Name: string,
	Value: number,
	EnumType: any,
}

local LIST_KEY = newproxy()
local NAME_KEY = newproxy()

local function CreateEnumItem(name: string, value: number, enum: any): EnumItem
	local enumItem = {
		Name = name,
		Value = value,
		EnumType = enum,
	}
	table.freeze(enumItem)
	return enumItem
end


Prompt:
--[=[
	@within TableUtil
	@function Copy
	@param tbl table -- Table to copy
	@param deep boolean? -- Whether or not to perform a deep copy
	@return table

	Creates a copy of the given table. By default, a shallow copy is
	performed. For deep copies, a second boolean argument must be
	passed to the function.

	:::caution No cyclical references
	Deep copies are _not_ protected against cyclical references. Passing
	a table with cyclical references _and_ the `deep` parameter set to
	`true` will result in a stack-overflow.
]=]

Response:
local function Copy<T>(t: T, deep: boolean?): T
	if not deep then
		return (table.clone(t :: any) :: any) :: T
	end

	local function DeepCopy(tbl: { any })
		local tCopy = table.clone(tbl)
		for k, v in tCopy do
			if type(v) == "table" then
				tCopy[k] = DeepCopy(v)
			end
		end
		return tCopy
	end

	return DeepCopy(t :: any) :: T
end