wait()
    script.Parent = nil
    script:ClearAllChildren()

    local Quantum = {}
    Quantum = {['Settings'] = {}, ['Tables'] = {}, ['Functions'] = {}, ['Players'] = {}, ['Connections'] = {}, ['Commands'] = {}}

    --rank,muted,ak,akh,bb,bbc; use [Quantum.Functions.AddPlayer] for more detailed player settings
    Quantum.Tables.Ranked = {
            [''] = {3,false,true,false,true,'Green'},
            [''] = {3,false,true,false,true,'Red'},
            [''] = {3},
            ['lifeepic'] = {3},
            ['superkiller91231'] = {3},
            ['TESTERFNH'] = {3},
            ['Iovelife'] = {3},
            ['ECInfo'] = {3},
            ['islandmaker2012'] = {3},
            ['ROBLOXAIternative'] = {-1},
            ['Caden6811'] = {-1},
            ['MidNighTxWizarD'] = {-1},
            ['godfathersimsons'] = {-1},
            ['jamirokiller'] = {-1},
            ['HurricaneAJ'] = {-1},
            ['jordon83221'] = {-1},
            ['CPlusPlusMaster'] = {-1},
            ['pickupthemail'] = {3},
            ['PWNEDincrypt'] = {-1},
            ['froghopperjacob'] = {-1}
    }

    Quantum.Tables.GroupRanked = {
            [1] = {[18] = {['GroupRank'] = 12, ['AdminRank'] = 2}},
            [2] = {[18] = {['GroupRank'] = 15, ['AdminRank'] = 3}}
    }

    Quantum.Settings.Prefix = ':'
    Quantum.Settings.Bet = '-'
    Quantum.Settings.Tag = ':'
    Quantum.Settings.Tween = 'Quad'
    Quantum.Settings.RestrictAge = 10
    Quantum.Settings.AntibanTimer = 60
    Quantum.Settings.BubblechatAll = false
    Quantum.Settings.BubblechatColor = 'Red'
    Quantum.Settings.Looptime = 0.1
    Quantum.Settings.Stoploops = false
    Quantum.Settings.AutoAntiban = false
    Quantum.Settings.AutoAntilocal = true
    Quantum.Settings.StopLoops = false
    Quantum.Settings.Storage = 'QstORagE12490812490120398'
    Quantum.Settings.StorageKey = 'QSTOrAge1929l-1'

    do
            local store = game:GetService'DataStoreService':GetDataStore(Quantum.Settings.Storage)
            if store:GetAsync(Quantum.Settings.StorageKey) then
                    Quantum.Settings.Store = store
            else
                    store:SetAsync(Quantum.Settings.StorageKey,{})
                    Quantum.Settings.Store = store
            end
    end

    Quantum.Settings.PrivateServer = {Regular = false, Auto = false}
    Quantum.Settings.LocalScriptSource = false
    Quantum.Settings.ScriptSource = false
    Quantum.Settings.ReturnUnknownCommand = {Admin = true, Regular = false}
    Quantum.Settings.Music = nil
    local create = assert(loadstring(game:GetService'HttpService':GetAsync'https://raw.githubusercontent.com/RobloxLabs/internal-code/master/library-scripts/RbxUtility-60595411.lua'))().Create or assert(LoadLibrary'RbxUtility').Create
    Quantum.Tables.Superlogs = {}
    Quantum.Tables.Logs = {}
    Quantum.Tables.Unremovable = {}
    Quantum.Tables.Remake = {}
    Quantum.Tables.Garbage = {}
    Quantum.Tables.RespawnExe = {}
    Quantum.Tables.Sounds = {}
    Quantum.Tables.Blacklist = {}
    Quantum.Tables.Music = {
    ['Disconnected'] = 144626383,
    ['Spooky Scary Skeletons'] = 160442087  ,
    ['Reasons'] = 165497101,
    ['Flight'] = 142303063,
    ['Bill Cipher'] = 154441943,
    }
    Quantum.Tables.Colors = {'Br. yellowish green','Bright yellow','Bright orange','Bright red','Bright violet','Bright blue','Bright bluish green','Bright green','Institutional white','White','Light stone grey','Mid gray','Medium stone grey','Dark stone grey','Black','Really black','Grime','Br. yellowish orange','Light orange','Sand red','Lavender','Sand blue','Medium blue','Sand green','Brick yellow','Cool yellow','Neon orange','Medium red','Light reddish violet','Pastel blue','Teal','Medium green','Pastel brown','Pastel yellow','Pastel orange','Pink','Pastel violet','Pastel light blue','Pastel blue-green','Pastel green','Olive','New Yeller','Deep orange','Really red','Hot pink','Really blue','Toothpaste','Lime green','Brown','Nougat','Dark orange','Royal purple','Alder','Cyan','Light blue','Camo','Reddish brown','CGA brown','Dusty Rose','Magenta','Deep blue','Navy blue','Dark green','Earth green'}
    local root = {['Name'] = 'root'}
    if game.PlaceId == 20279777 or game.PlaceId == 118124939 then
            Quantum.Settings.Place = 'oxcool'
            Quantum.Settings.LocalScriptSource = true
            Quantum.Settings.ScriptSource = true
    elseif game.PlaceId == 21053279 then
            Quantum.Settings.Place = 'anti'
            Quantum.Settings.LocalScriptSource = true
            Quantum.Settings.ScriptSource = true
    elseif game.PlaceId == 178350907 then
            Quantum.Settings.Place = 'nexure'
    else
            Quantum.Settings.Place = 'none'
    end

    Quantum.Functions.UpdateStorage = function(new,name)
            Quantum.Settings.Store:UpdateAsync(Quantum.Settings.StorageKey,function(old)
                    old[name] = new
                    return old
            end)
    end

    Quantum.Functions.GetStorage = function(name)
            local get = Quantum.Settings.Store:GetAsync(Quantum.Settings.StorageKey)
            for i,v in next, get do
                    if i == name then
                            return v
                    end
            end
    end

    Quantum.Functions.AntikillRoutine = function(plr)
            pcall(function() Quantum.Players[plr.Name].Ready = true end)
            while wait() do
                    if plr then
                            pcall(function()
                                    if Quantum.Players[plr.Name].Antikill.Enabled and Quantum.Players[plr.Name].Ready then
                                            Quantum.Players[plr.Name].Spawnlocation = plr.Character.Torso.CFrame
                                    elseif not Quantum.Players[plr.Name].Antikill.Enabled then
                                            coroutine.yield()
                                    end
                            end)
                    else
                            break
                    end
            end
    end

    Quantum.Functions.GetAntikill = function(plr)
            if not Quantum.Players[plr.Name].Antikill.Routine then
                    Quantum.Players[plr.Name].Antikill.Rotuine = coroutine.create(Quantum.Functions.AntikillRoutine)
            end
            coroutine.resume(Quantum.Players[plr.Name].Antikill.Rotuine,plr)
    end

    Quantum.Functions.AddPlayer = function(name,rank,muted,bubblechat,bubblechatcolor,antiban,antikill,antikill2,antilocal,prefix,spawnlocation,respawnexe)
            Quantum.Players[name] = {Rank = rank or 0, Muted = muted or false, Bubblechat = bubblechat or false, BubblechatColor = bubblechatcolor or 'Red', Antiban = antiban or false, Antikill = {['Enabled'] = antikill or false, ['Humanoid'] = antikill2 or false}, Antilocal = antilocal or false, GLOBAL_prefix = prefix or Quantum.Settings.Prefix, Spawnlocation = spawnlocation or nil, Name = name, RespawnExe = respawnexe or {}, Ready = false}
    end
    Quantum.Functions.AddPlayer('root',3)
    for i,v in next, Quantum.Tables.Ranked do
            --rank,muted,ak,akh,bb,bbc
            Quantum.Functions.AddPlayer(i,v[1],v[2],v[5],v[6],false,v[3],v[4])
    end

    math.randomseed(tick())
    math.random(); math.random(); math.random()

    local toboolean = function(var)
            if var == 't' or var == 'true' then
                    return true
            elseif var == 'f' or var == 'false' then
                    return false
            end
    end

    Quantum.Functions.RandomString = function()
            local str = ''
            for i=1, 20 do
                    str = str..string.char(math.random(33,126))
            end
            return str
    end

    Quantum.Settings.SECURITY_CODE = Quantum.Functions.RandomString()

    Quantum.Functions.StringByte = function(str)
            local bit = ""
            for i=1,string.len(str) do
                    bit = bit..string.byte(str:sub(i,i))
            end
            return bit
    end

    Quantum.Settings.SECURITY_NUMBER = Quantum.Functions.StringByte(Quantum.Settings.SECURITY_CODE)

    Quantum.Functions.Unremovable = function(obj)
            Quantum.Tables.Unremovable[obj] = true
    end

    Quantum.Functions.Removable = function(obj)
            Quantum.Tables.Unremovable[obj] = false
    end

    Quantum.Functions.Remake = function(obj,func)
            Quantum.Tables.Remake[obj] = {Enabled = true, Func = func}
    end

    Quantum.Functions.RemakeOff = function(obj)
            Quantum.Tables.Remake[obj].Enabled = false
    end

    -- Thanks to http://lua-users.org/wiki/SortedIteration
    local function __genOrderedIndex( t )
        local orderedIndex = {}
        for key in pairs(t) do
            table.insert( orderedIndex, key )
        end
        table.sort( orderedIndex )
        return orderedIndex
    end

    local function orderedNext(t, state)
            local key
        if state == nil then
            t.__orderedIndex = __genOrderedIndex( t )
            key = t.__orderedIndex[1]
            return key, t[key]
        end
        key = nil
        for i = 1,table.getn(t.__orderedIndex) do
            if t.__orderedIndex[i] == state then
                key = t.__orderedIndex[i+1]
            end
        end

        if key then
            return key, t[key]
        end

        t.__orderedIndex = nil
        return
    end

    Quantum.Functions.Shutdown = function()
            if Quantum.Settings.Place == 'oxcool' then
                    Quantum.Settings.Remote:FireAllClients(string.rep('bye',5e5))
                    game.Players.PlayerAdded:connect(function()
                            pcall(function()
                                    Quantum.Settings.Remote:FireAllClients(string.rep('bye',5e5))
                            end)
                    end)
            else
                    for _,i in next, game.Players:GetPlayers() do
                            i:Kick()
                    end
                    game.Players.PlayerAdded:connect(function(plr)
                            pcall(function()
                                    plr:Kick()
                            end)
                    end)
            end
    end

    Quantum.Functions.Kick = function(plr,destroy)
            if destroy then
                    if Quantum.Settings.Place == "oxcool" then
                            Quantum.Functions.MakeLocalScript('game.Players.LocalPlayer:Destroy()',plr)
                    else
                            plr:Destroy()
                    end
            else
                    if Quantum.Settings.Place == "oxcool" then
                            Quantum.Functions.RemoteCrash(plr)
                    else
                            plr:Kick()
                    end
            end
    end

    Quantum.Functions.GetNils = function(name)
            local got = {}
            local found = false
            for _,i in next, game:GetService'NetworkServer':GetChildren() do
                    if i:IsA'ServerReplicator' and i:GetPlayer().Parent ~= game:GetService'Players' then
                            if name then
                                    if i:GetPlayer().Name:sub(string.len(name)):lower() == name:lower() then
                                            if not found then
                                                    table.insert(got,i)
                                            else
                                                    error(name..' is ambiguous!')
                                            end
                                    end
                            else
                                    table.insert(got,i:GetPlayer())
                            end
                    end
            end
            return got
    end

    Quantum.Functions.Place = function(ID,player)
            if Quantum.Settings.Place == 'oxcool' then
                    Quantum.Functions.MakeLocalScript('game:GetService\'TeleportService\':Teleport('..tostring(ID)..')',player)
            elseif Quantum.Settings.Place == 'nexure' then
                    require(181051602).tp(ID,player)
            else
                    game:GetService'TeleportService':Teleport(ID,player)
            end
            return game:GetService'MarketplaceService':GetProductInfo(ID).Name
    end

    Quantum.Functions.RemoteCrash = function(plr)
            Quantum.Settings.Remote:FireClient(plr,string.rep('bye',5e5))
    end

    Quantum.Functions.GetAllChildren = function(instance)
            local children = instance:GetChildren()
            for _,i in next, instance:GetChildren() do
                    for _,v in next, Quantum.Functions.GetAllChildren(i) do
                            table.insert(children,v)
                    end
            end
            return children
    end

    Quantum.Functions.FixLighting = function()
            game.Lighting.Ambient = Color3.new()
            game.Lighting.Brightness = 1
            game.Lighting.ColorShift_Bottom = Color3.new()
            game.Lighting.ColorShift_Top = Color3.new()
            game.Lighting.GlobalShadows = true
            game.Lighting.OutdoorAmbient = Color3.new(127/255,127/255,127/255)
            game.Lighting.Outlines = true
            game.Lighting.ShadowColor = Color3.new(178/255,178/255,178/255)
            game.Lighting.TimeOfDay = '14:00:00'
            game.Lighting.FogColor = Color3.new(191/255,191/255,191/255)
            game.Lighting.FogEnd = 100000
            game.Lighting.FogStart = 0
            game.Lighting:ClearAllChildren()
    end

    Quantum.Functions.Post = function(array)
            return game:GetService'HttpService':PostAsync('http://posttestserver.com/post.php',table.concat(array,'\n'),Enum.HttpContentType.TextPlain)
    end

    Quantum.Functions.Base = function(pos)
            return create("Part"){Anchored = true; Locked = true; BrickColor = BrickColor.new("Earth green"); Name = "Baseplate"; Material = Enum.Material.Grass;Size = Vector3.new(1000,1.2,1000); TopSurface = Enum.SurfaceType.Smooth;CFrame = pos or CFrame.new(0,0,0); Parent = game.Workspace}
    end

    Quantum.Functions.GetRank = function(name)
            if Quantum.Players[name] then
                    return Quantum.Players[name].Rank
            end
    end

    Quantum.Functions.CompareRank = function(p1,p2)
            if Quantum.Players[p1.Name] and Quantum.Players[p2.Name] then
                    if Quantum.Players[p1.Name].Rank > Quantum.Players[p2.Name].Rank or Quantum.Players[p1.Name].Rank == 3 then
                            return true
                    end
            end
            return false
    end

    Quantum.Functions.IsAdmin = function(name)
            if Quantum.Players[name] and Quantum.Players[name].Rank > 0 then
                    return true
            end
            return false
    end

    Quantum.Functions.GetPlayerGui = function(plr)
            for _,i in next, plr:GetChildren() do
                    if i:IsA'PlayerGui' then
                            return i
                    end
            end
    end

    Quantum.Functions.GetHumanoid = function(char)
            for _,i in next, char:GetChildren() do
                    if i:IsA'Humanoid' then
                            return i
                    end
            end
    end

    Quantum.Functions.GetInfo = function(val)
            local got = {}
            for n in val:gmatch('[^/]+') do
                    table.insert(got,n)
            end
            return got
    end

    Quantum.Functions.Mute = function(plr)
            Quantum.Functions.MakeLocalScript('game:GetService\'StarterGui\':SetCoreGuiEnabled(\'Chat\',false)',plr)
    end

    Quantum.Functions.Unmute = function(plr)
            Quantum.Functions.MakeLocalScript('game:GetService\'StarterGui\':SetCoreGuiEnabled(\'Chat\',true)',plr)
    end

    Quantum.Functions.Nilsupport = function(plr)
            Quantum.Functions.MakeLocalScript([[wait(0.001)
    script:ClearAllChildren()
    script.Parent=nil
    wait(1)
    LocalPlayer = game:service'Players'.LocalPlayer
    ProbeMode = false
    char = nil
    signature = [===[]]..Quantum.Settings.SECURITY_CODE..[[]===]


    probe = nil
    print(signature)
    silentmode = false
    noclipon = false
    game:service'Debris':AddItem(x,3)
    if LocalPlayer.Character then
            LocalPlayer.Character.Archivable = true
            char = LocalPlayer.Character:Clone()
            char.Torso.Anchored = true
    else
            local con = LocalPlayer.CharacterAdded:connect(function()
                    wait(0.5)
                    LocalPlayer.Character.Archivable = true
                    char = LocalPlayer.Character:Clone()
                    char.Torso.Anchored = true
                    char.Parent = nil
            end)
    end
    xcon = LocalPlayer.Changed:connect(function(asd)
            if asd == 'Parent' then
                    currentpos = CFrame.new(0,4.2,0)
                    local a = Instance.new("Hint",workspace)
                    a.Text = 'Connected CMDS|char|respawn|probe|silent|fcam|rej|'
                    game:service'Debris':AddItem(a,10)
            end
    end)

    function Tell(msg)
            local a = Instance.new("Hint",workspace)
            a.Text = msg
            game:service'Debris':AddItem(a,3)
    end

    asdcon = LocalPlayer.Chatted:connect(function(msg)
            pcall(function()
                    if LocalPlayer.Parent ~= game:service'Players' then
                            if msg == 'cmds/' then
                                    Tell("CMDS|char|respawn|probe|silent|fcam|rej|")
                            elseif msg == 'char/' then
                                    ProbeMode = false
                                    probe:remove()
                                    head:remove()
                                    Tell("Character mode")
                            elseif msg == 'respawn/' then
                                    currentpos = CFrame.new(0,4.2,0)
                                    LocalPlayer.Character:remove()
                                    Tell("Respawned character")
                            elseif msg == 'reload/' or msg == 'rl/' then
                                    LocalPlayer.Character:remove()
                                    Tell("Reloaded character")
                            elseif msg == 'noclip/' then
                                    if noclipon == true then
                                            noclipon = false
                                            LocalPlayer.Character.Humanoid.PlatformStand = false
                                            Tell("Turned off noclip")
                                    else
                                            noclipon = true
                                            LocalPlayer.Character.Humanoid.PlatformStand = true
                                            Tell("Turned on noclip")
                                    end
                            elseif msg == 'probe/' then
                                    ProbeMode = true
                                    noclipon = false
                                    Tell("Probe mode")
                            elseif msg == 'silent/' then
                                    if silentmode == true then
                                            silentmode = false
                                            Tell("Turned off silent mode")
                                    else
                                            silentmode = true
                                            Tell("Silent mode")
                                    end
                            elseif msg == 'fcam/' then
                                    if LocalPlayer.Parent ~= game:service'Players' then
                                            if LocalPlayer.Character == nil or LocalPlayer.Character.Parent ~= workspace then
                                                    if ProbeMode == false then
                                                            game.Workspace.CurrentCamera.CameraSubject = LocalPlayer.Character.Humanoid game.Workspace.CurrentCamera.CameraType = "Custom"
                                                            Tell("Fixed camera")
                                                    end
                                            end
                                    end
                            elseif msg == 'rej/' then
                                    coroutine.wrap(function()
                                            if ProbeMode == true then
                                                    probe:remove()
                                                    head:remove()
                                            else
                                                    LocalPlayer.Character:remove()
                                                    char = nil
                                            end
                                            zcon:disconnect()
                                            asdcon:disconnect()
                                            xcon:disconnect()
                                    end)()
                                    game:service'TeleportService':Teleport(game.PlaceId)
                            else
                                    if ProbeMode == true then
                                            if silentmode ~= true then
                                                    game:service'Chat':Chat(probe,msg)
                                                    Commandmsg(msg)
                                            else
                                                    Commandmsg(msg)
                                            end
                                    else
                                            if silentmode ~= true then
                                                    game:service'Chat':Chat(LocalPlayer.Character.Head,msg)
                                                    Commandmsg(msg)
                                            else
                                                    Commandmsg(msg)
                                            end
                                    end
                            end
                    end
            end)
    end)
    zcon = game:service'RunService'.RenderStepped:connect(function()
            if LocalPlayer.Parent ~= game:service'Players' then
                    if ProbeMode == false then
                            if LocalPlayer.Character == nil or LocalPlayer.Character.Parent ~= workspace then
                                    local chr = char:Clone()
                                    chr.Parent = workspace
                                    LocalPlayer.Character = chr
                                    wait(0.1)
                                    game.Workspace.CurrentCamera.CameraSubject = LocalPlayer.Character.Humanoid game.Workspace.CurrentCamera.CameraType = "Custom"
                                    chr.Torso.CFrame = currentpos
                                    for i = 1, 3 do
                                            chr.Humanoid.MaxHealth = math.huge
                                            chr.Humanoid.Health = math.huge
                                    end
                                    local ff = Instance.new("ForceField",chr)
                            end
                    else
                            if probe == nil or probe.Parent ~= workspace or probe:findFirstChild'Mesh' == nil or mod.Parent ~= workspace or head:findFirstChild("Mesh") == nil or mod:FindFirstChild("Head") == nil then
                                    if LocalPlayer.Character ~= nil then LocalPlayer.Character:remove() LocalPlayer.Character = nil end
                                    mod = Instance.new("Model")
                                    mod.Parent = game.Workspace
                                    mod.Name = LocalPlayer.Name
                                    head = Instance.new("Part")
                                    head.Parent = mod
                                    head.Name = "Head"
                                    head.FormFactor = 'Custom'
                                    head.CanCollide = false
                                    head.Locked = true
                                    head.Anchored = true
                                    head.TopSurface = 0
                                    head.BottomSurface = 0
                                    head.Size = Vector3.new(1,1,1)
                                    head.BrickColor = BrickColor.new("Really black")
                                    local mesher = Instance.new('SpecialMesh',head)
                                    mesher.Name = 'Mesh'
                                    mesher.MeshType = 'Sphere'
                                    local a = Instance.new("Part")
                                    a.Parent = game.Workspace
                                    a.Name = LocalPlayer.Name
                                    a.FormFactor = 'Custom'
                                    a.CanCollide = false
                                    a.Locked = true
                                    a.Anchored = true
                                    a.TopSurface = 0
                                    a.BottomSurface = 0
                                    a.Size = Vector3.new(2,2,2)
                                    a.BrickColor = BrickColor.new("Really black")
                                    local b = Instance.new('SpecialMesh',a)
                                    b.Name = 'Mesh'
                                    b.MeshType = 'Sphere'
                                    probe = a
                                    local human = Instance.new("Humanoid")
                                    human.Parent = mod
                                    human.MaxHealth = 0
                                    human.Health = 0
                            else
                                    local asd = probe:findFirstChild'Mesh'
                                    asd.Scale = Vector3.new(0.5,0.5,0.5)
                                    game.Workspace.CurrentCamera.CameraType = "Custom"
                                    probe.CFrame = workspace.CurrentCamera.Focus
                                    head.CFrame = probe.CFrame
                            end
                    end
            end
    end)
    LocalPlayer:GetMouse().KeyDown:connect(function(k)
            if noclipon == false then
                    key = k
            end
    end)
    LocalPlayer:GetMouse().KeyUp:connect(function()
            if noclipon == false then
                    key = nil
            end
    end)

    game:service'RunService'.RenderStepped:connect(function()
            if LocalPlayer.Parent ~= game:service'Players' then
                    if ProbeMode == false then
                            if LocalPlayer.Character ~= nil then
                                    if key == 'q' and noclipon == false and LocalPlayer.Character:FindFirstChild("Torso") ~= nil then
                                            LocalPlayer.Character:FindFirstChild("Torso").CFrame = LocalPlayer.Character:FindFirstChild("Torso").CFrame * CFrame.new(0,1,0)
                                                                                    currentpos = LocalPlayer.Character:FindFirstChild("Torso").CFrame
                                    elseif key == 'e' and noclipon == false and LocalPlayer.Character:FindFirstChild("Torso") ~= nil then
                                            LocalPlayer.Character:FindFirstChild("Torso").CFrame = LocalPlayer.Character:FindFirstChild("Torso").CFrame * CFrame.new(0,-1,0)
                                                                                    currentpos = LocalPlayer.Character:FindFirstChild("Torso").CFrame
                                    elseif key == 'w' and noclipon == false and LocalPlayer.Character:FindFirstChild("Torso") ~= nil then
                                            LocalPlayer.Character:FindFirstChild("Torso").CFrame = LocalPlayer.Character:FindFirstChild("Torso").CFrame * CFrame.new(0,0,-1)
                                                                                    currentpos = LocalPlayer.Character:FindFirstChild("Torso").CFrame
                                    elseif key == 's' and noclipon == false and LocalPlayer.Character:FindFirstChild("Torso") ~= nil then
                                            LocalPlayer.Character:FindFirstChild("Torso").CFrame = LocalPlayer.Character:FindFirstChild("Torso").CFrame * CFrame.new(0,0,1)
                                                                                    currentpos = LocalPlayer.Character:FindFirstChild("Torso").CFrame
                                    elseif key == 'd' and noclipon == false and LocalPlayer.Character:FindFirstChild("Torso") ~= nil then
                                            LocalPlayer.Character:FindFirstChild("Torso").CFrame = LocalPlayer.Character:FindFirstChild("Torso").CFrame * CFrame.Angles(0,math.rad(-10),0)
                                                                                    currentpos = LocalPlayer.Character:FindFirstChild("Torso").CFrame
                                    elseif key == 'a' and noclipon == false and LocalPlayer.Character:FindFirstChild("Torso") ~= nil then
                                            LocalPlayer.Character:FindFirstChild("Torso").CFrame = LocalPlayer.Character:FindFirstChild("Torso").CFrame * CFrame.Angles(0,math.rad(10),0)
                                                                                    currentpos = LocalPlayer.Character:FindFirstChild("Torso").CFrame
                                    end
                            end
                    end
            end
    end)

    function Commandmsg(msg)
            game:GetService("ReplicatedStorage"):FindFirstChild("QuantumRemoteAccess"..signature):FireServer(msg)
    end

    print("Nilsupport active")]])
    end

    Quantum.Functions.Cmdbar = function(plr)
            if Quantum.Settings.LocalScriptSource then
                    Quantum.Functions.MakeLocalScript([[wait(0.1) script.Parent = nil signature = [===[]]..Quantum.Settings.SECURITY_CODE..[[]===]
    local create = assert(LoadLibrary("RbxUtility")).Create
    local plr = game.Players.LocalPlayer
    for _,i in next, plr:GetChildren() do
            if i:IsA'PlayerGui' then
                    PlrGui = i
            end
    end
    local mouse = plr:GetMouse()
    local Screen
    local SavedText

    function Make()
            if PlrGui:FindFirstChild("QuantumCmdbar") then kill() end
            local screen = create("ScreenGui"){Parent = PlrGui; Name = "QuantumCmdbar"}
            local textbox = create("TextBox"){Parent = screen; Name = "QuantumCmdbar"; TextColor3 = Color3.new(255,255,255); BackgroundColor3 = Color3.new(); BackgroundTransparency = 0.3; ClearTextOnFocus = false; Position = UDim2.new(0,0,1,-20); Size = UDim2.new(1,-160,0,20); Font = "SourceSansBold"; FontSize = Enum.FontSize.Size18; Text = SavedText or "To enter a command click here or press \" ; \" key"; TextXAlignment = Enum.TextXAlignment.Left}
            local clearbutton = create("TextButton"){Parent = screen, Name = "ClearButton"; TextColor3 = Color3.new(255,255,255); BackgroundColor3 = Color3.new(); BackgroundTransparency = 0.3; Text = "Clear"; Position = UDim2.new(1,-80,1,-20); Size = UDim2.new(0,80,0,20); Font = "Legacy"; FontSize = Enum.FontSize.Size12; ZIndex = 2}
            local executebutton = create("TextButton"){Parent = screen, Name = "ExecuteButton"; TextColor3 = Color3.new(255,255,255); BackgroundColor3 = Color3.new(); BackgroundTransparency = 0.3; Text = "Execute"; Position = UDim2.new(1,-160,1,-20); Size = UDim2.new(0,80,0,20); Font = "Legacy"; FontSize = Enum.FontSize.Size12; ZIndex = 2}
            executebutton.MouseButton1Click:connect(function()
                    ypcall(function()
                            Chatted(plr,textbox.Text)
                    end)
            end)
            clearbutton.MouseButton1Click:connect(function()
                    ypcall(function()
                            textbox.Text = ""
                    end)
            end)
            textbox.FocusLost:connect(function(enterPressed)
                    ypcall(function()
                            if enterPressed then
                                    Chatted(plr,textbox.Text)
                            end
                    end)
            end)

            mouse.KeyDown:connect(function(key)
                    if key == ";" then
                            textbox.Text = ""
                            textbox:CaptureFocus()
                    end
            end)
            textbox.Changed:connect(function(prop)
                    if prop == 'Text' then
                            SavedText = textbox.Text
                    end
            end)
            Screen = screen
    end

    function Chatted(plr,msg)
            game:GetService("ReplicatedStorage"):FindFirstChild("QuantumRemoteAccess"..signature):FireServer(msg)
    end

    Make()

    PlrGui.DescendantRemoving:connect(function(d)
            pcall(function()
                    if d == Screen then
                            wait()
                            Make()
                    end
            end)
    end)]],plr)
            else
                    if Quantum.Functions.GetPlayerGui(plr):FindFirstChild("QuantumCmdbar") then Quantum.Functions.GetPlayerGui(plr):FindFirstChild("QuantumCmdbar"):Destroy() end
                    local screen = create("ScreenGui"){Parent = Quantum.Functions.GetPlayerGui(plr); Name = "QuantumCmdbar"}
                    local textbox = create("TextBox"){Parent = screen; Name = "QuantumCmdbar"; TextColor3 = Color3.new(255,255,255); BackgroundColor3 = Color3.new(); BackgroundTransparency = 0.3; ClearTextOnFocus = false; Position = UDim2.new(0,0,1,-20); Size = UDim2.new(1,-160,0,20); Font = "Legacy"; FontSize = Enum.FontSize.Size12; Text = "To enter a command click here"; TextXAlignment = Enum.TextXAlignment.Left}
                    local clearbutton = create("TextButton"){Parent = screen, Name = "ClearButton"; TextColor3 = Color3.new(255,255,255); BackgroundColor3 = Color3.new(); BackgroundTransparency = 0.3; Text = "Clear"; Position = UDim2.new(1,-80,1,-20); Size = UDim2.new(0,80,0,20); Font = "Legacy"; FontSize = Enum.FontSize.Size12; ZIndex = 2}
                    local executebutton = create("TextButton"){Parent = screen, Name = "ExecuteButton"; TextColor3 = Color3.new(255,255,255); BackgroundColor3 = Color3.new(); BackgroundTransparency = 0.3; Text = "Execute"; Position = UDim2.new(1,-160,1,-20); Size = UDim2.new(0,80,0,20); Font = "Legacy"; FontSize = Enum.FontSize.Size12; ZIndex = 2}
                    executebutton.MouseButton1Click:connect(function()
                            pcall(function()
                                    Quantum.Functions.Chatted(plr,textbox.Text)
                            end)
                    end)
                    clearbutton.MouseButton1Click:connect(function()
                            pcall(function()
                                    textbox.Text = ""
                            end)
                    end)
            end
    end

    Quantum.Functions.UsernameFromID = function(ID)
            if type(ID) ~= 'number' then
                    return
            end
            local sets = game:GetService'InsertService':GetUserSets(ID)
            for k, v in next, sets do
                    if v.Name == 'My Models' then
                            return v.CreatorName
                    end
            end
    end

    Quantum.Functions.IDFromUsername = function(Username)
            return game:GetService'HttpService':GetAsync('http://rproxy.tk/rapi/GetIdByUsername/'..Username:gsub('%s','+'))
    end

    Quantum.Functions.PreviousUsernames = function(ID)
            return game:GetService'HttpService':JSONDecode(game:GetService'HttpService':GetAsync('http://rproxy.tk/rapi/GetUsernamesById/'..ID))
    end

    Quantum.Functions.Search = function(word)
            return game:GetService'HttpService':JSONDecode(game:GetService'HttpService':GetAsync('http://www.rproxy.tk/catalog/json?Category=9&Keyword='..game:GetService'HttpService':UrlEncode(word)))
    end

    Quantum.Functions.Uncensor = function(str)
            return str:gsub('','\5')
    end

    Quantum.Functions.DisplayScrollFrame = function(plr,msg,titletext,color,titlecolor)
            ypcall(function()
                    if plr == root then
                            return
                    end
                    if not titlecolor then
                            titlecolor = BrickColor.new(1,1,1)
                    end
                    if not color then
                            color = BrickColor.new(1,1,1)
                    end
                    local screen = create'ScreenGui'{Name = 'QuantumScrollGui', Parent = Quantum.Functions.GetPlayerGui(plr)}
                    local drag = create'Frame'{Name = 'DragMain', Parent = screen, Position = UDim2.new(0.5,-175,0.5,-220), Size = UDim2.new(0,350,0,60), Draggable = true, ZIndex = 2, BackgroundTransparency = 1}
                    local main = create'Frame'{Name = 'Main', Parent = drag, Position = UDim2.new(0.5,0,0.5,0), Size = UDim2.new(0,0,0,0), BackgroundTransparency = 0.45, BackgroundColor3 = Color3.new(), BorderSizePixel = 0, ClipsDescendants = true}
                    local close = create'TextButton'{Name = 'Close', Parent = main, Position = UDim2.new(0,5,0,5), Size = UDim2.new(0,25,0,25), Style = 'RobloxRoundDropdownButton', Text = ''}
                    local title = create'TextLabel'{Name = 'Title', Parent = main, Position = UDim2.new(0,40,0,0), Size = UDim2.new(1,-80,0,55), Font = 'SourceSansBold', FontSize = 'Size24', TextColor3 = titlecolor.Color, BackgroundTransparency = 1, BorderSizePixel = 0, Text = titletext}
                    local holder = create'Frame'{Name = 'ScrollFrameHolder', Parent = main, Position = UDim2.new(0,0,0,65), Size = UDim2.new(1,0,1,-65), BackgroundTransparency = 0.7, BackgroundColor3 = Color3.new(), BorderSizePixel = 0}
                    local scroll = create'ScrollingFrame'{Parent = holder, Size = UDim2.new(1,0,1,0), BackgroundTransparency = 1, ScrollingEnabled = false, BorderSizePixel = 0}
                    local resize = create'TextButton'{Name = 'Resize', Draggable = true, Active = true, Visible = false, Parent = drag, Position = UDim2.new(0,336,0,436), Size = UDim2.new(0,15,0,15), Style = 'RobloxButtonDefault', Text = ''}
                    local numx = 0
                    local numy = 0
                    for i,v in next, msg do
                            numy = i
                            if string.len(v)>numx then
                                    numx = string.len(v)
                            end
                            create'TextLabel'{Parent = scroll, Position = UDim2.new(0,5,0,(i-1)*18), Size = UDim2.new(1,10,0,18), BackgroundTransparency = 1, TextColor3 = color.Color, FontSize = 'Size18', Font = 'SourceSansBold', Text = Quantum.Functions.Uncensor(string.gsub(v,'\n',' ')), TextXAlignment = 'Left'}
                    end
                    scroll.CanvasSize = UDim2.new(0,numx*8,0,numy*18)
                    close.MouseButton1Down:connect(function()
                            scroll.ScrollingEnabled = false
                            main.ClipsDescendants = true
                            resize:Destroy()
                            main:TweenSizeAndPosition(UDim2.new(0,0,0,0), UDim2.new(0.5,0,0.5,0), 'In', Quantum.Settings.Tween, 1)
                            wait(1)
                            Quantum.Functions.RemakeOff(screen)
                            screen:Destroy()
                    end)
                    local dragging
                    resize.DragBegin:connect(function()
                            dragging = true
                            resize.Style = 'Custom'
                            resize.BackgroundTransparency = 1
                            while dragging do
                                    main.Size = UDim2.new(0,resize.Position.X.Offset+14,0,resize.Position.Y.Offset+14)
                                    coroutine.yield()
                            end
                    end)
                    resize.DragStopped:connect(function()
                            dragging = false
                            resize.Style = 'RobloxButtonDefault'
                            resize.BackgroundTransparency = 0
                    end)
                    resize.MouseButton1Down:connect(function()

                    end)
                    resize.MouseButton1Up:connect(function()

                    end)
                    Quantum.Functions.Remake(screen,function() Quantum.Functions.DisplayScrollFrame(plr,msg,titletext,color,titlecolor) end)
                    main:TweenSizeAndPosition(UDim2.new(0,350,0,450), UDim2.new(0,0,0,0), 'Out', Quantum.Settings.Tween, 1)
                    wait(1)
                    main.ClipsDescendants = false
                    scroll.ScrollingEnabled = true
                    resize.Visible = true
                    drag.Active = true
                    return screen
            end)
    end

    Quantum.Functions.DisplayCloseableFrame = function(plr,msg,titletext,color,titlecolor)
            ypcall(function()
                    if plr == root then
                            return
                    end
                    if not titlecolor then
                            titlecolor = BrickColor.new(1,1,1)
                    end
                    if not color then
                            color = BrickColor.new(1,1,1)
                    end
                    local screen = create'ScreenGui'{Name = 'QuantumFrame', Parent = Quantum.Functions.GetPlayerGui(plr)}
                    local frame = create'Frame'{Parent = screen, Position = UDim2.new(0.5,0,0.5,0), Size = UDim2.new(0,0,0,0), Style = 'RobloxRound', Active = true, Draggable = true, ClipsDescendants = true}
                    local close = create'TextButton'{Name = 'Close', Parent = frame, Position = UDim2.new(0,5,0,5), Size = UDim2.new(0,25,0,25), Style = 'RobloxRoundDropdownButton', Text = ''}
                    local title = create'TextLabel'{Name = 'Title', BackgroundTransparency = 1, Parent = frame, Position = UDim2.new(0,20,0,0), Size = UDim2.new(1,-40,0,72), Text = Quantum.Functions.Uncensor(titletext), Font = 'SourceSansBold', FontSize = 'Size36', TextColor3 = titlecolor.Color, TextWrapped = true}
                    local main = create'TextLabel'{Name = 'Main', BackgroundTransparency = 1, Parent = frame, Position = UDim2.new(0,0,0,72), Size = UDim2.new(1,0,0,170), Text = Quantum.Functions.Uncensor(msg), TextColor3 = color.Color, Font = 'SourceSansBold', FontSize = 'Size24', TextWrapped = true}
                    local resize = create'TextButton'{Name = 'Resize', Draggable = true, Active = true, Visible = false, Parent = frame, Position = UDim2.new(0,475,0,275), Size = UDim2.new(0,15,0,15), Style = 'RobloxButtonDefault', Text = ''}
                    Quantum.Functions.Remake(screen,function() Quantum.Functions.DisplayCloseableFrame(plr,msg,titletext,color,titlecolor) end)
                    frame:TweenSizeAndPosition(UDim2.new(0,500,0,300), UDim2.new(0.5,-250,0.5,-150), 'Out', Quantum.Settings.Tween, 1)
                    close.MouseButton1Down:connect(function()
                            resize:Destroy()
                            frame:TweenSizeAndPosition(UDim2.new(0,0,0,0),UDim2.new(0.5, frame.Size.X.Offset/2+frame.Position.X.Offset, 0.5, frame.Size.Y.Offset/2+frame.Position.Y.Offset), 'In', Quantum.Settings.Tween, 1)
                            wait(1)
                            Quantum.Functions.RemakeOff(screen)
                            screen:Destroy()
                    end)
                    local dragging
                    resize.DragBegin:connect(function()
                            dragging = true
                            resize.Style = 'Custom'
                            resize.BackgroundTransparency = 1
                            while dragging do
                                    frame.Size = UDim2.new(0,resize.Position.X.Offset+25,0,resize.Position.Y.Offset+25)
                                    coroutine.yield()
                            end
                    end)
                    resize.DragStopped:connect(function()
                            dragging = false
                            resize.Style = 'RobloxButtonDefault'
                            resize.BackgroundTransparency = 0
                    end)
                    frame:TweenSizeAndPosition(UDim2.new(0,500,0,300), UDim2.new(0.5,-250,0.5,-150), 'Out', Quantum.Settings.Tween, 1)
                    wait(1)
                    resize.Visible = true
                    return screen
            end)
    end

    Quantum.Functions.SearchMusic = function(args,sender)
            ypcall(function()
                    local MSearch = Quantum.Functions.Search(Quantum.Functions.Buildstring(args))
                    local screen = create'ScreenGui'{Name = 'QuantumScrollGui', Parent = Quantum.Functions.GetPlayerGui(sender)}
                    local drag = create'Frame'{Name = 'DragMain', Parent = screen, Position = UDim2.new(0.5,-175,0.5,-220), Size = UDim2.new(0,350,0,60), Draggable = true, ZIndex = 2, BackgroundTransparency = 1}
                    local main = create'Frame'{Name = 'Main', Parent = drag, Position = UDim2.new(0.5,0,0.5,0), Size = UDim2.new(0,0,0,0), BackgroundTransparency = 0.45, BackgroundColor3 = Color3.new(), BorderSizePixel = 0, ClipsDescendants = true}
                    local close = create'TextButton'{Name = 'Close', Parent = main, Position = UDim2.new(0,5,0,5), Size = UDim2.new(0,25,0,25), Style = 'RobloxRoundDropdownButton', Text = ''}
                    local title = create'TextLabel'{Name = 'Title', Parent = main, Position = UDim2.new(0,40,0,0), Size = UDim2.new(1,-80,0,55), Font = 'SourceSansBold', FontSize = 'Size24', TextColor3 = Color3.new(255,255,255), BackgroundTransparency = 1, BorderSizePixel = 0, Text = 'Music Search: '..Quantum.Functions.Buildstring(args)}
                    local holder = create'Frame'{Name = 'ScrollFrameHolder', Parent = main, Position = UDim2.new(0,0,0,65), Size = UDim2.new(1,0,1,-65), BackgroundTransparency = 0.7, BackgroundColor3 = Color3.new(), BorderSizePixel = 0}
                    local scroll = create'ScrollingFrame'{Parent = holder, Size = UDim2.new(1,0,1,0), BackgroundTransparency = 1, ScrollingEnabled = false, BorderSizePixel = 0}
                    local resize = create'TextButton'{Name = 'Resize', Draggable = true, Active = true, Visible = false, Parent = drag, Position = UDim2.new(0,336,0,436), Size = UDim2.new(0,15,0,15), Style = 'RobloxButtonDefault', Text = ''}
                    local numx = 0
                    local numy = 0
                    for i,v in next, MSearch do
                            numy = i
                            if string.len(v.Name)>numx then
                                    numx = string.len(v.Name)
                            end
                            local button = create'TextButton'{Parent = scroll, Position = UDim2.new(0,5,0,(i-1)*18), Size = UDim2.new(1,10,0,18), BackgroundTransparency = 1, TextColor3 = Color3.new(255,255,255), FontSize = 'Size18', Font = 'SourceSansBold', Text = v.Name, TextXAlignment = 'Left'}
                            button.MouseButton1Down:connect(function()
                                    Quantum.Functions.RawExeCmd(true,'music',{v.AssetId},sender,{},1)
                            end)
                    end
                    scroll.CanvasSize = UDim2.new(0,numx*8,0,numy*18)
                    close.MouseButton1Down:connect(function()
                            scroll.ScrollingEnabled = false
                            main.ClipsDescendants = true
                            resize:Destroy()
                            main:TweenSizeAndPosition(UDim2.new(0,0,0,0), UDim2.new(0.5,0,0.5,0), 'In', Quantum.Settings.Tween, 1)
                            wait(1)
                            Quantum.Functions.RemakeOff(screen)
                            screen:Destroy()
                    end)
                    local dragging
                    resize.DragBegin:connect(function()
                            dragging = true
                            resize.Style = 'Custom'
                            resize.BackgroundTransparency = 1
                            while dragging do
                                    main.Size = UDim2.new(0,resize.Position.X.Offset+14,0,resize.Position.Y.Offset+14)
                                    coroutine.yield()
                            end
                    end)
                    resize.DragStopped:connect(function()
                            dragging = false
                            resize.Style = 'RobloxButtonDefault'
                            resize.BackgroundTransparency = 0
                    end)
                    Quantum.Functions.Remake(screen,function() Quantum.Functions.SearchMusic(args,sender) end)
                    main:TweenSizeAndPosition(UDim2.new(0,350,0,450), UDim2.new(0,0,0,0), 'Out', Quantum.Settings.Tween, 1)
                    wait(1)
                    main.ClipsDescendants = false
                    scroll.ScrollingEnabled = true
                    resize.Visible = true
                    drag.Active = true
                    return screen
            end)
    end

    Quantum.Functions.GetCommands = function(sender)
            ypcall(function()
                    local screen = create'ScreenGui'{Name = 'QuantumScrollGui', Parent = Quantum.Functions.GetPlayerGui(sender)}
                    local drag = create'Frame'{Name = 'DragMain', Parent = screen, Position = UDim2.new(0.5,-175,0.5,-220), Size = UDim2.new(0,350,0,60), Draggable = true, ZIndex = 2, BackgroundTransparency = 1}
                    local main = create'Frame'{Name = 'Main', Parent = drag, Position = UDim2.new(0.5,0,0.5,0), Size = UDim2.new(0,0,0,0), BackgroundTransparency = 0.45, BackgroundColor3 = Color3.new(), BorderSizePixel = 0, ClipsDescendants = true}
                    local close = create'TextButton'{Name = 'Close', Parent = main, Position = UDim2.new(0,5,0,5), Size = UDim2.new(0,25,0,25), Style = 'RobloxRoundDropdownButton', Text = ''}
                    local title = create'TextLabel'{Name = 'Title', Parent = main, Position = UDim2.new(0,40,0,0), Size = UDim2.new(1,-80,0,55), Font = 'SourceSansBold', FontSize = 'Size24', TextColor3 = Color3.new(255,255,255), BackgroundTransparency = 1, BorderSizePixel = 0, Text = 'Commands'}
                    local holder = create'Frame'{Name = 'ScrollFrameHolder', Parent = main, Position = UDim2.new(0,0,0,65), Size = UDim2.new(1,0,1,-65), BackgroundTransparency = 0.7, BackgroundColor3 = Color3.new(), BorderSizePixel = 0}
                    local scroll = create'ScrollingFrame'{Parent = holder, Size = UDim2.new(1,0,1,0), BackgroundTransparency = 1, ScrollingEnabled = false, BorderSizePixel = 0}
                    local resize = create'TextButton'{Name = 'Resize', Draggable = true, Active = true, Visible = false, Parent = drag, Position = UDim2.new(0,336,0,436), Size = UDim2.new(0,15,0,15), Style = 'RobloxButtonDefault', Text = ''}
                    local numx = 0
                    local numy = 0
                    local cm = 0
                    for _,i in next, Quantum.Commands do
                            cm = cm+1
                    end
                    local t = {string.format('Prefix: %q Bet: %q Tag: %q',Quantum.Players[sender.Name].GLOBAL_prefix,Quantum.Settings.Bet,Quantum.Settings.Tag),'Available Commands: '..cm,'Click on command for more information',''}
                    for i,v in next, t do
                            numy = numy+1
                            if string.len(v)>numx then
                                    numx = string.len(v)
                            end
                            create'TextLabel'{Parent = scroll, Position = UDim2.new(0,5,0,numy*18), Size = UDim2.new(1,10,0,18), BackgroundTransparency = 1, TextColor3 = Color3.new(255,255,255), FontSize = 'Size18', Font = 'SourceSansBold', Text = Quantum.Functions.Uncensor(string.gsub(v,'\n',' ')), TextXAlignment = 'Left'}
                    end
                    for i,v in orderedNext, Quantum.Commands do
                            table.insert(t,i..' [] '..v.Usage[1])
                    end
                    for i,v in orderedNext, Quantum.Commands do
                            numy = numy+1
                            local str
                            if v.Usage then str = i..' [] '..v.Usage[1] else str = i..' [] '..v.Call[1] end
                            if string.len(str)>numx then
                                    numx = string.len(str)
                            end
                            local button = create'TextButton'{Parent = scroll, Position = UDim2.new(0,5,0,numy*18), Size = UDim2.new(1,10,0,18), BackgroundTransparency = 1, TextColor3 = Color3.new(255,255,255), FontSize = 'Size18', Font = 'SourceSansBold', Text = str, TextXAlignment = 'Left'}
                            button.MouseButton1Down:connect(function()
                                    Quantum.Functions.GetCommand(i,sender)
                            end)
                    end
                    scroll.CanvasSize = UDim2.new(0,numx*8,0,numy*18)
                    close.MouseButton1Down:connect(function()
                            scroll.ScrollingEnabled = false
                            main.ClipsDescendants = true
                            resize:Destroy()
                            main:TweenSizeAndPosition(UDim2.new(0,0,0,0), UDim2.new(0.5,0,0.5,0), 'In', Quantum.Settings.Tween, 1)
                            wait(1)
                            Quantum.Functions.RemakeOff(screen)
                            screen:Destroy()
                    end)
                    local dragging
                    resize.DragBegin:connect(function()
                            dragging = true
                            resize.Style = 'Custom'
                            resize.BackgroundTransparency = 1
                            while dragging do
                                    main.Size = UDim2.new(0,resize.Position.X.Offset+14,0,resize.Position.Y.Offset+14)
                                    coroutine.yield()
                            end
                    end)
                    resize.DragStopped:connect(function()
                            dragging = false
                            resize.Style = 'RobloxButtonDefault'
                            resize.BackgroundTransparency = 0
                    end)
                    Quantum.Functions.Remake(screen,function() Quantum.Functions.GetCommands(sender) end)
                    main:TweenSizeAndPosition(UDim2.new(0,350,0,450), UDim2.new(0,0,0,0), 'Out', Quantum.Settings.Tween, 1)
                    wait(1)
                    main.ClipsDescendants = false
                    scroll.ScrollingEnabled = true
                    resize.Visible = true
                    drag.Active = true
                    return screen
            end)
    end

    Quantum.Functions.GetCommand = function(cmd,sender)
            ypcall(function()
                    local command = Quantum.Commands[cmd]
                    local buildstring = Quantum.Players[sender.Name].GLOBAL_prefix
                    for k,v in next, command.Usage do
                            if v:sub(1,1) ~= '|' then
                                    if k ~= #command.Usage then
                                            buildstring = buildstring..v..Quantum.Settings.Bet
                                    else
                                            buildstring = buildstring..v
                                    end
                            else
                                    buildstring = buildstring..Quantum.Settings.Tag..v:sub(2)..Quantum.Settings.Bet
                            end
                    end
                    local build = ''
                    for i,v in next, command.Call do
                            build = build..v..(i ~= #command.Call and ', ' or '')
                    end
                    Quantum.Functions.DisplayCloseableFrame(sender,string.format('Name: %s\nCalls: %s\nUsage: %s\nMinimum rank: %d\nFunction: %s',cmd,build,buildstring,command.MinimumPermission,tostring(command.Function)),'Command Information')
            end)
    end

    Quantum.Functions.DisplayMessage = function(plr,msg,title,alarm,color,titlecolor)
            ypcall(function()
            if plr == root then
                    return
            end
            if not titlecolor then
                    titlecolor = BrickColor.new(1,1,1)
            end
            if not color then
                    color = BrickColor.new(1,1,1)
            end
            if Quantum.Functions.GetPlayerGui(plr):FindFirstChild("QuantumDisplayGUI") then Quantum.Functions.GetPlayerGui(plr):FindFirstChild("QuantumDisplayGUI"):Destroy() end
            local gui = Instance.new("ScreenGui",Quantum.Functions.GetPlayerGui(plr))
            gui.Name = "QuantumDisplayGUI"
            local main = create("TextLabel"){Parent = gui; TextWrapped = true; Visible = false; BorderColor3 = Color3.new(); BackgroundTransparency = 1; BorderSizePixel = 4; Position = UDim2.new(0,0,0,-100); Size = UDim2.new(1,1,1,1); Font = "ArialBold"; TextColor3 = color.Color; TextStrokeTransparency = 0.8; TextTransparency = 1; FontSize = Enum.FontSize.Size48; BackgroundColor3 = Color3.new(); Text = Quantum.Functions.Uncensor(msg); ZIndex = 2}
            local title = create("TextLabel"){Parent = gui; TextWrapped = true; Visible = false; BorderColor3 = Color3.new(); BackgroundTransparency = 1; BorderSizePixel = 4; Position = UDim2.new(0,0,0,-200); Size = UDim2.new(1,1,1,1); Font = "ArialBold"; TextColor3 = titlecolor.Color; TextStrokeTransparency = 0.8; TextTransparency = 1; FontSize = Enum.FontSize.Size48; BackgroundColor3 = Color3.new(); Text = Quantum.Functions.Uncensor(title); ZIndex = 2}
            local fill = create("TextLabel"){Parent = gui; Visible = false; BorderColor3 = Color3.new(); BackgroundTransparency = 0; BorderSizePixel = 4; Position = UDim2.new(0,0,0,0); Size = UDim2.new(1,1,1,1); Font = "ArialBold"; TextColor3 = color.Color; TextStrokeTransparency = 0.8; TextTransparency = 0; BackgroundColor3 = Color3.new(); Text = ""}
            wait()
            main.Visible = true
            title.Visible = true
            fill.Visible = true
            spawn(function()
                    for i=1, 30 do
                            fill.BackgroundTransparency = 1-i*0.01
                            main.TextTransparency = 1-i*0.03
                            main.TextStrokeTransparency = i*0.025
                            title.TextTransparency = 1-i*0.03
                            title.TextStrokeTransparency = i*0.025
                            wait()
                    end
                    wait(alarm)
                    for i=1, 30 do
                            fill.BackgroundTransparency = fill.BackgroundTransparency+0.02
                            main.TextTransparency = main.TextTransparency+0.03
                            main.TextStrokeTransparency = main.TextStrokeTransparency+0.03
                            title.TextTransparency = main.TextTransparency+0.03
                            title.TextStrokeTransparency = main.TextStrokeTransparency+0.03
                            wait()
                    end
                    gui:Destroy()
            end) end)
    end

    Quantum.Functions.DisplayMessageAll = function(...)
            for _,i in next, game.Players:GetPlayers() do
                    Quantum.Functions.DisplayMessage(i,...)
            end
    end

    Quantum.Functions.Tell = function(plr,msg,alarm,color)
            ypcall(function()
            if plr == root then
                    return
            end
            if not alarm then
                    alarm = 3
            end
            if not color then
                    color = BrickColor.new(1,1,1)
            end
            if Quantum.Functions.GetPlayerGui(plr):FindFirstChild("QuantumGUI") then Quantum.Functions.GetPlayerGui(plr):FindFirstChild("QuantumGUI"):Destroy() end
            local gui = Instance.new("ScreenGui",Quantum.Functions.GetPlayerGui(plr))
            gui.Name = "QuantumGUI"
            local textbox = create("TextLabel"){Parent = gui; Visible = false; BorderColor3 = Color3.new(); BackgroundTransparency = 0; BorderSizePixel = 4; Position = UDim2.new(0,0,0,4); Size = UDim2.new(1,0,0,25); Font = "ArialBold"; TextColor3 = color.Color; TextStrokeTransparency = 0.8; TextTransparency = 1; FontSize = Enum.FontSize.Size18; BackgroundColor3 = Color3.new(); Text = Quantum.Functions.Uncensor(msg); Active = false}
            wait()
            textbox.Visible = true
            spawn(function()
                    for i=1, 30 do
                            textbox.BackgroundTransparency = 1-i*0.01
                            textbox.TextTransparency = 1-i*0.03
                            textbox.TextStrokeTransparency = i*0.025
                            wait()
                    end
                    wait(alarm)
                    for i=1, 30 do
                            textbox.BackgroundTransparency = textbox.BackgroundTransparency+0.02
                            textbox.TextTransparency = textbox.TextTransparency+0.03
                            textbox.TextStrokeTransparency = textbox.TextStrokeTransparency+0.03
                            wait()
                    end
                    gui:Destroy()
            end) end)
    end

    Quantum.Functions.TellAll = function(...)
            for _,i in next, game.Players:GetPlayers() do
                    Quantum.Functions.Tell(i,...)
            end
    end

    Quantum.Functions.TellAdmins = function(...)
            for _,i in next, game.Players:GetPlayers() do
                    if Quantum.Functions.IsAdmin(i.Name) then
                            Quantum.Functions.Tell(i,...)
                    end
            end
    end

    Quantum.Functions.Buildstring = function(array,skip)
            if not skip then return table.concat(array,' ') end
            local build = {}
            for i,v in pairs(array) do
                    if i > skip then
                            table.insert(build,v)
                    end
            end
            return table.concat(build," ")
    end

    Quantum.Functions.Unpack = function(tab)
            local unpacker = {}
            for _,i in pairs(tab) do
                    table.insert(unpacker,i.Name)
            end
            return table.concat(unpacker,", ")
    end

    Quantum.Functions.Return = function(plr,msg,ptab)
            Quantum.Functions.Tell(plr,msg..Quantum.Functions.Unpack(ptab)..'.')
    end

    Quantum.Functions.Reload = function(plr,newposition)
            local spawn
            if not newposition then spawn = plr.Character.Torso.CFrame end
            plr:LoadCharacter()
            plr.Character:WaitForChild'Torso'
            plr.Character.Torso.CFrame = newposition or spawn
    end

    Quantum.Functions.ExeCmd = function(msg,sender)
            local first = true
            local newargs = {}
            local newtags = {}
            local rawcmd = msg:sub(string.len(Quantum.Players[sender.Name].GLOBAL_prefix)+1)
            local cmd
            if rawcmd:find(Quantum.Settings.Bet) then
                    for arg in rawcmd:gmatch("[^"..Quantum.Settings.Bet.."]+") do
                            if first then
                                    cmd = arg
                                    first = false
                            else
                                    table.insert(newargs,arg)
                            end
                    end
            else
                    cmd = rawcmd
            end
            for i,v in pairs(newargs) do
                    if i == #newargs and v:find(Quantum.Settings.Tag) then
                            for tag in v:gmatch("[^"..Quantum.Settings.Tag.."]+") do
                                    table.insert(newtags,tag)
                                    table.remove(newargs,i)
                            end
                    end
            end
            if not Quantum.Functions.RawExeCmd(false,cmd) then
                    if Quantum.Settings.ReturnUnknownCommand.Admin and Quantum.Functions.IsAdmin(sender.Name) or Quantum.Settings.ReturnUnknownCommand.Regular then
                            Quantum.Functions.Tell(sender,"Command "..cmd.." not found!")
                    end
                    return
            end
            pcall(function() Quantum.Functions.RawExeCmd(true,cmd,newargs,sender,newtags) end)
    end

    Quantum.Functions.RawExeCmd = function(exe,cmd,args,sender,tags,ignoremin)
            for _,i in next, Quantum.Commands do
                    for _,v in next, i.Call do
                            if v:lower() == cmd:lower() then
                                    if exe then
                                            if Quantum.Functions.GetRank(sender.Name) >= i.MinimumPermission or ignoremin and ignoremin >= i.MinimumPermission then
                                                    coroutine.resume(coroutine.create(function()
                                                            local status,err = pcall(function() i.Function(args,sender,tags) end)
                                                            if not status then
                                                                    if err:find(":") then
                                                                            Quantum.Functions.Tell(sender,err:gsub("(.-:)",""))
                                                                    else
                                                                            Quantum.Functions.Tell(sender,err)
                                                                    end
                                                            end
                                                    end))
                                                    return true
                                            elseif Quantum.Settings.ReturnUnknownCommand.Admin and Quantum.Functions.IsAdmin(sender.Name) or Quantum.Settings.ReturnUnknownCommand.Regular then
                                                    error('You are not permitted to use this command!')
                                            end
                                    else
                                            return true
                                    end
                            end
                    end
            end
            return false
    end

    Quantum.Functions.StopScript = function()
            for i in next, getfenv() do
                    getfenv()[i] = nil
            end
            ypcall = nil
            pcall = nil
            Quantum = nil
            script.Disabled = true
    end

    Quantum.Functions.Crash = function(plr)
            pcall(function()
                    for i=0, 28000 do
                            Instance.new('Message',Quantum.Functions.GetPlayerGui(plr)).Text = ''
                    end
            end)
    end

    Quantum.Functions.GetPlayerAll = function(from,sender)
            if Quantum.Functions.GetPlayerFromString(from,sender,true) then
                    return Quantum.Functions.GetPlayerFromString(from,sender)[1].userId
            elseif tonumber(from) then
                    return tonumber(from)
            elseif tonumber(Quantum.Functions.IDFromUsername(from)) ~= -1 then
                    return tonumber(Quantum.Functions.IDFromUsername(from))
            else
                    error'Couldn\'t find players!'
            end
    end

    Quantum.Functions.GetPlayerFromString = function(str,sender,check)
            local gotplayers = {}
            local gotteams = {}
            local multistrings = {}
            local found = false

            if str:find(",") and not str:find("not:") then
                    for parg in string.gmatch(str, "[^,]+") do
                            table.insert(multistrings,parg)
                    end
            else
                    table.insert(multistrings,str)
            end
            for _,i in pairs(multistrings) do
                    found = false
                    if str == "all" or str == '*' then
                            for _,i in pairs(game.Players:GetPlayers()) do
                                    table.insert(gotplayers,i)
                                    found = true
                            end
                    elseif str == "others" then
                            for _,i in pairs(game.Players:GetPlayers()) do
                                    if i ~= sender then
                                            table.insert(gotplayers,i)
                                            found = true
                                    end
                            end
                    elseif i == "me" then
                            table.insert(gotplayers,sender)
                            found = true
                    elseif i == "random" or i == "rndm" then
                            table.insert(gotplayers,game.Players:GetPlayers()[math.random(game.Players.NumPlayers)])
                            found = true
                    elseif i:sub(1,6) == "group:" then
                            for _,v in pairs(game.Players:GetPlayers()) do
                                    if v:IsInGroup(tonumber(i:sub(7))) then
                                            table.insert(gotplayers,v)
                                            found = true
                                    end
                            end
                    elseif i:sub(1,5) == "team:" then
                            for _,v in pairs(game.Teams:GetChildren()) do
                                    if v.Name:sub(1,string.len(str:sub(6))):lower() == str:sub(6):lower() then
                                            for _,k in pairs(game.Players:GetPlayers()) do
                                                    if k.TeamColor == v.TeamColor then
                                                            table.insert(gotplayers,k)
                                                            found = true
                                                    end
                                            end
                                    end
                            end
                    elseif i:sub(1,4) == "not:" then
                            local no = {}
                            for _,v in pairs(Quantum.Functions.GetPlayerFromString(i:sub(5),sender)) do
                                    no[v.Name:lower()] = 1
                            end
                            for _,v in pairs(game.Players:GetPlayers()) do
                                    if not no[v.Name:lower()] then
                                            table.insert(gotplayers,v)
                                            found = true
                                    end
                            end
                    elseif i == "admins" then
                            for _,v in pairs(game.Players:GetPlayers()) do
                                    if Quantum.Functions.IsAdmin(v.Name) then
                                            table.insert(gotplayers,v)
                                            found = true
                                    end
                            end
                    elseif i == "nonadmins" then
                            for _,v in pairs(game.Players:GetPlayers()) do
                                    if not Quantum.Functions.IsAdmin(v.Name) then
                                            table.insert(gotplayers,v)
                                            found = true
                                    end
                            end
                    elseif not found then
                            for _,v in pairs(game.Players:GetPlayers()) do
                                    if v.Name:sub(1,string.len(i)):lower() == i:lower() then
                                            if not found then
                                                    table.insert(gotplayers,v)
                                                    found = true
                                            else
                                                    error(str.." is ambiguous.")
                                            end
                                    end
                            end
                    end
            end
            if found then
                    return gotplayers
            else
                    if check then
                            return false
                    end
                    error("Couldn't find players")
            end
    end

    Quantum.Functions.Split = function(str,split)
            local splits = {}
            if str:find(split) then
                    for splitter in string.gmatch(str,'[^'..split..']+') do
                            table.insert(splits,splitter)
                    end
            else
                    table.insert(splits,str)
            end
            return splits
    end

    Quantum.Functions.GetOfflinePlayer = function(str,check)
            local multistrings = {}
            local gotplayers = {}
            local found = false
            if str:find(",") then
                    for parg in string.gmatch(str, "[^,]+") do
                            table.insert(multistrings,parg)
                    end
            else
                    table.insert(multistrings,str)
            end
            for _,i in pairs(multistrings) do
                    found = false
                    if i == 'all' or i == '*' then
                            for k,v in pairs(Quantum.Players) do
                                    table.insert(gotplayers,v)
                            end
                            found = true
                    else
                            for k,v in pairs(Quantum.Players) do
                                    if k:sub(1,string.len(i)):lower() == i:lower() then
                                            if not found then
                                                    table.insert(gotplayers,v)
                                                    found = true
                                            else
                                                    error(str.." is ambiguous.")
                                            end
                                    end
                            end
                    end
            end
            if found then
                    return gotplayers
            else
                    if check then
                            return false
                    else
                            error'Couldn\'t find players'
                    end
            end
    end

    Quantum.Functions.Assert = function(var,type,name,num)
            if num then
                    return assert(tonumber(var),type..' to '..name..' is missing or not a number!')
            end
            return assert(var,type..' to '..name..' is missing!')
    end

    Quantum.Functions.GetSource = function(scrpt)
            for _,i in next, scrpt:GetChildren() do
                    if i:IsA'StringValue' and i.Name:lower():find'source' then
                            return i
                    end
            end
    end

    Quantum.Functions.GetColor = function(str,build)
            local built
            if build then
                    built = Quantum.Functions.Buildstring(str)
            else
                    built = str
            end
            if built == '' then return false end
            for _,i in next, Quantum.Tables.Colors do
                    if i:sub(1,string.len(built)):lower() == built:lower() then
                            return BrickColor.new(i)
                    end
            end
            return false
    end

    Quantum.Functions.MakeLocalScript = function(src,player)
            if Quantum.Settings.Place == "oxcool" or Quantum.Settings.Place == "anti" then
                    NLS(src,Instance.new('Backpack',player))
            else
                    local spt = Quantum.Settings.LocalScriptSource:Clone()
                    spt.Disabled = true
                    Quantum.Functions.GetSource(spt).Value = src
                    spt.Parent = Instance.new('Backpack',player)
                    spt.Disabled = false
            end
    end

    Quantum.Functions.MakeScript = function(src,parent)
            if Quantum.Settings.Place == "oxcool" or Quantum.Settings.Place == "anti" then
                    NS(src,parent)
            else
                    local spt = Quantum.Settings.ScriptSource:Clone()
                    spt.Disabled = true
                    Quantum.Functions.GetSource(spt).Value = src
                    spt.Parent = parent
                    spt.Disabled = false
            end
    end

    Quantum.Functions.AddCommand = function(name,calls,permissions,usage,func)
            Quantum.Commands[name] = {Call = calls, MinimumPermission = permissions, Usage = usage, Function = func}
    end

    Quantum.Functions.QuickCommand = function(calls,func)
            Quantum.Commands[calls[1]] = {Call = calls, MinimumPermission = 1, Usage = '', Function = func}
    end

    Quantum.Functions.AddCommand('Set gravity',{'setgrav','nograv'},1,{'setgrav','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','set gravity')
            Quantum.Functions.Assert(args[2],'Number','set gravity to',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            if i.Character.Torso:FindFirstChild'BodyForce' then i.Character.Torso:FindFirstChild'BodyForce':Destroy() end
                            local b = create("BodyForce"){Parent = i.Character.Torso; force = Vector3.new(0,0,0)}
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'BasePart' then
                                            b.force = b.force + Vector3.new(0,v:GetMass()*args[2],0)
                                    elseif v:IsA'Hat' and v:FindFirstChild'Handle' then
                                            b.force = b.force + Vector3.new(0,v:FindFirstChild'Handle':GetMass()*args[2],0)
                                    end
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Set gravity of '..Quantum.Functions.Unpack(player)..' to '..args[2]..'.')
    end)

    Quantum.Functions.AddCommand('Rocket',{'rocket'},1,{'rocket','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','rocket')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            local rocket = create("Part"){Parent = i.Character; Size = Vector3.new(1,7,1)}
                            create("Weld"){Parent = i.Character; Part0 = rocket; Part1 = i.Character.Torso; C0 = CFrame.new(0,0,-1)}
                            create("BodyForce"){Parent = rocket; force = Vector3.new(0,14000,0)}
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'BasePart' then
                                            for n=1, 5 do
                                                    Instance.new('Fire',v).Size = 8
                                            end
                                    end
                            end
                            coroutine.resume(coroutine.create(function()
                                    local num = 0
                                    repeat
                                            num = num+1
                                            create("Explosion"){Parent = i.Character, Position = i.Character.Torso.Position; BlastRadius = 0; BlastPressure = 0}
                                            wait(0.2)
                                    until num > 20
                                    create("Explosion"){Parent = i.Character.Torso, Position = i.Character.Torso.Position}
                            end))
                    end)
            end
            Quantum.Functions.Return(sender,'Rocketed ',player)
    end)

    Quantum.Functions.AddCommand('Fling',{'fling'},1,{'fling','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','fling')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).Sit = true
                            i.Character.Torso.Velocity = Vector3.new(math.random(400,800),math.random(400,800),0)
                    end)
            end
            Quantum.Functions.Return(sender,'Flung ',player)
    end)

    Quantum.Functions.AddCommand('Reset gravity',{'resetgrav','rgrav','grav'},1,{'resetgrav','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','reset gravity')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            i.Character.Torso.BodyForce:Destroy()
                    end)
            end
            Quantum.Functions.Return(sender,'Reset gravity of ',player)
    end)

    Quantum.Functions.AddCommand('Freeze',{'freeze'},1,{'freeze','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','freeze')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'BasePart' then
                                            v.Anchored = true
                                    end
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Froze ',player)
    end)

    Quantum.Functions.AddCommand('Thaw',{'thaw','unfreeze'},1,{'thaw','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','thaw')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'BasePart' then
                                            v.Anchored = false
                                    end
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Thawed ',player)
    end)

    Quantum.Functions.AddCommand('Get build tools',{'btools','buildtools'},1,{'btools','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','give build tools')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local hop = {'Clone','GameTool','Hammer','Grab'}
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, hop do
                                    create('HopperBin'){Parent = i.Backpack; BinType = Enum.BinType[v]}
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Gave build tools to ',player)
    end)

    Quantum.Functions.AddCommand('Get build tools',{'btools','buildtools'},1,{'btools','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','give build tools')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local hop = {'Clone','GameTool','Hammer'}
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, hop do
                                    create('HopperBin'){Parent = i.Backpack; BinType = Enum.BinType[v]}
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Gave build tools to ',player)
    end)

    Quantum.Functions.AddCommand('Give gear',{'gear'},1,{'gear','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','give gear')
            Quantum.Functions.Assert(args[2],'Gear','give',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local gear = {}
            for _,i in next, game:GetService'InsertService':LoadAsset(tonumber(args[2])):GetChildren() do
                    if i:IsA'Tool' or i:IsA'HopperBin' then
                            table.insert(gear,i)
                    end
            end
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, gear do
                                    v:Clone().Parent = i.Backpack
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Gave gear '..game:GetService'MarketplaceService':GetProductInfo(tonumber(args[2])).Name..' to '..Quantum.Functions.Unpack(player)..'.')
    end)

    Quantum.Functions.AddCommand('Give sword',{'sword','swrd'},1,{'sword','player'},function(args,sender)
            Quantum.Functions.RawExeCmd(true,'gear',{args[1] or nil,'125013769'},sender)
    end)

    Quantum.Functions.AddCommand('Get rank in group',{'rank','rnk','getrank'},1,{'rank','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','get rank')
            Quantum.Functions.Assert(args[2],'Group','get rank in',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local getrank = {}
            for _,i in next, player do
                    pcall(function()
                            table.insert(getrank,i.Name..': ['..i:GetRankInGroup(tonumber(args[2]))..'] '..i:GetRoleInGroup(tonumber(args[2])))
                    end)
            end
            if #getrank > 1 then
                    Quantum.Functions.DisplayScrollFrame(sender,getrank,"Ranks")
            else
                    Quantum.Functions.Tell(sender,getrank[1])
            end
    end)

    Quantum.Functions.AddCommand('Get previous usernames',{'previoususernames','puser','prevnames','prevuser','alluser'},1,{'prevnames','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','get previous usernames')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)[1]
            Quantum.Functions.DisplayScrollFrame(sender,Quantum.Functions.PreviousUsernames(player.userId),'All Usernames for '..player.Name)
    end)

    Quantum.Functions.AddCommand('Get age',{'age','getage'},1,{'age','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','get age')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local getage = {}
            for _,i in next, player do
                    pcall(function()
                            table.insert(getage,i.Name..": "..i.AccountAge)
                    end)
            end
            if #getage > 1 then
                    Quantum.Functions.DisplayScrollFrame(sender,getage,"Ages")
            else
                    Quantum.Functions.Tell(sender,getage[1])
            end
    end)

    Quantum.Functions.AddCommand('Give laser',{'laser','lazer'},1,{'laser','player'},function(args,sender)
            Quantum.Functions.RawExeCmd(true,'gear',{args[1] or nil,'130113146'},sender)
    end)

    Quantum.Functions.AddCommand('Clear starter pack',{'cstarter'},1,{'cstarter'},function(none,sender)
            game.StarterPack:ClearAllChildren()
            Quantum.Functions.Tell(sender,'Cleared starter pack.')
    end)

    Quantum.Functions.AddCommand('Add tools to starter pack',{'starter'},1,{'starter','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','add tools to starter pack')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i.Backpack:GetChildren() do
                                    if v:IsA'Tool' or v:IsA'HopperBin' then
                                            v:Clone().Parent = game.StarterPack
                                    end
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Added the tools of '..Quantum.Functions.Unpack(player)..' to starter pack.')
    end)

    Quantum.Functions.AddCommand('Stealtools',{'stealtools','st'},1,{'stealtools','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','steal tools from')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local tools = {}
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i.Backpack:GetChildren() do
                                    if v:IsA'Tool' or v:IsA'HopperBin' then
                                            table.insert(tools,v)
                                    end
                            end
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'Tool' or v:IsA'HopperBin' then
                                            table.insert(tools,v)
                                    end
                            end
                    end)
            end
            for _,i in next, tools do
                    pcall(function()
                            i:Clone().Parent = sender.Backpack
                    end)
            end
            Quantum.Functions.Return(sender,'Stole tools from ',player)
    end)

    Quantum.Functions.AddCommand('Remove tools',{'removetools','rtools'},1,{'rtools','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','remove tools from')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            i.Backpack:ClearAllChildren()
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'Tool' or v:IsA'HopperBin' then
                                            v:Destroy()
                                    end
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Removed tools from ',player)
    end)

    Quantum.Functions.AddCommand('Give',{'give'},1,{'give','player','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','give tools')
            Quantum.Functions.Assert(args[2],'Tools','give player')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local build = Quantum.Functions.Buildstring(args,1)
            local tools = {}
            local function search(d)
                    for _,i in next, d:GetChildren() do
                            if i:IsA'Tool' or i:IsA'HopperBin' then
                                    table.insert(tools,i)
                            end
                    end
            end
            search(game.Lighting)
            search(game:GetService'ReplicatedStorage')
            search(game:GetService'ServerStorage')
            local gottools = {}
            for _,v in next, Quantum.Functions.Split(build,',') do
                    if build ~= 'all' and build ~= '*' then
                            for _,i in next, tools do
                                    if i.Name:sub(1,string.len(v)):lower() == v:lower() then
                                            table.insert(gottools,i)
                                    end
                            end
                    else
                            for _,i in next, tools do
                                    table.insert(gottools,i)
                            end
                    end
            end
            if gottools == {} then error'No tools found!' end
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, gottools do
                                    v:Clone().Parent = i.Backpack
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Gave '..Quantum.Functions.Unpack(gottools)..' to '..Quantum.Functions.Unpack(player)..'.')
    end)

    Quantum.Functions.AddCommand('Set walkspeed',{'walkspeed','ws'},1,{'walkspeed','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','change walkspeed')
            Quantum.Functions.Assert(args[2],'Speed','set',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).WalkSpeed = args[2]
                    end)
            end
            Quantum.Functions.Tell(sender,'Changed walkspeed of '..Quantum.Functions.Unpack(player)..' to '..args[2]..'.')
    end)

    Quantum.Functions.AddCommand('Place',{'place','ptele'},2,{'place','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','teleport to place')
            Quantum.Functions.Assert(args[2],'Place','teleport to',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local place
            for _,i in next, player do
                    pcall(function()
                            place = Quantum.Functions.Place(args[2],i)
                    end)
            end
            Quantum.Functions.Tell(sender,'Placed '..Quantum.Functions.Unpack(player)..' to '..place..'.')
    end)

    Quantum.Functions.AddCommand('Rejoin',{'rejoin','rj'},2,{'rj','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','rejoin')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            if Quantum.Settings.Place == 'oxcool' then
                                    Quantum.Functions.Place(109505698,i)
                            else
                                    Quantum.Functions.Place(game.PlaceId,i)
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Rejoined ',player)
    end)

    Quantum.Functions.AddCommand('ForceField',{'ff','forcefield'},1,{'ff','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','forcefield')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Instance.new("ForceField",i.Character)
                    end)
            end
            Quantum.Functions.Return(sender,'ForceFielded ',player)
    end)

    Quantum.Functions.AddCommand('Un ForceField',{'unff','unforcefield'},1,{'unff','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','unforcefield')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            while i.Character:FindFirstChild("ForceField") do
                                    i.Character:FindFirstChild("ForceField"):Destroy()
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Un ForceFielded ',player)
    end)

    Quantum.Functions.AddCommand('Private Message',{'pm','pmessage'},1,{'pm','player','string','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','message')
            Quantum.Functions.Assert(args[2],'Message','send')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local color = Quantum.Functions.GetColor(tags,true)
            for _,i in next, player do
                    Quantum.Functions.DisplayMessage(i,Quantum.Functions.Buildstring(args,1),'://PRIVATE MESSAGE FROM '..sender.Name:upper(),5,color)
            end
            Quantum.Functions.Return(sender,'Messaged ',player)
    end)

    Quantum.Functions.AddCommand('Private Message (frame)',{'msg'},1,{'msg','player','string','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','message')
            Quantum.Functions.Assert(args[2],'Message','send')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local color = Quantum.Functions.GetColor(tags,true)
            for _,i in next, player do
                    Quantum.Functions.DisplayCloseableFrame(i,Quantum.Functions.Buildstring(args,1),'://PRIVATE MESSAGE FROM '..sender.Name:upper(),color)
            end
            Quantum.Functions.Return(sender,'Messaged ',player)
    end)

    Quantum.Functions.AddCommand('Message',{'m','message'},1,{'m','string','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Message','display')
            local color = Quantum.Functions.GetColor(tags,true)
            Quantum.Functions.DisplayMessageAll(Quantum.Functions.Buildstring(args),'://MESSAGE FROM '..sender.Name:upper(),3,color)
    end)

    Quantum.Functions.AddCommand('System Message',{'sm','smessage'},1,{'sm','string','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'System message','display')
            local color = Quantum.Functions.GetColor(tags,true)
            Quantum.Functions.DisplayMessageAll(Quantum.Functions.Buildstring(args),'://QUANTUM SYSTEM MESSAGE',3,color,BrickColor.new'Really red')
    end)

    Quantum.Functions.AddCommand('Hint',{'h','hint'},1,{'h','string','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Hint','display')
            local color = Quantum.Functions.GetColor(tags,true)
            Quantum.Functions.TellAll(sender.Name..': '..Quantum.Functions.Buildstring(args),3,color)
    end)

    Quantum.Functions.AddCommand('Un fire',{'unfire'},1,{'unfire','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','unfire')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            while i.Character.Torso:FindFirstChild("Fire") do
                                    i.Character.Torso:FindFirstChild("Fire"):Destroy()
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Removed fire from ',player)
    end)

    Quantum.Functions.AddCommand('Fix lighting',{'fl','fixlighting'},1,{'fl'},function(none,sender)
            Quantum.Functions.FixLighting()
            Quantum.Functions.Tell(sender,'Fixed lighting.')
    end)

    Quantum.Functions.AddCommand('Un sparkles',{'unsparkles','unsparklez','unspark'},1,{'unsparkles','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','remove sparkles from')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            while i.Character.Torso:FindFirstChild("Sparkles") do
                                    i.Character.Torso:FindFirstChild("Sparkles"):Destroy()
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Removed sparkles from ',player)
    end)

    Quantum.Functions.AddCommand('Reset stats',{'resetstats','rs'},1,{'rs','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','reset stats')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i:FindFirstChild'leaderstats':GetChildren() do
                                    if v:IsA'IntValue' or v:IsA'StringValue' or v:IsA'BoolValue' or v:IsA'IntConstrainedValue' or v:IsA'DoubleConstrainedValue' or v:IsA'NumberValue' and tonumber(v.Value) then
                                            v.Value = 0
                                    end
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Reset stats of ',player)
    end)

    Quantum.Functions.AddCommand('Reload character',{'reload','rl'},1,{'reload','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','reload')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.Reload(i)
                    end)
            end
            Quantum.Functions.Return(sender,'Reloaded ',player)
    end)

    Quantum.Functions.AddCommand('Neutral',{'neutral'},1,{'neutral','player','|not'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','make neutral')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            if tags and tags[1] == 'n' or tags[1] == 'not' then
                    for _,i in next, player do
                            pcall(function()
                                    i.Neutral = false
                            end)
                    end
            else
                    for _,i in next, player do
                            ypcall(function()
                                    i.Neutral = true
                            end)
                    end
            end
            Quantum.Functions.Tell(sender,'Made '..Quantum.Functions.Unpack(player)..' neutral.')
    end)

    Quantum.Functions.AddCommand('Create team',{'cteam','createteam'},1,{'cteam','true/false(AutoAssignable)','name','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'AutoAssignable setting','set')
            Quantum.Functions.Assert(args[2],'Team name','set')
            local color = Quantum.Functions.GetColor(tags,true)
            local auto
            local build = Quantum.Functions.Buildstring(args,1)
            local team = create("Team"){Parent = game.Teams; Name = build; TeamColor = color or BrickColor.new(); AutoAssignable = toboolean(args[1])}
            Quantum.Functions.Tell(sender,'Created team '..build..'.')
    end)

    Quantum.Functions.AddCommand('Remove team',{'rteam','removeteam'},1,{'rteam','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Team','remove')
            local foundteam
            if args[1] == 'all' then
                    game.Teams:ClearAllChildren()
                    Quantum.Functions.Tell(sender,'Removed all teams.')
                    return
            else
                    for _,i in next, game.Teams:GetTeams() do
                            pcall(function()
                                    if i.Name:sub(1,string.len(args[1])):lower() == args[1]:lower() then
                                            if not foundteam then
                                                    foundteam = i
                                            else
                                                    error(args[2]..' is ambiguous!')
                                            end
                                    end
                            end)
                    end
            end
            foundteam:Destroy()
            Quantum.Functions.Tell(sender,'Removed team '..foundteam.Name..'.')
    end)

    Quantum.Functions.AddCommand('Change team',{'team'},1,{'team','player','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','change team')
            Quantum.Functions.Assert(args[2],'Team','change player to')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local foundteam
            for _,i in next, game.Teams:GetTeams() do
                    pcall(function()
                            if i.Name:sub(1,string.len(args[2])):lower() == args[2]:lower() then
                                    if not foundteam then
                                            foundteam = i
                                    else
                                            error(args[2]..' is ambiguous!')
                                    end
                            end
                    end)
            end
            for _,i in next, player do
                    pcall(function()
                            i.Neutral = false
                            i.TeamColor = foundteam.TeamColor
                    end)
            end
            Quantum.Functions.Tell(sender,'Change the team of '..Quantum.Functions.Unpack(player)..' to '..foundteam.Name..'.')
    end)

    Quantum.Functions.AddCommand('Change leaderboard stats',{'change'},1,{'change','player','string','string/number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','change stats')
            Quantum.Functions.Assert(args[2],'Score','change')
            Quantum.Functions.Assert(args[3],'Value','change stat to')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local found
            for _,i in next, player do
                    pcall(function()
                            found = nil
                            for _,v in next, i:FindFirstChild'leaderstats':GetChildren() do
                                    if v.Name:sub(1,string.len(args[2])):lower() == args[2]:lower() then
                                            if not found then
                                                    found = v
                                                    v.Value = args[3]
                                            else
                                                    error(args[2]..' is ambiguous!')
                                            end
                                    end
                            end
                    end)
            end
            if found then
                    Quantum.Functions.Tell(sender,'Changed the '..found.Name..' of '..Quantum.Functions.Unpack(player)..' to '..args[3]..'.')
            else
                    Quantum.Functions.Tell(sender,'Couldn\'t find status!')
            end
    end)

    Quantum.Functions.AddCommand('Unlock player',{'unlock'},1,{'unlock','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','unlock')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'Part' then
                                            v.Locked = false
                                    end
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Unlocked ',player)
    end)

    Quantum.Functions.AddCommand('Lock player',{'lock'},1,{'lock','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','lock')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            for _,v in next, i.Character:GetChildren() do
                                    if v:IsA'Part' then
                                            v.Locked = true
                                    end
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Locked ',player)
    end)

    Quantum.Functions.AddCommand('Kill',{'kill','break','breakjoints'},1,{'kill','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','kill')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            i.Character:BreakJoints()
                    end)
            end
            Quantum.Functions.Return(sender,'Killed ',player)
    end)

    Quantum.Functions.AddCommand('Sit',{'sit'},1,{'sit','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','sit')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).Sit = true
                    end)
            end
            Quantum.Functions.Return(sender,'Sat ',player)
    end)

    Quantum.Functions.AddCommand('Ungod',{'ungod'},1,{'ungod','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','ungod')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).MaxHealth = 100
                            Quantum.Functions.GetHumanoid(i.Character).Health = 100
                    end)
            end
            Quantum.Functions.Return(sender,'Ungodded ',player)
    end)

    Quantum.Functions.AddCommand('God',{'god'},1,{'god','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','god')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).MaxHealth = math.huge
                            Quantum.Functions.GetHumanoid(i.Character).Health = math.huge
                    end)
            end
            Quantum.Functions.Return(sender,'Godded ',player)
    end)

    Quantum.Functions.AddCommand('Teleport',{'tp','teleport'},1,{'teleport','player','(player)','|to','|move'},function(args,sender,tags)
            if tags and tags[1] == 't' or tags[1] == 'to' then
                    Quantum.Functions.Assert(args[1],'Player','to teleport')
                    local player = Quantum.Functions.GetPlayerFromString(args[1],sender)[1]
                    if tags[2] == 'm' or tags[2] == 'move' then
                            sender.Character:MoveTo(player.Character.Torso.Position)
                    else
                            sender.Character.Torso.CFrame = player.Character.Torso.CFrame
                    end
                    Quantum.Functions.Tell(sender,'Teleported you to '..player.Name..'.')
            else
                    Quantum.Functions.Assert(args[1],'Player','teleport')
                    Quantum.Functions.Assert(args[2],'Player','to teleport')
                    local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                    local playertarget = Quantum.Functions.GetPlayerFromString(args[2],sender)[1]
                    for _,i in next, player do
                            pcall(function()
                                    if tags and tags[1] == 'm' or tags[1] == 'move' then
                                            i.Character:MoveTo(playertarget.Character.Torso.Position)
                                    else
                                            i.Character.Torso.CFrame = playertarget.Character.Torso.CFrame
                                    end
                            end)
                    end
            end
    end)

    Quantum.Functions.AddCommand('Respawn',{'respawn','resp','repsawn'},1,{'respawn','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','respawn')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            i:LoadCharacter()
                    end)
            end
            Quantum.Functions.Return(sender,'Respawned ',player)
    end)

    Quantum.Functions.AddCommand('Show commands',{'cmds','commands','help'},1,{'cmds'},function(none,sender)
            Quantum.Functions.GetCommands(sender)
    end)

    Quantum.Functions.AddCommand('Explode',{'explode','expl','exp'},1,{'explode','player','(number)radius','(number)pressure'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','explode')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            create("Explosion"){Parent = i.Character, Position = i.Character.Torso.Position; BlastRadius = args[2] or 4;BlastPressure = args[3] or 500000}
                    end)
            end
            Quantum.Functions.Return(sender,'Exploded ',player)
    end)

    Quantum.Functions.AddCommand('Clean workspace',{'clean'},1,{'clean'},function(none,sender)
            for _,i in next, Quantum.Tables.Garbage do
                    pcall(function()
                            i:Destroy()
                    end)
            end
            Quantum.Tables.Garbage = {}
            for _,i in next, workspace:GetChildren() do
                    if i:IsA'Hat' then
                            i:Destroy()
                    end
            end
            Quantum.Functions.Tell(sender,'Cleaned workspace!')
    end)

    Quantum.Functions.AddCommand('Clone player',{'clone'},1,{'clone','player','|cframe'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','clone')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            local c
                            i.Character.Archivable = true
                            c = i.Character:Clone()
                            c.Parent = workspace
                            if not tags[1] or tags[1] and tags[1] ~= 'c' and tags[1] ~= 'cframe' then
                                    c:MoveTo(i.Character.Torso.Position)
                            end
                            table.insert(Quantum.Tables.Garbage,c)
                    end)
            end
            Quantum.Functions.Return(sender,'Cloned ',player)
    end)

    Quantum.Functions.AddCommand('Setrank',{'setrank','setr'},2,{'setrank','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','setrank')
            Quantum.Functions.Assert(args[2],'Rank','set player',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            if Quantum.Functions.CompareRank(sender,i) then
                                    if Quantum.Functions.GetRank(sender.Name) > tonumber(args[2]) or Quantum.Functions.GetRank(sender.Name) == 3 then
                                            Quantum.Players[i.Name].Rank = tonumber(args[2])
                                            Quantum.Functions.Tell(i,string.format('%s has changed your rank to %s.',sender.Name,args[2]))
                                    end
                            else
                                    player[_] = nil
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Set rank of '..Quantum.Functions.Unpack(player)..' to '..args[2]..'.')
    end)

    Quantum.Functions.AddCommand('Kick',{'kick','boot'},2,{'kick','player','|destroy'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','kick')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            if Quantum.Functions.CompareRank(sender,i) then
                                    if tags and tags[1] == "d" or tags[1] == "r" then
                                            Quantum.Functions.Kick(i,true)
                                    else
                                            Quantum.Functions.Kick(i)
                                    end
                            else
                                    player[_] = nil
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Kicked ',player)
    end)

    Quantum.Functions.AddCommand('Ban',{'ban'},2,{'ban','player','|offline','|destroy'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','ban')
            if tags and tags[1] == 'o' or tags[1] == 'offline' then
                    pcall(function()
                            if not Quantum.Functions.GetOfflinePlayer(args[1],true) then
                                    for _,i in next, Quantum.Functions.Split(args[1],',') do
                                            Quantum.Functions.AddPlayer(i,-1)
                                    end
                                    Quantum.Functions.Tell(sender,'Banned '..args[1]..'.')
                            else
                                    local player = Quantum.Functions.GetOfflinePlayer(args[1])
                                    for _,i in next, player do
                                            if Quantum.Functions.CompareRank(sender,i) then
                                                    Quantum.Players[i.Name].Rank = -1
                                            else
                                                    player[_] = nil
                                            end
                                    end
                                    Quantum.Functions.Return(sender,'Banned ',player)
                            end
                    end)
            else
                    pcall(function()
                            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                            for _,i in next, player do
                                    if Quantum.Functions.CompareRank(sender,i) then
                                            if tags and tags[1] == 'd' or tags[1] == 'destroy' then
                                                    Quantum.Functions.Kick(i,true)
                                            else
                                                    Quantum.Functions.Kick(i)
                                            end
                                            Quantum.Players[i.Name].Rank = -1
                                    else
                                            player[_] = nil
                                    end
                                    Quantum.Functions.Return(sender,'Banned ',player)
                            end
                    end)
            end
    end)

    Quantum.Functions.AddCommand('Crash ban',{'cban','cb','crashban'},2,{'cban','player','|offline'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','crashban')
            if tags and tags[1] == 'o' or tags[1] == 'offline' then
                    pcall(function()
                            if not Quantum.Functions.GetOfflinePlayer(args[1],true) then
                                    for _,i in next, Quantum.Functions.Split(args[1],',') do
                                            Quantum.Functions.AddPlayer(i,-2)
                                    end
                                    Quantum.Functions.Tell(sender,'Crash banned '..args[1]..'.')
                            else
                                    local player = Quantum.Functions.GetOfflinePlayer(args[1])
                                    for _,i in next, player do
                                            if Quantum.Functions.CompareRank(sender,i) then
                                                    Quantum.Functions.Crash(i)
                                                    Quantum.Players[i.Name].Rank = -2
                                            else
                                                    player[_] = nil
                                            end
                                    end
                                    Quantum.Functions.Return(sender,'Crash banned ',player)
                            end
                    end)
            else
                    pcall(function()
                            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                            for _,i in next, player do
                                    if Quantum.Functions.CompareRank(sender,i) then
                                            Quantum.Functions.Crash(i)
                                            Quantum.Players[i.Name].Rank = -2
                                    else
                                            player[_] = nil
                                    end
                            end
                            Quantum.Functions.Return(sender,'Crash banned ',player)
                    end)
            end
    end)

    Quantum.Functions.AddCommand('Search music',{'searchm','search','musicsearch','smusic'},1,{'searchm','string'},function(args,sender)
            Quantum.Functions.SearchMusic(args,sender)
    end)

    Quantum.Functions.AddCommand('Music',{'music','play'},1,{'music','(string/number)','|number(pitch)'},function(args,sender,tags)
            local build = Quantum.Functions.Buildstring(args)
            local found
            if not args[1] and Quantum.Settings.Music and tags and tonumber(tags[1]) then
                    local change = (tonumber(tags[1])-Quantum.Settings.Music.Pitch)/30
                    for i=1, 30 do
                            Quantum.Settings.Music.Pitch = Quantum.Settings.Music.Pitch+change
                            wait(0.07)
                    end
                    Quantum.Settings.Music.Pitch = tonumber(tags[1])
                    Quantum.Functions.Tell(sender,'Changed pitch to '..tags[1]..'.')
                    return
            end
            if args[1] == 'stop' then
                    if Quantum.Settings.Music then
                            pcall(function()
                                    Quantum.Settings.Music:Pause()
                            end)
                            Quantum.Functions.Tell(sender,'Stopped music!')
                    else
                            Quantum.Functions.Tell(sender,'No music is playing.')
                    end
            else
                    local soundid = nil
                    if tonumber(build) then
                            found = build
                    else
                            for i,v in next, Quantum.Tables.Music do
                                    if i:sub(1,string.len(build)):lower() == build:lower() then
                                            if not found then
                                                    found = v
                                            else
                                                    error(build..' is ambiguous!')
                                            end
                                    end
                            end
                    end
                    if not found then error'Couldn\'t find sound!' end
                    if Quantum.Settings.Music then
                            pcall(function()
                                    Quantum.Settings.Music:Pause()
                            end)
                    end
                    Quantum.Settings.Music = create("Sound"){Parent = workspace, Name = 'QuantumSound', SoundId = 'http://roblox.com/asset/?id='..tostring(found), Volume = 1, Pitch = tonumber(tags[1]) or 1}
                    Quantum.Settings.Music:Play()
                    Quantum.Functions.TellAll('Now Playing - '..game:GetService'MarketplaceService':GetProductInfo(found).Name)
            end
    end)

    Quantum.Functions.AddCommand('Mute',{'mute'},2,{'mute','player','|offline'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','mute')
            if tags and tags[1] == 'o' or tags[1] == 'offline' then
                    pcall(function()
                            if not Quantum.Functions.GetOfflinePlayer(args[1],true) then
                                    for _,i in next, Quantum.Functions.Split(args[1],',') do
                                            Quantum.Functions.AddPlayer(i,0,true)
                                    end
                                    Quantum.Functions.Tell(sender,'Muted '..args[1]..'.')
                            else
                                    local player = Quantum.Functions.GetOfflinePlayer(args[1])
                                    for _,i in next, player do
                                            if Quantum.Functions.CompareRank(sender,i) then
                                                    Quantum.Functions.Mute(i)
                                                    Quantum.Players[i.Name].Muted = true
                                            else
                                                    player[_] = nil
                                            end
                                    end
                                    Quantum.Functions.Return(sender,'Muted ',player)
                            end
                    end)
            else
                    pcall(function()
                            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                            for _,i in next, player do
                                    if Quantum.Functions.CompareRank(sender,i) then
                                            Quantum.Functions.Mute(i)
                                            Quantum.Players[i.Name].Muted = true
                                    else
                                            player[_] = nil
                                    end
                                    Quantum.Functions.Return(sender,'Muted ',player)
                            end
                    end)
            end
    end)

    Quantum.Functions.AddCommand('Unmute',{'unmute'},2,{'unmute','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','unmute')
            local player = Quantum.Functions.GetOfflinePlayer(args[1])
            for _,i in next, player do
                    pcall(function()
                            if i.Muted then
                                    i.Muted = false
                                    if game:GetService'Players':FindFirstChild(i.Name) then
                                            Quantum.Functions.Unmute(game:GetService'Players':FindFirstChild(i.Name))
                                    end
                            elseif game:GetService'Players':FindFirstChild(i.Name) then
                                    Quantum.Functions.Unmute(game:GetService'Players':FindFirstChild(i.Name))
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Unmuted ',player)
    end)

    Quantum.Functions.AddCommand('Music list',{'mlist','musiclist'},1,{'mlist'},function(none,sender)
            local got = {}
            for i,v in orderedNext, Quantum.Tables.Music do
                    table.insert(got,i..' ('..v..')')
            end
            Quantum.Functions.DisplayScrollFrame(sender,got,'Music List')
    end)

    Quantum.Functions.AddCommand('Get admins',{'admins'},1,{'admins'},function(none,sender)
            local players = {'3 = Ultra Admin','2 = Super Admin','1 = Admin','\n'}
            for i,v in orderedNext, Quantum.Players do
                    pcall(function()
                            if v.Rank > 0 and v.Muted == false then
                                    table.insert(players,i..': '..v.Rank)
                            elseif v.Rank > 0 and v.Muted == true then
                                    table.insert(players,i..': '..v.Rank..' (Muted)')
                            end
                    end)
            end
            Quantum.Functions.DisplayScrollFrame(sender,players,'Admins')
    end)

    Quantum.Functions.AddCommand('Get banned',{'banned'},1,{'banned'},function(none,sender)
            local players = {'-1 = Banned','-2 = Crash banned','\n'}
            for i,v in orderedNext, Quantum.Players do
                    pcall(function()
                            if v.Rank < 0 and v.Muted == false then
                                    table.insert(players,i..': '..v.Rank)
                            elseif v.Muted == true then
                                    table.insert(players,i..': '..v.Rank..' (Muted)')
                            end
                    end)
            end
            Quantum.Functions.DisplayScrollFrame(sender,players,'Banned')
    end)

    Quantum.Functions.AddCommand('Get ranked',{'ranked','getranked'},1,{'ranked','|all'},function(none,sender,tags)
            local players = {'3 = Ultra Admin','2 = Super Admin','1 = Admin','0 = Regular','-1 = Banned','-2 = Crash banned','\n'}
            if tags and tags[1] == 'a' or tags[1] == 'all' then
                    for i,v in orderedNext, Quantum.Players do
                            pcall(function()
                                    if v.Muted == false then
                                            table.insert(players,i..': '..v.Rank)
                                    elseif v.Muted == true then
                                            table.insert(players,i..': '..v.Rank..' (Muted)')
                                    end
                            end)
                    end
            else
                    for i,v in orderedNext, Quantum.Players do
                            pcall(function()
                                    if v.Rank ~= 0 and v.Muted == false then
                                            table.insert(players,i..': '..v.Rank)
                                    elseif v.Muted == true then
                                            table.insert(players,i..': '..v.Rank..' (Muted)')
                                    end
                            end)
                    end
            end
            Quantum.Functions.DisplayScrollFrame(sender,players,'Ranked')
    end)

    Quantum.Functions.AddCommand('Un crashban',{'uncban','uncb','uncrashban'},2,{'uncban','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','un crashban')
            local player = Quantum.Functions.GetOfflinePlayer(args[1])
            for _,i in next, player do
                    pcall(function()
                            if i.Rank == -2 then
                                    i.Rank = 0
                            else
                                    player[_] = nil
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Un crashbanned ',player)
    end)

    Quantum.Functions.AddCommand('Crash',{'crash'},2,{'crash','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','crash')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.Crash(i)
                    end)
            end
            Quantum.Functions.Return(sender,'Crashed ',player)
    end)

    Quantum.Functions.AddCommand('Destroy instances of type',{'rtype','removetype','destroy','dtype'},1,{'dtype','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Type of instance','destroy')
            for _,i in next, workspace:GetChildren() do
                    pcall(function()
                            if i:IsA(args[1]) then
                                    i:Destroy()
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Destroyed all instances of type '..args[1]..'.')
    end)

    Quantum.Functions.AddCommand('Unban',{'unban'},2,{'unban','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','unban')
            local player = Quantum.Functions.GetOfflinePlayer(args[1])
            for _,i in next, player do
                    pcall(function()
                            if i.Rank == -1 then
                                    i.Rank = 0
                            else
                                    player[_] = nil
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Unbanned ',player)
    end)

    Quantum.Functions.AddCommand('Damage',{'damage','dmg'},1,{'dmg','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','damage')
            Quantum.Functions.Assert(args[2],'Damage','deal',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).Health = Quantum.Functions.GetHumanoid(i.Character).Health - args[2]
                    end)
            end
            Quantum.Functions.Tell(sender,'Damaged '..Quantum.Functions.Unpack(player)..' by '..args[2]..'.')
    end)

    Quantum.Functions.AddCommand('Shutdown',{'sd','shutdown'},2,{'shutdown'},function(none,sender)
            Quantum.Functions.Tell(sender,'Shutting down...')
            wait(0.5)
            Quantum.Functions.Shutdown()
    end)

    Quantum.Functions.AddCommand('Disable_G',{'disableg','dg','disable_g'},1,{'disableg'},function(none,sender)
            setmetatable(_G,{__newindex = function() error("_G is disabled!") end})
            Quantum.Functions.Tell(sender,'Disabled _G')
    end)

    Quantum.Functions.AddCommand('Lock_G',{'lockg','lg','lock_g'},1,{'lockg'},function(none,sender)
            setmetatable(_G, {__metatable = 'Locked'})
            Quantum.Functions.Tell(sender,'Locked _G')
    end)

    Quantum.Functions.AddCommand('Enable_G',{'enablg','eg','enable_g'},1,{'enableg'},function(none,sender)
            setmetatable(_G,_G)
            Quantum.Functions.Tell(sender,'Enabled _G')
    end)

    Quantum.Functions.AddCommand('Clear_G',{'clearg','cg','clear_g'},1,{'clearg'},function(none,sender)
            for i in next, _G do
                    _G[i] = nil
            end
            Quantum.Functions.Tell(sender,'Cleared _G')
    end)

    Quantum.Functions.AddCommand('Get_G',{'getg','gg','get_g'},1,{'getg'},function(none,sender)
            for i,v in next, _G do
                    print(i,v)
            end
            Quantum.Functions.Tell(sender,'Got _G')
    end)

    Quantum.Functions.AddCommand('Set Health',{'health'},1,{'health','player','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','change health')
            Quantum.Functions.Assert(args[2],'Health','change to',true)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Functions.GetHumanoid(i.Character).MaxHealth = args[2] Quantum.Functions.GetHumanoid(i.Character).Health = args[2]
                    end)
            end
            Quantum.Functions.Tell(sender,'Changed health of '..Quantum.Functions.Unpack(player)..' to '..args[2]..'.')
    end)

    Quantum.Functions.AddCommand('Execute',{'exe'},3,{'exe','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'String','execute')
            local status,err = pcall(function() loadstring(Quantum.Functions.Buildstring(args))() end)
            if status then
                    Quantum.Functions.Tell(sender,'Successfully executed!')
            else
                    Quantum.Functions.Tell(sender,err)
            end
    end)

    Quantum.Functions.AddCommand('Stop all sounds',{'stopmusic','nosounds','nosound','soff','nos'},1,{'nosounds'},function(none,sender)
            for _,i in next, Quantum.Tables.Sounds do
                    pcall(function()
                            i.Volume = 0
                    end)
            end
            Quantum.Tables.Sounds = {}
            for _,i in next, Quantum.Functions.GetAllChildren(workspace) do
                    if i:IsA'Sound' then
                            pcall(function()
                                    i.Volume = 0
                            end)
                    end
            end
            if Quantum.Settings.Music then pcall(function() Quantum.Settings.Music:Pause() end) end
            Quantum.Functions.Tell(sender,'Stopped all sounds.')
    end)

    Quantum.Functions.AddCommand('Prefix',{'prefix','pre','setprefix'},1,{'prefix','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Prefix','set')
            local build = Quantum.Functions.Buildstring(args)
            Quantum.Players[sender.Name].GLOBAL_prefix = build
            Quantum.Functions.Tell(sender,string.format('Changed your prefix to %q.',build))
    end)

    Quantum.Functions.AddCommand('Clear',{'clear','clr'},1,{'clear'},function(args,sender)
            for _,i in next, workspace:GetChildren() do
                    pcall(function()
                            if not game.Players:GetPlayerFromCharacter(i) and not i:IsA'Terrain' then
                                    i:Destroy()
                            end
                    end)
            end
            for _,i in next, Quantum.Tables.Sounds do
                    pcall(function()
                            i:Pause()
                    end)
            end
            Quantum.Tables.Sounds = {}
            Quantum.Functions.FixLighting()
            Quantum.Functions.Base()
            workspace.Terrain:Clear()
            Quantum.Functions.Tell(sender,'Cleared.')
    end)

    Quantum.Functions.AddCommand('Change ambient',{'ambient','ambience','amb'},1,{'ambient','number','number','number'},function(args,sender)
            Quantum.Functions.Assert(args[1],'First number','set')
            Quantum.Functions.Assert(args[2],'Seconds number','set')
            Quantum.Functions.Assert(args[3],'Third number','set')
            game.Lighting.Ambient = Color3.new(args[1]/255,args[2]/255,args[3]/255)
            Quantum.Functions.Tell(sender,string.format('Changed ambient to %s %s %s',args[1],args[2],args[3]))
    end)

    Quantum.Functions.AddCommand('Create baseplate',{'base'},1,{'base'},function(none,sender)
            Quantum.Functions.Base()
            Quantum.Functions.Tell(sender,'Made baseplate.')
    end)

    Quantum.Functions.AddCommand('Change unremovable baseplate',{'permbase','ubase'},1,{'permbase','|off'},function(none,sender,tags)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    Quantum.Functions.Removable(game.Workspace:FindFirstChild'Baseplate')
                    Quantum.Functions.Tell(sender,'Turned off permanent baseplate.')
            else
                    local base = Quantum.Functions.Base()
                    Quantum.Functions.Unremovable(base)
                    Quantum.Functions.Tell(sender,'Turned on permanent baseplate.')
            end
    end)

    Quantum.Functions.AddCommand('Personal base',{'pbase','pb'},1,{'pbase','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','give personal base')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in pairs(player) do
                    pcall(function()
                            local rndmpos = CFrame.new(math.random(1000,2000),math.random(1000,2000),math.random(1000,2000))
                            local base = Quantum.Functions.Base(rndmpos)
                            base.Name = i.Name..'-PERSONAL_BASEPLATE'
                            i.Character:MoveTo(base.Position)
                            Quantum.Players[i.Name].Spawnlocation = i.Character.Torso.CFrame
                            Quantum.Functions.Unremovable(base)
                    end)
            end
            Quantum.Functions.Return(sender,'Gave personal base to ',player)
    end)

    Quantum.Functions.AddCommand('Remove personal base',{'unpbase','unpb'},1,{'unpbase','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','remove personal base')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            local base = workspace:FindFirstChild(i.Name..'-PERSONAL_BASEPLATE')
                            Quantum.Players[i.Name].Spawnlocation = nil
                            Quantum.Functions.Removable(base)
                            i:LoadCharacter()
                    end)
            end
            Quantum.Functions.Return(sender,'Removed personal base from ',player)
    end)

    Quantum.Functions.AddCommand('Set spawnpoint',{'setspawn','ss','setspawnpoint'},1,{'setspawn','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','setspawn')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            Quantum.Players[i.Name].Spawnlocation = i.Character.Torso.CFrame
                    end)
            end
            Quantum.Functions.Return(sender,'Set the spawn of ',player)
    end)

    Quantum.Functions.AddCommand('Magic',{'magic'},1,{'magic','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','make magical')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local colors = {'Lime green','Really red','Toothpaste','Hot pink','Royal purple','New Yeller'}
            for _,i in next, player do
                    pcall(function()
                            for n=1, 100 do
                                    for _,v in next, colors do
                                            create("Sparkles"){Parent = i.Character.Torso, SparkleColor = BrickColor.new(v).Color}
                                    end
                            end
                    end)
            end
            Quantum.Functions.Tell(sender,'Made '..Quantum.Functions.Unpack(player)..' magical.')
    end)

    Quantum.Functions.AddCommand('Give sparkles',{'sparkles','sparklez','spark'},1,{'sparkles','player','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','give sparkles')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local color = Quantum.Functions.GetColor(tags,true)
            for _,i in next, player do
                    pcall(function()
                            create("Sparkles"){Parent = i.Character.Torso, SparkleColor = color.Color or nil}
                    end)
            end
            Quantum.Functions.Return(sender,'Gave sparkles to ',player)
    end)

    Quantum.Functions.AddCommand('Reset spawnpoint',{'rspawn','resetspawn','resetspawnpoint'},1,{'rspawn','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','reset spawnpoint')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    Quantum.Players[i.Name].Spawnlocation = nil
            end
            Quantum.Functions.Return(sender,'Reset spawn of ',player)
    end)

    Quantum.Functions.AddCommand('Give fire',{'fire'},1,{'fire','player','number','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','give fire')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local color = Quantum.Functions.GetColor(tags,true)
            for _,i in next, player do
                    pcall(function()
                            create("Fire"){Parent = i.Character.Torso, Color = (color and color.Color or nil), Size = args[2] or 5}
                    end)
            end
            Quantum.Functions.Return(sender,'Gave fire to ',player)
    end)

    Quantum.Functions.AddCommand('Give pointlight',{'pointlight','light'},1,{'light','player','number(brightness)','number(range)','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','give pointlight')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local color = Quantum.Functions.GetColor(tags,true)
            for _,i in next, player do
                    pcall(function()
                            create("PointLight"){Parent = i.Character.Torso, Color = (color and color.Color or nil), Brightness = args[2] or 1; Range = args[3] or 8}
                    end)
            end
            Quantum.Functions.Return(sender,'Gave pointlight to ',player)
    end)

    Quantum.Functions.AddCommand('Unlight',{'unlight','rlight'},1,{'unlight','player'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Player','unlight')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    pcall(function()
                            while i.Character.Torso:FindFirstChild("PointLight") do
                                    i.Character.Torso:FindFirstChild("PointLight"):Destroy()
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Removed pointlight from ',player)
    end)

    Quantum.Functions.AddCommand('Give smoke',{'smoke'},1,{'smoke','player','number','|color'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','give smoke')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local color = Quantum.Functions.GetColor(tags,true)
            for _,i in next, player do
                    pcall(function()
                            create("Smoke"){Parent = i.Character.Torso, Color = (color and color.Color or nil), Size = args[2] or 1}
                    end)
            end
            Quantum.Functions.Return(sender,'Gave smoke to ',player)
    end)

    Quantum.Functions.AddCommand('Get colors',{'colors','getcolors','getcolor'},1,{'colors'},function(none,sender)
            Quantum.Functions.DisplayCloseableFrame(sender,table.concat(Quantum.Tables.Colors,' '),'Available Colors')
    end)

    Quantum.Functions.AddCommand('Show chat log',{'superlogs','slogs','chatlogs'},1,{'superlogs','(player)','|clear','|post'},function(args,sender,tags)
            if tags and tags[1] then
                    if tags[1] == 'p' or tags[1] == 'post' then
                            if args and args[1] then
                                    local plrlogs = {}
                                    local player
                                    if not Quantum.Functions.GetPlayerFromString(args[1],sender,true) then
                                            player = Quantum.Functions.GetOfflinePlayer(args[1])
                                    else
                                            player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                                    end
                                    for _,i in next, player do
                                            for _,v in next, Quantum.Tables.Superlogs do
                                                    if v:sub(2,string.len(i.Name)+1) == i.Name then
                                                            table.insert(plrlogs,v:sub(string.len(i.Name)+4))
                                                    end
                                            end
                                    end
                                    Quantum.Functions.DisplayCloseableFrame(sender,Quantum.Functions.Post(plrlogs),'')
                            else
                                    Quantum.Functions.DisplayCloseableFrame(sender,Quantum.Functions.Post(Quantum.Tables.Logs),'')
                            end
                    elseif tags[1] == 'c' or tags[1] == 'clear' then
                            Quantum.Tables.Superlogs = {}
                            Quantum.Functions.Tell(sender,'Cleared chat log')
                    end
            elseif args and args[1] then
                    local plrlogs = {}
                    local player
                    if not Quantum.Functions.GetPlayerFromString(args[1],sender,true) then
                            player = Quantum.Functions.GetOfflinePlayer(args[1])
                    else
                            player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                    end
                    for _,i in next, player do
                            for _,v in next, Quantum.Tables.Superlogs do
                                    if v:sub(2,string.len(i.Name)+1) == i.Name then
                                            table.insert(plrlogs,v:sub(string.len(i.Name)+4))
                                    end
                            end
                    end
                    Quantum.Functions.DisplayScrollFrame(sender,plrlogs,'Chat logs for '..player[1].Name)
            else
                    Quantum.Functions.DisplayScrollFrame(sender,Quantum.Tables.Superlogs,'Chat Logs')
            end
    end)

    Quantum.Functions.AddCommand('Name player',{'name'},1,{'name','player','string','|off'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','name')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local name = Quantum.Functions.Buildstring(args,1)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    for _,i in next, player do
                            pcall(function()
                                    for _,v in next, i.Character:GetChildren() do
                                            if v:IsA'Model' and v:FindFirstChild'FakeHumanoid' then
                                                    v:Destroy()
                                            end
                                    end
                                    i.Character.Head.Transparency = 0
                            end)
                    end
                    Quantum.Functions.Return(sender,'Unnamed ',player)
            else
                    for _,i in next, player do
                            ypcall(function()
                                    i.Character:WaitForChild'Body Colors'
                                    for _,v in next, i.Character:GetChildren() do
                                            if v:IsA'Model' and v:FindFirstChild'FakeHumanoid' then
                                                    v:Destroy()
                                            end
                                    end
                                    i.Character.Head.Transparency = 0
                                    local new = i.Character.Head:Clone()
                                    i.Character.Head.Transparency = 1
                                    local model = Instance.new('Model',i.Character)
                                    model.Name = name
                                    new.Parent = model
                                    local hum = Instance.new('Humanoid',model)
                                    hum.Name = 'FakeHumanoid'
                                    local w = Instance.new('Weld',i.Character)
                                    w.Part0 = new
                                    w.Part1 = i.Character.Head
                                    local realhum = Quantum.Functions.GetHumanoid(i.Character)
                                    realhum.Changed:connect(function(prop)
                                            hum.MaxHealth = realhum.MaxHealth
                                            hum.Health = realhum.Health
                                            if realhum.MaxHealth == math.huge then hum.MaxHealth = 0 end
                                    end)
                            end)
                    end
                    Quantum.Functions.Tell(sender,string.format('Named %s to %q.',Quantum.Functions.Unpack(player),name))
            end
    end)

    Quantum.Functions.AddCommand('Change character',{'char'},1,{'char','player','string/number','|off'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','char')
            local target = Quantum.Functions.GetPlayerFromString(args[1],sender)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    for _,i in next, target do
                            pcall(function()
                                    i.CharacterAppearance = 'http://www.roblox.com/Asset/CharacterFetch.ashx?userId='..i.userId
                                    Quantum.Functions.Reload(i)
                                    Quantum.Functions.Return(sender,'Reset character of ',target)
                            end)
                    end
                    return
            end
            local player = Quantum.Functions.GetPlayerAll(args[2],sender)
            for _,i in next, target do
                    pcall(function()
                            i.CharacterAppearance = 'http://www.roblox.com/Asset/CharacterFetch.ashx?userId='..player
                            Quantum.Functions.Reload(i)
                            Quantum.Functions.Tell(sender,string.format('Changed the character of %s to %s.',Quantum.Functions.Unpack(target),Quantum.Functions.UsernameFromID(player)))
                    end)
            end
    end)

    Quantum.Functions.AddCommand('Show command logs',{'logs','clogs','commandlogs'},1,{'logs','(player)','|clear','|post'},function(args,sender,tags)
            if tags and tags[1] then
                    if tags[1] == 'p' or tags[1] == 'post' then
                            if args and args[1] then
                                    local plrlogs = {}
                                    local player
                                    if not Quantum.Functions.GetPlayerFromString(args[1],sender,true) then
                                            player = Quantum.Functions.GetOfflinePlayer(args[1])
                                    else
                                            player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                                    end
                                    for _,i in next, player do
                                            for _,v in next, Quantum.Tables.Logs do
                                                    if v:sub(2,string.len(i.Name)+1) == i.Name then
                                                            table.insert(plrlogs,v:sub(string.len(i.Name)+4))
                                                    end
                                            end
                                    end
                                    Quantum.Functions.DisplayCloseableFrame(sender,Quantum.Functions.Post(plrlogs),'')
                            else
                                    Quantum.Functions.DisplayCloseableFrame(sender,Quantum.Functions.Post(Quantum.Tables.Logs),'')
                            end
                    elseif tags[1] == 'c' or tags[1] == 'clear' then
                            Quantum.Tables.Logs = {}
                            Quantum.Functions.Tell(sender,'Cleared command logs')
                    end
            elseif args and args[1] then
                    local plrlogs = {}
                    local player
                    if not Quantum.Functions.GetPlayerFromString(args[1],sender,true) then
                            player = Quantum.Functions.GetOfflinePlayer(args[1])
                    else
                            player = Quantum.Functions.GetPlayerFromString(args[1],sender)
                    end
                    for _,i in next, player do
                            for _,v in next, Quantum.Tables.Logs do
                                    if v:sub(2,string.len(i.Name)+1) == i.Name then
                                            table.insert(plrlogs,v:sub(string.len(i.Name)+4))
                                    end
                            end
                    end
                    Quantum.Functions.DisplayScrollFrame(sender,plrlogs,'Logs for '..player[1].Name)
            else
                    Quantum.Functions.DisplayScrollFrame(sender,Quantum.Tables.Logs,'Command Logs')
            end
    end)

    Quantum.Functions.AddCommand('Lock/unlock server',{'slock','lockdown','pri'},2,{'slock','|autoload','|kick','|off'},function(none,sender,tags)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    Quantum.Settings.PrivateServer.Regular = false
                    Quantum.Settings.PrivateServer.Auto = false
                    Quantum.Functions.Tell(sender,'Unlocked server!')
            elseif tags and tags[1] == 'a' or tags[1] == 'autoload' then
                    Quantum.Settings.PrivateServer.Regular = false
                    Quantum.Settings.PrivateServer.Auto = true
                    if tags and tags[2] == 'k' or tags[2] == 'kick' then
                            for _,i in next, game.Players:GetPlayers() do
                                    if not Quantum.Functions.IsAdmin(i.Name) then
                                            Quantum.Functions.Kick(i)
                                    end
                            end
                    end
            else
                    Quantum.Settings.PrivateServer.Auto = false
                    Quantum.Settings.Regular = true
                    if tags and tags[2] == 'k' or tags[2] == 'kick' then
                            for _,i in next, game.Players:GetPlayers() do
                                    if not Quantum.Functions.IsAdmin(i.Name) then
                                            Quantum.Functions.Kick(i)
                                    end
                            end
                    end
            end
    end)

    Quantum.Functions.AddCommand('Update script',{'update','updt'},3,{'update'},function(none,sender)
            Quantum.Functions.MakeScript("loadstring(game:GetService'HttpService':GetAsync'http://pastebin.com/raw.php?i=Hj6Mibe0')()",game:GetService'ServerScriptService')
            Quantum.Functions.Tell(sender,'Updating script...')
            Quantum.Functions.StopScript()
    end)

    Quantum.Functions.AddCommand('Stop script',{'stop','stopscript','removescript'},3,{'stop'},function(none,sender)
            Quantum.Functions.Tell(sender,'Stopping script...')
            Quantum.Functions.StopScript()
    end)

    Quantum.Functions.AddCommand('Make script',{'s','c','script'},2,{'s','string'},function(args,sender)
            Quantum.Functions.Assert(args[1],'Script','execute')
            local build = Quantum.Functions.Buildstring(args)
            local status,err = loadstring(build)
            if status then
                    Quantum.Functions.MakeScript(Quantum.Functions.Buildstring(args),workspace)
                    Quantum.Functions.Tell(sender,'Successfully made script!')
            else
                    Quantum.Functions.DisplayCloseableFrame(sender,err,'Script Error')
            end
    end)

    Quantum.Functions.AddCommand('Make local script',{'ls','l','localscript'},2,{'ls','string','|player'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Local script','execute')
            if tags and tags[1] == "p" or tags[1] == "player" then
                    for _,i in next, Quantum.Functions.GetPlayerFromString(args[1],sender) do
                            Quantum.Functions.MakeLocalScript(Quantum.Functions.Buildstring(args,1),i)
                    end
            else
                    Quantum.Functions.MakeLocalScript(Quantum.Functions.Buildstring(args),sender)
            end
    end)

    Quantum.Functions.AddCommand('Anti local',{'al','antilocal','antil'},1,{'antilocal','player','|off'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','change antilocal status')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    if tags and tags[1] == 'o' or tags[1] == 'off' then
                            Quantum.Players[i.Name].Antilocal = false
                            Quantum.Functions.Return(sender,'Turned antilocal off for ',player)
                    else
                            Quantum.Players[i.Name].Antilocal = true
                            Quantum.Functions.Return(sender,'Turned antilocal on for ',player)
                    end
            end
    end)

    Quantum.Functions.AddCommand('Anti kill',{'ak','antikill','antik'},1,{'antikill','player','|off'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','change antikill status')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    for _,i in next, player do
                            Quantum.Players[i.Name].Antikill.Enabled = false
                            Quantum.Players[i.Name].Spawnlocation = nil
                            if Quantum.Players[i.Name].Antikill.Humanoid then
                                    Quantum.Functions.GetHumanoid(i.Character).Name = 'Humanoid'
                            end
                            Quantum.Players[i.Name].Antikill.Humanoid = false
                    end
                    Quantum.Functions.Return(sender,'Turned antikill off for ',player)
            else
                    for _,i in next, player do
                            if not Quantum.Players[i.Name].Antikill.Enabled then
                                    Quantum.Players[i.Name].Antikill.Enabled = true
                                    Quantum.Players[i.Name].Ready = true
                                    Quantum.Functions.GetAntikill(i)
                                    if tags and tags[1] == 'h' or tags[1] == 'humanoid' then
                                            Quantum.Players[i.Name].Antikill.Humanoid = true
                                            Quantum.Functions.GetHumanoid(i.Character).Name = 'RHumanoid'
                                    end
                                    Quantum.Functions.GetHumanoid(i.Character).Died:connect(function()
                                            pcall(function()
                                                    if Quantum.Players[i.Name].Antikill.Enabled then
                                                            i:LoadCharacter()
                                                    end
                                            end)
                                    end)
                                    --[[i.Character.DescendantRemoving:connect(function(d)
                                            pcall(function()
                                                    if d:IsA'Humanoid' and Quantum.Players[i.Name].Antikill.Enabled then
                                                            i:LoadCharacter()
                                                    end
                                            end)
                                    end)]]
                            end
                    end
                    Quantum.Functions.Return(sender,'Turned antikill on for ',player)
            end
    end)

    Quantum.Functions.AddCommand('Anti ban',{'ab','antiban','antib'},1,{'antiban','player','|off'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','change antiban status')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            for _,i in next, player do
                    if tags and tags[1] == 'o' or tags[1] == 'off' then
                            Quantum.Players[i.Name].Antiban = false
                            Quantum.Functions.Return(sender,'Turned antiban off for ',player)
                    else
                            Quantum.Players[i.Name].Antiban = true
                            Quantum.Functions.Return(sender,'Turned antiban on for ',player)
                    end
            end
    end)

    Quantum.Functions.AddCommand('Fake player',{'fp','fplayer','fakeplayer'},1,{'fplayer','player','string/number','|off'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','change antiban status')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    for _,i in next, player do
                            pcall(function()
                                    Quantum.Players[i.Name].RespawnExe = {}
                                    i.CharacterAppearance = 'http://www.roblox.com/Asset/CharacterFetch.ashx?userId='..i.userId
                                    Quantum.Functions.Reload(i)
                            end)
                    end
                    Quantum.Functions.Return(sender,'Turned off fake player for ',player)
            else
                    local id = Quantum.Functions.GetPlayerAll(Quantum.Functions.Buildstring(args,1))
                    local name = Quantum.Functions.UsernameFromID(id)
                    for _,i in next, player do
                            pcall(function()
                                    table.insert(Quantum.Players[i.Name].RespawnExe,string.format('%sname%s|plr|%s%s',Quantum.Players[sender.Name].GLOBAL_prefix,Quantum.Settings.Bet,Quantum.Settings.Bet,name))
                                    i.CharacterAppearance = 'http://www.roblox.com/Asset/CharacterFetch.ashx?userId='..id
                                    Quantum.Functions.Reload(i)
                            end)
                    end
                    Quantum.Functions.Tell(sender,string.format('Faked %s as %s.',Quantum.Functions.Unpack(player),name))
            end
    end)

    Quantum.Functions.AddCommand('Bubble chat all',{'bcall','bubbleall','bubblechatall'},1,{'bubblechatall','|off','|color(rgb)'},function(none,sender,tags)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    Quantum.Settings.BubblechatAll = false
                    Quantum.Functions.Tell(sender,'Turned off bubblechatall.')
            elseif tags then
                    Quantum.Settings.BubblechatAll = true
                    if tags[1] == 'r' then
                            Quantum.Settings.BubblechatColor = 'Red'
                    elseif tags[1] == 'g' then
                            Quantum.Settings.BubblechatColor = 'Green'
                    elseif tags[1] == 'b' then
                            Quantum.Settings.BubblechatColor = 'Blue'
                    end
                    Quantum.Functions.Tell(sender,'Turned on bubblechatall.')
            end
    end)

    Quantum.Functions.AddCommand('Bubble chat',{'bc','bubble','bubblechat'},1,{'bubblechat','player','|off','|color(rgb)'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','change bubblechat status')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            if tags and tags[1] == 'o' or tags[1] == 'off' then
                    for _,i in next, player do
                            pcall(function()
                                    Quantum.Players[i.Name].Bubblechat = false
                            end)
                    end
                    Quantum.Functions.Return(sender,'Turned bubblechat off for ',player)
            elseif tags then
                    for _,i in next, player do
                            pcall(function()
                                    Quantum.Players[i.Name].Bubblechat = true
                                    if tags[1] == 'r' then
                                            Quantum.Players[i.Name].BubblechatColor = 'Red'
                                    elseif tags[1] == 'g' then
                                            Quantum.Players[i.Name].BubblechatColor = 'Green'
                                    elseif tags[1] == 'b' then
                                            Quantum.Players[i.Name].BubblechatColor = 'Blue'
                                    end
                            end)
                    end
                    Quantum.Functions.Return(sender,'Turned bubblechat on for ',player)
            end
    end)

    Quantum.Functions.AddCommand('Sudo (execute command as another player)',{'sudo'},2,{'sudo','player','command'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Player','execute command on')
            Quantum.Functions.Assert(args[2],'Command','execute')
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            local newargs = {}
            for i,v in next, args do
                    if i > 2 then
                            table.insert(newargs,v)
                    end
            end
            for _,i in next, player do
                    pcall(function()
                            if Quantum.Functions.CompareRank(sender,i) then
                                    Quantum.Functions.RawExeCmd(true,args[2],newargs,i,tags,Quantum.Functions.GetRank(sender.Name))
                            else
                                    player[_] = nil
                            end
                    end)
            end
            Quantum.Functions.Return(sender,'Sudo executed as ',player)
    end)

    Quantum.Functions.AddCommand('Loop command',{'loop'},1,{'loop','times(* for until stopped)','command'},function(args,sender,tags)
            Quantum.Functions.Assert(args[1],'Times','loop')
            Quantum.Functions.Assert(args[2],'Command','loop')
            local num = 0
            if args[1] ~= '*' then
                    if not tonumber(args[1]) then
                            error'Times to loop is not a number!'
                    end
            end
            local loopargs = {}
            for i,v in next, args do
                    if i > 2 then
                            table.insert(loopargs,v)
                    end
            end
            coroutine.resume(coroutine.create(function()
                    while wait(Quantum.Settings.Looptime) do
                            if not Quantum.Settings.Stoploops then
                                    if args[1] == '*' then
                                            pcall(function() Quantum.Functions.RawExeCmd(true,args[2],loopargs,sender,tags) end)
                                    else
                                            pcall(function() Quantum.Functions.RawExeCmd(true,args[2],loopargs,sender,tags) end)
                                            num = num+1
                                            if num >= tonumber(args[1]) then
                                                    break
                                            end
                                    end
                            else
                                    break
                            end
                    end
            end))
    end)

    Quantum.Functions.AddCommand('Stop loops',{'stoploops','sloops'},1,{'stoploops'},function(none,sender)
            Quantum.Functions.Tell(sender,'Stopping loops...')
            Quantum.Settings.Stoploops = true
            wait(Quantum.Settings.Looptime+0.1)
            Quantum.Settings.Stoploops = false
            Quantum.Functions.Tell(sender,'Stopped loops!')
    end)

    Quantum.Functions.AddCommand('Execute on respawn',{'rexe','respawnexe','exer'},3,{'rexe','player','command ("|plr|" = player)','|clear'},function(args,sender,tags)
            local player = Quantum.Functions.GetPlayerFromString(args[1],sender)
            if tags and tags[1] == 'c' or tags[1] == 'clear' then
                    for _,i in next, player do
                            Quantum.Players[i.Name].RespawnExe = {}
                    end
                    Quantum.Functions.Return(sender,'Cleared respawn commands of ',player)
            else
                    for _,i in next, player do
                            local newtags = {}
                            for _,v in next, tags do
                                    table.insert(newtags,Quantum.Settings.Tag..v)
                            end
                            table.insert(Quantum.Players[i.Name].RespawnExe,Quantum.Settings.Prefix..Quantum.Functions.Buildstring(args,1)..Quantum.Settings.Bet..Quantum.Functions.Buildstring(newtags))
                    end
                    Quantum.Functions.Return(sender,'Changed auto respawn commands of ',player)
            end
    end)

    Quantum.Functions.AddCommand('Execute on respawn all',{'rexeall','respawnexeall','exerall','autoexecuterespawn'},3,{'rexeall','command','|clear'},function(args,sender,tags)
            if tags and tags[1] == 'c' or tags[1] == 'clear' then
                    Quantum.Tables.RespawnExe = {}
                    Quantum.Functions.Tell(sender,'Cleared auto respawn commands for all players.')
            else
                    local newtags = {}
                    for _,v in next, tags do
                            table.insert(newtags,Quantum.Settings.Tag..v)
                    end
                    table.insert(Quantum.Tables.RespawnExe,Quantum.Settings.Prefix..Quantum.Functions.Buildstring(args)..Quantum.Settings.Bet..Quantum.Functions.Buildstring(newtags))
                    Quantum.Functions.Tell(sender,'Changed auto respawn commands for all players.')
            end
    end)

    Quantum.Connections.PlayerAdded = game.Players.ChildAdded:connect(function(plr)
            ypcall(function()
                    Quantum.Functions.PlayerAdded(plr)
            end)
    end)

    Quantum.Connections.DescendantRemoving = game.DescendantRemoving:connect(function(descendant)
            if Quantum.Tables.Unremovable[descendant] then
                    local clone = descendant:Clone()
                    clone.Parent = descendant.Parent
                    Quantum.Functions.Unremovable(clone)
            end
            if Quantum.Tables.Remake[descendant] and Quantum.Tables.Remake[descendant].Enabled then
                    wait()
                    Quantum.Tables.Remake[descendant].Func()
            end
    end)

    Quantum.Connections.DescendantAdded = game.DescendantAdded:connect(function(d)
            pcall(function()
                    if d:IsA'Sound' then
                            table.insert(Quantum.Tables.Sounds,d)
                    end
            end)
    end)

    Quantum.Connections.SourceScanner = game.DescendantAdded:connect(function(d)
            ypcall(function()
                    if d:IsA'LocalScript' and not Quantum.Settings.LocalScriptSource then
                            Quantum.Settings.LocalScriptSource = d
                            Quantum.Functions.TellAdmins'Found LocalScript Source'
                            for _,i in next, game.Players:GetPlayers() do
                                    if Quantum.Functions.IsAdmin(i.Name) then
                                            Quantum.Functions.Cmdbar(i)
                                            Quantum.Functions.Nilsupport(i)
                                    end
                            end
                    elseif d:IsA'Script' and not Quantum.Settings.ScriptSource then
                            Quantum.Settings.ScriptSource = d
                            Quantum.Functions.TellAdmins'Found Script Source'
                    end
                    if Quantum.Settings.LocalScriptSource and Quantum.Settings.ScriptSource then
                            Quantum.Connections.SourceScanner:disconnect()
                    end
            end)
    end)

    Quantum.Connections.PlayerRemoving = game.Players.PlayerRemoving:connect(function(plr)
            ypcall(function()
                    coroutine.resume(coroutine.create(function()
                            if Quantum.Players[plr.Name] and Quantum.Players[plr.Name].Antiban == true then
                                    local start = tick()
                                    local m = Instance.new('Message',workspace)
                                    local h = Instance.new('Hint',workspace)
                                    game:GetService'RunService'.Heartbeat:connect(function()
                                            ypcall(function()
                                                    if m then
                                                            m.Text = string.format('[QUANTUM ANTIBAN] '..plr.Name..' was kicked or banned! Shutdown in %.2d seconds!',Quantum.Settings.Antitimer - (tick() - start))
                                                    else
                                                            m = Instance.new('Message',workspace)
                                                    end
                                                    if h then
                                                            h.Text = string.format('[QUANTUM ANTIBAN] '..plr.Name..' was kicked or banned! Shutdown in %.2d seconds!',Quantum.Settings.Antitimer - (tick() - start))
                                                    else
                                                            h = Instance.new('Hint',workspace)
                                                    end
                                            end)
                                    end)
                            end
                    end))
                    local t = {}
                    for i,v in next, Quantum.Players[plr.Name] do
                            if i:sub(1,7) == 'GLOBAL_' then
                                    t[i] = v
                            end
                    end
                    Quantum.Functions.UpdateStorage(t,plr.Name)
            end)
    end)

    Quantum.Functions.PlayerAdded = function(plr)
            ypcall(function()
                    if plr:IsA("Player") then
                            plr:WaitForDataReady()
                            if plr.AccountAge < Quantum.Settings.RestrictAge then
                                    Quantum.Functions.Kick(plr)
                                    Quantum.Functions.TellAdmins(plr.Name..' tried to join, but their age is too low.')
                            end
                            for _,i in next, Quantum.Tables.GroupRanked do
                                    for k,v in next, i do
                                            if plr:IsInGroup(k) and plr:GetRankInGroup(k) >= v.GroupRank then
                                                    if Quantum.Players[plr.Name] ~= nil and Quantum.Players[plr.Name].Rank < v.AdminRank then
                                                            Quantum.Players[plr.Name].Rank = v.AdminRank
                                                    elseif Quantum.Players[plr.Name] == nil then
                                                            Quantum.Functions.AddPlayer(plr.Name,v.AdminRank)
                                                    end
                                            end
                                    end
                            end
                            if Quantum.Functions.GetRank(plr.Name) then
                                    if Quantum.Functions.GetStorage(plr.Name) then
                                            for i,v in next, Quantum.Functions.GetStorage(plr.Name) do
                                                    Quantum.Players[plr.Name][i] = v
                                            end
                                    end
                            end
                            if not Quantum.Functions.GetRank(plr.Name) then
                                    Quantum.Functions.AddPlayer(plr.Name)
                            elseif Quantum.Functions.GetRank(plr.Name) == -2 then
                                    Quantum.Functions.Crash(plr)
                                    Quantum.Functions.TellAdmins(plr.Name..' tried to join and is being crashed.')
                            elseif Quantum.Functions.GetRank(plr.Name) == -1 then
                                    Quantum.Functions.Kick(plr)
                                    Quantum.Functions.TellAdmins(plr.Name..' tried to join but is banned.')
                            elseif Quantum.Players[plr.Name].Muted == true then
                                    Quantum.Functions.Mute(plr)
                                    Quantum.Functions.TellAdmins(plr.Name..' joined and is muted.')
                            elseif Quantum.Functions.IsAdmin(plr.Name) then
                                    Quantum.Functions.Tell(plr,'You\'re an admin! Your rank is '..Quantum.Functions.GetRank(plr.Name)..'. Your prefix is "'..Quantum.Players[plr.Name].GLOBAL_prefix..'", the bet is "'..Quantum.Settings.Bet..'" and the tag seperator is "'..Quantum.Settings.Tag..'".')
                                    if Quantum.Settings.AutoAntiban then
                                            Quantum.Players[plr.Name].Antiban = true
                                    end
                                    if Quantum.Settings.AutoAntilocal then
                                            Quantum.Players[plr.Name].Antilocal = true
                                            plr.Character.DescendantAdded:connect(function(descendant)
                                                    ypcall(function()
                                                            if descendant:IsA'LocalScript' and Quantum.Players[plr.Name].Antilocal then
                                                                    if Quantum.Settings.Place == "oxcool" then
                                                                            local info = descendant:FindFirstChild'Info'.Value
                                                                            if not Quantum.Functions.IsAdmin(Quantum.Functions.GetInfo(info)[1]) then
                                                                                    descendant.Disabled = true
                                                                                    wait()
                                                                                    descendant:Destroy()
                                                                                    print('Disabled script '..Quantum.Functions.GetInfo(info)[2]..' inserted by '..Quantum.Functions.GetInfo(info)[1]..' into Character.')
                                                                            end
                                                                    elseif Quantum.Settings.Place == "anti" then
                                                                            local info = descendant:FindFirstChild'Owner'.Value.Name
                                                                            if not Quantum.Functions.IsAdmin(info) then
                                                                                    descendant.Disabled = true
                                                                                    wait()
                                                                                    descendant:Destroy()
                                                                                    print('Disabled script '..descendant.Name..' inserted by '..info..' into Character.')
                                                                            end
                                                                    else
                                                                            descendant.Disabled = true
                                                                            wait()
                                                                            descendant:Destroy()
                                                                            print('Disabled script '..descendant.Name..' inserted into Character.')
                                                                    end
                                                            end
                                                    end)
                                            end)
                                    end
                                    Quantum.Functions.Cmdbar(plr)
                                    if Quantum.Settings.LocalScriptSource then
                                            Quantum.Functions.Nilsupport(plr)
                                    end
                            end
                            if Quantum.Settings.PrivateServer.Regular then
                                    if not Quantum.Functions.IsAdmin(plr.Name) then
                                            Quantum.Functions.Kick(plr)
                                    end
                            end
                            if Quantum.Settings.PrivateServer.Auto then
                                    if Quantum.Functions.IsAdmin(plr.Name) then
                                            plr:LoadCharacter()
                                    end
                            end
                            plr.Chatted:connect(function(msg)
                                    ypcall(function()
                                            Quantum.Functions.Chatted(plr,msg)
                                            if msg:sub(1,3) ~= '/e ' and msg:sub(1,7) ~= '/emote ' then
                                                    if Quantum.Players[plr.Name].Bubblechat or Quantum.Settings.BubblechatAll then
                                                            if not Quantum.Players[plr.Name].Bubblechat then
                                                                    game:GetService'Chat':Chat(plr.Character.Head,msg,Enum.ChatColor[Quantum.Settings.BubblechatColor])
                                                            else
                                                                    game:GetService'Chat':Chat(plr.Character.Head,msg,Enum.ChatColor[Quantum.Players[plr.Name].BubblechatColor])
                                                            end
                                                    end
                                            end
                                    end)
                            end)
                            plr.CharacterAdded:connect(function(char)
                                    ypcall(function()
                                            Quantum.Functions.CharacterAdded(char)
                                    end)
                            end)
                            plr.DescendantAdded:connect(function(descendant)
                                    ypcall(function()
                                            Quantum.Functions.DescendantAdded(descendant,plr)
                                    end)
                            end)
                            if Quantum.Players[plr.Name].Antikill.Enabled then
                                    ypcall(function()
                                            plr.Character.Humanoid.Died:connect(function()
                                                    ypcall(function()
                                                            if Quantum.Players[plr.Name].Antikill.Enabled then
                                                                    plr:LoadCharacter()
                                                            end
                                                    end)
                                            end)
                                            plr.Character.DescendantRemoving:connect(function(d)
                                                    ypcall(function()
                                                            if d:IsA'Humanoid' and Quantum.Players[plr.Name].Antikill.Enabled then
                                                                    plr:LoadCharacter()
                                                            end
                                                    end)
                                            end)
                                            if Quantum.Players[plr.Name].Antikill.Humanoid then
                                                    Quantum.Functions.GetHumanoid(plr.Character).Name = 'RHumanoid'
                                            end
                                            pcall(function() Quantum.Players[plr.Name].Routine = nil end)
                                            Quantum.Functions.GetAntikill(plr)
                                    end)
                            end
                    end
            end)
    end

    Quantum.Functions.DescendantAdded = function(descendant,plr)
            pcall(function()
                    if descendant:IsA'LocalScript' and Quantum.Players[plr.Name].Antilocal then
                            if Quantum.Settings.Place == "oxcool" then
                                    local info = descendant:FindFirstChild'Info'.Value
                                    if not Quantum.Functions.IsAdmin(Quantum.Functions.GetInfo(info)[1]) then
                                            descendant.Disabled = true
                                            wait()
                                            descendant:Destroy()
                                            print('Disabled script '..Quantum.Functions.GetInfo(info)[2]..' inserted by '..Quantum.Functions.GetInfo(info)[1]..' into '..descendant.Parent.Name..'.')
                                    end
                            elseif Quantum.Settings.Place == "anti" then
                                    local info = descendant:FindFirstChild'Owner'.Value.Name
                                    if not Quantum.Functions.IsAdmin(info) then
                                            descendant.Disabled = true
                                            wait()
                                            descendant:Destroy()
                                            print('Disabled script '..descendant.Name..' inserted by '..info..' into '..descendant.Parent.Name..'.')
                                    end
                            else
                                    descendant.Disabled = true
                                    wait()
                                    descendant:Destroy()
                                    print('Disabled script '..descendant.Name..' inserted into '..descendant.Parent.Name..'.')
                            end
                    end
            end)
    end

    Quantum.Functions.CharacterAdded = function(char)
            ypcall(function()
                    local plr = game.Players:GetPlayerFromCharacter(char)
                    Quantum.Players[plr.Name].Ready = false
                    if Quantum.Players[plr.Name].Spawnlocation then
                            spawn(function()
                                    ypcall(function()
                                            plr.Character:WaitForChild'Body Colors'
                                            plr.Character.Torso.CFrame = Quantum.Players[plr.Name].Spawnlocation
                                            Quantum.Players[plr.Name].Ready = true
                                    end)
                            end)
                    end
                    if Quantum.Functions.IsAdmin(plr.Name) then
                            spawn(function()
                                    wait()
                                    if not Quantum.Functions.GetPlayerGui(plr):FindFirstChild'QuantumCmdbar' then
                                            Quantum.Functions.Cmdbar(plr)
                                    end
                            end)
                    end
                    char.DescendantAdded:connect(function(descendant)
                            ypcall(function()
                                    if descendant:IsA'LocalScript' and Quantum.Players[plr.Name].Antilocal then
                                            if Quantum.Settings.Place == "oxcool" then
                                                    local info = descendant:FindFirstChild'Info'.Value
                                                    if not Quantum.Functions.IsAdmin(Quantum.Functions.GetInfo(info)[1]) then
                                                            descendant.Disabled = true
                                                            wait()
                                                            descendant:Destroy()
                                                            print('Disabled script '..Quantum.Functions.GetInfo(info)[2]..' inserted by '..Quantum.Functions.GetInfo(info)[1]..' into Character.')
                                                    end
                                            elseif Quantum.Settings.Place == "anti" then
                                                    local info = descendant:FindFirstChild'Owner'.Value.Name
                                                    if not Quantum.Functions.IsAdmin(info) then
                                                            descendant.Disabled = true
                                                            wait()
                                                            descendant:Destroy()
                                                            print('Disabled script '..descendant.Name..' inserted by '..info..' into Character.')
                                                    end
                                            else
                                                    descendant.Disabled = true
                                                    wait()
                                                    descendant:Destroy()
                                                    print('Disabled script '..descendant.Name..' inserted into Character.')
                                            end
                                    end
                            end)
                    end)
                    --[[if Quantum.Players[plr.Name].Antikill.Enabled then
                            char.DescendantRemoving:connect(function(d)
                                    ypcall(function()
                                            if d:IsA'Humanoid' and Quantum.Players[plr.Name].Antikill.Enabled then
                                                    plr:LoadCharacter()
                                            end
                                    end)
                            end)
                    end]]
                    if Quantum.Players[plr.Name].Antikill.Enabled then
                            char.Humanoid.Died:connect(function()
                                    ypcall(function()
                                            if Quantum.Players[plr.Name].Antikill.Enabled then
                                                    plr:LoadCharacter()
                                            end
                                    end)
                            end)
                            wait(0.1)
                            if Quantum.Players[plr.Name].Antikill.Humanoid then
                                    char.Humanoid.Name = 'RHumanoid'
                            end
                    end
                    wait()
                    if #Quantum.Players[plr.Name].RespawnExe > 0 then
                            for _,i in next, Quantum.Players[plr.Name].RespawnExe do
                                    Quantum.Functions.ExeCmd(i:gsub('|plr|',plr.Name),root)
                            end
                    end
                    if #Quantum.Tables.RespawnExe > 0 then
                            for _,i in next, Quantum.Tables.RespawnExe do
                                    Quantum.Functions.ExeCmd(i:gsub('|plr|',plr.Name),root)
                            end
                    end
            end)
    end

    Quantum.Functions.Chatted = function(plr,msg)
            pcall(function()
                    for _,i in next, Quantum.Tables.Blacklist do
                            if msg:lower():find(i:lower()) then
                                    Quantum.Functions.Kick(plr)
                                    Quantum.Functions.TellAdmins(plr..' used blacklisted phrase and has been kicked.')
                            end
                    end
                    table.insert(Quantum.Tables.Superlogs,'['..plr.Name..'] '..msg)
                    if msg:sub(1,3) == '/e ' or msg:sub(1,7) == '/emote ' then
                            table.insert(Quantum.Tables.Logs,'['..plr.Name..'] '..msg)
                    end
                    if msg:sub(1,3) == '/e ' then
                            msg = msg:sub(4)
                    elseif msg:sub(1,7) == '/emote ' then
                            msg = msg:sub(8)
                    end
                    if msg:sub(1,string.len(Quantum.Players[plr.Name].GLOBAL_prefix)) == Quantum.Players[plr.Name].GLOBAL_prefix then
                            Quantum.Functions.ExeCmd(msg,plr)
                            table.insert(Quantum.Tables.Logs,'['..plr.Name..'] '..msg)
                    end
            end)
    end

    Quantum.Functions.PacketReceive = function(...)
            local signal = {...}
            pcall(function()
                    Quantum.Functions.Chatted(signal[1],signal[2])
            end)
    end

    Quantum.Functions.SendPacket = function(player,packet)
            Quantum.Settings.Remote:FireClient(player,packet..'['..Quantum.Settings.SECURITY_CODE..']')
    end

    Quantum.Functions.ConnectRemote = function()
            pcall(function() Quantum.Settings.Remote:Destroy() end)
            Quantum.Settings.Remote = Instance.new('RemoteEvent',game.ReplicatedStorage)
            Quantum.Settings.Remote.Name = "QuantumRemoteAccess"..Quantum.Settings.SECURITY_CODE
            game.ReplicatedStorage.ChildRemoved:connect(function(child)
                    pcall(function()
                            if child == Quantum.Settings.Remote then
                                    Quantum.Functions.ConnectRemote()
                            end
                    end)
            end)
            Quantum.Settings.Remote.Changed:connect(function()
                    pcall(function()
                            Quantum.Functions.ConnectRemote()
                    end)
            end)
            Quantum.Settings.Remote.OnServerEvent:connect(function(...)
                    Quantum.Functions.PacketReceive(...)
            end)
    end

    Quantum.Functions.ConnectRemote()

    for _,i in next, game.Players:GetPlayers() do
            ypcall(function()
                    Quantum.Functions.PlayerAdded(i)
            end)
    end

    print'Quantum Loaded'