Input:
public static void loadGameCharacterVariablesFromXML(GameCharacter character, StringBuilder log, Element parentElement, Document doc) {
    NodeList nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element element = (Element) nodes.item(0);
    if (((Element) element.getElementsByTagName("String_Node_Str").item(0)) != null) {
        character.setId(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getId());
    }
    if (!((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str").isEmpty()) {
        character.setName(new NameTriplet(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + ((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
    } else {
        Element nameElement = ((Element) element.getElementsByTagName("String_Node_Str").item(0));
        character.setName(new NameTriplet(nameElement.getAttribute("String_Node_Str"), nameElement.getAttribute("String_Node_Str"), nameElement.getAttribute("String_Node_Str")));
    }
    if (element.getElementsByTagName("String_Node_Str") != null && element.getElementsByTagName("String_Node_Str").getLength() > 0) {
        character.setSurname(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + ((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
    }
    character.setLevel(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
    CharacterUtils.appendToImportLog(log, "String_Node_Str" + Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        if (!((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str").equals("String_Node_Str")) {
            character.setSexualOrientation(SexualOrientation.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + SexualOrientation.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        } else {
            character.setSexualOrientation(SexualOrientation.AMBIPHILIC);
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + SexualOrientation.AMBIPHILIC);
        }
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setDescription(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        CharacterUtils.appendToImportLog(log, "String_Node_Str");
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setPlayerPetName(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getPlayerPetName());
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setPlayerKnowsName(Boolean.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.isPlayerKnowsName());
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setHistory(History.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getHistory());
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        String personality = ((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str");
        if (personality.equals("String_Node_Str")) {
            personality = "String_Node_Str";
        }
        character.setPersonality(Personality.valueOf(personality));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getPersonality());
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setObedience(Float.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getObedience());
    }
    boolean setGenderIdentity = false;
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setGenderIdentity(Gender.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getGenderIdentity());
        setGenderIdentity = true;
    }
    int extraLevelUpPoints = 0;
    if (element.getElementsByTagName("String_Node_Str").item(0) != null) {
        nodes = parentElement.getElementsByTagName("String_Node_Str");
        Element attElement = (Element) nodes.item(0);
        for (int i = 0; i < attElement.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) attElement.getElementsByTagName("String_Node_Str").item(i));
            try {
                character.setAttribute(Attribute.valueOf(e.getAttribute("String_Node_Str")), Float.valueOf(e.getAttribute("String_Node_Str")));
                CharacterUtils.appendToImportLog(log, "String_Node_Str" + Attribute.valueOf(e.getAttribute("String_Node_Str")).getName() + "String_Node_Str" + Float.valueOf(e.getAttribute("String_Node_Str")));
            } catch (IllegalArgumentException ex) {
            }
        }
    } else {
        extraLevelUpPoints = (Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) * 5);
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + (Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) * 5));
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setHealth(Float.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getHealth());
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setMana(Float.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getMana());
    }
    if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setStamina(Float.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getStamina());
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    if (nodes.getLength() > 0) {
        character.setPerkPoints((Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"))) - 1);
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + (Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) - 1));
        element = (Element) nodes.item(0);
        character.incrementExperience(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        character.setLevelUpPoints(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) + extraLevelUpPoints);
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + (Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) + extraLevelUpPoints));
    } else {
        character.incrementExperience(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        character.setLevelUpPoints(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) + extraLevelUpPoints);
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + (Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")) + extraLevelUpPoints));
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    element = (Element) nodes.item(0);
    if (element != null) {
        character.setLocation(WorldType.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")), new Vector2i(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")), Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"))), false);
        character.setHomeLocation(WorldType.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")), new Vector2i(Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")), Integer.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"))));
    } else {
        character.setLocation(new Vector2i(0, 0));
    }
    character.body = Body.loadFromXML(log, (Element) parentElement.getElementsByTagName("String_Node_Str").item(0), doc);
    if (!setGenderIdentity) {
        character.setGenderIdentity(character.getGender());
    }
    character.resetInventory();
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    element = (Element) nodes.item(0);
    if (element != null) {
        character.inventory = CharacterInventory.loadFromXML(element, doc);
    } else {
        CharacterCreation.getDressed(character, false);
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element attElement = (Element) nodes.item(0);
    if (attElement != null) {
        for (int i = 0; i < attElement.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) attElement.getElementsByTagName("String_Node_Str").item(i));
            try {
                character.addPotionEffect(Attribute.valueOf(e.getAttribute("String_Node_Str")), Float.valueOf(e.getAttribute("String_Node_Str")));
                CharacterUtils.appendToImportLog(log, "String_Node_Str" + Attribute.valueOf(e.getAttribute("String_Node_Str")).getName() + "String_Node_Str" + Float.valueOf(e.getAttribute("String_Node_Str")));
            } catch (IllegalArgumentException ex) {
            }
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    element = (Element) nodes.item(0);
    if (element != null) {
        for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
            try {
                if (!e.getAttribute("String_Node_Str").isEmpty()) {
                    if (Boolean.valueOf(e.getAttribute("String_Node_Str"))) {
                        if (Perk.valueOf(e.getAttribute("String_Node_Str")) != null) {
                            character.addPerk(Perk.valueOf(e.getAttribute("String_Node_Str")));
                            CharacterUtils.appendToImportLog(log, "String_Node_Str" + Perk.valueOf(e.getAttribute("String_Node_Str")).getName(character));
                        }
                    }
                } else {
                    if (Perk.valueOf(e.getAttribute("String_Node_Str")) != null) {
                        character.addPerk(Perk.valueOf(e.getAttribute("String_Node_Str")));
                        CharacterUtils.appendToImportLog(log, "String_Node_Str" + Perk.valueOf(e.getAttribute("String_Node_Str")).getName(character));
                    }
                }
            } catch (IllegalArgumentException ex) {
            }
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    element = (Element) nodes.item(0);
    if (element != null) {
        if (element.getElementsByTagName("String_Node_Str").item(0) != null && !((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str").isEmpty()) {
            for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
                Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
                try {
                    if (e.getAttribute("String_Node_Str").equals("String_Node_Str")) {
                        character.incrementEssenceCount(TFEssence.ARCANE, 5);
                        CharacterUtils.appendToImportLog(log, "String_Node_Str");
                    } else if (Fetish.valueOf(e.getAttribute("String_Node_Str")) != null) {
                        if (Boolean.valueOf(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"))) {
                            character.addFetish(Fetish.valueOf(e.getAttribute("String_Node_Str")));
                            CharacterUtils.appendToImportLog(log, "String_Node_Str" + Fetish.valueOf(e.getAttribute("String_Node_Str")).getName(character));
                        }
                    }
                } catch (IllegalArgumentException ex) {
                }
            }
        } else {
            for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
                Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
                try {
                    if (e.getAttribute("String_Node_Str").equals("String_Node_Str")) {
                        character.incrementEssenceCount(TFEssence.ARCANE, 5);
                        CharacterUtils.appendToImportLog(log, "String_Node_Str");
                    } else if (Fetish.valueOf(e.getAttribute("String_Node_Str")) != null) {
                        character.addFetish(Fetish.valueOf(e.getAttribute("String_Node_Str")));
                        CharacterUtils.appendToImportLog(log, "String_Node_Str" + Fetish.valueOf(e.getAttribute("String_Node_Str")).getName(character));
                    }
                } catch (IllegalArgumentException ex) {
                }
            }
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    element = (Element) nodes.item(0);
    for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
        Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
        try {
            if (Integer.valueOf(e.getAttribute("String_Node_Str")) != -1) {
                character.addStatusEffect(StatusEffect.valueOf(e.getAttribute("String_Node_Str")), Integer.valueOf(e.getAttribute("String_Node_Str")));
                CharacterUtils.appendToImportLog(log, "String_Node_Str" + StatusEffect.valueOf(e.getAttribute("String_Node_Str")).getName(character) + "String_Node_Str" + Integer.valueOf(e.getAttribute("String_Node_Str")) + "String_Node_Str");
            }
        } catch (IllegalArgumentException ex) {
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    element = (Element) nodes.item(0);
    if (element != null) {
        for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
            character.setAffection(e.getAttribute("String_Node_Str"), Float.valueOf(e.getAttribute("String_Node_Str")));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + Float.valueOf(e.getAttribute("String_Node_Str")));
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element pregnancyElement = (Element) nodes.item(0);
    if (pregnancyElement != null) {
        CharacterUtils.appendToImportLog(log, "String_Node_Str");
        character.setTimeProgressedToFinalPregnancyStage(Integer.valueOf(pregnancyElement.getAttribute("String_Node_Str")));
        nodes = pregnancyElement.getElementsByTagName("String_Node_Str");
        element = (Element) nodes.item(0);
        if (element != null) {
            for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
                Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
                character.getPotentialPartnersAsMother().add(PregnancyPossibility.loadFromXML(e, doc));
                CharacterUtils.appendToImportLog(log, "String_Node_Str");
            }
        }
        nodes = pregnancyElement.getElementsByTagName("String_Node_Str");
        element = (Element) nodes.item(0);
        if (element != null) {
            for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
                Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
                character.getPotentialPartnersAsFather().add(PregnancyPossibility.loadFromXML(e, doc));
                CharacterUtils.appendToImportLog(log, "String_Node_Str");
            }
        }
        nodes = pregnancyElement.getElementsByTagName("String_Node_Str");
        element = (Element) ((Element) nodes.item(0)).getElementsByTagName("String_Node_Str").item(0);
        if (element != null) {
            character.setPregnantLitter(Litter.loadFromXML(element, doc));
            CharacterUtils.appendToImportLog(log, "String_Node_Str");
        }
        nodes = pregnancyElement.getElementsByTagName("String_Node_Str");
        element = (Element) nodes.item(0);
        if (element != null) {
            for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
                Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
                character.getLittersBirthed().add(Litter.loadFromXML(e, doc));
                CharacterUtils.appendToImportLog(log, "String_Node_Str");
            }
        }
        nodes = pregnancyElement.getElementsByTagName("String_Node_Str");
        element = (Element) nodes.item(0);
        if (element != null) {
            for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
                Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
                character.getLittersFathered().add(Litter.loadFromXML(e, doc));
                CharacterUtils.appendToImportLog(log, "String_Node_Str");
            }
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element familyElement = (Element) nodes.item(0);
    if (familyElement != null) {
        character.setMother(((Element) familyElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        character.setFather(((Element) familyElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        character.setDayOfConception(Integer.valueOf(((Element) familyElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        character.setDayOfBirth(Integer.valueOf(((Element) familyElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element slaveryElement = (Element) nodes.item(0);
    if (slaveryElement != null) {
        for (int i = 0; i < ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(0)).getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(i));
            character.getSlavesOwned().add(e.getAttribute("String_Node_Str"));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str"));
        }
        character.setOwner(((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getOwnerId());
        character.setSlaveJob(SlaveJob.valueOf(((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getSlaveJob());
        for (int i = 0; i < ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(0)).getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(i));
            SlaveJobSetting setting = SlaveJobSetting.valueOf(e.getAttribute("String_Node_Str"));
            character.addSlaveJobSettings(setting);
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + setting);
        }
        for (int i = 0; i < ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(0)).getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(i));
            SlavePermission slavePermission = SlavePermission.valueOf(e.getAttribute("String_Node_Str"));
            for (int j = 0; j < e.getElementsByTagName("String_Node_Str").getLength(); j++) {
                Element e2 = ((Element) e.getElementsByTagName("String_Node_Str").item(j));
                SlavePermissionSetting setting = SlavePermissionSetting.valueOf(e2.getAttribute("String_Node_Str"));
                character.addSlavePermissionSetting(slavePermission, setting);
                CharacterUtils.appendToImportLog(log, "String_Node_Str" + slavePermission + "String_Node_Str" + setting);
            }
        }
        Element workHourElement = ((Element) slaveryElement.getElementsByTagName("String_Node_Str").item(0));
        for (int i = 0; i < character.workHours.length; i++) {
            character.workHours[i] = Boolean.valueOf(workHourElement.getAttribute("String_Node_Str" + String.valueOf(i)));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + i + "String_Node_Str" + character.workHours[i]);
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element sexStatsElement = (Element) nodes.item(0);
    if (sexStatsElement.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setSexConsensualCount(Integer.valueOf(((Element) sexStatsElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getSexConsensualCount());
    }
    if (sexStatsElement.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setSexAsSubCount(Integer.valueOf(((Element) sexStatsElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getSexAsSubCount());
    }
    if (sexStatsElement.getElementsByTagName("String_Node_Str").getLength() != 0) {
        character.setSexAsDomCount(Integer.valueOf(((Element) sexStatsElement.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str")));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getSexAsDomCount());
    }
    element = (Element) ((Element) nodes.item(0)).getElementsByTagName("String_Node_Str").item(0);
    for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
        Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
        try {
            for (int it = 0; it < Integer.valueOf(e.getAttribute("String_Node_Str")); it++) character.incrementCumCount(new SexType(PenetrationType.valueOf(e.getAttribute("String_Node_Str")), OrificeType.valueOf(e.getAttribute("String_Node_Str"))));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + Integer.valueOf(e.getAttribute("String_Node_Str")));
        } catch (IllegalArgumentException ex) {
        }
    }
    element = (Element) ((Element) nodes.item(0)).getElementsByTagName("String_Node_Str").item(0);
    for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
        Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
        try {
            for (int it = 0; it < Integer.valueOf(e.getAttribute("String_Node_Str")); it++) character.incrementSexCount(new SexType(PenetrationType.valueOf(e.getAttribute("String_Node_Str")), OrificeType.valueOf(e.getAttribute("String_Node_Str"))));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + Integer.valueOf(e.getAttribute("String_Node_Str")));
        } catch (IllegalArgumentException ex) {
        }
    }
    element = (Element) ((Element) nodes.item(0)).getElementsByTagName("String_Node_Str").item(0);
    for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
        Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
        character.setVirginityLoss(new SexType(PenetrationType.valueOf(e.getAttribute("String_Node_Str")), OrificeType.valueOf(e.getAttribute("String_Node_Str"))), e.getAttribute("String_Node_Str"));
        CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str");
    }
    element = (Element) ((Element) nodes.item(0)).getElementsByTagName("String_Node_Str").item(0);
    if (element != null) {
        for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
            character.sexPartnerMap.put(e.getAttribute("String_Node_Str"), new HashMap<>());
            for (int j = 0; j < element.getElementsByTagName("String_Node_Str").getLength(); j++) {
                Element e2 = ((Element) element.getElementsByTagName("String_Node_Str").item(j));
                character.sexPartnerMap.get(e.getAttribute("String_Node_Str")).put(new SexType(PenetrationType.valueOf(e2.getAttribute("String_Node_Str")), OrificeType.valueOf(e2.getAttribute("String_Node_Str"))), Integer.valueOf(e2.getAttribute("String_Node_Str")));
                CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e2.getAttribute("String_Node_Str") + "String_Node_Str" + e2.getAttribute("String_Node_Str") + "String_Node_Str" + Integer.valueOf(e2.getAttribute("String_Node_Str")));
            }
        }
    }
    nodes = parentElement.getElementsByTagName("String_Node_Str");
    Element addictionsElement = (Element) nodes.item(0);
    if (addictionsElement != null) {
        element = (Element) addictionsElement.getElementsByTagName("String_Node_Str").item(0);
        for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
            character.setAddiction(FluidType.valueOf(e.getAttribute("String_Node_Str")), Integer.valueOf(e.getAttribute("String_Node_Str")));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e.getAttribute("String_Node_Str"));
        }
        element = (Element) addictionsElement.getElementsByTagName("String_Node_Str").item(0);
        for (int i = 0; i < element.getElementsByTagName("String_Node_Str").getLength(); i++) {
            Element e = ((Element) element.getElementsByTagName("String_Node_Str").item(i));
            character.setLastTimeSatisfiedAddiction(FluidType.valueOf(e.getAttribute("String_Node_Str")), Long.valueOf(e.getAttribute("String_Node_Str")));
            CharacterUtils.appendToImportLog(log, "String_Node_Str" + e.getAttribute("String_Node_Str") + "String_Node_Str" + e.getAttribute("String_Node_Str"));
        }
    }
}

Output:
     if (element.getElementsByTagName("String_Node_Str").getLength() != 0) {
-        character.setPlayerPetName(((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str"));
-        CharacterUtils.appendToImportLog(log, "String_Node_Str" + character.getPlayerPetName());
+        String petName = ((Element) element.getElementsByTagName("String_Node_Str").item(0)).getAttribute("String_Node_Str");
+        character.setPlayerPetName(petName);
+        CharacterUtils.appendToImportLog(log, "String_Node_Str" + petName);
     }


Input:
public void createProject(final String jobId, final String repositoryName, final String projectName) {
    logger.info("String_Node_Str" + repositoryName + "String_Node_Str" + projectName);
    JobResult result = new JobResult();
    result.setJobId(jobId);
    org.uberfire.java.nio.file.Path repositoryPath = getRepositoryRootPath(repositoryName);
    if (repositoryPath == null) {
        result.setStatus(JobStatus.RESOURCE_NOT_EXIST);
        result.setResult("String_Node_Str" + repositoryName + "String_Node_Str");
        jobResultEvent.fire(result);
        return;
    } else {
        POM pom = new POM();
        pom.getGav().setArtifactId(projectName);
        pom.getGav().setGroupId(projectName);
        pom.getGav().setVersion("String_Node_Str");
        try {
            Project project = projectService.newProject(makeRepository(Paths.convert(repositoryPath)), projectName, pom, "String_Node_Str");
        } catch (org.uberfire.java.nio.file.FileAlreadyExistsException e) {
            result.setStatus(JobStatus.DUPLICATE_RESOURCE);
            result.setResult("String_Node_Str" + projectName + "String_Node_Str");
            jobResultEvent.fire(result);
            return;
        }
        result.setStatus(JobStatus.SUCCESS);
        jobResultEvent.fire(result);
    }
}

Output:
         try {
-            Project project = projectService.newProject(makeRepository(Paths.convert(repositoryPath)), projectName, pom, "String_Node_Str");
+            projectService.newProject(makeRepository(Paths.convert(repositoryPath)), projectName, pom, "String_Node_Str");
         } catch (org.uberfire.java.nio.file.FileAlreadyExistsException e) {


Input:
private void refreshTableLogo(List<Logo> logoList) {
    LOGGER.info("String_Node_Str");
    this.logoList.clear();
    this.logoList.add(new Profile.PairLogoRelativeRectangle(new Logo("String_Node_Str", "String_Node_Str"), new RelativeRectangle(100, 200, 200, 200)));
    this.logoList.add(new Profile.PairLogoRelativeRectangle(new Logo("String_Node_Str", "String_Node_Str"), new RelativeRectangle(100, 200, 200, 200)));
    tableLogo.setItems(this.logoList);
}

Output:
     this.logoList.clear();
-    this.logoList.add(new Profile.PairLogoRelativeRectangle(new Logo("String_Node_Str", "String_Node_Str"), new RelativeRectangle(100, 200, 200, 200)));
-    this.logoList.add(new Profile.PairLogoRelativeRectangle(new Logo("String_Node_Str", "String_Node_Str"), new RelativeRectangle(100, 200, 200, 200)));
+    this.logoList.addAll(logoList);
     tableLogo.setItems(this.logoList);


Input:
public long get() {
    long value = 0;
    return value;
}

Output:
 public long get() {
-    long value = 0;
+    long value;
     return value;


Input:
public String getKeyValue() throws DataException {
    try {
        if (keyValue != null) {
            if (keyValue instanceof String)
                return (String) this.keyValue;
            if (keyValue instanceof SoftReference) {
                String result = ((SoftReference<String>) keyValue).get();
                if (result != null)
                    return result;
            }
        }
        if (keyStream == null)
            return null;
        this.keyStream.seek(this.keyOffset);
        this.keyValue = new SoftReference<String>(IOUtil.readString(new DataInputStream(this.keyStream)));
        return ((SoftReference<String>) this.keyValue).get();
    } catch (IOException e) {
        throw new DataException(e.getLocalizedMessage(), e);
    }
}

Output:
             return null;
-        this.keyStream.seek(this.keyOffset);
-        this.keyValue = new SoftReference<String>(IOUtil.readString(new DataInputStream(this.keyStream)));
+        synchronized (this.keyStream) {
+            if (keyValue != null) {
+                if (keyValue instanceof String)
+                    return (String) this.keyValue;
+                if (keyValue instanceof SoftReference) {
+                    String result = ((SoftReference<String>) keyValue).get();
+                    if (result != null)
+                        return result;
+                }
+            }
+            this.keyStream.seek(this.keyOffset);
+            this.keyValue = new SoftReference<String>(IOUtil.readString(new DataInputStream(this.keyStream)));
+        }
         return ((SoftReference<String>) this.keyValue).get();


Input:
public static String convertLibrary(SWF swf, Map<Integer, String> characterVariables, Map<Integer, String> characterClasses, List<Integer> oneInstanceShapes, String backgroundColor, List<Tag> tags, HashMap<Integer, CharacterTag> characters, HashMap<String, byte[]> files) {
    String ret = "String_Node_Str";
    List<String> media = new ArrayList<>();
    List<String> symbols = new ArrayList<>();
    for (int ch : characters.keySet()) {
        CharacterTag symbol = characters.get(ch);
        if ((symbol instanceof ShapeTag) && oneInstanceShapes.contains(symbol.getCharacterID())) {
            continue;
        }
        if ((symbol instanceof ShapeTag) || (symbol instanceof DefineSpriteTag) || (symbol instanceof ButtonTag)) {
            String symbolStr = "String_Node_Str";
            symbolStr += "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str" + getTimestamp() + "String_Node_Str";
            if (symbol instanceof ShapeTag) {
                symbolStr += "String_Node_Str";
            } else if (symbol instanceof ButtonTag) {
                symbolStr += "String_Node_Str";
                if (((ButtonTag) symbol).trackAsMenu()) {
                    symbolStr += "String_Node_Str";
                }
            }
            boolean linkageExportForAS = false;
            if (characterClasses.containsKey(symbol.getCharacterID())) {
                linkageExportForAS = true;
                symbolStr += "String_Node_Str" + xmlString(characterClasses.get(symbol.getCharacterID())) + "String_Node_Str";
            }
            if (characterVariables.containsKey(symbol.getCharacterID())) {
                linkageExportForAS = true;
                symbolStr += "String_Node_Str" + xmlString(characterVariables.get(symbol.getCharacterID())) + "String_Node_Str";
            }
            if (linkageExportForAS) {
                symbolStr += "String_Node_Str";
            }
            symbolStr += "String_Node_Str";
            symbolStr += "String_Node_Str";
            String itemIcon = null;
            if (symbol instanceof ButtonTag) {
                itemIcon = "String_Node_Str";
                symbolStr += "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str";
                symbolStr += "String_Node_Str";
                ButtonTag button = (ButtonTag) symbol;
                List<BUTTONRECORD> records = button.getRecords();
                String[] frames = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
                int maxDepth = 0;
                for (BUTTONRECORD rec : records) {
                    if (rec.placeDepth > maxDepth) {
                        maxDepth = rec.placeDepth;
                    }
                }
                for (int i = maxDepth; i >= 1; i--) {
                    symbolStr += "String_Node_Str" + (maxDepth - i + 1) + "String_Node_Str";
                    if (i == 1) {
                        symbolStr += "String_Node_Str";
                    }
                    symbolStr += "String_Node_Str";
                    symbolStr += "String_Node_Str";
                    int lastFrame = 0;
                    loopframes: for (int frame = 1; frame <= 4; frame++) {
                        for (BUTTONRECORD rec : records) {
                            if (rec.placeDepth == i) {
                                boolean ok = false;
                                switch(frame) {
                                    case 1:
                                        ok = rec.buttonStateUp;
                                        break;
                                    case 2:
                                        ok = rec.buttonStateOver;
                                        break;
                                    case 3:
                                        ok = rec.buttonStateDown;
                                        break;
                                    case 4:
                                        ok = rec.buttonStateHitTest;
                                        break;
                                }
                                if (!ok) {
                                    continue;
                                }
                                CXFORMWITHALPHA colorTransformAlpha = null;
                                int blendMode = 0;
                                List<FILTER> filters = new ArrayList<>();
                                if (button instanceof DefineButton2Tag) {
                                    colorTransformAlpha = rec.colorTransform;
                                    if (rec.buttonHasBlendMode) {
                                        blendMode = rec.blendMode;
                                    }
                                    if (rec.buttonHasFilterList) {
                                        filters = rec.filterList;
                                    }
                                }
                                CharacterTag character = characters.get(rec.characterId);
                                MATRIX matrix = rec.placeMatrix;
                                String recCharStr = "String_Node_Str";
                                if (character instanceof TextTag) {
                                    recCharStr = convertText(tags, (TextTag) character, matrix, filters);
                                } else if (character instanceof DefineVideoStreamTag) {
                                    recCharStr = convertVideoInstance(matrix, (DefineVideoStreamTag) character);
                                } else {
                                    recCharStr = convertSymbolInstance(null, matrix, null, colorTransformAlpha, false, blendMode, filters, true, null, characters.get(rec.characterId), characters, tags);
                                }
                                int duration = frame - lastFrame;
                                lastFrame = frame;
                                if (duration > 0) {
                                    if (duration > 1) {
                                        symbolStr += "String_Node_Str";
                                        symbolStr += (frame - duration);
                                        symbolStr += "String_Node_Str";
                                        symbolStr += "String_Node_Str" + (duration - 1) + "String_Node_Str";
                                        symbolStr += "String_Node_Str" + KEY_MODE_NORMAL + "String_Node_Str";
                                        symbolStr += "String_Node_Str";
                                        symbolStr += "String_Node_Str";
                                        symbolStr += "String_Node_Str";
                                    }
                                    symbolStr += "String_Node_Str";
                                    symbolStr += (frame - 1);
                                    symbolStr += "String_Node_Str";
                                    symbolStr += "String_Node_Str" + KEY_MODE_NORMAL + "String_Node_Str";
                                    symbolStr += "String_Node_Str";
                                    symbolStr += recCharStr;
                                    symbolStr += "String_Node_Str";
                                    symbolStr += "String_Node_Str";
                                }
                            }
                        }
                    }
                    symbolStr += "String_Node_Str";
                    symbolStr += "String_Node_Str";
                }
                symbolStr += "String_Node_Str";
                symbolStr += "String_Node_Str";
            } else if (symbol instanceof DefineSpriteTag) {
                DefineSpriteTag sprite = (DefineSpriteTag) symbol;
                if (sprite.subTags.isEmpty()) {
                    continue;
                }
                symbolStr += convertTimeline(sprite.spriteId, oneInstanceShapes, backgroundColor, tags, sprite.getSubTags(), characters, "String_Node_Str" + symbol.getCharacterID());
            } else if (symbol instanceof ShapeTag) {
                itemIcon = "String_Node_Str";
                ShapeTag shape = (ShapeTag) symbol;
                symbolStr += "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str";
                symbolStr += "String_Node_Str";
                symbolStr += convertShape(characters, null, shape);
                symbolStr += "String_Node_Str";
                symbolStr += "String_Node_Str";
            }
            symbolStr += "String_Node_Str";
            symbolStr += "String_Node_Str";
            symbolStr = prettyFormatXML(symbolStr);
            String symbolFile = "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str";
            try {
                files.put(symbolFile, symbolStr.getBytes("String_Node_Str"));
            } catch (UnsupportedEncodingException ex) {
                Logger.getLogger(XFLConverter.class.getName()).log(Level.SEVERE, null, ex);
            }
            String symbLinkStr = "String_Node_Str";
            symbLinkStr += "String_Node_Str" + symbolFile + "String_Node_Str";
            if (itemIcon != null) {
                symbLinkStr += "String_Node_Str" + itemIcon + "String_Node_Str";
            }
            symbLinkStr += "String_Node_Str" + getTimestamp() + "String_Node_Str";
            symbols.add(symbLinkStr);
        } else if (symbol instanceof ImageTag) {
            ImageTag imageTag = (ImageTag) symbol;
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            BufferedImage image = imageTag.getImage(tags);
            String format = imageTag.getImageFormat();
            try {
                ImageIO.write(image, format.toUpperCase(), baos);
            } catch (IOException ex) {
                Logger.getLogger(XFLConverter.class.getName()).log(Level.SEVERE, null, ex);
            }
            String symbolFile = "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str" + imageTag.getImageFormat();
            files.put(symbolFile, baos.toByteArray());
            String mediaLinkStr = "String_Node_Str" + symbolFile + "String_Node_Str" + getTimestamp() + "String_Node_Str" + baos.toByteArray().length + "String_Node_Str";
            if (format.equals("String_Node_Str") || format.equals("String_Node_Str")) {
                mediaLinkStr += "String_Node_Str";
            } else if (format.equals("String_Node_Str")) {
                mediaLinkStr += "String_Node_Str";
            }
            if (characterClasses.containsKey(symbol.getCharacterID())) {
                mediaLinkStr += "String_Node_Str" + characterClasses.get(symbol.getCharacterID()) + "String_Node_Str";
            }
            mediaLinkStr += "String_Node_Str" + symbolFile + "String_Node_Str" + (media.size() + 1) + "String_Node_Str" + getTimestamp() + "String_Node_Str" + image.getWidth() + "String_Node_Str" + image.getHeight() + "String_Node_Str";
            media.add(mediaLinkStr);
        } else if ((symbol instanceof SoundStreamHeadTypeTag) || (symbol instanceof DefineSoundTag)) {
            int soundFormat = 0;
            int soundRate = 0;
            int soundType = 0;
            int soundSize = 0;
            long soundSampleCount = 0;
            byte[] soundData = new byte[0];
            int[] rateMap = { 5, 11, 22, 44 };
            String exportFormat = "String_Node_Str";
            if (symbol instanceof SoundStreamHeadTypeTag) {
                SoundStreamHeadTypeTag sstream = (SoundStreamHeadTypeTag) symbol;
                soundFormat = sstream.getSoundFormat();
                soundRate = sstream.getSoundRate();
                soundType = sstream.getSoundType();
                soundSize = sstream.getSoundSize();
                soundSampleCount = sstream.getSoundSampleCount();
                boolean found = false;
                for (Tag t : tags) {
                    if (found && (t instanceof SoundStreamBlockTag)) {
                        SoundStreamBlockTag bl = (SoundStreamBlockTag) t;
                        soundData = bl.getData(SWF.DEFAULT_VERSION);
                        break;
                    }
                    if (t == symbol) {
                        found = true;
                    }
                }
            } else if (symbol instanceof DefineSoundTag) {
                DefineSoundTag sound = (DefineSoundTag) symbol;
                soundFormat = sound.soundFormat;
                soundRate = sound.soundRate;
                soundType = sound.soundType;
                soundData = sound.soundData;
                soundSize = sound.soundSize;
                soundSampleCount = sound.soundSampleCount;
            }
            int format = 0;
            int bits = 0;
            if ((soundFormat == DefineSoundTag.FORMAT_ADPCM) || (soundFormat == DefineSoundTag.FORMAT_UNCOMPRESSED_LITTLE_ENDIAN) || (soundFormat == DefineSoundTag.FORMAT_UNCOMPRESSED_NATIVE_ENDIAN)) {
                if (soundType == 1) {
                    format += 1;
                }
                switch(soundRate) {
                    case 0:
                        format += 2;
                        break;
                    case 1:
                        format += 6;
                        break;
                    case 2:
                        format += 10;
                        break;
                    case 3:
                        format += 14;
                        break;
                }
            }
            if (soundFormat == DefineSoundTag.FORMAT_SPEEX) {
                bits = 18;
            }
            if (soundFormat == DefineSoundTag.FORMAT_ADPCM) {
                SWFInputStream sis = new SWFInputStream(new ByteArrayInputStream(soundData), SWF.DEFAULT_VERSION);
                exportFormat = "String_Node_Str";
                try {
                    int adpcmCodeSize = (int) sis.readUB(2);
                    bits = 2 + adpcmCodeSize;
                } catch (IOException ex) {
                    Logger.getLogger(XFLConverter.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            if (soundFormat == DefineSoundTag.FORMAT_MP3) {
                exportFormat = "String_Node_Str";
                if (soundType == 0) {
                    format += 1;
                }
                format += 4;
                SWFInputStream sis = new SWFInputStream(new ByteArrayInputStream(soundData), SWF.DEFAULT_VERSION);
                try {
                    sis.readSI16();
                    MP3FRAME frame = new MP3FRAME(sis);
                    int bitRate = frame.getBitrate();
                    switch(bitRate) {
                        case 8:
                            bits = 6;
                            break;
                        case 16:
                            bits = 7;
                            break;
                        case 20:
                            bits = 8;
                            break;
                        case 24:
                            bits = 9;
                            break;
                        case 32:
                            bits = 10;
                            break;
                        case 48:
                            bits = 11;
                            break;
                        case 56:
                            bits = 12;
                            break;
                        case 64:
                            bits = 13;
                            break;
                        case 80:
                            bits = 14;
                            break;
                        case 112:
                            bits = 15;
                            break;
                        case 128:
                            bits = 16;
                            break;
                        case 160:
                            bits = 17;
                            break;
                    }
                } catch (IOException ex) {
                    Logger.getLogger(XFLConverter.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            byte[] data = new byte[0];
            try {
                data = swf.exportSound(symbol);
            } catch (IOException ex) {
                Logger.getLogger(XFLConverter.class.getName()).log(Level.SEVERE, null, ex);
            }
            if (!exportFormat.equals("String_Node_Str")) {
                String symbolFile = "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str" + exportFormat;
                files.put(symbolFile, data);
                String mediaLinkStr = "String_Node_Str" + symbolFile + "String_Node_Str" + getTimestamp() + "String_Node_Str" + data.length + "String_Node_Str";
                mediaLinkStr += "String_Node_Str" + symbolFile + "String_Node_Str";
                mediaLinkStr += "String_Node_Str";
                mediaLinkStr += rateMap[soundRate] + "String_Node_Str";
                mediaLinkStr += "String_Node_Str" + (soundSize == 1 ? "String_Node_Str" : "String_Node_Str");
                mediaLinkStr += "String_Node_Str" + (soundType == 1 ? "String_Node_Str" : "String_Node_Str");
                mediaLinkStr += "String_Node_Str";
                mediaLinkStr += "String_Node_Str" + format + "String_Node_Str" + bits + "String_Node_Str" + soundSampleCount + "String_Node_Str";
                if (characterClasses.containsKey(symbol.getCharacterID())) {
                    mediaLinkStr += "String_Node_Str" + characterClasses.get(symbol.getCharacterID()) + "String_Node_Str";
                }
                if (characterVariables.containsKey(symbol.getCharacterID())) {
                    mediaLinkStr += "String_Node_Str" + xmlString(characterVariables.get(symbol.getCharacterID())) + "String_Node_Str";
                }
                mediaLinkStr += "String_Node_Str";
                media.add(mediaLinkStr);
            }
        } else if (symbol instanceof DefineVideoStreamTag) {
            DefineVideoStreamTag video = (DefineVideoStreamTag) symbol;
            String videoType = "String_Node_Str";
            switch(video.codecID) {
                case 2:
                    videoType = "String_Node_Str";
                    break;
                case 3:
                    videoType = "String_Node_Str";
                    break;
                case 4:
                    videoType = "String_Node_Str";
                    break;
                case 5:
                    videoType = "String_Node_Str";
                    break;
            }
            byte[] data = new byte[0];
            try {
                data = swf.exportMovie(video);
            } catch (IOException ex) {
                Logger.getLogger(XFLConverter.class.getName()).log(Level.SEVERE, null, ex);
            }
            String symbolFile = "String_Node_Str" + symbol.getCharacterID() + "String_Node_Str" + "String_Node_Str";
            files.put(symbolFile, data);
            String mediaLinkStr = "String_Node_Str" + symbolFile + "String_Node_Str" + getTimestamp() + "String_Node_Str" + data.length + "String_Node_Str";
            mediaLinkStr += "String_Node_Str" + symbolFile + "String_Node_Str";
            mediaLinkStr += "String_Node_Str" + videoType + "String_Node_Str";
            mediaLinkStr += "String_Node_Str" + swf.frameRate + "String_Node_Str";
            mediaLinkStr += "String_Node_Str" + video.width + "String_Node_Str";
            mediaLinkStr += "String_Node_Str" + video.height + "String_Node_Str";
            double len = ((double) video.numFrames) / ((double) swf.frameRate);
            mediaLinkStr += "String_Node_Str" + len + "String_Node_Str";
            if (characterClasses.containsKey(symbol.getCharacterID())) {
                mediaLinkStr += "String_Node_Str" + characterClasses.get(symbol.getCharacterID()) + "String_Node_Str";
            }
            if (characterVariables.containsKey(symbol.getCharacterID())) {
                mediaLinkStr += "String_Node_Str" + xmlString(characterVariables.get(symbol.getCharacterID())) + "String_Node_Str";
            }
            mediaLinkStr += "String_Node_Str";
            media.add(mediaLinkStr);
        }
    }
    if (!media.isEmpty()) {
        ret += "String_Node_Str";
        for (String m : media) {
            ret += m;
        }
        ret += "String_Node_Str";
    }
    if (!symbols.isEmpty()) {
        ret += "String_Node_Str";
        for (String s : symbols) {
            ret += s;
        }
        ret += "String_Node_Str";
    }
    return ret;
}

Output:
                     }
-                    symbolStr += "String_Node_Str";
+                    symbolStr += "String_Node_Str" + randomOutlineColor() + "String_Node_Str";
                     symbolStr += "String_Node_Str";


Input:
public Vector<TextField> getImageFields() {
    if (store.get(Names.imageFields) instanceof Vector<?>) {
        Vector<?> list = (Vector<?>) store.get(Names.imageFields);
        if (list != null && list.size() > 0) {
            Object obj = list.get(0);
            if (obj instanceof TextField) {
                return (Vector<TextField>) list;
            } else if (obj instanceof Hashtable) {
                Vector<TextField> newList = new Vector<TextField>();
                for (Object hashObj : list) {
                    newList.add(new TextField((Hashtable) hashObj));
                }
                return newList;
            }
        }
    }
    return null;
}

Output:
             Object obj = list.get(0);
-            if (obj instanceof TextField) {
-                return (Vector<TextField>) list;
+            if (obj instanceof ImageField) {
+                return (Vector<ImageField>) list;
             } else if (obj instanceof Hashtable) {


Input:
private void createUI() {
    destroyChildren();
    Rectangle bounds = getBounds();
    this.title = new Label("String_Node_Str");
    this.title.setTheme(theme);
    this.title.setBounds(new Rectangle(bounds));
    this.title.getBounds().height = 30;
    this.title.getBounds().y += 30;
    this.title.setFont(theme.getSecondaryFontName());
    this.title.setHorizontalTextAlignment(TextAlignment.CENTER);
    this.title.setTextSize(28);
    refreshButtons();
    this.cancel = new Button();
    this.cancel.setText("String_Node_Str");
    this.cancel.setBounds(new Rectangle(0, 0, 100, 40));
    this.cancel.getBounds().centerAround(bounds.x + 205, bounds.y + bounds.height - 20);
    this.cancel.setEnableGradiant(false);
    this.cancel.setTheme(theme);
    this.cancel.getTextLabel().setFont(theme.getSecondaryFontName());
    this.cancel.getTextLabel().setForegroundColor(theme.getForegroundColor());
    this.cancel.setTextSize(22);
    this.cancel.setHoverTextSize(26);
    this.cancel.addOnButtonClickedListener(new OnButtonClickedListener() {
        public void onButtonClicked(ButtonEvent event) {
            owner.close();
        }
    });
    addWidget(cancel);
    addWidget(title);
}

Output:
     this.title.setBounds(new Rectangle(bounds));
-    this.title.getBounds().height = 30;
-    this.title.getBounds().y += 30;
+    this.title.getBounds().height = 15;
+    this.title.getBounds().y += 20;
     this.title.setFont(theme.getSecondaryFontName());


Input:
public boolean isSubtypeOf(ClassInfo classInfo) {
    if (!classInfo.isInterface()) {
        return classInfo.isSuperclassOf(this);
    }
    Set<ClassInfo> supers = getAllSuperClasses();
    return supers.contains(classInfo);
}

Output:
     }
-    Set<ClassInfo> supers = getAllSuperClasses();
+    Set<ClassInfo> supers = getAncestors();
     return supers.contains(classInfo);


Input:
public static GenBookBackendState getGenBookBackendState(SwordBookMetaData metadata) throws BookException {
    ensureNotShuttingDown();
    GenBookBackendState state = getInstance(metadata);
    if (state == null) {
        state = new GenBookBackendState(metadata);
    }
    return state;
}

Output:
     if (state == null) {
-        state = new GenBookBackendState(metadata);
+        LOGGER.trace("String_Node_Str", metadata.getInitials());
+        return new GenBookBackendState(metadata);
     }


Input:
protected void afterHookedMethod(MethodHookParam param) throws Throwable {
    X2oolsSharedPreferences prefs = new X2oolsSharedPreferences();
    int tintColor = prefs.getInt(X2oolsActivity.KEY_STATUS_COLOR, Color.TRANSPARENT);
    if (tintColor == Color.TRANSPARENT) {
        Activity activity = (Activity) ((View) param.thisObject).getContext();
        XSystemUI.changeColorAuto(activity, true);
    }
}

Output:
         Activity activity = (Activity) ((View) param.thisObject).getContext();
-        XSystemUI.changeColorAuto(activity, true);
+        XPhoneStatusBar.changeColorAuto(activity, true);
     }


Input:
void commitCurrentLogUnit() {
    if (DEBUG) {
        Log.d(TAG, "String_Node_Str" + (mCurrentLogUnit.hasWord() ? "String_Node_Str" + mCurrentLogUnit.getWord() : "String_Node_Str"));
    }
    if (!mCurrentLogUnit.isEmpty()) {
        if (mMainLogBuffer != null) {
            mMainLogBuffer.shiftIn(mCurrentLogUnit);
            if (mMainLogBuffer.isSafeToLog() && mMainResearchLog != null) {
                publishLogBuffer(mMainLogBuffer, mMainResearchLog, true);
                mMainLogBuffer.resetWordCounter();
            }
        }
        if (mFeedbackLogBuffer != null) {
            mFeedbackLogBuffer.shiftIn(mCurrentLogUnit);
        }
        mCurrentLogUnit = new LogUnit();
    }
}

Output:
             mMainLogBuffer.shiftIn(mCurrentLogUnit);
-            if (mMainLogBuffer.isSafeToLog() && mMainResearchLog != null) {
+            if ((mMainLogBuffer.isSafeToLog() || LOG_EVERYTHING) && mMainResearchLog != null) {
                 publishLogBuffer(mMainLogBuffer, mMainResearchLog, true);


Input:
public void onTabClick(int position) {
    if (this.tabs != null && position < this.tabs.length()) {
        JSONObject entry = this.tabs.optJSONObject(position);
        String url = entry.optString("String_Node_Str");
        String javascript = entry.optString("String_Node_Str");
        if (url != null && !url.isEmpty()) {
            if (javascript != null)
                mainActivity.loadUrlAndJavascript(url, javascript);
            else
                mainActivity.loadUrl(url);
        }
    }
}

Output:
             if (javascript != null)
-                mainActivity.loadUrlAndJavascript(url, javascript);
+                mainActivity.loadUrlAndJavascript(url, javascript, true);
             else


Input:
public Collection<ParameterEnum<?>> getParameters() {
    return Arrays.asList(new ParameterEnum<?>[] { StoreParam.STORE });
}

Output:
 public Collection<ParameterEnum<?>> getParameters() {
-    return Arrays.asList(new ParameterEnum<?>[] { StoreParam.STORE });
+    return Arrays.asList(new ParameterEnum<?>[] { StoreParam.INPUT_STORE });
 }


Input:
public void testVirtualUpRefs() {
    ListImpl listWithExport = new ListImpl();
    FooImpl listNoExport = new FooImpl();
    Collection collectionWithExport = alwaysTrue() ? listWithExport : listNoExport;
    collectionWithExport.add("String_Node_Str");
    assertEquals("String_Node_Str", listWithExport.x);
    Collection collectionNoExport = alwaysTrue() ? listNoExport : listWithExport;
    collectionNoExport.add("String_Node_Str");
    assertEquals("String_Node_Str", listNoExport.x);
    listNoExport.add("String_Node_Str");
    assertEquals("String_Node_Str", listNoExport.x);
    listWithExport.add("String_Node_Str");
    assertEquals("String_Node_Str", listWithExport.x);
}

Output:
     FooImpl listNoExport = new FooImpl();
-    Collection collectionWithExport = alwaysTrue() ? listWithExport : listNoExport;
+    Collection collectionWithExport = listWithExport;
     collectionWithExport.add("String_Node_Str");


Input:
public void readFromNBT(NBTTagCompound nbt) {
    super.readFromNBT(nbt);
    pearlTypes = EnhancementEnumHelper.deserialize(nbt.getString("String_Node_Str"), EnderPearlEnhancements.class);
    life = nbt.getShort("String_Node_Str");
}

Output:
     super.readFromNBT(nbt);
-    pearlTypes = EnhancementEnumHelper.deserialize(nbt.getString("String_Node_Str"), EnderPearlEnhancements.class);
+    enhancements.deserialize(nbt.getString("String_Node_Str"));
     life = nbt.getShort("String_Node_Str");


Input:
public DBNode getFirst() {
    moveRtx();
    final AbstractTemporalAxis axis = new FirstAxisTest(mRtx.getSession(), mNodeKey);
    return axis.hasNext() ? new DBNode(axis.getTrx(), mCollection) : null;
}

Output:
     moveRtx();
-    final AbstractTemporalAxis axis = new FirstAxisTest(mRtx.getSession(), mNodeKey);
+    final AbstractTemporalAxis axis = new FirstAxis(mRtx.getSession(), mNodeKey);
     return axis.hasNext() ? new DBNode(axis.getTrx(), mCollection) : null;


Input:
private void saveProjectData(String dirName) {
    if (dirName.charAt(dirName.length() - 1) != File.separatorChar) {
        dirName += File.separator;
    }
    File tempDirFile = new File(dirName);
    tempDirFile.mkdir();
    AUseCase useCase = (AUseCase) GeneralManager.get().getUseCase(EDataDomain.GENETIC_DATA);
    LoadDataParameters parameters = useCase.getLoadDataParameters();
    FileOperations.writeInputStreamToFile(dirName + SET_DATA_FILE_NAME, GeneralManager.get().getResourceLoader().getInputSource(parameters.getFileName()).getByteStream());
    SerializationManager serializationManager = GeneralManager.get().getSerializationManager();
    JAXBContext projectContext = serializationManager.getProjectContext();
    try {
        Marshaller marshaller = projectContext.createMarshaller();
        saveVirtualArray(marshaller, dirName, useCase, EVAType.CONTENT);
        saveVirtualArray(marshaller, dirName, useCase, EVAType.CONTENT_CONTEXT);
        saveVirtualArray(marshaller, dirName, useCase, EVAType.CONTENT_EMBEDDED_HM);
        saveVirtualArray(marshaller, dirName, useCase, EVAType.STORAGE);
        TreePorter treePorter = new TreePorter();
        Tree<ClusterNode> geneTree = useCase.getSet().getClusteredTreeGenes();
        if (geneTree != null) {
            treePorter.exportTree(dirName + GENE_TREE_FILE_NAME, geneTree);
        }
        treePorter = new TreePorter();
        Tree<ClusterNode> expTree = useCase.getSet().getClusteredTreeExps();
        if (expTree != null) {
            treePorter.exportTree(dirName + EXP_TREE_FILE_NAME, expTree);
        }
        File useCaseFile = new File(dirName + USECASE_FILE_NAME);
        marshaller.marshal(useCase, useCaseFile);
    } catch (JAXBException ex) {
        throw new RuntimeException("String_Node_Str", ex);
    } catch (IOException ex) {
        throw new RuntimeException("String_Node_Str", ex);
    }
}

Output:
     LoadDataParameters parameters = useCase.getLoadDataParameters();
-    FileOperations.writeInputStreamToFile(dirName + SET_DATA_FILE_NAME, GeneralManager.get().getResourceLoader().getInputSource(parameters.getFileName()).getByteStream());
+    FileOperations.writeInputStreamToFile(dirName + SET_DATA_FILE_NAME, GeneralManager.get().getResourceLoader().getResource(parameters.getFileName()));
     SerializationManager serializationManager = GeneralManager.get().getSerializationManager();


Input:
public String get(final String key, final String def) {
    return p.get(key, def);
}

Output:
 public String get(final String key, final String def) {
-    return p.get(key, def);
+    return p.get(safeKey(key), def);
 }


Input:
public String toString() {
    return id();
}

Output:
 public String toString() {
-    return id();
+    return this.id();
 }


Input:
private static void processTransition(final ServiceConfiguration parent, final Completion transitionCallback, final TransitionActions transitionAction) {
    ServiceTransitionCallback trans = null;
    try {
        if (parent.isVmLocal() || (parent.isHostLocal() && BootstrapArgs.isCloudController())) {
            try {
                trans = ServiceLocalTransitionCallbacks.valueOf(transitionAction.name());
            } catch (Exception ex) {
                LOG.error(ex, ex);
                throw ex;
            }
        } else if (!BootstrapArgs.isCloudController()) {
            try {
                trans = ServiceRemoteTransitionNotification.valueOf(transitionAction.name());
            } catch (Exception ex) {
                LOG.error(ex, ex);
                throw ex;
            }
        } else if (BootstrapArgs.isCloudController()) {
            try {
                trans = CloudRemoteTransitionCallbacks.valueOf(transitionAction.name());
            } catch (Exception ex) {
                LOG.error(ex, ex);
                throw ex;
            }
        } else {
            LOG.debug("String_Node_Str" + parent);
        }
        if (trans != null) {
            Logs.extreme().debug("String_Node_Str" + trans.getClass() + "String_Node_Str" + transitionAction.name() + "String_Node_Str" + parent);
            trans.fire(parent);
        }
        transitionCallback.fire();
    } catch (Exception ex) {
        if (ServiceExceptions.filterExceptions(parent, ex)) {
            transitionCallback.fireException(ex);
            throw new UndeclaredThrowableException(ex);
        } else {
            transitionCallback.fire();
        }
    }
}

Output:
         if (trans != null) {
-            Logs.extreme().debug("String_Node_Str" + trans.getClass() + "String_Node_Str" + transitionAction.name() + "String_Node_Str" + parent);
+            Logs.exhaust().debug("String_Node_Str" + trans.getClass() + "String_Node_Str" + transitionAction.name() + "String_Node_Str" + parent);
             trans.fire(parent);


Input:
public void displayAboutTab() {
    this.openTab(this.aboutTab, "String_Node_Str");
}

Output:
 public void displayAboutTab() {
-    this.openTab(this.aboutTab, "String_Node_Str");
+    this.openTab(this.aboutTab);
 }


Input:
public boolean isOnlyChildInSuppressedGroup(StatusBarNotification sbn) {
    return isGroupSuppressed(sbn.getGroupKey()) && !sbn.getNotification().isGroupSummary() && getTotalNumberOfChildren(sbn) == 1;
}

Output:
 public boolean isOnlyChildInSuppressedGroup(StatusBarNotification sbn) {
-    return isGroupSuppressed(sbn.getGroupKey()) && !sbn.getNotification().isGroupSummary() && getTotalNumberOfChildren(sbn) == 1;
+    return isGroupSuppressed(sbn.getGroupKey()) && isOnlyChildInGroup(sbn);
 }


Input:
public List<String> getProjectBranches() {
    projectBranches = new ArrayList<String>();
    try {
        URIish sourceRepository = getSourceRepoURLDefault();
        if (!gitlabHostUrl.isEmpty() && (null != sourceRepository)) {
            List<GitlabProject> projects = getGitlab().instance().getProjects();
            for (GitlabProject project : projects) {
                if (project.getSshUrl().equalsIgnoreCase(sourceRepository.toString())) {
                    List<GitlabBranch> branches = getGitlab().instance().getBranches(project);
                    for (GitlabBranch branch : branches) {
                        projectBranches.add(branch.getName());
                    }
                    break;
                }
            }
        }
    } catch (Exception ex) {
        LOGGER.log(Level.WARNING, "String_Node_Str", new String[] { ex.toString(), ex.getMessage() });
    }
    return projectBranches;
}

Output:
             for (GitlabProject project : projects) {
-                if (project.getSshUrl().equalsIgnoreCase(sourceRepository.toString())) {
+                if (project.getSshUrl().equalsIgnoreCase(sourceRepository.toString()) || project.getHttpUrl().equalsIgnoreCase(sourceRepository.toString())) {
                     List<GitlabBranch> branches = getGitlab().instance().getBranches(project);


Input:
private void convert() {
    final File spawnFile = new File(plugin.getDataFolder(), "String_Node_Str");
    if (spawnFile.exists()) {
        YamlConfiguration spawn = new YamlConfiguration();
        try {
            spawn.load(spawnFile);
            int range = spawn.getInt("String_Node_Str");
            Location spawnLoc = Util.getLocationString(spawn.getString("String_Node_Str", "String_Node_Str"));
            if (spawnLoc != null && onGrid(spawnLoc)) {
                Island newIsland = addIsland(spawnLoc.getBlockX(), spawnLoc.getBlockZ());
                setSpawn(newIsland);
                newIsland.setProtectionSize(range);
            } else {
                plugin.getLogger().severe("String_Node_Str" + spawnLoc);
                plugin.getLogger().severe("String_Node_Str");
            }
        } catch (Exception e) {
            plugin.getLogger().severe("String_Node_Str");
        }
    }
    final File playerFolder = new File(plugin.getDataFolder() + File.separator + "String_Node_Str");
    final File quarantineFolder = new File(plugin.getDataFolder() + File.separator + "String_Node_Str");
    YamlConfiguration playerFile = new YamlConfiguration();
    int noisland = 0;
    int inTeam = 0;
    int count = 0;
    if (playerFolder.exists() && playerFolder.listFiles().length > 0) {
        plugin.getLogger().warning("String_Node_Str");
        if (playerFolder.listFiles().length > 5000) {
            plugin.getLogger().warning("String_Node_Str");
        }
        for (File f : playerFolder.listFiles()) {
            String fileName = f.getName();
            if (fileName.endsWith("String_Node_Str")) {
                try {
                    playerFile.load(f);
                    boolean hasIsland = playerFile.getBoolean("String_Node_Str", false);
                    if (hasIsland) {
                        String islandLocation = playerFile.getString("String_Node_Str");
                        if (islandLocation.isEmpty()) {
                            plugin.getLogger().severe("String_Node_Str" + fileName);
                            plugin.getLogger().severe("String_Node_Str" + playerFile.getString("String_Node_Str", "String_Node_Str"));
                            plugin.getLogger().severe("String_Node_Str");
                            if (!quarantineFolder.exists()) {
                                quarantineFolder.mkdir();
                            }
                            plugin.getLogger().severe("String_Node_Str" + f.getName() + "String_Node_Str" + quarantineFolder.getName());
                            File rename = new File(quarantineFolder, f.getName());
                            f.renameTo(rename);
                        } else {
                            Location islandLoc = Util.getLocationString(islandLocation);
                            if (islandLoc != null) {
                                Island island = getIslandAt(islandLoc);
                                if (island != null) {
                                    plugin.getLogger().severe("String_Node_Str" + fileName);
                                    plugin.getLogger().severe("String_Node_Str" + playerFile.getString("String_Node_Str", "String_Node_Str"));
                                    plugin.getLogger().severe("String_Node_Str");
                                    if (island.getUpdatedDate() > f.lastModified()) {
                                        plugin.getLogger().severe("String_Node_Str");
                                        if (!quarantineFolder.exists()) {
                                            quarantineFolder.mkdir();
                                        }
                                        plugin.getLogger().severe("String_Node_Str" + (playerFile.getString("String_Node_Str", "String_Node_Str")) + "String_Node_Str" + f.getName() + "String_Node_Str" + quarantineFolder.getName());
                                        File rename = new File(quarantineFolder, f.getName());
                                        f.renameTo(rename);
                                    } else {
                                        plugin.getLogger().severe(playerFile.getString("String_Node_Str", "String_Node_Str") + "String_Node_Str");
                                        File oldFile = new File(playerFolder, island.getOwner().toString() + "String_Node_Str");
                                        File rename = new File(quarantineFolder, oldFile.getName());
                                        if (!quarantineFolder.exists()) {
                                            quarantineFolder.mkdir();
                                        }
                                        plugin.getLogger().severe("String_Node_Str" + oldFile.getName() + "String_Node_Str" + quarantineFolder.getName());
                                        oldFile.renameTo(rename);
                                        deleteIsland(islandLoc);
                                        island = null;
                                    }
                                }
                                if (island == null) {
                                    if (!onGrid(islandLoc)) {
                                        plugin.getLogger().severe("String_Node_Str" + fileName);
                                        plugin.getLogger().severe("String_Node_Str" + playerFile.getString("String_Node_Str", "String_Node_Str"));
                                        plugin.getLogger().severe("String_Node_Str" + islandLoc);
                                    }
                                    String ownerString = fileName.substring(0, fileName.length() - 4);
                                    UUID owner = UUID.fromString(ownerString);
                                    Island newIsland = addIsland(islandLoc.getBlockX(), islandLoc.getBlockZ(), owner);
                                    ownershipMap.put(owner, newIsland);
                                    newIsland.setUpdatedDate(f.lastModified());
                                    if ((count) % 1000 == 0) {
                                        plugin.getLogger().info("String_Node_Str" + count + "String_Node_Str");
                                    }
                                    count++;
                                    int islandLevel = playerFile.getInt("String_Node_Str", 0);
                                    String teamLeaderUUID = playerFile.getString("String_Node_Str", "String_Node_Str");
                                    if (islandLevel > 0) {
                                        if (!playerFile.getBoolean("String_Node_Str")) {
                                            TopTen.topTenAddEntry(owner, islandLevel);
                                        } else if (!teamLeaderUUID.isEmpty()) {
                                            if (teamLeaderUUID.equals(ownerString)) {
                                                TopTen.topTenAddEntry(owner, islandLevel);
                                            }
                                        }
                                    }
                                    String islandInfo = playerFile.getString("String_Node_Str", "String_Node_Str");
                                    if (!islandInfo.isEmpty()) {
                                        String[] split = islandInfo.split("String_Node_Str");
                                        try {
                                            newIsland.setLocked(false);
                                            if (split.length > 6) {
                                                if (split[6].equalsIgnoreCase("String_Node_Str")) {
                                                    newIsland.setLocked(true);
                                                }
                                            }
                                            newIsland.setPurgeProtected(false);
                                            if (split.length > 7) {
                                                if (split[7].equalsIgnoreCase("String_Node_Str")) {
                                                    newIsland.setPurgeProtected(true);
                                                }
                                            }
                                            if (!split[5].equals("String_Node_Str")) {
                                                if (split[5].equals("String_Node_Str")) {
                                                    newIsland.setSpawn(true);
                                                    if (split.length > 8) {
                                                        Location spawnPoint = Util.getLocationString(islandInfo.substring(islandInfo.indexOf("String_Node_Str") + 4));
                                                        newIsland.setSpawnPoint(spawnPoint);
                                                    }
                                                }
                                            }
                                            if (!newIsland.isSpawn()) {
                                                if (split.length > 8 && split[8].length() == 29) {
                                                    int index = 0;
                                                    for (Flags flag : Flags.values()) {
                                                        newIsland.setIgsFlag(flag, split[8].charAt(index++) == '1' ? true : false);
                                                    }
                                                }
                                            }
                                        } catch (Exception e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            } else {
                                plugin.getLogger().severe("String_Node_Str" + fileName);
                                plugin.getLogger().severe("String_Node_Str" + playerFile.getString("String_Node_Str", "String_Node_Str"));
                                plugin.getLogger().severe("String_Node_Str");
                            }
                        }
                    } else {
                        noisland++;
                        if (playerFile.getBoolean("String_Node_Str", false)) {
                            inTeam++;
                        }
                    }
                } catch (Exception e) {
                    plugin.getLogger().severe("String_Node_Str" + fileName);
                    e.printStackTrace();
                }
            }
        }
        plugin.getLogger().info("String_Node_Str" + count + "String_Node_Str");
        plugin.getLogger().info(noisland + "String_Node_Str" + inTeam + "String_Node_Str");
        plugin.getLogger().info((noisland - inTeam) + "String_Node_Str");
    }
    TopTen.topTenSave();
    int count2 = 0;
    final File islandFolder = new File(plugin.getDataFolder() + File.separator + "String_Node_Str");
    if (islandFolder.exists() && islandFolder.listFiles().length > 0) {
        plugin.getLogger().warning("String_Node_Str");
        if (islandFolder.listFiles().length > 5000) {
            plugin.getLogger().warning("String_Node_Str");
        }
        for (File f : islandFolder.listFiles()) {
            String fileName = f.getName();
            int comma = fileName.indexOf("String_Node_Str");
            if (fileName.endsWith("String_Node_Str") && comma != -1) {
                try {
                    int x = Integer.parseInt(fileName.substring(0, comma));
                    int z = Integer.parseInt(fileName.substring(comma + 1, fileName.indexOf("String_Node_Str")));
                    if (!onGrid(x, z)) {
                        plugin.getLogger().severe("String_Node_Str" + x + "String_Node_Str" + z + "String_Node_Str");
                    } else {
                        if (getIslandAt(x, z) == null) {
                            addIsland(x, z);
                            if (count2 % 1000 == 0) {
                                plugin.getLogger().info("String_Node_Str" + count + "String_Node_Str");
                            }
                            count2++;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        plugin.getLogger().info("String_Node_Str" + count2 + "String_Node_Str");
        plugin.getLogger().info("String_Node_Str" + (count + count2) + "String_Node_Str");
    }
    saveGrid();
}

Output:
                                                     for (Flags flag : Flags.values()) {
-                                                        newIsland.setIgsFlag(flag, split[8].charAt(index++) == '1' ? true : false);
+                                                        if (index < split[8].length()) {
+                                                            newIsland.setIgsFlag(flag, split[8].charAt(index++) == '1' ? true : false);
+                                                        }
                                                     }


Input:
private boolean renewSessionID() {
    triedRenewSessionID = true;
    sessionID = Utils.loadStringFromFile(directory + "String_Node_Str");
    if (sessionID == null || sessionID.length() == 0) {
        return false;
    }
    JSONObject payload = new JSONObject();
    payload.put("String_Node_Str", getMojangSessionID());
    payload.put("String_Node_Str", clientToken);
    JSONObject answer = sendJSONPayload("String_Node_Str", payload);
    if (ifErrorThenSet(answer))
        return false;
    sessionID = (String) answer.get("String_Node_Str");
    if (keepLoggedIn)
        saveSessionID();
    return true;
}

Output:
     JSONObject answer = sendJSONPayload("String_Node_Str", payload);
-    if (ifErrorThenSet(answer))
+    if (ifErrorThenSet(answer)) {
+        sessionID = null;
         return false;


Input:
static VanillaSharedReplicatedHashMap<Integer, CharSequence> newSocketShmIntString(final byte identifier, final int serverPort, ClientPort... clientSocketChannelProviderMaps) throws IOException {
    final VanillaSharedReplicatedHashMapBuilder builder = new VanillaSharedReplicatedHashMapBuilder().entries(1000).identifier(identifier);
    final VanillaSharedReplicatedHashMap<Integer, CharSequence> result = builder.create(getPersistenceFile(), Integer.class, CharSequence.class);
    final int adjustedEntrySize = result.maxEntrySize();
    final short maxNumberOfEntriesPerChunk = ServerTcpSocketReplicator.toMaxNumberOfEntriesPerChunk(1024 * 8, adjustedEntrySize);
    for (ClientPort clientSocketChannelProvider : clientSocketChannelProviderMaps) {
        final SocketChannelEntryWriter socketChannelEntryWriter0 = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
        final SocketChannelEntryReader socketChannelEntryReader = new SocketChannelEntryReader(adjustedEntrySize, result);
        ClientTcpSocketReplicator clientTcpSocketReplicator = new ClientTcpSocketReplicator(clientSocketChannelProvider, socketChannelEntryReader, socketChannelEntryWriter0, result);
        result.addCloseable(clientTcpSocketReplicator);
    }
    final SocketChannelEntryWriter socketChannelEntryWriter = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
    ServerTcpSocketReplicator serverTcpSocketReplicator = new ServerTcpSocketReplicator(result, result, serverPort, socketChannelEntryWriter);
    result.addCloseable(serverTcpSocketReplicator);
    return result;
}

Output:
     final SocketChannelEntryWriter socketChannelEntryWriter = new SocketChannelEntryWriter(adjustedEntrySize, maxNumberOfEntriesPerChunk, result);
-    ServerTcpSocketReplicator serverTcpSocketReplicator = new ServerTcpSocketReplicator(result, result, serverPort, socketChannelEntryWriter);
+    final ServerTcpSocketReplicator serverTcpSocketReplicator = new ServerTcpSocketReplicator(result, result, serverPort, socketChannelEntryWriter);
     result.addCloseable(serverTcpSocketReplicator);


Input:
private static void test1() {
    MultiLabelClfDataSet dataSet = MLClfDataSetBuilder.getBuilder().numDataPoints(10).numFeatures(3).numClasses(4).dense(true).missingValue(false).build();
    System.out.println(dataSet.getMetaInfo());
}

Output:
 private static void test1() {
-    MultiLabelClfDataSet dataSet = MLClfDataSetBuilder.getBuilder().numDataPoints(10).numFeatures(3).numClasses(4).dense(true).missingValue(false).build();
+    MultiLabelClfDataSet dataSet = MLClfDataSetBuilder.getBuilder().numDataPoints(10).numFeatures(3).numClasses(4).missingValue(false).build();
     System.out.println(dataSet.getMetaInfo());


Input:
public Learner[] getSublearners() {
    return null;
}

Output:
 public Learner[] getSublearners() {
-    return null;
+    return getSubClassifiers();
 }


Input:
public void showLastRender() {
    Client client = parent.getClient();
    if (client != null) {
        Server server = client.getServer();
        if (server != null) {
            byte[] data = server.getLastRender();
            if (data != null) {
                InputStream is = new ByteArrayInputStream(data);
                try {
                    BufferedImage image = ImageIO.read(is);
                    lastRender.setIcon(new ImageIcon(image));
                } catch (IOException e) {
                    System.out.println("String_Node_Str" + e);
                    e.printStackTrace();
                }
            }
        }
    }
}

Output:
                     BufferedImage image = ImageIO.read(is);
-                    lastRender.setIcon(new ImageIcon(image));
+                    if (image != null) {
+                        lastRender.setIcon(new ImageIcon(image));
+                    }
                 } catch (IOException e) {


Input:
public InformationLoss<double[]> clone() {
    return new InformationLossRCE(value, ints, string);
}

Output:
 public InformationLoss<double[]> clone() {
-    return new InformationLossRCE(value, ints, string);
+    return new InformationLossRCE(value, ints, string, perc);
 }


Input:
public synchronized void showGame(UUID gameId, UUID playerId) {
    this.gameId = gameId;
    this.playerId = playerId;
    session = MageFrame.getSession();
    MageFrame.addGame(gameId, this);
    this.feedbackPanel.init(gameId);
    this.feedbackPanel.clear();
    this.abilityPicker.init(session, gameId);
    this.btnConcede.setVisible(true);
    this.btnEndTurn.setVisible(true);
    this.btnSwitchHands.setVisible(false);
    this.pnlReplay.setVisible(false);
    this.btnStopWatching.setVisible(false);
    this.gameChatPanel.clear();
    this.gameChatPanel.connect(session.getGameChatId(gameId));
    if (!session.joinGame(gameId)) {
        hideGame();
    }
}

Output:
     if (!session.joinGame(gameId)) {
-        hideGame();
+        removeGame();
     }


Input:
public static String escapeQuotes(String value) {
    return String.valueOf(value).replaceAll(QUOTE, "String_Node_Str" + QUOTE);
}

Output:
 public static String escapeQuotes(String value) {
-    return String.valueOf(value).replaceAll(QUOTE, "String_Node_Str" + QUOTE);
+    return value.replaceAll(QUOTE, "String_Node_Str" + QUOTE);
 }


Input:
synchronized ImmutableList<State> getStateHistory() throws Exception {
    completionLatch.await();
    return ImmutableList.copyOf(stateHistory);
}

Output:
     completionLatch.await();
-    return ImmutableList.copyOf(stateHistory);
+    synchronized (this) {
+        return ImmutableList.copyOf(stateHistory);
+    }
 }


Input:
public void init(boolean force) {
    dbCount = -1;
    String version = null;
    Connection conn = null;
    ResultSet rs = null;
    Statement stmt = null;
    boolean force_delete = false;
    try {
        conn = getConnection();
    } catch (SQLException se) {
        force_delete = true;
    } finally {
        close(conn);
        if (FileUtils.exists(dbDir + File.separator + dbName + "String_Node_Str") || force_delete) {
            FileUtils.deleteRecursive(dbDir, true);
            if (!FileUtils.exists(dbDir)) {
                LOGGER.debug("String_Node_Str");
            } else {
                if (!java.awt.GraphicsEnvironment.isHeadless()) {
                    JOptionPane.showMessageDialog((JFrame) (SwingUtilities.getWindowAncestor((Component) PMS.get().getFrame())), String.format(Messages.getString("String_Node_Str"), dbDir), Messages.getString("String_Node_Str"), JOptionPane.ERROR_MESSAGE);
                }
                LOGGER.debug("String_Node_Str" + dbDir + "String_Node_Str");
            }
        }
    }
    try {
        conn = getConnection();
        stmt = conn.createStatement();
        rs = stmt.executeQuery("String_Node_Str");
        if (rs.next()) {
            dbCount = rs.getInt(1);
        }
        rs.close();
        stmt.close();
        stmt = conn.createStatement();
        rs = stmt.executeQuery("String_Node_Str");
        if (rs.next()) {
            version = rs.getString(1);
        }
    } catch (SQLException se) {
        if (se.getErrorCode() != 42102) {
            LOGGER.error(null, se);
        }
    } finally {
        close(rs);
        close(stmt);
        close(conn);
    }
    boolean force_reinit = !PMS.getVersion().equals(version);
    if (force || dbCount == -1 || force_reinit) {
        LOGGER.debug("String_Node_Str");
        try {
            conn = getConnection();
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
        } catch (SQLException se) {
            if (se.getErrorCode() != 42102) {
                LOGGER.error(null, se);
            }
        }
        try {
            StringBuilder sb = new StringBuilder();
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_CODECV).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_FRAMERATE).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_ASPECT).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_CONTAINER).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_MODEL).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_MUXINGMODE).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_FRAMERATE_MODE).append("String_Node_Str");
            sb.append("String_Node_Str");
            executeUpdate(conn, sb.toString());
            sb = new StringBuilder();
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_LANG).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_FLAVOR).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_SAMPLEFREQ).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_CODECA).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_ALBUM).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_ARTIST).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_SONGNAME).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_GENRE).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_MUXINGMODE).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            executeUpdate(conn, sb.toString());
            sb = new StringBuilder();
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_LANG).append("String_Node_Str");
            sb.append("String_Node_Str").append(SIZE_FLAVOR).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            executeUpdate(conn, sb.toString());
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str" + PMS.getVersion() + "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            executeUpdate(conn, "String_Node_Str");
            String[] chars = Messages.getString("String_Node_Str").split("String_Node_Str");
            for (int i = 0; i < chars.length; i++) {
                executeUpdate(conn, "String_Node_Str" + chars[i] + "String_Node_Str" + chars[i] + "String_Node_Str" + (i + 2) + "String_Node_Str");
            }
            LOGGER.debug("String_Node_Str");
        } catch (SQLException se) {
            LOGGER.info("String_Node_Str" + se.getMessage());
        } finally {
            close(conn);
        }
    } else {
        LOGGER.debug("String_Node_Str" + dbCount);
        LOGGER.debug("String_Node_Str" + version);
    }
}

Output:
     } catch (SQLException se) {
-        force_delete = true;
-    } finally {
-        close(conn);
-        if (FileUtils.exists(dbDir + File.separator + dbName + "String_Node_Str") || force_delete) {
+        if (FileUtils.exists(dbDir + File.separator + dbName + "String_Node_Str") || (se.getErrorCode() == 90048)) {
             FileUtils.deleteRecursive(dbDir, true);


Input:
public void testContainsAll() {
    final char[] raw = { 3, 5, 8, 13, 21 };
    final CharArray array = new CharArray(raw.clone());
    final ArrayList<Integer> list = new ArrayList<Integer>();
    assertTrue(array.containsAll(list));
    list.add(13);
    assertTrue(array.containsAll(list));
    list.add(1);
    assertFalse(array.containsAll(list));
    final CharArray yes = new CharArray(new char[] { 3, 8, 21 });
    assertTrue(array.containsAll(yes));
    final CharArray no = new CharArray(new char[] { 5, 13, 1 });
    assertFalse(array.containsAll(no));
}

Output:
     final CharArray array = new CharArray(raw.clone());
-    final ArrayList<Integer> list = new ArrayList<Integer>();
+    final ArrayList<Character> list = new ArrayList<Character>();
     assertTrue(array.containsAll(list));


Input:
public void onResume() {
    Crouton.cancelAllCroutons();
    checkVisibilityEmptyLabel();
    super.onResume();
}

Output:
     Crouton.cancelAllCroutons();
-    checkVisibilityEmptyLabel();
+    if (isChatsListLoaded) {
+        checkVisibilityEmptyLabel();
+    }
     super.onResume();


Input:
public Entity toEntity() {
    Entity entity = toProtoEntity();
    entity.setUnindexedProperty(FILLED_PROPERTY, filled);
    if (null != fillTime) {
        entity.setUnindexedProperty(FILL_TIME_PROPERTY, fillTime);
    }
    if (null != sourceJobKey) {
        entity.setProperty(SOURCE_JOB_KEY_PROPERTY, sourceJobKey);
    }
    try {
        entity.setUnindexedProperty(VALUE_PROPERTY, PipelineManager.getBackEnd().serlializeValue(this, value));
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    entity.setProperty(WAITING_ON_ME_PROPERTY, waitingOnMeKeys);
    return entity;
}

Output:
     try {
-        entity.setUnindexedProperty(VALUE_PROPERTY, PipelineManager.getBackEnd().serlializeValue(this, value));
+        entity.setUnindexedProperty(VALUE_PROPERTY, PipelineManager.getBackEnd().serializeValue(this, value));
     } catch (IOException e) {