public void Permission(CommandInfo cmd)
        {
            string lower;
            Dictionary<string, int> strs;
            int num;
            string str;
            int num1;
            Player player = cmd.Player;
            Permission permissions = Server.Permissions;
            if (Player.IsLocalClient)
            {
                return;
            }
            string[] args = cmd.Args;
            if ((int)args.Length == 1)
            {
                lower = args[0].ToLower();
                if (lower != null)
                {
                    if (CoreCommandHandler.<>f__switch$map7 == null)
                    {
                        strs = new Dictionary<string, int>(3)
                        {
                            { "reload", 0 },
                            { "users", 1 },
                            { "groups", 2 }
                        };
                        CoreCommandHandler.<>f__switch$map7 = strs;
                    }
                    if (CoreCommandHandler.<>f__switch$map7.TryGetValue(lower, out num))
                    {
                        switch (num)
                        {
                            case 0:
                            {
                                if (!permissions.Load())
                                {
                                    player.SendError("Unable to load the permission config. Was not reloaded.");
                                    return;
                                }
                                player.SendMessage("Permissions reloaded.");
                                break;
                            }
                            case 1:
                            {
                                StringBuilder stringBuilder = new StringBuilder();
                                stringBuilder.AppendLine("Users:");
                                List<PermissionUser> users = permissions.GetUsers();
                                int count = users.Count - 1;
                                for (int i = 0; i < users.Count; i++)
                                {
                                    PermissionUser item = users[i];
                                    if (item.Name.Length > 0)
                                    {
                                        stringBuilder.AppendFormat("[555555]{0}[-]", item.Name);
                                        if (i < count)
                                        {
                                            stringBuilder.Append(", ");
                                        }
                                        if (i + 1 == 0)
                                        {
                                            stringBuilder.AppendLine();
                                        }
                                    }
                                }
                                if (users.Count <= 0)
                                {
                                    player.SendError("No users are defined.");
                                }
                                else
                                {
                                    player.SendMessage(stringBuilder.ToString());
                                }
                                break;
                            }
                            case 2:
                            {
                                StringBuilder stringBuilder1 = new StringBuilder();
                                stringBuilder1.AppendLine("Groups:");
                                List<PermissionGroup> groups = permissions.GetGroups();
                                int count1 = groups.Count - 1;
                                for (int j = 0; j < groups.Count; j++)
                                {
                                    PermissionGroup permissionGroup = groups[j];
                                    if (permissionGroup.Name.Length > 0)
                                    {
                                        stringBuilder1.AppendFormat("[555555]{0}[-]", permissionGroup.Name);
                                        if (j < count1)
                                        {
                                            stringBuilder1.Append(", ");
                                        }
                                        if (j == 0)
                                        {
                                            stringBuilder1.AppendLine();
                                        }
                                    }
                                }
                                if (groups.Count <= 0)
                                {
                                    player.SendError("No groups are defined.");
                                }
                                else
                                {
                                    player.SendMessage(stringBuilder1.ToString());
                                }
                                break;
                            }
                        }
                    }
                }
            }
            else if ((int)args.Length == 2)
            {
                lower = args[0].ToLower();
                if (lower != null)
                {
                    if (CoreCommandHandler.<>f__switch$map8 == null)
                    {
                        strs = new Dictionary<string, int>(2)
                        {
                            { "user", 0 },
                            { "group", 1 }
                        };
                        CoreCommandHandler.<>f__switch$map8 = strs;
                    }
                    if (CoreCommandHandler.<>f__switch$map8.TryGetValue(lower, out num))
                    {
                        if (num == 0)
                        {
                            string str1 = args[1];
                            int num2 = 0;
                            string str2 = string.Concat(str1, "'s Permissions:\n");
                            PermissionUser user = permissions.GetUser(str1);
                            if (user == null)
                            {
                                player.SendError(string.Concat("'", str1, "' does not exist."));
                            }
                            else
                            {
                                List<string> permissions1 = user.GetPermissions();
                                for (int k = 0; k < permissions1.Count; k++)
                                {
                                    str2 = string.Concat(str2, "- '[555555]", permissions1[k], "[-]'\n");
                                    num2++;
                                }
                                if (num2 <= 0)
                                {
                                    player.SendError(string.Concat("'", str1, "' does not have permissions."));
                                }
                                else
                                {
                                    str2 = str2.Trim(new char[] { '\n' });
                                    player.SendMessage(str2);
                                }
                            }
                        }
                        else if (num == 1)
                        {
                            string str3 = args[1];
                            int num3 = 0;
                            string str4 = string.Concat(str3, "'s Permissions:\n");
                            PermissionGroup group = permissions.GetGroup(str3);
                            if (group == null)
                            {
                                player.SendError(string.Concat("'", str3, "' does not exist."));
                            }
                            else
                            {
                                List<string> strs1 = group.GetPermissions(true);
                                for (int l = 0; l < strs1.Count; l++)
                                {
                                    str4 = string.Concat(str4, "- '[555555]", strs1[l], "[-]'\n");
                                    num3++;
                                }
                                if (num3 <= 0)
                                {
                                    player.SendError(string.Concat("'", str3, "' has no permissions."));
                                }
                                else
                                {
                                    str4 = str4.Trim(new char[] { '\n' });
                                    player.SendMessage(str4);
                                }
                            }
                        }
                    }
                }
            }
            else if ((int)args.Length == 3)
            {
                lower = args[0].ToLower();
                if (lower != null)
                {
                    if (CoreCommandHandler.<>f__switch$mapB == null)
                    {
                        strs = new Dictionary<string, int>(2)
                        {
                            { "user", 0 },
                            { "group", 1 }
                        };
                        CoreCommandHandler.<>f__switch$mapB = strs;
                    }
                    if (CoreCommandHandler.<>f__switch$mapB.TryGetValue(lower, out num))
                    {
                        if (num == 0)
                        {
                            str = args[2].ToLower();
                            if (str != null)
                            {
                                if (CoreCommandHandler.<>f__switch$map9 == null)
                                {
                                    strs = new Dictionary<string, int>(2)
                                    {
                                        { "add", 0 },
                                        { "remove", 1 }
                                    };
                                    CoreCommandHandler.<>f__switch$map9 = strs;
                                }
                                if (CoreCommandHandler.<>f__switch$map9.TryGetValue(str, out num1))
                                {
                                    if (num1 == 0)
                                    {
                                        string str5 = args[1];
                                        if (!permissions.AddUser(str5))
                                        {
                                            player.SendError("Unable to add user. Does it already exist?");
                                            return;
                                        }
                                        permissions.Save();
                                        player.SendMessage(string.Concat("'", str5, "' has been added."));
                                    }
                                    else if (num1 == 1)
                                    {
                                        string str6 = args[1];
                                        if (!permissions.RemoveUser(str6))
                                        {
                                            player.SendError("Unable to remove user. Does it even exist?");
                                            return;
                                        }
                                        permissions.Save();
                                        player.SendMessage(string.Concat("'", str6, "' has been removed."));
                                    }
                                }
                            }
                        }
                        else if (num == 1)
                        {
                            str = args[2].ToLower();
                            if (str != null)
                            {
                                if (CoreCommandHandler.<>f__switch$mapA == null)
                                {
                                    strs = new Dictionary<string, int>(3)
                                    {
                                        { "add", 0 },
                                        { "remove", 1 },
                                        { "makedefault", 2 }
                                    };
                                    CoreCommandHandler.<>f__switch$mapA = strs;
                                }
                                if (CoreCommandHandler.<>f__switch$mapA.TryGetValue(str, out num1))
                                {
                                    switch (num1)
                                    {
                                        case 0:
                                        {
                                            string str7 = args[1];
                                            if (!permissions.AddGroup(str7, false))
                                            {
                                                player.SendError("Unable to add group. Does it already exist?");
                                                return;
                                            }
                                            permissions.Save();
                                            player.SendMessage(string.Concat("'", str7, "' has been added."));
                                            break;
                                        }
                                        case 1:
                                        {
                                            string str8 = args[1];
                                            if (!permissions.RemoveGroup(str8))
                                            {
                                                player.SendError("Unable to remove group. Does it even exist?");
                                                return;
                                            }
                                            permissions.Save();
                                            player.SendMessage("'{0}' has been removed.", new object[] { str8 });
                                            break;
                                        }
                                        case 2:
                                        {
                                            string str9 = args[1];
                                            if (args[1].IsNullEmptyOrWhite() || permissions.GetGroup(str9) == null)
                                            {
                                                PlayerExtensions.SendError(player, "'{0}' is not a group.", new object[] { args[1] });
                                                return;
                                            }
                                            if (permissions.DefaultGroup.Name.EqualsIgnoreCase(args[1]))
                                            {
                                                PlayerExtensions.SendError(player, "{0} is already the default group.", new object[] { permissions.DefaultGroup.Name });
                                                return;
                                            }
                                            if (!permissions.SetDefaultGroup(str9))
                                            {
                                                PlayerExtensions.SendError(player, "Could not make '{0}' the default group.", new object[] { args[1] });
                                                return;
                                            }
                                            permissions.Save();
                                            Server.UpdatePlayerData();
                                            player.SendMessage("'{0}' is now the default group.");
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else if ((int)args.Length >= 4)
            {
                lower = args[0].ToLower();
                if (lower != null)
                {
                    if (CoreCommandHandler.<>f__switch$mapE == null)
                    {
                        strs = new Dictionary<string, int>(2)
                        {
                            { "user", 0 },
                            { "group", 1 }
                        };
                        CoreCommandHandler.<>f__switch$mapE = strs;
                    }
                    if (CoreCommandHandler.<>f__switch$mapE.TryGetValue(lower, out num))
                    {
                        if (num == 0)
                        {
                            str = args[2];
                            if (str != null)
                            {
                                if (CoreCommandHandler.<>f__switch$mapC == null)
                                {
                                    strs = new Dictionary<string, int>(7)
                                    {
                                        { "add", 0 },
                                        { "remove", 1 },
                                        { "addgroup", 2 },
                                        { "removegroup", 3 },
                                        { "setprimary", 4 },
                                        { "chatformat", 5 },
                                        { "nameformat", 6 }
                                    };
                                    CoreCommandHandler.<>f__switch$mapC = strs;
                                }
                                if (CoreCommandHandler.<>f__switch$mapC.TryGetValue(str, out num1))
                                {
                                    switch (num1)
                                    {
                                        case 0:
                                        {
                                            string str10 = args[1];
                                            string str11 = args[3];
                                            bool flag = permissions.AddUser(str10);
                                            if (!permissions.GetUser(str10).AddPermission(str11))
                                            {
                                                if (flag)
                                                {
                                                    permissions.RemoveUser(str10);
                                                }
                                                player.SendError(string.Concat(new string[] { "Could not add '", str11, "' for ", str10, "." }));
                                                return;
                                            }
                                            permissions.Save();
                                            Player playerByName = Server.GetPlayerByName(str10);
                                            if (playerByName != null)
                                            {
                                                Server.UpdatePlayerData(playerByName);
                                            }
                                            player.SendMessage(string.Concat(new string[] { "'", str11, "' added to ", str10, "'s permissions." }));
                                            break;
                                        }
                                        case 1:
                                        {
                                            string str12 = args[1];
                                            string str13 = args[3];
                                            bool flag1 = permissions.AddUser(str12);
                                            if (!permissions.GetUser(str12).RemovePermission(str13))
                                            {
                                                if (flag1)
                                                {
                                                    permissions.RemoveUser(str12);
                                                }
                                                player.SendError(string.Concat(new string[] { "Could not remove '", str13, "' for ", str12, ". Did it even exist?" }));
                                                return;
                                            }
                                            permissions.Save();
                                            Player playerByName1 = Server.GetPlayerByName(str12);
                                            if (playerByName1 != null)
                                            {
                                                Server.UpdatePlayerData(playerByName1);
                                            }
                                            player.SendMessage(string.Concat(new string[] { "'", str13, "' removed from ", str12, "'s permissions." }));
                                            break;
                                        }
                                        case 2:
                                        {
                                            string str14 = args[1];
                                            string str15 = args[3];
                                            PermissionGroup group1 = permissions.GetGroup(str15);
                                            if (group1 == null)
                                            {
                                                PlayerExtensions.SendError(player, "The {0} group does not exist.", new object[] { str15 });
                                                return;
                                            }
                                            bool flag2 = permissions.AddUser(str14);
                                            if (!permissions.GetUser(str14).AddGroup(group1))
                                            {
                                                if (flag2)
                                                {
                                                    permissions.RemoveUser(str14);
                                                }
                                                player.SendError(string.Concat(new string[] { "Could not add ", str14, " to ", str15, ". Does it even exist?" }));
                                                return;
                                            }
                                            permissions.Save();
                                            Player player1 = Server.GetPlayerByName(str14);
                                            if (player1 != null)
                                            {
                                                Server.UpdatePlayerData(player1);
                                            }
                                            player.SendMessage(string.Concat(new string[] { "'", str14, "' has been added to '", str15, "'." }));
                                            break;
                                        }
                                        case 3:
                                        {
                                            string str16 = args[1];
                                            string str17 = args[3];
                                            PermissionGroup permissionGroup1 = permissions.GetGroup(str17);
                                            if (permissionGroup1 == null)
                                            {
                                                PlayerExtensions.SendError(player, "The {0} group does not exist.", new object[] { str17 });
                                                return;
                                            }
                                            bool flag3 = permissions.AddUser(str16);
                                            if (!permissions.GetUser(str16).RemoveGroup(permissionGroup1.Name))
                                            {
                                                if (flag3)
                                                {
                                                    permissions.RemoveUser(str16);
                                                }
                                                player.SendError(string.Concat(new string[] { "Could not remove ", str16, " from ", str17, ". Does it even exist?" }));
                                                return;
                                            }
                                            permissions.Save();
                                            Player playerByName2 = Server.GetPlayerByName(str16);
                                            if (playerByName2 != null)
                                            {
                                                Server.UpdatePlayerData(playerByName2);
                                            }
                                            player.SendMessage(string.Concat(new string[] { "'", str16, "' has been removed from '", str17, "'." }));
                                            break;
                                        }
                                        case 4:
                                        {
                                            string str18 = args[1];
                                            string str19 = args[3];
                                            bool flag4 = permissions.AddUser(str18);
                                            PermissionUser permissionUser = permissions.GetUser(str18);
                                            if (permissionUser == null)
                                            {
                                                if (flag4)
                                                {
                                                    permissions.RemoveUser(str18);
                                                }
                                                PlayerExtensions.SendError(player, "Unable to find user '{0}'.", new object[] { str18 });
                                                return;
                                            }
                                            PermissionGroup group2 = permissions.GetGroup(str19);
                                            if (group2 == null)
                                            {
                                                if (flag4)
                                                {
                                                    permissions.RemoveUser(str18);
                                                }
                                                PlayerExtensions.SendError(player, "Unable to find group '{0}'.", new object[] { str19 });
                                                return;
                                            }
                                            if (!permissionUser.MakePrimaryGroup(group2))
                                            {
                                                if (flag4)
                                                {
                                                    permissions.RemoveUser(str18);
                                                }
                                                PlayerExtensions.SendError(player, "Could not make '{0}' '{1}'s primary group.", new object[] { group2.Name, permissionUser.Name });
                                                return;
                                            }
                                            permissions.Save();
                                            Player player2 = Server.GetPlayerByName(str18);
                                            if (player2 != null)
                                            {
                                                Server.UpdatePlayerData(player2);
                                            }
                                            player.SendMessage("'{0}' is now '{1}'s primary group.", new object[] { group2.Name, permissionUser.Name });
                                            break;
                                        }
                                        case 5:
                                        {
                                            string str20 = args[1];
                                            string str21 = string.Join(" ", args, 3, (int)args.Length - 3);
                                            bool flag5 = permissions.AddUser(str20);
                                            PermissionUser user1 = permissions.GetUser(str20);
                                            if (str21.IsNullEmptyOrWhite())
                                            {
                                                if (flag5)
                                                {
                                                    permissions.RemoveUser(str20);
                                                }
                                                player.SendError("'{0}' is an invalid chat format.");
                                                return;
                                            }
                                            if (!str21.ToLower().Contains("%message%"))
                                            {
                                                if (flag5)
                                                {
                                                    permissions.RemoveUser(str20);
                                                }
                                                player.SendError("The chat format must contain the %message% variable.");
                                                return;
                                            }
                                            if (!str21.ToLower().Contains("%name%"))
                                            {
                                                if (flag5)
                                                {
                                                    permissions.RemoveUser(str20);
                                                }
                                                player.SendError("The chat format must contain the %name% variable.");
                                                return;
                                            }
                                            if (user1 == null)
                                            {
                                                PlayerExtensions.SendError(player, "User '{0}' not found.", new object[] { user1.Name });
                                                return;
                                            }
                                            if (!user1.SetChatFormat(str21))
                                            {
                                                if (flag5)
                                                {
                                                    permissions.RemoveUser(str20);
                                                }
                                                PlayerExtensions.SendError(player, "Could not set '{0}'s chat format to '{1}'.", new object[] { user1.Name, str21 });
                                                return;
                                            }
                                            permissions.Save();
                                            Player playerByName3 = Server.GetPlayerByName(str20);
                                            if (playerByName3 != null)
                                            {
                                                Server.UpdatePlayerData(playerByName3);
                                            }
                                            player.SendMessage("'{0}'s chat format was changed to '{1}'.", new object[] { user1.Name, str21 });
                                            break;
                                        }
                                        case 6:
                                        {
                                            string str22 = args[1];
                                            string str23 = string.Join(" ", args, 3, (int)args.Length - 3);
                                            permissions.AddUser(str22);
                                            PermissionUser permissionUser1 = permissions.GetUser(str22);
                                            if (str23.IsNullEmptyOrWhite())
                                            {
                                                player.SendError("'{0}' is an invalid name format.");
                                                return;
                                            }
                                            if (!str23.ToLower().Contains("%name%"))
                                            {
                                                player.SendError("The name format must contain the %name% variable.");
                                                return;
                                            }
                                            if (permissionUser1 == null)
                                            {
                                                PlayerExtensions.SendError(player, "User '{0}' not found.", new object[] { permissionUser1.Name });
                                                return;
                                            }
                                            if (!permissionUser1.SetNameFormat(str23))
                                            {
                                                PlayerExtensions.SendError(player, "Could not set '{0}'s name format to '{1}'.", new object[] { permissionUser1.Name, str23 });
                                                return;
                                            }
                                            permissions.Save();
                                            Player player3 = Server.GetPlayerByName(str22);
                                            if (player3 != null)
                                            {
                                                Server.UpdatePlayerData(player3);
                                            }
                                            player.SendMessage("'{0}'s name format was changed to '{1}'.", new object[] { permissionUser1.Name, str23 });
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                        else if (num == 1)
                        {
                            str = args[2].ToLower();
                            if (str != null)
                            {
                                if (CoreCommandHandler.<>f__switch$mapD == null)
                                {
                                    strs = new Dictionary<string, int>(5)
                                    {
                                        { "add", 0 },
                                        { "remove", 1 },
                                        { "inherit", 2 },
                                        { "chatformat", 3 },
                                        { "nameformat", 4 }
                                    };
                                    CoreCommandHandler.<>f__switch$mapD = strs;
                                }
                                if (CoreCommandHandler.<>f__switch$mapD.TryGetValue(str, out num1))
                                {
                                    switch (num1)
                                    {
                                        case 0:
                                        {
                                            string str24 = args[1];
                                            string str25 = args[3];
                                            PermissionGroup permissionGroup2 = permissions.GetGroup(str24);
                                            if (permissionGroup2 == null)
                                            {
                                                PlayerExtensions.SendError(player, "'{0}' group not found.", new object[] { str24 });
                                                return;
                                            }
                                            if (!permissionGroup2.AddPermission(str25))
                                            {
                                                player.SendError(string.Concat(new string[] { "Could not add '", str25, "' for ", str24, "." }));
                                                return;
                                            }
                                            permissions.Save();
                                            Server.UpdatePlayerData();
                                            player.SendMessage(string.Concat(new string[] { "'", str25, "' added to ", str24, "'s permissions." }));
                                            break;
                                        }
                                        case 1:
                                        {
                                            string str26 = args[1];
                                            string str27 = args[3];
                                            PermissionGroup group3 = permissions.GetGroup(str26);
                                            if (group3 == null)
                                            {
                                                PlayerExtensions.SendError(player, "'{0}' group not found.", new object[] { str26 });
                                                return;
                                            }
                                            if (!group3.RemovePermission(str27))
                                            {
                                                player.SendError(string.Concat(new string[] { "Could not remove '", str27, "' for ", str26, ". Did it even exist?" }));
                                                return;
                                            }
                                            permissions.Save();
                                            Server.UpdatePlayerData();
                                            player.SendMessage(string.Concat(new string[] { "'", str27, "' removed from ", str26, "'s permissions." }));
                                            break;
                                        }
                                        case 2:
                                        {
                                            string str28 = args[1];
                                            string str29 = args[3];
                                            if (str28.IsNullEmptyOrWhite() || str29.IsNullEmptyOrWhite())
                                            {
                                                PlayerExtensions.SendError(player, "'{0}' cannot inherit from '{1}'.", new object[] { str28, str29 });
                                                return;
                                            }
                                            if (str28.EqualsIgnoreCase(str29))
                                            {
                                                PlayerExtensions.SendError(player, "'{0}' cannot inherit from '{1}'.", new object[] { str28, str29 });
                                                return;
                                            }
                                            if (!permissions.MakeGroupInherit(str28, str29))
                                            {
                                                PlayerExtensions.SendError(player, "Could not make '{0}' inherit from '{1}'.", new object[] { str28, str29 });
                                                return;
                                            }
                                            permissions.Save();
                                            Server.UpdatePlayerData();
                                            player.SendMessage("'{0}' now inherits '{1}'", new object[] { str28, str29 });
                                            break;
                                        }
                                        case 3:
                                        {
                                            string str30 = args[1];
                                            string str31 = string.Join(" ", args, 3, (int)args.Length - 3);
                                            PermissionGroup permissionGroup3 = permissions.GetGroup(str30);
                                            if (permissionGroup3 == null)
                                            {
                                                PlayerExtensions.SendError(player, "Group '{0}' not found.", new object[] { str30 });
                                                return;
                                            }
                                            if (str31.IsNullEmptyOrWhite())
                                            {
                                                PlayerExtensions.SendError(player, "Invalid chat format '{0}'.", new object[] { str31 });
                                                return;
                                            }
                                            if (!str31.ToLower().Contains("%message%"))
                                            {
                                                player.SendError("The chat format must contain the %message% variable.");
                                                return;
                                            }
                                            if (!str31.ToLower().Contains("%name%"))
                                            {
                                                player.SendError("The chat format must contain the %name% variable.");
                                                return;
                                            }
                                            if (!permissionGroup3.SetChatFormat(str31))
                                            {
                                                PlayerExtensions.SendError(player, "Could not set group '{0}'s chat format to '{1}'.", new object[] { permissionGroup3.Name, str31 });
                                                return;
                                            }
                                            permissions.Save();
                                            Server.UpdatePlayerData();
                                            player.SendMessage("'{0}'s chat format was changed to '{1}'.", new object[] { permissionGroup3.Name, str31 });
                                            break;
                                        }
                                        case 4:
                                        {
                                            string str32 = args[1];
                                            string str33 = string.Join(" ", args, 3, (int)args.Length - 3);
                                            PermissionGroup group4 = permissions.GetGroup(str32);
                                            if (group4 == null)
                                            {
                                                PlayerExtensions.SendError(player, "Group '{0}' not found.", new object[] { str32 });
                                                return;
                                            }
                                            if (str33.IsNullEmptyOrWhite())
                                            {
                                                PlayerExtensions.SendError(player, "Invalid name format '{0}'.", new object[] { str33 });
                                                return;
                                            }
                                            if (!str33.ToLower().Contains("%name%"))
                                            {
                                                player.SendError("The name format must contain the %name% variable.");
                                                return;
                                            }
                                            if (!group4.SetNameFormat(str33))
                                            {
                                                PlayerExtensions.SendError(player, "Could not set group '{0}'s name format to '{1}'.", new object[] { group4.Name, str33 });
                                                return;
                                            }
                                            permissions.Save();
                                            Server.UpdatePlayerData();
                                            player.SendMessage("'{0}'s name format was changed to '{1}'.", new object[] { group4.Name, str33 });
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }