Input:
public boolean onCommand(final CommandSender sender, final Command command, final String label, final String[] split) {
    if (!(sender instanceof Player)) {
        return false;
    }
    final Player player = (Player) sender;
    if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).islanderrorYouDoNotHavePermission);
        return true;
    }
    final UUID playerUUID = player.getUniqueId();
    final UUID teamLeader = plugin.getPlayers().getTeamLeader(playerUUID);
    List<UUID> teamMembers = new ArrayList<UUID>();
    if (teamLeader != null) {
        teamMembers = plugin.getPlayers().getMembers(teamLeader);
    }
    UUID targetPlayer = null;
    switch(split.length) {
        case 0:
            if (plugin.getPlayers().getIslandLocation(playerUUID) == null && !plugin.getPlayers().inTeam(playerUUID)) {
                player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).islandnew);
                chooseIsland(player);
                return true;
            } else {
                if (Settings.useControlPanel) {
                    player.performCommand(Settings.ISLANDCOMMAND + "String_Node_Str");
                } else {
                    if (!player.getWorld().getName().equalsIgnoreCase(Settings.worldName) || Settings.allowTeleportWhenFalling || !PlayerEvents.isFalling(playerUUID) || (player.isOp() && !Settings.damageOps)) {
                        plugin.getGrid().homeTeleport(player);
                        if (Settings.islandRemoveMobs) {
                            plugin.getGrid().removeMobs(player.getLocation());
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorCommandNotReady);
                    }
                }
                return true;
            }
        case 1:
            if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (!Settings.teamChat) {
                        return false;
                    }
                    if (plugin.getPlayers().inTeam(playerUUID)) {
                        boolean online = false;
                        for (UUID teamMember : plugin.getPlayers().getMembers(playerUUID)) {
                            if (!teamMember.equals(playerUUID) && plugin.getServer().getPlayer(teamMember) != null) {
                                online = true;
                            }
                        }
                        if (!online) {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).teamChatNoTeamAround);
                            player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).teamChatStatusOff);
                            plugin.getChatListener().unSetPlayer(playerUUID);
                            return true;
                        }
                        if (plugin.getChatListener().isTeamChat(playerUUID)) {
                            player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).teamChatStatusOff);
                            plugin.getChatListener().unSetPlayer(playerUUID);
                        } else {
                            player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).teamChatStatusOn);
                            plugin.getChatListener().setPlayer(playerUUID);
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).teamChatNoTeam);
                    }
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).errorNoPermission);
                }
                return true;
            }
            if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(playerUUID).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(playerUUID).islandhelpBan);
                } else {
                    player.sendMessage(plugin.myLocale(playerUUID).errorNoPermission);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str") && VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(playerUUID).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(playerUUID).islandhelpUnban);
                } else {
                    player.sendMessage(plugin.myLocale(playerUUID).errorNoPermission);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!pendingNewIslandSelection.contains(playerUUID)) {
                    return false;
                }
                pendingNewIslandSelection.remove(playerUUID);
                Island oldIsland = plugin.getGrid().getIsland(player.getUniqueId());
                newIsland(player);
                if (resettingIsland.contains(playerUUID)) {
                    resettingIsland.remove(playerUUID);
                    resetPlayer(player, oldIsland);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage("String_Node_Str" + label + "String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                    player.sendMessage("String_Node_Str");
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).errorNoPermission);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.openInventory(SettingsPanel.islandGuardPanel());
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
                Island island = plugin.getGrid().getIsland(playerUUID);
                if (island == null) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIsland);
                    return true;
                } else {
                    if (!island.isLocked()) {
                        for (Player target : plugin.getServer().getOnlinePlayers()) {
                            if (!player.equals(target) && !target.isOp() && !VaultHelper.checkPerm(target, Settings.PERMPREFIX + "String_Node_Str") && (target.getWorld().equals(ASkyBlock.getIslandWorld()) || target.getWorld().equals(ASkyBlock.getNetherWorld())) && plugin.getGrid().isOnIsland(player, target) && !CoopPlay.getInstance().getCoopPlayers(island.getCenter()).contains(target.getUniqueId())) {
                                if (plugin.getPlayers().inTeam(target.getUniqueId()) || plugin.getPlayers().hasIsland(target.getUniqueId())) {
                                    plugin.getGrid().homeTeleport(target);
                                } else {
                                    if (!target.performCommand(Settings.SPAWNCOMMAND)) {
                                        target.teleport(player.getWorld().getSpawnLocation());
                                    }
                                }
                                target.sendMessage(ChatColor.RED + plugin.myLocale(target.getUniqueId()).expelExpelled);
                                plugin.getLogger().info(player.getName() + "String_Node_Str" + target.getName() + "String_Node_Str");
                                player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).expelSuccess.replace("String_Node_Str", target.getDisplayName()));
                            }
                        }
                        player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).lockLocking);
                        plugin.getMessages().tellOfflineTeam(playerUUID, plugin.myLocale(playerUUID).lockPlayerLocked.replace("String_Node_Str", player.getDisplayName()));
                        plugin.getMessages().tellTeam(playerUUID, plugin.myLocale(playerUUID).lockPlayerLocked.replace("String_Node_Str", player.getDisplayName()));
                        island.setLocked(true);
                    } else {
                        player.sendMessage(ChatColor.GREEN + plugin.myLocale(playerUUID).lockUnlocking);
                        plugin.getMessages().tellOfflineTeam(playerUUID, plugin.myLocale(playerUUID).lockPlayerUnlocked.replace("String_Node_Str", player.getDisplayName()));
                        plugin.getMessages().tellTeam(playerUUID, plugin.myLocale(playerUUID).lockPlayerUnlocked.replace("String_Node_Str", player.getDisplayName()));
                        island.setLocked(false);
                    }
                    return true;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!plugin.getPlayers().hasIsland(playerUUID) && !plugin.getPlayers().inTeam(playerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).errorNoIsland);
                    return true;
                }
                plugin.getGrid().homeTeleport(player);
                if (Settings.islandRemoveMobs) {
                    plugin.getGrid().removeMobs(player.getLocation());
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                player.sendMessage(ChatColor.GOLD + "String_Node_Str");
                return true;
            }
            if (split[0].equalsIgnoreCase("String_Node_Str") || split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.openInventory(ControlPanel.controlPanel.get(ControlPanel.getDefaultPanelName()));
                    return true;
                }
            }
            if (split[0].equalsIgnoreCase("String_Node_Str") || split[0].equalsIgnoreCase("String_Node_Str")) {
                if (Settings.useEconomy) {
                    if (player.getWorld().getName().equalsIgnoreCase(Settings.worldName)) {
                        if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                            player.openInventory(ControlPanel.miniShop);
                            return true;
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorWrongWorld);
                        return true;
                    }
                }
            }
            if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(ChatColor.YELLOW + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpWarp);
                    return true;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    Set<UUID> warpList = plugin.getWarpSignsListener().listWarps();
                    if (warpList.isEmpty()) {
                        player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).warpserrorNoWarpsYet);
                        if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && plugin.getGrid().playerIsOnIsland(player)) {
                            player.sendMessage(ChatColor.YELLOW + plugin.myLocale().warpswarpTip);
                        }
                        return true;
                    } else {
                        if (Settings.useWarpPanel) {
                            player.openInventory(plugin.getWarpPanel().getWarpPanel(0));
                        } else {
                            Boolean hasWarp = false;
                            String wlist = "String_Node_Str";
                            for (UUID w : warpList) {
                                if (wlist.isEmpty()) {
                                    wlist = plugin.getPlayers().getName(w);
                                } else {
                                    wlist += "String_Node_Str" + plugin.getPlayers().getName(w);
                                }
                                if (w.equals(playerUUID)) {
                                    hasWarp = true;
                                }
                            }
                            player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).warpswarpsAvailable + "String_Node_Str" + ChatColor.WHITE + wlist);
                            if (!hasWarp && (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str"))) {
                                player.sendMessage(ChatColor.YELLOW + plugin.myLocale().warpswarpTip);
                            }
                        }
                        return true;
                    }
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str") || split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!plugin.getPlayers().hasIsland(playerUUID)) {
                    player.performCommand(Settings.ISLANDCOMMAND);
                    return true;
                }
                if (plugin.getPlayers().inTeam(playerUUID)) {
                    if (!plugin.getPlayers().getTeamLeader(playerUUID).equals(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).islandresetOnlyOwner);
                    } else {
                        player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).islandresetMustRemovePlayers);
                    }
                    return true;
                }
                if (plugin.getPlayers().getResetsLeft(playerUUID) == 0) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).islandResetNoMore);
                    return true;
                }
                if (plugin.getPlayers().getResetsLeft(playerUUID) > 0) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).resetYouHave.replace("String_Node_Str", String.valueOf(plugin.getPlayers().getResetsLeft(playerUUID))));
                }
                if (!onRestartWaitTime(player) || Settings.resetWait == 0 || player.isOp()) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).islandresetConfirm.replace("String_Node_Str", String.valueOf(Settings.resetConfirmWait)));
                    if (!confirm.containsKey(playerUUID) || !confirm.get(playerUUID)) {
                        confirm.put(playerUUID, true);
                        plugin.getServer().getScheduler().runTaskLater(plugin, new Runnable() {
                            public void run() {
                                confirm.put(playerUUID, false);
                            }
                        }, (Settings.resetConfirmWait * 20));
                    }
                    return true;
                } else {
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).islandresetWait.replace("String_Node_Str", String.valueOf(getResetWaitTime(player))));
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (confirm.containsKey(playerUUID) && confirm.get(playerUUID)) {
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).islandresetPleaseWait);
                    if (plugin.getPlayers().getResetsLeft(playerUUID) == 0) {
                        player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).islandResetNoMore);
                    }
                    if (plugin.getPlayers().getResetsLeft(playerUUID) > 0) {
                        player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).resetYouHave.replace("String_Node_Str", String.valueOf(plugin.getPlayers().getResetsLeft(playerUUID))));
                    }
                    List<Schematic> schems = getSchematics(player, false);
                    Island oldIsland = plugin.getGrid().getIsland(player.getUniqueId());
                    if (schems.isEmpty()) {
                        newIsland(player);
                        resetPlayer(player, oldIsland);
                    } else if (schems.size() == 1) {
                        newIsland(player, schems.get(0));
                        resetPlayer(player, oldIsland);
                    } else {
                        if (Settings.useSchematicPanel) {
                            pendingNewIslandSelection.add(playerUUID);
                            resettingIsland.add(playerUUID);
                            player.openInventory(plugin.getSchematicsPanel().getPanel(player));
                        } else {
                            schems = getSchematics(player, true);
                            if (schems.isEmpty()) {
                                newIsland(player);
                            } else if (Settings.chooseIslandRandomly) {
                                newIsland(player, schems.get(random.nextInt(schems.size())));
                            } else {
                                newIsland(player, schems.get(0));
                            }
                            resetPlayer(player, oldIsland);
                        }
                    }
                    return true;
                } else {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpRestart);
                    return true;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    plugin.getGrid().homeSet(player);
                    return true;
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                player.sendMessage(ChatColor.GREEN + plugin.getName() + "String_Node_Str" + plugin.getDescription().getVersion() + "String_Node_Str");
                if (Settings.useControlPanel) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpControlPanel);
                } else {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpIsland);
                }
                int maxHomes = Settings.maxHomes;
                for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                    if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                        maxHomes = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
                    }
                    if (maxHomes < 1) {
                        maxHomes = 1;
                    }
                }
                if (maxHomes > 1 && VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + maxHomes + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpTeleport);
                } else {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpTeleport);
                }
                if (plugin.getGrid() != null && plugin.getGrid().getSpawn() != null) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpSpawn);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpControlPanel);
                }
                player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpRestart);
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (maxHomes > 1) {
                        player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + maxHomes + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpSetHome);
                    } else {
                        player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpSetHome);
                    }
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpLevel);
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpLevelPlayer);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpTop);
                }
                if (Settings.useEconomy && VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpMiniShop);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpWarps);
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpWarp);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpTeam);
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpInvite);
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpLeave);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpKick);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpAcceptReject);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpMakeLeader);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && plugin.getPlayers().inTeam(playerUUID)) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).teamChatHelp);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpBiome);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpExpel);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpBan);
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpUnban);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandhelpCoop);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandHelpLock);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str" + ChatColor.WHITE + plugin.myLocale(player.getUniqueId()).islandHelpSettings);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + plugin.myLocale(player.getUniqueId()).islandHelpChallenges);
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + label + "String_Node_Str");
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (teamLeader != null && !teamLeader.equals(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).levelerrornotYourIsland);
                        return true;
                    }
                    if (!plugin.getPlayers().hasIsland(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIsland);
                        return true;
                    }
                    if (!plugin.getGrid().playerIsOnIsland(player)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).challengeserrorNotOnIsland);
                        return true;
                    }
                    if (plugin.getPlayers().getIslandLocation(playerUUID).getWorld().getEnvironment().equals(Environment.NETHER)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorWrongWorld);
                        return true;
                    }
                    Inventory inv = plugin.getBiomes().getBiomePanel(player);
                    if (inv != null) {
                        player.openInventory(inv);
                    }
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str") && plugin.getGrid().getSpawn() != null) {
                Location l = ASkyBlock.getIslandWorld().getSpawnLocation();
                l.add(new Vector(0.5, 0, 0.5));
                Island spawn = plugin.getGrid().getSpawn();
                if (spawn != null && spawn.getSpawnPoint() != null) {
                    l = spawn.getSpawnPoint();
                }
                player.teleport(l);
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    TopTen.topTenShow(player);
                    return true;
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (!plugin.getPlayers().inTeam(playerUUID) && !plugin.getPlayers().hasIsland(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIsland);
                        return true;
                    } else {
                        if (Settings.fastLevelCalc) {
                            calculateIslandLevel(player, playerUUID);
                            return true;
                        } else {
                            if (plugin.getGrid().playerIsOnIsland(player)) {
                                calculateIslandLevel(player, playerUUID);
                            } else {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).challengeserrorNotOnIsland);
                            }
                            return true;
                        }
                    }
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(plugin.myLocale(player.getUniqueId()).helpColor + "String_Node_Str" + ChatColor.WHITE + "String_Node_Str" + label + "String_Node_Str" + plugin.myLocale(player.getUniqueId()).helpColor + plugin.myLocale(player.getUniqueId()).islandhelpInvite);
                    if (plugin.getPlayers().inTeam(playerUUID)) {
                        if (teamLeader.equals(playerUUID)) {
                            int maxSize = Settings.maxTeamSize;
                            for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                                if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                                    maxSize = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
                                }
                                if (maxSize < Settings.maxTeamSize) {
                                    maxSize = Settings.maxTeamSize;
                                }
                            }
                            if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                                if (Settings.maxTeamSizeVIP > maxSize) {
                                    maxSize = Settings.maxTeamSizeVIP;
                                }
                            }
                            if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                                if (Settings.maxTeamSizeVIP2 > maxSize) {
                                    maxSize = Settings.maxTeamSizeVIP2;
                                }
                            }
                            if (teamMembers.size() < maxSize) {
                                player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).inviteyouCanInvite.replace("String_Node_Str", String.valueOf(maxSize - teamMembers.size())));
                            } else {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYourIslandIsFull);
                            }
                            return true;
                        }
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYouMustHaveIslandToInvite);
                        return true;
                    }
                    return true;
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (!plugin.getPlayers().inTeam(playerUUID) && inviteList.containsKey(playerUUID)) {
                        if (plugin.getPlayers().hasIsland(playerUUID)) {
                            plugin.getLogger().info(player.getName() + "String_Node_Str");
                            plugin.deletePlayerIsland(playerUUID, true);
                            plugin.getLogger().info("String_Node_Str");
                        }
                        addPlayertoTeam(playerUUID, inviteList.get(playerUUID));
                        if (!plugin.getPlayers().inTeam(inviteList.get(playerUUID))) {
                            addPlayertoTeam(inviteList.get(playerUUID), inviteList.get(playerUUID));
                        }
                        setResetWaitTime(player);
                        plugin.getGrid().homeTeleport(player);
                        plugin.resetPlayer(player);
                        player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).inviteyouHaveJoinedAnIsland);
                        if (Bukkit.getPlayer(inviteList.get(playerUUID)) != null) {
                            Bukkit.getPlayer(inviteList.get(playerUUID)).sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).invitehasJoinedYourIsland.replace("String_Node_Str", player.getName()));
                        }
                        inviteList.remove(player.getUniqueId());
                        return true;
                    }
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorCommandNotReady);
                    return true;
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (inviteList.containsKey(player.getUniqueId())) {
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).rejectyouHaveRejectedInvitation);
                    if (Bukkit.getPlayer(inviteList.get(player.getUniqueId())) != null) {
                        Bukkit.getPlayer(inviteList.get(player.getUniqueId())).sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).rejectnameHasRejectedInvite.replace("String_Node_Str", player.getName()));
                    }
                    inviteList.remove(player.getUniqueId());
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).rejectyouHaveNotBeenInvited);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (player.getWorld().getName().equalsIgnoreCase(ASkyBlock.getIslandWorld().getName())) {
                        if (plugin.getPlayers().inTeam(playerUUID)) {
                            if (plugin.getPlayers().getTeamLeader(playerUUID).equals(playerUUID)) {
                                player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).leaveerrorYouAreTheLeader);
                                return true;
                            }
                            CoopPlay.getInstance().clearMyInvitedCoops(player);
                            CoopPlay.getInstance().clearMyCoops(player);
                            plugin.getPlayers().startInviteCoolDownTimer(playerUUID, plugin.getPlayers().getTeamIslandLocation(teamLeader));
                            removePlayerFromTeam(playerUUID, teamLeader);
                            plugin.getWarpSignsListener().removeWarp(playerUUID);
                            player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).leaveyouHaveLeftTheIsland);
                            if (plugin.getServer().getPlayer(teamLeader) != null) {
                                plugin.getServer().getPlayer(teamLeader).sendMessage(ChatColor.RED + plugin.myLocale(teamLeader).leavenameHasLeftYourIsland.replace("String_Node_Str", player.getName()));
                            } else {
                                plugin.getMessages().setMessage(teamLeader, ChatColor.RED + plugin.myLocale(teamLeader).leavenameHasLeftYourIsland.replace("String_Node_Str", player.getName()));
                            }
                            if (teamMembers.size() < 2) {
                                removePlayerFromTeam(teamLeader, teamLeader);
                            }
                            plugin.resetPlayer(player);
                            if (!player.performCommand(Settings.SPAWNCOMMAND)) {
                                player.teleport(player.getWorld().getSpawnLocation());
                            }
                            return true;
                        } else {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).leaveerrorYouCannotLeaveIsland);
                            return true;
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).leaveerrorYouMustBeInWorld);
                    }
                    return true;
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (plugin.getPlayers().inTeam(playerUUID)) {
                    if (teamLeader.equals(playerUUID)) {
                        int maxSize = Settings.maxTeamSize;
                        for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                            if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                                maxSize = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
                            }
                            if (maxSize < Settings.maxTeamSize) {
                                maxSize = Settings.maxTeamSize;
                            }
                        }
                        if (teamMembers.size() < maxSize) {
                            player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).inviteyouCanInvite.replace("String_Node_Str", String.valueOf(maxSize - teamMembers.size())));
                        } else {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYourIslandIsFull);
                        }
                    }
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).teamlistingMembers + "String_Node_Str");
                    for (UUID m : plugin.getPlayers().getMembers(teamLeader)) {
                        player.sendMessage(ChatColor.WHITE + plugin.getPlayers().getName(m));
                    }
                } else if (inviteList.containsKey(playerUUID)) {
                    player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).invitenameHasInvitedYou.replace("String_Node_Str", plugin.getPlayers().getName(inviteList.get(playerUUID))));
                    player.sendMessage(ChatColor.WHITE + "String_Node_Str" + label + "String_Node_Str" + ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).invitetoAcceptOrReject);
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).kickerrorNoTeam);
                }
                return true;
            } else {
                return false;
            }
        case 2:
            if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (Settings.useWarpPanel) {
                    if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                        Set<UUID> warpList = plugin.getWarpSignsListener().listWarps();
                        if (warpList.isEmpty()) {
                            player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).warpserrorNoWarpsYet);
                            if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && plugin.getGrid().playerIsOnIsland(player)) {
                                player.sendMessage(ChatColor.YELLOW + plugin.myLocale().warpswarpTip);
                            }
                            return true;
                        } else {
                            int panelNum = 0;
                            try {
                                panelNum = Integer.valueOf(split[1]) - 1;
                            } catch (Exception e) {
                                panelNum = 0;
                            }
                            player.openInventory(plugin.getWarpPanel().getWarpPanel(panelNum));
                            return true;
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).errorNoPermission);
                    }
                } else {
                    return false;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!pendingNewIslandSelection.contains(playerUUID)) {
                    return false;
                }
                pendingNewIslandSelection.remove(playerUUID);
                if (!schematics.containsKey(split[1])) {
                    return false;
                } else {
                    Schematic schematic = schematics.get(split[1]);
                    if (schematic.getPerm().isEmpty() || VaultHelper.checkPerm(player, schematic.getPerm())) {
                        Island oldIsland = plugin.getGrid().getIsland(player.getUniqueId());
                        newIsland(player, schematic);
                        if (resettingIsland.contains(playerUUID)) {
                            resettingIsland.remove(playerUUID);
                            resetPlayer(player, oldIsland);
                        }
                        return true;
                    } else {
                        return false;
                    }
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else if (split[1].equalsIgnoreCase("String_Node_Str") || split[1].equalsIgnoreCase("String_Node_Str")) {
                        plugin.getPlayers().setLocale(playerUUID, "String_Node_Str");
                    } else {
                        player.sendMessage("String_Node_Str" + label + "String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        player.sendMessage("String_Node_Str");
                        return true;
                    }
                    player.sendMessage("String_Node_Str");
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).errorNoPermission);
                    return true;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!plugin.getPlayers().hasIsland(playerUUID) && !plugin.getPlayers().inTeam(playerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIsland);
                    return true;
                }
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    int number = 1;
                    try {
                        number = Integer.valueOf(split[1]);
                        if (number < 1) {
                            plugin.getGrid().homeTeleport(player, 1);
                        }
                        int maxHomes = Settings.maxHomes;
                        for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                            if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                                maxHomes = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
                            }
                            if (maxHomes < 1) {
                                maxHomes = 1;
                            }
                        }
                        if (number > maxHomes) {
                            if (maxHomes > 1) {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).setHomeerrorNumHomes.replace("String_Node_Str", String.valueOf(maxHomes)));
                            } else {
                                plugin.getGrid().homeTeleport(player, 1);
                            }
                        } else {
                            plugin.getGrid().homeTeleport(player, number);
                        }
                    } catch (Exception e) {
                        plugin.getGrid().homeTeleport(player, 1);
                    }
                    if (Settings.islandRemoveMobs) {
                        plugin.getGrid().removeMobs(player.getLocation());
                    }
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    int maxHomes = Settings.maxHomes;
                    for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                        if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                            maxHomes = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
                        }
                    }
                    if (maxHomes > 1) {
                        int number = 0;
                        try {
                            number = Integer.valueOf(split[1]);
                            if (number < 0 || number > maxHomes) {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).setHomeerrorNumHomes.replace("String_Node_Str", String.valueOf(maxHomes)));
                            } else {
                                plugin.getGrid().homeSet(player, number);
                            }
                        } catch (Exception e) {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).setHomeerrorNumHomes.replace("String_Node_Str", String.valueOf(maxHomes)));
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    }
                    return true;
                }
                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    final Set<UUID> warpList = plugin.getWarpSignsListener().listWarps();
                    if (warpList.isEmpty()) {
                        player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).warpserrorNoWarpsYet);
                        if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                            player.sendMessage(ChatColor.YELLOW + plugin.myLocale().warpswarpTip);
                        } else {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                        }
                        return true;
                    } else {
                        UUID foundWarp = null;
                        for (UUID warp : warpList) {
                            if (plugin.getPlayers().getName(warp).toLowerCase().startsWith(split[1].toLowerCase())) {
                                foundWarp = warp;
                                break;
                            }
                        }
                        if (foundWarp == null) {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).warpserrorDoesNotExist);
                            return true;
                        } else {
                            final Location warpSpot = plugin.getWarpSignsListener().getWarp(foundWarp);
                            if (warpSpot == null) {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).warpserrorNotReadyYet);
                                plugin.getLogger().warning("String_Node_Str" + plugin.getPlayers().getName(foundWarp));
                                return true;
                            }
                            Island island = plugin.getGrid().getIslandAt(warpSpot);
                            if (island != null && island.isLocked()) {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).lockIslandLocked);
                                return true;
                            }
                            Block b = warpSpot.getBlock();
                            if (b.getType().equals(Material.SIGN_POST)) {
                                Sign sign = (Sign) b.getState();
                                org.bukkit.material.Sign s = (org.bukkit.material.Sign) sign.getData();
                                BlockFace directionFacing = s.getFacing();
                                Location inFront = b.getRelative(directionFacing).getLocation();
                                if ((GridManager.isSafeLocation(inFront))) {
                                    float yaw = Util.blockFaceToFloat(directionFacing);
                                    final Location actualWarp = new Location(inFront.getWorld(), inFront.getBlockX() + 0.5D, inFront.getBlockY(), inFront.getBlockZ() + 0.5D, yaw, 30F);
                                    player.teleport(actualWarp);
                                    player.getWorld().playSound(player.getLocation(), Sound.BAT_TAKEOFF, 1F, 1F);
                                    Player warpOwner = plugin.getServer().getPlayer(foundWarp);
                                    if (warpOwner != null) {
                                        warpOwner.sendMessage(plugin.myLocale(foundWarp).warpsPlayerWarped.replace("String_Node_Str", player.getDisplayName()));
                                    }
                                    return true;
                                }
                            } else {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).warpserrorDoesNotExist);
                                plugin.getWarpSignsListener().removeWarp(warpSpot);
                                return true;
                            }
                            if (!(GridManager.isSafeLocation(warpSpot))) {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).warpserrorNotSafe);
                                plugin.getLogger().warning("String_Node_Str" + warpSpot.toString() + "String_Node_Str" + plugin.getPlayers().getName(foundWarp));
                                return true;
                            } else {
                                final Location actualWarp = new Location(warpSpot.getWorld(), warpSpot.getBlockX() + 0.5D, warpSpot.getBlockY(), warpSpot.getBlockZ() + 0.5D);
                                player.teleport(actualWarp);
                                player.getWorld().playSound(player.getLocation(), Sound.BAT_TAKEOFF, 1F, 1F);
                                return true;
                            }
                        }
                    }
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return false;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    final UUID targetPlayerUUID = plugin.getPlayers().getUUID(split[1]);
                    if (targetPlayerUUID == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                        return true;
                    }
                    if (plugin.getPlayers().hasIsland(targetPlayerUUID) || plugin.getPlayers().inTeam(targetPlayerUUID)) {
                        calculateIslandLevel(player, targetPlayerUUID);
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIslandOther);
                    }
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                }
                return false;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    final UUID invitedPlayerUUID = plugin.getPlayers().getUUID(split[1]);
                    if (invitedPlayerUUID == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                        return true;
                    }
                    if (plugin.getServer().getPlayer(invitedPlayerUUID) == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorOfflinePlayer);
                        return true;
                    }
                    if (!plugin.getPlayers().hasIsland(player.getUniqueId())) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYouMustHaveIslandToInvite);
                        return true;
                    }
                    if (player.getName().equalsIgnoreCase(split[1])) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYouCannotInviteYourself);
                        return true;
                    }
                    long time = plugin.getPlayers().getInviteCoolDownTime(invitedPlayerUUID, plugin.getPlayers().getIslandLocation(playerUUID));
                    if (time > 0 && !player.isOp()) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorCoolDown.replace("String_Node_Str", String.valueOf(time)));
                        return true;
                    }
                    if (plugin.getPlayers().inTeam(player.getUniqueId())) {
                        if (teamLeader.equals(player.getUniqueId())) {
                            if (!plugin.getPlayers().inTeam(invitedPlayerUUID)) {
                                int maxSize = Settings.maxTeamSize;
                                for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
                                    if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
                                        maxSize = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
                                    }
                                    if (maxSize < Settings.maxTeamSize) {
                                        maxSize = Settings.maxTeamSize;
                                    }
                                }
                                if (teamMembers.size() < maxSize) {
                                    if (inviteList.containsValue(playerUUID)) {
                                        inviteList.remove(getKeyByValue(inviteList, player.getUniqueId()));
                                        player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).inviteremovingInvite);
                                    }
                                    inviteList.put(invitedPlayerUUID, player.getUniqueId());
                                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).inviteinviteSentTo.replace("String_Node_Str", split[1]));
                                    Bukkit.getPlayer(invitedPlayerUUID).sendMessage(plugin.myLocale(invitedPlayerUUID).invitenameHasInvitedYou.replace("String_Node_Str", player.getName()));
                                    Bukkit.getPlayer(invitedPlayerUUID).sendMessage(ChatColor.WHITE + "String_Node_Str" + label + "String_Node_Str" + ChatColor.YELLOW + "String_Node_Str" + plugin.myLocale(invitedPlayerUUID).invitetoAcceptOrReject);
                                    if (plugin.getPlayers().hasIsland(invitedPlayerUUID)) {
                                        Bukkit.getPlayer(invitedPlayerUUID).sendMessage(ChatColor.RED + plugin.myLocale(invitedPlayerUUID).invitewarningYouWillLoseIsland);
                                    }
                                } else {
                                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYourIslandIsFull);
                                }
                            } else {
                                player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorThatPlayerIsAlreadyInATeam);
                            }
                        } else {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYouMustHaveIslandToInvite);
                        }
                    } else {
                        if (!plugin.getPlayers().inTeam(invitedPlayerUUID)) {
                            if (inviteList.containsValue(playerUUID)) {
                                inviteList.remove(getKeyByValue(inviteList, player.getUniqueId()));
                                player.sendMessage(ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).inviteremovingInvite);
                            }
                            inviteList.put(invitedPlayerUUID, player.getUniqueId());
                            player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).inviteinviteSentTo.replace("String_Node_Str", split[1]));
                            Bukkit.getPlayer(invitedPlayerUUID).sendMessage(plugin.myLocale(invitedPlayerUUID).invitenameHasInvitedYou.replace("String_Node_Str", player.getName()));
                            Bukkit.getPlayer(invitedPlayerUUID).sendMessage(ChatColor.WHITE + "String_Node_Str" + label + "String_Node_Str" + ChatColor.YELLOW + "String_Node_Str" + plugin.myLocale(invitedPlayerUUID).invitetoAcceptOrReject);
                            if (plugin.getPlayers().hasIsland(invitedPlayerUUID)) {
                                Bukkit.getPlayer(invitedPlayerUUID).sendMessage(ChatColor.RED + plugin.myLocale(invitedPlayerUUID).invitewarningYouWillLoseIsland);
                            }
                        } else {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorThatPlayerIsAlreadyInATeam);
                        }
                    }
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return false;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    final UUID invitedPlayerUUID = plugin.getPlayers().getUUID(split[1]);
                    if (invitedPlayerUUID == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                        return true;
                    }
                    Player newPlayer = plugin.getServer().getPlayer(invitedPlayerUUID);
                    if (newPlayer == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorOfflinePlayer);
                        return true;
                    }
                    if (!plugin.getPlayers().hasIsland(playerUUID) && !plugin.getPlayers().inTeam(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYouMustHaveIslandToInvite);
                        return true;
                    }
                    if (player.getName().equalsIgnoreCase(split[1])) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).inviteerrorYouCannotInviteYourself);
                        return true;
                    }
                    if (plugin.getPlayers().getMembers(playerUUID).contains(invitedPlayerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).coopOnYourTeam);
                        return true;
                    }
                    if (!plugin.getPlayers().inTeam(invitedPlayerUUID)) {
                        if (!plugin.getPlayers().hasIsland(invitedPlayerUUID)) {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoIslandOther);
                            return true;
                        }
                    }
                    CoopPlay.getInstance().addCoopPlayer(player, newPlayer);
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).coopSuccess.replace("String_Node_Str", newPlayer.getDisplayName()));
                    newPlayer.sendMessage(ChatColor.GREEN + plugin.myLocale(newPlayer.getUniqueId()).coopMadeYouCoop.replace("String_Node_Str", player.getDisplayName()));
                    return true;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
                final UUID targetPlayerUUID = plugin.getPlayers().getUUID(split[1]);
                if (targetPlayerUUID == null) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                    return true;
                }
                if (targetPlayerUUID.equals(playerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).expelNotYourself);
                    return true;
                }
                Player target = plugin.getServer().getPlayer(targetPlayerUUID);
                if (target == null) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorOfflinePlayer);
                    return true;
                }
                if (target.isOp() || VaultHelper.checkPerm(target, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).expelFail.replace("String_Node_Str", target.getDisplayName()));
                    return true;
                }
                boolean coop = CoopPlay.getInstance().removeCoopPlayer(player, target);
                if (coop) {
                    target.sendMessage(ChatColor.RED + plugin.myLocale(target.getUniqueId()).coopRemoved.replace("String_Node_Str", player.getDisplayName()));
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).coopRemoveSuccess.replace("String_Node_Str", target.getDisplayName()));
                }
                if (plugin.getGrid().isOnIsland(player, target)) {
                    if (plugin.getPlayers().inTeam(targetPlayerUUID) || plugin.getPlayers().hasIsland(targetPlayerUUID)) {
                        plugin.getGrid().homeTeleport(target);
                    } else {
                        if (!target.performCommand(Settings.SPAWNCOMMAND)) {
                            target.teleport(player.getWorld().getSpawnLocation());
                        }
                    }
                    target.sendMessage(ChatColor.RED + plugin.myLocale(target.getUniqueId()).expelExpelled);
                    plugin.getLogger().info(player.getName() + "String_Node_Str" + target.getName() + "String_Node_Str");
                    player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).expelSuccess.replace("String_Node_Str", target.getDisplayName()));
                } else if (!coop) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).expelNotOnIsland);
                }
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
                final UUID targetPlayerUUID = plugin.getPlayers().getUUID(split[1]);
                if (targetPlayerUUID == null) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                    return true;
                }
                if (targetPlayerUUID.equals(playerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).banNotYourself);
                    return true;
                }
                if (plugin.getPlayers().inTeam(playerUUID) && plugin.getPlayers().inTeam(targetPlayerUUID)) {
                    if (plugin.getPlayers().getTeamLeader(playerUUID).equals(plugin.getPlayers().getTeamLeader(targetPlayerUUID))) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).banNotTeamMember);
                        return true;
                    }
                }
                if (plugin.getPlayers().isBanned(playerUUID, targetPlayerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(playerUUID).banAlreadyBanned.replace("String_Node_Str", split[1]));
                    return true;
                }
                Player target = plugin.getServer().getPlayer(targetPlayerUUID);
                OfflinePlayer offlineTarget = plugin.getServer().getOfflinePlayer(targetPlayerUUID);
                if (offlineTarget.isOp()) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).banFail.replace("String_Node_Str", offlineTarget.getName()));
                    return true;
                }
                if (target != null) {
                    boolean coop = CoopPlay.getInstance().removeCoopPlayer(player, target);
                    if (coop) {
                        target.sendMessage(ChatColor.RED + plugin.myLocale(target.getUniqueId()).coopRemoved.replace("String_Node_Str", player.getDisplayName()));
                        player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).coopRemoveSuccess.replace("String_Node_Str", target.getDisplayName()));
                    }
                    if (plugin.getGrid().isOnIsland(player, target)) {
                        if (plugin.getPlayers().inTeam(targetPlayerUUID) || plugin.getPlayers().hasIsland(targetPlayerUUID)) {
                            plugin.getGrid().homeTeleport(target);
                        } else {
                            if (!target.performCommand(Settings.SPAWNCOMMAND)) {
                                target.teleport(player.getWorld().getSpawnLocation());
                            }
                        }
                    }
                    target.sendMessage(ChatColor.RED + plugin.myLocale(targetPlayerUUID).banBanned.replace("String_Node_Str", player.getDisplayName()));
                } else {
                    plugin.getMessages().setMessage(targetPlayerUUID, ChatColor.RED + plugin.myLocale(targetPlayerUUID).banBanned.replace("String_Node_Str", player.getDisplayName()));
                }
                plugin.getLogger().info(player.getName() + "String_Node_Str" + offlineTarget.getName() + "String_Node_Str");
                player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).banSuccess.replace("String_Node_Str", offlineTarget.getName()));
                plugin.getMessages().tellTeam(playerUUID, ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).banSuccess.replace("String_Node_Str", offlineTarget.getName()));
                plugin.getMessages().tellOfflineTeam(playerUUID, ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).banSuccess.replace("String_Node_Str", offlineTarget.getName()));
                plugin.getPlayers().ban(playerUUID, targetPlayerUUID);
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (!VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return true;
                }
                final UUID targetPlayerUUID = plugin.getPlayers().getUUID(split[1]);
                if (targetPlayerUUID == null) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                    return true;
                }
                if (targetPlayerUUID.equals(playerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).banNotYourself);
                    return true;
                }
                if (!plugin.getPlayers().isBanned(playerUUID, targetPlayerUUID)) {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).banNotBanned.replace("String_Node_Str", split[1]));
                    return true;
                }
                Player target = plugin.getServer().getPlayer(targetPlayerUUID);
                if (target != null) {
                    target.sendMessage(ChatColor.RED + plugin.myLocale(target.getUniqueId()).banLifted.replace("String_Node_Str", player.getDisplayName()));
                } else {
                    plugin.getMessages().setMessage(targetPlayerUUID, ChatColor.GREEN + plugin.myLocale(targetPlayerUUID).banLifted.replace("String_Node_Str", player.getDisplayName()));
                }
                OfflinePlayer offlineTarget = plugin.getServer().getOfflinePlayer(targetPlayerUUID);
                player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).banLiftedSuccess.replace("String_Node_Str", offlineTarget.getName()));
                plugin.getLogger().info(player.getName() + "String_Node_Str" + offlineTarget.getName() + "String_Node_Str");
                plugin.getMessages().tellTeam(playerUUID, ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).banLiftedSuccess.replace("String_Node_Str", offlineTarget.getName()));
                plugin.getMessages().tellOfflineTeam(playerUUID, ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).banLiftedSuccess.replace("String_Node_Str", offlineTarget.getName()));
                plugin.getPlayers().unBan(playerUUID, targetPlayerUUID);
                return true;
            } else if (split[0].equalsIgnoreCase("String_Node_Str") || split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    if (!plugin.getPlayers().inTeam(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).kickerrorNoTeam);
                        return true;
                    }
                    if (teamLeader != null && !teamLeader.equals(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).kickerrorOnlyLeaderCan);
                        return true;
                    }
                    targetPlayer = null;
                    for (UUID member : teamMembers) {
                        if (plugin.getPlayers().getName(member).equalsIgnoreCase(split[1])) {
                            targetPlayer = member;
                        }
                    }
                    if (targetPlayer == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).kickerrorNotPartOfTeam);
                        return true;
                    }
                    if (teamMembers.contains(targetPlayer)) {
                        if (player.getUniqueId().equals(targetPlayer)) {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).leaveerrorLeadersCannotLeave);
                            return true;
                        }
                        Player target = plugin.getServer().getPlayer(targetPlayer);
                        if (target != null) {
                            target.sendMessage(ChatColor.RED + plugin.myLocale(targetPlayer).kicknameRemovedYou.replace("String_Node_Str", player.getName()));
                            plugin.getPlayers().startInviteCoolDownTimer(targetPlayer, plugin.getPlayers().getIslandLocation(playerUUID));
                            CoopPlay.getInstance().clearMyInvitedCoops(target);
                            CoopPlay.getInstance().clearMyCoops(target);
                            if (target.getWorld().equals(ASkyBlock.getIslandWorld())) {
                                for (ItemStack i : target.getInventory().getContents()) {
                                    if (i != null) {
                                        try {
                                            player.getWorld().dropItemNaturally(player.getLocation(), i);
                                        } catch (Exception e) {
                                        }
                                    }
                                }
                                for (ItemStack i : target.getEquipment().getArmorContents()) {
                                    if (i != null) {
                                        try {
                                            player.getWorld().dropItemNaturally(player.getLocation(), i);
                                        } catch (Exception e) {
                                        }
                                    }
                                }
                                target.getInventory().clear();
                                target.getInventory().setArmorContents(null);
                                target.getInventory().setHelmet(null);
                                target.getInventory().setChestplate(null);
                                target.getInventory().setLeggings(null);
                                target.getInventory().setBoots(null);
                                target.getEquipment().clear();
                                if (Settings.resetChallenges) {
                                    plugin.getPlayers().resetAllChallenges(target.getUniqueId());
                                }
                                plugin.getPlayers().setIslandLevel(target.getUniqueId(), 0);
                                plugin.getPlayers().save(target.getUniqueId());
                                TopTen.topTenAddEntry(playerUUID, 0);
                                target.updateInventory();
                            }
                            if (!target.performCommand(Settings.SPAWNCOMMAND)) {
                                target.teleport(ASkyBlock.getIslandWorld().getSpawnLocation());
                            }
                        } else {
                            plugin.getMessages().setMessage(targetPlayer, ChatColor.RED + plugin.myLocale(player.getUniqueId()).kicknameRemovedYou.replace("String_Node_Str", player.getName()));
                        }
                        plugin.getWarpSignsListener().removeWarp(targetPlayer);
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).kicknameRemoved.replace("String_Node_Str", split[1]));
                        removePlayerFromTeam(targetPlayer, teamLeader);
                        teamMembers.remove(targetPlayer);
                        if (teamMembers.size() < 2) {
                            removePlayerFromTeam(player.getUniqueId(), teamLeader);
                        }
                        plugin.getPlayers().save(targetPlayer);
                    } else {
                        plugin.getLogger().warning("String_Node_Str" + player.getName() + "String_Node_Str" + plugin.getPlayers().getName(targetPlayer));
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).kickerrorNotPartOfTeam);
                    }
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return false;
                }
            } else if (split[0].equalsIgnoreCase("String_Node_Str")) {
                if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str")) {
                    targetPlayer = plugin.getPlayers().getUUID(split[1]);
                    if (targetPlayer == null) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorUnknownPlayer);
                        return true;
                    }
                    if (targetPlayer.equals(playerUUID)) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).makeLeadererrorGeneralError);
                        return true;
                    }
                    if (!plugin.getPlayers().inTeam(player.getUniqueId())) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).makeLeadererrorYouMustBeInTeam);
                        return true;
                    }
                    if (plugin.getPlayers().getMembers(player.getUniqueId()).size() > 2) {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).makeLeadererrorRemoveAllPlayersFirst);
                        plugin.getLogger().info(player.getName() + "String_Node_Str");
                        return true;
                    }
                    if (plugin.getPlayers().inTeam(player.getUniqueId())) {
                        if (teamLeader.equals(player.getUniqueId())) {
                            if (teamMembers.contains(targetPlayer)) {
                                if (plugin.getServer().getPlayer(targetPlayer) != null) {
                                    plugin.getServer().getPlayer(targetPlayer).sendMessage(ChatColor.GREEN + plugin.myLocale(targetPlayer).makeLeaderyouAreNowTheOwner);
                                } else {
                                    plugin.getMessages().setMessage(targetPlayer, plugin.myLocale(player.getUniqueId()).makeLeaderyouAreNowTheOwner);
                                }
                                player.sendMessage(ChatColor.GREEN + plugin.myLocale(player.getUniqueId()).makeLeadernameIsNowTheOwner.replace("String_Node_Str", plugin.getPlayers().getName(targetPlayer)));
                                removePlayerFromTeam(targetPlayer, teamLeader);
                                removePlayerFromTeam(teamLeader, teamLeader);
                                plugin.getGrid().transferIsland(player.getUniqueId(), targetPlayer);
                                addPlayertoTeam(player.getUniqueId(), targetPlayer);
                                addPlayertoTeam(targetPlayer, targetPlayer);
                                return true;
                            }
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).makeLeadererrorThatPlayerIsNotInTeam);
                        } else {
                            player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).makeLeadererrorNotYourIsland);
                        }
                    } else {
                        player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).makeLeadererrorGeneralError);
                    }
                    return true;
                } else {
                    player.sendMessage(ChatColor.RED + plugin.myLocale(player.getUniqueId()).errorNoPermission);
                    return false;
                }
            } else {
                return false;
            }
    }
    return false;
}

Output:
                             plugin.getGrid().homeTeleport(player, 1);
-                        }
-                        int maxHomes = Settings.maxHomes;
-                        for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
-                            if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
-                                maxHomes = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
-                            }
-                            if (maxHomes < 1) {
-                                maxHomes = 1;
+                        } else {
+                            int maxHomes = Settings.maxHomes;
+                            for (PermissionAttachmentInfo perms : player.getEffectivePermissions()) {
+                                if (perms.getPermission().startsWith(Settings.PERMPREFIX + "String_Node_Str")) {
+                                    maxHomes = Integer.valueOf(perms.getPermission().split(Settings.PERMPREFIX + "String_Node_Str")[1]);
+                                }
+                                if (maxHomes < 1) {
+                                    maxHomes = 1;
+                                }
                             }


Input:
private void CNodeToTree(ClusterNode clusterNode, CNode node) {
    if (node.getChilds() != null) {
        int iNrChildsNode = node.getChilds().size();
        for (int i = 0; i < iNrChildsNode; i++) {
            CNode currentNode = (CNode) node.getChilds().elementAt(i);
            ClusterNode currentGraph = new ClusterNode("String_Node_Str" + currentNode.getClusterNum(), currentNode.getClusterNum(), 0f, 0, false);
            currentGraph.setNrElements(1);
            tree.addChild(clusterNode, currentGraph);
            CNodeToTree(currentGraph, currentNode);
        }
    }
}

Output:
             CNode currentNode = (CNode) node.getChilds().elementAt(i);
-            ClusterNode currentGraph = new ClusterNode("String_Node_Str" + currentNode.getClusterNum(), currentNode.getClusterNum(), 0f, 0, false);
+            int clusterNr = 0;
+            clusterNr = currentNode.getClusterNum();
+            ClusterNode currentGraph = new ClusterNode("String_Node_Str" + clusterNr, clusterNr, 0f, 0, false);
             currentGraph.setNrElements(1);


Input:
public void onDestroy() {
    super.onDestroy();
    cleanUpPlayer();
    sNativeSynth.shutdown();
    sNativeSynth = null;
    mCallbacks.kill();
}

Output:
     cleanUpPlayer();
-    sNativeSynth.shutdown();
+    if (sNativeSynth != null) {
+        sNativeSynth.shutdown();
+    }
     sNativeSynth = null;


Input:
public static boolean verifyPOST(String url, String queryString, String authorizationHeader, OAuthConsumer consumer, OAuthAccessToken accessToken, SignatureMethod signatureMethod, Map<String, String> formParams) {
    if (authorizationHeader == null) {
        return false;
    }
    Map<String, String> elements = parseAuthorizationHeader(authorizationHeader);
    if (formParams != null) {
        for (String key : formParams.keySet()) {
            String value = formParams.get(key);
            if (value != null) {
                elements.put(key, value);
            }
        }
    }
    SignedRequest req = SignedRequestFactory.create(consumer, accessToken, signatureMethod);
    Map<String, Object> additionalParams = new HashMap<String, Object>();
    for (String name : elements.keySet()) {
        String _name = name.replaceFirst("String_Node_Str", "String_Node_Str");
        if (!oAuthElementNames.contains(_name)) {
            additionalParams.put(name, OAuthEncoding.decode(elements.get(name)));
        }
    }
    req.setAdditionalAuthorizationHeaderParams(additionalParams);
    if (queryString == null) {
        queryString = "String_Node_Str";
    }
    req.readQueryStringAndAddToSignatureBaseString(url + "String_Node_Str" + queryString);
    String signature = req.getSignature(url, HttpMethod.POST, elements.get("String_Node_Str"), Long.valueOf(elements.get("String_Node_Str")));
    return OAuthEncoding.encode(signature).equals(elements.get("String_Node_Str"));
}

Output:
     }
-    Map<String, String> elements = parseAuthorizationHeader(authorizationHeader);
+    Map<String, String> urlDecodedElements = parseAuthorizationHeader(authorizationHeader);
     if (formParams != null) {


Input:
protected void init() throws BirtException {
    if (PropertyUtil.isInlineElement(image)) {
        root = new ImageInlineContainer(parent, context, image);
    } else {
        root = new ImageBlockContainer(parent, context, image);
    }
    root.initialize();
    root.setAllocatedWidth(parent.getCurrentMaxContentWidth());
    root.setMaxAvaWidth(root.getContentWidth());
    Dimension contentDimension = getSpecifiedDimension(image, root.getContentWidth(), true);
    ImageArea imageArea = createImageArea(image);
    int actualHeight = contentDimension.getHeight();
    int actualWidth = contentDimension.getWidth();
    int maxHeight = root.getMaxAvaHeight();
    int maxWidth = root.getMaxAvaWidth();
    int cHeight = contentDimension.getHeight();
    int cWidth = contentDimension.getWidth();
    if (cHeight > maxHeight || cWidth > maxWidth) {
        if (fitToContainer) {
            float rh = ((float) maxHeight) / cHeight;
            float rw = ((float) maxWidth) / cWidth;
            if (rh > rw) {
                actualHeight = (int) (rw * maxHeight);
                actualWidth = maxWidth;
            } else {
                actualHeight = maxHeight;
                actualWidth = (int) (rh * maxWidth);
            }
        } else {
            root.setNeedClip(true);
            root.setAllocatedHeight(Math.min(maxHeight, cHeight));
            root.setAllocatedWidth(Math.min(maxWidth, cWidth));
        }
        imageArea.setWidth(actualWidth);
        imageArea.setHeight(actualHeight);
    } else {
        imageArea.setWidth(actualWidth);
        imageArea.setHeight(actualHeight);
        root.setContentWidth(imageArea.getWidth());
        root.setContentHeight(imageArea.getHeight());
    }
    root.addChild(imageArea);
    imageArea.setPosition(root.getContentX(), root.getContentY());
    processChartLegend(image, imageArea);
    root.finished = true;
}

Output:
     processChartLegend(image, imageArea);
-    root.finished = true;
+    root.finished = false;
 }


Input:
public double[] inputs(TorusAgent me, TorusWorld world, TorusAgent[] preds, TorusAgent[] prey) {
    double[] inputs = new double[preds.length * 2];
    for (int i = 0; i < preds.length; i++) {
        inputs[(2 * i)] = me.shortestXOffset(preds[i]) / (1.0 * world.width());
        inputs[(2 * i) + 1] = me.shortestYOffset(preds[i]) / (1.0 * world.height());
    }
    return inputs;
}

Output:
 public double[] inputs(TorusAgent me, TorusWorld world, TorusAgent[] preds, TorusAgent[] prey) {
-    double[] inputs = new double[preds.length * 2];
-    for (int i = 0; i < preds.length; i++) {
-        inputs[(2 * i)] = me.shortestXOffset(preds[i]) / (1.0 * world.width());
-        inputs[(2 * i) + 1] = me.shortestYOffset(preds[i]) / (1.0 * world.height());
+    int numAgentsSensed = isPredator ? prey.length : preds.length;
+    double[] inputs = new double[numAgentsSensed * 2];
+    for (int i = 0; i < numAgentsSensed; i++) {
+        inputs[(2 * i)] = me.shortestXOffset(isPredator ? prey[i] : preds[i]) / (1.0 * world.width());
+        inputs[(2 * i) + 1] = me.shortestYOffset(isPredator ? prey[i] : preds[i]) / (1.0 * world.height());
     }


Input:
public boolean updateState(State oldState, Event event, State newState, VirtualMachine vm, Long hostId) {
    if (newState == null) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str" + oldState.toString() + "String_Node_Str" + event.toString());
        }
        return false;
    }
    VMInstanceVO vmi = (VMInstanceVO) vm;
    Long oldHostId = vmi.getHostId();
    SearchCriteria<VMInstanceVO> sc = StateChangeSearch.create();
    sc.setParameters("String_Node_Str", vmi.getId());
    sc.setParameters("String_Node_Str", oldState);
    sc.setParameters("String_Node_Str", vmi.getHostId());
    sc.setParameters("String_Node_Str", vmi.getUpdated());
    vmi.incrUpdated();
    UpdateBuilder ub = getUpdateBuilder(vmi);
    ub.set(vmi, "String_Node_Str", newState);
    ub.set(vmi, "String_Node_Str", hostId);
    ub.set(vmi, _updateTimeAttr, new Date());
    int result = update(vmi, sc);
    if (result == 0 && s_logger.isDebugEnabled()) {
        vmi.setState(oldState);
        vmi.setHostId(oldHostId);
        vmi.decrUpdated();
        VMInstanceVO vo = findById(vm.getId());
        StringBuilder str = new StringBuilder("String_Node_Str").append(vo.toString());
        str.append("String_Node_Str").append(vo.getHostId()).append("String_Node_Str").append(vo.getState().toString()).append("String_Node_Str").append(vo.getUpdated());
        str.append("String_Node_Str").append(vm.getHostId()).append("String_Node_Str").append(vm.getState().toString()).append("String_Node_Str").append(vmi.getUpdated()).append("String_Node_Str");
        s_logger.debug(str.toString());
    }
    return result > 0;
}

Output:
         StringBuilder str = new StringBuilder("String_Node_Str").append(vo.toString());
-        str.append("String_Node_Str").append(vo.getHostId()).append("String_Node_Str").append(vo.getState().toString()).append("String_Node_Str").append(vo.getUpdated());
-        str.append("String_Node_Str").append(vm.getHostId()).append("String_Node_Str").append(vm.getState().toString()).append("String_Node_Str").append(vmi.getUpdated()).append("String_Node_Str");
+        str.append("String_Node_Str").append(vo.getHostId()).append("String_Node_Str").append(vo.getState().toString()).append("String_Node_Str").append(vo.getUpdated()).append("String_Node_Str").append(vo.getUpdateTime());
+        str.append("String_Node_Str").append(vm.getHostId()).append("String_Node_Str").append(vm.getState().toString()).append("String_Node_Str").append(vmi.getUpdated()).append("String_Node_Str").append(vo.getUpdateTime());
+        str.append("String_Node_Str").append(oldHostId).append("String_Node_Str").append(oldState).append("String_Node_Str").append(oldUpdated).append("String_Node_Str").append(oldUpdateDate).append("String_Node_Str");
         s_logger.debug(str.toString());