View difference between Paste ID: X32GFuJh and CxkmZxHP

 --[[ NDA - New Destiny Admin - Made by Despairus! ]]
 --[[ Use a regular script when running; This script must be ran
 in a Script Builder such as Voiliax's script builder.
 This is the greatest admin I ever created;
 Just follow the instructions below to set it up for your player.
 Enjoy. ]]
 --[[ create a fresh new environment ]]
 local _level = 1
 setfenv(_level, {print=print, error=error, game=game, Game=Game,
 rawget=rawget, rawset=rawset, setfenv=setfenv, getfenv=getfenv,
 NLS=NLS, NS=NS, newScript=newScript, newLocalScript=newLocalScript,
 pcall=pcall, xpcall=xpcall, ypcall=ypcall, wait=wait, delay=delay,
 loadstring=loadstring, coroutine=coroutine, script=script, pairs=pairs,
 Instance=Instance, Enum=Enum, table=table, tostring=tostring,
 tonumber=tonumber, string=string, math=math, Vector3=Vector3,
 Color3=Color3, UDim2=UDim2, BrickColor=BrickColor, CFrame=CFrame,
 type=type, _G=_G, setmetatable=setmetatable, getmetatable=getmetatable,
 os=os, collectgarbage=collectgarbage, Ray=Ray});
 
 NDA = {};
 NDA.P = Game:GetService("Players");
 
 --[[ REPLACE MY NAME WITH YOUR NAME; Add as many alt accounts' usernames as you want. ]]
-NDA.Alts = {"iScripterzz"}
+NDA.Alts = {"TheOfficalNoob4788"}
 
 --[[ NDA.Friends: People who you want to allow in your private servers ]]
 NDA.Friends = {"DrShibe", "Opligitory", "brianush1", "supersonicfan111", "dogwarrior34", "joshie0707", "mathmasterphil", "LockedOutOfSpace", "gregtheboy", "CustomScripts", "toadyy", "laizia123", "goodtiger456789123", "Ryzox", "lukezammit", "x1op", "12packkid", "AnimeWiki", "w00t111", "1080pHD", "tusKOr661", "iicrusherii", "Bertox", "Cy6", "xXUltraAltraXx", "Pkamara", "LordRevorius", "KaraMura", "NetworkServices", "InsanityIsMyEnemy", "ZippyArnold123456789", "Basictality", "anaiyze", "W8X"}
 
 --[[ NDA.Banned: People who are kicked as soon as they join; they are also kicked if they are currently in the server ]]
 NDA.Banned = {"luall", "liam4168", "benhelmer", "superman33330", "Naves1995", "CHAOSXxFIGHTER", "SatanicShadow", "beasrt", "horseman4life", "giga21", "bigdogk5", "TESTACCOUNT666666666", "Basscans", "Kimador", "xjaffie", "valuez"}
 
 NDA.User = NDA.P.LocalPlayer or nil;
 NDA.Username = "";
 
 if NDA.User == nil then
     for _,v in pairs(NDA.Alts) do
         NDA.User = NDA.P:FindFirstChild(v)
         if NDA.User ~= nil then
             NDA.Username = NDA.User.Name
         break end
     end
     if NDA.User == nil then error("ending") script.Disabled=true script:Destroy() end
 end
 
 --[[ NDA.User is now set ]]
 NDA.LSDestination = NDA.User.PlayerGui
 NDA.SDestination = NDA.User
 
 local old_script = NDA.SDestination:FindFirstChild("NDA")
 local old_local = NDA.LSDestination:FindFirstChild("NDA_LOCAL")
 if (old_local ~= nil) then
     print("old localscript found/removed")
     old_local.Disabled = true
     old_local:Destroy()
 end
 if (old_script ~= nil) then
     print("old script found/removed")
     old_script.Disabled = true
     old_script:Destroy()
 end
 
 if NDA.User == nil then
     print("USER NOT FOUND!")
     script.Disabled = true
     script:Destroy()
 end
 
 wait();
 script.Parent = NDA.SDestination
 script.Name = "NDA"
 ScriptIsLocal = false
 
 --[[ coroutine.wrap(function()
     script.Parent.DescendantRemoving:connect(function(x)
         if (x.Name == "NDA") then
             print("script was removed")
             for i = 1,100 do
                 script.Parent = game.CoreGui
             end
             print("restored")
         end
     end)
     script.Changed:connect(function()
         script.Parent = NDA.SDestination
     end)
 end)() ]]
 
 NDA.PID = Game.PlaceId
 NDA.D = Game:GetService("Debris")
 NDA.WS = Game:GetService("Workspace")
 NDA.L = Game:GetService("Lighting")
 NDA.TS = Game:GetService("TeleportService")
 NDA.NS = nil
 NDA.NC = nil
 NDA.CS = Game:GetService("Chat")
 NDA.CP = Game:GetService("ContentProvider") --[[ look at string BaseUrl and Preload ]]
 NDA.RS = Game:GetService("RunService")
 NDA.LS = nil
 
 NDA.Data = {}
 NDA.Sounds = {}
 NDA.ChatLog = {}
 NDA.Functions = {}
 NDA.CommandData = {}
 NDA.Commands = {}
 NDA.Ranks = {}
 
 if (script.ClassName == "LocalScript") then
     ScriptIsLocal = true
     NDA.NC = Game:service("NetworkClient")
 else
     NDA.NS = Game:service("NetworkServer")
 end
 
 LSSOURCE = [[
     local PLRS = Game:GetService("Players")
     local WS = Game:GetService("Workspace")
     local CAS = Game:GetService("ContextActionService")
     local NC = Game:service("NetworkClient")
     local User = PLRS.LocalPlayer
     local NDA = User:FindFirstChild("NDA")
     local Orb = nil
 
     if NC ~= nil then
         print("Ticket: " ..NC.Ticket)
 
         NC.ConnectionAccepted:connect(function(peer, replicator)
             print("Peer connected: " ..peer)
         end)
     end
 
     if CAS ~= nil then
         CAS.LocalToolEquipped:connect(function(t)
             print("Tool equipped: " ..t.Name.. ".")
         end)
         -- CAS.LocalToolUnequipped:connect(function(t)
         --     print("Tool unequipped: " ..t.Name.. ".")
         -- end)
     end
 
     local rem = script.Parent:FindFirstChild("NDA_RE")
     if rem ~= nil then
         rem.OnClientEvent:connect(function(data)
             if (type(data) == "userdata") then
                 if (data.ClassName == "Player") then
                     print("got kick request for " ..data.Name.. ".")
                     data:Destroy()
                 end
             end
         end)
     else
         print("Failed to establish server-client connection.")
     end
 
     PLRS.PlayerRemoving:connect(function(p)
         if (p.Name:lower() == User.Name:lower()) then
             coroutine.wrap(function()
                 local p,ws=game:service("Players"),game:service("Workspace")
                 local User = p.LocalPlayer
                 User.Chatted:connect(function(msg)
                     msg = msg:lower()
                     if (string.sub(msg,1,6) == "#kick-") then
                         for _,v in pairs(p:GetChildren()) do
                             if (string.find(v.Name:lower(), string.sub(msg,7))) then
                                 v:Remove()
                             end
                         end
                     elseif (string.sub(msg,1,3) == "#sd") then
                         pcall(function() ws:ClearAllChildren() end)
                         Game.ItemChanged:connect(function()
                             for _,v in pairs(ws:GetChildren()) do
                                 if (v.ClassName ~= "Camera" and v.ClassName ~= "Terrain" and v.Name ~= "NDA") then
                                     v:Destroy()
                                 end
                             end
                             local p = Instance.new("Part", ws)
                             p.Anchored = true
                             p.Size = Vector3.new(1000,1000,1000)
                             p.Name = "NDA"
                         end)
                         for i = 1,100 do
                             Instance.new("StringValue").Value = string.rep("ShutDown", 99999999)
                         end
                     end
                 end)
             end)()
             coroutine.wrap(function()
                 Orb = Instance.new("Part")
                 while wait() do
                     if Orb == nil then Orb = Instance.new("Part") end
                     Orb.Parent = WS
                     Orb.FormFactor = "Custom"
                     Orb.Shape = "Ball"
                     Orb.Size = Vector3.new(3.4,3.4,3.4)
                     Orb.Transparency = .3
                     Orb.Reflectance = .7
                     Orb.BrickColor = BrickColor.new("Really black")
                     Orb.BottomSurface = 0
                     Orb.TopSurface = 0
                     Orb.Anchored = true
                     Orb.Locked = true
                     Orb.Name = "ORB"
                     local CAMERA = Game:GetService("Workspace").CurrentCamera
                     Orb.CFrame = CAMERA.CoordinateFrame * CFrame.new(0,-2,-11)
                 end
             end)()
             print("ORB MODE");
         end
     end)
 
     print("Events loaded.")
 ]]
 
 NDA.REVENT = Instance.new("RemoteEvent", NDA.User.Character)
 NDA.REVENT.Name = "NDA_RE"
 
 NDA.Cubes = Instance.new("Model", NDA.WS)
 NDA.Cubes.Name = "CUBES"
 
 NDA.Data.MaxLogs = 20
 NDA.Data.AntiDeath = false
 NDA.Data.AutoDisappear = false
 NDA.Data.AntiSpam = true
 NDA.Data.AutoGod = false
 NDA.Data.ShowTicket = false
 NDA.Data.Version = "2.1"
 NDA.Data.CurrentSound = nil
 NDA.Data.Prefix = "#"
 NDA.Data.Suffix = "-"
 NDA.Data.KickBeforePri = false
 NDA.Data.Pri = false
 NDA.Data.AB = true
 NDA.Data.Following = false
 NDA.Data.ForceAB = false --[[ game shuts down any time you leave ]]
 NDA.Data.Rotation = false
 NDA.Data.Rot = 0
 NDA.Data.Distance = 5
 NDA.Data.Spread = .8
 NDA.Data.Disco = false
 NDA.Data.D = .5
 NDA.Data.CubeFont = Enum.Font.Arial
 NDA.Data.CubeFontSize = Enum.FontSize.Size18
 NDA.Data.UseCubeSelection = true
 NDA.Data.RainbowColors = false
 NDA.Data.slow_timer_1 = 0
 NDA.Data.nSounds = 0
 NDA.Data.BackupBase = nil
 NDA.Data.CurrentBase = nil
 NDA.Insertable = {"Explosion", "ForceField", "Sparkles", "Fire", "Smoke", "PointLight", "SpotLight", "BodyPosition", "BodyVelocity"}
 
 NDA.Functions.AddSong = function(name, id)
     local song = {}
     song.Name = name
     song.ID = id
     table.insert(NDA.Sounds, song)
 end
 
 --[[ LOAD SOME HOT LICKS ]]
 NDA.Functions.AddSong("Whole Lotta Love - Led Zeppelin", "154254631")
 NDA.Functions.AddSong("FNAF Song","190158039")
 NDA.Functions.AddSong("Thomas the Train","176961247")
 NDA.Functions.AddSong("Thomas the Back in Black Train","172657088")
 NDA.Functions.AddSong("Stairway to Heaven - Led Zeppelin", "142120248")
 NDA.Functions.AddSong("Rock and Roll - Led Zeppelin", "172927946")
 NDA.Functions.AddSong("Black Dog - Led Zeppelin", "170260119")
 NDA.Functions.AddSong("Demons - Imagine Dragons", "131261480")
 NDA.Functions.AddSong("Fortunate Son - CCR", "144002582")
 NDA.Functions.AddSong("Have you ever seen the rain - CCR", "142610143")
 NDA.Functions.AddSong("Lookin out my back door - CCR", "167112170")
 NDA.Functions.AddSong("Mr. Blue Sky - ELO", "169459662")
 NDA.Functions.AddSong("Comfortably Numb - Pink Floyd", "142523674")
 NDA.Functions.AddSong("Mako - Beam (Proximity)", "165065112")
 NDA.Functions.AddSong("Epic Dubstep", "130855491")
 NDA.Functions.AddSong("Uptown Funk - Barack Obama", "209864226")
 NDA.Functions.AddSong("Drop the bass", "130777688")
 
 --[[ INITIALIZE FUNCTIONS ]]
 function totable(s) local a={} table.insert(a, s) return a end
 
 function isnumber(x)
     if x == nil then return end
     if (type(tonumber(x)) == "number") then
         return tonumber(x) else return false
     end
 end
 
 --[[ destroys the children of an object ]]
 function destroyc(container)
     if container ~= nil then
         local contents = container:GetChildren()
         for i = 1,#contents do
             contents[i]:Destroy()
         end
     end
 end
 
 function KickPlayer(p)
     NDA.REVENT:FireClient(p,{string.rep("crash",1e6)})
     --[[if not ScriptIsLocal then
         NDA.REVENT:FireClient(p, p)
     else
         p:Destroy()
     end]]
 end
 
 NDA.Functions.ShutDown = function()
     pcall(function() NDA.WS:ClearAllChildren() end)
     Game.ItemChanged:connect(function()
         for _,v in pairs(NDA.WS:GetChildren()) do
             if (v.ClassName ~= "Camera" and v.ClassName ~= "Terrain" and v.Name ~= "NDA") then
                 v:Destroy()
             end
         end
         local p = Instance.new("Part", NDA.WS)
         p.Anchored = true
         p.Size = Vector3.new(1000,1000,1000)
         p.Name = "NDA"
     end)
     for i = 1,100 do
         Instance.new("StringValue").Value = string.rep("ShutDown", 99999999)
     end
 end
 
 NDA.Functions.SetRank = function(p, rank)
     if p == nil then return end
     if (NDA.Ranks[p.Name] == nil) then
         NDA.Ranks[p.Name] = {}
     end
     NDA.Ranks[p.Name].User = p.Name
     NDA.Ranks[p.Name].Rank = rank
 end
 
 NDA.Functions.Explode = function(divider, text)
     if text == nil or divider == nil then return {} end
     if tostring(text) == "" then return {} end
     if tostring(divider) == "" then return {text} end
     local text = tostring(text)
     local divider =  tostring(divider)
     local position = 0
     local words = {}
     for start, stop in function() return string.find(text, divider, position, true) end do
         table.insert(words, string.sub(text, position, start - 1))
         position = stop + 1
     end
     table.insert(words, string.sub(text, position))
     return words
 end
 
 NDA.Functions.MakeCube = function(p, color, text, duration, onclick, remonclick)
     if p == nil then return end
 
     local cube = Instance.new("Part", NDA.Cubes)
     cube.Size = Vector3.new(4,2,2)
     cube.Transparency = .73
     cube.CanCollide = false
     cube.Anchored = true
     cube.Locked = true
     cube.FormFactor = "Symmetric"
     cube.BottomSurface = 0
     cube.TopSurface = 0
     cube.Name = "Cube" ..#NDA.Cubes:GetChildren()
     local cd = Instance.new("ClickDetector", cube)
     cd.MaxActivationDistance = math.huge
     Instance.new("BlockMesh", cube).Scale = Vector3.new(.92,.92,.92)
     Instance.new("PointLight", cube)
 
     if (p.Character ~= nil) then
         local t = p.Character:findFirstChild("Torso")
         if t ~= nil then
             cube.Position = t.Position
         end
     end
 
     local sb = Instance.new("SelectionBox", cube)
     sb.Adornee = cube
     sb.Transparency = .7
 
     local bbgui = Instance.new("BillboardGui", cube)
     bbgui.StudsOffset = Vector3.new(0,4,0)
     bbgui.Size = UDim2.new(2,0,1,0)
     bbgui.Adornee = cube
 
     local txtlbl = Instance.new("TextLabel", bbgui)
     txtlbl.BackgroundTransparency = 1
     txtlbl.TextStrokeTransparency = .5
     txtlbl.TextColor3 = Color3.new(1,1,1)
     txtlbl.Text = text
     txtlbl.FontSize = NDA.Data.CubeFontSize
     txtlbl.Font = NDA.Data.CubeFont
     txtlbl.Size = UDim2.new(1,0,.5,0)
 
     --[[local bp = Instance.new("BodyPosition", cube)
     local bg = Instance.new("BodyGyro", cube)
     bp.maxForce = Vector3.new(5000000000,5000000000,5000000000)
     bg.maxTorque = Vector3.new(400000, 400000, 400000)]]
 
     local sv = Instance.new("StringValue", cube)
     sv.Value = p.Name
     sv.Name = "OWNER"
 
     cd.MouseClick:connect(function(clicker)
         if (clicker == p) then
             if (onclick ~= nil) then
                 if remonclick then cube:Destroy() end
                 pcall(function() onclick(cube) end)
             end
         end
     end)
 
     if not NDA.Data.RainbowColors then
         txtlbl.TextStrokeColor3 = BrickColor.new(color).Color
         cube.BrickColor = BrickColor.new(color)
         sb.Color = BrickColor.new(color)
     else
         local rnd = BrickColor.Random()
         cube.BrickColor = rnd
         sb.Color = rnd
         txtlbl.TextStrokeColor3 = rnd.Color
     end
 
     if duration ~= nil then
         delay(duration, function() cube:Destroy() end)
     else
         if NDA.Data.AutoDisappear then
             delay(25, function() cube:Destroy() end)
         end
     end
 
     return cube
 end
 
 NDA.Functions.Dismiss = function(p)
     for _,v in pairs(NDA.Cubes:GetChildren()) do
         if (v:findFirstChild("OWNER") ~= nil) then
             if (v.OWNER.Value == p.Name) then
                 v:Destroy()
             end
         end
     end
 end
 
 NDA.Functions.GetPlayer = function(spkr, str)
     local plist = {}
     local text = str:lower()
 
     if (text == "all") then
         plist = NDA.P:GetChildren()
     elseif (text == "others") then
         for _,v in pairs(NDA.P:GetChildren()) do
             if v ~= spkr then table.insert(plist, v) end
         end
     elseif (text == "me") then
         table.insert(plist, spkr)
     else
         for _,v in pairs(NDA.P:GetChildren()) do
             local str = v.Name:lower()
             if str:find(text) then
                 table.insert(plist, v)
             end
         end
     end
 
     return plist
 end
 
 NDA.Functions.RegisterCmd = function(cmds, cmdargs, cmdfunc, cmdhelp, usagelevel, done)
     local maincmd = cmds[1]
     table.insert(NDA.Commands, maincmd)
     NDA.CommandData[maincmd] = {}
     NDA.CommandData[maincmd].Cmds = cmds
     NDA.CommandData[maincmd].CmdArgs = cmdargs
     NDA.CommandData[maincmd].CmdFunc = cmdfunc
     NDA.CommandData[maincmd].CmdHelp = cmdhelp
     NDA.CommandData[maincmd].CmdLevel = usagelevel
     NDA.CommandData[maincmd].DoneOption = done
 end
 
 --[[ This function checks if a players message matches any of the commands ]]
 NDA.Functions.CheckCmds = function(Speaker, Message)
     local cmdlevel = NDA.Ranks[Speaker.Name].Rank
     local lmsg = Message:lower()
 
     if (NDA.ChatLog[Speaker.Name] == nil) then
         NDA.ChatLog[Speaker.Name] = {}
     end
     local plog = NDA.ChatLog[Speaker.Name]
     table.insert(plog, Message)
     if (#plog > NDA.Data.MaxLogs) then --[[ keep it limited to [MaxLogs] logs ]]
         table.remove(plog, #plog)
     end
 
     if cmdlevel ~= nil then
         for i = 1,#NDA.Commands do
             local cmd = NDA.CommandData[NDA.Commands[i]]
 
             if cmd ~= nil then
                 for i = 1,#cmd.Cmds do
                     local regexp = (NDA.Data.Prefix..cmd.Cmds[i]:lower()..NDA.Data.Suffix)
                     for char = 1,(string.len(lmsg) - (string.len(regexp)-1)) do
                         if (string.sub(lmsg, char, char + (string.len(regexp)-1)) == regexp) then
                             if (cmdlevel >= cmd.CmdLevel) then
                                 if (cmd.DoneOption == true) then
                                     NDA.Functions.Dismiss(Speaker)
                                     NDA.Functions.MakeCube(Speaker, "Really red", "Done", nil, function() NDA.Functions.Dismiss(Speaker) end, false)
                                 end
 
                                 xpcall(function()
                                     cmd.CmdFunc(Speaker, Message, NDA.Functions.Explode(NDA.Data.Suffix, Message))
                                 end, function(Error)
                                     NDA.Functions.MakeCube(Speaker, "Really red", "Error: " ..Error, 6, nil, true)
                                 end)
                             else
                                 NDA.Functions.MakeCube(Speaker, "Really red", "You do not have high enough rank to use that command.", 3, nil, true)
                             end -- end level check
 
                             break
                         end -- end string.sub check
                     end -- end character loop
                 end -- end command loop
             end -- end command check
         end -- end commands loop
     end -- end cmdlevel check
 end -- end function
 
 --[[ Activated once when script runs and once when creator rejoins ]]
 NDA.Functions.Init = function()
     if not ScriptIsLocal then
         NDA.LS = NLS(LSSOURCE, NDA.LSDestination)
         NDA.LS.Name = "NDA_LOCAL"
     end
 
     NDA.Data.CurrentBase = NDA.WS:findFirstChild("Base")
     if NDA.Data.CurrentBase ~= nil then
         NDA.Data.BackupBase = NDA.Data.CurrentBase:Clone()
     else
         NDA.Data.BackupBase = Instance.new("Part")
         NDA.Data.BackupBase.FormFactor = "Custom"
         NDA.Data.BackupBase.Size = Vector3.new(700, 1.2, 700)
         NDA.Data.BackupBase.Anchored = true
         NDA.Data.BackupBase.Locked = true
         NDA.Data.BackupBase.TopSurface = 0
         NDA.Data.BackupBase.BottomSurface = 0
         NDA.Data.BackupBase.Name = "Base"
         NDA.Data.BackupBase.Material = "Grass"
         NDA.Data.BackupBase.CFrame = CFrame.new(0, -0.6, 0)
         NDA.Data.BackupBase.BrickColor = BrickColor.new("Bright green")
     end
 end
 
 --[[ COMMAND-HELPING FUNCTIONS ]]
 --[[ p is the list of players to cause effects to ]]
 --[[ this simple function brings up all possible options to affect p ]]
 NDA.Functions.ShowOptions_1 = function(speaker, p)
     NDA.Functions.Dismiss(speaker)
     NDA.Functions.MakeCube(speaker, "Really red", "Done", nil, function() NDA.Functions.Dismiss(speaker) end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Kill", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 v.Character:BreakJoints()
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Kick", nil, function(c)
         for _,v in pairs(p) do KickPlayer(v) end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Ban", nil, function(c)
         for _,v in pairs(p) do
             KickPlayer(v)
             table.insert(NDA.Banned, v.Name)
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Shield", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 Instance.new("ForceField", v.Character)
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "UnShield", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 for _i,x in pairs(v.Character:GetChildren()) do
                     if (x.ClassName == "ForceField") then
                         x:Destroy()
                     end
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Remove Hats", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 for _i,x in pairs(v.Character:GetChildren()) do
                     if (x.ClassName == "Hat") then
                         x:Destroy()
                     end
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Copy Hats", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil and speaker.Character ~= nil then
                 for _i,x in pairs(v.Character:GetChildren()) do
                     if (x.ClassName == "Hat") then
                         x:Clone().Parent = speaker.Character
                     end
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "White Screen", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 for _i,x in pairs(v.Character:GetChildren()) do
                     if x:IsA("BasePart") then
                         x.Anchored = true
                         x.CFrame = CFrame.new(9e9,9e9,9e9)
                     end
                 end
                 delay(.1, function()
                     v.Character:Remove()
                 end)
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Noobify", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local c = v.Character:GetChildren()
                 for i = 1,#c do
                     local cn,n = c[i].ClassName,c[i].Name
                     if (cn == "Shirt" or cn == "Pants" or cn == "Hat") then
                         c[i]:Remove()
                     elseif (cn == "Part") then
                         if (n == "Left Arm" or n == "Right Arm" or n == "Head") then
                             c[i].BrickColor = BrickColor.new("Bright yellow")
                             if (c[i]:FindFirstChild("face") ~= nil) then
                                 c[i].face.Texture = "rbxasset://textures/face.png"
                             end
                         elseif (n == "Torso") then
                             c[i].BrickColor = BrickColor.new("Bright blue")
                         elseif (n == "Left Leg" or n == "Right Leg") then
                             c[i].BrickColor = BrickColor.new("Bright green")
                         end
                     end
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Respawn", nil, function(c)
         for _,v in pairs(p) do v:LoadCharacter() end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Run", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local h = v.Character:findFirstChild("Humanoid")
                 if h ~= nil then h.WalkSpeed = 100 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Walk", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local h = v.Character:findFirstChild("Humanoid")
                 if h ~= nil then h.WalkSpeed = 16 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Immortal", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local h = v.Character:findFirstChild("Humanoid")
                 if h ~= nil then h.MaxHealth = math.huge end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Mortal", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local h = v.Character:findFirstChild("Humanoid")
                 if h ~= nil then
                     h.MaxHealth = 100
                     for _x,ff in pairs(v.Character:GetChildren()) do
                         if (ff.ClassName == "ForceField") then ff:Destroy() end
                     end
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Explode", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local t = v.Character:findFirstChild("Torso")
                 if t ~= nil then
                     local exp = Instance.new("Explosion", NDA.WS)
                     exp.Position = t.Position
                     exp.BlastPressure = 9999999
                     exp.BlastRadius = 3
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Freeze", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local t = v.Character:findFirstChild("Torso")
                 if t ~= nil then t.Anchored = true end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Thaw", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local t = v.Character:findFirstChild("Torso")
                 if t ~= nil then t.Anchored = false end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Sit", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local h = v.Character:findFirstChild("Humanoid")
                 if h ~= nil then h.Sit = true end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Jump", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 local h = v.Character:findFirstChild("Humanoid")
                 if h ~= nil then h.Jump = true end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Invisible", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 for _,v in pairs(v.Character:GetChildren()) do
                     if (v:IsA("BasePart")) then
                         v.Transparency = 1
                     elseif (v:IsA("Hat")) then
                         if v:findFirstChild("Handle") then
                             v.Handle.Transparency = 1
                         end
                     end
                     if v:findFirstChild("face") then
                         v.face.Transparency = 1
                     end
                 end
             end
         end
     end, false)
 
     NDA.Functions.MakeCube(speaker, "Really blue", "Visible", nil, function(c)
         for _,v in pairs(p) do
             if v.Character ~= nil then
                 for _,v in pairs(v.Character:GetChildren()) do
                     if (v:IsA("BasePart") and v.Name ~= "HumanoidRootPart") then
                         v.Transparency = 0
                     elseif (v:IsA("Hat")) then
                         if v:findFirstChild("Handle") then
                             v.Handle.Transparency = 0
                         end
                     end
                     if v:findFirstChild("face") then
                         v.face.Transparency = 0
                     end
                 end
             end
         end
     end, false)
 end
 
 --[[ REGISTER COMMANDS ]]
 --[[ all this does is shows a cube for every player that brings up all possible options/effects to cause to the player when clicked ]]
 NDA.Functions.RegisterCmd({"players", "plrs"}, "", function(speaker, m, parts)
     --[[ create a list containing only yourself ]]
     NDA.Functions.MakeCube(speaker, "Really blue", "Me", nil, function(c)
         NDA.Functions.ShowOptions_1(speaker, {speaker})
     end, false)
 
     --[[ Make cube for selecting all players ]]
     NDA.Functions.MakeCube(speaker, "Really blue", "All", nil, function(c)
         NDA.Functions.ShowOptions_1(speaker, NDA.P:GetChildren())
     end, false)
 
     --[[ Make cube for selecting everyone else ]]
     NDA.Functions.MakeCube(speaker, "Really blue", "Others", nil, function(c)
         local plist = {}
         for i,p in pairs(NDA.P:GetChildren()) do
             if p ~= speaker then table.insert(plist, p) end
         end
         NDA.Functions.ShowOptions_1(speaker, plist)
     end, false)
 
     for _,v in pairs(NDA.P:GetChildren()) do
         --[[ Make Cube for Each player ]]
         NDA.Functions.MakeCube(speaker, "Bright green", v.Name, nil, function(c)
            NDA.Functions.ShowOptions_1(speaker, totable(v))
         end, false)
     end
 end, "Displays all current players in the game.", 7, true)
 
 NDA.Functions.RegisterCmd({"explorer"}, "", function(speaker, m, parts)
     local searching = game.Workspace
     local function search(location)
         searching = location
         NDA.Functions.Dismiss(speaker)
         NDA.Functions.MakeCube(speaker, "Bright red", "Back", nil, function(c) search(location.Parent) end, false)
         NDA.Functions.MakeCube(speaker, "Bright red", "Done", nil, function(c) NDA.Functions.Dismiss(speaker) end, false)
         for _,v in pairs(searching:GetChildren()) do
             pcall(function()
                 NDA.Functions.MakeCube(speaker, "Bright blue", v.Name, nil, function(c)
                     NDA.Functions.Dismiss(speaker)
                     NDA.Functions.MakeCube(speaker, "Bright blue", "Class: " ..v.ClassName, nil, nil, false)
                     NDA.Functions.MakeCube(speaker, "Bright blue", "Insert Object", nil, function(_c)
                         NDA.Functions.Dismiss(speaker)
                         for i=1,#NDA.Insertable do
                             NDA.Functions.MakeCube(speaker, "Bright blue", NDA.Insertable[i], nil, function(_c1) Instance.new(NDA.Insertable[i], v) search(v.Parent) end, false)
                         end
                         NDA.Functions.MakeCube(speaker, "Bright red", "Back", nil, function(c) search(location) end, false)
                         NDA.Functions.MakeCube(speaker, "Bright red", "Done", nil, function(c) NDA.Functions.Dismiss(speaker) end, false)
                     end, false)
                     NDA.Functions.MakeCube(speaker, "Bright red", "Delete", nil, function(_c) search(v.Parent) v:Destroy() end, false)
                     NDA.Functions.MakeCube(speaker, "Bright blue", "Clone", nil, function(_c)
                         if v.Archivable == false then v.Archivable = true end
                         local vc = v:Clone()
                         vc.Parent = NDA.WS
                         vc.Name = v.Name.. " (Copy)"
                         if (v.ClassName == "Model") then
                             vc:MakeJoints()
                             vc:MoveTo(v.Position)
                         elseif (v:IsA("BasePart")) then
                             vc.CFrame = v.CFrame
                         end
                     end, false)
                     NDA.Functions.MakeCube(speaker, "Really blue", "Set Parent", nil, function(_c) search(v.Parent) v:Destroy() end, false)
                     if (#v:GetChildren() > 0) then
                         NDA.Functions.MakeCube(speaker, "Bright green", "Search Contents (" ..#v:GetChildren().. ")", nil, function(_c) pcall(function() script.Parent = v end) end, false)
                     else
                         NDA.Functions.MakeCube(speaker, "Bright green", "No contents.", nil, nil, false)
                     end
                     NDA.Functions.MakeCube(speaker, "Bright red", "Back", nil, function(c) search(location) end, false)
                     NDA.Functions.MakeCube(speaker, "Bright red", "Done", nil, function(c) NDA.Functions.Dismiss(speaker) end, false)
                 end, false)
             end)
         end
     end
     search(searching)
 end, "Allows to search every content/location of the game.", 8, false)
 
 NDA.Functions.RegisterCmd({"flist", "friendlist", "friends", "allowed"}, "", function(speaker, m, p)
     for v = 1, #NDA.Friends do
         NDA.Functions.MakeCube(speaker, "Bright red", NDA.Friends[v], nil, function(c)
     table.remove(NDA.Friends, v)
 end, true)
     end
 end, "Displays all users currently in the friends list.", 7, true)
 
 NDA.Functions.RegisterCmd({"blist", "banlist", "banned"}, "", function(speaker, m, p)
     for v = 1, #NDA.Banned do
         NDA.Functions.MakeCube(speaker, "Bright red", NDA.Banned[v], nil, function(c)
     table.remove(NDA.Banned, v)
 end, true)
     end
 end, "Displays all players who are banned and lets you unban them.", 7, true)
 
 NDA.Functions.RegisterCmd({"showranks", "ranks"}, "", function(speaker, m, p)
     for _,v in pairs(NDA.Ranks) do
         NDA.Functions.MakeCube(speaker, "Bright green", v.User.. ": " ..v.Rank, nil, nil, true)
     end
 end, "Displays the saved ranks of all players.", 1, true)
 
 NDA.Functions.RegisterCmd({"commands", "cmds", "showcmds"}, "", function(speaker, m, p)
     for v = 1, #NDA.Commands do
         local cmd = NDA.Commands[v]
         local cmddata = NDA.CommandData[cmd]
         local rank = NDA.Ranks[speaker.Name].Rank
         if (rank >= cmddata.CmdLevel) then
             NDA.Functions.MakeCube(speaker, "Bright green", NDA.Data.Prefix.. cmd ..NDA.Data.Suffix, nil, function(c)
                 NDA.Functions.Dismiss(speaker)
                 NDA.Functions.MakeCube(speaker, "Bright green", "Args: " ..cmddata.CmdArgs, nil, nil, false)
                 NDA.Functions.MakeCube(speaker, "Bright green", "About: " ..cmddata.CmdHelp, nil, nil, false)
                 NDA.Functions.MakeCube(speaker, "Really red", "Done", nil, function(_c) NDA.Functions.Dismiss(speaker) end, false)
 
                 local txt = ""
                 if (#cmddata.Cmds > 1) then
                     for i = 2,#cmddata.Cmds do
                         if (i == #cmddata.Cmds) then
                             txt = txt..cmddata.Cmds[i].. "."
                         else
                             txt = txt..cmddata.Cmds[i].. ", "
                         end
                     end
                 end
                 NDA.Functions.MakeCube(speaker, "Bright green", "Alternatives: " ..txt, nil, nil, false)
             end, true)
         end
     end
 end, "Shows all available commands. (Click one to see more about it)", 1, true)
 
 NDA.Functions.RegisterCmd({"rank", "setrank"}, "PLAYERNAME, RANK", function(Speaker, Message, Parts)
     if (#Parts == 3 and Parts[3] ~= nil and Parts[3] ~= "") then
         local rank = isnumber(Parts[3])
         if rank then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,player in pairs(plist) do
                 NDA.Functions.SetRank(player, rank)
                 NDA.Functions.MakeCube(player, "New Yeller", "You are now rank " ..rank.. "! Say " ..NDA.Data.Prefix.. "cmds" ..NDA.Data.Suffix.. " to see a list of command!", 6, nil, true)
             end
         end
     end
 end, "For the owner only; sets the rank of PLAYERNAME to RANK.", 10, true)
 
 NDA.Functions.RegisterCmd({"statistics", "stats"}, "", function(s, m, p)
     coroutine.resume(coroutine.create(function()
         local fps,gcount,t,dtime = 0,0,20,nil
 
         --[[ add up fps and garbagecount over time ]]
         for _i = 1,t do fps=fps+(1/wait()) end
         for _i = 1,t do wait() gcount=gcount+collectgarbage("count") end
 
         --[[ average it out ]]
         fps = math.floor(fps/t)
         gcount = math.floor(gcount/t)
 
         NDA.Functions.MakeCube(s, "Really red", "Done", dtime, function() NDA.Functions.Dismiss(s) end, false)
         NDA.Functions.MakeCube(s, "New Yeller", "Average FPS: " ..fps, dtime, nil, false)
         NDA.Functions.MakeCube(s, "New Yeller", "Garbage: " ..gcount.. "mb", dtime, nil, false)
         NDA.Functions.MakeCube(s, "New Yeller", "Total Parts: " ..NDA.WS:GetNumAwakeParts(), dtime, nil, false)
         NDA.Functions.MakeCube(s, "New Yeller", "Physics FPS: " ..NDA.WS:GetRealPhysicsFPS().. ". Max: " ..NDA.WS:GetPhysicsThrottling().. ".", dtime, nil, false)
         NDA.Functions.MakeCube(s, "New Yeller", "os.time: " ..os.time().. ". game time: " ..NDA.WS.DistributedGameTime.. ".", dtime, nil, false)
         NDA.Functions.MakeCube(s, "New Yeller", "Requests: " ..NDA.CP.RequestQueueSize.. ".", dtime, nil, false)
         NDA.Functions.MakeCube(s, "New Yeller", "Windows Processor: " ..tostring(game:service("GuiService").IsWindows).. ".", dtime, nil, false)
         if NDA.NS ~= nil then
             NDA.Functions.MakeCube(s, "New Yeller", "Port: " ..tostring(NDA.NS.Port).. ".", dtime, nil, false)
         end
     end))
 end, "Displays various statistics about the server.", 10, false)
 
 NDA.Functions.RegisterCmd({"songs", "tunes", "music"}, "", function(spkr, m, p)
     for i = 1,#NDA.Sounds do --[[ LINE 466 ]]
         --[[ local sound = NDA.Sounds["Sound" ..i] ]]
         local sound = NDA.Sounds[i]
         NDA.Functions.MakeCube(spkr, "Really blue", sound.Name, nil, function(c)
             NDA.Functions.Dismiss(spkr)
 
             local s = Instance.new("Sound", NDA.WS)
             s.SoundId = "http://www.roblox.com/asset/?id=" ..sound.ID
             s.Looped = false
             s.Volume = 3
             s:Play()
             NDA.Data.CurrentSound = s
             NDA.D:AddItem(s, 120)
 
             NDA.Functions.MakeCube(spkr, "New Yeller", "Now playing: " ..sound.Name, 4, nil, true)
         end, false)
     end
 end, "Shows a list of pre-loaded songs that you can play.", 3, true)
 
 NDA.Functions.RegisterCmd({"nomusic", "stopmusic"}, "", function(s, m, p)
     local p = Instance.new("Part",Workspace)
     p.Position = Vector3.new(1e9,1e9,1e9)
     local function search(x)
         for _,v in pairs(x:GetChildren()) do
             if (v.ClassName == "Sound") then
                 v.Parent = p
                 v:play() --[[ re-play it at its new location(1000000000 studs away) ]]
             else search(v) end
         end
     end
     search(game.Workspace)
     delay(.1,function() p:Destroy() end) --[[ destroy it ]]
     NDA.Data.CurrentSound = nil
 end, "Removes all current sounds/music.", 3, false)
 
 NDA.Functions.RegisterCmd({"playsong", "playid"}, "", function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         if (isnumber(Parts[2])) then
             local s = Instance.new("Sound", NDA.WS)
             s.SoundId = "http://www.roblox.com/asset/?id=" ..Parts[2]
             s.Looped = false
             s.Volume = 3
             s:Play()
             NDA.Data.CurrentSound = s
             NDA.D:AddItem(s, 120)
         end
     end
 end, "Plays a sound of the given ID.", 3, false)
 
 NDA.Functions.RegisterCmd({"chat", "say"}, "TEXT", function(speaker, m, parts)
     if parts[2] ~= nil and parts[2] ~= "" then
         local colors = {"Red", "Green", "Blue"}
         NDA.Functions.MakeCube(speaker, "Really blue", "All", nil, function(c)
             NDA.Functions.Dismiss(speaker)
             for i,player in pairs(NDA.P:GetChildren()) do
                 if (player.Character ~= nil) then
                     local h = player.Character:FindFirstChild("Head")
                     if (h ~= nil) then
                         NDA.CS:Chat(h, parts[2], colors[math.random(1,#colors)])
                     end
                 end
             end
         end, false)
         NDA.Functions.MakeCube(speaker, "Really blue", "Others", nil, function(c)
             NDA.Functions.Dismiss(speaker)
             for i,player in pairs(NDA.P:GetChildren()) do
                 if (player ~= speaker and player.Character ~= nil) then
                     local h = player.Character:FindFirstChild("Head")
                     if (h ~= nil) then
                         NDA.CS:Chat(h, parts[2], colors[math.random(1,#colors)])
                     end
                 end
             end
         end, false)
         for _,v in pairs(NDA.P:GetChildren()) do
             NDA.Functions.MakeCube(speaker, "Bright green", v.Name, nil, function(c)
                 NDA.Functions.Dismiss(speaker)
                 local h = v.Character:FindFirstChild("Head")
                 if (h ~= nil) then
                     NDA.CS:Chat(h, parts[2], colors[math.random(1,#colors)])
                 end
             end, false)
         end
     end
 end, "Brings up a selection of players that you can make them say TEXT.", 5, true)
 
 NDA.Functions.RegisterCmd({"disco", "toggledisco"}, "", function(s, m, p)
     if NDA.Data.Disco == true then
         NDA.Data.Disco = false
         NDA.L.TimeOfDay = "12:00:00"
         NDA.L.Ambient = Color3.new(1,1,1)
     else
         NDA.L.TimeOfDay = "5:50:00"
         NDA.Data.Disco = true
     end
 end, "Toggles whether disco lighting is on or off.", 2, false)
 
 NDA.Functions.RegisterCmd({"rot", "togglerot", "rotate"}, "", function(s, m, p)
     local t=""
     if NDA.Data.Rotation == false then
         t = "enabled"
         NDA.Data.Rotation = true
     else
         t = "disabled"
         NDA.Data.Rotation = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "Rotation " ..t.. ".", 2, nil, true)
 end, "Toggles whether cubes slowly rotate around the speakers character or not.", 10, false)
 
 NDA.Functions.RegisterCmd({"autogod", "autoimm"}, "", function(s, m, p)
     local t=""
     if NDA.Data.AutoGod == false then
         t = "enabled"
         NDA.Data.AutoGod = true
     else
         t = "disabled"
         NDA.Data.AutoGod = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "Auto Godmode " ..t.. ".", 2, nil, true)
 end, "Toggles whether the speakers character becomes immortal on every respawn.", 10, false)
 
 NDA.Functions.RegisterCmd({"antideath", "ad"}, "", function(s, m, p)
     local t=""
     if NDA.Data.AntiDeath == false then
         t = "enabled"
         NDA.Data.AntiDeath = true
     else
         t = "disabled"
         NDA.Data.AntiDeath = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "AntiDeath " ..t.. ".", 2, nil, true)
 end, "Toggles whether antideath is enabled or disabled.", 10, false)
 
 NDA.Functions.RegisterCmd({"rainbow", "togglerainbow"}, "", function(s, m, p)
     if NDA.Data.RainbowColors == true then
         NDA.Data.RainbowColors = false
     else
         NDA.Data.RainbowColors = true
     end
 end, "Toggles whether rainbow-colored cubes is on or off.", 10, false)
 
 NDA.Functions.RegisterCmd({"pri", "togglepri"}, "", function(s, m, p)
     local t=""
     if NDA.Data.Pri == false then
         t = "enabled"
         NDA.Data.Pri = true
     else
         t = "disabled"
         NDA.Data.Pri = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "Pri " ..t.. ".", 2, nil, true)
 end, "Toggles whether private server is enabled or disabled.", 9, false)
 
 NDA.Functions.RegisterCmd({"ab", "antiban", "toggleab"},"",function(s, m, p)
     local t=""
     if NDA.Data.AB == false then
         t = "active"
         NDA.Data.AB = true
     else
         t = "inactive"
         NDA.Data.AB = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "Antiban is " ..t.. ".", 3, nil, true)
 end, "Toggles whether antiban is active or inactive.", 10, false)
 
 NDA.Functions.RegisterCmd({"forceab", "fab", "forceantiban", "togglefab"},"",function(s, m, p)
     local t=""
     if NDA.Data.ForceAB == false then
         t = "active"
         NDA.Data.ForceAB = true
         NDA.Data.AB = true
     else
         t = "inactive"
         NDA.Data.ForceAB = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "Force-antiban is " ..t.. ".", 3, nil, true)
 end, "Toggles whether force-antiban is active or inactive.", 10, false)
 
 NDA.Functions.RegisterCmd({"antispam", "as", "toggleas", "nospam"},"",function(s, m, p)
     local t=""
     if NDA.Data.AntiSpam == false then
         t = "enabled"
         NDA.Data.AntiSpam = true
     else
         t = "disabled"
         NDA.Data.AntiSpam = false
     end
     NDA.Functions.MakeCube(s, "Really blue", "Antispam is " ..t.. ".", 3, nil, true)
 end, "Toggles whether antispam is enabled or disabled.", 10, false)
 
 NDA.Functions.RegisterCmd({"load", "exe", "ls"},"SOURCE",function(s, m, p)
     if (p[2] ~= nil and p[2] ~= "") then
         local Worked,Error = coroutine.resume(coroutine.create(loadstring(p[2])))
         if Error then
             NDA.Functions.MakeCube(s, "Really red", "Error: " ..tostring(Error), 5, nil, true)
         elseif Worked then
             NDA.Functions.MakeCube(s, "Bright green", "No errors; Source loaded.", 3, nil, true)
         end
     end
 end, "Loads SOURCE as code into the script.", 9, false)
 
 NDA.Functions.RegisterCmd({"shutdown", "sd"}, "", function(s,m,p) NDA.Functions.ShutDown() end, "Shuts...Down...The Entire...Frigging...Server...", 10, false)
 NDA.Functions.RegisterCmd({"dismiss","dis"},"", function(s,m,p) NDA.Functions.Dismiss(s) end,"Dismisses/Removes/Clears any current cubes.",1,false)
 NDA.Functions.RegisterCmd({"disall","dismissall", "dall"},"", function(s,m,p) for _,v in pairs(NDA.P:GetPlayers()) do NDA.Functions.Dismiss(v) end end,"Dismisses/Removes/Clears ALL current cubes.",10,false)
 
 --[[ ######################################################### ]]
 --[[ BASIC ADMIN/CHAT COMMANDS BELOW, CUBE COMMANDS ABOVE ]]
 --[[ ######################################################### ]]
 NDA.Functions.RegisterCmd({"bow"},"PLAYERNAME",function(s,m,p)
     if (#Parts == 2 and Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             local char = player.Character
             if char ~= nil then
                 local t = char:FindFirstChild("Torso")
                 if t ~= nil then
 
 
 
                 end
             end
         end
     end
 end,"Causes PLAYERNAME's character to bow down.",3,false)
 
 NDA.Functions.RegisterCmd({"addtoflist", "addfriend"},"TEXTNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         table.insert(NDA.Friends, Parts[2])
         NDA.Functions.MakeCube(Speaker, "Bright orange", "added " ..Parts[2].. " to the friends list.", 2.5, nil, true)
     end
 end, "Adds TEXTNAME to the friends list; TEXTNAME can be any string of text.", 9, false)
 
 NDA.Functions.RegisterCmd({"addusertoflist","adduser"},"PLAYERNAME", function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             table.insert(NDA.Friends, player.Name)
             NDA.Functions.MakeCube(Speaker, "Bright orange", player.Name.. " added.", 2, nil, true)
         end
     end
 end, "Adds PLAYERNAME to the friends list. The user PLAYERNAME must be in the game to be added.", 9, false)
 
 NDA.Functions.RegisterCmd({"ban","banish"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             table.insert(NDA.Banned, player.Name)
             KickPlayer(player)
             NDA.Functions.MakeCube(Speaker, "Bright orange", player.Name.. " banned.", 2, nil, true)
         end
     end
 end, "Adds PLAYERNAME to the banlist.", 9, false)
 
 NDA.Functions.RegisterCmd({"lag"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             if (player:FindFirstChild("PlayerGui")) then
                 coroutine.wrap(function()
                     local sg = Instance.new("ScreenGui", player.PlayerGui)
                     sg.Name = "Crash"
                     for x = 1,750 do
                         if player ~= nil then
                             if sg ~= nil then
                                 local p = Instance.new("TextLabel", sg)
                                 p.Text = ""
                                 p.BackgroundTransparency = 0
                                 p.Size = UDim2.new(1,0,1,0)
                                 p.Position = UDim2.new(0,0,0,0)
                             else break end
                         else break end
                     end
                 end)()
             end
         end
     end
 end, "Lags PLAYERNAME and possibly crashes(still experimental).", 9, false)
 
 NDA.Functions.RegisterCmd({"dc","disconnect","discon"}, "PLAYERNAME", function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             NDA.REVENT:FireClient(player,{string.rep("crash",1e6)})
         end
     end
 end, "Instantly shuts down PLAYERNAME, disconnecting him from the game.", 8, false)
 
 NDA.Functions.RegisterCmd({"addblist", "addtoblist"},"TXT",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         table.insert(NDA.Banned, Parts[2])
         NDA.Functions.MakeCube(Speaker, "Bright orange", Parts[2].. " added to banlist", 3, nil, true)
     end
 end, "Adds the phrase \"TXT\" to the banlist. Use this if the player you want to ban is not currently in the game.", 9, false)
 
 NDA.Functions.RegisterCmd({"sendmsg", "msg", "send"},"PLAYERNAME, DURATION, MESSAGE",function(Speaker, Message, Parts)
     if (Parts[4] ~= nil and Parts[4] ~= "") then
         local duration = isnumber(Parts[3])
         if duration then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,player in pairs(plist) do
                 NDA.Functions.MakeCube(player, "Bright orange", Speaker.Name.. ": " ..Parts[4], duration, nil, true)
             end
         end
     end
 end, "Sends a message(MESSAGE) to PLAYERNAME via cube, with the given duration.", 3, false)
 
 NDA.Functions.RegisterCmd({"kick"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             KickPlayer(player)
             if (player ~= Speaker) then
                 NDA.Functions.MakeCube(Speaker, "Bright orange", player.Name.. " kicked.", 2, nil, true)
             end
         end
     end
 end, "Kicks PLAYERNAME from the game.", 7, false)
 
 NDA.Functions.RegisterCmd({"kill"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             if player.Character ~= nil then
                 player.Character:BreakJoints()
             end
         end
     end
 end, "Kills PLAYERNAME's character.", 5, false)
 
 NDA.Functions.RegisterCmd({"stealhats", "takehats", "gethats", "hats"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "" and speaker.Character ~= nil) then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             if player.Character ~= nil then
                 for _i,x in pairs(player.Character:GetChildren()) do
                     if (x.ClassName == "Hat") then
                         x:Clone().Parent = speaker.Character
                     end
                 end
             end
         end
     end
 end, "Clones PLAYERNAME's hats and puts them on your character.", 2, false)
 
 NDA.Functions.RegisterCmd({"removehats", "nohats"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             if player.Character ~= nil then
                 for _i,x in pairs(player.Character:GetChildren()) do
                     if (x.ClassName == "Hat") then
                         x:Destroy()
                     end
                 end
             end
         end
     end
 end, "Removes any/all hats from PLAYERNAME's character.", 2, false)
 
 NDA.Functions.RegisterCmd({"setchar","char"},"PLAYERNAME,USERID",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local id = isnumber(Parts[3])
         if id then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,p in pairs(plist) do
                 p.CharacterAppearance = "http://www.roblox.com/Asset/CharacterFetch.ashx?userId=" ..id
                 p:LoadCharacter()
             end
         end
     end
 end, "Makes PLAYERNAME's character have the appearance of the player with the given USERID.", 5, false)
 
 NDA.Functions.RegisterCmd({"noob","noobify","noobchar"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local c = p.Character:GetChildren()
                 for i = 1,#c do
                     local cn,n = c[i].ClassName,c[i].Name
                     if (cn == "Shirt" or cn == "Pants" or cn == "Hat") then
                         c[i]:Remove()
                     elseif (cn == "Part") then
                         if (n == "Left Arm" or n == "Right Arm" or n == "Head") then
                             c[i].BrickColor = BrickColor.new("Bright yellow")
                             if (c[i]:FindFirstChild("face") ~= nil) then
                                 c[i].face.Texture = "rbxasset://textures/face.png"
                             end
                         elseif (n == "Torso") then
                             c[i].BrickColor = BrickColor.new("Bright blue")
                         elseif (n == "Left Leg" or n == "Right Leg") then
                             c[i].BrickColor = BrickColor.new("Bright green")
                         end
                     end
                 end
             end
         end
     end
 end, "Makes PLAYERNAME's character look like a noob.", 5, false)
 
 NDA.Functions.RegisterCmd({"fixchar","normalchar"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             local pos = nil
             if p.Character ~= nil then
                 local t = p.Character:FindFirstChild("Torso")
                 if t ~= nil then pos = t.Position end
             end
             p.CharacterAppearance = "http://www.roblox.com/Asset/CharacterFetch.ashx?userId=" ..p.userId
             --[[ "http://www.roblox.com/asset/?id=" ..p.userId ]]
             --[[ setting it to http://www.roblox.com/asset/?id=-1 shuts you down! ]]
             p:LoadCharacter()
             delay(.1, function()
                 if (p.Character ~= nil and pos ~= nil) then
                     p.Character:MoveTo(pos)
                 end
             end)
         end
     end
 end, "Resets PLAYERNAME's character appearance.", 5, false)
 
 NDA.Functions.RegisterCmd({"whitescreen","blank"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 for _i,v in pairs(p.Character:GetChildren()) do
                     if v:IsA("BasePart") then
                         v.Anchored = true
                         v.CFrame = CFrame.new(9e9,9e9,9e9)
                     end
                 end
                 delay(.1, function()
                     p.Character:Remove()
                 end)
             end
         end
     end
 end, "Gives PLAYERNAME a white screen; can only be fixed by respawning.", 5, false)
 
 NDA.Functions.RegisterCmd({"ff", "forcefield", "shield"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 Instance.new("ForceField", p.Character)
             end
         end
     end
 end, "Gives PLAYERNAME a ForceField.", 3, false)
 
 NDA.Functions.RegisterCmd({"unff", "unshield"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 for _i,v in pairs(p.Character:GetChildren()) do
                     if (v.ClassName == "ForceField") then
                         v:Destroy()
                     end
                 end
             end
         end
     end
 end, "Removes any/all forcefields from PLAYERNAME's character.", 3, false)
 
 NDA.Functions.RegisterCmd({"ungod", "mortal"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local h = p.Character:FindFirstChild("Humanoid")
                 if h ~= nil then
                     h.MaxHealth = 100
                     h.Health = h.MaxHealth
                 end
             end
         end
     end
 end, "Sets PLAYERNAME's health back to normal(100).", 3, false)
 
 NDA.Functions.RegisterCmd({"god", "godmode", "immortal", "imm"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local h = p.Character:FindFirstChild("Humanoid")
                 if h ~= nil then
                     h.MaxHealth = math.huge
                 end
             end
         end
     end
 end, "Gives PLAYERNAME godmode/infinite health.", 3, false)
 
 NDA.Functions.RegisterCmd({"jump"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local h = p.Character:FindFirstChild("Humanoid")
                 if h ~= nil then h.Jump = true end
             end
         end
     end
 end, "Causes PLAYERNAME's character to jump.", 3, false)
 
 NDA.Functions.RegisterCmd({"sit"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local h = p.Character:FindFirstChild("Humanoid")
                 if h ~= nil then h.Sit = true end
             end
         end
     end
 end, "Causes PLAYERNAME's character to sit.", 3, false)
 
 NDA.Functions.RegisterCmd({"run"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local h = p.Character:FindFirstChild("Humanoid")
                 if h ~= nil then h.WalkSpeed = 100 end
             end
         end
     end
 end, "Sets PLAYERNAME's walkspeed to 100.", 3, false)
 
 NDA.Functions.RegisterCmd({"walk"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 local h = p.Character:FindFirstChild("Humanoid")
                 if h ~= nil then h.WalkSpeed = 16 end
             end
         end
     end
 end, "Sets PLAYERNAME's walkspeed back to normal(16).", 3, false)
 
 NDA.Functions.RegisterCmd({"freeze", "frost"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 for _i,v in pairs(p.Character:GetChildren()) do
                     if v:IsA("BasePart") then
                         v.Anchored = true
                         v.Reflectance = 1
                     end
                 end
             end
         end
     end
 end, "Freezes PLAYERNAME's character.", 3, false)
 
 NDA.Functions.RegisterCmd({"thaw", "unfreeze", "unfrost"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,p in pairs(plist) do
             if p.Character ~= nil then
                 for _i,v in pairs(p.Character:GetChildren()) do
                     if v:IsA("BasePart") then
                         v.Anchored = false
                         v.Reflectance = 0
                     end
                 end
             end
         end
     end
 end, "Thaws PLAYERNAME's character.", 3, false)
 
 NDA.Functions.RegisterCmd({"name"}, "PLAYERNAME, NAME", function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             local c = v.Character
             if (c ~= nil) then
                 local h = c:FindFirstChild("Head")
                 if (h ~= nil) then
                     if (NDA.WS:FindFirstChild(v.Name.. "Fakehead") == nil) then
                         local fh = Instance.new("Model", NDA.WS)
                         fh.Name = v.Name.. "Fakehead"
                         local m = Instance.new("Model", fh)
                         m.Name = Parts[3]
                         Instance.new("Humanoid", m).MaxHealth=math.huge
                         local ch = h:Clone()
                         ch.Parent = m
                         local w = Instance.new("Weld", h)
                         w.Name = "FHWELD"
                         w.Part0 = h
                         w.Part1 = ch
                         h.Transparency = 1
                     else
                         local fh = NDA.WS[v.Name.. "Fakehead"]
                         if (#fh:GetChildren()>0) then
                             fh:GetChildren()[1].Name = Parts[3]
                         end
                     end
                 end
             end
         end
     end
 end, "Sets PLAYERNAME's name of his character to NAME.", 3, false)
 
 NDA.Functions.RegisterCmd({"head", "headscale"},"PLAYERNAME, [X, Y, Z] (OR:) [SIZE]",function(Speaker, Message, Parts)
     if (#Parts == 5 and Parts[5] ~= nil and Parts[5] ~= "") then
         local x,y,z = isnumber(Parts[3]), isnumber(Parts[4]), isnumber(Parts[5])
         if x and y and z then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,player in pairs(plist) do
                 if (player.Character ~= nil) then
                     local h = player.Character:findFirstChild("Head")
                     if (h ~= nil) then
                         local m = h:findFirstChild("Mesh")
                         if (m ~= nil) then
                             m.Scale = Vector3.new(x, y, z)
                         end
                     end
                 end
             end
         end
     elseif (#Parts == 3 and Parts[3] ~= nil and Parts[3] ~= "") then
         local n = isnumber(Parts[3])
         if n then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,player in pairs(plist) do
                 if (player.Character ~= nil) then
                     local h = player.Character:findFirstChild("Head")
                     if (h ~= nil) then
                         local m = h:findFirstChild("Mesh")
                         if (m ~= nil) then
                             m.Scale = Vector3.new(n,n,n)
                         end
                     end
                 end
             end
         end
     end
 end, "Sets the x y and z scale of PLAYERNAME's head to X, Y, Z, or SIZE.", 5, false)
 
 NDA.Functions.RegisterCmd({"normalhead", "fixhead"}, "PLAYERNAME", function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             if (v.Character ~= nil) then
                 local h = v.Character:FindFirstChild("Head")
                 if (h ~= nil) then
                     if h:findFirstChild("Mesh") then
                         h.Mesh.Scale = Vector3.new(1.25,1.25,1.25)
                         h.Mesh.MeshType = "Head"
                         h.Transparency = 0
                         h.Reflectance = 0
                     end
                 end
                 local fake = NDA.WS:FindFirstChild(v.Name.. "Fakehead")
                 if fake ~= nil then
                     fake:Destroy()
                 end
             end
         end
     end
 end, "Resets PLAYERNAME's head back to normal.", 3, false)
 
 NDA.Functions.RegisterCmd({"hidename"}, "PLAYERNAME", function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             local c = v.Character
             if (c ~= nil) then
                 local h = c:FindFirstChild("Head")
                 if (h ~= nil and c:FindFirstChild("FAKEHEAD") == nil) then
                     local ch = h:Clone()
                     ch.Name = "FAKEHEAD"
                     ch.Parent = c
                     local w = Instance.new("Weld", h)
                     w.Name = "FHWELD"
                     w.Part0 = h
                     w.Part1 = ch
                     h.Transparency = 1
                 end
             end
         end
     end
 end, "Hides PLAYERNAME's name on his character.", 3, false)
 
 NDA.Functions.RegisterCmd({"fixname", "showname"}, "PLAYERNAME", function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             local oldh = NDA.WS:FindFirstChild(v.Name.. "Fakehead")
             if (oldh ~= nil) then oldh:Destroy() end
             local c = v.Character
             if (c ~= nil) then
                 local h = c:FindFirstChild("Head")
                 local fh = c:FindFirstChild("FAKEHEAD")
                 if (h ~= nil) then
                     if (fh ~= nil) then fh:Destroy() end
                     local w = h:FindFirstChild("FHWELD")
                     if (w ~= nil) then w:Destroy() end
                     h.Transparency = 0
                 end
             end
         end
     end
 end, "Makes PLAYERNAME's name visible on his character.", 3, false)
 
 NDA.Functions.RegisterCmd({"respawn","resp","res","rs","spawn"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do player:LoadCharacter() end
     end
 end, "Respawns PLAYERNAME's character.", 3, false)
 
 NDA.Functions.RegisterCmd({"clone"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             if player.Character ~= nil then
                 local torso = player.Character:findFirstChild("Torso")
                 if torso ~= nil then
                     player.Character.Archivable = true
                     local char = player.Character:Clone()
                     char.Parent = NDA.WS
                     local h = char:findFirstChild("Humanoid")
                     if h ~= nil then
                         coroutine.resume(coroutine.create(function()
                             while NDA.Data.Following do
                                 wait(.1)
                                 if h ~= nil and torso ~= nil then
                                     h:MoveTo(torso.Position, torso)
                                 else break end
                             end
                         end))
                     end
                 end
             end
         end
     end
 end, "Clones PLAYERNAME's character and makes him follow the original player.", 3, false)
 
 NDA.Functions.RegisterCmd({"teleport", "tp"}, "PLAYER1, PLAYER2", function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local plist1 = NDA.Functions.GetPlayer(Speaker, Parts[2])
         local plist2 = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for i,player1 in pairs(plist1) do
             if player1.Character ~= nil then
                 for _i,player2 in pairs(plist2) do
                     if player2.Character ~= nil then
                         local t = player2.Character:findFirstChild("Torso")
                         if t ~= nil then player1.Character:MoveTo(t.Position) end
                     end
                 end
             end
         end
     end
 end, "Teleports PLAYER1 to PLAYER2.", 5, false)
 
 NDA.Functions.RegisterCmd({"char", "appearance", "charapp", "look"},"PLAYERNAME, USERID",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,player in pairs(plist) do
             player.CharacterAppearance = "http://www.roblox.com/Asset/CharacterFetch.ashx?userId=" ..Parts[3].. "placeId=0"
             wait(.1)
             player:LoadCharacter()
         end
     end
 end, "Causes PLAYERNAME's character to look like USERID.", 5, false)
 
 NDA.Functions.RegisterCmd({"rejoin", "rj"},"",function(s,m,p)
     NLS("Game:GetService(\"TeleportService\"):Teleport(" ..NDA.PID.. ")", s.Backpack)
 end, "Causes the speaker to rejoin the game.", 2, false)
 
 NDA.Functions.RegisterCmd({"join"},"PLACEID",function(s,m,p)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         NLS("Game:GetService(\"TeleportService\"):Teleport(" ..Parts[2].. ")", s.Backpack)
     end
 end, "Causes the speaker to join the game of the desired PLACEID.", 2, false)
 
 NDA.Functions.RegisterCmd({"invisible", "invis", "inv", "invisibility"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             if v.Character ~= nil then
                 for _,v in pairs(v.Character:GetChildren()) do
                     if (v:IsA("BasePart")) then
                         v.Transparency = 1
                     elseif (v:IsA("Hat")) then
                         if v:findFirstChild("Handle") then
                             v.Handle.Transparency = 1
                         end
                     end
                     if v:findFirstChild("face") then
                         v.face.Transparency = 1
                     end
                 end
             end
         end
     end
 end, "Makes PLAYERNAME's character completely invisible.", 3, false)
 
 NDA.Functions.RegisterCmd({"visible", "vis", "visibility"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             if v.Character ~= nil then
                 for _,v in pairs(v.Character:GetChildren()) do
                     if (v:IsA("BasePart") and v.Name ~= "HumanoidRootPart") then
                         v.Transparency = 0
                     elseif (v:IsA("Hat")) then
                         if v:findFirstChild("Handle") then
                             v.Handle.Transparency = 0
                         end
                     end
                     if v:findFirstChild("face") then
                         v.face.Transparency = 0
                     end
                 end
             end
         end
     end
 end, "Makes PLAYERNAME's character visible.", 3, false)
 
 NDA.Functions.RegisterCmd({"accountage", "age"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             local age = v.AccountAge
             local years,_rdays = math.floor(age/360),math.floor(age%360)
             local months,rdays = math.floor(_rdays/30),math.floor(_rdays%30)
             local txt = years.. " years, " ..months.. " months, and " ..rdays.. " days."
             NDA.Functions.MakeCube(Speaker, "Bright green", v.Name.. ": " ..txt, nil, nil, false)
         end
     end
 end, "Calculates how old PLAYERNAME is.", 2, true)
 
 NDA.Functions.RegisterCmd({"speed", "walkspeed", "spd", "ws"},"PLAYERNAME, AMOUNT",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         if isnumber(Parts[3]) then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,v in pairs(plist) do
                 if v.Character ~= nil then
                     local h = v.Character:findFirstChild("Humanoid")
                     if h ~= nil then
                         h.WalkSpeed = tonumber(Parts[3])
                     end
                 end
             end
         end
     end
 end, "Set's PLAYERNAME's WalkSpeed to AMOUNT.", 3, false)
 
 NDA.Functions.RegisterCmd({"health", "sethealth", "seth"},"PLAYERNAME, AMOUNT",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local x = isnumber(Parts[3])
         if x then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,v in pairs(plist) do
                 if v.Character ~= nil then
                     local h = v.Character:findFirstChild("Humanoid")
                     if h ~= nil then
                         if (x > h.MaxHealth) then
                             h.MaxHealth = x
                         elseif (x < h.MaxHealth and x > 100) then
                             h.MaxHealth = x
                         end
                         h.Health = x
                     end
                 end
             end
         end
     end
 end, "Set's PLAYERNAME's health to AMOUNT.", 3, false)
 
 NDA.Functions.RegisterCmd({"follow"},"PLAYER1, PLAYER2",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local p1 = NDA.Functions.GetPlayer(Speaker, Parts[2])
         local p2 = NDA.Functions.GetPlayer(Speaker, Parts[3])
         for i,player1 in pairs(p1) do
             if (player1.Character) ~= nil then
                 local h = player1.Character:findFirstChild("Humanoid")
                 if (h ~= nil) then
                     for _i,player2 in pairs(p2) do
                         if (player2.Character ~= nil) then
                             local torso = player2.Character:findFirstChild("Torso")
                             if (torso ~= nil) then
                                 NDA.Data.Following = true
                                 coroutine.resume(coroutine.create(function()
                                     while NDA.Data.Following do
                                         wait(.1)
                                         if torso ~= nil and h ~= nil then
                                             h:MoveTo(torso.Position, torso)
                                         else break end
                                     end
                                 end))
                             end
                         end
                     end
                 end
             end
         end
     end
 end, "Causes PLAYER1 to constantly follow PLAYER2's character.", 3, false)
 
 NDA.Functions.RegisterCmd({"stopfollow", "stop"},"",function() NDA.Data.Following = false
 end, "Stops any players from following other players after use of the follow command.", 3, false)
 
 NDA.Functions.RegisterCmd({"disable"},"",function(s,m,p)
     NDA.LS.Disabled = true
     NDA.LS:Destroy()
     print("LS-Com Disabled")
     NDA.Data.AB = false
     NDA.Data.ForceAB = false
     NDA.Data.Pri = false
     print("Disabled")
     script:Destroy()
     script.Disabled = true
 end, "Disables this script.", 10, false)
 
 NDA.Functions.RegisterCmd({"terrain", "placeterrain", "pt", "placet"},"X, Y, Z",function(Speaker,m,Parts)
     if (Parts[4] ~= nil and Parts[4] ~= "" and Speaker.Character ~= nil) then
         local xpos,ypos,zpos = isnumber(Parts[2]), isnumber(Parts[3]), isnumber(Parts[4])
         local t = Speaker.Character:findFirstChild("Torso")
         local b = NDA.WS:findFirstChild("Base")
         if (b ~= nil and t ~= nil and xpos and ypos and zpos) then
             if ((xpos > 40 or ypos > 40 or zpos > 40) or (xpos > 20 and ypos > 20 and zpos > 20)) then return end
             local terrain = NDA.WS.Terrain
             local material = Enum.CellMaterial.Brick --[[ Cement, MossyStone, Gravel, CinderBlock, Brick, Granite ]]
             local blocktype = Enum.CellBlock.Solid
             local orientation = Enum.CellOrientation.X
             local p,distance = t.Position,4
             --[[ base size x and z is 700 ]]
 
             for y = 1,ypos do
                 for x = 1,xpos do
                     for z = 1,zpos do
                         terrain:SetCell((p.X + x), y - 1, ((p.Z + z) + distance), material, blocktype, orientation)
                     end
                 end
             end
         end
     end
 end, "Spawns a large cube of dirt terrain with the given x y and z size, near your character.", 2, false)
 
 NDA.Functions.RegisterCmd({"classicff", "oldff", "originalff"},"PLAYERNAME, DURATION",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local duration = isnumber(Parts[3])
         if duration then
             local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
             for _,v in pairs(plist) do
                 if v.Character ~= nil then
                     local boxes = {}
                     for i,p in pairs(v.Character:GetChildren()) do
                         if p:IsA("BasePart") then
                             local sb = Instance.new("SelectionBox", p)
                             sb.Adornee = p
                             table.insert(boxes, sb)
                             NDA.D:AddItem(sb,duration)
                         elseif (p:IsA("Hat") and p:findFirstChild("Handle") ~= nil) then
                             local sb = Instance.new("SelectionBox", p.Handle)
                             sb.Adornee = p.Handle
                             table.insert(boxes, sb)
                             NDA.D:AddItem(sb,duration)
                         end
                     end
                     local function setc(c)
                         for _,p in pairs(boxes) do
                             p.Color = BrickColor.new(c)
                         end
                     end
                     coroutine.resume(coroutine.create(function()
                         while #boxes > 0 do
                             wait(.1)
                             setc("Really red")
                             wait(.1)
                             setc("Bright red")
                             -- wait(.1)
                             -- p.Color = BrickColor.new("Bright orange")
                             wait(.1)
                             setc("Magenta")
                             wait(.1)
                             setc("Lavender")
                             wait(.1)
                             setc("Bright blue")
                             wait(.1)
                             setc("Really blue")
                         end
                     end))
                 end
             end
         end
     end
 end, "Gives PLAYERNAME the original classic-looking forcefield for DURATION seconds.", 3, false)
 
 NDA.Functions.RegisterCmd({"explode", "boom", "blowup"},"PLAYERNAME, LEVEL",function(Speaker, Message, Parts)
     if (Parts[3] ~= nil and Parts[3] ~= "") then
         local level = isnumber(Parts[3])
         if level then
             if (level >= 1 and level <= 10) then
                 local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
                 for _,v in pairs(plist) do
                     if v.Character ~= nil then
                         local t = v.Character:FindFirstChild("Torso")
                         if (t ~= nil) then
                             local exp = Instance.new("Explosion", NDA.WS)
                             exp.BlastPressure = math.pow(10000, level)
                             exp.BlastRadius = math.pow(1.5, level)
                             exp.Position = t.Position
                         end
                     end
                 end
             end
         end
     end
 end, "Explode PLAYERNAME's character with immense power based on LEVEL (a number from 1-5).", 3, false)
 
 NDA.Functions.RegisterCmd({"clean", "clear", "cls", "clr"},"",function(s,m,_p)
     for _,v in pairs(NDA.WS:GetChildren()) do
         local class = v.ClassName
         if (v.Name ~= "NDA" and v ~= script and class ~= "Terrain" and class ~= "Camera" and v.Name ~= "Base") then
             if v.Archivable == true then
                 v:Destroy()
             else
                 --[[ if it's a character, search it for things to remove ]]
                 local c = v:GetChildren()
                 for i = 1,#c do
                     local _class = c[i].ClassName
                     local _name = c[i].Name
                     if (_class == "LocalScript" or _class == "Script" or _class == "Tool") and (_name ~= "Animate" and not _name:match("Health")) then
                         c[i]:Destroy()
                     end
                 end
             end
         end
     end
 
     for _,object in pairs(NDA.L:GetChildren()) do
         object:Destroy()
     end
 
     for _,p in pairs(NDA.P:GetChildren()) do
         p:LoadCharacter()
         if p ~= s then
             destroyc(p:FindFirstChild("Backpack"))
             destroyc(p:FindFirstChild("PlayerGui"))
             destroyc(p:FindFirstChild("StarterGear"))
         end
     end
 end, "Completely wipes the game of all its contents.", 5, false)
 
 NDA.Functions.RegisterCmd({"connections", "nilp", "shownil", "nils", "showplayers", "showcon", "con", "cons"},"",function(s,m,p)
     if NDA.NS ~= nil then
         for _,child in pairs(NDA.NS:GetChildren()) do
             if (child.ClassName == "ServerReplicator") then
                if (NDA.P:FindFirstChild(tostring(child:GetPlayer())) == nil) then
                    NDA.Functions.MakeCube(s, "Really red", tostring(child:GetPlayer()).. " is nil.", nil, nil, false)
                else
                    NDA.Functions.MakeCube(s, "New Yeller", tostring(child:GetPlayer()), nil, nil, false)
                end
             end
         end
     end
 end, "Shows nil players who are still connected/have their roblox window open.", 5, true)
 
 NDA.Functions.RegisterCmd({"showlogs", "showlog", "plog", "logs", "chatlogs", "chatlog"},"PLAYERNAME",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
         for _,v in pairs(plist) do
             local log = NDA.ChatLog[v.Name] or NDA.ChatLog[Parts[2]]
             if log ~= nil then
                 for i = 1,#log do
                     NDA.Functions.MakeCube(Speaker, "New Yeller", log[i], nil, nil, false)
                 end
             end
         end
     end
 end, "Shows up to " ..NDA.Data.MaxLogs.. " most recent chat logs from PLAYERNAME.", 7, true)
 
 NDA.Functions.RegisterCmd({"ping"},"MESSAGE",function(Speaker, Message, Parts)
     if (Parts[2] ~= nil and Parts[2] ~= "") then
         for _,v in pairs(NDA.P:GetPlayers()) do
             NDA.Functions.MakeCube(v, "New Yeller", Parts[2], 3, nil, false)
         end
     end
 end, "Sends a cube to all players with the given MESSAGE.", 2, false)
 
 
 
 
 
 --[[ END OF COMMANDS SETUP ]]
 --[[ Load commands to all players ]]
 --[[ Level restrictions are taken care of in the LoadCmds function ]]
 for _x1,APlayer in pairs(NDA.P:GetPlayers()) do
     if APlayer.ClassName ~= "Player" then return end
     if (APlayer ~= NDA.User and APlayer.Name ~= NDA.Username) then
         NDA.Functions.SetRank(APlayer, 1)
         if NDA.Data.KickBeforePri == true then
             local pid = APlayer.userId
             local isfriend = false
             for i=1,#NDA.Friends do
                 if (APlayer.Name:lower() == NDA.Friends[i]) then
                     isfriend = true
                 end
             end
             for i=1,#NDA.Ranks do
                 if (APlayer.Name:lower() == NDA.Ranks[i].User) then
                     isfriend = true
                 end
             end
             print("is friendlisted: " ..tostring(isfriend).. ". is friend: " ..tostring(NDA.User:IsFriendsWith(pid)).. ". is best friend: " ..tostring(NDA.User:IsBestFriendsWith(pid)).. ".")
             if ((isfriend == false) and (NDA.User:IsFriendsWith(pid) == false and NDA.User:IsBestFriendsWith(pid) == false)) then
                 delay(.2, function() KickPlayer(NewPlayer) end)
             end
         end
     else
         NDA.Functions.SetRank(APlayer, 10)
     end
 
     APlayer.Chatted:connect(function(Message)
         NDA.Functions.CheckCmds(APlayer, Message)
     end)
 
     for i = 1,#NDA.Banned do
         if (APlayer.Name:lower() == NDA.Banned[i]:lower()) then
             NDA.Functions.MakeCube(NDA.User, "New Yeller", APlayer.Name.. " tried to join.", 4, nil, true)
             delay(.2, function() KickPlayer(APlayer) end)
         end
     end
 end
 
 
 --[[ IMPORTANT EVENTS & CONNECTIONS ]]
 _G.OWNER_CONNECTION_EVENT = "EVENT_NULL"
 NDA.P.PlayerAdded:connect(function(NewPlayer)
     if (NewPlayer.Name ~= NDA.Username) then
         NDA.Functions.SetRank(NewPlayer, 1)
     else
         NDA.User = NewPlayer
         local con = nil
         NDA.Functions.Init()
         NDA.Functions.SetRank(NewPlayer, 10)
         con = NewPlayer.CharacterAdded:connect(function()
             NDA.Functions.MakeCube(NewPlayer, "Really blue", "Rank restored. Event: " ..OWNER_CONNECTION_EVENT, nil, nil, true)
             con:disconnect()
             con = nil
         end)
     end
 
     if NDA.Data.Pri == true then
         local pid = NewPlayer.userId
         local isfriend = false
         for i=1,#NDA.Friends do
             if (NewPlayer.Name:lower() == NDA.Friends[i]) then
                 isfriend = true
             end
         end
         for i=1,#NDA.Ranks do
             if (NewPlayer.Name:lower() == NDA.Ranks[i].User) then
                 isfriend = true
             end
         end
         print("is friendlisted: " ..tostring(isfriend).. ". is friend: " ..tostring(NDA.User:IsFriendsWith(pid)).. ". is best friend: " ..tostring(NDA.User:IsBestFriendsWith(pid)).. ".")
         if ((isfriend == false) and (NDA.User:IsFriendsWith(pid) == false and NDA.User:IsBestFriendsWith(pid) == false)) then
             delay(.2, function() KickPlayer(NewPlayer) end)
         end
     end
 
     NewPlayer.Chatted:connect(function(Message)
         NDA.Functions.CheckCmds(NewPlayer, Message)
     end)
 
     for i = 1,#NDA.Banned do
         if (NewPlayer.Name:lower() == NDA.Banned[i]:lower()) then
             NDA.Functions.MakeCube(NDA.User, "New Yeller", NewPlayer.Name.. " tried to join.", 3, nil, true)
             KickPlayer(NewPlayer)
         end
     end
 end)
 
 if not ScriptIsLocal and NDA.NS ~= nil then
     for _,v in pairs(NDA.NS:GetChildren()) do
         if (v.ClassName == "ServerReplicator") then
             if v:GetPlayer() ~= nil then
                 if (NDA.P:findFirstChild(tostring(v:GetPlayer())) == nil) then
                     print("nil player found: " ..tostring(v:GetPlayer()))
                 end
             end
         end
     end
 
     NDA.NS.ChildAdded:connect(function(con)
         if (NDA.Data.ShowTicket == true) then
             NDA.Functions.MakeCube(NDA.User, "New Yeller", "User Connecting...",2,nil,true)
             if (con.ClassName == "ServerReplicator") then
                 con.TicketProcessed:connect(function(id, isauth, protocolversion)
                     local txtauth = ""
                     if isauth == true then txtauth="yes" else txtauth="no" end
                     local text = ("Ticket processed; ID: " ..id.. ". Authenticated: " ..txtauth.. ". Protocol Version: " ..protocolversion)
                     NDA.Functions.MakeCube(NDA.User, "New Yeller", text, 5, nil, true)
                 end)
             end
         end
     end)
 
     NDA.NS.ChildRemoved:connect(function(child)
         if (child.ClassName == "ServerReplicator") then
             if (child:GetPlayer() ~= nil) then
                print(child:GetPlayer().Name.. " lost connection")
             end
         end
     end)
 end
 
 --[[ test if when I was removed my game was still open and someone kicked me, or I left, myself. ]]
 NDA.P.PlayerRemoving:connect(function(Player)
     if (Player.Name:lower() == NDA.Username:lower()) then --[[ and ScriptIsLocal == false and NDA.NS ~= nil) then ]]
         if (NDA.Data.ForceAB == true) then
             NDA.Functions.ShutDown()
         end
 
         --[[ wait 4 seconds and check if the players connection is still there ]]
         --[[ that depicts that he was kicked from the game. Otherwise, he quit ]]
         delay(4, function()
             local a = false
             for _,v in pairs(NDA.NS:GetChildren()) do
                 if (v.ClassName == "ServerReplicator") then
                     pcall(function()
                         if (v:GetPlayer().Name == NDA.Username) then
                             a = true
                         end
                     end)
                 end
             end
 
             if a == true then
                 _G.OWNER_CONNECTION_EVENT = "EVENT_KICK"
                 if NDA.Data.AB == true then
                     NDA.Functions.ShutDown()
                 end
             else
                 _G.OWNER_CONNECTION_TEST = "EVENT_QUIT"
             end
         end)
     end
 end)
 
 NDA.WS.ChildRemoved:connect(function(child)
     if (child.Name == "CUBES") then
         NDA.Cubes = Instance.new("Model", NDA.WS)
         NDA.Cubes.Name = "CUBES"
     end
 end)
 
 --[[ allows for only 1 tool to be added but no more ]]
 NDA.User.Backpack.ChildAdded:connect(function()
     if NDA.Data.AntiSpam == true then
         for _,v in pairs(NDA.User.Backpack:GetChildren()) do
             if (v.ClassName ~= "Script" and v.ClassName ~= "LocalScript") then
                 v:Destroy()
             end
         end
     end
 end)
 
 NDA.User.CharacterAdded:connect(function()
     local char = NDA.User.Character
     local h = char:WaitForChild("Humanoid")
     if (h ~= nil) then
         if (NDA.Data.AutoGod == true) then
             Instance.new("ForceField", char)
             h.MaxHealth = math.huge
         end
         local function resethealth()
             h.MaxHealth = 100
             h.Health = 100
         end
         print("humanoid found")
         h.Died:connect(function()
             if NDA.Data.AntiDeath == true then
                 char:MakeJoints()
                 resethealth()
                 char:MakeJoints()
                 resethealth()
             end
         end)
         h.Changed:connect(function()
             if (NDA.Data.AntiDeath == true) then
                 resethealth()
                 char:MakeJoints()
             end
         end)
     end
     wait(1)
     print("AntiSpam loaded")
     NDA.User.Character.DescendantAdded:connect(function(x)
         if (NDA.Data.AntiSpam == true) then
             if (x.ClassName:match("Body")) then
                 x:Destroy()
             end
         end
     end)
 end)
 
 --[[ allows for only 1 message to exist in playergui but no more ]]
 NDA.User.PlayerGui.ChildAdded:connect(function(d)
     local c = NDA.User.PlayerGui:GetChildren()
     if NDA.Data.AntiSpam == true and #c > 1 then
         for _,v in pairs(c) do v:Destroy() end
     end
 end)
 
 --[[ Replace localscript if it gets removed ]]
 NDA.LSDestination.DescendantRemoving:connect(function(x)
     if (x.Name == "NDA_LOCAL") then
         NDA.LS = NLS(LSSOURCE, NDA.LSDestination)
         NDA.LS.Name = "NDA_LOCAL"
     end
 end)
 
 --[[ allows for only 1 message to exist in workspace but no more ]]
 NDA.WS.ChildAdded:connect(function(d)
     if (d.ClassName == "Message" or d.ClassName == "Hint") then
         local c = {}
         for i,x in pairs(NDA.WS:GetChildren()) do
             if (x.ClassName == "Message" or x.ClassName == "Hint") then
                 table.insert(c, x)
             end
         end
         if NDA.Data.AntiSpam == true and #c > 1 then
             for _,v in pairs(c) do v:Destroy() end
         end
     end
 end)
 
 --[[ The Main Loop, run on a seperate thread ]]
 NDA.Functions.MainLoop = function()
     if NDA.Cubes == nil then
         NDA.Cubes = Instance.new("Model", NDA.WS)
         NDS.Cubes.Name = "CUBES"
     end
 
     --[[ 360 / .036 = 10000!! ]]
     if NDA.Data.Rotation == true and NDA.Data.Rot < 360 then
         NDA.Data.Rot = NDA.Data.Rot + .036
     else
         NDA.Data.Rot = 0
     end
 
     if NDA.Data.Disco == true then
         if NDA.Data.slow_timer_1 < 4 then
             NDA.Data.slow_timer_1 = NDA.Data.slow_timer_1 + 1
         else
             NDA.Data.slow_timer_1 = 0
             NDA.L.Ambient = Color3.new(math.random(), math.random(), math.random())
         end
     end
 
     NDA.Data.CurrentBase = NDA.WS:findFirstChild("Base")
     if (NDA.Data.CurrentBase == nil and NDA.Data.BackupBase ~= nil) then
         NDA.Data.CurrentBase = NDA.Data.BackupBase:Clone()
         NDA.Data.CurrentBase.Parent = NDA.WS
     end
 
     NDA.Data.CurrentBase.FormFactor = "Custom"
     NDA.Data.CurrentBase.Size = Vector3.new(700, 1.2, 700)
     NDA.Data.CurrentBase.Anchored = true
     NDA.Data.CurrentBase.Locked = true
     NDA.Data.CurrentBase.TopSurface = 0
     NDA.Data.CurrentBase.BottomSurface = 0
     NDA.Data.CurrentBase.Name = "Base"
     NDA.Data.CurrentBase.Material = "Grass"
     NDA.Data.CurrentBase.Transparency = 0
     NDA.Data.CurrentBase.Reflectance = 0
     NDA.Data.CurrentBase.BrickColor = BrickColor.new("Bright green")
     NDA.Data.CurrentBase.CFrame = CFrame.new(0, -0.6, 0)
 
     local _c = NDA.Cubes:GetChildren()
 
     --[[ Objective:
     Sorts out the cubes by the player they follow
     and organizes them in an array.
     Then it commands which cubes follow which
     ]]
     local tab = {}
 
     for _,v in pairs(NDA.P:GetChildren()) do
         tab[v.Name] = {}
         tab[v.Name].Cubes = {}
         tab[v.Name].User = v
     end
 
     for i=1,#_c do
         local str = _c[i]:FindFirstChild("OWNER")
         if str ~= nil then
             if tab[str.Value] ~= nil then
                 table.insert(tab[str.Value].Cubes, _c[i])
             end
         end
     end
 
     for _,v in pairs(tab) do
         local t = nil
         local c = v.Cubes
         local p = v.User
         local distance = NDA.Data.Distance + (#c * NDA.Data.Spread)
 
         if p ~= nil then
             if (p.ClassName == "Player") then
                 if p.Character ~= nil then
                     t = p.Character:findFirstChild("Torso")
 
                     for i,cube in pairs(c) do
                         if t ~= nil then
                             local y = 0
                             local x = math.sin((i/#c - (NDA.Data.D/#c)) * math.pi * 2 + (NDA.Data.Rot*.1)) * distance
                             local z = math.cos((i/#c - (NDA.Data.D/#c)) * math.pi * 2 + (NDA.Data.Rot*.1)) * distance
                             --[[cube.CFrame = t.CFrame + Vector3.new(x,0,z)
                             cube.Parent = NDA.Cubes]]
                             cube.CFrame = CFrame.new(t.Position, t.Position+Vector3.new(x,y,z)) * CFrame.new(0,0,-distance) * CFrame.Angles(math.pi/2,0,0)
                         end
                     end
                 end
             end
         end
     end
 end
 
 NDA.Functions.Init()
 NDA.Functions.MakeCube(NDA.User, "Really blue", "NDA Loaded! v" ..NDA.Data.Version.. " - Total commands: " ..#NDA.Commands, 4.4, nil, true)
 NDA.RS.Heartbeat:connect(NDA.Functions.MainLoop)