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 = {};

		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;

			DataStore = true;
			DataStoreKey = true;
			DataStoreEnabled = true;

			Creators = true;
			Permissions = true;

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

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

			CustomRanks = true;
		};

		Returnables = {
			RateLimits = function(p, args)
				return server.Process.RateLimits
			end;

			Test = function(p,args)
				return "HELLO FROM THE OTHER SIDE :)!"
			end;

			Ping = function(p,args)
				return "Pong"
			end;

			Filter = function(p,args)
				return service.Filter(args[1],args[2],args[3])
			end;

			BroadcastFilter = function(p,args)
				return service.BroadcastFilter(args[1],args[2] or p)
			end;

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

			ExecutePermission = function(p,args)
				return Core.ExecutePermission(args[1],args[2],true)
			end;

			Variable = function(p,args)
				return Variables[args[1]]
			end;

			Default = function(p,args)
				local setting = args[1]
				local level = Admin.GetLevel(p)
				local ret = nil
				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 i,set in pairs(setting) do
						if Defaults[set] and not (blocked[set] and not level >= Settings.Ranks.Creators.Level) then
							ret[set] = Defaults[set]
						end
					end
				elseif type(setting) == "string" then
					if Defaults[setting] and not (blocked[setting] and not level >= Settings.Ranks.Creators.Level) then
						ret = Defaults[setting]
					end
				end

				return ret
			end;

			AllDefaults = function(p,args)
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local sets = {}

					sets.Settings = {}
					sets.Descs = server.Descriptions
					sets.Order = server.Order

					for i,v in pairs(Defaults) do
						sets.Settings[i] = v
					end

					local blocked = {
						HideScript = true;  -- Changing in-game will do nothing; Not able to be saved
						DataStore = true;
						DataStoreKey = true;
						DataStoreEnabled = 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;

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

						CustomRanks = true; -- Not supported yet
					}

					for setting,value in pairs(sets.Settings) do
						if blocked[setting] then
							sets.Settings[setting] = nil
						end
					end

					return sets
				end
			end;

			Setting = function(p,args)
				local setting = args[1]
				local level = Admin.GetLevel(p)
				local ret = nil
				local allowed = Remote.AllowedSettings

				if type(setting) == "table" then
					ret = {}
					for i,set in pairs(setting) do
						if Settings[set] ~= nil 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,args)
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local sets = {}

					sets.Settings = {}
					sets.Descs = server.Descriptions
					sets.Order = server.Order

					for i,v in pairs(Settings) do
						sets.Settings[i] = v
					end

					local blocked = Remote.BlockedSettings

					for setting,value in pairs(sets.Settings) do
						if blocked[setting] then
							sets.Settings[setting] = nil
						end
					end

					return sets
				end
			end;

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

			AdminLevel = function(p,args)
				return Admin.GetLevel(p)
			end;

			Keybinds = function(p,args)
				local playerData = Core.GetPlayer(p)
				return playerData.Keybinds or {}
			end;

			UpdateKeybinds = function(p,args)
				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,args)
				local playerData = Core.GetPlayer(p)
				return playerData.CustomPlaylist or {}
			end;

			UpdatePlaylist = function(p,args)
				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,args)
				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,args)
				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, args)
				local aliases = args[1] or {};

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

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

					data.Aliases = aliases;
				end
			end;

			PlayerData = function(p,args)
				local data = Core.GetPlayer(p)
				data.isDonor = Admin.CheckDonor(p)
				return data
			end;

			CheckAdmin = function(p,args)
				return Admin.CheckAdmin(p)
			end;

			SearchCommands = function(p,args)
				return Admin.SearchCommands(p,args[1] or "all")
			end;

			CheckBackpack = function(p,args)
				return Anti.CheckBackpack(p,args[1])
			end;

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

			TerminalData = function(p,args)
				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,args)
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					local data = args[2]
					local message = args[1]
					local command = message:match("(.-) ") or message
					local argString = message:match("^.- (.+)") 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
		};

		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 next,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 i,v in next,service.GetPlayers() do
							Remote.Send(v,"Function","ChatMessage",args[1],Color3.new(1,64/255,77/255))
						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 i,v in pairs(nums) do Remote.Terminal.LiveOutput(p,"PRINT: "..tostring(v)) end end;
							warn = function(...) local nums = {...} for i,v in pairs(nums) do Remote.Terminal.LiveOutput(p,"WARN: "..tostring(v)) end end;
						})

						local func,err = Core.Loadstring(args[1], newenv)
						if func then
							func()
						else
							Remote.Terminal.LiveOutput(p,"ERROR: "..tostring(err:match(":(.*)") 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 i,v in pairs(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 i,v in pairs(plrs) do
								if v.Character and v.Character ~= nil then
									v.Character:BreakJoints()
									return {"Killed "..tostring(v.Name)}
								else
									return {tostring(v.Name).." has no character"}
								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 i,v in pairs(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)
						for i,v in next,service.Players:GetPlayers() do
							v:Kick()
						end

						service.PlayerAdded:Connect(function(p)
							p:Kick()
						end)
					end
				};
			};
		};

		SessionHandlers = {

		};

		UnEncrypted = {
			--[[TrustCheck = function(p)
				local keys = Remote.Clients[tostring(p.UserId)]
				Remote.Fire(p, "TrustCheck", keys.Special)
			end;--]]

			ProcessChat = function(p,msg)
				Process.Chat(p,msg)
			end;

			ExplorerAction = function(p, ...)
				--if Admin.CheckAdmin(p) then
					--// Handle stuff like Dex calls(?)
				--end
			end;
		};

		Commands = {
			GetReturn = function(p,args)
				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,args)
				if Remote.PendingReturns[args[1]] then
					Remote.PendingReturns[args[1]] = nil
					service.Events[args[1]]:Fire(unpack(args,2))
				end
			end;

			ClientCheck = function(p,args)
				local key = tostring(p.UserId)
				local data = args[1]
				local special = args[2]
				local keys = Remote.Clients[key]

				--if (math.abs(data.Received - keys.Sent) > 10) then
				--	print("Something is wrong...")
				--end

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

				return;
			end;

		--[[Session = function(p,args)
				local type = args[1]
				local data = args[2]
				local handler = Remote.SessionHandlers[type]
				if handler then
					return handler(p, data)
				end
			end;--]]

			Session = function(p, args)
				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)
				--// TODO
				--// Make this a separate Admin method
				local Command = Commands.Explore
				if not Command then return end
				local Level = Command.AdminLevel
				if not Level then return end
				local Rank = Settings.Ranks[Level]
				if not Rank then return end
				if not Rank.Level then return end
				if Admin.GetLevel(p) >= Rank.Level 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,args)
				service.Events[tostring(args[1])..p.UserId]:Fire(unpack(args,2))
			end;

			SaveTableAdd = function(p,args)
				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,args)
				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,args)
				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 pairs(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,args)
				if Admin.GetLevel(p) >= Settings.Ranks.Creators.Level then
					Core.DoSave({Type = "ClearSettings"})
					Functions.Hint("Cleared saved settings", {p})
				end
			end;

			SetSetting = function(p,args)
				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 pairs(Commands) do
							if v.Prefix == orig then
								v.Prefix = value
							end
						end

						server.Admin.CacheCommands()
					end

					Settings[setting] = value
				end
			end;

			Detected = function(p,args)
				Anti.Detected(p, args[1], args[2])
			end;

			TrelloOperation = function(p,args)
				if Admin.GetLevel(p) > Settings.Ranks.Admins.Level then
					local data = args[1]
					if data.Action == "MakeCard" then
						local list = data.List
						local name = data.Name
						local desc = data.Desc
						local trello = HTTP.Trello.API(Settings.Trello_AppKey,Settings.Trello_Token)
						local lists = trello.getLists(Settings.Trello_Primary)
						local list = trello.getListObj(lists,list)
						if list then
							local card = trello.makeCard(list.id,name,desc)
							Functions.Hint("Made card \""..card.name.."\"",{p})
							Logs.AddLog(Logs.Script,{
								Text = tostring(p).." performed Trello operation";
								Desc = "Player created a Trello card";
								Player = p;
							})
						end
					end
				end
			end;

			ClientLoaded = function(p, args)
				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)
					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,args)
				logError(p,args[1])
			end;

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

			ProcessCommand = function(p,args)
				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,args)
				Process.Chat(p,args[1])
				--Process.CustomChat(p,args[1])
			end;

			ProcessCustomChat = function(p,args)
				Process.Chat(p,args[1],"CustomChat")
				Process.CustomChat(p,args[1],args[2],true)
			end;

			PrivateMessage = function(p,args)
				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)
			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 = 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 = 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 next,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 next,self.Events do
							event:Disconnect();
							self.Events[t] = nil;
						end

						self:SendToUsers("SessionEnded");

						self.NumUsers = 0;
						self.Users = {};
						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)
			return Remote.Sessions[sessionKey];
		end;

		Fire = function(p, ...)
			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 = keys.Sent+1
				pcall(RemoteEvent.Object.FireClient, RemoteEvent.Object, p, {Mode = "Fire", Sent = 0},...)
			end
		end;

		Send = function(p,com,...)
			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, ...)
			local keys = Remote.Clients[tostring(p.UserId)]
			local RemoteEvent = Core.RemoteEvent
			if RemoteEvent and RemoteEvent.Function then
				keys.Sent = keys.Sent+1
				return RemoteEvent.Function:InvokeClient(p, {Mode = "Get", Sent = 0}, ...)
			end
		end;

		Get = function(p,com,...)
			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, com, ...)
			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)
					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()
				end

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

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

		CheckClient = function(p)
			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 pairs(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)
			return Remote.Get(p,"Ping")
		end;

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

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

		GetGui = function(p,GUI,data,themeData)
			return Remote.MakeGuiGet(p,GUI,data,themeData)
		end;

		RemoveGui = function(p,name,ignore)
			Remote.Send(p,"RemoveUI",name,ignore)
		end;

		RefreshGui = function(p, name, ignore, data, themeData)
			local theme = {Desktop = Settings.Theme; Mobile = Settings.MobileTheme}
			if themeData then for ind,dat in pairs(themeData) do theme[ind] = dat end end
			Remote.Send(p,"RefreshUI", name, ignore, themeData, data or {})
		end;

		NewParticle = function(p,target,type,properties)
			Remote.Send(p,"Function","NewParticle",target,type,properties)
		end;

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

		NewLocal = function(p, type, props, parent)
			Remote.Send(p,"Function","NewLocal",type,props,parent)
		end;

		MakeLocal = function(p,object,parent,clone)
			object.Parent = p
			wait(0.5)
			Remote.Send(p,"Function","MakeLocal",object,parent,clone)
		end;

		MoveLocal = function(p,object,parent,newParent)
			Remote.Send(p,"Function","MoveLocal",object,false,newParent)
		end;

		RemoveLocal = function(p,object,parent,match)
			Remote.Send(p,"Function","RemoveLocal",object,parent,match)
		end;

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

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

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

		StartLoop = function(p,name,delay,funcCode)
			Remote.Send(p,"StartLoop",name,delay,Core.ByteCode(funcCode))
		end;

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

		PlayAudio = function(p,audioId,volume,pitch,looped)
			Remote.Send(p,"Function","PlayAudio",audioId,volume,pitch,looped)
		end;

		StopAudio = function(p,id)
			Remote.Send(p,"Function","StopAudio",id)
		end;

		FadeAudio = function(p,id,inVol,pitch,looped,incWait)
			Remote.Send(p,"Function","FadeAudio",id,inVol,pitch,looped,incWait)
		end;

		StopAllAudio = function(p)
			Remote.Send(p,"Function","KillAllLocalAudio")
		end;
		--[[
		StartSession = function(p,type,data)
			local index = Functions.GetRandom()
			local data = data or {}
			local custKill = data.Kill
			data.Type = type
			data.Player = p
			data.Index = index
			data.Kill = function()
				Remote.Sessions[index] = nil
				if custKill then return custKill() end
				return true
			end
			Remote.KillSession(p,type)
			Remote.Sessions[index] = data
		end;

		GetSession = function(p,type)
			for i,v in pairs(Remote.Sessions) do
				if v.Type == type and v.Player == p then
					return v,i
				end
			end
		end;

		KillSession = function(p,type)
			for i,v in pairs(Remote.Sessions) do
				if v.Type == type and v.Player == p then
					v.Kill()
				end
			end
		end;
		--]]
		LoadCode = function(p,code,getResult)
			if getResult then
				return Remote.Get(p,"LoadCode",Core.Bytecode(code))
			else
				Remote.Send(p,"LoadCode",Core.Bytecode(code))
			end
		end;

		Encrypt = function(str, key, cache)
			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, key, cache)
			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


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

Response:
export type ForValues<VI, VO, M> = PubTypes.ForValues<any, VO> & {
	_oldDependencySet: Set<PubTypes.Dependency>,
	_processor: (VI) -> (VO),
	_destructor: (VO, M?) -> (),
	_inputIsState: boolean,
	_inputTable: PubTypes.CanBeState<{ [VI]: VO }>,
	_outputTable: { [any]: VI },
	_valueCache: { [VO]: any },
	_oldValueCache: { [VO]: any },
	_meta: { [VO]: M? },
	_valueData: {
		[VI]: {
			dependencySet: Set<PubTypes.Dependency>,
			oldDependencySet: Set<PubTypes.Dependency>,
			dependencyValues: { [PubTypes.Dependency]: any },
		},
	},
}


Prompt:
--A-Chassis 6 Stock Gauge Cluster Interface
--	SecondLogic @ Inspare

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

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

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

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

local revEnd = math.ceil(_lRPM/1000)

local Drive={}
if _Tune.Config == "FWD" or _Tune.Config == "AWD" then
	if car.Wheels:FindFirstChild("FL")~= nil then
		table.insert(Drive,car.Wheels.FL)
	end
	if car.Wheels:FindFirstChild("FR")~= nil then
		table.insert(Drive,car.Wheels.FR)
	end
end
if _Tune.Config == "RWD" or _Tune.Config == "AWD" then
	if car.Wheels:FindFirstChild("RL")~= nil then
		table.insert(Drive,car.Wheels.RL)
	end
	if car.Wheels:FindFirstChild("RR")~= nil then
		table.insert(Drive,car.Wheels.RR)
	end
end

local wDia = 0
for i,v in pairs(Drive) do
	if v.Size.x>wDia then wDia = v.Size.x end
end
Drive = nil
local maxSpeed = math.ceil(wDia*math.pi*_lRPM/60/_Tune.Ratios[#_Tune.Ratios]/_Tune.FinalDrive)
local spInc = math.max(math.ceil(maxSpeed/200)*20,20)

for i=0,revEnd*2 do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Tach
	ln.Rotation = 45 + i * 225 / (revEnd*2)
	ln.Num.Text = i/2
	ln.Num.Rotation = -ln.Rotation
	if i*500>=math.floor(_pRPM/500)*500 then
		ln.Frame.BackgroundColor3 = Color3.new(1,0,0)
		if i<revEnd*2 then
			ln2 = ln:clone()
			ln2.Parent = script.Parent.Tach
			ln2.Rotation = 45 + (i+.5) * 225 / (revEnd*2)
			ln2.Num:Destroy()
			ln2.Visible=true
		end
	end
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,3,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
		ln.Num.Visible = true
	else
		ln.Num:Destroy()
	end
	ln.Visible=true
end

for i=1,90 do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Speedo
	ln.Rotation = 45 + 225*(i/90)
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,2,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
	else
		ln.Frame.Size = UDim2.new(0,3,0,5)
	end
	ln.Num:Destroy()
	ln.Visible=true
end
for i=0,maxSpeed,spInc do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Speedo
	ln.Rotation = 45 + 225*(i/maxSpeed)
	ln.Num.Text = i
	ln.Num.Rotation = -ln.Rotation
	ln.Frame:Destroy()
	ln.Num.Visible=true
	ln.Visible=true
end

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

script.Parent.Parent.Values.RPM.Changed:connect(function()
	script.Parent.Tach.Needle.Rotation = 45 + 225 * math.min(1,script.Parent.Parent.Values.RPM.Value / (revEnd*1000))
end)

script.Parent.Parent.Values.Gear.Changed:connect(function()
	local gearText = script.Parent.Parent.Values.Gear.Value
	if gearText == 0 then gearText = "N"
	elseif gearText == -1 then gearText = "R"
	end
	script.Parent.Gear.Text = gearText
end)

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

script.Parent.Parent.Values.TCSActive.Changed:connect(function()
	if script.Parent.Parent.Values.TCSActive.Value and script.Parent.Parent.Values.TCS.Value then
		wait()
		script.Parent.TCS.Visible = not script.Parent.TCS.Visible
	else
		wait()
		script.Parent.TCS.Visible = false
	end
end)

script.Parent.TCS.Changed:connect(function()
	if script.Parent.Parent.Values.TCSActive.Value and script.Parent.Parent.Values.TCS.Value then
		wait()
		script.Parent.TCS.Visible = not script.Parent.TCS.Visible
	end
end)

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

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

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


Prompt: -- A function to play fire sounds.

Response:
function PlayFireSound()
	local NewSound = FireSound:Clone()
	NewSound.Parent = Handle
	NewSound:Play()
	Debris:AddItem(NewSound, NewSound.TimeLength)
end


Prompt: -- In radians the minimum accuracy penalty

Response: local MinSpread = 0.05


Prompt: -- Loop through all players when model added

Response:
for _, player in pairs(game.Players:GetPlayers()) do
	addScriptAtRespawn(player)
	addMyLocalScript(player)
end


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

Response:
Lift:WaitForChild("Direction").Changed:connect(function(val)
    if val == 1 then
		This.Display.ARW1.Up1.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.Up2.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.Down1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.Down2.BrickColor = BrickColor.new("Really black")
    elseif val == -1 then
		This.Display.ARW1.Up1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.Up2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.Down1.BrickColor = BrickColor.new("Really red")
		This.Display.ARW1.Down2.BrickColor = BrickColor.new("Really red")
	else
		This.Display.ARW1.Up1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.Up2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.Down1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.Down2.BrickColor = BrickColor.new("Really black")
    end
end)


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

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


Prompt:
--[[ << ASSET PERMISSIONS >> (e.g. Gamepasses, Shirts, Models etc)
Format:  [AssetId] = "PermissionName" OR PermissionNumber ;																																													]]

Response:
Asset_Permissions={
	[0] = "Mod";
}																																																											;


Prompt: -- externally played animations

Response:
local playEmoteEvent = script:WaitForChild("PlayEmote")
playEmoteEvent.OnInvoke = playEmote


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

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

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

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

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

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

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

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

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


Prompt: --strategy that you walk around the opponent while running away


Prompt: -- Returns module (possibly nil) and success code to differentiate returning nil due to error vs Scriptable

Response:
function ControlModule:SelectComputerMovementModule(): ({}?, boolean)
	if not (UserInputService.KeyboardEnabled or UserInputService.GamepadEnabled) then
		return nil, false
	end

	local computerModule
	local DevMovementMode = Players.LocalPlayer.DevComputerMovementMode

	if DevMovementMode == Enum.DevComputerMovementMode.UserChoice then
		computerModule = computerInputTypeToModuleMap[lastInputType]
		if UserGameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove and computerModule == Keyboard then
			-- User has ClickToMove set in Settings, prefer ClickToMove controller for keyboard and mouse lastInputTypes
			computerModule = ClickToMove
		end
	else
		-- Developer has selected a mode that must be used.
		computerModule = movementEnumToModuleMap[DevMovementMode]

		-- computerModule is expected to be nil here only when developer has selected Scriptable
		if (not computerModule) and DevMovementMode ~= Enum.DevComputerMovementMode.Scriptable then
			warn("No character control module is associated with DevComputerMovementMode ", DevMovementMode)
		end
	end

	if computerModule then
		return computerModule, true
	elseif DevMovementMode == Enum.DevComputerMovementMode.Scriptable then
		-- Special case where nil is returned and we actually want to set self.activeController to nil for Scriptable
		return nil, true
	else
		-- This case is for when computerModule is nil because of an error and no suitable control module could
		-- be found.
		return nil, false
	end
end


Prompt: --// Firemode Shot Customization

Response:
	BurstNum = 3; -- How many bullets per burst
	ShotNum = 5; -- How many bullets per shot


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

	@param value The value to check against

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

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


Prompt: --// bolekinds

Response:
workspace.Roommate.Head.Dialog.DialogChoiceSelected:Connect(function(player,choice)
	if choice.Name == "Gimme rent" then
		game.ReplicatedStorage.Rent:FireServer()
	elseif choice.Name == "I'm raising your rent" then
		game.ReplicatedStorage.Raise:FireServer()
	end
end)


Prompt: --Folders

Response: local servicesFolder = ServerStorage:WaitForChild("Services")


Prompt:
--[=[
	@param tag string
	@param class table
	@param renderPriority number?
	@param requireComponents {string}?
	@return Component

	Constructs a new component class.
]=]

Response:
function Component.new(tag, class, renderPriority, requireComponents)

	assert(type(tag) == "string", "Argument #1 (tag) should be a string; got " .. type(tag))
	assert(type(class) == "table", "Argument #2 (class) should be a table; got " .. type(class))
	assert(type(class.new) == "function", "Class must contain a .new constructor function")
	assert(type(class.Destroy) == "function", "Class must contain a :Destroy function")
	assert(componentsByTag[tag] == nil, "Component already bound to this tag")

	local self = setmetatable({}, Component)

	self._trove = Trove.new()
	self._lifecycleTrove = self._trove:Construct(Trove)
	self._tag = tag
	self._class = class
	self._objects = {}
	self._instancesToObjects = {}
	self._hasHeartbeatUpdate = (type(class.HeartbeatUpdate) == "function")
	self._hasSteppedUpdate = (type(class.SteppedUpdate) == "function")
	self._hasRenderUpdate = (type(class.RenderUpdate) == "function")
	self._hasInit = (type(class.Init) == "function")
	self._hasDeinit = (type(class.Deinit) == "function")
	self._renderPriority = renderPriority or Enum.RenderPriority.Last.Value
	self._requireComponents = requireComponents or {}
	self._lifecycle = false
	self._nextId = 0

	self.Added = self._trove:Construct(Signal)
	self.Removed = self._trove:Construct(Signal)

	local observeTrove = self._trove:Construct(Trove)

	local function ObserveTag()

		local function HasRequiredComponents(instance)
			for _,reqComp in ipairs(self._requireComponents) do
				local comp = Component.FromTag(reqComp)
				if comp:GetFromInstance(instance) == nil then
					return false
				end
			end
			return true
		end

		observeTrove:Connect(CollectionService:GetInstanceAddedSignal(tag), function(instance)
			if IsDescendantOfWhitelist(instance) and HasRequiredComponents(instance) then
				self:_instanceAdded(instance)
			end
		end)

		observeTrove:Connect(CollectionService:GetInstanceRemovedSignal(tag), function(instance)
			self:_instanceRemoved(instance)
		end)

		for _,reqComp in ipairs(self._requireComponents) do
			local comp = Component.FromTag(reqComp)
			observeTrove:Connect(comp.Added, function(obj)
				if CollectionService:HasTag(obj.Instance, tag) and HasRequiredComponents(obj.Instance) then
					self:_instanceAdded(obj.Instance)
				end
			end)
			observeTrove:Connect(comp.Removed, function(obj)
				if CollectionService:HasTag(obj.Instance, tag) then
					self:_instanceRemoved(obj.Instance)
				end
			end)
		end

		observeTrove:Add(function()
			self:_stopLifecycle()
			for instance in pairs(self._instancesToObjects) do
				self:_instanceRemoved(instance)
			end
		end)

		do
			for _,instance in ipairs(CollectionService:GetTagged(tag)) do
				if IsDescendantOfWhitelist(instance) and HasRequiredComponents(instance) then
					task.defer(function()
						self:_instanceAdded(instance)
					end)
				end
			end
		end

	end

	if #self._requireComponents == 0 then
		ObserveTag()
	else
		-- Only observe tag when all required components are available:
		local tagsReady = {}
		local function Check()
			for _,ready in pairs(tagsReady) do
				if not ready then
					return
				end
			end
			ObserveTag()
		end
		local function Cleanup()
			observeTrove:Clean()
		end
		for _,requiredComponent in ipairs(self._requireComponents) do
			tagsReady[requiredComponent] = false
		end
		for _,requiredComponent in ipairs(self._requireComponents) do
			self._trove:Add(Component.ObserveFromTag(requiredComponent, function(_component, trove)
				tagsReady[requiredComponent] = true
				Check()
				trove:Add(function()
					tagsReady[requiredComponent] = false
					Cleanup()
				end)
			end))
		end
	end

	componentsByTag[tag] = self
	componentByTagCreated:Fire(self)
	self._trove:Add(function()
		componentsByTag[tag] = nil
		componentByTagDestroyed:Fire(self)
	end)

	return self

end

function Component:_startHeartbeatUpdate()
	local all = self._objects
	self._heartbeatUpdate = RunService.Heartbeat:Connect(function(dt)
		for _,v in ipairs(all) do
			v:HeartbeatUpdate(dt)
		end
	end)
	self._lifecycleTrove:Add(self._heartbeatUpdate)
end

function Component:_startSteppedUpdate()
	local all = self._objects
	self._steppedUpdate = RunService.Stepped:Connect(function(_, dt)
		for _,v in ipairs(all) do
			v:SteppedUpdate(dt)
		end
	end)
	self._lifecycleTrove:Add(self._steppedUpdate)
end

function Component:_startRenderUpdate()
	local all = self._objects
	self._renderName = (self._tag .. "RenderUpdate")
	RunService:BindToRenderStep(self._renderName, self._renderPriority, function(dt)
		for _,v in ipairs(all) do
			v:RenderUpdate(dt)
		end
	end)
	self._lifecycleTrove:Add(function()
		RunService:UnbindFromRenderStep(self._renderName)
	end)
end

function Component:_startLifecycle()
	self._lifecycle = true
	if self._hasHeartbeatUpdate then
		self:_startHeartbeatUpdate()
	end
	if self._hasSteppedUpdate then
		self:_startSteppedUpdate()
	end
	if self._hasRenderUpdate then
		self:_startRenderUpdate()
	end
end

function Component:_stopLifecycle()
	self._lifecycle = false
	self._lifecycleTrove:Clean()
end

function Component:_instanceAdded(instance)
	if self._instancesToObjects[instance] then return end
	if not self._lifecycle then
		self:_startLifecycle()
	end
	self._nextId = (self._nextId + 1)
	local id = (self._tag .. tostring(self._nextId))
	if IS_SERVER then
		instance:SetAttribute(ATTRIBUTE_ID_NAME, id)
	end
	local obj = self._class.new(instance)
	obj.Instance = instance
	obj._id = id
	self._instancesToObjects[instance] = obj
	table.insert(self._objects, obj)
	if self._hasInit then
		task.defer(function()
			if self._instancesToObjects[instance] ~= obj then return end
			obj:Init()
		end)
	end
	self.Added:Fire(obj)
	return obj
end

function Component:_instanceRemoved(instance)
	if not self._instancesToObjects[instance] then return end
	self._instancesToObjects[instance] = nil
	for i,obj in ipairs(self._objects) do
		if obj.Instance == instance then
			if self._hasDeinit then
				obj:Deinit()
			end
			if IS_SERVER and instance.Parent and instance:GetAttribute(ATTRIBUTE_ID_NAME) ~= nil then
				instance:SetAttribute(ATTRIBUTE_ID_NAME, nil)
			end
			self.Removed:Fire(obj)
			obj:Destroy()
			obj._destroyed = true
			TableUtil.SwapRemove(self._objects, i)
			break
		end
	end
	if #self._objects == 0 and self._lifecycle then
		self:_stopLifecycle()
	end
end


Response:
local KeyframeAnimation = script.Animation.Value
local rig = script.Rig.Value
local origin = script.Origin.Value

local keyframeList = KeyframeAnimation:GetKeyframes()

local KFNumber = 1
local maxKFNumber = #keyframeList

local basePositions = {}
local lastPositions = {}
local desiredPositions = {}


Prompt: -- constants

Response:
local SQUADS	= ReplicatedStorage.Squads
local REMOTES	= ReplicatedStorage.Remotes


Prompt: -- Cosmetic bullet container

Response:
local CosmeticBulletsFolder = workspace:FindFirstChild("CosmeticBulletsFolder") or Instance.new("Folder", workspace)
CosmeticBulletsFolder.Name = "CosmeticBulletsFolder"


Prompt: -- Decompiled with Visenya | https://targaryentech.com

Response:
wait(0.1)
local car = script.Parent.Car.Value
local handler = car.Backfire
while wait(0.1) do
  local randomability = math.random(1, 2)
  if script.Parent.Values.RPM.Value > 5000 and randomability <= 1 and script.Parent.Values.Throttle.Value < 0.05 then
    wait(0.03)
    wait(0.07)
  end
  handler:FireServer("Heat", math.max(math.min(car.Body.Exhaust.Hot1.Texture.Transparency + 0.005 * (script.Parent.Values.RPM.Value / 5000 * script.Parent.Values.Throttle.Value) - 0.003, 1), 0))
  handler:FireServer("Heat", math.max(math.min(car.Body.Exhaust.Hot1.Texture2.Transparency + 0.005 * (script.Parent.Values.RPM.Value / 5000 * script.Parent.Values.Throttle.Value) - 0.003, 1), 0))
  handler:FireServer("Heat", math.max(math.min(car.Body.Exhaust.Hot1.Texture3.Transparency + 0.005 * (script.Parent.Values.RPM.Value / 5000 * script.Parent.Values.Throttle.Value) - 0.003, 1), 0))
  handler:FireServer("Heat", math.max(math.min(car.Body.Exhaust.Hot1.Texture4.Transparency + 0.005 * (script.Parent.Values.RPM.Value / 5000 * script.Parent.Values.Throttle.Value) - 0.003, 1), 0))
  handler:FireServer("Heat", math.max(math.min(car.Body.Exhaust.Hot1.Texture5.Transparency + 0.005 * (script.Parent.Values.RPM.Value / 5000 * script.Parent.Values.Throttle.Value) - 0.003, 1), 0))
  handler:FireServer("Heat", math.max(math.min(car.Body.Exhaust.Hot1.Texture6.Transparency + 0.005 * (script.Parent.Values.RPM.Value / 5000 * script.Parent.Values.Throttle.Value) - 0.003, 1), 0))
  if car.Body.Exhaust.Hot1.Texture.Transparency > 0.9 then
    car.Body.Exhaust.Hot1.Texture2.Transparency = 0.9
    car.Body.Exhaust.Hot1.Texture3.Transparency = 0.9
    car.Body.Exhaust.Hot1.Texture4.Transparency = 0.9
    car.Body.Exhaust.Hot1.Texture5.Transparency = 0.9
    car.Body.Exhaust.Hot1.Texture6.Transparency = 0.9
    value2 = NumberRange.new(5 * script.Parent.Values.Throttle.Value, 10 * script.Parent.Values.Throttle.Value)
    value3 = 100 * script.Parent.Values.Throttle.Value
    handler:FireServer("Sparks", true, value2, value3)
  else
    handler:FireServer("Sparks", false)
  end
end


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

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

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

	-- check for config values
	local config = script:FindFirstChild(name)
	if (config ~= nil) then
		--		print("Loading anims " .. name)
		table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
		table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))
		local idx = 1
		for _, childPart in pairs(config:GetChildren()) do
			if (childPart:IsA("Animation")) then
				table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
				animTable[name][idx] = {}
				animTable[name][idx].anim = childPart
				local weightObject = childPart:FindFirstChild("Weight")
				if (weightObject == nil) then
					animTable[name][idx].weight = 1
				else
					animTable[name][idx].weight = weightObject.Value
				end
				animTable[name].count = animTable[name].count + 1
				animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
				--			print(name .. " [" .. idx .. "] " .. animTable[name][idx].anim.AnimationId .. " (" .. animTable[name][idx].weight .. ")")
				idx = idx + 1
			end
		end
	end

	-- fallback to defaults
	if (animTable[name].count <= 0) then
		for idx, anim in pairs(fileList) do
			animTable[name][idx] = {}
			animTable[name][idx].anim = Instance.new("Animation")
			animTable[name][idx].anim.Name = name
			animTable[name][idx].anim.AnimationId = anim.id
			animTable[name][idx].weight = anim.weight
			animTable[name].count = animTable[name].count + 1
			animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
			--			print(name .. " [" .. idx .. "] " .. anim.id .. " (" .. anim.weight .. ")")
		end
	end
end


Prompt:
-----------------
--| Constants |--
-----------------

Response:
local BLAST_RADIUS = 8 -- Blast radius of the explosion
local BLAST_DAMAGE = 60 -- Amount of damage done to players
local BLAST_FORCE = 1000 -- Amount of force applied to parts

local IGNORE_LIST = {rocket = 1, handle = 1, effect = 1, water = 1} -- Rocket will fly through things named these


Prompt: -- Attack state

Response:
local attacking = false
local searchingForTargets = false


Prompt:
--////////////////////////////// Methods
--//////////////////////////////////////

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

function methods:SendSystemMessage(message, extraData)
	local messageObj = self:InternalCreateMessageObject(message, nil, true, extraData)

	local success, err = pcall(function() self.eMessagePosted:Fire(messageObj) end)
	if not success and err then
		print("Error posting message: " ..err)
	end

	self:InternalAddMessageToHistoryLog(messageObj)

	for i, speaker in pairs(self.Speakers) do
		speaker:InternalSendSystemMessage(messageObj, self.Name)
	end

	return messageObj
end

function methods:SendSystemMessageToSpeaker(message, speakerName, extraData)
	local speaker = self.Speakers[speakerName]
	if (speaker) then
		local messageObj = self:InternalCreateMessageObject(message, nil, true, extraData)
		speaker:InternalSendSystemMessage(messageObj, self.Name)
	elseif RunService:IsStudio() then
		warn(string.format("Speaker '%s' is not in channel '%s' and cannot be sent a system message", speakerName, self.Name))
	end
end

function methods:SendMessageObjToFilters(message, messageObj, fromSpeaker)
	local oldMessage = messageObj.Message
	messageObj.Message = message
	self:InternalDoMessageFilter(fromSpeaker.Name, messageObj, self.Name)
	self.ChatService:InternalDoMessageFilter(fromSpeaker.Name, messageObj, self.Name)
	local newMessage = messageObj.Message
	messageObj.Message = oldMessage
	return newMessage
end

function methods:CanCommunicateByUserId(userId1, userId2)
	if RunService:IsStudio() then
		return true
	end
	-- UserId is set as 0 for non player speakers.
	if userId1 == 0 or userId2 == 0 then
		return true
	end
	local success, canCommunicate = pcall(function()
		return Chat:CanUsersChatAsync(userId1, userId2)
	end)
	return success and canCommunicate
end

function methods:CanCommunicate(speakerObj1, speakerObj2)
	local player1 = speakerObj1:GetPlayer()
	local player2 = speakerObj2:GetPlayer()
	if player1 and player2 then
		return self:CanCommunicateByUserId(player1.UserId, player2.UserId)
	end
	return true
end

function methods:SendMessageToSpeaker(message, speakerName, fromSpeakerName, extraData)
	local speakerTo = self.Speakers[speakerName]
	local speakerFrom = self.ChatService:GetSpeaker(fromSpeakerName)
	if speakerTo and speakerFrom then
		local isMuted = speakerTo:IsSpeakerMuted(fromSpeakerName)
		if isMuted then
			return
		end

		if not self:CanCommunicate(speakerTo, speakerFrom) then
			return
		end

		-- We need to claim the message is filtered even if it not in this case for compatibility with legacy client side code.
		local isFiltered = speakerName == fromSpeakerName
		local messageObj = self:InternalCreateMessageObject(message, fromSpeakerName, isFiltered, extraData)
		message = self:SendMessageObjToFilters(message, messageObj, fromSpeakerName)
		speakerTo:InternalSendMessage(messageObj, self.Name)

		local textContext = self.Private and Enum.TextFilterContext.PrivateChat or Enum.TextFilterContext.PublicChat
		local filterSuccess, isFilterResult, filteredMessage = self.ChatService:InternalApplyRobloxFilterNewAPI(
			messageObj.FromSpeaker,
			message,
			textContext
		)
		if (filterSuccess) then
			messageObj.FilterResult = filteredMessage
			messageObj.IsFilterResult = isFilterResult
			messageObj.IsFiltered = true
			speakerTo:InternalSendFilteredMessageWithFilterResult(messageObj, self.Name)
		end
	elseif RunService:IsStudio() then
		warn(string.format("Speaker '%s' is not in channel '%s' and cannot be sent a message", speakerName, self.Name))
	end
end

function methods:KickSpeaker(speakerName, reason)
	local speaker = self.ChatService:GetSpeaker(speakerName)
	if (not speaker) then
		error("Speaker \"" .. speakerName .. "\" does not exist!")
	end

	local messageToSpeaker = ""
	local messageToChannel = ""
	local playerName = speaker:GetNameForDisplay()

	if (reason) then
		messageToSpeaker = string.format("You were kicked from '%s' for the following reason(s): %s", self.Name, reason)
		messageToChannel = string.format("%s was kicked for the following reason(s): %s", playerName, reason)
	else
		messageToSpeaker = string.format("You were kicked from '%s'", self.Name)
		messageToChannel = string.format("%s was kicked", playerName)
	end

	self:SendSystemMessageToSpeaker(messageToSpeaker, speakerName)
	speaker:LeaveChannel(self.Name)
	self:SendSystemMessage(messageToChannel)
end

function methods:MuteSpeaker(speakerName, reason, length)
	local speaker = self.ChatService:GetSpeaker(speakerName)
	if (not speaker) then
		error("Speaker \"" .. speakerName .. "\" does not exist!")
	end

	self.Mutes[speakerName:lower()] = (length == 0 or length == nil) and 0 or (os.time() + length)

	if (reason) then
		local playerName = speaker:GetNameForDisplay()

		self:SendSystemMessage(string.format("%s was muted for the following reason(s): %s", playerName, reason))
	end

	local success, err = pcall(function() self.eSpeakerMuted:Fire(speakerName, reason, length) end)
	if not success and err then
		print("Error mutting speaker: " ..err)
	end

	local spkr = self.ChatService:GetSpeaker(speakerName)
	if (spkr) then
		local success, err = pcall(function() spkr.eMuted:Fire(self.Name, reason, length) end)
		if not success and err then
			print("Error mutting speaker: " ..err)
		end
	end

end

function methods:UnmuteSpeaker(speakerName)
	local speaker = self.ChatService:GetSpeaker(speakerName)
	if (not speaker) then
		error("Speaker \"" .. speakerName .. "\" does not exist!")
	end

	self.Mutes[speakerName:lower()] = nil

	local success, err = pcall(function() self.eSpeakerUnmuted:Fire(speakerName) end)
	if not success and err then
		print("Error unmuting speaker: " ..err)
	end

	local spkr = self.ChatService:GetSpeaker(speakerName)
	if (spkr) then
		local success, err = pcall(function() spkr.eUnmuted:Fire(self.Name) end)
		if not success and err then
			print("Error unmuting speaker: " ..err)
		end
	end
end

function methods:IsSpeakerMuted(speakerName)
	return (self.Mutes[speakerName:lower()] ~= nil)
end

function methods:GetSpeakerList()
	local list = {}
	for i, speaker in pairs(self.Speakers) do
		table.insert(list, speaker.Name)
	end
	return list
end

function methods:RegisterFilterMessageFunction(funcId, func, priority)
	if self.FilterMessageFunctions:HasFunction(funcId) then
		error(string.format("FilterMessageFunction '%s' already exists", funcId))
	end
	self.FilterMessageFunctions:AddFunction(funcId, func, priority)
end

function methods:FilterMessageFunctionExists(funcId)
	return self.FilterMessageFunctions:HasFunction(funcId)
end

function methods:UnregisterFilterMessageFunction(funcId)
	if not self.FilterMessageFunctions:HasFunction(funcId) then
		error(string.format("FilterMessageFunction '%s' does not exists", funcId))
	end
	self.FilterMessageFunctions:RemoveFunction(funcId)
end

function methods:RegisterProcessCommandsFunction(funcId, func, priority)
	if self.ProcessCommandsFunctions:HasFunction(funcId) then
		error(string.format("ProcessCommandsFunction '%s' already exists", funcId))
	end
	self.ProcessCommandsFunctions:AddFunction(funcId, func, priority)
end

function methods:ProcessCommandsFunctionExists(funcId)
	return self.ProcessCommandsFunctions:HasFunction(funcId)
end

function methods:UnregisterProcessCommandsFunction(funcId)
	if not self.ProcessCommandsFunctions:HasFunction(funcId) then
		error(string.format("ProcessCommandsFunction '%s' does not exist", funcId))
	end
	self.ProcessCommandsFunctions:RemoveFunction(funcId)
end

local function ShallowCopy(table)
	local copy = {}
	for i, v in pairs(table) do
		copy[i] = v
	end
	return copy
end

function methods:GetHistoryLog()
	return ShallowCopy(self.ChatHistory)
end

function methods:GetHistoryLogForSpeaker(speaker)
	local userId = -1
	local player = speaker:GetPlayer()
	if player then
		userId = player.UserId
	end
	local chatlog = {}

	for i = 1, #self.ChatHistory do
		local logUserId = self.ChatHistory[i].SpeakerUserId
		if self:CanCommunicateByUserId(userId, logUserId) then
			local messageObj = ShallowCopy(self.ChatHistory[i])

			--// Since we're using the new filter API, we need to convert the stored filter result
			--// into an actual string message to send to players for their chat history.
			--// System messages aren't filtered the same way, so they just have a regular
			--// text value in the Message field.
			if (messageObj.MessageType == ChatConstants.MessageTypeDefault or messageObj.MessageType == ChatConstants.MessageTypeMeCommand) then
				local filterResult = messageObj.FilterResult
				if (messageObj.IsFilterResult) then
					if (player) then
						messageObj.Message = filterResult:GetChatForUserAsync(player.UserId)
					else
						messageObj.Message = filterResult:GetNonChatStringForBroadcastAsync()
					end
				else
					messageObj.Message = filterResult
				end
			end

			table.insert(chatlog, messageObj)
		end
	end
	return chatlog
end


Prompt: -- Colors

Response:
Border.Color = Colors.White

ContainerGui:GetAttributeChangedSignal("ThemeColor"):Connect(function()
	local themeColor = ContainerGui:GetAttribute("ThemeColor")
	Gradient.Color = ColorSequence.new(themeColor)
end)


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

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

script.Parent.Parent.Values.Gear.Changed:Connect(function()
	local gearText = script.Parent.Parent.Values.Gear.Value
	if gearText == 0 then
		gearText = "N"
		car.Body.Dash.D.G.Info.Gear.Text = "N"
		car.DriveSeat.Filter:FireServer('reverse',false)
	elseif gearText == -1 then
		gearText = "R"
		car.Body.Dash.D.G.Info.Gear.Text = "R"
		car.DriveSeat.Filter:FireServer('reverse',true)
	else
		gearText = "D"
	end
		car.Body.Dash.D.G.Info.Gear.Text = gearText
		script.Parent.Tac.G.Gear.Text = gearText
end)

while wait() do
	local speed = math.floor(UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude)
	for i, v in pairs(script.Parent.Tac.G:GetChildren()) do
		if v:IsA("Frame") and v.Name ~= "Unit" then
			local rt = math.abs(script.Parent.Tac.G.Needle.AbsoluteRotation - (v.AbsoluteRotation))
			v.Num.TextSize = math.max(18,(18 - (((rt/4)^2)-18)))
		end
	end
	for i, u in pairs(script.Parent.Spd.G:GetChildren()) do
		for j,v in pairs(u:GetChildren()) do
			if v:IsA("Frame") and v.Name ~= "Unit" then
				local st = math.abs(script.Parent.Spd.G.Needle.AbsoluteRotation - (v.AbsoluteRotation))
				if v:FindFirstChild("Num") then
					v.Num.TextSize = math.max(16,(16 - (((st/4)^2)-16)))
				end
			end
		end
	end
end


Response:
	,Distance = 10000
	,BDrop = .25
	,BSpeed = 2200

	,SuppressMaxDistance = 25	--- Studs
	,SuppressTime = 10			--- Seconds

	,BulletWhiz = true
	,BWEmitter = 25
	,BWMaxDistance = 200

	,BulletFlare = false
	,BulletFlareColor = Color3.fromRGB(255,255,255)

	,Tracer = true
	,TracerColor = Color3.fromRGB(255,255,255)
	,TracerLightEmission = 1
	,TracerLightInfluence = 0
	,TracerLifeTime = .2
	,TracerWidth = .1
	,RandomTracer = false
	,TracerEveryXShots = 3
	,TracerChance = 100

	,BulletLight = false
	,BulletLightBrightness = 1
	,BulletLightColor = Color3.fromRGB(255,255,255)
	,BulletLightRange = 10

	,ExplosiveHit = false
	,ExPressure = 500
	,ExpRadius = 25
	,DestroyJointRadiusPercent = 0	--- Between 0 & 1
	,ExplosionDamage = 100

	,LauncherDamage = 100
	,LauncherRadius = 25
	,LauncherPressure = 500
	,LauncherDestroyJointRadiusPercent = 0


Prompt: -- setup emote chat hook

Response:
script.msg.Changed:connect(function(msg)
	script.msg.Value = ""
	local emote = ""
	if (string.sub(msg, 1, 3) == "/e ") then
		emote = string.sub(msg, 4)
	elseif (string.sub(msg, 1, 7) == "/emote ") then
		emote = string.sub(msg, 8)
	end

	if (pose == "Standing" and emoteNames[emote] ~= nil) then
		playAnimation(emote, 0.1, Humanoid)
	end


Prompt: -- GROUPS

Response:
Groups = {
	[0] = {
		[254] = "Admin";
		[1] = "VIP";
		};
};


Prompt: --------------------[ GUI UPDATE FUNCTIONS ]------------------------------------------

Response:
local function updateClipAmmo()
	clipAmmoGUI.Text = Ammo.Value
	clipAmmoGUI.TextColor3 = (Ammo.Value <= (ClipSize.Value / 3) and Color3.new(1, 0, 0) or Color3.new(1, 1, 1))
end

local function updateStoredAmmo()
	storedAmmoGUI.Text = StoredAmmo.Value
	storedAmmoGUI.TextColor3 = (StoredAmmo.Value <= (ClipSize.Value * 2) and Color3.new(1, 0, 0) or Color3.new(1, 1, 1))
end

local function updateHealth()
	HUD.Health.Num.Text = CEIL(Humanoid.Health).."%"
	HUD.Health.Num.TextColor3 = (
		(Humanoid.Health > 200 / 3) and Color3.new(1, 1, 1) or
		(Humanoid.Health <= 200 / 3 and Humanoid.Health > 100 / 3) and Color3.new(1, 1, 0) or
		(Humanoid.Health <= 100 / 3) and Color3.new(1, 0, 0)
	)
end

local function updateModeLabels(prevState, newState, X)
	for Num, Mode in pairs(fireModes:GetChildren()) do
		local guiAngOffset2 = guiAngOffset + 90
		local Ang = numLerp(
			(guiAngOffset2 * prevState) - (guiAngOffset2 * Num) - guiAngOffset2,
			(guiAngOffset2 * newState) - (guiAngOffset2 * Num) - guiAngOffset2,
			Sine(X)
		) + guiAngOffset
		local XPos = COS(RAD(Ang))
		local YPos = SIN(RAD(Ang))
		Mode.Position = UDim2.new(0.5, XPos * 100, 0.5, YPos * 100)

		local R = COS(math.atan2(Mode.Position.Y.Offset, Mode.Position.X.Offset) + RAD(90))
		Mode.Label.TextTransparency = 1 - ((R / 4) + 0.75)

		local Scale = (R * 10) + 50
		Mode.Label.Position = UDim2.new(0, -Scale / 2, 0, 0)
		Mode.Label.Size = UDim2.new(0, Scale, 0, Scale / 2)
	end
end


Prompt: --// Input Connections

Response:
L_101_.InputBegan:connect(function(L_303_arg1, L_304_arg2)
	if not L_304_arg2 and L_15_ then
		if L_303_arg1.UserInputType == Enum.UserInputType.MouseButton2 or L_303_arg1.KeyCode == Enum.KeyCode.ButtonL2 and not L_75_ and not L_74_ and L_24_.CanAim and not L_71_ and L_15_ and not L_63_ and not L_64_ then
			if not L_61_ then
				if not L_62_ then
					L_3_.Humanoid.WalkSpeed = 10
					L_148_ = 10
					L_147_ = 0.008
				end

				if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude <= 2 then
					L_93_ = L_50_
				end
				L_126_.target = L_53_.CFrame:toObjectSpace(L_44_.CFrame).p
				L_109_:FireServer(true)
				L_61_ = true
			end
		end;

		if L_303_arg1.KeyCode == Enum.KeyCode.E and L_15_ and not L_76_ and not L_77_ then
			L_76_ = true
			L_78_ = false
			L_77_ = true
			LeanRight()
		end

		if L_303_arg1.KeyCode == Enum.KeyCode.Q and L_15_ and not L_76_ and not L_78_ then
			L_76_ = true
			L_77_ = false
			L_78_ = true
			LeanLeft()
		end

		if L_303_arg1.KeyCode == L_24_.AlternateAimKey and not L_75_ and not L_74_ and L_24_.CanAim and not L_71_ and L_15_ and not L_63_ and not L_64_ then
			if not L_61_ then
				if not L_62_ then
					L_3_.Humanoid.WalkSpeed = 10
					L_148_ = 10
					L_147_ = 0.008
				end
				L_93_ = L_50_
				L_126_.target = L_53_.CFrame:toObjectSpace(L_44_.CFrame).p
				L_109_:FireServer(true)
				L_61_ = true
			end
		end;

		if L_303_arg1.UserInputType == Enum.UserInputType.MouseButton1 or L_303_arg1.KeyCode == Enum.KeyCode.ButtonR2 and not L_74_ and L_66_ and L_15_ and not L_63_ and not L_64_ and not L_71_ then
			L_65_ = true
			if not Shooting and L_15_ and not L_79_ then
				if L_97_ > 0 then
					Shoot()
				end
			elseif not Shooting and L_15_ and L_79_ then
				if L_99_ > 0 then
					Shoot()
				end
			end
		end;

		if L_303_arg1.KeyCode == L_24_.LaserKey or L_303_arg1.KeyCode == Enum.KeyCode.DPadRight and L_15_ and L_24_.LaserAttached then
			local L_305_ = L_1_:FindFirstChild("LaserLight")
			L_115_.KeyDown[1].Plugin()
		end;

		if L_303_arg1.KeyCode == L_24_.LightKey or L_303_arg1.KeyCode == Enum.KeyCode.ButtonR3 and L_15_ and L_24_.LightAttached then
			local L_306_ = L_1_:FindFirstChild("FlashLight"):FindFirstChild('Light')
			local L_307_ = false
			L_306_.Enabled = not L_306_.Enabled
		end;

		if L_15_ and L_303_arg1.KeyCode == L_24_.FireSelectKey or L_303_arg1.KeyCode == Enum.KeyCode.DPadUp and not L_67_ and not L_75_ then
			L_67_ = true
			if L_88_ == 1 then
				if Shooting then
					Shooting = false
				end
				if L_24_.AutoEnabled then
					L_88_ = 2
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.AutoEnabled and L_24_.BurstEnabled then
					L_88_ = 3
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.AutoEnabled and not L_24_.BurstEnabled and L_24_.BoltAction then
					L_88_ = 4
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.AutoEnabled and not L_24_.BurstEnabled and not L_24_.BoltAction and L_24_.ExplosiveEnabled then
					L_88_ = 6
					L_79_ = true
					L_80_ = L_66_
					L_66_ = L_81_
				elseif not L_24_.AutoEnabled and not L_24_.BurstEnabled and not L_24_.BoltAction and not L_24_.ExplosiveEnabled then
					L_88_ = 1
					L_79_ = false
					L_66_ = L_80_
				end
			elseif L_88_ == 2 then
				if Shooting then
					Shooting = false
				end
				if L_24_.BurstEnabled then
					L_88_ = 3
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.BurstEnabled and L_24_.BoltAction then
					L_88_ = 4
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.BurstEnabled and not L_24_.BoltAction and L_24_.ExplosiveEnabled then
					L_88_ = 6
					L_79_ = true
					L_80_ = L_66_
					L_66_ = L_81_
				elseif not L_24_.BurstEnabled and not L_24_.BoltAction and not L_24_.ExplosiveEnabled and L_24_.SemiEnabled then
					L_88_ = 1
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.BurstEnabled and not L_24_.BoltAction and not L_24_.SemiEnabled then
					L_88_ = 2
					L_79_ = false
					L_66_ = L_80_
				end
			elseif L_88_ == 3 then
				if Shooting then
					Shooting = false
				end
				if L_24_.BoltAction then
					L_88_ = 4
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.BoltAction and L_24_.ExplosiveEnabled then
					L_88_ = 6
					L_79_ = true
					L_80_ = L_66_
					L_66_ = L_81_
				elseif not L_24_.BoltAction and not L_24_.ExplosiveEnabled and L_24_.SemiEnabled then
					L_88_ = 1
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.BoltAction and not L_24_.SemiEnabled and L_24_.AutoEnabled then
					L_88_ = 2
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.BoltAction and not L_24_.SemiEnabled and not L_24_.AutoEnabled then
					L_88_ = 3
					L_79_ = false
					L_66_ = L_80_
				end
			elseif L_88_ == 4 then
				if Shooting then
					Shooting = false
				end
				if L_24_.ExplosiveEnabled then
					L_88_ = 6
					L_79_ = true
					L_80_ = L_66_
					L_66_ = L_81_
				elseif not L_24_.ExplosiveEnabled and L_24_.SemiEnabled then
					L_88_ = 1
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and L_24_.AutoEnabled then
					L_88_ = 2
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and not L_24_.AutoEnabled and L_24_.BurstEnabled then
					L_88_ = 3
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and not L_24_.AutoEnabled and not L_24_.BurstEnabled then
					L_88_ = 4
					L_79_ = false
					L_66_ = L_80_
				end
			elseif L_88_ == 6 then
				if Shooting then
					Shooting = false
				end
				L_81_ = L_66_
				if L_24_.SemiEnabled then
					L_88_ = 1
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and L_24_.AutoEnabled then
					L_88_ = 2
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and not L_24_.AutoEnabled and L_24_.BurstEnabled then
					L_88_ = 3
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and not L_24_.AutoEnabled and not L_24_.BurstEnabled and L_24_.BoltAction then
					L_88_ = 4
					L_79_ = false
					L_66_ = L_80_
				elseif not L_24_.SemiEnabled and not L_24_.AutoEnabled and not L_24_.BurstEnabled and not L_24_.BoltAction then
					L_88_ = 6
					L_79_ = true
					L_80_ = L_66_
					L_66_ = L_81_
				end
			end
			UpdateAmmo()
			FireModeAnim()
			IdleAnim()
			L_67_ = false
		end;

		if L_303_arg1.KeyCode == Enum.KeyCode.F or L_303_arg1.KeyCode == Enum.KeyCode.DPadDown and not L_74_ and not L_75_ and not L_64_ and not L_67_ and not L_61_ and not L_63_ and not Shooting and not L_73_ then
			if not L_70_ and not L_71_ then
				L_71_ = true
				Shooting = false
				L_66_ = false
				L_128_ = time()
				delay(0.6, function()
					if L_97_ ~= L_24_.Ammo and L_97_ > 0 then
						CreateShell()
					end
				end)
				BoltBackAnim()
				L_70_ = true
			elseif L_70_ and L_71_ then
				BoltForwardAnim()
				Shooting = false
				L_66_ = true
				if L_97_ ~= L_24_.Ammo and L_97_ > 0 then
					L_97_ = L_97_ - 1
				elseif L_97_ >= L_24_.Ammo then
					L_66_ = true
				end
				L_70_ = false
				L_71_ = false
				IdleAnim()
				L_72_ = false
			end
			UpdateAmmo()
		end;

		if L_303_arg1.KeyCode == Enum.KeyCode.LeftShift or L_303_arg1.KeyCode == Enum.KeyCode.ButtonL3 and not L_75_ and not L_74_ and L_139_ and not L_61_ then
			L_68_ = true
			if L_15_ and not L_67_ and not L_64_ and L_68_ and not L_62_ and not L_71_ then
				Shooting = false
				L_61_ = false
				L_64_ = true

				delay(0, function()
					if L_64_ and not L_63_ then
						L_61_ = false
						L_69_ = true
					end
				end)
				L_93_ = 80
				L_3_.Humanoid.WalkSpeed = L_24_.SprintSpeed
				L_148_ = L_24_.SprintSpeed
				L_147_ = 0.4
			end
		end;

		if L_303_arg1.KeyCode == Enum.KeyCode.R or L_303_arg1.KeyCode == Enum.KeyCode.ButtonX and not L_75_ and not L_74_ and L_15_ and not L_63_ and not L_61_ and not Shooting and not L_64_ and not L_71_ then
			if not L_79_ then
				if L_98_ > 0 and L_97_ < L_24_.Ammo then
					Shooting = false
					L_63_ = true
					ReloadAnim()
					if L_97_ <= 0 then
						if not L_24_.CanSlideLock then
							BoltBackAnim()
							BoltForwardAnim()
						end
					end
					IdleAnim()
					L_66_ = true

					if L_97_ <= 0 then
						if (L_98_ - (L_24_.Ammo - L_97_)) < 0 then
							L_97_ = L_97_ + L_98_
							L_98_ = 0
						else
							L_98_ = L_98_ - (L_24_.Ammo - L_97_)
							L_97_ = L_24_.Ammo
						end
					elseif L_97_ > 0 then
						if (L_98_ - (L_24_.Ammo - L_97_)) < 0 then
							L_97_ = L_97_ + L_98_ + 1
							L_98_ = 0
						else
							L_98_ = L_98_ - (L_24_.Ammo - L_97_)
							L_97_ = L_24_.Ammo + 1
						end
					end

					L_63_ = false
					if not L_72_ then
						L_66_ = true
					end
				end;
			elseif L_79_ then
				if L_99_ > 0 then
					Shooting = false
					L_63_ = true
					nadeReload()
					IdleAnim()
					L_63_ = false
					L_66_ = true
				end
			end;
			UpdateAmmo()
		end;

		if L_303_arg1.KeyCode == Enum.KeyCode.RightBracket and L_61_ then
			if (L_51_ < 1) then
				L_51_ = L_51_ + L_24_.SensitivityIncrement
			end
		end

		if L_303_arg1.KeyCode == Enum.KeyCode.LeftBracket and L_61_ then
			if (L_51_ > 0.1) then
				L_51_ = L_51_ - L_24_.SensitivityIncrement
			end
		end

		if L_303_arg1.KeyCode == Enum.KeyCode.T or L_303_arg1.KeyCode == Enum.KeyCode.DPadLeft and L_1_:FindFirstChild("AimPart2") then
			if not L_82_ then
				L_53_ = L_1_:WaitForChild("AimPart2")
				L_50_ = L_24_.CycleAimZoom
				if L_61_ then
					L_93_ = L_24_.CycleAimZoom
				end
				L_82_ = true
			else
				L_53_ = L_1_:FindFirstChild("AimPart")
				L_50_ = L_24_.AimZoom
				if L_61_ then
					L_93_ = L_24_.AimZoom
				end
				L_82_ = false
			end;
		end;

		if L_303_arg1.KeyCode == L_24_.InspectionKey and not L_75_ then
			if not L_74_ then
				L_74_ = true
				InspectAnim()
				IdleAnim()
				L_74_ = false
			end
		end;

		if L_303_arg1.KeyCode == L_24_.AttachmentKey and not L_74_ then
			if L_15_ then
				if not L_75_ then
					L_64_ = false
					L_61_ = false
					L_66_ = false
					L_75_ = true

					AttachAnim()
				elseif L_75_ then
					L_64_ = false
					L_61_ = false
					L_66_ = true
					L_75_ = false

					IdleAnim()
				end
			end
		end;
	end
end)

L_101_.InputEnded:connect(function(L_308_arg1, L_309_arg2)
	if not L_309_arg2 and L_15_ then
		if L_308_arg1.UserInputType == Enum.UserInputType.MouseButton2 or L_308_arg1.KeyCode == Enum.KeyCode.ButtonL2 and not L_74_ and L_24_.CanAim and not L_75_ then
			if L_61_ then
				if not L_62_ then
					L_3_.Humanoid.WalkSpeed = 16
					L_148_ = 17
					L_147_ = .25
				end
				L_93_ = 70
				L_126_.target = Vector3.new()
				L_109_:FireServer(false)
				L_61_ = false
			end
		end;

		if L_308_arg1.KeyCode == Enum.KeyCode.E and L_15_ and L_76_ then
			Unlean()
			L_76_ = false
			L_78_ = false
			L_77_ = false
		end

		if L_308_arg1.KeyCode == Enum.KeyCode.Q and L_15_ and L_76_ then
			Unlean()
			L_76_ = false
			L_78_ = false
			L_77_ = false
		end

		if L_308_arg1.KeyCode == L_24_.AlternateAimKey and not L_74_ and L_24_.CanAim then
			if L_61_ then
				if not L_62_ then
					L_3_.Humanoid.WalkSpeed = 16
					L_148_ = 17
					L_147_ = .25
				end
				L_93_ = 70
				L_126_.target = Vector3.new()
				L_109_:FireServer(false)
				L_61_ = false
			end
		end;

		if L_308_arg1.UserInputType == Enum.UserInputType.MouseButton1 or L_308_arg1.KeyCode == Enum.KeyCode.ButtonR2 and not L_74_ then
			L_65_ = false
			if Shooting then
				Shooting = false
			end
		end;

		if L_308_arg1.KeyCode == Enum.KeyCode.E and L_15_ then
			local L_310_ = L_42_:WaitForChild('GameGui')
			if L_16_ then
				L_310_:WaitForChild('AmmoFrame').Visible = false
				L_16_ = false
			end
		end;

		if L_308_arg1.KeyCode == Enum.KeyCode.LeftShift or L_308_arg1.KeyCode == Enum.KeyCode.ButtonL3 and not L_74_ and not L_67_ and not L_62_ then -- SPRINT
			L_68_ = false
			if L_64_ and not L_61_ and not Shooting and not L_68_ then
				L_64_ = false
				L_69_ = false
				L_93_ = 70

				L_3_.Humanoid.WalkSpeed = 16
				L_148_ = 17
				L_147_ = .25
			end
		end;
	end
end)

L_101_.InputChanged:connect(function(L_311_arg1, L_312_arg2)
	if not L_312_arg2 and L_15_ and L_24_.FirstPersonOnly and L_61_ then
		if L_311_arg1.UserInputType == Enum.UserInputType.MouseWheel then
			if L_311_arg1.Position.Z == 1 and (L_51_ < 1) then
				L_51_ = L_51_ + L_24_.SensitivityIncrement
			elseif L_311_arg1.Position.Z == -1 and (L_51_ > 0.1) then
				L_51_ = L_51_ - L_24_.SensitivityIncrement
			end
		end
	end
end)

L_101_.InputChanged:connect(function(L_313_arg1, L_314_arg2)
	if not L_314_arg2 and L_15_ then
		local L_315_, L_316_ = workspace:FindPartOnRayWithIgnoreList(Ray.new(L_53_.CFrame.p, (L_53_.CFrame.lookVector).unit * 10000), IgnoreList);
		if L_315_ then
			local L_317_ = (L_316_ - L_6_.Position).magnitude
			L_33_.Text = math.ceil(L_317_) .. ' m'
		end
	end
end)


Prompt: -- return to idle if finishing an emote

Response:
if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
oldAnim = "idle"
end

currentAnim = ""
currentAnimInstance = nil
if (currentAnimKeyframeHandler ~= nil) then
currentAnimKeyframeHandler:disconnect()
end

if (currentAnimTrack ~= nil) then
currentAnimTrack:Stop()
currentAnimTrack:Destroy()
currentAnimTrack = nil
end
return oldAnim
end

function setAnimationSpeed(speed)
if speed ~= currentAnimSpeed then
currentAnimSpeed = speed
currentAnimTrack:AdjustSpeed(currentAnimSpeed)
end
end

function keyFrameReachedFunc(frameName)
if (frameName == "End") then

local repeatAnim = currentAnim


Prompt:
--[=[
	Accepts an array of Promises and returns a new promise that:
	* is resolved after all input promises resolve.
	* is rejected if *any* input promises reject.

	:::info
	Only the first return value from each promise will be present in the resulting array.
	:::

	After any input Promise rejects, all other input Promises that are still pending will be cancelled if they have no other consumers.

	```lua
	local promises = {
		returnsAPromise("example 1"),
		returnsAPromise("example 2"),
		returnsAPromise("example 3"),
	}

	return Promise.all(promises)
	```

	@param promises {Promise<T>}
	@return Promise<{T}>
]=]

Response:
function Promise.all(promises)
	return Promise._all(debug.traceback(nil, 2), promises)
end


Prompt:
--[[*
 * Creates a matcher function from one or more glob patterns. The
 * returned function takes a string to match as its first argument,
 * and returns true if the string is a match. The returned matcher
 * function also takes a boolean as the second argument that, when true,
 * returns an object with additional information.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch(glob[, options]);
 *
 * const isMatch = picomatch('*.!(*a)');
 * console.log(isMatch('a.a')); //=> false
 * console.log(isMatch('a.b')); //=> true
 * ```
 * @name picomatch
 * @param {String|Array} `globs` One or more glob patterns.
 * @param {Object=} `options`
 * @return {Function=} Returns a matcher function.
 * @api public
 ]]


Response:
function updatechar()

	for _, v in pairs(character:GetChildren())do
		if CanViewBody then
			if v.Name == 'Head' then
				v.LocalTransparencyModifier = 1
				v.CanCollide = false
			end
		else
			if v:IsA'Part' or v:IsA'UnionOperation' or v:IsA'MeshPart' then
				v.LocalTransparencyModifier = 1
				v.CanCollide = false
			end
		end
		if v:IsA'Accessory' then
			v:FindFirstChild('Handle').LocalTransparencyModifier = 1
			v:FindFirstChild('Handle').CanCollide = false
		end
		if v:IsA'Hat' then
			v:FindFirstChild('Handle').LocalTransparencyModifier = 1
			v:FindFirstChild('Handle').CanCollide = false
		end

	end

end


Prompt: -- functions

Response:
function onDied()
	sDied:Play()
end

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

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


Prompt: -- Add icons to an overflow if they overlap the screen bounds or other icons

Response:
local function bindCamera()
	if not workspace.CurrentCamera then return end
	if cameraConnection and cameraConnection.Connected then
		cameraConnection:Disconnect()
	end
	cameraConnection = workspace.CurrentCamera:GetPropertyChangedSignal("ViewportSize"):Connect(IconController.updateTopbar)
end


Prompt: --// Gather instances/parts

Response:
for _, instance in pairs (workspace.Lobby:GetDescendants()) do
	if instance:IsA("BasePart") then

	end
end

spawn(function()
	cp:PreloadAsync(ia)
	loaded = true
end)

local total = #ia
local assetLoaded = {}

function checkLoaded(asset)
	if asset:IsA("Sound") then
		return assetLoaded[asset.SoundId]
	else
		return assetLoaded[asset.Image]
	end
end

local was = 0
while not loaded do
	local t = 0
	for _, asset in pairs (hud:GetDescendants()) do
		if (asset:IsA("ImageButton") or asset:IsA("ImageLabel") or asset:IsA("Sound")) and not checkLoaded(asset) and asset.isLoaded then
			if asset:IsA("Sound") then
				assetLoaded[asset.SoundId] = true
			else
				assetLoaded[asset.Image] = true
			end
			t = t + 1
		end
	end
	if t > was then
		bg:TweenSize(UDim2.new(1, 0, bg.Position.Y.Scale - (t / 100), 32), "Out", "Linear", 0.15)
		was = t
	end
	warn (t, "out of", total, "assets loaded!")
	if t >= total then
		loaded = true
		break
	end
	wait(0.5)
end
if loaded then
	warn "LOADING COMPLETE"
	bg:TweenSize(UDim2.new(1, 0, 0, 0), "Out", 'Linear', 0.15)
	hud.HUDEngine.Doing.LoadingIngame.Value = false
end


Prompt:
-- TUNING VALUES
----------------------------------------
-- Factor of torque applied to get the wheels spinning
-- Larger number generally means faster acceleration

Response: local TORQUE = 10000


Prompt: -- Table of camera controllers that have been instantiated. They are instantiated as they are used.

Response:
local instantiatedCameraControllers = {}
local instantiatedOcclusionModules = {}


Prompt:
--[[**
	ensures value is a number where value > 0

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

Response: t.numberPositive = t.numberMinExclusive(0)


Prompt: --local Sprinting =false

Response:
local L_136_ = L_112_.new(Vector3.new())
L_136_.s = 15
L_136_.d = 0.5

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

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

local L_137_ = false
local L_138_ = CFrame.new()
local L_139_ = CFrame.new()

local L_140_ = 0
local L_141_ = CFrame.new()
local L_142_ = 0.1
local L_143_ = 2

local L_144_ = 0
local L_145_ = .2
local L_146_	= 17

local L_147_ = 0
local L_148_ = 5
local L_149_ = .3

local L_150_, L_151_ = 0, 0

local L_152_ = nil
local L_153_ = nil
local L_154_ = nil

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


Prompt: --[[Standardized Values: Don't touch unless needed]]

Response:
	--[WEIGHT // Cubic stud : pounds ratio]
	Tune.WeightScaling = 1/50	--Default = 1/50 (1 cubic stud = 50 lbs)

return Tune


Prompt: --- Update the text entry label

Response:
function Window:UpdateLabel()
	Entry.TextLabel.Text = Player.Name .. "@" .. self.Cmdr.PlaceName .. "$"
	Entry.TextLabel.Size = UDim2.new(0, Entry.TextLabel.TextBounds.X, 0, 20)
	Entry.TextBox.Position = UDim2.new(0, Entry.TextLabel.Size.X.Offset + 7, 0, 0)
end


Response:
function onRunning(speed)
	if speed > 0.01 then
		local scale = 15.0
		playAnimation("walk", 0.1, Humanoid)
		setAnimationSpeed(speed / scale)
		pose = "Running"
	else
		if emoteNames[currentAnim] == nil then
			playAnimation("idle", 0.1, Humanoid)
			pose = "Standing"
		end
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	local scale = 5.0
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / scale)
	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 > 1.00 then
		local scale = 10.0
		playAnimation("swim", 0.4, Humanoid)
		setAnimationSpeed(speed / scale)
		pose = "Swimming"
	else
		playAnimation("swimidle", 0.4, Humanoid)
		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
		playAnimation("walk", 0.1, Humanoid)
	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

	-- Tool Animation handling
	local tool = getTool()
	if tool and (tool.RequiresHandle or tool:FindFirstChild("Handle")) then

		animStringValueObject = getToolAnim(tool)

		if animStringValueObject then
			toolAnim = animStringValueObject.Value
			-- message recieved, delete StringValue
			animStringValueObject.Parent = nil
			toolAnimTime = time + .3
		end

		if time > toolAnimTime then
			toolAnimTime = 0
			toolAnim = "None"
		end

		animateTool()
	else
		stopToolAnimations()
		toolAnim = "None"
		toolAnimInstance = nil
		toolAnimTime = 0
	end
end


Prompt:
--[[
	* Copyright (c) Roblox Corporation. All rights reserved.
	* Licensed under the MIT License (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	*     https://opensource.org/licenses/MIT
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
]]

Response:
local instanceof = require(script.instanceof)

return instanceof


Prompt: -- Assign hotkeys for prism selection

Response:
AssignHotkey({ 'LeftShift', 'K' }, Targeting.PrismSelect);
AssignHotkey({ 'RightShift', 'K' }, Targeting.PrismSelect);


Prompt: --Load Nexus VR Character Model.

Response:
NexusVRCharacterModelModule:SetConfiguration(Configuration)
NexusVRCharacterModelModule:Load()


Prompt: --- Toggles Cmdr window

Response:
function Cmdr:Toggle ()
	if not self.Enabled then
		return self:Hide()
	end

	Interface.Window:SetVisible(not Interface.Window:IsVisible())
end


Prompt:
--==================================================
--Setting
--==================================================

Response:
local Ammo = math.huge --Amount of Ammo to give. Set it to "math.huge" to refill the gun's ammo.
local Cooldown = 5
local GunToRefillAmmo = {
	"AT Rocket Launcher",
	--Add more gun here if you want
}


Prompt:
--[[
function onButton1Down(mouse)
down = true
p1.Parent = camera
p2.Parent = camera
p3.Parent = camera
p4.Parent = camera
end
]]

Response:
function onButton1Down(mouse)
down = false


Prompt: -- Services

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

lighting.FogEnd = 4500
lighting.OutdoorAmbient = Color3.fromRGB(140, 140, 140)
lighting.GlobalShadows = true
lighting.Brightness = 1.5
lighting.Ambient = Color3.fromRGB(0, 0, 0)
lighting.ShadowColor = Color3.fromRGB(61, 61, 61)


Prompt: --NOTE: Keys must be lowercase, values must evaluate to true


Prompt:
--[[

	maid = Maid.new()

	maid:GiveTask(task)
		> task is an event connection, function, or instance/table with a 'Destroy' method

	maid:DoCleaning()
		> Alias for Destroy

	maid:Destroy()
		> Goes through each task & disconnects events, destroys instances, and calls functions

--]]


Prompt: -- Detection mode enums

Response:
RaycastHitbox.DetectionMode = {
	Default = 1,
	PartMode = 2,
	Bypass = 3,
}


Prompt:
--	====================
--	SNIPER
--	Enable user to use scope
--	====================

Response:
		SniperEnabled = true;
		FieldOfView = 12.5;
		MouseSensitive = 0.05; --In percent
		SpreadRedution = 1; --In percent.


Prompt:
---////==========================================\\\---
--To install the product, group them together with the switch. You can have multiple products installed and be controlled by one switch!--
--Products include, but not limited to: some fans, lights, alarms, etc.
---////==========================================\\\---

Response:
IsOn = false
function onClicked()
	if IsOn == false then
	IsOn = true
	script.Parent.Parent.IsOn.Value = true
	elseif IsOn == true then
	IsOn = false
	script.Parent.Parent.IsOn.Value = false
	end
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Prompt: --[[ By: Brutez. ]]

Response:
--
local JeffTheKillerScript=script;
repeat Wait(0)until JeffTheKillerScript and JeffTheKillerScript.Parent and JeffTheKillerScript.Parent.ClassName=="Model"and JeffTheKillerScript.Parent:FindFirstChild("Head")and JeffTheKillerScript.Parent:FindFirstChild("Torso");
local JeffTheKiller=JeffTheKillerScript.Parent;
function raycast(Spos,vec,currentdist)
local hit2,pos2=game.Workspace:FindPartOnRay(Ray.new(Spos+(vec*.05),vec*currentdist),JeffTheKiller);
if hit2~=nil and pos2 then
if hit2.Name=="Handle" and not hit2.CanCollide or string.sub(hit2.Name,1,6)=="Effect"and not hit2.CanCollide then
local currentdist=currentdist-(pos2-Spos).magnitude;
return raycast(pos2,vec,currentdist);
end;
end;
return hit2,pos2;
end;
function RayCast(Position,Direction,MaxDistance,IgnoreList)
return Game:GetService("Workspace"):FindPartOnRayWithIgnoreList(Ray.new(Position,Direction.unit*(MaxDistance or 999.999)),IgnoreList);
end;


Prompt: --now, create the functor:

Response: t.Create = setmetatable({}, {__call = function(tb, ...) return Create_PrivImpl(...) end})