Input:
public void handleEvent(Event event) {
    Main.mainController.setTooltipSize(360, 180);
    Main.mainController.setTooltipContent("String_Node_Str");
    if (statusEffect != null) {
        int yIncrease = (statusEffect.getModifiersAsStringList(owner).size() > 4 ? statusEffect.getModifiersAsStringList(owner).size() - 4 : 0) + (owner.hasStatusEffect(statusEffect) ? (owner.getStatusEffectDuration(statusEffect) == -1 ? 0 : 2) : 0);
        Main.mainController.setTooltipSize(360, 284 + (yIncrease * LINE_HEIGHT));
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + "String_Node_Str" + Util.capitaliseSentence(statusEffect.getName(owner)) + "String_Node_Str");
        tooltipSB.append("String_Node_Str");
        if (!statusEffect.getModifiersAsStringList(owner).isEmpty()) {
            int i = 0;
            for (String s : statusEffect.getModifiersAsStringList(owner)) {
                tooltipSB.append((i != 0 ? "String_Node_Str" : "String_Node_Str") + s);
                i++;
            }
        } else {
            tooltipSB.append("String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
        }
        tooltipSB.append("String_Node_Str");
        tooltipSB.append("String_Node_Str" + statusEffect.getSVGString(owner) + "String_Node_Str" + "String_Node_Str" + statusEffect.getDescription(owner) + "String_Node_Str");
        if (owner.hasStatusEffect(statusEffect))
            if (owner.getStatusEffectDuration(statusEffect) != -1) {
                if (statusEffect.isCombatEffect()) {
                    tooltipSB.append("String_Node_Str" + owner.getStatusEffectDuration(statusEffect) + "String_Node_Str");
                } else {
                    int timerHeight = (int) ((owner.getStatusEffectDuration(statusEffect) / (60 * 6f)) * 100);
                    Colour timerColour = Colour.STATUS_EFFECT_TIME_HIGH;
                    if (timerHeight > 100) {
                        timerHeight = 100;
                        timerColour = Colour.STATUS_EFFECT_TIME_OVERFLOW;
                    } else if (timerHeight < 15) {
                        timerColour = Colour.STATUS_EFFECT_TIME_LOW;
                    } else if (timerHeight < 50) {
                        timerColour = Colour.STATUS_EFFECT_TIME_MEDIUM;
                    }
                    tooltipSB.append("String_Node_Str" + "String_Node_Str" + timerColour.toWebHexString() + "String_Node_Str" + (owner.getStatusEffectDuration(statusEffect) / 60) + "String_Node_Str" + String.format("String_Node_Str", (owner.getStatusEffectDuration(statusEffect) % 60)) + "String_Node_Str" + "String_Node_Str");
                }
            }
        tooltipSB.append("String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (perk != null) {
        int yIncrease = (perk.getModifiersAsStringList().size() > 4 ? perk.getModifiersAsStringList().size() - 4 : 0);
        Main.mainController.setTooltipSize(360, 324 + (yIncrease * LINE_HEIGHT));
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(perk.getName(owner)) + "String_Node_Str");
        if (perk.isMajor()) {
            tooltipSB.append("String_Node_Str" + Colour.TRAIT.toWebHexString() + "String_Node_Str");
        } else {
            tooltipSB.append("String_Node_Str" + Colour.PERK.toWebHexString() + "String_Node_Str");
        }
        tooltipSB.append("String_Node_Str");
        if (!perk.getModifiersAsStringList().isEmpty()) {
            int i = 0;
            for (String s : perk.getModifiersAsStringList()) {
                tooltipSB.append((i != 0 ? "String_Node_Str" : "String_Node_Str") + s);
                i++;
            }
        } else
            tooltipSB.append("String_Node_Str" + Colour.PERK.toWebHexString() + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
        tooltipSB.append("String_Node_Str");
        tooltipSB.append("String_Node_Str" + perk.getSVGString() + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + perk.getDescription(owner) + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (levelUpPerk != null) {
        int yIncrease = (levelUpPerk.getModifiersAsStringList().size() > 4 ? levelUpPerk.getModifiersAsStringList().size() - 4 : 0);
        Main.mainController.setTooltipSize(360, 352 + (yIncrease * LINE_HEIGHT));
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(levelUpPerk.getName(owner)) + "String_Node_Str");
        if (levelUpPerk.isMajor()) {
            tooltipSB.append("String_Node_Str" + Colour.TRAIT.toWebHexString() + "String_Node_Str");
        } else {
            tooltipSB.append("String_Node_Str" + Colour.PERK.toWebHexString() + "String_Node_Str");
        }
        tooltipSB.append("String_Node_Str");
        if (!levelUpPerk.getModifiersAsStringList().isEmpty()) {
            int i = 0;
            for (String s : levelUpPerk.getModifiersAsStringList()) {
                tooltipSB.append((i != 0 ? "String_Node_Str" : "String_Node_Str") + s);
                i++;
            }
        } else {
            tooltipSB.append("String_Node_Str" + Colour.PERK.toWebHexString() + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
        }
        tooltipSB.append("String_Node_Str");
        tooltipSB.append("String_Node_Str" + levelUpPerk.getSVGString() + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + levelUpPerk.getDescription(Main.game.getPlayer()) + "String_Node_Str");
        if (levelUpPerk.isMajor()) {
            if (levelUpPerk.getPerkCategory() == PerkCategory.JOB) {
                tooltipSB.append("String_Node_Str" + Colour.TRAIT.toWebHexString() + "String_Node_Str");
            } else {
                if (!owner.hasPerkInTree(perkRow, levelUpPerk)) {
                    if (!PerkManager.MANAGER.isPerkAvailable(perkRow, levelUpPerk)) {
                        tooltipSB.append("String_Node_Str" + Colour.GENERIC_BAD.toWebHexString() + "String_Node_Str");
                    } else {
                        tooltipSB.append("String_Node_Str" + Colour.GENERIC_MINOR_GOOD.toWebHexString() + "String_Node_Str");
                    }
                } else {
                    if (owner.getTraits().contains(levelUpPerk)) {
                        tooltipSB.append("String_Node_Str" + Colour.GENERIC_MINOR_BAD.toWebHexString() + "String_Node_Str");
                    } else {
                        if (owner.getTraits().size() == GameCharacter.MAX_TRAITS) {
                            tooltipSB.append("String_Node_Str" + Colour.GENERIC_BAD.toWebHexString() + "String_Node_Str");
                        } else {
                            tooltipSB.append("String_Node_Str" + Colour.TRAIT.toWebHexString() + "String_Node_Str");
                        }
                    }
                }
            }
        } else {
            if (!owner.hasPerkInTree(perkRow, levelUpPerk)) {
                if (!PerkManager.MANAGER.isPerkAvailable(perkRow, levelUpPerk)) {
                    tooltipSB.append("String_Node_Str" + Colour.GENERIC_BAD.toWebHexString() + "String_Node_Str");
                } else {
                    tooltipSB.append("String_Node_Str" + Colour.GENERIC_MINOR_GOOD.toWebHexString() + "String_Node_Str");
                }
            } else {
                tooltipSB.append("String_Node_Str" + Colour.PERK.toWebHexString() + "String_Node_Str");
            }
        }
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (desire != null) {
        Main.mainController.setTooltipSize(360, 264);
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + desire.getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(desire.getName()) + "String_Node_Str");
        tooltipSB.append("String_Node_Str");
        int i = 0;
        for (String s : desire.getModifiersAsStringList()) {
            tooltipSB.append((i != 0 ? "String_Node_Str" : "String_Node_Str") + s);
            i++;
        }
        tooltipSB.append("String_Node_Str");
        tooltipSB.append("String_Node_Str" + desire.getSVGImage() + "String_Node_Str");
        if (owner.hasFetish(fetish) && desire != FetishDesire.FOUR_LOVE) {
            tooltipSB.append("String_Node_Str" + FetishDesire.FOUR_LOVE.getColour().toWebHexString() + "String_Node_Str" + FetishDesire.FOUR_LOVE.getName() + "String_Node_Str" + "String_Node_Str" + fetish.getName(owner) + "String_Node_Str");
            tooltipSB.append("String_Node_Str");
        } else {
            tooltipSB.append("String_Node_Str" + fetish.getFetishDesireDescription(owner, desire) + "String_Node_Str");
            if (owner.getBaseFetishDesire(fetish) == desire) {
                tooltipSB.append("String_Node_Str");
            } else {
                tooltipSB.append("String_Node_Str" + (FetishDesire.getCostToChange() == 0 ? "String_Node_Str" : "String_Node_Str" + FetishDesire.getCostToChange() + "String_Node_Str" + (FetishDesire.getCostToChange() > 1 ? "String_Node_Str" : "String_Node_Str")) + "String_Node_Str");
            }
        }
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (fetish != null) {
        if (fetishExperience) {
            Main.mainController.setTooltipSize(420, 156);
            tooltipSB.setLength(0);
            tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(fetish.getName(owner)) + "String_Node_Str");
            FetishLevel level = FetishLevel.getFetishLevelFromValue(owner.getFetishExperience(fetish));
            tooltipSB.append("String_Node_Str" + level.getNumeral() + "String_Node_Str" + level.getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(level.getName()) + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + owner.getFetishExperience(fetish) + "String_Node_Str" + level.getMaximumExperience() + "String_Node_Str" + "String_Node_Str");
            tooltipSB.append("String_Node_Str");
            Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
        } else {
            int yIncrease = (fetish.getModifiersAsStringList(owner).size() > 4 ? fetish.getModifiersAsStringList(owner).size() - 4 : 0) + fetish.getFetishesForAutomaticUnlock().size();
            Main.mainController.setTooltipSize(360, (fetish.getFetishesForAutomaticUnlock().isEmpty() ? 350 : 360) + (yIncrease * LINE_HEIGHT));
            tooltipSB.setLength(0);
            tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(fetish.getName(owner)) + "String_Node_Str");
            FetishLevel level = FetishLevel.getFetishLevelFromValue(owner.getFetishExperience(fetish));
            tooltipSB.append("String_Node_Str" + level.getNumeral() + "String_Node_Str" + level.getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(level.getName()) + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + owner.getFetishExperience(fetish) + "String_Node_Str" + level.getMaximumExperience() + "String_Node_Str" + "String_Node_Str");
            if (!fetish.getFetishesForAutomaticUnlock().isEmpty()) {
                tooltipSB.append("String_Node_Str");
                for (Fetish f : fetish.getFetishesForAutomaticUnlock()) tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(f.getName(Main.game.getPlayer())) + "String_Node_Str");
                tooltipSB.append("String_Node_Str");
            }
            tooltipSB.append("String_Node_Str");
            if (!fetish.getModifiersAsStringList(owner).isEmpty()) {
                int i = 0;
                for (String s : fetish.getModifiersAsStringList(owner)) {
                    tooltipSB.append((i != 0 ? "String_Node_Str" : "String_Node_Str") + s);
                    i++;
                }
            } else {
                tooltipSB.append("String_Node_Str" + Colour.FETISH.toWebHexString() + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
            }
            tooltipSB.append("String_Node_Str");
            tooltipSB.append("String_Node_Str" + fetish.getSVGString() + "String_Node_Str");
            tooltipSB.append("String_Node_Str" + fetish.getDescription(owner) + "String_Node_Str");
            if (fetish.getFetishesForAutomaticUnlock().isEmpty()) {
                if (owner.hasBaseFetish(fetish)) {
                    tooltipSB.append("String_Node_Str");
                } else {
                    tooltipSB.append("String_Node_Str" + fetish.getCost() + "String_Node_Str");
                }
            }
            Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
        }
    } else if (specialAttack != null) {
        int yIncrease = (specialAttack.getStatusEffects().size() > 2 ? specialAttack.getStatusEffects().size() - 2 : 0);
        Main.mainController.setTooltipSize(360, 324 + (yIncrease * LINE_HEIGHT));
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(specialAttack.getName()) + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + "String_Node_Str" + Colour.SPECIAL_ATTACK.toWebHexString() + "String_Node_Str" + "String_Node_Str" + Attack.getMinimumSpecialAttackDamage(owner, null, specialAttack.getDamageType(), specialAttack.getDamage(), specialAttack.getDamageVariance()) + "String_Node_Str" + Attack.getMaximumSpecialAttackDamage(owner, null, specialAttack.getDamageType(), specialAttack.getDamage(), specialAttack.getDamageVariance()) + "String_Node_Str" + "String_Node_Str" + specialAttack.getDamageType().getMultiplierAttribute().getColour().toWebHexString() + "String_Node_Str" + specialAttack.getDamageType().getName() + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + Colour.SPECIAL_ATTACK.toWebHexString() + "String_Node_Str");
        if (!specialAttack.getStatusEffects().isEmpty()) {
            for (Entry<StatusEffect, Integer> e : specialAttack.getStatusEffects().entrySet()) tooltipSB.append("String_Node_Str" + e.getKey().getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(e.getKey().getName(owner)) + "String_Node_Str" + e.getValue() + "String_Node_Str" + (e.getValue() > 1 ? "String_Node_Str" : "String_Node_Str"));
        } else
            tooltipSB.append("String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
        tooltipSB.append("String_Node_Str");
        tooltipSB.append("String_Node_Str" + specialAttack.getSVGString() + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + specialAttack.getDescription(owner) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (specialAttack.getCooldown()) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (Main.game.isInCombat() ? (Combat.getCooldown(owner, specialAttack) == 0 ? "String_Node_Str" : "String_Node_Str" + Combat.getCooldown(owner, specialAttack)) : "String_Node_Str") + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (spell != null) {
        int yIncrease = (spell.getStatusEffects().size() > 2 ? spell.getStatusEffects().size() - 2 : 0);
        Main.mainController.setTooltipSize(360, 324 + (yIncrease * LINE_HEIGHT));
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + Util.capitaliseSentence(spell.getName()) + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + "String_Node_Str" + Colour.GENERIC_ARCANE.toWebHexString() + "String_Node_Str");
        if (spell.isBeneficial()) {
            tooltipSB.append("String_Node_Str" + Colour.GENERIC_GOOD.toWebHexString() + "String_Node_Str" + spell.getDamageType().getMultiplierAttribute().getColour().toWebHexString() + "String_Node_Str" + spell.getDamageType().getName() + "String_Node_Str");
        } else {
            tooltipSB.append("String_Node_Str" + Attack.getMinimumSpellDamage(owner, null, spell.getDamageType(), spell.getDamage(), spell.getDamageVariance()) + "String_Node_Str" + Attack.getMaximumSpellDamage(owner, null, spell.getDamageType(), spell.getDamage(), spell.getDamageVariance()) + "String_Node_Str" + "String_Node_Str" + spell.getDamageType().getMultiplierAttribute().getColour().toWebHexString() + "String_Node_Str" + spell.getDamageType().getName() + "String_Node_Str");
        }
        tooltipSB.append("String_Node_Str" + Colour.GENERIC_ARCANE.toWebHexString() + "String_Node_Str");
        if (!spell.getStatusEffects().isEmpty()) {
            for (Entry<StatusEffect, Integer> e : spell.getStatusEffects().entrySet()) {
                tooltipSB.append("String_Node_Str" + e.getKey().getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(e.getKey().getName(owner)) + "String_Node_Str" + e.getValue() + "String_Node_Str" + (e.getValue() > 1 ? "String_Node_Str" : "String_Node_Str"));
            }
        } else {
            tooltipSB.append("String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
        }
        tooltipSB.append("String_Node_Str");
        tooltipSB.append("String_Node_Str" + spell.getSVGString() + "String_Node_Str");
        tooltipSB.append("String_Node_Str" + spell.getDescription(owner, spellLevel) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Colour.GENERIC_BAD.toWebHexString() + "String_Node_Str" + (spell.getModifiedCost(owner)) + "String_Node_Str" + "String_Node_Str" + Colour.ATTRIBUTE_MANA.toWebHexString() + "String_Node_Str" + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (attribute != null) {
        if (attribute == Attribute.MAJOR_PHYSIQUE || attribute == Attribute.MAJOR_ARCANE || attribute == Attribute.MAJOR_CORRUPTION || attribute == Attribute.AROUSAL || attribute == Attribute.LUST) {
            StatusEffect currentAttributeStatusEffect = null;
            int minimumLevelValue = 0, maximumLevelValue = 0;
            if (attribute == Attribute.MAJOR_PHYSIQUE) {
                currentAttributeStatusEffect = PhysiqueLevel.getPhysiqueLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_PHYSIQUE)).getRelatedStatusEffect();
                minimumLevelValue = PhysiqueLevel.getPhysiqueLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_PHYSIQUE)).getMinimumValue();
                maximumLevelValue = PhysiqueLevel.getPhysiqueLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_PHYSIQUE)).getMaximumValue();
            } else if (attribute == Attribute.MAJOR_ARCANE) {
                currentAttributeStatusEffect = IntelligenceLevel.getIntelligenceLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_ARCANE)).getRelatedStatusEffect();
                minimumLevelValue = IntelligenceLevel.getIntelligenceLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_ARCANE)).getMinimumValue();
                maximumLevelValue = IntelligenceLevel.getIntelligenceLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_ARCANE)).getMaximumValue();
            } else if (attribute == Attribute.MAJOR_CORRUPTION) {
                currentAttributeStatusEffect = CorruptionLevel.getCorruptionLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_CORRUPTION)).getRelatedStatusEffect();
                minimumLevelValue = CorruptionLevel.getCorruptionLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_CORRUPTION)).getMinimumValue();
                maximumLevelValue = CorruptionLevel.getCorruptionLevelFromValue(owner.getAttributeValue(Attribute.MAJOR_CORRUPTION)).getMaximumValue();
            } else if (attribute == Attribute.AROUSAL) {
                currentAttributeStatusEffect = ArousalLevel.getArousalLevelFromValue(owner.getAttributeValue(Attribute.AROUSAL)).getRelatedStatusEffect();
                minimumLevelValue = ArousalLevel.getArousalLevelFromValue(owner.getAttributeValue(Attribute.AROUSAL)).getMinimumValue();
                maximumLevelValue = ArousalLevel.getArousalLevelFromValue(owner.getAttributeValue(Attribute.AROUSAL)).getMaximumValue();
            } else if (attribute == Attribute.LUST) {
                currentAttributeStatusEffect = LustLevel.getLustLevelFromValue(owner.getAttributeValue(Attribute.LUST)).getRelatedStatusEffect();
                minimumLevelValue = LustLevel.getLustLevelFromValue(owner.getAttributeValue(Attribute.LUST)).getMinimumValue();
                maximumLevelValue = LustLevel.getLustLevelFromValue(owner.getAttributeValue(Attribute.LUST)).getMaximumValue();
            }
            int yIncrease = (currentAttributeStatusEffect.getModifiersAsStringList(owner).size() > 4 ? currentAttributeStatusEffect.getModifiersAsStringList(owner).size() - 4 : 0) + (owner.hasStatusEffect(currentAttributeStatusEffect) ? (owner.getStatusEffectDuration(currentAttributeStatusEffect) == -1 ? 0 : 2) : 0);
            Main.mainController.setTooltipSize(360, 460 + (yIncrease * LINE_HEIGHT));
            tooltipSB.setLength(0);
            tooltipSB.append("String_Node_Str" + attribute.getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(attribute.getName()) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + (owner.getBaseAttributeValue(attribute) > 0 ? "String_Node_Str" + Colour.GENERIC_EXCELLENT.getShades()[1] + "String_Node_Str" : "String_Node_Str") + String.format("String_Node_Str", owner.getBaseAttributeValue(attribute)) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + ((owner.getBonusAttributeValue(attribute)) > 0 ? "String_Node_Str" + Colour.GENERIC_GOOD.getShades()[1] + "String_Node_Str" : ((owner.getBonusAttributeValue(attribute)) == 0 ? "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" : "String_Node_Str" + Colour.GENERIC_BAD.getShades()[1] + "String_Node_Str")) + String.format("String_Node_Str", owner.getBonusAttributeValue(attribute)) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + attribute.getColour().toWebHexString() + "String_Node_Str" + String.format("String_Node_Str", owner.getAttributeValue(attribute)) + "String_Node_Str" + "String_Node_Str");
            tooltipSB.append("String_Node_Str" + attribute.getDescription(owner) + "String_Node_Str");
            tooltipSB.append("String_Node_Str" + "String_Node_Str" + currentAttributeStatusEffect.getColour().toWebHexString() + "String_Node_Str" + currentAttributeStatusEffect.getName(owner) + "String_Node_Str" + minimumLevelValue + "String_Node_Str" + maximumLevelValue + "String_Node_Str" + "String_Node_Str");
            tooltipSB.append("String_Node_Str");
            if (!currentAttributeStatusEffect.getModifiersAsStringList(owner).isEmpty()) {
                int i = 0;
                for (String s : currentAttributeStatusEffect.getModifiersAsStringList(owner)) {
                    if (i != 0) {
                        tooltipSB.append("String_Node_Str");
                    }
                    tooltipSB.append(s);
                    i++;
                }
            } else {
                tooltipSB.append("String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str");
            }
            tooltipSB.append("String_Node_Str");
            tooltipSB.append("String_Node_Str" + currentAttributeStatusEffect.getSVGString(owner) + "String_Node_Str");
            tooltipSB.append("String_Node_Str" + currentAttributeStatusEffect.getDescription(owner) + "String_Node_Str");
            Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
        } else if (attribute == Attribute.EXPERIENCE) {
            if (owner.isRaceConcealed()) {
                Main.mainController.setTooltipSize(420, 64);
                tooltipSB.setLength(0);
                tooltipSB.append("String_Node_Str" + Colour.RACE_UNKNOWN.toWebHexString() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                Main.mainController.setTooltipSize(420, 508);
                tooltipSB.setLength(0);
                tooltipSB.append("String_Node_Str" + owner.getRace().getColour().toWebHexString() + "String_Node_Str" + (owner.getRaceStage().getName() != "String_Node_Str" ? "String_Node_Str" + owner.getRaceStage().getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(owner.getRaceStage().getName()) + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + owner.getRace().getColour().toWebHexString() + "String_Node_Str" + (owner.isFeminine() ? Util.capitaliseSentence(owner.getSubspecies().getSingularFemaleName()) : Util.capitaliseSentence(owner.getSubspecies().getSingularMaleName())) + "String_Node_Str" + "String_Node_Str");
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getFaceRace(), owner.getFaceType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getSkinRace(), owner.getSkinType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getArmRace(), owner.getArmType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getLegRace(), owner.getLegType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getHairRace(), owner.getHairType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getEyeRace(), owner.getEyeType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getEarRace(), owner.getEarType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getTongueRace(), owner.getTongueType().getBodyCoveringType()));
                if (owner.getHornType() != HornType.NONE) {
                    tooltipSB.append(getBodyPartDiv((owner.hasHorns() ? Util.capitaliseSentence(owner.getHornName()) : "String_Node_Str"), owner.getHornRace(), owner.getHornType().getBodyCoveringType()));
                } else {
                    tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                }
                if (owner.getAntennaType() != AntennaType.NONE) {
                    tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getAntennaRace(), owner.getAntennaType().getBodyCoveringType()));
                } else {
                    tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                }
                if (owner.getWingType() != WingType.NONE) {
                    tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getWingRace(), owner.getWingType().getBodyCoveringType()));
                } else {
                    tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                }
                if (owner.getTailType() != TailType.NONE) {
                    tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getTailRace(), owner.getTailType().getBodyCoveringType()));
                } else {
                    tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                }
                if (!owner.isPlayer() && !owner.getPlayerKnowsAreas().contains(CoverableArea.VAGINA)) {
                    tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                } else {
                    if (owner.getVaginaType() != VaginaType.NONE) {
                        tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getVaginaRace(), owner.getVaginaType().getBodyCoveringType()));
                    } else {
                        tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                    }
                }
                if (!owner.isPlayer() && !owner.getPlayerKnowsAreas().contains(CoverableArea.PENIS)) {
                    tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                } else {
                    if (owner.getPenisType() != PenisType.NONE) {
                        tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getPenisRace(), owner.getPenisType().getBodyCoveringType()));
                    } else {
                        tooltipSB.append(getEmptyBodyPartDiv("String_Node_Str", "String_Node_Str"));
                    }
                }
                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getAssRace(), owner.getAssType().getBodyCoveringType()));
                tooltipSB.append(getBodyPartDiv(owner.hasBreasts() ? "String_Node_Str" : "String_Node_Str", owner.getBreastRace(), owner.getBreastType().getBodyCoveringType()));
            }
            Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
        } else {
            Main.mainController.setTooltipSize(360, 234);
            Main.mainController.setTooltipContent(UtilText.parse("String_Node_Str" + attribute.getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(attribute.getName()) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + (owner.getBaseAttributeValue(attribute) > 0 ? "String_Node_Str" + Colour.GENERIC_EXCELLENT.getShades()[1] + "String_Node_Str" : "String_Node_Str") + String.format("String_Node_Str", owner.getBaseAttributeValue(attribute)) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + ((owner.getBonusAttributeValue(attribute)) > 0 ? "String_Node_Str" + Colour.GENERIC_GOOD.getShades()[1] + "String_Node_Str" : ((owner.getBonusAttributeValue(attribute)) == 0 ? "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" : "String_Node_Str" + Colour.GENERIC_BAD.getShades()[1] + "String_Node_Str")) + String.format("String_Node_Str", owner.getBonusAttributeValue(attribute)) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + attribute.getColour().toWebHexString() + "String_Node_Str" + String.format("String_Node_Str", owner.getAttributeValue(attribute)) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + attribute.getDescription(owner) + "String_Node_Str"));
        }
    } else if (extraAttributes) {
        Main.mainController.setTooltipSize(360, 520);
        tooltipSB.setLength(0);
        tooltipSB.append(UtilText.parse(owner, "String_Node_Str" + Femininity.valueOf(owner.getFemininityValue()).getColour().toWebHexString() + "String_Node_Str" + (owner.getName().length() == 0 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + owner.getLevel() + "String_Node_Str" + Colour.TEXT_GREY.toWebHexString() + "String_Node_Str" + owner.getExperience() + "String_Node_Str" + (10 * owner.getLevel()) + "String_Node_Str" + extraAttributeBonus(owner, Attribute.CRITICAL_CHANCE) + extraAttributeBonus(owner, Attribute.CRITICAL_DAMAGE) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + extraAttributeTableRow(owner, "String_Node_Str", Attribute.DAMAGE_PHYSICAL, Attribute.RESISTANCE_PHYSICAL) + extraAttributeTableRow(owner, "String_Node_Str", Attribute.DAMAGE_FIRE, Attribute.RESISTANCE_FIRE) + extraAttributeTableRow(owner, "String_Node_Str", Attribute.DAMAGE_ICE, Attribute.RESISTANCE_ICE) + extraAttributeTableRow(owner, "String_Node_Str", Attribute.DAMAGE_POISON, Attribute.RESISTANCE_POISON) + extraAttributeTableRow(owner, "String_Node_Str", Attribute.DAMAGE_LUST, Attribute.RESISTANCE_LUST) + extraAttributeTableRow(owner, "String_Node_Str", Attribute.DAMAGE_SPELLS, Attribute.RESISTANCE_SPELLS) + extraAttributeBonus(owner, Attribute.FERTILITY) + extraAttributeBonus(owner, Attribute.VIRILITY) + extraAttributeBonus(owner, Attribute.SPELL_COST_MODIFIER)));
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (weather) {
        Main.mainController.setTooltipSize(360, 100);
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + "String_Node_Str" + Main.game.getCurrentWeather().getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(Main.game.getCurrentWeather().getName()) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + ((Main.game.getWeatherTimeRemaining() / 60) + 1) + "String_Node_Str" + (((Main.game.getWeatherTimeRemaining() / 60) + 1) > 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (protection) {
        Main.mainController.setTooltipSize(360, 100);
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + "String_Node_Str" + (owner.isWearingCondom() ? "String_Node_Str" + Colour.GENERIC_GOOD.toWebHexString() + "String_Node_Str" : "String_Node_Str" + Colour.GENERIC_BAD.toWebHexString() + "String_Node_Str") + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (tattoo) {
        Main.mainController.setTooltipSize(360, 100);
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else if (copyInformation) {
        Main.mainController.setTooltipSize(360, 170);
        tooltipSB.setLength(0);
        tooltipSB.append("String_Node_Str" + (Main.game.getCurrentDialogueNode().getLabel() == "String_Node_Str" || Main.game.getCurrentDialogueNode().getLabel() == null ? "String_Node_Str" : Main.game.getCurrentDialogueNode().getLabel()) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Colour.ANDROGYNOUS.toWebHexString() + "String_Node_Str" + Main.game.getCurrentDialogueNode().getAuthor() + "String_Node_Str");
        Main.mainController.setTooltipContent(UtilText.parse(tooltipSB.toString()));
    } else {
        if (description == null || description.isEmpty()) {
            Main.mainController.setTooltipSize(360, 64);
            Main.mainController.setTooltipContent(UtilText.parse("String_Node_Str" + title + "String_Node_Str"));
        } else {
            Main.mainController.setTooltipSize(360, 175);
            Main.mainController.setTooltipContent(UtilText.parse("String_Node_Str" + title + "String_Node_Str" + "String_Node_Str" + description + "String_Node_Str"));
        }
    }
    (new Thread(new TooltipUpdateThread())).start();
}

Output:
                 tooltipSB.append("String_Node_Str" + owner.getRace().getColour().toWebHexString() + "String_Node_Str" + (owner.getRaceStage().getName() != "String_Node_Str" ? "String_Node_Str" + owner.getRaceStage().getColour().toWebHexString() + "String_Node_Str" + Util.capitaliseSentence(owner.getRaceStage().getName()) + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + owner.getRace().getColour().toWebHexString() + "String_Node_Str" + (owner.isFeminine() ? Util.capitaliseSentence(owner.getSubspecies().getSingularFemaleName()) : Util.capitaliseSentence(owner.getSubspecies().getSingularMaleName())) + "String_Node_Str" + "String_Node_Str");
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getFaceRace(), owner.getFaceType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getSkinRace(), owner.getSkinType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getArmRace(), owner.getArmType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getLegRace(), owner.getLegType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getHairRace(), owner.getHairType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getEyeRace(), owner.getEyeType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getEarRace(), owner.getEarType().getBodyCoveringType()));
-                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getTongueRace(), owner.getTongueType().getBodyCoveringType()));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getFaceRace(), owner.getFaceType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getSkinRace(), owner.getSkinType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getArmRace(), owner.getArmType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getLegRace(), owner.getLegType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getHairRace(), owner.getHairType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getEyeRace(), owner.getEyeType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getEarRace(), owner.getEarType().getBodyCoveringType(owner)));
+                tooltipSB.append(getBodyPartDiv("String_Node_Str", owner.getTongueRace(), owner.getTongueType().getBodyCoveringType(owner)));
                 if (owner.getHornType() != HornType.NONE) {


Input:
public String listQuerys(final String streamName) {
    try {
        List<ColumnNameTypeValue> columnsValues = stratioStreamingApi.columnsFromStream(streamName);
        List<String> columns = Arrays.asList("String_Node_Str", "String_Node_Str");
        List<Map<String, Object>> data = new ArrayList<>();
        for (ColumnNameTypeValue columnValue : columnsValues) {
            Map<String, Object> row = new HashMap<>();
            row.put("String_Node_Str", columnValue.getColumn());
            row.put("String_Node_Str", columnValue.getType());
            data.add(row);
        }
        return TableRenderer.renderMapDataAsTable(data, columns);
    } catch (StratioEngineOperationException e) {
        throw new StreamingShellException(e);
    }
}

Output:
     try {
-        List<ColumnNameTypeValue> columnsValues = stratioStreamingApi.columnsFromStream(streamName);
+        List<ColumnNameTypeValue> columnsValues = ssaw.api().columnsFromStream(streamName);
         List<String> columns = Arrays.asList("String_Node_Str", "String_Node_Str");


Input:
public static ColaSynchronizationStrategy getInstanceFor(ID client, boolean isInitiator) {
    if (sessionStrategies.get(client) == null) {
        sessionStrategies.put(client, new ColaSynchronizationStrategy(isInitiator));
    }
    return (ColaSynchronizationStrategy) sessionStrategies.get(client);
}

Output:
 public static ColaSynchronizationStrategy getInstanceFor(ID client, boolean isInitiator) {
-    if (sessionStrategies.get(client) == null) {
-        sessionStrategies.put(client, new ColaSynchronizationStrategy(isInitiator));
+    ColaSynchronizationStrategy existingStrategy = (ColaSynchronizationStrategy) sessionStrategies.get(client);
+    if (existingStrategy != null) {
+        Boolean existingStrategyIsInitiator = new Boolean(existingStrategy.isInitiator);
+        if (existingStrategyIsInitiator.equals(new Boolean(isInitiator))) {
+            return existingStrategy;
+        }
     }


Input:
private String encodeType(ElementDefn e, TypeRef type, boolean params) throws Exception {
    if (type.isResourceReference())
        return "String_Node_Str";
    else if (type.getName().equals("String_Node_Str")) {
        String en = null;
        if (e.hasBinding()) {
            BindingSpecification cd = e.getBinding();
            if (cd != null && cd.getBinding() == BindingSpecification.BindingMethod.CodeList) {
                en = cd.getValueSet().getName();
                if (!cd.isShared()) {
                    enums.put(en, cd.getValueSet());
                    enumDefs.put(en, cd.getDefinition());
                }
                return en;
            }
        }
        return "String_Node_Str";
    } else if (!type.hasParams() || !params) {
        if (type.getName().equals("String_Node_Str"))
            return "String_Node_Str";
        else
            return type.getName();
    } else if (type.getParams().size() > 1)
        throw new Exception("String_Node_Str");
    else
        return type.getName() + "String_Node_Str" + upFirst(type.getParams().get(0));
}

Output:
             return "String_Node_Str";
-        else
+        else if (definitions.getConstraints().containsKey(type.getName())) {
+            ProfiledType pt = definitions.getConstraints().get(type.getName());
+            return pt.getBaseType();
+        } else
             return type.getName();


Input:
protected void loadCoreData(final String group) {
    ImmutableMap.Builder<String, Object> builder;
    switch(group) {
        case CHAMPION_MASTERY_SCORE_LOAD_GROUP:
            builder = ImmutableMap.builder();
            if (coreData.getSummonerId() != 0L) {
                builder.put("String_Node_Str", coreData.getSummonerId());
            }
            if (coreData.getPlatform() != null) {
                builder.put("String_Node_Str", Platform.withTag(coreData.getPlatform()));
            }
            coreData = Orianna.getSettings().getPipeline().get(com.merakianalytics.orianna.types.data.championmastery.ChampionMasteryScore.class, builder.build());
            break;
        default:
            break;
    }
}

Output:
             }
-            coreData = Orianna.getSettings().getPipeline().get(com.merakianalytics.orianna.types.data.championmastery.ChampionMasteryScore.class, builder.build());
+            final com.merakianalytics.orianna.types.data.championmastery.ChampionMasteryScore data = Orianna.getSettings().getPipeline().get(com.merakianalytics.orianna.types.data.championmastery.ChampionMasteryScore.class, builder.build());
+            if (data != null) {
+                coreData = data;
+            }
             break;


Input:
public void deleteGroupEvictionState(ReadPointer readPointer, long writeVersion) throws OperationException {
    if (groupEvictEntries.isEmpty()) {
        readGroupEvictInformationInternal(readPointer);
    }
    if (groupEvictEntries.isEmpty()) {
        return;
    }
    byte[][] columnKeys = new byte[groupEvictEntries.size()][];
    byte[][] values = new byte[groupEvictEntries.size()][];
    int i = 0;
    for (Map.Entry<Long, Long> entry : groupEvictEntries.entrySet()) {
        columnKeys[i] = makeColumnName(GROUP_EVICT_ENTRY, entry.getKey());
        values[i] = Bytes.toBytes(entry.getValue());
        ++i;
    }
    table.put(GLOBAL_EVICT_META_ROW, columnKeys, writeVersion, values);
}

Output:
         columnKeys[i] = makeColumnName(GROUP_EVICT_ENTRY, entry.getKey());
-        values[i] = Bytes.toBytes(entry.getValue());
+        values[i] = Bytes.EMPTY_BYTE_ARRAY;
         ++i;


Input:
private ChangeItem createRelationChangeItem(RelationData data) throws OseeCoreException {
    ApplicabilityId appId = data.getApplicabilityId();
    return ChangeItemUtil.newRelationChange(RelationId.valueOf(data.getLocalId()), RelationTypeId.valueOf(data.getTypeUuid()), GammaId.valueOf(data.getVersion().getGammaId()), determineModType(data), ArtifactId.valueOf(data.getArtIdA()), ArtifactId.valueOf(data.getArtIdB()), data.getRationale(), getApplicabilityToken(appId));
}

Output:
     ApplicabilityId appId = data.getApplicabilityId();
-    return ChangeItemUtil.newRelationChange(RelationId.valueOf(data.getLocalId()), RelationTypeId.valueOf(data.getTypeUuid()), GammaId.valueOf(data.getVersion().getGammaId()), determineModType(data), ArtifactId.valueOf(data.getArtIdA()), ArtifactId.valueOf(data.getArtIdB()), data.getRationale(), getApplicabilityToken(appId));
+    return ChangeItemUtil.newRelationChange(RelationId.valueOf(Long.valueOf(data.getLocalId())), RelationTypeId.valueOf(data.getTypeUuid()), GammaId.valueOf(data.getVersion().getGammaId()), determineModType(data), ArtifactId.valueOf(data.getArtIdA()), ArtifactId.valueOf(data.getArtIdB()), data.getRationale(), getApplicabilityToken(appId));
 }


Input:
private void reportSpecial(String metric, WcetCost cost, long start, long stop, double solverTime) {
    String key = "String_Node_Str" + metric;
    System.out.println(key + "String_Node_Str" + cost);
    if (start != stop)
        System.out.println(key + "String_Node_Str" + timeDiff(start, stop));
    if (solverTime != 0)
        System.out.println(key + "String_Node_Str" + solverTime);
    project.recordSpecialResult(metric, cost);
    project.getReport().addStat(key, cost.toString());
}

Output:
     project.recordSpecialResult(metric, cost);
-    project.getReport().addStat(key, cost.toString());
+    if (project.reportGenerationActive()) {
+        project.getReport().addStat(key, cost.toString());
+    }
 }


Input:
protected void addOrderedChildrenTo(List<StringExpression> children) {
    if (expression != null) {
        children.add(expression);
    }
    if (hasNot) {
        children.add(buildStringExpression(SPACE));
        children.add(buildStringExpression(NOT));
    } else if (hasExpression()) {
        children.add(buildStringExpression(SPACE));
    }
    children.add(buildStringExpression(IN));
    if (hasLeftParenthesis) {
        children.add(buildStringExpression(LEFT_PARENTHESIS));
    } else if (hasInItems()) {
        children.add(buildStringExpression(SPACE));
    }
    if (inItems != null) {
        children.add(inItems);
    }
    if (hasRightParenthesis) {
        children.add(buildStringExpression(RIGHT_PARENTHESIS));
    }
}

Output:
 protected void addOrderedChildrenTo(List<StringExpression> children) {
-    if (expression != null) {
+    if (hasExpression()) {
         children.add(expression);


Input:
protected Map<String, Double> updateTrustAfterHunt(double foodHunted, double foodReceived) {
    throw new UnsupportedOperationException("String_Node_Str");
}

Output:
 protected Map<String, Double> updateTrustAfterHunt(double foodHunted, double foodReceived) {
-    throw new UnsupportedOperationException("String_Node_Str");
+    return null;
 }


Input:
public List<UserBan> getBans(String user) throws NetworkException, APIException {
    Response response = this.getAPIURL("String_Node_Str", "String_Node_Str", user);
    if (response.getContent() != null && response.getContent().length() != 0) {
        JSONNode json = response.getJSONResult();
        if (json == null) {
            throw new APIException("String_Node_Str");
        }
        if (json.getBoolean("String_Node_Str", false)) {
            List<UserBan> bans = new ArrayList<UserBan>();
            for (MapNode node : json.getMapNodeList("String_Node_Str")) {
                bans.add(new UserBan(node));
            }
            return bans;
        } else {
            throw new APIException(json.getString("String_Node_Str"));
        }
    }
    throw new APIException("String_Node_Str");
}

Output:
     if (response.getContent() != null && response.getContent().length() != 0) {
-        JSONNode json = response.getJSONResult();
-        if (json == null) {
+        JSONNode json = null;
+        try {
+            json = response.getJSONResult();
+        } catch (ParserException e) {
             throw new APIException("String_Node_Str");


Input:
public TableDefinition buildROOTA_BRANCHATable() {
    TableDefinition table = new TableDefinition();
    table.setName("String_Node_Str");
    FieldDefinition fieldBRANCHA_ID = new FieldDefinition();
    fieldBRANCHA_ID.setName("String_Node_Str");
    fieldBRANCHA_ID.setTypeName("String_Node_Str");
    fieldBRANCHA_ID.setSize(0);
    fieldBRANCHA_ID.setSubSize(0);
    fieldBRANCHA_ID.setIsPrimaryKey(true);
    fieldBRANCHA_ID.setIsIdentity(false);
    fieldBRANCHA_ID.setUnique(false);
    fieldBRANCHA_ID.setShouldAllowNull(true);
    table.addField(fieldBRANCHA_ID);
    FieldDefinition fieldROOTA_ID = new FieldDefinition();
    fieldROOTA_ID.setName("String_Node_Str");
    fieldROOTA_ID.setTypeName("String_Node_Str");
    fieldROOTA_ID.setSize(0);
    fieldROOTA_ID.setSubSize(0);
    fieldROOTA_ID.setIsPrimaryKey(true);
    fieldROOTA_ID.setIsIdentity(false);
    fieldROOTA_ID.setUnique(false);
    fieldROOTA_ID.setShouldAllowNull(true);
    table.addField(fieldROOTA_ID);
    ForeignKeyConstraint foreignKeyROOTA_BRANCHA_BRANCHA = new ForeignKeyConstraint();
    foreignKeyROOTA_BRANCHA_BRANCHA.setName("String_Node_Str");
    foreignKeyROOTA_BRANCHA_BRANCHA.setTargetTable("String_Node_Str");
    foreignKeyROOTA_BRANCHA_BRANCHA.addSourceField("String_Node_Str");
    foreignKeyROOTA_BRANCHA_BRANCHA.addTargetField("String_Node_Str");
    table.addForeignKeyConstraint(foreignKeyROOTA_BRANCHA_BRANCHA);
    ForeignKeyConstraint foreignKeyROOTA_BRANCHA_ROOTA = new ForeignKeyConstraint();
    foreignKeyROOTA_BRANCHA_ROOTA.setName("String_Node_Str");
    foreignKeyROOTA_BRANCHA_ROOTA.setTargetTable("String_Node_Str");
    foreignKeyROOTA_BRANCHA_ROOTA.addSourceField("String_Node_Str");
    foreignKeyROOTA_BRANCHA_ROOTA.addTargetField("String_Node_Str");
    table.addForeignKeyConstraint(foreignKeyROOTA_BRANCHA_ROOTA);
    return table;
}

Output:
     fieldBRANCHA_ID.setUnique(false);
-    fieldBRANCHA_ID.setShouldAllowNull(true);
+    fieldBRANCHA_ID.setShouldAllowNull(false);
     table.addField(fieldBRANCHA_ID);


Input:
public void route(RestxRequest restxRequest, RestxResponse restxResponse) throws IOException {
    RestxSpecTape tape = null;
    if (restxSpecRecorder != null && !restxRequest.getRestxPath().startsWith("String_Node_Str")) {
        tape = restxSpecRecorder.record(restxRequest, restxResponse);
        restxRequest = tape.getRecordingRequest();
        restxResponse = tape.getRecordingResponse();
    }
    if (getLoadFactoryMode().equals("String_Node_Str")) {
        loadFactory();
    }
    try {
        mainRouter.route(restxRequest, restxResponse);
    } finally {
        if (tape != null) {
            restxSpecRecorder.stop(tape);
        }
        if (getLoadFactoryMode().equals("String_Node_Str")) {
            closeFactory();
        }
    }
}

Output:
     }
-    if (getLoadFactoryMode().equals("String_Node_Str")) {
-        loadFactory();
-    }
+    Factory factory = loadFactory(newFactoryBuilder(getFactoryContextName(restxRequest.getPort()), restxSpecRecorder));
     try {


Input:
public static void getforeignKeyOfElement(Set<String> list, XSDElementDeclaration element) {
    if (element.getAnnotation() != null) {
        getForeignKeyofParcle(list, element.getAnnotation());
    }
    if (element.getTypeDefinition() instanceof XSDComplexTypeDefinition) {
        XSDComplexTypeContent fromcomplexType = ((XSDComplexTypeDefinition) element.getTypeDefinition()).getContent();
        if (fromcomplexType instanceof XSDParticle) {
            XSDParticle particle = (XSDParticle) fromcomplexType;
            if (particle.getTerm() instanceof XSDModelGroup) {
                XSDModelGroup modelGroup = ((XSDModelGroup) particle.getTerm());
                EList fromlist = modelGroup.getContents();
                for (XSDParticle el : (XSDParticle[]) fromlist.toArray(new XSDParticle[fromlist.size()])) {
                    XSDTerm term = el.getTerm();
                    if (term instanceof XSDElementDeclaration) {
                        if (term.equals(element)) {
                            continue;
                        }
                        XSDAnnotation annotation = ((XSDElementDeclaration) term).getAnnotation();
                        if (annotation != null) {
                            getForeignKeyofParcle(list, annotation);
                        }
                        getforeignKeyOfElement(list, (XSDElementDeclaration) term);
                    }
                }
            }
        }
    }
}

Output:
                     if (term instanceof XSDElementDeclaration) {
-                        if (term.equals(element)) {
+                        if (isReferrenced(element, (XSDElementDeclaration) term)) {
                             continue;


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (rootView != null) {
        if (rootView.getParent() != null)
            ((ViewGroup) rootView.getParent()).removeView(rootView);
        return rootView;
    }
    rootView = inflater.inflate(R.layout.fragment_recyclerview, container, false);
    ButterKnife.bind(this, rootView);
    init();
    return rootView;
}

Output:
     }
-    rootView = inflater.inflate(R.layout.fragment_recyclerview, container, false);
+    rootView = inflater.inflate(R.layout.fragment_bookmark, container, false);
     ButterKnife.bind(this, rootView);


Input:
private static String buildJmolSelection(ResidueNumber[] residues) {
    StringBuilder cmd = new StringBuilder("String_Node_Str");
    for (ResidueNumber res : residues) {
        if (res != null) {
            cmd.append(String.format("String_Node_Str", res.getSeqNum(), res.getInsCode() == null ? "String_Node_Str" : res.getInsCode(), res.getChainId()));
        }
    }
    cmd.append("String_Node_Str");
    return cmd.toString();
}

Output:
         if (res != null) {
-            cmd.append(String.format("String_Node_Str", res.getSeqNum(), res.getInsCode() == null ? "String_Node_Str" : res.getInsCode(), res.getChainId()));
+            cmd.append(String.format("String_Node_Str", res.getSeqNum(), res.getInsCode() == null ? "String_Node_Str" : res.getInsCode(), res.getChainName()));
         }


Input:
public Optional<MemberState> getState() {
    return state;
}

Output:
 public Optional<MemberState> getState() {
-    return state;
+    return Optional.ofNullable(state);
 }


Input:
public <T> Form initFormBean(Object bean, Class<Object> class1) {
    Form form = ((BinderCtrl) getBinder()).getForm(getComponent(), _formId);
    if (form == null) {
        form = (Form) ProxyHelper.createFormProxy(bean, class1);
        ((BinderCtrl) getBinder()).storeForm(getComponent(), _formId, form);
    }
    if (!(bean instanceof Form) && form instanceof FormProxyObject)
        ((FormProxyObject) form).setFormOwner(bean, this);
    return form;
}

Output:
     if (form == null) {
-        form = (Form) ProxyHelper.createFormProxy(bean, class1);
+        Class[] interfaces = null;
+        if (bindContext.getAttribute(String.valueOf(Method.class)) != null) {
+            Annotation[] annotations = (Annotation[]) bindContext.getAttribute(String.valueOf(Method.class));
+            if (annotations != null) {
+                boolean found = false;
+                for (Annotation annot : annotations) {
+                    if (annot.annotationType() == ImmutableFields.class) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                    interfaces = new Class[] { ImmutableFields.class };
+            }
+        }
+        form = (Form) ProxyHelper.createFormProxy(bean, class1, interfaces);
         ((BinderCtrl) getBinder()).storeForm(getComponent(), _formId, form);


Input:
private WireParser<Void> wireParser() {
    final WireParser<Void> parser = new VanillaWireParser<>((s, v, $) -> {
    });
    parser.register(EventId.domain::toString, (s, v, $) -> v.text(this, (o, x) -> o.sessionDetails.domain(x)));
    parser.register(EventId.sessionMode::toString, (s, v, $) -> v.text(this, (o, x) -> o.sessionDetails.sessionMode(SessionMode.valueOf(x))));
    parser.register(EventId.securityToken::toString, (s, v, $) -> v.text(this, (o, x) -> o.sessionDetails.securityToken(x)));
    parser.register(EventId.clientId::toString, (s, v, $) -> v.text(this, (o, x) -> o.sessionDetails.clientId(UUID.fromString(x))));
    parser.register(EventId.wireType::toString, (s, v, $) -> v.text(this, (o, x) -> o.sessionDetails.wireType(WireType.valueOf(x))));
    parser.register(EventId.hostId::toString, (s, v, $) -> v.int8(this, (o, x) -> o.sessionDetails.hostId(x)));
    return parser;
}

Output:
 private WireParser<Void> wireParser() {
-    final WireParser<Void> parser = new VanillaWireParser<>((s, v, $) -> {
+    final WireParser<Void> parser = new VanillaWireParser<>((s, in, out) -> {
+    }, (methodId, bytes, o) -> {
     });


Input:
public List getReferableBindings(String targetLevel, ICubeQueryDefinition cubeDefn, boolean isSort) throws AdapterException {
    try {
        List bindings = cubeDefn.getBindings();
        if (bindings == null)
            return new ArrayList();
        DimLevel target = OlapExpressionUtil.getTargetDimLevel(targetLevel);
        List result = new ArrayList();
        for (int i = 0; i < bindings.size(); i++) {
            IBinding binding = (IBinding) bindings.get(i);
            Set refDimLevel = OlapExpressionCompiler.getReferencedDimLevel(binding.getExpression(), bindings, isSort);
            if (refDimLevel.size() > 1)
                continue;
            if (!refDimLevel.contains(target)) {
                List aggrOns = binding.getAggregatOns();
                if (aggrOns.size() == 0) {
                    if (this.getReferencedMeasureName(binding.getExpression()) != null) {
                        result.add(binding);
                        continue;
                    }
                }
                for (int j = 0; j < aggrOns.size(); j++) {
                    DimLevel dimLevel = OlapExpressionUtil.getTargetDimLevel(aggrOns.get(j).toString());
                    if (dimLevel.equals(target)) {
                        if (j == aggrOns.size() - 1)
                            result.add(binding);
                        else {
                            DimLevel next = OlapExpressionUtil.getTargetDimLevel(aggrOns.get(j + 1).toString());
                            if (getAxisQualifierLevel(next, cubeDefn.getEdge(getAxisQualifierEdgeType(dimLevel, cubeDefn))) == null)
                                continue;
                            else
                                result.add(binding);
                        }
                        break;
                    }
                }
                continue;
            }
            result.add(binding);
        }
        return result;
    } catch (DataException e) {
        throw new AdapterException(e.getLocalizedMessage(), e);
    }
}

Output:
                 if (aggrOns.size() == 0) {
-                    if (this.getReferencedMeasureName(binding.getExpression()) != null) {
+                    if (this.getReferencedMeasureName(binding.getExpression()) != null && this.isLeafLevel(cubeDefn, target)) {
                         result.add(binding);


Input:
private IContextResourceLoader loaderForVersion() {
    if (Utilities.noString(version))
        return null;
    if (version.equals("String_Node_Str"))
        return new R2ToR4Loader();
    if (version.equals("String_Node_Str"))
        return new R3ToR4Loader();
    if (version.equals("String_Node_Str"))
        return new R3ToR4Loader();
    return null;
}

Output:
     if (version.equals("String_Node_Str"))
-        return new R3ToR4Loader();
+        return new R2016MayToR4Loader();
     if (version.equals("String_Node_Str"))


Input:
private void isLegal(List<? extends DataSet<?>> dataSets) {
    if (dataSets == null)
        return;
    for (int i = 0; i < dataSets.size(); i++) {
        if (dataSets.get(i).getYVals().size() > mXVals.size()) {
            throw new IllegalArgumentException("String_Node_Str");
        }
    }
}

Output:
         return;
-    for (int i = 0; i < dataSets.size(); i++) {
-        if (dataSets.get(i).getYVals().size() > mXVals.size()) {
+    for (int i = 0; i < mDataSets.size(); i++) {
+        if (mDataSets.get(i).getYVals().size() > mXVals.size()) {
             throw new IllegalArgumentException("String_Node_Str");


Input:
private void positionSelector(int position, View sel, boolean manageHotspot, float x, float y) {
    final boolean positionChanged = position != mSelectorPosition;
    if (position != INVALID_POSITION) {
        mSelectorPosition = position;
    }
    final Rect selectorRect = mSelectorRect;
    selectorRect.set(sel.getLeft(), sel.getTop(), sel.getRight(), sel.getBottom());
    if (sel instanceof SelectionBoundsAdjuster) {
        ((SelectionBoundsAdjuster) sel).adjustListItemSelectionBounds(selectorRect);
    }
    selectorRect.left -= mSelectionLeftPadding;
    selectorRect.top -= mSelectionTopPadding;
    selectorRect.right += mSelectionRightPadding;
    selectorRect.bottom += mSelectionBottomPadding;
    final Drawable selector = mSelector;
    if (selector != null) {
        if (positionChanged) {
            selector.setVisible(false, false);
            selector.setState(StateSet.NOTHING);
        }
        selector.setBounds(selectorRect);
        if (positionChanged) {
            if (getVisibility() == VISIBLE) {
                selector.setVisible(true, false);
            }
            selector.setState(getDrawableState());
        }
        if (manageHotspot) {
            selector.setHotspot(x, y);
        }
    }
    final boolean isChildViewEnabled = mIsChildViewEnabled;
    if (sel.isEnabled() != isChildViewEnabled) {
        mIsChildViewEnabled = !isChildViewEnabled;
        if (getSelectedItemPosition() != INVALID_POSITION) {
            refreshDrawableState();
        }
    }
}

Output:
             }
-            selector.setState(getDrawableState());
+            updateSelectorState();
         }


Input:
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
    ProcessRecord app;
    if (pid != MY_PID && pid >= 0) {
        synchronized (mPidsSelfLocked) {
            app = mPidsSelfLocked.get(pid);
        }
    } else if (mStartingProcesses.size() > 0) {
        app = mStartingProcesses.remove(0);
        app.setPid(pid);
    } else {
        app = null;
    }
    if (app == null) {
        Log.w(TAG, "String_Node_Str" + pid + "String_Node_Str" + thread + "String_Node_Str");
        EventLog.writeEvent(LOG_AM_DROP_PROCESS, pid);
        if (pid > 0 && pid != MY_PID) {
            Process.killProcess(pid);
        } else {
            try {
                thread.scheduleExit();
            } catch (Exception e) {
            }
        }
        return false;
    }
    if (app.thread != null) {
        handleAppDiedLocked(app, true);
    }
    if (localLOGV)
        Log.v(TAG, "String_Node_Str" + pid + "String_Node_Str" + app);
    String processName = app.processName;
    try {
        thread.asBinder().linkToDeath(new AppDeathRecipient(app, pid, thread), 0);
    } catch (RemoteException e) {
        app.resetPackageList();
        startProcessLocked(app, "String_Node_Str", processName);
        return false;
    }
    EventLog.writeEvent(LOG_AM_PROCESS_BOUND, app.pid, app.processName);
    app.thread = thread;
    app.curAdj = app.setAdj = -100;
    app.forcingToForeground = null;
    app.foregroundServices = false;
    app.debugging = false;
    mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
    List providers = generateApplicationProvidersLocked(app);
    if (localLOGV)
        Log.v(TAG, "String_Node_Str" + app + "String_Node_Str" + thread.asBinder() + "String_Node_Str" + pid);
    try {
        int testMode = IApplicationThread.DEBUG_OFF;
        if (mDebugApp != null && mDebugApp.equals(processName)) {
            testMode = mWaitForDebugger ? IApplicationThread.DEBUG_WAIT : IApplicationThread.DEBUG_ON;
            app.debugging = true;
            if (mDebugTransient) {
                mDebugApp = mOrigDebugApp;
                mWaitForDebugger = mOrigWaitForDebugger;
            }
        }
        thread.bindApplication(processName, app.info, providers, app.instrumentationClass, app.instrumentationProfileFile, app.instrumentationArguments, app.instrumentationWatcher, testMode, mConfiguration, getCommonServicesLocked());
        updateLRUListLocked(app, false);
        app.lastRequestedGc = SystemClock.uptimeMillis();
    } catch (Exception e) {
        Log.w(TAG, "String_Node_Str", e);
        app.resetPackageList();
        startProcessLocked(app, "String_Node_Str", processName);
        return false;
    }
    mPersistentStartingProcesses.remove(app);
    mProcessesOnHold.remove(app);
    boolean badApp = false;
    boolean didSomething = false;
    HistoryRecord hr = topRunningActivityLocked(null);
    if (hr != null) {
        if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid && processName.equals(hr.processName)) {
            try {
                if (realStartActivityLocked(hr, app, true, true)) {
                    didSomething = true;
                }
            } catch (Exception e) {
                Log.w(TAG, "String_Node_Str" + hr.intent.getComponent().flattenToShortString(), e);
                badApp = true;
            }
        } else {
            ensureActivitiesVisibleLocked(hr, null, processName, 0);
        }
    }
    if (!badApp && mPendingServices.size() > 0) {
        ServiceRecord sr = null;
        try {
            for (int i = 0; i < mPendingServices.size(); i++) {
                sr = mPendingServices.get(i);
                if (app.info.uid != sr.appInfo.uid || !processName.equals(sr.processName)) {
                    continue;
                }
                mPendingServices.remove(i);
                i--;
                realStartServiceLocked(sr, app);
                didSomething = true;
            }
        } catch (Exception e) {
            Log.w(TAG, "String_Node_Str" + sr.shortName, e);
            badApp = true;
        }
    }
    BroadcastRecord br = mPendingBroadcast;
    if (!badApp && br != null && br.curApp == app) {
        try {
            mPendingBroadcast = null;
            processCurBroadcastLocked(br, app);
            didSomething = true;
        } catch (Exception e) {
            Log.w(TAG, "String_Node_Str" + br.curComponent.flattenToShortString(), e);
            badApp = true;
            logBroadcastReceiverDiscard(br);
            finishReceiverLocked(br.receiver, br.resultCode, br.resultData, br.resultExtras, br.resultAbort, true);
            scheduleBroadcastsLocked();
        }
    }
    if (badApp) {
        handleAppDiedLocked(app, false);
        return false;
    }
    if (!didSomething) {
        updateOomAdjLocked();
    }
    return true;
}

Output:
         }
-        thread.bindApplication(processName, app.info, providers, app.instrumentationClass, app.instrumentationProfileFile, app.instrumentationArguments, app.instrumentationWatcher, testMode, mConfiguration, getCommonServicesLocked());
+        thread.bindApplication(processName, app.instrumentationInfo != null ? app.instrumentationInfo : app.info, providers, app.instrumentationClass, app.instrumentationProfileFile, app.instrumentationArguments, app.instrumentationWatcher, testMode, mConfiguration, getCommonServicesLocked());
         updateLRUListLocked(app, false);


Input:
void clear() {
    commands.clear();
    addCount = 0;
    removeCount = 0;
}

Output:
     commands.clear();
-    addCount = 0;
-    removeCount = 0;
+    containsWrites = false;
 }


Input:
public String readRawContent(GenBookBackendState state, Key key, String keyName) throws IOException, BookException {
    TreeNode node = find(key);
    if (node == null) {
        throw new BookException(JSMsg.gettext("String_Node_Str", keyName, getBookMetaData().getInitials()));
    }
    byte[] userData = node.getUserData();
    if (userData.length == 8) {
        int start = SwordUtil.decodeLittleEndian32(userData, 0);
        int size = SwordUtil.decodeLittleEndian32(userData, 4);
        byte[] data = SwordUtil.readRAF(state.getBdtRaf(), start, size);
        decipher(data);
        return SwordUtil.decode(keyName, data, getBookMetaData().getBookCharset());
    }
    return "String_Node_Str";
}

Output:
     if (node == null) {
-        throw new BookException(JSMsg.gettext("String_Node_Str", keyName, getBookMetaData().getInitials()));
+        throw new BookException(JSMsg.gettext("String_Node_Str", key.getName(), getBookMetaData().getInitials()));
     }


Input:
protected void visitTemplateNode(TemplateNode node) {
    boolean useStrongTyping = hasStrictParams(node);
    String templateName = node.getTemplateName();
    String partialName = node.getPartialTemplateName();
    String alias;
    boolean addToExports = jsSrcOptions.shouldGenerateGoogModules();
    if (addToExports && node instanceof TemplateDelegateNode) {
        alias = node.getPartialTemplateName().substring(1);
    } else {
        alias = templateAliases.get(templateName);
    }
    UniqueNameGenerator nameGenerator = JsSrcNameGenerators.forLocalVariables();
    CodeChunk.Generator codeGenerator = CodeChunk.Generator.create(nameGenerator);
    templateTranslationContext = TranslationContext.of(SoyToJsVariableMappings.forNewTemplate(), codeGenerator, nameGenerator);
    genJsExprsVisitor = genJsExprsVisitorFactory.create(templateTranslationContext, templateAliases, errorReporter);
    assistantForMsgs = null;
    String paramsRecordType = null;
    if (jsSrcOptions.shouldGenerateJsdoc()) {
        jsCodeBuilder.appendLine("String_Node_Str");
        jsCodeBuilder.append("String_Node_Str");
        if (useStrongTyping) {
            paramsRecordType = genParamsRecordType(node);
            jsCodeBuilder.append(paramsRecordType);
        } else {
            jsCodeBuilder.append("String_Node_Str");
        }
        jsCodeBuilder.appendLine("String_Node_Str");
        jsCodeBuilder.appendLine("String_Node_Str");
        jsCodeBuilder.appendLine("String_Node_Str");
        String returnType = getTemplateReturnType(node);
        jsCodeBuilder.appendLine("String_Node_Str", returnType, "String_Node_Str");
        String suppressions = "String_Node_Str";
        jsCodeBuilder.appendLine("String_Node_Str" + suppressions + "String_Node_Str");
        if (node.getVisibility() == Visibility.PRIVATE) {
            jsCodeBuilder.appendLine("String_Node_Str");
        }
        jsCodeBuilder.appendLine("String_Node_Str");
    }
    if (addToExports) {
        jsCodeBuilder.appendLine("String_Node_Str", alias, "String_Node_Str");
    } else {
        jsCodeBuilder.appendLine(alias, "String_Node_Str");
    }
    jsCodeBuilder.increaseIndent();
    if (!SoyTreeUtils.getAllNodesOfType(node, NullCoalescingOpNode.class).isEmpty() || !SoyTreeUtils.getAllNodesOfType(node, SwitchNode.class).isEmpty()) {
        jsCodeBuilder.appendLine("String_Node_Str");
    }
    if (new ShouldEnsureDataIsDefinedVisitor().exec(node)) {
        jsCodeBuilder.appendLine("String_Node_Str");
    }
    if (shouldEnsureIjDataIsDefined(node)) {
        jsCodeBuilder.appendLine("String_Node_Str");
    }
    generateFunctionBody(node);
    jsCodeBuilder.decreaseIndent();
    if (addToExports) {
        jsCodeBuilder.appendLine("String_Node_Str");
        jsCodeBuilder.appendLine("String_Node_Str", partialName.substring(1), "String_Node_Str", alias, "String_Node_Str");
    } else {
        jsCodeBuilder.appendLine("String_Node_Str");
    }
    if (paramsRecordType != null) {
        jsCodeBuilder.appendLine("String_Node_Str");
        jsCodeBuilder.appendLine("String_Node_Str", paramsRecordType, "String_Node_Str");
        jsCodeBuilder.appendLine("String_Node_Str");
        jsCodeBuilder.appendLine(alias + "String_Node_Str");
    }
    jsCodeBuilder.appendLine("String_Node_Str");
    jsCodeBuilder.increaseIndent();
    jsCodeBuilder.appendLine(alias + "String_Node_Str" + templateName + "String_Node_Str");
    jsCodeBuilder.decreaseIndent();
    jsCodeBuilder.appendLine("String_Node_Str");
    if (node instanceof TemplateDelegateNode) {
        TemplateDelegateNode nodeAsDelTemplate = (TemplateDelegateNode) node;
        String delTemplateIdExprText = "String_Node_Str" + delTemplateNamer.getDelegateName(nodeAsDelTemplate) + "String_Node_Str";
        String delTemplateVariantExprText = "String_Node_Str" + nodeAsDelTemplate.getDelTemplateVariant() + "String_Node_Str";
        jsCodeBuilder.appendLine("String_Node_Str", delTemplateIdExprText, "String_Node_Str", delTemplateVariantExprText, "String_Node_Str", nodeAsDelTemplate.getDelPriority().toString(), "String_Node_Str", alias, "String_Node_Str");
    }
}

Output:
         TemplateDelegateNode nodeAsDelTemplate = (TemplateDelegateNode) node;
-        String delTemplateIdExprText = "String_Node_Str" + delTemplateNamer.getDelegateName(nodeAsDelTemplate) + "String_Node_Str";
-        String delTemplateVariantExprText = "String_Node_Str" + nodeAsDelTemplate.getDelTemplateVariant() + "String_Node_Str";
-        jsCodeBuilder.appendLine("String_Node_Str", delTemplateIdExprText, "String_Node_Str", delTemplateVariantExprText, "String_Node_Str", nodeAsDelTemplate.getDelPriority().toString(), "String_Node_Str", alias, "String_Node_Str");
+        jsCodeBuilder.append(SOY_REGISTER_DELEGATE_FN.call(SOY_GET_DELTEMPLATE_ID.call(stringLiteral(delTemplateNamer.getDelegateName(nodeAsDelTemplate))), stringLiteral(nodeAsDelTemplate.getDelTemplateVariant()), number(nodeAsDelTemplate.getDelPriority().getValue()), dottedIdNoRequire(alias)));
     }


Input:
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... extra) {
    ItemStack itemStack = (ItemStack) extra[0];
    Vector3 position = new Vector3(data.readInt(), data.readInt(), data.readInt());
    ((ItemLaserDesignator) ICBMExplosion.itemLaserDesignator).setLauncherCountDown(itemStack, 119);
    player.worldObj.playSoundEffect(position.intX(), player.worldObj.getHeightValue(position.intX(), position.intZ()), position.intZ(), Reference.PREFIX + "String_Node_Str", 5.0F, (1.0F + (player.worldObj.rand.nextFloat() - player.worldObj.rand.nextFloat()) * 0.2F) * 0.7F);
    player.worldObj.spawnEntityInWorld(new EntityLightBeam(player.worldObj, position, 5 * 20, 0F, 1F, 0F));
    if (ICBMExplosion.itemRadarGun instanceof ItemElectric)
        ((ItemElectric) ICBMExplosion.itemRadarGun).discharge(itemStack, ItemLaserDesignator.YONG_DIAN_LIANG, true);
}

Output:
     if (ICBMExplosion.itemRadarGun instanceof ItemElectric)
-        ((ItemElectric) ICBMExplosion.itemRadarGun).discharge(itemStack, ItemLaserDesignator.YONG_DIAN_LIANG, true);
+        ((ItemElectric) ICBMExplosion.itemRadarGun).discharge(itemStack, ItemLaserDesignator.energyCost, true);
 }


Input:
public List<Reference> getDtoOppositeReferences(EObject context, List<Reference> references) {
    Map<String, Reference> map = new HashMap<String, Reference>();
    for (Reference ref : references) {
        if (ref.getOppositeOf() != null) {
            String key1 = ref.getOppositeOf().hashCode() + "String_Node_Str" + ref.hashCode();
            String key2 = ref.hashCode() + "String_Node_Str" + ref.getOppositeOf().hashCode();
            if (map.get(key1) == null && map.get(key2) == null) {
                map.put(key1, ref);
            }
        }
    }
    return new ArrayList<Reference>(map.values());
}

Output:
             if (map.get(key1) == null && map.get(key2) == null) {
-                map.put(key1, ref);
+                if (key1.compareTo(key2) > 0) {
+                    map.put(key1, ref);
+                } else {
+                    map.put(key2, ref.getOppositeOf());
+                }
             }


Input:
public HttpResponse execute(HttpRequest request) throws HttpClientException {
    HttpResponse response = null;
    try {
        HttpRequestBase uriRequest = methodMap.get(request.getMethod());
        uriRequest.setURI(request.getURI());
        boolean useSSL = "String_Node_Str".equals(request.getURI().getScheme());
        SSLContext sslContext = null;
        X509HostnameVerifier hostnameVerifier = null;
        HttpParams params = request.getParams();
        if (params != null) {
            if (params.getProxy() != null) {
                InetSocketAddress socketAddress = (InetSocketAddress) params.getProxy().address();
                HttpHost proxy = new HttpHost(socketAddress.getHostName(), socketAddress.getPort());
                uriRequest.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
                useSSL = false;
            }
            uriRequest.getParams().setIntParameter(CoreConnectionPNames.SOCKET_BUFFER_SIZE, params.getChunkSize());
            uriRequest.getParams().setIntParameter(CoreConnectionPNames.SO_TIMEOUT, params.getSocketTimeout());
            uriRequest.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, params.getConnectTimeout());
            uriRequest.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, Consts.UTF_8);
            uriRequest.getParams().setParameter(HttpHeaders.CONTENT_ENCODING, Consts.UTF_8);
            uriRequest.getParams().setParameter(HttpHeaders.ACCEPT_CHARSET, Consts.UTF_8);
            sslContext = params.getSSLContext();
            hostnameVerifier = new CustomHostnameVerifier(params.getHostnameVerifier());
        }
        if (useSSL) {
            if (sslContext == null) {
                sslContext = HttpClientFactory.allowSSLContext();
            }
            if (hostnameVerifier == null) {
                hostnameVerifier = SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
            }
            SSLSocketFactory socketFactory = new SSLSocketFactory(sslContext);
            socketFactory.setHostnameVerifier(hostnameVerifier);
            Scheme scheme = new Scheme("String_Node_Str", socketFactory, 443);
            httpClient.getConnectionManager().getSchemeRegistry().register(scheme);
        }
        addHeaders(request.getHeaders(), uriRequest);
        addEntity(request.getEntity(), uriRequest);
        org.apache.http.HttpResponse httpResponse = httpClient.execute(uriRequest);
        response = new HttpComponent4_1Response(httpResponse, getContent(httpResponse));
        handleResponse(response);
    } catch (IOException e) {
        throw new HttpClientException("String_Node_Str" + request.getMethod().name() + "String_Node_Str" + request.getURI().toString() + "String_Node_Str" + e.getMessage(), e);
    } finally {
        if (response != null) {
            response.close();
        }
    }
    return response;
}

Output:
     try {
-        HttpRequestBase uriRequest = methodMap.get(request.getMethod());
-        uriRequest.setURI(request.getURI());
+        HttpRequestBase uriRequest = createHttpRequest(request.getMethod(), request.getURI());
         boolean useSSL = "String_Node_Str".equals(request.getURI().getScheme());


Input:
public void queryStockByQuote(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String twUserName = (String) request.getParameter(QUOTE);
    if (twUserName != null && twUserName.length() > 0) {
        User userTmp = getUser() == null ? userMgr.random() : getUser();
        request.setAttribute(QUOTE, twUserName);
        TwitterProxy twitterProxy = null;
        Response resp = Response.create();
        twitterProxy = twitterProxyFactory.create(userTmp.getOauthToken(), userTmp.getOauthTokenSecret());
        SimpleTwitterUser twUser = null;
        ArrayList<SimpleTwitterUser> searchResultList = new ArrayList<SimpleTwitterUser>();
        if (twitterProxy != null) {
            try {
                try {
                    twitter4j.User twitterUser = twitterProxy.getTwUser(twUserName);
                    if (twitterUser != null) {
                        twUser = new SimpleTwitterUser(twitterUser);
                    }
                } catch (TwitterException ex) {
                }
                searchResultList = twitterProxy.searchUsers(twUserName);
                if (twUser == null) {
                    if (searchResultList != null && searchResultList.size() > 0) {
                        twUser = searchResultList.get(0);
                        searchResultList.remove(0);
                    }
                } else if (searchResultList.size() > 0 && twUser.getScreenName().equalsIgnoreCase(searchResultList.get(0).getScreenName())) {
                    searchResultList.remove(0);
                }
                request.setAttribute(OTHER_SEARCH_RESULTS, searchResultList);
            } catch (TwitterException e1) {
                resp.fail().reason("String_Node_Str");
                return;
            }
            Stock stock = null;
            if (twUser != null) {
                stock = stockMgr.getStockById(twUser.getId());
                if (stock == null) {
                    logger.debug("String_Node_Str" + twUserName);
                    stock = new Stock();
                    stock.setId(twUser.getId());
                    stock.setName(twUser.getScreenName());
                    stock.setTotal(twUser.getFollowerCount());
                    stock.setPictureUrl(twUser.getPictureUrl());
                    stock.setSold(0.0D);
                    stock.setVerified(twUser.isVerified());
                    stockMgr.saveStock(stock);
                } else {
                    stockMgr.updateTwitterData(stock.getId(), twUser.getFollowerCount(), twUser.getPictureUrl(), twUser.getScreenName(), twUser.isVerified());
                }
                request.setAttribute(STOCK, stock);
                logger.debug("String_Node_Str" + stock.getName());
            } else {
                logger.error("String_Node_Str" + twUserName);
                request.setAttribute(RESULT, USER_NOT_FOUND);
                request.setAttribute(REASON, twUserName + "String_Node_Str");
            }
        } else {
            logger.error("String_Node_Str" + twUserName);
            resp.fail().reason("String_Node_Str");
        }
    }
}

Output:
     if (twUserName != null && twUserName.length() > 0) {
-        User userTmp = getUser() == null ? userMgr.random() : getUser();
+        User userTmp = (User) (request.getAttribute(User.USER) == null ? userMgr.random() : request.getAttribute(User.USER));
         request.setAttribute(QUOTE, twUserName);


Input:
public final IReportItem copy() {
    final ChartReportItemImpl crii = new ChartReportItemImpl(handle);
    crii.bCopied = true;
    if (!ChartCubeUtil.isAxisChart(handle)) {
        crii.cm = cm == null ? null : cm.copyInstance();
    }
    return crii;
}

Output:
     if (!ChartCubeUtil.isAxisChart(handle)) {
-        crii.cm = cm == null ? null : cm.copyInstance();
+        if (cm == null) {
+            crii.cm = null;
+        } else {
+            synchronized (this) {
+                try {
+                    crii.cm = cm.copyInstance();
+                } catch (ConcurrentModificationException e) {
+                    crii.cm = cm.copyInstance();
+                } catch (NullPointerException e) {
+                    crii.cm = cm.copyInstance();
+                }
+            }
+        }
     }


Input:
public static int[] getInputOutputCandidateCounts(List<ColumnConfig> columnConfigList) {
    int input = 0, output = 0, candidate = 0;
    for (ColumnConfig config : columnConfigList) {
        if (!config.isTarget() && !config.isMeta()) {
            candidate++;
        }
        if (config.isFinalSelect()) {
            input++;
        }
        if (config.isTarget()) {
            output++;
        }
    }
    return new int[] { input, output, candidate };
}

Output:
 public static int[] getInputOutputCandidateCounts(List<ColumnConfig> columnConfigList) {
-    int input = 0, output = 0, candidate = 0;
+    int input = 0, output = 0, totalCandidate = 0, goodCandidate = 0;
     for (ColumnConfig config : columnConfigList) {


Input:
public boolean equals(Object obj) {
    User other = (User) obj;
    if (other == null) {
        return false;
    }
    if (compareValues(getName(), other.getName()) && compareValues(getEmail(), other.getEmail()) && isEnabled().equals(other.isEnabled()) && compareValues(getPassword(), other.getPassword()) && compareValues(getSalt(), other.getSalt()) && compareValues(getUserid(), other.getUserid()) && compareValues(getDescription(), other.getDescription())) {
        return true;
    }
    return false;
}

Output:
 public boolean equals(Object obj) {
-    User other = (User) obj;
-    if (other == null) {
+    if (this == obj) {
+        return true;
+    }
+    if (obj == null || getClass() != obj.getClass()) {
         return false;


Input:
public void rcDropByTextPath(final String pathType, final int preAscend, final String treePath, final String operator, int delayBeforeDrop) {
    Event wakeEvent = new Event();
    wakeEvent.type = SWT.MouseMove;
    getTreeTable().getDisplay().post(wakeEvent);
    waitForDisplayUpdate();
    SwtUtils.waitForDisplayIdle(getTreeTable().getDisplay());
    super.rcDropByTextPath(pathType, preAscend, treePath, operator, delayBeforeDrop);
    SwtUtils.waitForDisplayIdle(getTreeTable().getDisplay());
}

Output:
 public void rcDropByTextPath(final String pathType, final int preAscend, final String treePath, final String operator, int delayBeforeDrop) {
-    Event wakeEvent = new Event();
-    wakeEvent.type = SWT.MouseMove;
-    getTreeTable().getDisplay().post(wakeEvent);
-    waitForDisplayUpdate();
-    SwtUtils.waitForDisplayIdle(getTreeTable().getDisplay());
+    postMouseMovementEvent();
     super.rcDropByTextPath(pathType, preAscend, treePath, operator, delayBeforeDrop);


Input:
public CompoundVector getPlateauNaturalParameterPosterior() {
    List<Vector> naturalPlateauParametersPriors = ef_learningmodel.getDistributionList().stream().map(dist -> dist.getVariable()).filter(var -> isNonReplicatedVar(var)).filter(var -> this.getNodeOfNonReplicatedVar(var).isActive()).map(var -> {
        NaturalParameters parameter = this.getNodeOfNonReplicatedVar(var).getQDist().getNaturalParameters();
        NaturalParameters copy = new ArrayVector(parameter.size());
        copy.copy(parameter);
        return copy;
    }).collect(Collectors.toList());
    return new CompoundVector(naturalPlateauParametersPriors);
}

Output:
 public CompoundVector getPlateauNaturalParameterPosterior() {
-    List<Vector> naturalPlateauParametersPriors = ef_learningmodel.getDistributionList().stream().map(dist -> dist.getVariable()).filter(var -> isNonReplicatedVar(var)).filter(var -> this.getNodeOfNonReplicatedVar(var).isActive()).map(var -> {
+    List<Vector> naturalPlateauParametersPriors = ef_learningmodel.getDistributionList().stream().map(dist -> dist.getVariable()).filter(var -> isNonReplicatedVar(var)).map(var -> {
         NaturalParameters parameter = this.getNodeOfNonReplicatedVar(var).getQDist().getNaturalParameters();


Input:
private static String createRandomString(int minLength, int maxLength) {
    char[] chars = new char[(int) (Math.random() * (maxLength + 1)) + minLength];
    for (int i = 0; i < chars.length; i++) chars[i] = (char) (Math.random() * 0xFFFF);
    return new String(chars);
}

Output:
 private static String createRandomString(int minLength, int maxLength) {
-    char[] chars = new char[(int) (Math.random() * (maxLength + 1)) + minLength];
-    for (int i = 0; i < chars.length; i++) chars[i] = (char) (Math.random() * 0xFFFF);
+    char[] chars = new char[(int) (rnd.nextDouble() * (maxLength + 1)) + minLength];
+    for (int i = 0; i < chars.length; i++) chars[i] = (char) (rnd.nextDouble() * 0xFFFF);
     return new String(chars);


Input:
public void testGetFailed() throws Exception {
    final String topic = "String_Node_Str";
    final int maxSize = 1024;
    final Partition partition = new Partition("String_Node_Str");
    final long offset = 12;
    final byte[] data = "String_Node_Str".getBytes();
    final String url = "String_Node_Str";
    final MessageIterator messageIterator = new MessageIterator(topic, data);
    this.producerZooKeeper.publishTopic(topic);
    EasyMock.expectLastCall();
    EasyMock.expect(this.producerZooKeeper.selectBroker(topic, partition)).andReturn(url);
    EasyMock.expect(this.remotingClient.invokeToGroup(url, new GetCommand(topic, this.consumerConfig.getGroup(), partition.getPartition(), offset, maxSize, Integer.MIN_VALUE), 10000, TimeUnit.MILLISECONDS)).andReturn(new BooleanCommand(Integer.MIN_VALUE, 500, "String_Node_Str"));
    this.mocksControl.replay();
    try {
        OpaqueGenerator.resetOpaque();
        assertEquals(messageIterator, this.consumer.get(topic, partition, offset, maxSize));
        fail();
    } catch (final MetaClientException e) {
    }
    this.mocksControl.verify();
}

Output:
     final MessageIterator messageIterator = new MessageIterator(topic, data);
-    this.producerZooKeeper.publishTopic(topic);
+    this.producerZooKeeper.publishTopic(topic, this.consumer);
     EasyMock.expectLastCall();


Input:
public void run() {
    try {
        guiHome.updateCalendar(monthNumber, proxy);
    } catch (ParseException e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        guiHome.updateCalendar(monthNumber, proxy);
+        guiHome.updateCalendar(proxy);
     } catch (ParseException e) {


Input:
private NodeValue getNodeValueForValue(Object value) {
    if (value == null) {
        Iterator<NodeValue> nodeValues = fieldToNodeValues.values().iterator();
        while (nodeValues.hasNext()) {
            XMLChoiceCollectionMappingUnmarshalNodeValue unmarshalNodeValue = (XMLChoiceCollectionMappingUnmarshalNodeValue) nodeValues.next();
            NodeValue nextNodeValue = unmarshalNodeValue.getChoiceElementMarshalNodeValue();
            if (nextNodeValue instanceof MappingNodeValue) {
                Mapping nextMapping = ((MappingNodeValue) nextNodeValue).getMapping();
                if (nextMapping.isAbstractCompositeCollectionMapping()) {
                    if (((CompositeCollectionMapping) nextMapping).getNullPolicy().isNullRepresentedByXsiNil()) {
                        return unmarshalNodeValue;
                    }
                } else if (nextMapping.isAbstractCompositeDirectCollectionMapping()) {
                    if (((DirectCollectionMapping) nextMapping).getNullPolicy().isNullRepresentedByXsiNil()) {
                        return unmarshalNodeValue;
                    }
                } else if (nextMapping instanceof BinaryDataCollectionMapping) {
                    if (((BinaryDataCollectionMapping) nextMapping).getNullPolicy().isNullRepresentedByXsiNil()) {
                        return unmarshalNodeValue;
                    }
                }
            }
        }
        return null;
    }
    Field associatedField = null;
    NodeValue nodeValue = null;
    if (value instanceof Root) {
        Root rootValue = (Root) value;
        String localName = rootValue.getLocalName();
        String namespaceUri = rootValue.getNamespaceURI();
        Object fieldValue = rootValue.getObject();
        associatedField = getFieldForName(localName, namespaceUri);
        if (associatedField == null) {
            if (xmlChoiceCollectionMapping.isAny()) {
                return this.anyNodeValue;
            }
            Class theClass = fieldValue.getClass();
            while (associatedField == null) {
                associatedField = (Field) xmlChoiceCollectionMapping.getClassToFieldMappings().get(theClass);
                if (theClass.getSuperclass() != null) {
                    theClass = theClass.getSuperclass();
                } else {
                    break;
                }
            }
        }
        if (associatedField != null) {
            nodeValue = this.fieldToNodeValues.get(associatedField);
        }
    } else {
        Class theClass = value.getClass();
        while (associatedField == null) {
            associatedField = (Field) xmlChoiceCollectionMapping.getClassToFieldMappings().get(theClass);
            nodeValue = classToNodeValues.get(theClass);
            if (theClass.getSuperclass() != null) {
                theClass = theClass.getSuperclass();
            } else {
                break;
            }
        }
    }
    if (associatedField == null) {
        List<Field> sourceFields = null;
        Class theClass = value.getClass();
        while (theClass != null) {
            sourceFields = (List<Field>) xmlChoiceCollectionMapping.getClassToSourceFieldsMappings().get(theClass);
            if (sourceFields != null) {
                break;
            }
            theClass = theClass.getSuperclass();
        }
        if (sourceFields != null) {
            associatedField = sourceFields.get(0);
            nodeValue = fieldToNodeValues.get(associatedField);
        }
    }
    if (nodeValue != null) {
        return nodeValue;
    }
    if (associatedField != null) {
        return fieldToNodeValues.get(associatedField);
    }
    if (xmlChoiceCollectionMapping.isMixedContent() && value instanceof String) {
        return this;
    }
    if (xmlChoiceCollectionMapping.isAny()) {
        return anyNodeValue;
    }
    return null;
}

Output:
             associatedField = (Field) xmlChoiceCollectionMapping.getClassToFieldMappings().get(theClass);
-            nodeValue = classToNodeValues.get(theClass);
+            List<FieldNodeValue> fieldNodes = classToNodeValues.get(theClass);
+            nodeValue = null;
+            if (null != fieldNodes) {
+                if (null != associatedField && fieldNodes.size() > 1) {
+                    for (FieldNodeValue fieldNode : fieldNodes) {
+                        if (fieldNode.getField().equals(associatedField)) {
+                            nodeValue = fieldNode.getNodeValue();
+                        }
+                    }
+                }
+                if (null == nodeValue && fieldNodes.size() > 0) {
+                    nodeValue = fieldNodes.get(0).getNodeValue();
+                }
+            }
             if (theClass.getSuperclass() != null) {


Input:
public String getContent() {
    String postContent;
    if (!getMt_text_more().equals("String_Node_Str")) {
        if (isLocalDraft())
            postContent = getDescription() + "String_Node_Str" + getMt_text_more();
        else
            postContent = getDescription() + "String_Node_Str" + getMt_text_more();
    } else
        postContent = getDescription();
    return postContent;
}

Output:
     String postContent;
-    if (!getMt_text_more().equals("String_Node_Str")) {
+    if (!TextUtils.isEmpty(getMoreText())) {
         if (isLocalDraft())


Input:
public Object getElementInfo() throws JavaModelException {
    try {
        return super.getElementInfo();
    } catch (JavaModelException jme) {
        if (!jme.getJavaModelStatus().isDoesNotExist()) {
            throw jme;
        }
        final IType anonType = this;
        return new org.eclipse.jdt.internal.core.SourceTypeElementInfo() {
            {
                setHandle(anonType);
                setFlags(inner.getModifiers());
                ClassNode[] faces = inner.getInterfaces();
                char[][] names = new char[faces.length][];
                for (int i = 0; i < faces.length; i += 1) {
                    names[i] = faces[i].getName().toCharArray();
                }
                setSuperInterfaceNames(names);
                setSuperclassName(inner.getUnresolvedSuperClass().getName().toCharArray());
                setNameSourceStart(inner.getNameStart());
                setNameSourceEnd(inner.getNameEnd());
                setSourceRangeStart(inner.getStart());
                setSourceRangeEnd(inner.getEnd());
            }
        };
    }
}

Output:
             {
-                setHandle(anonType);
-                setFlags(inner.getModifiers());
-                ClassNode[] faces = inner.getInterfaces();
-                char[][] names = new char[faces.length][];
-                for (int i = 0; i < faces.length; i += 1) {
-                    names[i] = faces[i].getName().toCharArray();
-                }
-                setSuperInterfaceNames(names);
-                setSuperclassName(inner.getUnresolvedSuperClass().getName().toCharArray());
-                setNameSourceStart(inner.getNameStart());
-                setNameSourceEnd(inner.getNameEnd());
-                setSourceRangeStart(inner.getStart());
-                setSourceRangeEnd(inner.getEnd());
+                setReturnType(methodNode.getReturnType().getNameWithoutPackage().toCharArray());
+                setNameSourceStart(methodNode.getNameStart());
+                setNameSourceEnd(methodNode.getNameEnd());
+                setSourceRangeStart(methodNode.getStart());
+                setSourceRangeEnd(methodNode.getEnd());
+                setFlags(methodNode.getModifiers());
             }


Input:
public void drawData(Canvas c) {
    int width = (int) mViewPortHandler.getChartWidth();
    int height = (int) mViewPortHandler.getChartHeight();
    if (mDrawBitmap == null || (mDrawBitmap.getWidth() != width) || (mDrawBitmap.getHeight() != height)) {
        if (width > 0 && height > 0) {
            mDrawBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_4444);
            mBitmapCanvas = new Canvas(mDrawBitmap);
        } else
            return;
    }
    mDrawBitmap.eraseColor(Color.TRANSPARENT);
    LineData lineData = mChart.getLineData();
    for (LineDataSet set : lineData.getDataSets()) {
        if (set.isVisible())
            drawDataSet(c, set);
    }
    c.drawBitmap(mDrawBitmap, 0, 0, mRenderPaint);
}

Output:
     for (LineDataSet set : lineData.getDataSets()) {
-        if (set.isVisible())
+        if (set.isVisible() && set.getEntryCount() > 0)
             drawDataSet(c, set);