Prompt:
-- local Madwork = _G.Madwork
--[[
{Madwork}

-[ProfileService]---------------------------------------
	(STANDALONE VERSION)
	DataStore profiles - universal session-locked savable table API

	Official documentation:
		https://madstudioroblox.github.io/ProfileService/

	DevForum discussion:
		https://devforum.roblox.com/t/ProfileService/667805

	WARNINGS FOR "Profile.Data" VALUES:
	 	! Do not create numeric tables with gaps - attempting to replicate such tables will result in an error;
		! Do not create mixed tables (some values indexed by number and others by string key), as only
		     the data indexed by number will be replicated.
		! Do not index tables by anything other than numbers and strings.
		! Do not reference Roblox Instances
		! Do not reference userdata (Vector3, Color3, CFrame...) - Serialize userdata before referencing
		! Do not reference functions

	WARNING: Calling ProfileStore:LoadProfileAsync() with a "profile_key" which wasn't released in the SAME SESSION will result
		in an error! If you want to "ProfileStore:LoadProfileAsync()" instead of using the already loaded profile, :Release()
		the old Profile object.

	Members:

		ProfileService.ServiceLocked         [bool]

		ProfileService.IssueSignal           [ScriptSignal] (error_message, profile_store_name, profile_key)
		ProfileService.CorruptionSignal      [ScriptSignal] (profile_store_name, profile_key)
		ProfileService.CriticalStateSignal   [ScriptSignal] (is_critical_state)

	Functions:

		ProfileService.GetProfileStore(profile_store_index, profile_template) --> [ProfileStore]
			profile_store_index   [string] -- DataStore name
			OR
			profile_store_index   [table]: -- Allows the developer to define more GlobalDataStore variables
				{
					Name = "StoreName", -- [string] -- DataStore name
					-- Optional arguments:
					Scope = "StoreScope", -- [string] -- DataStore scope
				}
			profile_template      [table] -- Profiles will default to given table (hard-copy) when no data was saved previously

		ProfileService.IsLive() --> [bool] -- (CAN YIELD!!!)
			-- Returns true if ProfileService is connected to live Roblox DataStores

	Members [ProfileStore]:

		ProfileStore.Mock   [ProfileStore] -- Reflection of ProfileStore methods, but the methods will use a mock DataStore

	Methods [ProfileStore]:

		ProfileStore:LoadProfileAsync(profile_key, not_released_handler) --> [Profile] or nil -- not_released_handler(place_id, game_job_id)
			profile_key            [string] -- DataStore key
			not_released_handler   nil or []: -- Defaults to "ForceLoad"
				[string] "ForceLoad" -- Force loads profile on first call
				OR
				[string] "Steal" -- Steals the profile ignoring it's session lock
				OR
				[function] (place_id, game_job_id) --> [string] "Repeat", "Cancel", "ForceLoad" or "Steal"
					place_id      [number] or nil
					game_job_id   [string] or nil

				-- not_released_handler [function] will be triggered in cases where the profile is not released by a session. This
				--	function may yield for as long as desirable and must return one of three string values:

						["Repeat"] - ProfileService will repeat the profile loading proccess and may trigger the release handler again
						["Cancel"] - ProfileStore:LoadProfileAsync() will immediately return nil
						["ForceLoad"] - ProfileService will repeat the profile loading call, but will return Profile object afterwards
							and release the profile for another session that has loaded the profile
						["Steal"] - The profile will usually be loaded immediately, ignoring an existing remote session lock and applying
							a session lock for this session.

		ProfileStore:GlobalUpdateProfileAsync(profile_key, update_handler) --> [GlobalUpdates] or nil
			-- Returns GlobalUpdates object if update was successful, otherwise returns nil
			profile_key      [string] -- DataStore key
			update_handler   [function] (global_updates [GlobalUpdates])

		ProfileStore:ViewProfileAsync(profile_key, version) --> [Profile] or nil
			-- Reads profile without requesting a session lock; Data will not be saved and profile doesn't need to be released
			profile_key   [string] -- DataStore key
			version       nil or [string] -- DataStore key version

		ProfileStore:ProfileVersionQuery(profile_key, sort_direction, min_date, max_date) --> [ProfileVersionQuery]
			profile_key      [string]
			sort_direction   nil or [Enum.SortDirection]
			min_date         nil or [DateTime]
			max_date         nil or [DateTime]

		ProfileStore:WipeProfileAsync(profile_key) --> is_wipe_successful [bool]
			-- Completely wipes out profile data from the DataStore / mock DataStore with no way to recover it.

		* Parameter description for "ProfileStore:GlobalUpdateProfileAsync()":

			profile_key      [string] -- DataStore key
			update_handler   [function] (GlobalUpdates) -- This function gains access to GlobalUpdates object methods
				(update_handler can't yield)

	Methods [ProfileVersionQuery]:

		ProfileVersionQuery:NextAsync() --> [Profile] or nil -- (Yields)
			-- Returned profile has the same rules as profile returned by :ViewProfileAsync()

	Members [Profile]:

		Profile.Data              [table] -- Writable table that gets saved automatically and once the profile is released
		Profile.MetaData          [table] (Read-only) -- Information about this profile

			Profile.MetaData.ProfileCreateTime   [number] (Read-only) -- os.time() timestamp of profile creation
			Profile.MetaData.SessionLoadCount    [number] (Read-only) -- Amount of times the profile was loaded
			Profile.MetaData.ActiveSession       [table] (Read-only) {place_id, game_job_id} / nil -- Set to a session link if a
				game session is currently having this profile loaded; nil if released
			Profile.MetaData.MetaTags            [table] {["tag_name"] = tag_value, ...} -- Saved and auto-saved just like Profile.Data
			Profile.MetaData.MetaTagsLatest      [table] (Read-only) -- Latest version of MetaData.MetaTags that was definetly saved to DataStore
				(You can use Profile.MetaData.MetaTagsLatest for product purchase save confirmation, but create a system to clear old tags after
				they pile up)

		Profile.MetaTagsUpdated   [ScriptSignal] (meta_tags_latest) -- Fires after every auto-save, after
			--	Profile.MetaData.MetaTagsLatest has been updated with the version that's guaranteed to be saved;
			--  .MetaTagsUpdated will fire regardless of whether .MetaTagsLatest changed after update;
			--	.MetaTagsUpdated may fire after the Profile is released - changes to Profile.Data are not saved
			--	after release.

		Profile.RobloxMetaData    [table] -- Writable table that gets saved automatically and once the profile is released
		Profile.UserIds           [table] -- (Read-only) -- {user_id [number], ...} -- User ids associated with this profile

		Profile.KeyInfo           [DataStoreKeyInfo]
		Profile.KeyInfoUpdated    [ScriptSignal] (key_info [DataStoreKeyInfo])

		Profile.GlobalUpdates     [GlobalUpdates]

	Methods [Profile]:

		-- SAFE METHODS - Will not error after profile expires:
		Profile:IsActive() --> [bool] -- Returns true while the profile is active and can be written to

		Profile:GetMetaTag(tag_name) --> value [any]
			tag_name   [string]

		Profile:Reconcile() -- Fills in missing (nil) [string_key] = [value] pairs to the Profile.Data structure

		Profile:ListenToRelease(listener) --> [ScriptConnection] (place_id / nil, game_job_id / nil)
			-- WARNING: Profiles can be released externally if another session force-loads
			--	this profile - use :ListenToRelease() to handle player leaving cleanup.

		Profile:Release() -- Call after the session has finished working with this profile
			e.g., after the player leaves (Profile object will become expired) (Does not yield)

		Profile:ListenToHopReady(listener) --> [ScriptConnection] () -- Passed listener will be executed after the releasing UpdateAsync call finishes;
			--	Wrap universe teleport requests with this method AFTER releasing the profile to improve session lock sharing between universe places;
			--  :ListenToHopReady() will usually call the listener in around a second, but may ocassionally take up to 7 seconds when a release happens
			--	next to an auto-update in regular usage scenarios.

		Profile:AddUserId(user_id) -- Associates user_id with profile (GDPR compliance)
			user_id   [number]

		Profile:RemoveUserId(user_id) -- Unassociates user_id with profile (safe function)
			user_id   [number]

		Profile:Identify() --> [string] -- Returns a string containing DataStore name, scope and key; Used for debug;
			-- Example return: "[Store:"GameData";Scope:"Live";Key:"Player_2312310"]"

		Profile:SetMetaTag(tag_name, value) -- Equivalent of Profile.MetaData.MetaTags[tag_name] = value
			tag_name   [string]
			value      [any]

		Profile:Save() -- Call to quickly progress global update state or to speed up save validation processes (Does not yield)

		-- VIEW-MODE ONLY:

		Profile:ClearGlobalUpdates() -- Clears all global updates data from a profile payload

		Profile:OverwriteAsync() -- (Yields) Saves the profile payload to the DataStore and removes the session lock

	Methods [GlobalUpdates]:

	-- ALWAYS PUBLIC:
		GlobalUpdates:GetActiveUpdates() --> [table] {{update_id, update_data [table]}, ...}
		GlobalUpdates:GetLockedUpdates() --> [table] {{update_id, update_data [table]}, ...}

	-- ONLY WHEN FROM "Profile.GlobalUpdates":
		GlobalUpdates:ListenToNewActiveUpdate(listener) --> [ScriptConnection] (update_id, update_data)
			update_data   [table]
		GlobalUpdates:ListenToNewLockedUpdate(listener) --> [ScriptConnection] (update_id, update_data)
			update_data   [table]
		GlobalUpdates:LockActiveUpdate(update_id)  -- WARNING: will error after profile expires
		GlobalUpdates:ClearLockedUpdate(update_id) -- WARNING: will error after profile expires

	-- EXPOSED TO "update_handler" DURING ProfileStore:GlobalUpdateProfileAsync() CALL
		GlobalUpdates:AddActiveUpdate(update_data)
			update_data   [table]
		GlobalUpdates:ChangeActiveUpdate(update_id, update_data)
			update_data   [table]
		GlobalUpdates:ClearActiveUpdate(update_id)

--]]

Response:
local SETTINGS = {

	AutoSaveProfiles = 30, -- Seconds (This value may vary - ProfileService will split the auto save load evenly in the given time)
	RobloxWriteCooldown = 7, -- Seconds between successive DataStore calls for the same key
	ForceLoadMaxSteps = 8, -- Steps taken before ForceLoad request steals the active session for a profile
	AssumeDeadSessionLock = 30 * 60, -- (seconds) If a profile hasn't been updated for 30 minutes, assume the session lock is dead
		-- As of writing, os.time() is not completely reliable, so we can only assume session locks are dead after a significant amount of time.

	IssueCountForCriticalState = 5, -- Issues to collect to announce critical state
	IssueLast = 120, -- Seconds
	CriticalStateLast = 120, -- Seconds

	MetaTagsUpdatedValues = { -- Technical stuff - do not alter
		ProfileCreateTime = true,
		SessionLoadCount = true,
		ActiveSession = true,
		ForceLoadSession = true,
		LastUpdate = true,
	},

}

local Madwork -- Standalone Madwork reference for portable version of ProfileService
do

	local MadworkScriptSignal = {}

	local FreeRunnerThread = nil

	local function AcquireRunnerThreadAndCallEventHandler(fn, ...)
		local acquired_runner_thread = FreeRunnerThread
		FreeRunnerThread = nil
		fn(...)
		FreeRunnerThread = acquired_runner_thread
	end

	local function RunEventHandlerInFreeThread(...)
		AcquireRunnerThreadAndCallEventHandler(...)
		while true do
			AcquireRunnerThreadAndCallEventHandler(coroutine.yield())
		end
	end

	-- ScriptConnection object:

	local ScriptConnection = {
		--[[
			_listener = listener,
			_script_signal = script_signal,
			_disconnect_listener = disconnect_listener,
			_disconnect_param = disconnect_param,

			_next = next_script_connection,
			_is_connected = is_connected,
		--]]
	}
	ScriptConnection.__index = ScriptConnection

	function ScriptConnection:Disconnect()

		if self._is_connected == false then
			return
		end

		self._is_connected = false
		self._script_signal._listener_count -= 1

		if self._script_signal._head == self then
			self._script_signal._head = self._next
		else
			local prev = self._script_signal._head
			while prev ~= nil and prev._next ~= self do
				prev = prev._next
			end
			if prev ~= nil then
				prev._next = self._next
			end
		end

		if self._disconnect_listener ~= nil then
			if not FreeRunnerThread then
				FreeRunnerThread = coroutine.create(RunEventHandlerInFreeThread)
			end
			task.spawn(FreeRunnerThread, self._disconnect_listener, self._disconnect_param)
			self._disconnect_listener = nil
		end

	end

	-- ScriptSignal object:

	local ScriptSignal = {
		--[[
			_head = nil,
			_listener_count = 0,
		--]]
	}
	ScriptSignal.__index = ScriptSignal

	function ScriptSignal:Connect(listener, disconnect_listener, disconnect_param) --> [ScriptConnection]

		local script_connection = {
			_listener = listener,
			_script_signal = self,
			_disconnect_listener = disconnect_listener,
			_disconnect_param = disconnect_param,

			_next = self._head,
			_is_connected = true,
		}
		setmetatable(script_connection, ScriptConnection)

		self._head = script_connection
		self._listener_count += 1

		return script_connection

	end

	function ScriptSignal:GetListenerCount() --> [number]
		return self._listener_count
	end

	function ScriptSignal:Fire(...)
		local item = self._head
		while item ~= nil do
			if item._is_connected == true then
				if not FreeRunnerThread then
					FreeRunnerThread = coroutine.create(RunEventHandlerInFreeThread)
				end
				task.spawn(FreeRunnerThread, item._listener, ...)
			end
			item = item._next
		end
	end

	function ScriptSignal:FireUntil(continue_callback, ...)
		local item = self._head
		while item ~= nil do
			if item._is_connected == true then
				item._listener(...)
				if continue_callback() ~= true then
					return
				end
			end
			item = item._next
		end
	end

	function MadworkScriptSignal.NewScriptSignal() --> [ScriptSignal]
		return {
			_head = nil,
			_listener_count = 0,
			Connect = ScriptSignal.Connect,
			GetListenerCount = ScriptSignal.GetListenerCount,
			Fire = ScriptSignal.Fire,
			FireUntil = ScriptSignal.FireUntil,
		}
	end

	-- Madwork framework namespace:

	Madwork = {
		NewScriptSignal = MadworkScriptSignal.NewScriptSignal,
		ConnectToOnClose = function(task, run_in_studio_mode)
			if game:GetService("RunService"):IsStudio() == false or run_in_studio_mode == true then
				game:BindToClose(task)
			end
		end,
	}

end


Prompt: --And it's done.  If there's anything wrong with this button, PM me.


Prompt:
--[[
	Called when the goal state changes value; this will initiate a new tween.
	Returns false as the current value doesn't change right away.
]]

Response:
function class:update(): boolean
	local goalValue = self._goalState:get(false)

	-- if the goal hasn't changed, then this is a TweenInfo change.
	-- in that case, if we're not currently animating, we can skip everything
	if goalValue == self._nextValue and not self._currentlyAnimating then
		return false
	end

	local tweenInfo = self._tweenInfo
	if self._tweenInfoIsState then
		tweenInfo = tweenInfo:get()
	end

	-- if we receive a bad TweenInfo, then error and stop the update
	if typeof(tweenInfo) ~= "TweenInfo" then
		logErrorNonFatal("mistypedTweenInfo", nil, typeof(tweenInfo))
		return false
	end

	self._prevValue = self._currentValue
	self._nextValue = goalValue

	self._currentTweenStartTime = os.clock()
	self._currentTweenInfo = tweenInfo

	local tweenDuration = tweenInfo.DelayTime + tweenInfo.Time
	if tweenInfo.Reverses then
		tweenDuration += tweenInfo.Time
	end
	tweenDuration *= tweenInfo.RepeatCount + 1
	self._currentTweenDuration = tweenDuration

	-- start animating this tween
	TweenScheduler.add(self)

	return false
end

local function Tween<T>(
	goalState: PubTypes.StateObject<PubTypes.Animatable>,
	tweenInfo: PubTypes.CanBeState<TweenInfo>?
): Types.Tween<T>
	local currentValue = goalState:get(false)

	-- apply defaults for tween info
	if tweenInfo == nil then
		tweenInfo = TweenInfo.new()
	end

	local dependencySet = {[goalState] = true}
	local tweenInfoIsState = xtypeof(tweenInfo) == "State"

	if tweenInfoIsState then
		dependencySet[tweenInfo] = true
	end

	local startingTweenInfo = tweenInfo
	if tweenInfoIsState then
		startingTweenInfo = startingTweenInfo:get()
	end

	-- If we start with a bad TweenInfo, then we don't want to construct a Tween
	if typeof(startingTweenInfo) ~= "TweenInfo" then
		logError("mistypedTweenInfo", nil, typeof(startingTweenInfo))
	end

	local self = setmetatable({
		type = "State",
		kind = "Tween",
		dependencySet = dependencySet,
		-- if we held strong references to the dependents, then they wouldn't be
		-- able to get garbage collected when they fall out of scope
		dependentSet = setmetatable({}, WEAK_KEYS_METATABLE),
		_goalState = goalState,
		_tweenInfo = tweenInfo,
		_tweenInfoIsState = tweenInfoIsState,

		_prevValue = currentValue,
		_nextValue = currentValue,
		_currentValue = currentValue,

		-- store current tween into separately from 'real' tween into, so it
		-- isn't affected by :setTweenInfo() until next change
		_currentTweenInfo = tweenInfo,
		_currentTweenDuration = 0,
		_currentTweenStartTime = 0,
		_currentlyAnimating = false
	}, CLASS_METATABLE)

	initDependency(self)
	-- add this object to the goal state's dependent set
	goalState.dependentSet[self] = true

	return self
end

return Tween


Prompt:
--!strict
--[=[
	@function reduce
	@within Array

	@param array {T} -- The array to reduce.
	@param reducer (accumulator: U, value: T, index: number, array: {T}) -> U -- The reducer to use.
	@param initialReduction? U = {T}[1] -- The initial accumulator value.
	@return U -- The final accumulator value.

	Reduces the array using the given reducer and initial accumulator value.
	If no `initialReduction` value is given, the first item in the array is used.

	```lua
	local array = { 1, 2, 3 }

	local value = Reduce(array, function(accumulator, item, index)
		return accumulator - item
	end) -- -4

	local value = Reduce(array, function(accumulator, item, index)
		table.insert(accumulator, item)
		return accumulator
	end, {}) -- { 1, 2, 3 }
	```
]=]

Response:
local function reduce<T, U>(
	array: { T },
	reducer: (accumulator: U, value: T, index: number, array: { T }) -> U,
	initReduction: U?
): U
	local result = initReduction
	local start = 1

	if result == nil then
		result = array[1]
		start = 2
	end

	for index = start, #array do
		result = reducer(result, array[index], index, array)
	end

	return result
end

return reduce


Prompt: --	mouse.Icon = "rbxasset://textures\\GunCursor.png"

Response:
	while true do
		wait()
	end
end

function onUnequippedLocal(mouse)

end

function Equip(mouse)
wait(0.01)
tool.GripPos=Vector3.new(0,0,0)
arms = {tool.Parent:FindFirstChild("Left Arm"), tool.Parent:FindFirstChild("Right Arm")}
torso = tool.Parent:FindFirstChild("Torso")
if arms ~= nil and torso ~= nil then
local sh = {torso:FindFirstChild("Left Shoulder"), torso:FindFirstChild("Right Shoulder")}
if sh ~= nil then
local yes = true
if yes then
yes = false
sh[1].Part1 = nil
sh[2].Part1 = nil
local weld1 = Instance.new("Weld") -- left arm
weld55 = weld1
weld1.Part0 = torso
weld1.Parent = torso
weld1.Part1 = arms[1]
weld1.C1 = f(-1.12,0.3,-0.84,75,-4,15)
welds[1] = weld1
local weld2 = Instance.new("Weld") -- right arm
weld33 = weld2
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = f(0.1,0.17,-1.14,72,2,-52)
welds[2] = weld2
local weld3 = Instance.new("Weld") -- right arm
weld77 = weld3
weld3.Part0 = torso
weld3.Parent = torso
weld3.Part1 = tool.Handle
weld3.C1 = f(-0.76,1.93,-1.73,5,-90,0)
welds[3] = weld2
end
else
end
else
end
end

function Unequip(mouse)
if arms ~= nil and torso ~= nil then
local sh = {torso:FindFirstChild("Left Shoulder"), torso:FindFirstChild("Right Shoulder")}
if sh ~= nil then
local yes = true
if yes then
yes = false
sh[1].Part1 = arms[1]
sh[2].Part1 = arms[2]
welds[1].Parent = nil
welds[2].Parent = nil
end
else
end
else
end
end

tool.Unequipped:connect(onUnequippedLocal)

tool.Equipped:connect(onEquippedLocal)
tool.Equipped:connect(Equip)
tool.Unequipped:connect(Unequip)


Prompt: --//services//--

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


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, TAG_TIMER)
	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)
	-- print("sword attack - ",Hit.Parent.Name)
	local tmp = Hit.Parent:FindFirstChild("Owner")
	if tmp ~= nil then -- по постройкам не бьём
		return
	end

	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)
	modDamage:Take(Humanoid, humanoid,Damage) -- from, to, 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

	wait(0.2)
	Tool.Grip = Grips.Out
	wait(0.6)
	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.5)
	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: -- Set up item list

Response:
function MakeList()
	itemList:ClearAllChildren()
	local buttonsPerPage = 10
	local items = {}
	local sorted = {}
	for _,item in pairs(players.LocalPlayer.Backpack:GetChildren()) do -- sort by price in ascending order
		if item:FindFirstChild("Price") then
			table.insert(items, item)
			local positionToInsertAt = 1
			for i,sortItem in pairs(sorted) do
				if replicatedStorage.Items[sortItem].Price.Value < replicatedStorage.Items[item.Name].Price.Value then
					positionToInsertAt = i + 1
				end
			end
			table.insert(sorted, positionToInsertAt, item.Name)
		end
	end
	local amount = math.clamp(#items, buttonsPerPage, math.huge)
	local button = script:WaitForChild("ItemButton")
	itemList.CanvasSize = UDim2.new(0, 0, itemList.Size.Y.Scale + (itemList.Size.Y.Scale * (1 / buttonsPerPage) * (amount - buttonsPerPage)), 0)
	for i,item in pairs(sorted) do
		local newButton = button:Clone()
		if i % 2 == 0 then
			newButton.BackgroundColor3 = Color3.fromRGB(82, 76, 115)
		else
			newButton.BackgroundColor3 = Color3.fromRGB(99, 119, 148)
		end
		newButton.Text = item
		newButton.Size = UDim2.new(1, -15, 1 / amount, 0)
		newButton.Position = UDim2.new(0, 0, (i - 1) * (1 / amount), 0)
		newButton.Parent = itemList
		newButton.MouseButton1Click:Connect(function()
			SelectItem(item)
		end)
		if i == 1 then
			SelectItem(item)
		end
	end
	if #sorted == 0 then
		itemNameLabel.Text = "No items to sell"
		price.Text = ""
		itemInfo.Text = ""
	end
end

script.Parent:WaitForChild("Close").MouseButton1Click:Connect(function()
	require(switchMenu)()
end)

script.Parent:WaitForChild("Sell").MouseButton1Click:Connect(function()
	if sellCooldown == false then
		sellCooldown = true
		require(playSoundEffect)("Coins")
		workspace.Remotes.SellItem:InvokeServer(itemNameLabel.Text) -- Uses RemoteFunction to yield until action is complete
		MakeList()
		sellCooldown = false
	end
end)

script.Parent:GetPropertyChangedSignal("Visible"):Connect(function()
	if script.Parent.Visible == true then
		MakeList()
	end
end)


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

Response:
local FFlagUserHandleChatHotKeyWithContextActionService = false do
	local ok, value = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserHandleChatHotKeyWithContextActionService")
	end)
	if ok then
		FFlagUserHandleChatHotKeyWithContextActionService = value
	end
end

local FILTER_MESSAGE_TIMEOUT = 60

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

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

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

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

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


Prompt: --[ LOCALS ]--

Response: local ReplicatedStorageEvent = game.ReplicatedStorage:WaitForChild("AFK")


Prompt: --// Handling Settings

Response:
	Firerate = 60 / 180; -- 60 = 1 Minute, 180 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!

	FireMode = 5; -- 5 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive


Prompt: --// Math

Response:
local L_118_ = function(L_155_arg1, L_156_arg2, L_157_arg3)
	if L_155_arg1 > L_157_arg3 then
		return L_157_arg3
	elseif L_155_arg1 < L_156_arg2 then
		return L_156_arg2
	end
	return L_155_arg1
end

local L_119_ = L_107_.new(Vector3.new())
L_119_.s = 30
L_119_.d = 0.55

local L_120_ = CFrame.Angles(0, 0, 0)


Prompt:
--[[
	Shorthand for an andThen handler that returns the given value.
]]

Response:
function Promise.prototype:andThenReturn(...)
	local length, values = pack(...)
	return self:_andThen(debug.traceback(nil, 2), function()
		return unpack(values, 1, length)
	end)
end


Prompt: -- Nominal distance, set by dollying in and out with the mouse wheel or equivalent, not measured distance

Response:
function VRBaseCamera:GetCameraToSubjectDistance(): number
	return self.currentSubjectDistance
end


Prompt:
--[[
	Fired when PostGame is entered, throwing out a player state update, as well as transitioning the player state
]]

Response:
function Transitions.onEnterPostGame(stateMachine, event, from, to, playerComponent)
	Logger.trace(playerComponent.player.Name, " state change: ", from, " -> ", to)
	playerComponent:updateStatus("currentState", to)
	PlayerPostGame.enter(stateMachine, playerComponent)
end


Prompt: --[[Misc]]

Response:
	Tune.LoadDelay		= 3.0		-- Delay before initializing chassis (in seconds)
	Tune.AutoStart		= true		-- Set to false if using manual ignition plugin
	Tune.AutoFlip		= true		-- Set to false if using manual flip plugin
	Tune.AutoUpdate		= true		-- Automatically applies minor updates to the chassis if any are found.
									-- Will NOT apply major updates, but will notify you of any.
									-- Set to false to mute notifications, or if using modified Drive.


Prompt: -- вертикальный вектор

Response:
function module.lookAtY(target, eye)
    local forwardVector = (eye - target)
    local upVector = Vector3.new(0, 1, 0)
    -- You have to remember the right hand rule or google search to get this right
    local rightVector = forwardVector:Cross(upVector)
    local upVector2 = rightVector:Cross(forwardVector)
    return CFrame.fromMatrix(eye, -rightVector, upVector2) -- upVector2 - для вертикали
end

function computeDirection(vec)
	local lenSquared = vec.magnitude * vec.magnitude
	local invSqrt = 1 / math.sqrt(lenSquared)
	return Vector3.new(vec.x * invSqrt, vec.y * invSqrt, vec.z * invSqrt)
end

local Rocket = Instance.new("Part")
Rocket.Locked = true
Rocket.Size = Vector3.new(1,1,1)
Rocket.Shape = Enum.PartType.Ball
Rocket.Color = Color3.fromRGB(0,0,0)
Rocket.CanCollide=false


Prompt: --[[ Roblox Services ]]

Response:
--
local UserInputService = game:GetService("UserInputService")
local ContextActionService = game:GetService("ContextActionService")


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 180		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 1000		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 8000
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 9.4
	Tune.CurveMult		= 0.13

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

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


Prompt: -- modules

Response:
local module	= {}

function module.Create(self, item)
	local itemModule	= {
		Item		= item;
		Equipped	= false;
		Connections	= {};
	}

	-- variables

	local animations	= {}

	local character	= item.Parent.Parent
	local handle	= item:WaitForChild("Handle")
	local muzzle	= handle:WaitForChild("Muzzle")

	local config	= CONFIG:GetConfig(item)

	local ammo			= item:WaitForChild("Ammo").Value
	local reloading		= false
	local rCancelled	= false

	-- functions

	local function Reload()
		if (not reloading) and itemModule.Equipped and ammo < config.Magazine then
			reloading	= true
			rCancelled	= false

			local storedAmmo	= character.Ammo[config.Size].Value
			if storedAmmo > 0 then
				MOUSE.Reticle	= "Reloading"
				REMOTES.Reload:FireServer(item)
				EFFECTS:Effect("Reload", item)
				animations.Reload:Play(0.1, 1, 1/config.ReloadTime)

				local start		= tick()
				local elapsed	= 0
				repeat
					elapsed	= tick() - start
					RunService.Stepped:wait()
				until elapsed >= config.ReloadTime or rCancelled or (not itemModule.Equipped)

				animations.Reload:Stop()

				if itemModule.Equipped then
					if elapsed >= config.ReloadTime then
						local magazine	= config.Magazine
						local needed	= magazine - ammo

						if storedAmmo >= needed then
							ammo	= ammo + needed
						else
							ammo	= ammo + storedAmmo
						end
					end

					MOUSE.Reticle	= config.Reticle or "Gun"
					EVENTS.Gun:Fire("Update", ammo)
				end
			end
			reloading	= false
		end
	end

	-- module functions

	function itemModule.Connect(self)
		local character		= PLAYER.Character
		local humanoid		= character:WaitForChild("Humanoid")

		for _, animation in pairs(self.Item:WaitForChild("Animations"):GetChildren()) do
			animations[animation.Name]	= humanoid:LoadAnimation(animation)
		end

		table.insert(self.Connections, INPUT.ActionBegan:connect(function(action, processed)
			if self.Equipped and (not processed) then
				if action == "Reload" then
					Reload()
				end
			end
		end))

		table.insert(self.Connections, item.Attachments.ChildAdded:connect(function()
			config	= CONFIG:GetConfig(item)
			EVENTS.Zoom:Fire(config.Zoom)
			EVENTS.Scope:Fire(config.Scope)
		end))

		table.insert(self.Connections, item.Attachments.ChildRemoved:connect(function()
			config	= CONFIG:GetConfig(item)
			EVENTS.Zoom:Fire(config.Zoom)
			EVENTS.Scope:Fire(config.Scope)
		end))
	end

	function itemModule.Disconnect(self)
		for _, connection in pairs(self.Connections) do
			connection:Disconnect()
		end
		self.Connections	= {}
	end

	function itemModule.Equip(self)
		self.Equipped	= true
		EVENTS.Zoom:Fire(config.Zoom)
		EVENTS.Scope:Fire(config.Scope)
		MOUSE.Reticle	= config.Reticle or "Gun"
		animations.Idle:Play()
		animations.Equip:Play(0, 1, 1)

		ammo	= item.Ammo.Value

		EVENTS.Gun:Fire("Enable", config.Size, ammo)

		if ammo == 0 then
			spawn(function()
				Reload()
			end)
		end
	end

	function itemModule.Unequip(self)
		self.Equipped	= false

		EVENTS.Zoom:Fire()
		EVENTS.Scope:Fire(false)
		MOUSE.Reticle	= "Default"

		for _, animation in pairs(animations) do
			animation:Stop()
		end

		EVENTS.Gun:Fire("Disable")
	end

	function itemModule.Activate(self)
		if ammo > 0 then
			ammo	= ammo - 1

			local direction		= (MOUSE.WorldPosition - muzzle.WorldPosition).Unit
			local projectileID	= EVENTS.GetProjectileID:Invoke()

			EVENTS.Projectile:Fire(PLAYER, item, projectileID, muzzle.WorldPosition, direction)
			REMOTES.RocketLauncher:FireServer(item, "Fire", projectileID, muzzle.WorldPosition, direction)

			animations.Shoot:Play(0, 1, 1)
			EVENTS.Recoil:Fire(Vector3.new(math.random(-config.Recoil, config.Recoil) / 4, 0, math.random(config.Recoil / 2, config.Recoil)))
			EFFECTS:Effect("RocketLauncher", item, "Fire")

			EVENTS.Gun:Fire("Update", ammo)

			wait(0.4)

			Reload()
		end
	end

	function itemModule.Deactivate(self)

	end

	return itemModule
end

return module


Prompt: --[[Engine]]

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

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

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


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

Response:
local v1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
while not v1.Loaded do
	game:GetService("RunService").Heartbeat:Wait();
end;
local u1 = {};
local v13
local u2 = nil;
function Update()
	if u1 then

	else
		return;
	end;
	if not u2 then
		return;
	end;

	for v5, v6 in pairs(u2:GetChildren()) do
		if v5 then

		else
			break;
		end;
		local v7 = nil
		if v6.Name == "Energy Leaderboard" then
			v7 = u1["Energy"]
		else
			v7 = u1["Gems"]

		end
		if v7 then
			local v8 = v6:FindFirstChildOfClass("SurfaceGui");

			for v9, v10 in ipairs(v7) do
				if v9 then

				else
					break;
				end;
				local v12 = v8.Frame:FindFirstChild("Entry" .. v9);
				if not v12 then
					v12 = v1.Assets.UI.Leaderboard.Entry:Clone();
					v12.LayoutOrder = v9;
					v12.Rank.Text = "#" .. v9;
					v12.Name = "Entry" .. v9;
					if v9 <= 3 then
						v13 = 80;
					else
						v13 = 60;
					end;
					v12.Size = UDim2.new(1, 0, 0, v13);
					v12.Parent = v8.Frame;
				end;
				v12.Score.Text = v1.Functions.Format.Short(v10.loadvalue);
				v12.Username.Text = "@" .. v10.username;
				if v10.username == v1.LocalPlayer.Name then
					v12.Username.TextColor3 = Color3.fromRGB(28, 134, 173);
				else
					v12.Username.TextColor3 = Color3.fromRGB(218, 218, 218);
				end;
			end;
			v8.Frame.CanvasSize = UDim2.new(0, 0, 0, v8.Frame:FindFirstChildOfClass("UIListLayout").AbsoluteContentSize.Y);
		end;
	end;
end;
function Grab()
	local v14 = v1.Network.Invoke("Get Leaderboards");
	if v14 then
		u1 = v14;
		Update();
	end;
end;
function Check()
	local v15 = v1.WorldCmds.GetMap();
	if v15:FindFirstChild("Interactive") then

	else
		return;
	end;
	u2 = v15.Interactive:FindFirstChild("Leaderboards");
	if not u2 then
		return;
	end;
	Update();
end;
v1.Signal.Fired("World Changed"):Connect(function()
	u2 = nil;
	Check();
end);
coroutine.wrap(function()
	while true do
		Grab();
		wait(10);
	end;
end)();


Prompt:
-- js  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt
-- lua http://www.lua.org/manual/5.4/manual.html#pdf-utf8.codepoint

Response:
return function(str: string, index: number): number
	if type(index) ~= "number" then
		index = 1
	end
	--[[
		Initial bounds check. Checking string.len is not an exhaustive upper bound,
		but it is cheaper to check string.len and handle utf8.offset than to check
		utf.len, which iterates over all codepoints.
	]]
	local length = string.len(str)
	if index < 1 or index > length then
		return NaN
	end

	-- utf8.offset returns nil for out of bounds
	local offset = utf8.offset(str, index)

	-- check that offset is not greater than the length of the string
	if offset == nil or offset > length then
		return NaN
	end

	local value = utf8.codepoint(str, offset, offset)

	if value == nil then
		return NaN
	end

	return value
end


Prompt: --messageText = "Regening car, please wait..."--If you want a message to appear upon pressing, type it here.


Prompt:
--[[**
	ensures Roblox RBXScriptSignal type

	@param value The value to check against

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

Response: t.RBXScriptSignal = primitive("RBXScriptSignal")


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

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

math.randomseed(tick())

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

	-- check for config values
	local config = script:FindFirstChild(name)
	if (config ~= nil) then


Prompt: --// Renders

Response:
local L_155_

L_99_:connect(function()
	if L_15_ then
		L_150_, L_151_ = L_150_ or 0, L_151_ or 0
		if L_153_ == nil or L_152_ == nil then
			L_153_ = L_44_.C0
			L_152_ = L_44_.C1
		end

		local L_261_ = (math.sin(L_144_ * L_146_ / 2) * L_145_)
		local L_262_ = (math.sin(L_144_ * L_146_) * L_145_)
		local L_263_ = CFrame.new(L_261_, L_262_, 0.02)

		local L_264_ = (math.sin(L_140_ * L_143_ / 2) * L_142_)
		local L_265_ = (math.cos(L_140_ * L_143_) * L_142_)
		local L_266_ = CFrame.new(L_264_, L_265_, 0.02)

		if L_137_ then
			L_144_ = L_144_ + .017
			if L_24_.WalkAnimEnabled == true then
				L_138_ = L_263_
			else
				L_138_ = CFrame.new()
			end
		else
			L_144_ = 0
			L_138_ = CFrame.new()
		end

		L_136_.t = Vector3.new(L_131_, L_132_, 0)
		local L_267_ = L_136_.p
		local L_268_ = L_267_.X / L_133_ * (L_60_ and L_135_ or L_134_)
		local L_269_ = L_267_.Y / L_133_ * (L_60_ and L_135_ or L_134_)

		L_5_.CFrame = L_5_.CFrame:lerp(L_5_.CFrame * L_139_, 0.2)

		if L_60_ then
			L_127_ = CFrame.Angles(math.rad(-L_268_), math.rad(L_268_), math.rad(L_269_)) * CFrame.fromAxisAngle(Vector3.new(5, 0, -1), math.rad(L_268_))
			L_140_ = 0
			L_141_ = CFrame.new()
		elseif not L_60_ then
			L_127_ = CFrame.Angles(math.rad(-L_269_), math.rad(-L_268_), math.rad(-L_268_)) * CFrame.fromAxisAngle(L_43_.Position, math.rad(-L_269_))
			L_140_ = L_140_ + 0.017
			L_141_ = L_266_
		end

		if L_24_.SwayEnabled ==  true then
			L_44_.C0 = L_44_.C0:lerp(L_153_ * L_127_ * L_138_ * L_141_, 0.1)
		else
			L_44_.C0 = L_44_.C0:lerp(L_153_ * L_138_, 0.1)
		end

		if L_63_ and not L_66_ and L_68_ and not L_60_ and not L_62_ and not Shooting then
			L_44_.C1 = L_44_.C1:lerp(L_44_.C0 * L_24_.SprintPos, 0.1)
		elseif not L_63_ and not L_66_ and not L_68_ and not L_60_ and not L_62_ and not Shooting then
			L_44_.C1 = L_44_.C1:lerp(CFrame.new(), 0.1)
		end

		if L_60_ and not L_63_ then
			if not L_61_ then
				L_85_ = L_24_.AimCamRecoil
				L_84_ = L_24_.AimGunRecoil
				L_86_ = L_24_.AimKickback
			elseif L_61_ then
				if L_88_ == 1 then
					L_85_ = L_24_.AimCamRecoil / 1.5
					L_84_ = L_24_.AimGunRecoil / 1.5
					L_86_ = L_24_.AimKickback / 1.5
				end

				if L_88_ == 2 then
					L_85_ = L_24_.AimCamRecoil / 2
					L_84_ = L_24_.AimGunRecoil / 2
					L_86_ = L_24_.AimKickback / 2
				end
			end

			if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude < 2 then
				L_44_.C1 = L_44_.C1:lerp(L_44_.C0 * L_52_.CFrame:toObjectSpace(L_43_.CFrame), L_24_.AimSpeed)

				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = true
				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_50_
				L_100_.MouseDeltaSensitivity = L_50_
			end
		elseif not L_60_ and not L_63_ and L_15_ then
			if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude < 2 then
				L_44_.C1 = L_44_.C1:lerp(CFrame.new(), L_24_.UnaimSpeed)

				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = false
				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_50_
				L_100_.MouseDeltaSensitivity = L_51_
			end

			if not L_61_ then
				L_85_ = L_24_.camrecoil
				L_84_ = L_24_.gunrecoil
				L_86_ = L_24_.Kickback
			elseif L_61_ then
				if L_88_ == 1 then
					L_85_ = L_24_.camrecoil / 1.5
					L_84_ = L_24_.gunrecoil / 1.5
					L_86_ = L_24_.Kickback / 1.5
				end

				if L_88_ == 2 then
					L_85_ = L_24_.camrecoil / 2
					L_84_ = L_24_.gunrecoil / 2
					L_86_ = L_24_.Kickback / 2
				end
			end
		end

		if Recoiling then
			L_139_ = CFrame.Angles(L_85_, 0, 0)
			--cam.CoordinateFrame = cam.CoordinateFrame *  CFrame.fromEulerAnglesXYZ(math.rad(camrecoil*math.random(0,3)), math.rad(camrecoil*math.random(-1,1)), math.rad(camrecoil*math.random(-1,1)))
			L_44_.C0 = L_44_.C0:lerp(L_44_.C0 * CFrame.new(0, 0, L_84_) * CFrame.Angles(-math.rad(L_86_), 0, 0), 0.3)
		elseif not Recoiling then
			L_139_ = CFrame.Angles(0, 0, 0)
			L_44_.C0 = L_44_.C0:lerp(CFrame.new(), 0.2)
		end

		if L_61_ then
			L_3_:WaitForChild('Humanoid').Jump = false
		end

		if L_15_ then
			L_5_.FieldOfView = L_5_.FieldOfView * (1 - L_24_.ZoomSpeed) + (L_92_ * L_24_.ZoomSpeed)
			if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude >= 2 then
				L_85_ = L_24_.AimCamRecoil
				L_84_ = L_24_.AimGunRecoil
				L_86_ = L_24_.AimKickback

				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = true
				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_50_
				L_100_.MouseDeltaSensitivity = L_50_
			elseif (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude < 2 and not L_60_ and not L_61_ then
				L_85_ = L_24_.camrecoil
				L_84_ = L_24_.gunrecoil
				L_86_ = L_24_.Kickback

				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = false
				L_41_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_50_
				L_100_.MouseDeltaSensitivity = L_51_
			end
		end

		if L_15_ and L_24_.CameraGo then --and (char.Head.Position - cam.CoordinateFrame.p).magnitude < 2 then
			L_4_.TargetFilter = game.Workspace
			local L_270_ =  L_3_:WaitForChild("HumanoidRootPart").CFrame * CFrame.new(0, 1.5, 0) * CFrame.new(L_3_:WaitForChild("Humanoid").CameraOffset)
			L_47_.C0 = L_8_.CFrame:toObjectSpace(L_270_)
			L_47_.C1 = CFrame.Angles(-math.asin((L_4_.Hit.p - L_4_.Origin.p).unit.y), 0, 0)
			L_100_.MouseIconEnabled = false
		end

		if L_15_ and (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude >= 2 then
			if L_4_.Icon ~= "http://www.roblox.com/asset?id=" .. L_24_.TPSMouseIcon then
				L_4_.Icon = "http://www.roblox.com/asset?id=" .. L_24_.TPSMouseIcon
			end
			L_100_.MouseIconEnabled = true

			if L_3_:FindFirstChild('Right Arm') and L_3_:FindFirstChild('Left Arm') then
				L_3_['Right Arm'].LocalTransparencyModifier = 1
				L_3_['Left Arm'].LocalTransparencyModifier = 1
			end
		end;
	end
end)


Prompt: --// Services

Response:
local L_103_ = game:GetService('RunService').RenderStepped
local L_104_ = game:GetService('UserInputService')


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

Response:
local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
end)();
local v1 = {};
local u2 = {};
function v1.Debounce(p1, p2)
	if p2 == 0 then
		u2[p1] = nil;
		return false;
	end;
	if u2[p1] and tick() <= u2[p1] then
		return true;
	end;
	u2[p1] = tick() + p2;
	return false;
end;
function v1.CheckDebounce(p3)
	if u2[p3] and tick() <= u2[p3] then
		return true;
	end;
	return false;
end;
task.defer(function()
	while true do
		task.wait(10);
		for v2, v3 in pairs((u1.Functions.CloneTable(u2))) do
			if v3 < tick() - 10 then
				u2[v2] = nil;
			end;
		end;
	end;
end);
return v1;


Prompt: -- Function to handle sprinting and meter depletion

Response:
local function handleSprinting()
	humanoid.WalkSpeed = defaultWalkSpeed * (isSprinting and sprintSpeedMultiplier or 1)

	while isSprinting and meterV > 0 do
		meterV = meterV - 1
		if MeterLocation:FindFirstChild("Meter" .. meterV + 1) then
			MeterLocation["Meter" .. meterV + 1].ImageTransparency = 1
		end
		wait(1)
	end

	if meterV <= 0 then
		isSprinting = false
		humanoid.WalkSpeed = defaultWalkSpeed
	end
end


Prompt: --Listen to seat enter/exit

Response:
VehicleSeating.AddSeat(DriverSeat, onEnterSeat, onExitSeat)

for _, seat in ipairs(AdditionalSeats) do
	VehicleSeating.AddSeat(seat, onEnterSeat, onExitSeat)
end

local function playerAdded(player)
	local playerGui = player:WaitForChild("PlayerGui")

	if not playerGui:FindFirstChild("VehiclePromptScreenGui") then
		local screenGui = Instance.new("ScreenGui")
		screenGui.ResetOnSpawn = false
		screenGui.Name = "VehiclePromptScreenGui"
		screenGui.Parent = playerGui

		local newLocalVehiclePromptGui = Scripts.LocalVehiclePromptGui:Clone()
		newLocalVehiclePromptGui.CarValue.Value = TopModel
		newLocalVehiclePromptGui.Parent = screenGui
	end
end

Players.PlayerAdded:Connect(playerAdded)

for _, player in ipairs(Players:GetPlayers()) do
	playerAdded(player)
end


Prompt:
-- A complete function to extend reverse paths from (d - 1) to d changes.
-- Return true if a path overlaps forward path of d changes in its diagonal.

Response:
local function extendOverlappablePathsR(
	d: number,
	aStart: number,
	aEnd: number,
	bStart: number,
	bEnd: number,
	isCommon: IsCommon,
	aIndexesF: Indexes,
	iMaxF: number,
	aIndexesR: Indexes, -- update indexes in sequence a of paths in diagonals kR
	iMaxR: number,
	division: Division -- update prop values if return true
): boolean
	local bR = bEnd - aEnd -- bIndex = bR + aIndex - kR
	local aLength = aEnd - aStart
	local bLength = bEnd - bStart
	local baDeltaLength = bLength - aLength -- kR = kF + baDeltaLength

	-- Range of diagonals in which forward and reverse paths might overlap.
	local kMinOverlapR = baDeltaLength - d -- -d <= kF
	local kMaxOverlapR = baDeltaLength + d -- kF <= d

	local aIndexPrev1 = NOT_YET_SET -- prev value of [iR - 1] in next iteration

	-- Optimization: skip diagonals in which paths cannot ever overlap.
	local nR = d < iMaxR and d or iMaxR

	-- The diagonals kR = d - 2 * iR are odd when d is odd and even when d is even.
	local iR = 0
	local kR = d
	while iR <= nR do
		-- To get first point of path segment, move one change in reverse direction
		-- from last point of previous path segment in an adjacent diagonal.
		-- In first iteration when iR === 0 and kR === d always insert.
		-- In last possible iteration when iR === d and kR === -d always delete.
		-- ROBLOX FIXME? should the values inserted into aIndexesF be 1-based so we don't have to adjust in several places here?
		local insert = iR == 0 or (iR ~= d and aIndexesR[iR + 1] < aIndexPrev1)
		local aLastPrev = insert and aIndexesR[iR + 1] or aIndexPrev1
		local aFirst: number = insert and aLastPrev -- vertical to insert from b
			or aLastPrev - 1 -- horizontal to delete from a

		-- To get last point of path segment, move along diagonal of common items.
		local bFirst = bR + aFirst - kR
		local nCommonR = countCommonItemsR(aStart, aFirst - 1, bStart, bFirst - 1, isCommon)
		local aLast = aFirst - nCommonR

		aIndexPrev1 = aIndexesR[iR + 1]
		aIndexesR[iR + 1] = aLast

		if kMinOverlapR <= kR and kR <= kMaxOverlapR then
			-- Solve for iF of forward path with d changes in diagonal kR:
			-- kF = kR - baDeltaLength
			-- kF = 2 * iF - d
			local iF = (d + (kR - baDeltaLength)) / 2

			-- If this reverse path overlaps the forward path in this diagonal,
			-- then this is a middle change of the index intervals.
			if iF <= iMaxF and aLast - 1 <= aIndexesF[iF + 1] then
				local bLast = bFirst - nCommonR

				division.nChangePreceding = d
				if d == aLast + bLast - aStart - bStart then
					-- Optimization: number of changes in reverse direction
					-- is equal to number of items in preceding interval,
					-- therefore it cannot contain any common items.
					division.aEndPreceding = aStart
					division.bEndPreceding = bStart
				else
					division.aEndPreceding = aLast
					division.bEndPreceding = bLast
				end

				division.nCommonPreceding = nCommonR
				if nCommonR ~= 0 then
					-- The last point of reverse path segment is start of common subsequence.
					division.aCommonPreceding = aLast
					division.bCommonPreceding = bLast
				end

				division.nChangeFollowing = d - 1
				if d == 1 then
					-- There is no previous path segment.
					division.nCommonFollowing = 0
					division.aStartFollowing = aEnd
					division.bStartFollowing = bEnd
				else
					-- Unlike the Myers algorithm which finds only the middle “snake”
					-- this package can find two common subsequences per division.
					-- Last point of previous path segment is on an adjacent diagonal.
					local bLastPrev = bR + aLastPrev - (insert and kR - 1 or kR + 1)

					-- Because of invariant that intervals following the middle change
					-- cannot have common items at the start,
					-- move in forward direction along a diagonal of common items.
					local nCommonF = countCommonItemsF(aLastPrev, aEnd, bLastPrev, bEnd, isCommon)

					division.nCommonFollowing = nCommonF
					if nCommonF ~= 0 then
						-- The last point of reverse path segment is start of common subsequence.
						division.aCommonFollowing = aLastPrev
						division.bCommonFollowing = bLastPrev
					end

					local aStartFollowing = aLastPrev + nCommonF -- aFirstPrev
					local bStartFollowing = bLastPrev + nCommonF -- bFirstPrev

					if d - 1 == aEnd + bEnd - aStartFollowing - bStartFollowing then
						-- Optimization: number of changes in forward direction
						-- is equal to number of items in following interval,
						-- therefore it cannot contain any common items.
						division.aStartFollowing = aEnd
						division.bStartFollowing = bEnd
					else
						division.aStartFollowing = aStartFollowing
						division.bStartFollowing = bStartFollowing
					end
				end

				return true
			end
		end
		iR += 1
		kR -= 2
	end

	return false
end


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

Response:
function Transitions.onLeaveGame(stateMachine, event, from, to)
	ServerGame.leave(stateMachine)
end


Prompt:
-- waitChildren/EventFolder does not contain all the remote events, because the server version could be older than the client version.
-- In that case it would not create the new events.
-- These events are accessed directly from DefaultChatSystemChatEvents

Response:
local useEvents = {}

local FoundAllEventsEvent = Instance.new("BindableEvent")

function TryRemoveChildWithVerifyingIsCorrectType(child)
	if (waitChildren[child.Name] and child:IsA(waitChildren[child.Name])) then
		waitChildren[child.Name] = nil
		useEvents[child.Name] = child
		numChildrenRemaining = numChildrenRemaining - 1
	end
end

for i, child in pairs(EventFolder:GetChildren()) do
	TryRemoveChildWithVerifyingIsCorrectType(child)
end

if (numChildrenRemaining > 0) then
	local con = EventFolder.ChildAdded:connect(function(child)
		TryRemoveChildWithVerifyingIsCorrectType(child)
		if (numChildrenRemaining < 1) then
			FoundAllEventsEvent:Fire()
		end
	end)

	FoundAllEventsEvent.Event:wait()
	con:disconnect()

	FoundAllEventsEvent:Destroy()
end

EventFolder = useEvents


Prompt:
--[[**
	<description>
	Adds a backup to the data store if :Get() fails a specified amount of times.
	Will return the value provided (if the value is nil, then the default value of :Get() will be returned)
	and mark the data store as a backup store, and attempts to :Save() will not truly save.
	</description>

	<parameter name = "retries">
	Number of retries before the backup will be used.
	</parameter>

	<parameter name = "value">
	The value to return to :Get() in the case of a failure.
	You can keep this blank and the default value you provided with :Get() will be used instead.
	</parameter>
**--]]

Response:
function DataStore:SetBackup(retries, value)
	self.backupRetries = retries
	self.backupValue = value
end


Prompt: --!strict

Response:
local trimStart = require(script.Parent.trimStart)
local trimEnd = require(script.Parent.trimEnd)

return function(source: string): string
	return trimStart(trimEnd(source))
end


Prompt: --// Ammo Settings

Response:
	Ammo = 30;
	StoredAmmo = 30;
	MagCount = math.huge; --  If you want infinate ammo, set to math.huge EX. MagCount = math.huge;
	ExplosiveAmmo = 3;


Prompt:
-- Manually call OnTouched for parts the rocket might have spawned inside of
--TODO: Remove when Touched correctly fires for parts spawned within other parts

Response:
local partClone = Rocket:Clone()
partClone:ClearAllChildren()
partClone.Transparency = 1


Prompt: --Hidden Stash--

Response:
local function AttachParticleControl(source_part)

	local prtc = nil

	local function Start()
		prtc = script.Bux:clone()
		prtc.Parent = source_part
	end

	local function Update()

	end

	local function Stop()
		if prtc ~= nil then
			prtc:destroy()
			prtc = nil
		end
	end

	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachParticleControl


Prompt: --------------------[ MATH FUNCTIONS ]------------------------------------------------

Response:
function Map(Val, fromLow, fromHigh, toLow, toHigh)
	return (Val - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow
end

function numLerp(A, B, Alpha)
	return A + (B - A) * Alpha
end

function RAND(Min, Max, Accuracy)
	return numLerp(Min, Max, math.random())
	--[[local Inverse = 1 / (Accuracy or 1)
	return (math.random(Min * Inverse, Max * Inverse) / Inverse)]]
end

function Round(Num, toNearest)
	return math.floor(Num / toNearest + 0.5) * toNearest
end

function getNearestPoint(A, B, Origin)
	local A2 = (A - Origin).magnitude
	local B2 = (B - Origin).magnitude
	return (math.min(A2, B2) == A2 and A or B)
end


Prompt: -- Function to bind to touch moved if player is on mobile

Response:
local function mobileFrame(touch, processed)
	-- Check to see if the touch was on a UI element. If so, we don't want to update anything
	if not processed then
		-- Calculate touch position in world space. Uses Stravant's ScreenSpace Module script
		-- to create a ray from the camera.
		local test = screenSpace.ScreenToWorld(touch.Position.X, touch.Position.Y, 1)
		local nearPos = game.Workspace.CurrentCamera.CoordinateFrame:vectorToWorldSpace(screenSpace.ScreenToWorld(touch.Position.X, touch.Position.Y, 1))
		nearPos = game.Workspace.CurrentCamera.CoordinateFrame.p - nearPos
		local farPos = screenSpace.ScreenToWorld(touch.Position.X, touch.Position.Y,50)
		farPos = game.Workspace.CurrentCamera.CoordinateFrame:vectorToWorldSpace(farPos) * -1
		if farPos.magnitude > 900 then
			farPos = farPos.unit * 900
		end
		local ray = Ray.new(nearPos, farPos)
		local part, pos = game.Workspace:FindPartOnRay(ray, player.Character)

		-- if a position was found on the ray then update the character's rotation
		if pos then
			frame(pos)
		end
	end
end

local oldIcon = nil


Prompt:
-- Some cool functions idk
-- Andrew Bereza

Response:
local Utl = {}

function Utl.CurrentDay()
	return math.floor(os.time()/86400)
end

function Utl.GetPlayerData(PlayerId)
	local Module = game.ServerStorage.PlayerData:FindFirstChild(tostring(PlayerId))
	if Module then
		return require(Module)
	end
end

function Utl.NewPlayerData(Player, PlayerData)
	local Module = game.ServerStorage.PlayerData:FindFirstChild(tostring(Player.userId))
	if Module then
		Module:Destroy()
	end
	local NewModule = game.ServerStorage.PlayerDataTemplate:Clone()
	NewModule.Name = tostring(Player.userId)
	NewModule.Parent = game.ServerStorage.PlayerData
	local FreshTable = require(NewModule)
	for Key,Value in pairs(PlayerData) do
		FreshTable[Key] = Value
	end
end

function Utl.IntToBool(Int)
	return (Int == 1 and true) or false
end

function Utl.BoolToInt(Bool)
	return (Bool and 1) or 0
end

function Utl.GetTycoon(Player)
	for i,Tycoon in pairs(workspace.Tycoons:GetChildren()) do
		if Tycoon.Owner.Value == Player then
			return Tycoon
		end
	end
end

function Utl.GetEmptyTycoon()
	for i,Tycoon in pairs(workspace.Tycoons:GetChildren()) do
		if Tycoon.Owner.Value == nil then
			return Tycoon
		elseif Tycoon.Owner.Value.Parent ~= game.Players then
			Tycoon.Owner.Value = nil -- Clears it up for the next person
		end
	end
end

function Utl.CreateTag(Player, Name)
	if Player:FindFirstChild(Name) == nil then
		local Tag = Instance.new("BoolValue")
		Tag.Name = Name
		Tag.Parent = Player
	end
end

Utl.ShuttingDown = false

return Utl


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	= "RPM"												--[[
	[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 			-- 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 ]]		4   		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.7 		,
		--[[ 3 ]]		1.75	   	,
		--[[ 4 ]]		1.3    		,
		--[[ 5 ]]		0.9 		,
		--[[ 6 ]]		0.8	    	,
	}
	Tune.FDMult			= 1.0			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt: -- Resizes a model to the specified scale

Response:
local function scaleModel(model, scale)
	local primary = model.PrimaryPart
	local primaryCf = primary.CFrame

	for _,v in pairs(model:GetDescendants()) do
		if (v:IsA("BasePart")) then
			v.Size = (v.Size * scale)
			if (v ~= primary) then
				v.CFrame = (primaryCf + (primaryCf:inverse() * v.Position * scale))
			end
		end
	end

	return model
end


Prompt: -- << CHECK INITIALIZED >>

Response:
function main:CheckInitialized()
	if not main.initialized then
		script.Parent.Parent:WaitForChild("Signals"):WaitForChild("Initialized").Event:Wait()
	end
	return main
end


Prompt: -- functions

Response:
function onDied()
	sDied:Play()
	wait(2.5)
	script.Parent:Destroy()
end

function onState(state, sound)
	if state then
		sound:Play()
	else
		sound:Pause()
	end
end

function onRunning(speed)
	if speed>0 then
		sRunning:Play()
	else
		sRunning:Pause()
	end
end


Response:
elseif Clicking == false then
end
end)

Brightness.MouseButton1Down:Connect(function()
Clicking = true
end)
Brightness.MouseLeave:Connect(function()
Clicking = false
end)
Brightness.MouseButton1Up:Connect(function()
Clicking = false
end)
Brightness.Picker.MouseButton1Up:Connect(function()
Clicking = false
end)


Prompt: --[[Brakes]]

Response:
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS)

	Tune.FBrakeForce	= 1500		-- Front brake force
	Tune.RBrakeForce	= 1000		-- Rear brake force
	Tune.PBrakeForce	= 5000		-- Handbrake force

	Tune.FLgcyBForce	= 15000		-- Front brake force [PGS OFF]
	Tune.RLgcyBForce	= 10000		-- Rear brake force [PGS OFF]
	Tune.LgcyPBForce	= 25000		-- Handbrake force [PGS OFF]


Prompt:
--[[
	Constructs a new ForPairs object which maps pairs of a table using
	a `processor` function.

	Optionally, a `destructor` function can be specified for cleaning up values.
	If omitted, the default cleanup function will be used instead.

	Additionally, a `meta` table/value can optionally be returned to pass data created
	when running the processor to the destructor when the created object is cleaned up.
]]

Response:
local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)
local Types = require(Package.Types)
local captureDependencies = require(Package.Dependencies.captureDependencies)
local initDependency = require(Package.Dependencies.initDependency)
local useDependency = require(Package.Dependencies.useDependency)
local parseError = require(Package.Logging.parseError)
local logErrorNonFatal = require(Package.Logging.logErrorNonFatal)
local logError = require(Package.Logging.logError)
local logWarn = require(Package.Logging.logWarn)
local cleanup = require(Package.Utility.cleanup)
local needsDestruction = require(Package.Utility.needsDestruction)

local class = {}

local CLASS_METATABLE = { __index = class }
local WEAK_KEYS_METATABLE = { __mode = "k" }


Prompt: -- The maximum distance the can can shoot, this value should never go above 1000

Response: local Range = 400


Prompt: -- State: Wether or not the light is on

Response:
local work = script.Parent.Value
local status = script.Parent.Parent.Parent.On
local LED = script.Parent.Parent.LED

function onTouch()
	wait()
	status.Value = true
	LED.Material = "Glass"
	LED.BrickColor = BrickColor.new("Medium stone grey")
	wait(30)
	status.Value = false
	LED.Material = "Neon"
	LED.BrickColor = BrickColor.new("Forest green")
end

script.Parent.Touched:connect(onTouch)


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

Response:
local v1 = {};
local v2 = Vector2.new(0, 1);
local v3 = Vector2.new(0.1, 0.5);
local v4 = Vector2.new(-0.1, 0.5);
local l__TweenService__5 = game:GetService("TweenService");
local l__RunService__6 = game:GetService("RunService");
local l__Workspace__7 = game:GetService("Workspace");
local l__LocalPlayer__8 = game:GetService("Players").LocalPlayer;
local u1 = Vector2.new(1.5, 1.5);
local u2 = false;
local u3 = "rbxasset://textures/ui/traildot.png";
local u4 = UDim2.new(0, 42, 0, 50);
local u5 = Vector2.new(0, 0.5);
local u6 = "rbxasset://textures/ui/waypoint.png";
local u7 = Vector2.new(0, 0.5);
local function v9()
	local v10 = Instance.new("Part");
	v10.Size = Vector3.new(1, 1, 1);
	v10.Anchored = true;
	v10.CanCollide = false;
	v10.Name = "TrailDot";
	v10.Transparency = 1;
	local v11 = Instance.new("ImageHandleAdornment");
	v11.Name = "TrailDotImage";
	v11.Size = u1;
	v11.SizeRelativeOffset = Vector3.new(0, 0, -0.1);
	v11.AlwaysOnTop = u2;
	v11.Image = u3;
	v11.Adornee = v10;
	v11.Parent = v10;
	local v12 = Instance.new("Part");
	v12.Size = Vector3.new(2, 2, 2);
	v12.Anchored = true;
	v12.CanCollide = false;
	v12.Name = "EndWaypoint";
	v12.Transparency = 1;
	local v13 = Instance.new("ImageHandleAdornment");
	v13.Name = "TrailDotImage";
	v13.Size = u1;
	v13.SizeRelativeOffset = Vector3.new(0, 0, -0.1);
	v13.AlwaysOnTop = u2;
	v13.Image = u3;
	v13.Adornee = v12;
	v13.Parent = v12;
	local v14 = Instance.new("BillboardGui");
	v14.Name = "EndWaypointBillboard";
	v14.Size = u4;
	v14.LightInfluence = 0;
	v14.SizeOffset = u5;
	v14.AlwaysOnTop = true;
	v14.Adornee = v12;
	v14.Parent = v12;
	local v15 = Instance.new("ImageLabel");
	v15.Image = u6;
	v15.BackgroundTransparency = 1;
	v15.Size = UDim2.new(1, 0, 1, 0);
	v15.Parent = v14;
	local v16 = Instance.new("Part");
	v16.Size = Vector3.new(2, 2, 2);
	v16.Anchored = true;
	v16.CanCollide = false;
	v16.Name = "FailureWaypoint";
	v16.Transparency = 1;
	local v17 = Instance.new("ImageHandleAdornment");
	v17.Name = "TrailDotImage";
	v17.Size = u1;
	v17.SizeRelativeOffset = Vector3.new(0, 0, -0.1);
	v17.AlwaysOnTop = u2;
	v17.Image = u3;
	v17.Adornee = v16;
	v17.Parent = v16;
	local v18 = Instance.new("BillboardGui");
	v18.Name = "FailureWaypointBillboard";
	v18.Size = u4;
	v18.LightInfluence = 0;
	v18.SizeOffset = u7;
	v18.AlwaysOnTop = true;
	v18.Adornee = v16;
	v18.Parent = v16;
	local v19 = Instance.new("Frame");
	v19.BackgroundTransparency = 1;
	v19.Size = UDim2.new(0, 0, 0, 0);
	v19.Position = UDim2.new(0.5, 0, 1, 0);
	v19.Parent = v18;
	local v20 = Instance.new("ImageLabel");
	v20.Image = u6;
	v20.BackgroundTransparency = 1;
	v20.Position = UDim2.new(0, -u4.X.Offset / 2, 0, -u4.Y.Offset);
	v20.Size = u4;
	v20.Parent = v19;
	return v10, v12, v16;
end;
local v21, v22, v23 = v9();
local v24 = {};
v24.__index = v24;
function v24.Destroy(p1)
	p1.DisplayModel:Destroy();
end;
local u8 = v21;
local function u9(p2, p3)
	local v25, v26, v27 = l__Workspace__7:FindPartOnRayWithIgnoreList(Ray.new(p3 + Vector3.new(0, 2.5, 0), Vector3.new(0, -10, 0)), { l__Workspace__7.CurrentCamera, l__LocalPlayer__8.Character });
	if v25 then
		p2.CFrame = CFrame.new(v26, v26 + v27);
		local l__CurrentCamera__28 = l__Workspace__7.CurrentCamera;
		local v29 = l__CurrentCamera__28:FindFirstChild("ClickToMoveDisplay");
		if not v29 then
			v29 = Instance.new("Model");
			v29.Name = "ClickToMoveDisplay";
			v29.Parent = l__CurrentCamera__28;
		end;
		p2.Parent = v29;
	end;
end;
function v24.NewDisplayModel(p4, p5)
	local v30 = u8:Clone();
	u9(v30, p5);
	return v30;
end;
function v24.new(p6, p7)
	local v31 = setmetatable({}, v24);
	v31.DisplayModel = v31:NewDisplayModel(p6);
	v31.ClosestWayPoint = p7;
	return v31;
end;
local v32 = {};
v32.__index = v32;
function v32.Destroy(p8)
	p8.Destroyed = true;
	p8.Tween:Cancel();
	p8.DisplayModel:Destroy();
end;
local u10 = v22;
function v32.NewDisplayModel(p9, p10)
	local v33 = u10:Clone();
	u9(v33, p10);
	return v33;
end;
function v32.CreateTween(p11)
	local v34 = l__TweenService__5:Create(p11.DisplayModel.EndWaypointBillboard, TweenInfo.new(0.5, Enum.EasingStyle.Sine, Enum.EasingDirection.Out, -1, true), {
		SizeOffset = v2
	});
	v34:Play();
	return v34;
end;
function v32.TweenInFrom(p12, p13)
	p12.DisplayModel.EndWaypointBillboard.StudsOffset = Vector3.new(0, (p13 - p12.DisplayModel.Position).Y, 0);
	local v35 = l__TweenService__5:Create(p12.DisplayModel.EndWaypointBillboard, TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.Out), {
		StudsOffset = Vector3.new(0, 0, 0)
	});
	v35:Play();
	return v35;
end;
function v32.new(p14, p15, p16)
	local v36 = setmetatable({}, v32);
	v36.DisplayModel = v36:NewDisplayModel(p14);
	v36.Destroyed = false;
	if p16 and (p16 - p14).Magnitude > 5 then
		v36.Tween = v36:TweenInFrom(p16);
		coroutine.wrap(function()
			v36.Tween.Completed:Wait();
			if not v36.Destroyed then
				v36.Tween = v36:CreateTween();
			end;
		end)();
	else
		v36.Tween = v36:CreateTween();
	end;
	v36.ClosestWayPoint = p15;
	return v36;
end;
local v37 = {};
v37.__index = v37;
function v37.Hide(p17)
	p17.DisplayModel.Parent = nil;
end;
function v37.Destroy(p18)
	p18.DisplayModel:Destroy();
end;
local u11 = v23;
function v37.NewDisplayModel(p19, p20)
	local v38 = u11:Clone();
	u9(v38, p20);
	local v39, v40, v41 = l__Workspace__7:FindPartOnRayWithIgnoreList(Ray.new(p20 + Vector3.new(0, 2.5, 0), Vector3.new(0, -10, 0)), { l__Workspace__7.CurrentCamera, l__LocalPlayer__8.Character });
	if v39 then
		v38.CFrame = CFrame.new(v40, v40 + v41);
		local l__CurrentCamera__42 = l__Workspace__7.CurrentCamera;
		local v43 = l__CurrentCamera__42:FindFirstChild("ClickToMoveDisplay");
		if not v43 then
			v43 = Instance.new("Model");
			v43.Name = "ClickToMoveDisplay";
			v43.Parent = l__CurrentCamera__42;
		end;
		v38.Parent = v43;
	end;
	return v38;
end;
function v37.RunFailureTween(p21)
	wait(0.125);
	local v44 = TweenInfo.new(0.0625, Enum.EasingStyle.Sine, Enum.EasingDirection.Out);
	local v45 = l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard, v44, {
		SizeOffset = v3
	});
	v45:Play();
	l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard.Frame, v44, {
		Rotation = 10
	}):Play();
	v45.Completed:wait();
	local v46 = l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard, TweenInfo.new(0.125, Enum.EasingStyle.Sine, Enum.EasingDirection.Out, 3, true), {
		SizeOffset = v4
	});
	v46:Play();
	local v47 = TweenInfo.new(0.125, Enum.EasingStyle.Sine, Enum.EasingDirection.Out, 3, true);
	l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard.Frame.ImageLabel, v47, {
		ImageColor3 = Color3.new(0.75, 0.75, 0.75)
	}):Play();
	l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard.Frame, v47, {
		Rotation = -10
	}):Play();
	v46.Completed:wait();
	local v48 = TweenInfo.new(0.0625, Enum.EasingStyle.Sine, Enum.EasingDirection.Out);
	local v49 = l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard, v48, {
		SizeOffset = u7
	});
	v49:Play();
	l__TweenService__5:Create(p21.DisplayModel.FailureWaypointBillboard.Frame, v48, {
		Rotation = 0
	}):Play();
	v49.Completed:wait();
	wait(0.125);
end;
function v37.new(p22)
	local v50 = setmetatable({}, v37);
	v50.DisplayModel = v50:NewDisplayModel(p22);
	return v50;
end;
local v51 = Instance.new("Animation");
v51.AnimationId = "rbxassetid://2874840706";
local u12 = nil;
local u13 = 0;
local function u14(p23, p24)
	local v52 = {};
	local v53 = 1;
	for v54 = 1, #p23 - 1 do
		local v55 = false;
		if v54 % 2 == 0 then
			v55 = not ((p23[v54].Position - p23[#p23].Position).Magnitude < 3);
		end;
		if v55 then
			v52[v53] = v24.new(p23[v54].Position, v54);
			v53 = v53 + 1;
		end;
	end;
	table.insert(v52, (v32.new(p23[#p23].Position, #p23, p24)));
	local v56 = {};
	local v57 = 1;
	for v58 = #v52, 1, -1 do
		v56[v57] = v52[v58];
		v57 = v57 + 1;
	end;
	return v56;
end;
function v1.CreatePathDisplay(p25, p26)
	u13 = u13 + 1;
	local u15 = u14(p25, p26);
	local u16 = "ClickToMoveResizeTrail" .. u13;
	l__RunService__6:BindToRenderStep(u16, Enum.RenderPriority.Camera.Value - 1, function()
		if #u15 == 0 then
			l__RunService__6:UnbindFromRenderStep(u16);
			return;
		end;
		local l__p__59 = l__Workspace__7.CurrentCamera.CFrame.p;
		for v60 = 1, #u15 do
			local l__TrailDotImage__61 = u15[v60].DisplayModel:FindFirstChild("TrailDotImage");
			if l__TrailDotImage__61 then
				l__TrailDotImage__61.Size = u1 * (1 + 1.5 * (math.clamp((u15[v60].DisplayModel.Position - l__p__59).Magnitude - 10, 0, 90) / 90));
			end;
		end;
	end);
	local function u17(p27)
		for v62 = #u15, 1, -1 do
			local v63 = u15[v62];
			if not (v63.ClosestWayPoint <= p27) then
				break;
			end;
			v63:Destroy();
			u15[v62] = nil;
		end;
	end;
	return function()
		u17(#p25);
	end, u17;
end;
local u18 = nil;
function v1.DisplayFailureWaypoint(p28)
	if u18 then
		u18:Hide();
	end;
	local v64 = v37.new(p28);
	u18 = v64;
	local u19 = v64;
	coroutine.wrap(function()
		u19:RunFailureTween();
		u19:Destroy();
		u19 = nil;
	end)();
end;
function v1.CreateEndWaypoint(p29)
	return v32.new(p29);
end;
function v1.PlayFailureAnimation()
	local l__Character__65 = l__LocalPlayer__8.Character;
	if l__Character__65 then
		local v66 = l__Character__65:FindFirstChildOfClass("Humanoid");
	else
		v66 = nil;
	end;
	if v66 then
		if v66 == nil then
			local v67 = u12;
		else
			u12 = v66:LoadAnimation(v51);
			assert(u12, "");
			u12.Priority = Enum.AnimationPriority.Action;
			u12.Looped = false;
			v67 = u12;
		end;
		v67:Play();
	end;
end;
function v1.CancelFailureAnimation()
	if u12 ~= nil and u12.IsPlaying then
		u12:Stop();
	end;
end;
function v1.SetWaypointTexture(p30)
	u3 = p30;
	local v68, v69, v70 = v9();
	u8 = v68;
	u10 = v69;
	u11 = v70;
end;
function v1.GetWaypointTexture()
	return u3;
end;
function v1.SetWaypointRadius(p31)
	u1 = Vector2.new(p31, p31);
	local v71, v72, v73 = v9();
	u8 = v71;
	u10 = v72;
	u11 = v73;
end;
function v1.GetWaypointRadius()
	return u1.X;
end;
function v1.SetEndWaypointTexture(p32)
	u6 = p32;
	local v74, v75, v76 = v9();
	u8 = v74;
	u10 = v75;
	u11 = v76;
end;
function v1.GetEndWaypointTexture()
	return u6;
end;
function v1.SetWaypointsAlwaysOnTop(p33)
	u2 = p33;
	local v77, v78, v79 = v9();
	u8 = v77;
	u10 = v78;
	u11 = v79;
end;
function v1.GetWaypointsAlwaysOnTop()
	return u2;
end;
return v1;


Prompt: --Wheels Array

Response:
local fDensity = _Tune.FWheelDensity
local rDensity = _Tune.RWheelDensity
local fFwght = _WHEELTUNE.FFrictionWeight
local rFwght = _WHEELTUNE.RFrictionWeight
local fElast = _WHEELTUNE.FElasticity
local rElast = _WHEELTUNE.RElasticity
local fEwght = _WHEELTUNE.FElastWeight
local rEwght = _WHEELTUNE.RElastWeight
if not workspace:PGSIsEnabled() then
	fDensity = _Tune.FWLgcyDensity
	rDensity = _Tune.RWLgcyDensity
	fFwght = _WHEELTUNE.FLgcyFrWeight
	rFwght = _WHEELTUNE.FLgcyFrWeight
	fElast = _WHEELTUNE.FLgcyElasticity
	rElast = _WHEELTUNE.RLgcyElasticity
	fEwght = _WHEELTUNE.FLgcyElWeight
	rEwght = _WHEELTUNE.RLgcyElWeight
end
local Wheels = {}
for i,v in pairs(car.Wheels:GetChildren()) do
	local w = {}
	w.wheel = v
	local ca
	w.x = 0
	if v.Name == "FL" or v.Name == "FR" or v.Name == "F" then
		ca = (12-math.abs(_Tune.FCamber))/15
		w.x = fDensity
		w.BaseHeat = _WHEELTUNE.FTargetFriction-_WHEELTUNE.FMinFriction
		w.WearSpeed = _WHEELTUNE.FWearSpeed
		w.fWeight = fFwght
		w.elast = fElast
		w.eWeight = fEwght
	else
		ca = (12-math.abs(_Tune.RCamber))/15
		w.x = rDensity
		w.BaseHeat = _WHEELTUNE.RTargetFriction-_WHEELTUNE.RMinFriction
		w.WearSpeed = _WHEELTUNE.RWearSpeed
		w.fWeight = rFwght
		w.elast = rElast
		w.eWeight = rEwght
	end
	--if car:FindFirstChild("WearData")~=nil then
	--	w.Heat = math.min(w.BaseHeat,car.WearData[v.Name].Value+(((tick()-car.WearData.STime.Value)*_WHEELTUNE.RegenSpeed*15/10000)))
	--else
		w.Heat = w.BaseHeat
	--end
	w.stress = 0
	table.insert(Wheels,w)
end


Prompt:
-- If you want to after how many seconds can you get another hat on your head, change the line that says "wait(5)"
-- Changing this will change after how many seconds can someone touch the giver, and get a hat. It's best to leave it as it is,
-- Changing it really doesnt matter.


Prompt: -- Below are functions that are only meant to be used in command implementations --


Prompt:
--// Hash: 38f532afdee11571075140006601d75ddefce7a87d429f16b86768a1265dce192622a9061d57e77106a81f527e16f8a9
-- Decompiled with the Synapse X Luau decompiler.

Response:
return {
	Crouch = "C"
};


Prompt: -- Activate when setting is checked.

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


Prompt: ---[[ Message Settings ]]

Response:
module.MaximumMessageLength = 200
module.DisallowedWhiteSpace = {"\n", "\r", "\t", "\v", "\f"}
module.ClickOnPlayerNameToWhisper = true
module.ClickOnChannelNameToSetMainChannel = true
module.BubbleChatMessageTypes = {ChatConstants.MessageTypeDefault, ChatConstants.MessageTypeWhisper}


Prompt: --[[Susupension]]

Response:
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled

	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

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

	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

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

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

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


Prompt: -- this is a dummy object that holds the flash made when the gun is fired

Response:
local FlashHolder = nil

local WorldToCellFunction = Workspace.Terrain.WorldToCellPreferSolid
local GetCellFunction = Workspace.Terrain.GetCell

function RayIgnoreCheck(hit, pos)
	if hit then
		if hit.Transparency >= 1 or string.lower(hit.Name) == "water" or
				hit.Name == "Effect" or hit.Name == "Rocket" or hit.Name == "Bullet" or
				hit.Name == "Handle" or hit:IsDescendantOf(MyCharacter) then
			return true
		elseif hit:IsA('Terrain') and pos then
			local cellPos = WorldToCellFunction(Workspace.Terrain, pos)
			if cellPos then
				local cellMat = GetCellFunction(Workspace.Terrain, cellPos.x, cellPos.y, cellPos.z)
				if cellMat and cellMat == Enum.CellMaterial.Water then
					return true
				end
			end
		end
	end
	return false
end


Prompt:
--[[**
	ensures value is a given literal value

	@param literal The literal to use

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

Response:
function t.literal(...)
	local size = select("#", ...)
	if size == 1 then
		local literal = ...
		return function(value)
			if value ~= literal then
				return false, string.format("expected %s, got %s", tostring(literal), tostring(value))
			end
			return true
		end
	else
		local literals = {}
		for i = 1, size do
			local value = select(i, ...)
			literals[i] = t.literal(value)
		end
		return t.union(unpack(literals))
	end
end


Prompt:
--[[
	An implementation of Promises similar to Promise/A+.
]]

Response:
local ERROR_NON_PROMISE_IN_LIST = "Non-promise value passed into %s at index %s"
local ERROR_NON_LIST = "Please pass a list of promises to %s"
local ERROR_NON_FUNCTION = "Please pass a handler function to %s!"
local MODE_KEY_METATABLE = {__mode = "k"}


Prompt: -- LocalScripts that are cloned and deployed

Response:
local DriverScriptPrototype = Scripts.Driver
local PassengerScriptPrototype = Scripts.Passenger
local LocalGuiModulePrototype = Scripts.LocalVehicleGui


Prompt: --[[Drivetrain]]

Response:
	Tune.Config			= "AWD"		--"FWD" , "RWD" , "AWD"

	--Differential Settings
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 50		-- 1 - 100%
	Tune.RDiffLockThres	= 50		-- 0 - 100%
	Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]

	--Traction Control Settings
	Tune.TCSEnabled		= true		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)


Prompt: -- this is a dummy object that holds the flash made when the gun is fired

Response:
local FlashHolder = nil

local EquipTrack = nil
local PumpTrack = nil

local WorldToCellFunction = game.Workspace.Terrain.WorldToCellPreferSolid
local GetCellFunction = game.Workspace.Terrain.GetCell

function RayIgnoreCheck(hit, pos)
	if hit then
		if hit.Transparency >= 1 or string.lower(hit.Name) == "water" or
				hit.Name == "Effect" or hit.Name == "Rocket" or hit.Name == "Bullet" or
				hit.Name == "Handle" or hit:IsDescendantOf(MyCharacter) then
			return true
		elseif hit:IsA('Terrain') and pos then
			local cellPos = WorldToCellFunction(game.Workspace.Terrain, pos)
			if cellPos then
				local cellMat = GetCellFunction(game.Workspace.Terrain, cellPos.x, cellPos.y, cellPos.z)
				if cellMat and cellMat == Enum.CellMaterial.Water then
					return true
				end
			end
		end
	end
	return false
end


Prompt: --Find all important instances

Response:
local model 	= script.Parent.Parent 		--The teleporter model
local colorPart	= model.Parts.Color 		--The part that has color
local glowPart  = model.Parts.Glow 			--Teleporter glow part
local indicator = model.Parts.Indicator		--Indicator part
local telePart 	= model.Parts.Teleporter	--The actual teleporter part
local config 	= model.Configuration		--The configuration folder


Prompt:
--script.Parent.Urinal.Flushes.DistortionSoundEffect.Level = 0.75
--script.Parent.Waterz.Disabled = false

Response:
wait(0.545)
script.Parent.WaterUp.Disabled = false
wait(0.5)


Prompt:
--[=[
	@param name string -- Name passed to `RunService:BindToRenderStep`
	@param priority number -- Priority passed to `RunService:BindToRenderStep`
	@param callbackFn UpdateCallbackFn

	Bind the `Update` method to RenderStep.

	All bond functions are cleaned up when the shake instance is stopped
	or destroyed.

	```lua
	local renderPriority = Enum.RenderPriority.Camera.Value

	local function SomeShake(pos: Vector3, rot: Vector3, completed: boolean)
		-- Shake
	end

	shake:BindToRenderStep("SomeShake", renderPriority, SomeShake)
	```
]=]

Response:
function Shake:BindToRenderStep(name: string, priority: number, callbackFn: UpdateCallbackFn)
	self._trove:BindToRenderStep(name, priority, function()
		callbackFn(self:Update())
	end)
end


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

	@param max The maximum to use

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

Response:
function t.numberMaxExclusive(max)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg or ""
		end
		if value < max then
			return true
		else
			return false, string.format("number < %s expected, got %s", max, value)
		end
	end
end


Prompt: --Allows users to do /w displayName along with /w userName, only works if PlayerDisplayNamesEnabled is 'true'

Response:
module.WhisperByDisplayName = true

local ChangedEvent = Instance.new("BindableEvent")

local proxyTable = setmetatable({},
{
	__index = function(tbl, index)
		return module[index]
	end,
	__newindex = function(tbl, index, value)
		module[index] = value
		ChangedEvent:Fire(index, value)
	end,
})

rawset(proxyTable, "SettingsChanged", ChangedEvent.Event)

return proxyTable


Prompt:
---------------
--// Events
---------------

Response:
STC.UpdateInventory.OnClientEvent:Connect(function(D)
	Data = D
	if ContentFrame.Sell.Visible == true then
		loadStuff()
	end
end)

script.Parent.MouseButton1Up:Connect(function()
	toggleVisibility()
	loadStuff()
	loadPriceVisual()
end)

SellButton.MouseButton1Down:Connect(function()
	if #SelectedItems ~= 0 then
		CTS.Sell:FireServer(SelectedItems)
		SelectedItems = {}
	end
	loadPriceVisual()
end)

clearButton.MouseButton1Down:Connect(function()
	SelectedItems = {}
	for i,v in pairs(SellItemsScrollingFrame:GetChildren()) do
		if v.Name ~= "Z" and v.Name ~= "Template" and v:IsA("Frame") then
			v.BackgroundColor3 = Color3.new(0, 0, 0)
			v.A:FindFirstChildOfClass("ViewportFrame").ImageTransparency = 0
			v.A:FindFirstChildOfClass("ViewportFrame").ImageColor3 = Color3.new(1, 1, 1)
			v.A.Amount.Visible = false

		end
	end
	loadPriceVisual()
end)


Prompt:
-- -- -- -- -- -- --
--DIRECTION SCROLL--
-- -- -- -- -- -- --

Response:
This.Parent.Parent.Parent.Parent.Parent:WaitForChild("Direction", 120).Changed:connect(function(val)
if val == 1 then
This.Frame.Direction.Text = "▲"
elseif val == -1 then
This.Frame.Direction.Text = "▼"
else
This.Frame.Direction.Text = ""
end
end)


Prompt: --griptcf = CFrame.new(0, -1, 0) * CFrame.fromEulerAnglesXYZ(-math.pi/2+0.5, 0, 0)

Response:
script.Parent.Unequipped:connect(function()
	selected = false
	local pl = player
	--[[Bring_Arm_Down animation
	for i = 1, 0, -0.05 do
		wait()
		RW.C0 = CFrame.new(1.5, 0.5, 0) * CFrame.fromEulerAnglesXYZ(1.5*i, 0, -0.5*i)
		LW.C0 = CFrame.new(-1.5, 0.5, 0) * CFrame.fromEulerAnglesXYZ(1.6*i, 0, 0.7*i)
		LW.C1 = CFrame.new(-0.3*i, 1.7*i, 0)
	end]]
	RW.Parent = nil
	LW.Parent = nil
	RSH.Part1 = pl.Character["Right Arm"]
	LSH.Part1 = pl.Character["Left Arm"]
end)


Prompt: --- Constants used to decide when to notify that the chat filter is having issues filtering messages.

Response:
local FILTER_NOTIFCATION_THRESHOLD = 3 --Number of notifcation failures before an error message is output.
local FILTER_NOTIFCATION_INTERVAL = 60 --Time between error messages.
local FILTER_THRESHOLD_TIME = 60 --If there has not been an issue in this many seconds, the count of issues resets.

local module = {}

local RunService = game:GetService("RunService")
local Chat = game:GetService("Chat")
local ReplicatedModules = Chat:WaitForChild("ClientChatModules")

local modulesFolder = script.Parent
local ReplicatedModules = Chat:WaitForChild("ClientChatModules")
local ChatSettings = require(ReplicatedModules:WaitForChild("ChatSettings"))

local errorTextColor = ChatSettings.ErrorMessageTextColor or Color3.fromRGB(245, 50, 50)
local errorExtraData = {ChatColor = errorTextColor}


Prompt: --// Handling Settings

Response:
	Firerate = 60 / 720; -- 60 = 1 Minute, 700 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!

	FireMode = 1; -- 1 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive


Prompt:
--------------------------------------------------------------------------------------
--------------------[ WELD CFRAMES ]--------------------------------------------------
--------------------------------------------------------------------------------------

Response:
spawn(function()
	--[[for _, v in pairs(Gun:GetChildren()) do
		if v:IsA("BasePart") and v ~= Handle then
			if v:FindFirstChild("mainWeld") then v.mainWeld:Destroy() end
			if (not v:FindFirstChild("weldCF")) then
				local weldCF = Instance.new("CFrameValue")
				weldCF.Name = "weldCF"
				weldCF.Value = Handle.CFrame:toObjectSpace(v.CFrame)
				weldCF.Parent = v
				INSERT(gunParts, {Obj = v, Weld = nil})
			end
			if string.sub(v.Name, 1, 3) == "Mag" then
				if (not v:FindFirstChild("magTrans")) then
					local magTrans = Instance.new("NumberValue")
					magTrans.Name = "magTrans"
					magTrans.Value = v.Transparency
					magTrans.Parent = v
				end
			end
			v.Anchored = false
		end
	end
	Handle.Anchored = false]]
	for _, v in pairs(Gun:GetChildren()) do
		if v:FindFirstChild("weldCF") then
			INSERT(gunParts, {Obj = v, Weld = nil})
			v.Anchored = false
		end
	end
end)


Response:
local Spring = {} do
	Spring.__index = Spring

	function Spring.new(freq, pos)
		local self = setmetatable({}, Spring)
		self.f = freq
		self.p = pos
		self.v = pos*0
		return self
	end

	function Spring:Update(dt, goal)
		local f = self.f*2*pi
		local p0 = self.p
		local v0 = self.v

		local offset = goal - p0
		local decay = exp(-f*dt)

		local p1 = goal + (v0*dt - offset*(f*dt + 1))*decay
		local v1 = (f*dt*(offset*f - v0) + v0)*decay

		self.p = p1
		self.v = v1

		return p1
	end

	function Spring:Reset(pos)
		self.p = pos
		self.v = pos*0
	end
end


Prompt:
--[[
	Cmdr setup
]]

Response:
Cmdr:SetActivationKeys({
	Enum.KeyCode.Backquote,
	Enum.KeyCode.BackSlash,
})

Cmdr:SetEnabled(true)
if not UserInputService.KeyboardEnabled then
	if Util.isPlayerIDInTable(localPlayer, Conf.reference_games_user_ids) then
		local cmdrFrame = ReplicatedStorage.Assets.GuiObjects.Frames.CmdrFrame
		local cmdrButton = cmdrFrame.CmdrButton
		local cmdrGui = playerGui:WaitForChild("Cmdr")
		cmdrButton.Activated:Connect(function()
			local window = Cmdr.Interface.Window
			if window:IsVisible() then
				cmdrFrame.Position = UDim2.new(0, 0, 0, 0)
				window:Hide()
			else
				cmdrFrame.Position = UDim2.new(0, 0, 0.1, 0)
				window:Show()
			end
		end)
		cmdrFrame.Parent = cmdrGui
	end
end

local ConsoleEventHandlers = require(ReplicatedStorage.Libraries.ConsoleEventHandlers)


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

Response:
local l__Parent__1 = script.Parent;
local v2 = {};
v2.__index = v2;
local u1 = require(game:GetService("Chat"):WaitForChild("ClientChatModules"):WaitForChild("ChatSettings"));
local u2 = {
	ScrollBarThickness = 4
};
function v2.Destroy(p1)
	p1.GuiObject:Destroy();
	p1.Destroyed = true;
end;
function v2.SetActive(p2, p3)
	p2.GuiObject.Visible = p3;
end;
function v2.UpdateMessageFiltered(p4, p5)
	local v3 = nil;
	local v4 = 1;
	local l__MessageObjectLog__5 = p4.MessageObjectLog;
	while v4 <= #l__MessageObjectLog__5 do
		local v6 = l__MessageObjectLog__5[v4];
		if v6.ID == p5.ID then
			v3 = v6;
			break;
		end;
		v4 = v4 + 1;
	end;
	if v3 then
		v3.UpdateTextFunction(p5);
		p4:PositionMessageLabelInWindow(v3, v4);
	end;
end;
local u3 = require(l__Parent__1:WaitForChild("MessageLabelCreator")).new();
function v2.AddMessage(p6, p7)
	p6:WaitUntilParentedCorrectly();
	local v7 = u3:CreateMessageLabel(p7, p6.CurrentChannelName);
	if v7 == nil then
		return;
	end;
	table.insert(p6.MessageObjectLog, v7);
	p6:PositionMessageLabelInWindow(v7, #p6.MessageObjectLog);
end;
function v2.AddMessageAtIndex(p8, p9, p10)
	local v8 = u3:CreateMessageLabel(p9, p8.CurrentChannelName);
	if v8 == nil then
		return;
	end;
	table.insert(p8.MessageObjectLog, p10, v8);
	p8:PositionMessageLabelInWindow(v8, p10);
end;
function v2.RemoveLastMessage(p11)
	p11:WaitUntilParentedCorrectly();
	p11.MessageObjectLog[1]:Destroy();
	table.remove(p11.MessageObjectLog, 1);
end;
function v2.IsScrolledDown(p12)
	local l__Offset__9 = p12.Scroller.CanvasSize.Y.Offset;
	local l__Y__10 = p12.Scroller.AbsoluteWindowSize.Y;
	local v11 = true;
	if not (l__Offset__9 < l__Y__10) then
		v11 = l__Offset__9 - p12.Scroller.CanvasPosition.Y <= l__Y__10 + 5;
	end;
	return v11;
end;
function v2.UpdateMessageTextHeight(p13, p14)
	local l__BaseFrame__12 = p14.BaseFrame;
	for v13 = 1, 10 do
		if p14.BaseMessage.TextFits then
			break;
		end;
		l__BaseFrame__12.Size = UDim2.new(1, 0, 0, p14.GetHeightFunction(p13.Scroller.AbsoluteSize.X - v13));
	end;
end;
function v2.PositionMessageLabelInWindow(p15, p16, p17)
	p15:WaitUntilParentedCorrectly();
	local l__BaseFrame__14 = p16.BaseFrame;
	local v15 = 1;
	if p15.MessageObjectLog[p17 - 1] then
		if p17 == #p15.MessageObjectLog then
			v15 = p15.MessageObjectLog[p17 - 1].BaseFrame.LayoutOrder + 1;
		else
			v15 = p15.MessageObjectLog[p17 - 1].BaseFrame.LayoutOrder;
		end;
	end;
	l__BaseFrame__14.LayoutOrder = v15;
	l__BaseFrame__14.Size = UDim2.new(1, 0, 0, p16.GetHeightFunction(p15.Scroller.AbsoluteSize.X));
	l__BaseFrame__14.Parent = p15.Scroller;
	if p16.BaseMessage then
		p15:UpdateMessageTextHeight(p16);
	end;
	if p15:IsScrolledDown() then
		p15.Scroller.CanvasPosition = Vector2.new(0, math.max(0, p15.Scroller.CanvasSize.Y.Offset - p15.Scroller.AbsoluteSize.Y));
	end;
end;
function v2.ReorderAllMessages(p18)
	p18:WaitUntilParentedCorrectly();
	if p18.GuiObject.AbsoluteSize.Y < 1 then
		return;
	end;
	for v16, v17 in pairs(p18.MessageObjectLog) do
		p18:UpdateMessageTextHeight(v17);
	end;
	if not p18:IsScrolledDown() then
		p18.Scroller.CanvasPosition = p18.Scroller.CanvasPosition;
		return;
	end;
	p18.Scroller.CanvasPosition = Vector2.new(0, math.max(0, p18.Scroller.CanvasSize.Y.Offset - p18.Scroller.AbsoluteSize.Y));
end;
function v2.Clear(p19)
	for v18, v19 in pairs(p19.MessageObjectLog) do
		v19:Destroy();
	end;
	p19.MessageObjectLog = {};
end;
function v2.SetCurrentChannelName(p20, p21)
	p20.CurrentChannelName = p21;
end;
function v2.FadeOutBackground(p22, p23)

end;
function v2.FadeInBackground(p24, p25)

end;
local u4 = require(l__Parent__1:WaitForChild("CurveUtil"));
function v2.FadeOutText(p26, p27)
	for v20 = 1, #p26.MessageObjectLog do
		if p26.MessageObjectLog[v20].FadeOutFunction then
			p26.MessageObjectLog[v20].FadeOutFunction(p27, u4);
		end;
	end;
end;
function v2.FadeInText(p28, p29)
	for v21 = 1, #p28.MessageObjectLog do
		if p28.MessageObjectLog[v21].FadeInFunction then
			p28.MessageObjectLog[v21].FadeInFunction(p29, u4);
		end;
	end;
end;
function v2.Update(p30, p31)
	for v22 = 1, #p30.MessageObjectLog do
		if p30.MessageObjectLog[v22].UpdateAnimFunction then
			p30.MessageObjectLog[v22].UpdateAnimFunction(p31, u4);
		end;
	end;
end;
function v2.WaitUntilParentedCorrectly(p32)
	while not p32.GuiObject:IsDescendantOf(game:GetService("Players").LocalPlayer) do
		p32.GuiObject.AncestryChanged:wait();
	end;
end;
local function u5()
	local v23 = Instance.new("Frame");
	v23.Selectable = false;
	v23.Size = UDim2.new(1, 0, 1, 0);
	v23.BackgroundTransparency = 1;
	local v24 = Instance.new("ScrollingFrame");
	v24.Selectable = u1.GamepadNavigationEnabled;
	v24.Name = "Scroller";
	v24.BackgroundTransparency = 1;
	v24.BorderSizePixel = 0;
	v24.Position = UDim2.new(0, 0, 0, 3);
	v24.Size = UDim2.new(1, -4, 1, -6);
	v24.CanvasSize = UDim2.new(0, 0, 0, 0);
	v24.ScrollBarThickness = u2.ScrollBarThickness;
	v24.Active = true;
	v24.Parent = v23;
	local v25 = Instance.new("UIListLayout");
	v25.SortOrder = Enum.SortOrder.LayoutOrder;
	v25.Parent = v24;
	return v23, v24, v25;
end;
function u2.new()
	local v26 = setmetatable({}, v2);
	v26.Destroyed = false;
	local v27, v28, v29 = u5();
	v26.GuiObject = v27;
	v26.Scroller = v28;
	v26.Layout = v29;
	v26.MessageObjectLog = {};
	v26.Name = "MessageLogDisplay";
	v26.GuiObject.Name = "Frame_" .. v26.Name;
	v26.CurrentChannelName = "";
	v26.GuiObject:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
		spawn(function()
			v26:ReorderAllMessages();
		end);
	end);
	local u6 = true;
	v26.Layout:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(function()
		local l__AbsoluteContentSize__30 = v26.Layout.AbsoluteContentSize;
		v26.Scroller.CanvasSize = UDim2.new(0, 0, 0, l__AbsoluteContentSize__30.Y);
		if u6 then
			v26.Scroller.CanvasPosition = Vector2.new(0, l__AbsoluteContentSize__30.Y - v26.Scroller.AbsoluteWindowSize.Y);
		end;
	end);
	v26.Scroller:GetPropertyChangedSignal("CanvasPosition"):Connect(function()
		u6 = v26:IsScrolledDown();
	end);
	return v26;
end;
return u2;


Response:
	,FastReload = true					--- Automatically operates the bolt on reload if needed
	,SlideLock = false
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = true
	,CanBreak = true					--- Weapon can jam?
	,JamChance = 1000					--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = true		--- Include the chambered bullet on next reload
	,Chambered = false					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = false				--- You can check the magazine
	,ArcadeMode = false					--- You can see the bullets left in magazine
	,RainbowMode = false				--- Operation: Party Time xD
	,ModoTreino = false					--- Surrender enemies instead of killing them
	,GunSize = 5
	,GunFOVReduction = 5.5

	,BoltExtend = Vector3.new(0, 0, 0.4)
	,SlideExtend = Vector3.new(0, 0, 0.2)