Input:
public void handleFree(DownloadLink downloadLink) throws Exception {
    setBrowserExclusive();
    requestFileInformation(downloadLink);
    String link = downloadLink.getDownloadURL();
    br.getPage(link);
    if (br.getRedirectLocation() != null) {
        link = br.getRedirectLocation().replaceAll("String_Node_Str", "String_Node_Str");
        br.getPage(link);
    }
    if (br.containsHTML(DOWNLOAD_NOTALLOWED)) {
        throw new PluginException(LinkStatus.ERROR_TEMPORARILY_UNAVAILABLE, 20 * 60 * 1000l);
    }
    String dllink = br.getRegex("String_Node_Str").getMatch(0);
    if (dllink != null) {
        dl = jd.plugins.BrowserAdapter.openDownload(br, downloadLink, dllink, true, 1);
        URLConnectionAdapter con = dl.getConnection();
        if (Plugin.getFileNameFromHeader(con) == null || Plugin.getFileNameFromHeader(con).indexOf("String_Node_Str") >= 0) {
            con.disconnect();
            throw new PluginException(LinkStatus.ERROR_RETRY);
        }
        if (!con.isContentDisposition()) {
            con.disconnect();
            throw new PluginException(LinkStatus.ERROR_TEMPORARILY_UNAVAILABLE, 10 * 60 * 1000l);
        }
        dl.startDownload();
    } else {
        if (br.containsHTML("String_Node_Str") || br.containsHTML("String_Node_Str")) {
            String wait = br.getRegex("String_Node_Str").getMatch(0);
            if (wait != null)
                throw new PluginException(LinkStatus.ERROR_IP_BLOCKED, Integer.parseInt(wait.trim()) * 1000l);
            throw new PluginException(LinkStatus.ERROR_IP_BLOCKED, 30 * 60 * 1000l);
        }
        Form form = br.getFormBySubmitvalue("String_Node_Str");
        if (form == null)
            throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFEKT);
        br.submitForm(form);
        if (br.containsHTML("String_Node_Str"))
            throw new PluginException(LinkStatus.ERROR_IP_BLOCKED, JDL.L("String_Node_Str", "String_Node_Str"), 10 * 60 * 1000l);
        String wait = br.getRegex("String_Node_Str").getMatch(0);
        if (wait != null)
            throw new PluginException(LinkStatus.ERROR_IP_BLOCKED, Regex.getMilliSeconds(wait));
        if (br.containsHTML("String_Node_Str"))
            throw new PluginException(LinkStatus.ERROR_IP_BLOCKED, null, 2 * 60 * 1001l);
        if (br.getRedirectLocation() != null && br.getRedirectLocation().indexOf("String_Node_Str") > 0) {
            throw new PluginException(LinkStatus.ERROR_RETRY);
        }
        dllink = br.getRegex("String_Node_Str").getMatch(0);
        if (dllink == null)
            throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFEKT);
        dl = jd.plugins.BrowserAdapter.openDownload(br, downloadLink, dllink, true, 1);
        URLConnectionAdapter con = dl.getConnection();
        if (Plugin.getFileNameFromHeader(con) == null || Plugin.getFileNameFromHeader(con).indexOf("String_Node_Str") >= 0) {
            con.disconnect();
            throw new PluginException(LinkStatus.ERROR_RETRY);
        }
        if (!con.isContentDisposition()) {
            con.disconnect();
            throw new PluginException(LinkStatus.ERROR_TEMPORARILY_UNAVAILABLE, 10 * 60 * 1000l);
        }
        dl.startDownload();
    }
}

Output:
     }
-    if (br.containsHTML(DOWNLOAD_NOTALLOWED)) {
-        throw new PluginException(LinkStatus.ERROR_TEMPORARILY_UNAVAILABLE, 20 * 60 * 1000l);
-    }
+    checkErrors();
     String dllink = br.getRegex("String_Node_Str").getMatch(0);


Input:
private int renameAS2Identifiers(RenameType renameType, Map<String, String> selected) {
    actionsMap = new HashMap<>();
    allFunctions = new ArrayList<>();
    allVariableNames = new ArrayList<>();
    allStrings = new HashMap<>();
    List<Object> objs = new ArrayList<>();
    int ret = 0;
    objs.addAll(tags);
    getVariables(objs, "String_Node_Str");
    informListeners("String_Node_Str", "String_Node_Str");
    int fc = 0;
    for (MyEntry<DirectValueActionItem, ConstantPool> it : allVariableNames) {
        String name = it.key.toStringNoH(it.value);
        allVariableNamesStr.add(name);
    }
    informListeners("String_Node_Str", "String_Node_Str");
    int classCount = 0;
    for (Tag t : tags) {
        if (t instanceof DoInitActionTag) {
            classCount++;
        }
    }
    int cnt = 0;
    for (Tag t : tags) {
        if (t instanceof DoInitActionTag) {
            cnt++;
            informListeners("String_Node_Str", "String_Node_Str" + cnt + "String_Node_Str" + classCount);
            DoInitActionTag dia = (DoInitActionTag) t;
            String exportName = dia.getExportName();
            final String pkgPrefix = "String_Node_Str";
            String[] classNameParts = null;
            if ((exportName != null) && exportName.startsWith(pkgPrefix)) {
                String className = exportName.substring(pkgPrefix.length());
                if (className.contains("String_Node_Str")) {
                    classNameParts = className.split("String_Node_Str");
                } else {
                    classNameParts = new String[] { className };
                }
            }
            int staticOperation = (Boolean) Configuration.getConfig("String_Node_Str", true) ? Graph.SOP_SKIP_STATIC : Graph.SOP_USE_STATIC;
            List<GraphTargetItem> dec = Action.actionsToTree(dia.getActions(version), version, staticOperation, "String_Node_Str");
            GraphTargetItem name = null;
            for (GraphTargetItem it : dec) {
                if (it instanceof ClassActionItem) {
                    ClassActionItem cti = (ClassActionItem) it;
                    List<GraphTargetItem> methods = new ArrayList<>();
                    methods.addAll(cti.functions);
                    methods.addAll(cti.staticFunctions);
                    for (GraphTargetItem gti : methods) {
                        if (gti instanceof FunctionActionItem) {
                            FunctionActionItem fun = (FunctionActionItem) gti;
                            if (fun.calculatedFunctionName instanceof DirectValueActionItem) {
                                DirectValueActionItem dvf = (DirectValueActionItem) fun.calculatedFunctionName;
                                String fname = dvf.toStringNoH(null);
                                String changed = deobfuscateName(fname, false, "String_Node_Str", renameType, selected);
                                if (changed != null) {
                                    deobfuscated.put(fname, changed);
                                }
                            }
                        }
                    }
                    List<GraphTargetItem> vars = new ArrayList<>();
                    for (MyEntry<GraphTargetItem, GraphTargetItem> item : cti.vars) {
                        vars.add(item.key);
                    }
                    for (MyEntry<GraphTargetItem, GraphTargetItem> item : cti.staticVars) {
                        vars.add(item.key);
                    }
                    for (GraphTargetItem gti : vars) {
                        if (gti instanceof DirectValueActionItem) {
                            DirectValueActionItem dvf = (DirectValueActionItem) gti;
                            String vname = dvf.toStringNoH(null);
                            String changed = deobfuscateName(vname, false, "String_Node_Str", renameType, selected);
                            if (changed != null) {
                                deobfuscated.put(vname, changed);
                            }
                        }
                    }
                    name = cti.className;
                    break;
                }
                if (it instanceof InterfaceActionItem) {
                    InterfaceActionItem ift = (InterfaceActionItem) it;
                    name = ift.name;
                }
            }
            if (name != null) {
                int pos = 0;
                while (name instanceof GetMemberActionItem) {
                    GetMemberActionItem mem = (GetMemberActionItem) name;
                    GraphTargetItem memberName = mem.memberName;
                    if (memberName instanceof DirectValueActionItem) {
                        DirectValueActionItem dvt = (DirectValueActionItem) memberName;
                        String nameStr = dvt.toStringNoH(null);
                        if (classNameParts != null) {
                            if (classNameParts.length - 1 - pos < 0) {
                                break;
                            }
                        }
                        String changedNameStr = nameStr;
                        if (classNameParts != null) {
                            changedNameStr = classNameParts[classNameParts.length - 1 - pos];
                        }
                        String changedNameStr2 = deobfuscateName(changedNameStr, pos == 0, pos == 0 ? "String_Node_Str" : "String_Node_Str", renameType, selected);
                        if (changedNameStr2 != null) {
                            changedNameStr = changedNameStr2;
                        }
                        ret++;
                        deobfuscated.put(nameStr, changedNameStr);
                        pos++;
                    }
                    name = mem.object;
                }
                if (name instanceof GetVariableActionItem) {
                    GetVariableActionItem var = (GetVariableActionItem) name;
                    if (var.name instanceof DirectValueActionItem) {
                        DirectValueActionItem dvt = (DirectValueActionItem) var.name;
                        String nameStr = dvt.toStringNoH(null);
                        if (classNameParts != null) {
                            if (classNameParts.length - 1 - pos < 0) {
                                break;
                            }
                        }
                        String changedNameStr = nameStr;
                        if (classNameParts != null) {
                            changedNameStr = classNameParts[classNameParts.length - 1 - pos];
                        }
                        String changedNameStr2 = deobfuscateName(changedNameStr, pos == 0, pos == 0 ? "String_Node_Str" : "String_Node_Str", renameType, selected);
                        if (changedNameStr2 != null) {
                            changedNameStr = changedNameStr2;
                        }
                        ret++;
                        deobfuscated.put(nameStr, changedNameStr);
                        pos++;
                    }
                }
            }
        }
    }
    for (GraphSourceItem fun : allFunctions) {
        fc++;
        informListeners("String_Node_Str", "String_Node_Str" + fc + "String_Node_Str" + allFunctions.size());
        if (fun instanceof ActionDefineFunction) {
            ActionDefineFunction f = (ActionDefineFunction) fun;
            if (f.functionName.equals("String_Node_Str")) {
                continue;
            }
            String changed = deobfuscateName(f.functionName, false, "String_Node_Str", renameType, selected);
            if (changed != null) {
                f.replacedFunctionName = changed;
                ret++;
            }
        }
        if (fun instanceof ActionDefineFunction2) {
            ActionDefineFunction2 f = (ActionDefineFunction2) fun;
            if (f.functionName.equals("String_Node_Str")) {
                continue;
            }
            String changed = deobfuscateName(f.functionName, false, "String_Node_Str", renameType, selected);
            if (changed != null) {
                f.replacedFunctionName = changed;
                ret++;
            }
        }
    }
    HashSet<String> stringsNoVarH = new HashSet<>();
    List<DirectValueActionItem> allVariableNamesDv = new ArrayList<>();
    for (MyEntry<DirectValueActionItem, ConstantPool> it : allVariableNames) {
        allVariableNamesDv.add(it.key);
    }
    for (DirectValueActionItem ti : allStrings.keySet()) {
        if (!allVariableNamesDv.contains(ti)) {
            stringsNoVarH.add(System.identityHashCode(allStrings.get(ti)) + "String_Node_Str" + ti.toStringNoH(allStrings.get(ti)));
        }
    }
    int vc = 0;
    for (MyEntry<DirectValueActionItem, ConstantPool> it : allVariableNames) {
        vc++;
        String name = it.key.toStringNoH(it.value);
        String changed = deobfuscateName(name, false, usageTypes.get(it.key), renameType, selected);
        if (changed != null) {
            boolean addNew = false;
            String h = System.identityHashCode(it.key) + "String_Node_Str" + name;
            if (stringsNoVarH.contains(h)) {
                addNew = true;
            }
            ActionPush pu = (ActionPush) it.key.src;
            if (pu.replacement == null) {
                pu.replacement = new ArrayList<>();
                pu.replacement.addAll(pu.values);
            }
            if (pu.replacement.get(it.key.pos) instanceof ConstantIndex) {
                ConstantIndex ci = (ConstantIndex) pu.replacement.get(it.key.pos);
                ConstantPool pool = it.value;
                if (pool == null) {
                    continue;
                }
                if (pool.constants == null) {
                    continue;
                }
                if (addNew) {
                    pool.constants.add(changed);
                    ci.index = pool.constants.size() - 1;
                } else {
                    pool.constants.set(ci.index, changed);
                }
            } else {
                pu.replacement.set(it.key.pos, changed);
            }
            ret++;
        }
    }
    for (ASMSource src : actionsMap.keySet()) {
        actionsMap.put(src, Action.removeNops(0, actionsMap.get(src), version, 0, "String_Node_Str"));
        src.setActions(actionsMap.get(src), version);
    }
    deobfuscateInstanceNames(renameType, tags, selected);
    return ret;
}

Output:
             }
-            int staticOperation = (Boolean) Configuration.getConfig("String_Node_Str", true) ? Graph.SOP_SKIP_STATIC : Graph.SOP_USE_STATIC;
+            int staticOperation = Graph.SOP_USE_STATIC;
             List<GraphTargetItem> dec = Action.actionsToTree(dia.getActions(version), version, staticOperation, "String_Node_Str");


Input:
public void endTurn(int turnTime, boolean advanceTime) {
    long startHour = getHour();
    if (advanceTime) {
        minutesPassed += turnTime;
        updateResponses();
    }
    int hoursPassed = (int) (getHour() - startHour);
    int hourStartTo24 = (int) (startHour % 24);
    for (int i = 1; i <= hoursPassed; i++) {
        slaveryUtil.performHourlyUpdate(this.getDayNumber(startHour * 60 + i * 60), (hourStartTo24 + i) % 24);
    }
    boolean newDay = ((int) (minutesPassed / (60 * 24)) != (int) (((minutesPassed - turnTime) / (60 * 24))));
    if (newDay) {
        AbstractClothing goggles = AbstractClothingType.generateClothing(ClothingType.SCIENTIST_EYES_SAFETY_GOGGLES, Colour.CLOTHING_BLACK, false);
        if (!Main.game.getWorlds().get(WorldType.LILAYAS_HOUSE_GROUND_FLOOR).getCell(PlaceType.LILAYA_HOME_LAB).getInventory().hasClothing(goggles)) {
            Main.game.getWorlds().get(WorldType.LILAYAS_HOUSE_GROUND_FLOOR).getCell(PlaceType.LILAYA_HOME_LAB).getInventory().addClothing(goggles);
        }
        pendingSlaveInStocksReset = true;
    }
    if (pendingSlaveInStocksReset && Main.game.getPlayer().getLocationPlace().getPlaceType() != PlaceType.SLAVER_ALLEY_PUBLIC_STOCKS) {
        for (NPC npc : Main.game.getCharactersPresent(Main.game.getWorlds().get(WorldType.SLAVER_ALLEY).getCell(PlaceType.SLAVER_ALLEY_PUBLIC_STOCKS))) {
            if (npc instanceof SlaveInStocks) {
                Main.game.banishNPC(npc);
            }
        }
        for (int i = 0; i < 4; i++) {
            SlaveInStocks slave = new SlaveInStocks(GenderPreference.getGenderFromUserPreferences());
            if (Math.random() > 0.5f) {
                Main.game.getGenericFemaleNPC().addSlave(slave);
            } else {
                Main.game.getGenericMaleNPC().addSlave(slave);
            }
            try {
                Main.game.addNPC(slave, false);
            } catch (Exception e) {
                e.printStackTrace();
            }
            slavesInStocks.add(slave);
        }
        pendingSlaveInStocksReset = false;
    }
    handleAtmosphericConditions(turnTime);
    isInNPCUpdateLoop = true;
    for (NPC npc : NPCMap.values()) {
        if (npc.getLocationPlace().getPlaceType() != PlaceType.DOMINION_BACK_ALLEYS && npc.getWorldLocation() == WorldType.DOMINION && npc instanceof DominionAlleywayAttacker && !Main.game.getPlayer().getLocation().equals(npc.getLocation())) {
            banishNPC(npc);
        }
    }
    for (NPC npc : NPCMap.values()) {
        npc.calculateStatusEffects(turnTime);
        if (npc.isPendingClothingDressing() && (Main.game.getCurrentDialogueNode().equals(Main.game.getPlayer().getLocationPlace().getDialogue(false)) || !(npc.getWorldLocation() == Main.game.getPlayer().getWorldLocation() && npc.getLocation().equals(Main.game.getPlayer().getLocation())))) {
            npc.equipClothing(true, true);
            npc.setPendingClothingDressing(false);
        }
        if (npc.isPendingTransformationToGenderIdentity()) {
            npc.setBody(npc.getGenderIdentity(), RacialBody.valueOfRace(npc.getRace()), npc.getRaceStage());
            CharacterUtils.randomiseBody(npc);
            npc.setPendingTransformationToGenderIdentity(false);
        }
        if ((!npc.isPregnant() && !npc.isSlave() && npc.getHistory() == History.PROSTITUTE && !npc.hasStatusEffect(StatusEffect.PROMISCUITY_PILL) && !npc.getLocation().equals(Main.game.getPlayer().getLocation())) || (npc.isSlave() && npc.getSlaveJobSettings().contains(SlaveJobSetting.SEX_PROMISCUITY_PILLS))) {
            npc.useItem(AbstractItemType.generateItem(ItemType.PROMISCUITY_PILL), npc, false);
        }
        if (npc.isSlave() && npc.getSlaveJobSettings().contains(SlaveJobSetting.SEX_VIXENS_VIRILITY)) {
            npc.useItem(AbstractItemType.generateItem(ItemType.VIXENS_VIRILITY), npc, false);
        }
        if (npc.hasStatusEffect(StatusEffect.PREGNANT_3) && (minutesPassed - npc.getTimeProgressedToFinalPregnancyStage()) > (12 * 60)) {
            if (npc instanceof Lilaya) {
                if (!Main.game.getDialogueFlags().values.contains(DialogueFlagValue.reactedToPregnancyLilaya)) {
                    npc.endPregnancy(true);
                }
            } else {
                npc.endPregnancy(true);
                if (npc instanceof Kate) {
                    Main.game.getDialogueFlags().values.remove(DialogueFlagValue.reactedToKatePregnancy);
                }
            }
        }
        if (npc.getLocation().equals(Main.game.getPlayer().getLocation()) && npc.getWorldLocation() == Main.game.getPlayer().getWorldLocation()) {
            for (CoverableArea ca : CoverableArea.values()) {
                if (npc.isCoverableAreaExposed(ca) && ca != CoverableArea.MOUTH) {
                    npc.getPlayerKnowsAreasMap().put(ca, true);
                }
            }
        }
        if (newDay) {
            npc.dailyReset();
        }
    }
    isInNPCUpdateLoop = false;
    for (NPC npc : npcsToRemove) {
        NPCMap.remove(npc.getId());
    }
    for (NPC npc : npcsToAdd) {
        NPCMap.put(npc.getId(), npc);
    }
    npcsToRemove.clear();
    npcsToAdd.clear();
    if (!isInCombat()) {
        if (Main.game.getCurrentDialogueNode() != MiscDialogue.STATUS_EFFECTS) {
            Main.game.getPlayer().calculateStatusEffects(turnTime);
        }
        if (!inSex && !currentDialogueNode.isRegenerationDisabled()) {
            if (Main.game.getPlayer().getStaminaPercentage() < 1)
                Main.game.getPlayer().incrementStamina(turnTime * 0.1f);
            if (Main.game.getPlayer().getHealthPercentage() < 1)
                Main.game.getPlayer().incrementHealth(turnTime * 0.1f);
            if (Main.game.getPlayer().getManaPercentage() < 1)
                Main.game.getPlayer().incrementMana(turnTime * 0.1f);
        }
    }
    RenderingEngine.ENGINE.renderButtons();
    Main.mainController.updateUI();
    Main.mainController.getTooltip().hide();
    if (!Main.game.getPlayer().getStatusEffectDescriptions().isEmpty() && Main.game.getCurrentDialogueNode() != MiscDialogue.STATUS_EFFECTS) {
        if (Main.game.getCurrentDialogueNode().getMapDisplay() == MapDisplay.NORMAL)
            Main.game.saveDialogueNode();
        Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", MiscDialogue.STATUS_EFFECTS) {
            public void effects() {
                if (!Main.game.getPlayer().hasQuest(QuestLine.SIDE_ENCHANTMENT_DISCOVERY) && Main.game.getPlayer().hasNonArcaneEssences()) {
                    Main.game.getTextEndStringBuilder().append(Main.game.getPlayer().incrementQuest(QuestLine.SIDE_ENCHANTMENT_DISCOVERY));
                }
                if (!Main.game.getPlayer().hasQuest(QuestLine.SIDE_FIRST_TIME_PREGNANCY) && Main.game.getPlayer().isVisiblyPregnant()) {
                    Main.game.getTextEndStringBuilder().append(Main.game.getPlayer().incrementQuest(QuestLine.SIDE_FIRST_TIME_PREGNANCY));
                }
            }
        });
        Main.game.getPlayer().getStatusEffectDescriptions().clear();
    }
}

Output:
     if (!Main.game.getPlayer().getStatusEffectDescriptions().isEmpty() && Main.game.getCurrentDialogueNode() != MiscDialogue.STATUS_EFFECTS) {
-        if (Main.game.getCurrentDialogueNode().getMapDisplay() == MapDisplay.NORMAL)
+        if (Main.game.getCurrentDialogueNode().getMapDisplay() == MapDisplay.NORMAL) {
             Main.game.saveDialogueNode();


Input:
private Set<String> getAllExposedArchivesIdsExluding(Location excludedLocation) {
    QueryBuilder query = QueryBuilders.boolQuery().mustNot(QueryBuilders.idsQuery(Location.class.getSimpleName().toLowerCase()).ids(excludedLocation.getId()));
    List<Location> locations = alienDAO.customFindAll(Location.class, query);
    Set<String> archiveIds = Sets.newHashSet();
    if (locations != null) {
        for (Location location : locations) {
            IOrchestratorPlugin orchestratorInstance = (IOrchestratorPlugin) orchestratorPluginService.getOrFail(location.getOrchestratorId());
            ILocationConfiguratorPlugin configuratorPlugin = orchestratorInstance.getConfigurator(location.getInfrastructureType());
            List<PluginArchive> pluginArchives = configuratorPlugin.pluginArchives();
            for (PluginArchive pluginArchive : pluginArchives) {
                archiveIds.add(pluginArchive.getArchive().getArchive().getId());
            }
        }
    }
    return archiveIds;
}

Output:
         for (Location location : locations) {
-            IOrchestratorPlugin orchestratorInstance = (IOrchestratorPlugin) orchestratorPluginService.getOrFail(location.getOrchestratorId());
-            ILocationConfiguratorPlugin configuratorPlugin = orchestratorInstance.getConfigurator(location.getInfrastructureType());
+            ILocationConfiguratorPlugin configuratorPlugin = getConfiguratorPlugin(location);
             List<PluginArchive> pluginArchives = configuratorPlugin.pluginArchives();


Input:
public Graphics2D canvasGraphics() {
    try {
        Graphics2D graphics = (Graphics2D) (bufferStrategy != null ? bufferStrategy.getDrawGraphics() : canvas.getGraphics());
        return graphics;
    } catch (IllegalStateException e) {
        e.printStackTrace();
        return null;
    }
}

Output:
 public Graphics2D canvasGraphics() {
-    try {
-        Graphics2D graphics = (Graphics2D) (bufferStrategy != null ? bufferStrategy.getDrawGraphics() : canvas.getGraphics());
-        return graphics;
-    } catch (IllegalStateException e) {
-        e.printStackTrace();
-        return null;
-    }
+    Graphics2D graphics = (Graphics2D) (bufferStrategy != null ? bufferStrategy.getDrawGraphics() : canvas.getGraphics());
+    return graphics;
 }


Input:
public void find_SVarLong_errorCode() throws Exception {
    Random random = new Random();
    byte[] bytes = new byte[10];
    while (true) {
        random.nextBytes(bytes);
        Buffer buffer = new FixedBuffer(bytes);
        try {
            long i = buffer.readVarLong();
        } catch (IllegalArgumentException e) {
            logger.info(e.getMessage(), e);
            String binaryString = Bytes.toStringBinary(bytes);
            logger.info(binaryString);
            ;
            for (byte aByte : bytes) {
                String code = String.valueOf((int) aByte);
                logger.info(code);
            }
            return;
        }
    }
}

Output:
             logger.info(e.getMessage(), e);
-            String binaryString = Bytes.toStringBinary(bytes);
+            String binaryString = BytesUtils.toString(bytes);
             logger.info(binaryString);


Input:
private boolean IsInSelectionRectangle(float x, float y) {
    float XMin = Math.min(fDragStartPoint[0], fDragEndPoint[0]);
    float XMax = Math.max(fDragStartPoint[0], fDragEndPoint[0]);
    float YMin = Math.min(fDragStartPoint[1], fDragEndPoint[1]);
    float YMax = Math.max(fDragStartPoint[1], fDragEndPoint[1]);
    x = x + XYAXISDISTANCE;
    y = y + XYAXISDISTANCE;
    if (x >= XMin && x <= XMax)
        if (y >= YMin && y <= YMax)
            return true;
    return false;
}

Output:
 private boolean IsInSelectionRectangle(float x, float y) {
-    float XMin = Math.min(fDragStartPoint[0], fDragEndPoint[0]);
-    float XMax = Math.max(fDragStartPoint[0], fDragEndPoint[0]);
-    float YMin = Math.min(fDragStartPoint[1], fDragEndPoint[1]);
-    float YMax = Math.max(fDragStartPoint[1], fDragEndPoint[1]);
+    float XMin = Math.min(fRectangleDragStartPoint[0], fRectangleDragEndPoint[0]);
+    float XMax = Math.max(fRectangleDragStartPoint[0], fRectangleDragEndPoint[0]);
+    float YMin = Math.min(fRectangleDragStartPoint[1], fRectangleDragEndPoint[1]);
+    float YMax = Math.max(fRectangleDragStartPoint[1], fRectangleDragEndPoint[1]);
     x = x + XYAXISDISTANCE;


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    Permanent enchantment = game.getPermanent(source.getSourceId());
    if (enchantment == null || controller == null || enchantment.getAttachedTo() == null) {
        return false;
    }
    Permanent creature = game.getPermanent(enchantment.getAttachedTo());
    if (creature == null) {
        return false;
    }
    Cards cards = new CardsImpl();
    cards.addAll(controller.getLibrary().getTopCards(game, 5));
    controller.lookAtCards(enchantment.getIdName(), cards, game);
    FilterCreatureCard filter = new FilterCreatureCard();
    if (!creature.getAbilities().contains(ChangelingAbility.getInstance())) {
        StringBuilder sb = new StringBuilder("String_Node_Str");
        ArrayList<Predicate<MageObject>> subtypes = new ArrayList<>();
        for (String subtype : creature.getSubtype(game)) {
            subtypes.add(new SubtypePredicate(subtype));
            sb.append(subtype).append("String_Node_Str");
        }
        filter.add(Predicates.or(subtypes));
        sb.delete(sb.length() - 2, sb.length());
        filter.setMessage(sb.toString());
    } else {
        filter.setMessage("String_Node_Str");
    }
    if (cards.count(filter, game) > 0 && controller.chooseUse(Outcome.DrawCard, "String_Node_Str", source, game)) {
        TargetCard target = new TargetCard(Zone.LIBRARY, filter);
        if (controller.choose(Outcome.PutCreatureInPlay, cards, target, game)) {
            Card card = cards.get(target.getFirstTarget(), game);
            if (card != null) {
                cards.remove(card);
                controller.moveCards(card, Zone.BATTLEFIELD, source, game);
            }
        }
    }
    controller.putCardsOnBottomOfLibrary(cards, game, source, true);
    return true;
}

Output:
         for (String subtype : creature.getSubtype(game)) {
-            subtypes.add(new SubtypePredicate(subtype));
+            subtypes.add(new SubtypePredicate(SubType.byDescription(subtype)));
             sb.append(subtype).append("String_Node_Str");


Input:
public Object run() throws StepExecutionException {
    for (int k = getStartingColIndex(searchType); k < m_table.getColumnCount(); ++k) {
        String header = m_table.getColumnName(k);
        if (MatchUtil.getInstance().match(header, value, operator)) {
            return new Boolean(true);
        }
    }
    return new Boolean(false);
}

Output:
         if (MatchUtil.getInstance().match(header, value, operator)) {
-            return new Boolean(true);
+            return Boolean.TRUE;
         }


Input:
public void mergeClips(Collection<SpriteClip> mergeClips) {
    if (mergeClips == null) {
        return;
    }
    if (mergeClips.size() == 1) {
        SpriteClip selectedClip = mergeClips.iterator().next();
        Collection<SpriteClip> overlappingSprites = new HashSet();
        overlappingSprites.add(selectedClip);
        for (SpriteClip currentClip : clips) {
            if (selectedClip != currentClip && currentClip.getBoundingBox().intersects(selectedClip.getBoundingBox())) {
                overlappingSprites.add(currentClip);
            }
        }
        if (overlappingSprites.size() >= 2) {
            clips.removeAll(overlappingSprites);
            SpriteClip newMergedClip = SpriteClip.makeMergedClip(overlappingSprites);
            clips.add(newMergedClip);
        }
    } else {
        clips.removeAll(mergeClips);
        SpriteClip newMergedClip = SpriteClip.makeMergedClip(mergeClips);
        clips.add(newMergedClip);
    }
}

Output:
 public void mergeClips(Collection<SpriteClip> mergeClips) {
-    if (mergeClips == null) {
+    if (mergeClips == null || mergeClips.size() == 0) {
         return;


Input:
private void ball(SnipeData v, Location<World> targetBlock) {
    double brushSize = v.getBrushSize();
    double brushSizeSquared = brushSize * brushSize;
    int tx = targetBlock.getBlockX();
    int ty = targetBlock.getBlockY();
    int tz = targetBlock.getBlockZ();
    int minx = GenericMath.floor(targetBlock.getBlockX() - brushSize);
    int maxx = GenericMath.floor(targetBlock.getBlockX() + brushSize) + 1;
    int miny = Math.max(GenericMath.floor(targetBlock.getBlockY() - brushSize), 0);
    int maxy = Math.min(GenericMath.floor(targetBlock.getBlockY() + brushSize) + 1, WORLD_HEIGHT);
    int minz = GenericMath.floor(targetBlock.getBlockZ() - brushSize);
    int maxz = GenericMath.floor(targetBlock.getBlockZ() + brushSize) + 1;
    this.undo = new Undo(GenericMath.floor(4 * Math.PI * (brushSize + 1) * (brushSize + 1) * (brushSize + 1) / 3));
    for (int x = minx; x <= maxx; x++) {
        double xs = (tx - x) * (tx - x);
        for (int y = miny; y <= maxy; y++) {
            double ys = (ty - y) * (ty - y);
            for (int z = minz; z <= maxz; z++) {
                double zs = (tz - z) * (tz - z);
                if (xs + ys + zs < brushSizeSquared) {
                    perform(v, x, y, z);
                }
            }
        }
    }
    v.owner().storeUndo(this.undo);
    this.undo = null;
}

Output:
     this.undo = new Undo(GenericMath.floor(4 * Math.PI * (brushSize + 1) * (brushSize + 1) * (brushSize + 1) / 3));
-    for (int x = minx; x <= maxx; x++) {
+    for (int x = maxx; x >= minx; x--) {
         double xs = (tx - x) * (tx - x);


Input:
protected void parseRecord() {
    if (ch <= ' ' && ignoreLeadingWhitespace) {
        skipWhitespace();
    }
    while (ch != newLine && ch != '\0') {
        parseField();
        if (ch != newLine) {
            ch = input.nextChar();
            if (ch == newLine) {
                output.emptyParsed();
            }
        }
    }
}

Output:
     }
-    while (ch != newLine && ch != '\0') {
+    while (ch != newLine) {
         parseField();


Input:
public SaveResult[] update(String tablename, String idStr, OMElement[] updatefields, String[] fieldsToNull) throws Exception {
    SObject item = new SObject();
    item.setType(tablename);
    ID id = new ID();
    id.setID(idStr);
    item.setId(id);
    item.setExtraElement(updatefields);
    item.setFieldsToNull(fieldsToNull);
    updateItems.add(item);
    if (updateItems.size() >= commitLevel) {
        SObject[] upds = updateItems.toArray(new SObject[updateItems.size()]);
        Update update = new Update();
        update.setSObjects(upds);
        SaveResult[] saveResults = stub.update(update, sh, co, null, null, null, null, null, null, null, null, null).getResult();
        updateItems.clear();
        upds = null;
        if (exceptionForErrors && saveResults != null && saveResults.length != 0) {
            for (SaveResult result : saveResults) {
                StringBuilder errors = new StringBuilder("String_Node_Str");
                if (result.getSuccess()) {
                } else {
                    errors = addLog(result.getErrors());
                }
                if (exceptionForErrors && errors.toString().length() > 0) {
                    if (logWriter != null) {
                        logWriter.close();
                    }
                    throw new Exception(errors.toString());
                }
            }
        }
        return saveResults;
    }
    return null;
}

Output:
         upds = null;
-        if (exceptionForErrors && saveResults != null && saveResults.length != 0) {
+        if (saveResults != null && saveResults.length != 0) {
+            int batch_idx = -1;
             for (SaveResult result : saveResults) {


Input:
private void processBlock() {
    if (currentBlockOffset < BLOCK_SIZE) {
        currentBlock[currentBlockOffset] = 1;
        for (int i = currentBlockOffset + 1; i < BLOCK_SIZE; i++) {
            currentBlock[i] = 0;
        }
    }
    final long t0 = 0xffffffffL & Pack.littleEndianToInt(currentBlock, 0);
    final long t1 = 0xffffffffL & Pack.littleEndianToInt(currentBlock, 4);
    final long t2 = 0xffffffffL & Pack.littleEndianToInt(currentBlock, 8);
    final long t3 = 0xffffffffL & Pack.littleEndianToInt(currentBlock, 12);
    h0 += t0 & 0x3ffffff;
    h1 += (((t1 << 32) | t0) >>> 26) & 0x3ffffff;
    h2 += (((t2 << 32) | t1) >>> 20) & 0x3ffffff;
    h3 += (((t3 << 32) | t2) >>> 14) & 0x3ffffff;
    h4 += (t3 >>> 8);
    if (currentBlockOffset == BLOCK_SIZE) {
        h4 += (1 << 24);
    }
    long tp0 = mul32x32_64(h0, r0) + mul32x32_64(h1, s4) + mul32x32_64(h2, s3) + mul32x32_64(h3, s2) + mul32x32_64(h4, s1);
    long tp1 = mul32x32_64(h0, r1) + mul32x32_64(h1, r0) + mul32x32_64(h2, s4) + mul32x32_64(h3, s3) + mul32x32_64(h4, s2);
    long tp2 = mul32x32_64(h0, r2) + mul32x32_64(h1, r1) + mul32x32_64(h2, r0) + mul32x32_64(h3, s4) + mul32x32_64(h4, s3);
    long tp3 = mul32x32_64(h0, r3) + mul32x32_64(h1, r2) + mul32x32_64(h2, r1) + mul32x32_64(h3, r0) + mul32x32_64(h4, s4);
    long tp4 = mul32x32_64(h0, r4) + mul32x32_64(h1, r3) + mul32x32_64(h2, r2) + mul32x32_64(h3, r1) + mul32x32_64(h4, r0);
    long b;
    h0 = (int) tp0 & 0x3ffffff;
    b = (tp0 >>> 26);
    tp1 += b;
    h1 = (int) tp1 & 0x3ffffff;
    b = ((tp1 >>> 26) & 0xffffffff);
    tp2 += b;
    h2 = (int) tp2 & 0x3ffffff;
    b = ((tp2 >>> 26) & 0xffffffff);
    tp3 += b;
    h3 = (int) tp3 & 0x3ffffff;
    b = (tp3 >>> 26);
    tp4 += b;
    h4 = (int) tp4 & 0x3ffffff;
    b = (tp4 >>> 26);
    h0 += b * 5;
}

Output:
     h0 = (int) tp0 & 0x3ffffff;
-    b = (tp0 >>> 26);
-    tp1 += b;
+    tp1 += (tp0 >>> 26);
     h1 = (int) tp1 & 0x3ffffff;


Input:
public void worldMoved(GuiUrbanist gui, MovingObjectPosition pos) {
    if (step == 1) {
        x = pos.blockX;
        z = pos.blockZ;
        gui.urbanist.rpcMoveFrame(pos);
    } else if (step == 2) {
        float ydiff = (float) Mouse.getY() / (float) Minecraft.getMinecraft().displayHeight;
        y = (int) (startY + (ydiff - baseY) * 50);
        gui.urbanist.rpcMoveFrame(pos);
    }
}

Output:
     if (step == 1) {
-        x = pos.blockX;
-        z = pos.blockZ;
-        gui.urbanist.rpcMoveFrame(pos);
+        this.pos = new BlockPos(pos.getBlockPos().getX(), this.pos.getY(), pos.getBlockPos().getX());
+        gui.urbanist.rpcMoveFrame(this.pos);
     } else if (step == 2) {


Input:
public void updateObjectName() {
    try {
        StandardHost host = (StandardHost) getParent();
        oname = createObjectName(host.getDomain(), host.getJmxName());
        controller = oname;
        for (Container wrapper : findChildren()) {
            ((StandardWrapper) wrapper).registerJMX(this);
        }
    } catch (Exception ex) {
        if (log.isLoggable(Level.INFO)) {
            log.log(Level.INFO, "String_Node_Str" + this + "String_Node_Str" + oname + "String_Node_Str" + ex.toString(), ex);
        }
    }
}

Output:
         StandardHost host = (StandardHost) getParent();
-        oname = createObjectName(host.getDomain(), host.getJmxName());
-        controller = oname;
+        synchronized (this) {
+            oname = createObjectName(host.getDomain(), host.getJmxName());
+            controller = oname;
+        }
         for (Container wrapper : findChildren()) {


Input:
private ODataErrorCallback getErrorHandlerCallback() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
    ODataErrorCallback callback = null;
    final String factoryClassName = servletConfig.getInitParameter(ODataServiceFactory.FACTORY_LABEL);
    if (factoryClassName != null) {
        Class<?> factoryClass = Class.forName(factoryClassName);
        final ODataServiceFactory serviceFactory = (ODataServiceFactory) factoryClass.newInstance();
        callback = serviceFactory.getCallback(ODataErrorCallback.class);
    }
    return callback;
}

Output:
     if (factoryClassName != null) {
-        Class<?> factoryClass = Class.forName(factoryClassName);
+        ClassLoader cl = (ClassLoader) servletRequest.getAttribute(ODataServiceFactory.FACTORY_CLASSLOADER_LABEL);
+        Class<?> factoryClass;
+        if (cl == null) {
+            factoryClass = Class.forName(factoryClassName);
+        } else {
+            factoryClass = Class.forName(factoryClassName, true, cl);
+        }
         final ODataServiceFactory serviceFactory = (ODataServiceFactory) factoryClass.newInstance();


Input:
public void initControlConnection() throws Exception, RuntimeException {
    while (true) {
        try {
            logNotice("String_Node_Str" + TOR_CONTROL_PORT);
            String baseMessage = getString(R.string.tor_process_connecting);
            sendCallbackStatusMessage(baseMessage);
            torConnSocket = new Socket(IP_LOCALHOST, TOR_CONTROL_PORT);
            conn = TorControlConnection.getConnection(torConnSocket);
            sendCallbackStatusMessage(getString(R.string.tor_process_connecting_step2));
            logNotice("String_Node_Str");
            String torAuthCookie = appDataHome + TOR_CONTROL_COOKIE;
            File fileCookie = new File(torAuthCookie);
            if (fileCookie.exists()) {
                byte[] cookie = new byte[(int) fileCookie.length()];
                new FileInputStream(new File(torAuthCookie)).read(cookie);
                conn.authenticate(cookie);
                logNotice("String_Node_Str");
                sendCallbackStatusMessage(getString(R.string.tor_process_connecting_step2) + getString(R.string.tor_process_connecting_step3));
                addEventHandler();
            }
            break;
        } catch (Exception ce) {
            conn = null;
            Log.d(TAG, "String_Node_Str" + ce.getLocalizedMessage(), ce);
            sendCallbackStatusMessage(getString(R.string.tor_process_connecting_step4));
            Thread.sleep(1000);
        }
    }
}

Output:
             logNotice("String_Node_Str");
-            String torAuthCookie = appDataHome + TOR_CONTROL_COOKIE;
+            String torAuthCookie = new File(appDataHome, TOR_CONTROL_COOKIE).getAbsolutePath();
             File fileCookie = new File(torAuthCookie);


Input:
public IMetrics setConfig(BenchmarkConfig benchConfig) {
    config = benchConfig.getStormConfig();
    topoName = benchConfig.getTopologyName();
    pollInterval = BenchmarkUtils.getInt(config, METRICS_POLL_FREQ, DEFAULT_POLL_INTERVAL);
    totalTime = BenchmarkUtils.getInt(config, METRICS_TOTAL_TIME, DEFAULT_TOTAL_TIME);
    msgSize = BenchmarkUtils.getInt(config, BenchmarkConfig.MESSAGE_SIZE, DEFAULT_MESSAGE_SIZE);
    path = (String) Utils.get(config, METRICS_PATH, DEFAULT_PATH);
    return this;
}

Output:
 public IMetrics setConfig(BenchmarkConfig benchConfig) {
-    config = benchConfig.getStormConfig();
-    topoName = benchConfig.getTopologyName();
+    config = Utils.readStormConfig();
+    topoName = (String) Utils.get(config, Config.TOPOLOGY_NAME, BenchmarkConfig.DEFAULT_TOPOLOGY_NAME);
     pollInterval = BenchmarkUtils.getInt(config, METRICS_POLL_FREQ, DEFAULT_POLL_INTERVAL);


Input:
private CellStyle getPreCellStyle() {
    if (isAbsY && keepCellFormat) {
        if (preCell == null) {
            return null;
        } else {
            CellStyle preCellStyle = preCell.getCellStyle();
            CellStyle targetCellStyle = wb.createCellStyle();
            targetCellStyle.cloneStyleFrom(preCellStyle);
            return targetCellStyle;
        }
    } else {
        return null;
    }
}

Output:
         if (preCell == null) {
-            return null;
+            preCellStyle = preSheet.getColumnStyle(curCell.getColumnIndex());
         } else {


Input:
private static Image getIconForProvider(ProtocolProviderService providerService, Image customProviderImage, ImageObserver imageObserver) {
    Image left = null;
    if (isAutoAnswerEnabled(providerService))
        left = ImageLoader.getImage(ImageLoader.AUTO_ANSWER_CHECK);
    if (customProviderImage == null)
        customProviderImage = ImageUtils.getBytesInImage(providerService.getProtocolIcon().getIcon(ProtocolIcon.ICON_SIZE_16x16));
    return ImageUtils.getComposedImage(left, customProviderImage, imageObserver);
}

Output:
 private static Image getIconForProvider(ProtocolProviderService providerService, Image customProviderImage, ImageObserver imageObserver) {
-    Image left = null;
-    if (isAutoAnswerEnabled(providerService))
-        left = ImageLoader.getImage(ImageLoader.AUTO_ANSWER_CHECK);
-    if (customProviderImage == null)
-        customProviderImage = ImageUtils.getBytesInImage(providerService.getProtocolIcon().getIcon(ProtocolIcon.ICON_SIZE_16x16));
+    Image left = isAutoAnswerEnabled(providerService) ? ImageLoader.getImage(ImageLoader.AUTO_ANSWER_CHECK) : null;
+    if (customProviderImage == null) {
+        byte[] bytes = providerService.getProtocolIcon().getIcon(ProtocolIcon.ICON_SIZE_16x16);
+        if (bytes != null)
+            customProviderImage = ImageUtils.getBytesInImage(bytes);
+    }
     return ImageUtils.getComposedImage(left, customProviderImage, imageObserver);


Input:
public void run() {
    Vector<String> mirrorlist = new Vector<String>();
    for (int i = linkList.size() - 1; i >= 0 && isVisible() && linkList.size() > i; i--) {
        DownloadLink link = linkList.elementAt(i);
        if (!link.isAvailable()) {
            linkList.remove(i);
        } else if (mirrorlist.contains(linkList.elementAt(i).getName().toLowerCase().replaceFirst("String_Node_Str", "String_Node_Str"))) {
            linkList.remove(i);
        } else
            mirrorlist.add(linkList.elementAt(i).getName().toLowerCase().replaceFirst("String_Node_Str", "String_Node_Str"));
        fireTableChanged();
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
        }
    }
}

Output:
         DownloadLink link = linkList.elementAt(i);
-        if (!link.isAvailable()) {
+        if (!link.isAvailable() || mirrorlinks.contains(link)) {
             linkList.remove(i);


Input:
public void fireCallback(final ClientCallback call) {
    if (isConnected()) {
        SessionManager.getInstance().getSession(sessionId).fireCallback(call);
    }
}

Output:
     if (isConnected()) {
-        SessionManager.getInstance().getSession(sessionId).fireCallback(call);
+        Session session = SessionManager.getInstance().getSession(sessionId);
+        if (session != null) {
+            session.fireCallback(call);
+        }
     }


Input:
private String getAssetCacheFileName(AssetID assetID) {
    String basePath = cacheDir.getAbsolutePath();
    String relativePath = assetID.getResourceURI().getRelativeCachePath();
    String checksum = assetID.getChecksum();
    return basePath + File.separator + relativePath + "String_Node_Str" + checksum;
}

Output:
     String checksum = assetID.getChecksum();
-    return basePath + File.separator + relativePath + "String_Node_Str" + checksum;
+    return basePath + File.separator + relativePath + File.separator + checksum;
 }


Input:
public Map<Vertex3d, Vector3d> getContactImpulses(CollidableBody colA, CollidableBody colB) {
    if (!colA.isDeformable()) {
        return null;
    }
    updateHandlers();
    CollisionHandler handler = null;
    for (CollisionHandler h : myCollisionHandlers) {
        if ((h.myCollidable0 == colA && h.myCollidable1 == colB) || (h.myCollidable0 == colB && h.myCollidable1 == colA)) {
            handler = h;
        }
    }
    if (handler == null) {
        return null;
    } else {
        return handler.getContactImpulses();
    }
}

Output:
     } else {
-        return handler.getContactImpulses();
+        return handler.getContactImpulses(colA);
     }


Input:
private static void performConsistencyCheck() throws Exception {
    LSN last = DBS.replication_pause();
    if (last != null) {
        LookupGroup lookupGroup = generator.getLookupGroup(last);
        for (int i = 0; i < lookupGroup.size(); i++) {
            byte[] value = DBS.hiddenLookup(lookupGroup.dbName, lookupGroup.getIndex(i), lookupGroup.getKey(i));
            if (!new String(value).equals(new String(lookupGroup.getValue(i)))) {
                System.err.println("String_Node_Str" + last.toString() + "String_Node_Str" + "String_Node_Str" + new String(value) + "String_Node_Str" + new String(lookupGroup.getValue(i)));
                System.exit(1);
            }
        }
        System.out.println("String_Node_Str" + last.toString() + "String_Node_Str");
    }
    DBS.replication_resume();
}

Output:
         System.out.println("String_Node_Str" + last.toString() + "String_Node_Str");
-    }
+    } else
+        System.err.println("String_Node_Str");
     DBS.replication_resume();


Input:
public boolean putCardsOnTopOfLibrary(Cards cardsToLibrary, Game game, Ability source, boolean anyOrder) {
    if (cardsToLibrary != null && !cardsToLibrary.isEmpty()) {
        Cards cards = new CardsImpl(cardsToLibrary);
        UUID sourceId = (source == null ? null : source.getSourceId());
        if (!anyOrder) {
            for (UUID cardId : cards) {
                moveObjectToLibrary(cardId, sourceId, game, true, false);
            }
        } else {
            TargetCard target = new TargetCard(Zone.LIBRARY, new FilterCard("String_Node_Str"));
            target.setRequired(true);
            while (cards.size() > 1) {
                this.choose(Outcome.Neutral, cards, target, game);
                if (!canRespond()) {
                    return false;
                }
                UUID targetObjectId = target.getFirstTarget();
                cards.remove(targetObjectId);
                moveObjectToLibrary(targetObjectId, sourceId, game, true, false);
                target.clearChosen();
            }
            if (cards.size() == 1) {
                moveObjectToLibrary(cards.iterator().next(), sourceId, game, true, false);
            }
        }
    }
    return true;
}

Output:
         if (!anyOrder) {
-            for (UUID cardId : cards) {
-                moveObjectToLibrary(cardId, sourceId, game, true, false);
+            while (!cards.isEmpty()) {
+                UUID cardId = cards.getRandom(game).getId();
+                cards.remove(cardId);
+                moveObjectToLibrary(cardId, source == null ? null : source.getSourceId(), game, true, false);
             }


Input:
public float calculateCorrectDiskRotation(PoincareNode currentNode) {
    if (currentNode != null) {
        if (currentNode.iComparableValue != 1) {
            float[] currentPosition = new float[2];
            currentPosition = currentNode.getPosition().clone();
            float[] parentPosition;
            parentPosition = currentNode.getParent().getPosition().clone();
            float[] relativePosition = new float[2];
            relativePosition[0] = -currentPosition[0];
            relativePosition[1] = -currentPosition[1];
            currentPosition[0] = 0;
            currentPosition[1] = 0;
            ComplexNumber moebiusTransformation = new ComplexNumber();
            ComplexNumber complexParentPosition = new ComplexNumber();
            moebiusTransformation.setValue((double) relativePosition[0], (double) relativePosition[1]);
            complexParentPosition.setValue((double) parentPosition[0], (double) parentPosition[1]);
            complexParentPosition = this.moebiusTransformation(complexParentPosition, moebiusTransformation);
            relativePosition[0] = (float) complexParentPosition.getRealPart();
            relativePosition[1] = (float) complexParentPosition.getImaginaryPart();
            float[] eV = getEV(relativePosition);
            float angle = (float) Math.atan2(eV[1], eV[0]);
            if (Math.abs(-angle + Math.PI) < Math.PI) {
                return -angle + (float) Math.PI;
            } else {
                return -angle - (float) Math.PI;
            }
        } else {
            float[] currentPosition = new float[2];
            currentPosition = currentNode.getPosition().clone();
            float[] childPosition;
            if (currentNode.getNrLeaves() != 0) {
                childPosition = currentNode.getChildren().get(0).getPosition();
                float[] relativePosition = new float[2];
                relativePosition[0] = -currentPosition[0];
                relativePosition[1] = -currentPosition[1];
                currentPosition[0] = 0;
                currentPosition[1] = 0;
                ComplexNumber moebiusTransformation = new ComplexNumber();
                ComplexNumber complexParentPosition = new ComplexNumber();
                moebiusTransformation.setValue((double) relativePosition[0], (double) relativePosition[1]);
                complexParentPosition.setValue((double) childPosition[0], (double) childPosition[1]);
                complexParentPosition = this.moebiusTransformation(complexParentPosition, moebiusTransformation);
                relativePosition[0] = (float) complexParentPosition.getRealPart();
                relativePosition[1] = (float) complexParentPosition.getImaginaryPart();
                float[] eV = getEV(relativePosition);
                float angle = (float) Math.atan2(eV[1], eV[0]);
                float angleOffset = ((float) Math.PI / (float) currentNode.getChildren().size()) / 2;
                angle = angle + angleOffset + (float) Math.PI / 2;
                if (Math.abs(-angle + Math.PI) < Math.PI) {
                    return -angle + (float) Math.PI;
                } else {
                    return -angle - (float) Math.PI;
                }
            }
        }
    } else {
    }
    return 0;
}

Output:
             float[] childPosition;
-            if (currentNode.getNrLeaves() != 0) {
-                childPosition = currentNode.getChildren().get(0).getPosition();
-                float[] relativePosition = new float[2];
-                relativePosition[0] = -currentPosition[0];
-                relativePosition[1] = -currentPosition[1];
-                currentPosition[0] = 0;
-                currentPosition[1] = 0;
-                ComplexNumber moebiusTransformation = new ComplexNumber();
-                ComplexNumber complexParentPosition = new ComplexNumber();
-                moebiusTransformation.setValue((double) relativePosition[0], (double) relativePosition[1]);
-                complexParentPosition.setValue((double) childPosition[0], (double) childPosition[1]);
-                complexParentPosition = this.moebiusTransformation(complexParentPosition, moebiusTransformation);
-                relativePosition[0] = (float) complexParentPosition.getRealPart();
-                relativePosition[1] = (float) complexParentPosition.getImaginaryPart();
-                float[] eV = getEV(relativePosition);
-                float angle = (float) Math.atan2(eV[1], eV[0]);
-                float angleOffset = ((float) Math.PI / (float) currentNode.getChildren().size()) / 2;
-                angle = angle + angleOffset + (float) Math.PI / 2;
-                if (Math.abs(-angle + Math.PI) < Math.PI) {
-                    return -angle + (float) Math.PI;
-                } else {
-                    return -angle - (float) Math.PI;
+            if (this.calculateRootNodeAngleSwitch == true) {
+                if (currentNode.getChildren() != null) {
+                    childPosition = currentNode.getChildren().get(0).getPosition();
+                    float[] relativePosition = new float[2];
+                    relativePosition[0] = -currentPosition[0];
+                    relativePosition[1] = -currentPosition[1];
+                    currentPosition[0] = 0;
+                    currentPosition[1] = 0;
+                    ComplexNumber moebiusTransformation = new ComplexNumber();
+                    ComplexNumber complexParentPosition = new ComplexNumber();
+                    moebiusTransformation.setValue((double) relativePosition[0], (double) relativePosition[1]);
+                    complexParentPosition.setValue((double) childPosition[0], (double) childPosition[1]);
+                    complexParentPosition = this.moebiusTransformation(complexParentPosition, moebiusTransformation);
+                    relativePosition[0] = (float) complexParentPosition.getRealPart();
+                    relativePosition[1] = (float) complexParentPosition.getImaginaryPart();
+                    float[] eV = getEV(relativePosition);
+                    float angle = (float) Math.atan2(eV[1], eV[0]);
+                    float angleOffset = ((float) Math.PI / (float) currentNode.getChildren().size()) / 2;
+                    angle = angle + angleOffset + (float) Math.PI / 2;
+                    if (Math.abs(-angle + Math.PI) < Math.PI) {
+                        return -angle + (float) Math.PI;
+                    } else {
+                        return -angle - (float) Math.PI;
+                    }
                 }


Input:
public void writeDataFormat(StyleEntry style) {
    if (style.getProperty(StyleConstant.DATA_TYPE_PROP) == Data.DATE && style.getProperty(StyleConstant.DATE_FORMAT_PROP) != null) {
        writer.openTag("String_Node_Str");
        writer.attribute("String_Node_Str", style.getProperty(StyleConstant.DATE_FORMAT_PROP));
        writer.closeTag("String_Node_Str");
    }
    if (style.getProperty(StyleConstant.DATA_TYPE_PROP) == Data.NUMBER && style.getProperty(StyleConstant.NUMBER_FORMAT_PROP) != null) {
        writer.openTag("String_Node_Str");
        String numberStyle = style.getProperty(StyleConstant.NUMBER_FORMAT_PROP);
        numberStyle = format(numberStyle);
        writer.attribute("String_Node_Str", numberStyle);
        writer.closeTag("String_Node_Str");
    }
}

Output:
         String numberStyle = style.getProperty(StyleConstant.NUMBER_FORMAT_PROP);
-        numberStyle = format(numberStyle);
+        numberStyle = ExcelUtil.formatNumberPattern(numberStyle);
         writer.attribute("String_Node_Str", numberStyle);


Input:
public void testIObject11() throws Exception {
    testTypesWithExtraExterns(EXTERNS_WITH_IOBJECT_DECLS, lineJoiner.join("String_Node_Str", "String_Node_Str", "String_Node_Str"), lineJoiner.join("String_Node_Str", "String_Node_Str", "String_Node_Str"));
}

Output:
 public void testIObject11() throws Exception {
-    testTypesWithExtraExterns(EXTERNS_WITH_IOBJECT_DECLS, lineJoiner.join("String_Node_Str", "String_Node_Str", "String_Node_Str"), lineJoiner.join("String_Node_Str", "String_Node_Str", "String_Node_Str"));
+    testTypesWithExtraExterns(EXTERNS_WITH_IOBJECT_DECLS, LINE_JOINER.join("String_Node_Str", "String_Node_Str", "String_Node_Str"), LINE_JOINER.join("String_Node_Str", "String_Node_Str", "String_Node_Str"));
 }


Input:
<T> BindingImpl<T> createUninitializedBinding(Key<T> key, Scoping scoping, Object source, Errors errors, boolean jitBinding) throws ErrorsException {
    Class<?> rawType = key.getTypeLiteral().getRawType();
    if (rawType.isArray() || rawType.isEnum()) {
        throw errors.missingImplementation(key).toException();
    }
    if (rawType == TypeLiteral.class) {
        BindingImpl<T> binding = (BindingImpl<T>) createTypeLiteralBinding((Key<TypeLiteral<Object>>) key, errors);
        return binding;
    }
    ImplementedBy implementedBy = rawType.getAnnotation(ImplementedBy.class);
    if (implementedBy != null) {
        Annotations.checkForMisplacedScopeAnnotations(rawType, source, errors);
        return createImplementedByBinding(key, scoping, implementedBy, errors);
    }
    ProvidedBy providedBy = rawType.getAnnotation(ProvidedBy.class);
    if (providedBy != null) {
        Annotations.checkForMisplacedScopeAnnotations(rawType, source, errors);
        return createProvidedByBinding(key, scoping, providedBy, errors);
    }
    return ConstructorBindingImpl.create(this, key, null, source, scoping, errors, jitBinding && options.jitDisabled, options.atInjectRequired);
}

Output:
     Class<?> rawType = key.getTypeLiteral().getRawType();
-    if (rawType.isArray() || rawType.isEnum()) {
+    ImplementedBy implementedBy = rawType.getAnnotation(ImplementedBy.class);
+    if (rawType.isArray() || (rawType.isEnum() && implementedBy != null)) {
         throw errors.missingImplementation(key).toException();


Input:
protected void populateSchemaList() {
    if (rootNode != null) {
        removeTreeItem(rootNode);
    }
    if (JdbcPlugin.getDefault().getPluginPreferences().getString(DateSetPreferencePage.SCHEMAS_PREFETCH_CONFIG).equals(ENABLED)) {
        getAvailableSchema();
    } else {
        getSpecificSchema(schemaCombo.getText().trim());
    }
    if (schemaCombo.getItemCount() < 1) {
        schemaCombo.add(JdbcPlugin.getResourceString("String_Node_Str"));
        schemaCombo.select(0);
        if (schemaList != null) {
            Iterator it = schemaList.iterator();
            while (it.hasNext()) schemaCombo.add(it.next().toString());
        }
    }
    ArrayList schemaObjectList = new ArrayList();
    if (schemaList != null) {
        int numberOfSchema = 0;
        Preferences preferences = JdbcPlugin.getDefault().getPluginPreferences();
        if (preferences.contains(DateSetPreferencePage.USER_MAX_NUM_OF_SCHEMA)) {
            numberOfSchema = preferences.getInt(DateSetPreferencePage.USER_MAX_NUM_OF_SCHEMA);
        } else {
            numberOfSchema = DateSetPreferencePage.DEFAULT_MAX_NUM_OF_SCHEMA;
            preferences.setValue(DateSetPreferencePage.USER_MAX_NUM_OF_SCHEMA, numberOfSchema);
        }
        cachedSchemaComboIndex = schemaCombo.getSelectionIndex();
        if (schemaCombo.getSelectionIndex() < 0) {
            String schemaName = schemaCombo.getText().trim();
            if (schemaName.length() != 0) {
                DbObject schemaObj = new DbObject(schemaName, schemaName, DbObject.SCHEMA_TYPE, schemaImage);
                schemaObjectList.add(schemaObj);
            } else
                schemaCombo.select(0);
        }
        if (schemaCombo.getSelectionIndex() == 0) {
            for (int i = 0, count = 0; i < schemaList.size() && count < numberOfSchema; i++) {
                String schemaName = (String) schemaList.get(i);
                if (containsTableInSchema(schemaName)) {
                    DbObject schemaObj = new DbObject(schemaName, schemaName, DbObject.SCHEMA_TYPE, schemaImage);
                    schemaObjectList.add(schemaObj);
                    count++;
                }
            }
        } else if (schemaCombo.getSelectionIndex() > 0) {
            String schemaName = schemaCombo.getItem(schemaCombo.getSelectionIndex());
            DbObject schemaObj = new DbObject(schemaName, schemaName, DbObject.SCHEMA_TYPE, schemaImage);
            schemaObjectList.add(schemaObj);
        }
    }
    TreeItem[] items = Utility.createTreeItems(rootNode, schemaObjectList, SWT.NONE, schemaImage);
    if (items != null && items.length > 0) {
        availableDbObjectsTree.showItem(items[0]);
    }
}

Output:
                 String schemaName = (String) schemaList.get(i);
-                if (containsTableInSchema(schemaName)) {
+                if (showSystemTableCheckBox.isEnabled() && showSystemTableCheckBox.getSelection()) {
+                    if (containsTableInSchema(schemaName, true)) {
+                        DbObject schemaObj = new DbObject(schemaName, schemaName, DbObject.SCHEMA_TYPE, schemaImage);
+                        schemaObjectList.add(schemaObj);
+                        count++;
+                    }
+                } else if (containsTableInSchema(schemaName, false)) {
                     DbObject schemaObj = new DbObject(schemaName, schemaName, DbObject.SCHEMA_TYPE, schemaImage);


Input:
private void onReceive_HandleReset(Packet packet) {
    Session current = getOutboundByNode(packet.getFrom());
    if (current != null && current.getConnectionId() == packet.getConnectionId()) {
        info("String_Node_Str" + packet.stringizeHeader());
        current.setClosed();
        m_activeOutSessions.remove(packet.getFrom());
        onConnectionAborted(packet.getFrom());
    } else {
        current = getInboundByNode(packet.getFrom());
        if (current != null && current.getConnectionId() == packet.getConnectionId()) {
            info("String_Node_Str" + packet.stringizeHeader());
            current.setClosed();
            m_activeInSessions.remove(packet.getFrom());
            onConnectionAborted(packet.getFrom());
        } else {
            info("String_Node_Str" + packet.stringizeHeader());
        }
    }
}

Output:
     } else {
-        current = getInboundByNode(packet.getFrom());
-        if (current != null && current.getConnectionId() == packet.getConnectionId()) {
-            info("String_Node_Str" + packet.stringizeHeader());
-            current.setClosed();
-            m_activeInSessions.remove(packet.getFrom());
-            onConnectionAborted(packet.getFrom());
-        } else {
-            info("String_Node_Str" + packet.stringizeHeader());
-        }
+        info("String_Node_Str" + packet.stringizeHeader());
     }


Input:
protected void placeItems(Bag container) {
    Belongings stuff = Dungeon.hero.belongings;
    placeItem(stuff.weapon != null ? stuff.weapon : new Placeholder(ItemSpriteSheet.WEAPON_HOLDER));
    placeItem(stuff.armor != null ? stuff.armor : new Placeholder(ItemSpriteSheet.ARMOR_HOLDER));
    placeItem(stuff.misc1 != null ? stuff.misc1 : new Placeholder(ItemSpriteSheet.RING_HOLDER));
    placeItem(stuff.misc2 != null ? stuff.misc2 : new Placeholder(ItemSpriteSheet.RING_HOLDER));
    boolean backpack = (container == Dungeon.hero.belongings.backpack);
    if (!backpack) {
        count = nCols;
        col = 0;
        row = 1;
    }
    for (Item item : container.items) {
        placeItem(item);
    }
    while (count - (backpack ? 4 : nCols) < container.size) {
        placeItem(null);
    }
}

Output:
     }
-    for (Item item : container.items) {
+    for (Item item : container.items.toArray(new Item[0])) {
         placeItem(item);


Input:
public static Set<VCFHeaderLine> withUpdatedContigsAsLines(final Set<VCFHeaderLine> oldLines, final File referenceFile, final SAMSequenceDictionary refDict, boolean referenceNameOnly) {
    final Set<VCFHeaderLine> lines = new LinkedHashSet<VCFHeaderLine>(oldLines.size());
    for (final VCFHeaderLine line : oldLines) {
        if (line instanceof VCFContigHeaderLine)
            continue;
        if (line.getKey().equals(VCFHeader.REFERENCE_KEY))
            continue;
        lines.add(line);
    }
    for (final VCFHeaderLine contigLine : makeContigHeaderLines(refDict, referenceFile)) lines.add(contigLine);
    String referenceValue;
    if (referenceFile != null) {
        if (referenceNameOnly) {
            int extensionStart = referenceFile.getName().lastIndexOf("String_Node_Str");
            referenceValue = extensionStart == -1 ? referenceFile.getName() : referenceFile.getName().substring(0, extensionStart);
        } else {
            referenceValue = "String_Node_Str" + referenceFile.getAbsolutePath();
        }
        lines.add(new VCFHeaderLine(VCFHeader.REFERENCE_KEY, referenceValue));
    }
    return lines;
}

Output:
     for (final VCFHeaderLine contigLine : makeContigHeaderLines(refDict, referenceFile)) lines.add(contigLine);
-    String referenceValue;
+    final String referenceValue;
     if (referenceFile != null) {


Input:
public void refresh() {
    List<Entry> entries = dataComp.retrieveAllEntries();
    if (!entries.isEmpty() && emptyLabel != null) {
        emptyLabel.dispose();
        emptyLabel = null;
    }
    for (int i = 0; i < entries.size(); i++) {
        Entry entry = dataComp.retrieveAllEntries().get(i);
        EntryComposite entryComp = entryMap.get(i);
        if (entryComp != null && !entry.getValue().equals(entryComp.entry.getValue())) {
            entryComp.entry.setValue(entry.getValue());
        }
    }
    int maxIterations = entries.size() > entryMap.size() ? entries.size() : entryMap.size();
    for (int i = 0; i < maxIterations; i++) {
        Entry entry = (i < entries.size() ? entries.get(i) : null);
        EntryComposite entryComp = (i < entryMap.size() ? entryMap.get(i) : null);
        String value = (entryComp != null ? entryComp.entry.getValue() : (entry != null ? entry.getValue() : "String_Node_Str"));
        if (entry == null || !entry.isReady()) {
            disposeEntry(i);
            continue;
        } else if (entryComp == null && entry.isReady()) {
            renderEntry(entry, i);
            entryComp = entryMap.get(i);
            entryComp.setEntryValue(value);
            entryComp.refresh();
        } else {
            for (int j = 0; j < entry.getAllowedValues().size(); j++) {
                String allowedValue = entry.getAllowedValues().get(j);
                if (!entryComp.entry.getAllowedValues().contains(allowedValue)) {
                    disposeEntry(i);
                    renderEntry(entry, i);
                    entryComp = entryMap.get(i);
                    entryComp.setEntryValue(value);
                    entryComp.refresh();
                }
            }
        }
    }
    layout();
    return;
}

Output:
         if (entryComp != null && !entry.getValue().equals(entryComp.entry.getValue())) {
-            entryComp.entry.setValue(entry.getValue());
+            entryComp.entry = entry;
+            entryComp.refresh();
         }


Input:
private List<Map<String, String>> getMatchRulesFromRules(MatchRuleDefinition matchRuleDefinition, boolean retrieveDisplayValue) {
    if (matchRuleDefinition != null) {
        List<Map<String, String>> ruleValues = new ArrayList<Map<String, String>>();
        for (MatchRule matchRule : matchRuleDefinition.getMatchRules()) {
            for (MatchKeyDefinition matchKey : matchRule.getMatchKeys()) {
                Map<String, String> pr = new HashMap<String, String>();
                pr.put(MatchRulesTableLabelProvider.MATCH_KEY_NAME, null == matchKey.getName() ? StringUtils.EMPTY : matchKey.getName());
                pr.put(MatchRulesTableLabelProvider.INPUT_COLUMN, null == matchKey.getColumn() ? StringUtils.EMPTY : matchKey.getColumn());
                if (getLookupColumnNames().size() > 0) {
                    for (String lookupColumnName : getLookupColumnNames()) {
                        if (lookupColumnName.equalsIgnoreCase(matchKey.getColumn()) || lookupColumnName.equalsIgnoreCase(matchKey.getName())) {
                            pr.put("String_Node_Str", null == matchKey.getColumn() ? StringUtils.EMPTY : lookupColumnName);
                            break;
                        }
                    }
                }
                String algorithmType = matchKey.getAlgorithm().getAlgorithmType();
                if (retrieveDisplayValue) {
                    pr.put(MatchRulesTableLabelProvider.MATCHING_TYPE, null == algorithmType ? StringUtils.EMPTY : AttributeMatcherType.valueOf(algorithmType).getLabel());
                } else {
                    pr.put(MatchRulesTableLabelProvider.MATCHING_TYPE, null == algorithmType ? StringUtils.EMPTY : AttributeMatcherType.valueOf(algorithmType).getComponentValue());
                }
                pr.put(MatchRulesTableLabelProvider.CUSTOM_MATCHER, null == matchKey.getAlgorithm().getAlgorithmParameters() ? StringUtils.EMPTY : matchKey.getAlgorithm().getAlgorithmParameters());
                pr.put(MatchRulesTableLabelProvider.CONFIDENCE_WEIGHT, String.valueOf(matchKey.getConfidenceWeight()));
                if (retrieveDisplayValue) {
                    pr.put(MatchRulesTableLabelProvider.HANDLE_NULL, null == matchKey.getHandleNull() ? StringUtils.EMPTY : HandleNullEnum.getTypeByValue(matchKey.getHandleNull()).getLabel());
                } else {
                    pr.put(MatchRulesTableLabelProvider.HANDLE_NULL, null == matchKey.getHandleNull() ? StringUtils.EMPTY : matchKey.getHandleNull());
                }
                ruleValues.add(pr);
            }
        }
        return ruleValues;
    }
    return null;
}

Output:
                 pr.put(MatchRulesTableLabelProvider.MATCH_KEY_NAME, null == matchKey.getName() ? StringUtils.EMPTY : matchKey.getName());
-                pr.put(MatchRulesTableLabelProvider.INPUT_COLUMN, null == matchKey.getColumn() ? StringUtils.EMPTY : matchKey.getColumn());
+                String matchedColumnName = matchExistingColumnForMatchRule(matchKey);
+                pr.put(MatchRulesTableLabelProvider.INPUT_COLUMN, null == matchedColumnName ? StringUtils.EMPTY : matchedColumnName);
                 if (getLookupColumnNames().size() > 0) {


Input:
public void of(TableReader reader) {
    this.reader = reader;
    this.timestampIndex = reader.getMetadata().getTimestampIndex();
    if (this.timestampIndex == -1) {
        throw CairoException.instance(0).put("String_Node_Str");
    }
    calculateRanges();
}

Output:
     if (this.timestampIndex == -1) {
-        throw CairoException.instance(0).put("String_Node_Str");
+        throw CairoException.instance(0).put("String_Node_Str").put(reader.getTableName()).put("String_Node_Str");
     }


Input:
private Action getActionForKeyboard(int keyCode) {
    switch(keyCode) {
        case KeyEvent.VK_F12:
            return new Action(EActionType.FAST_FORWARD);
        case KeyEvent.VK_PAUSE:
        case KeyEvent.VK_P:
            return new Action(EActionType.SPEED_TOGGLE_PAUSE);
        case KeyEvent.VK_PLUS:
            return new Action(EActionType.SPEED_FASTER);
        case KeyEvent.VK_MINUS:
            return new Action(EActionType.SPEED_SLOWER);
        case KeyEvent.VK_SPACE:
            return new Action(EActionType.SHOW_SELECTION);
        case KeyEvent.VK_D:
            return new Action(EActionType.DEBUG_ACTION);
        case KeyEvent.VK_S:
            return new Action(EActionType.STOP_WORKING);
        case KeyEvent.VK_Q:
            ENABLE_DEBUG = !ENABLE_DEBUG;
            break;
    }
    return null;
}

Output:
         case KeyEvent.VK_Q:
-            ENABLE_DEBUG = !ENABLE_DEBUG;
-            break;
+            return new Action(EActionType.TOGGLE_DEBUG);
     }


Input:
private JsonNode wsSendChat(JsonNode wsMessage, ActorRef senderActor, Account sender) {
    if (!wsMessage.has("String_Node_Str") || !wsMessage.has("String_Node_Str")) {
        return this.errorResponse("String_Node_Str");
    }
    Long recipientAccountId = wsMessage.get("String_Node_Str").asLong();
    String text = wsMessage.get("String_Node_Str").asText();
    ActorRef recipientActor = this.getActorForAccountId(recipientAccountId);
    Account recipient = Account.findById(recipientAccountId);
    if (recipientActor == null) {
        return this.errorResponse("String_Node_Str");
    }
    if (recipientActor.equals(senderActor)) {
        return this.errorResponse("String_Node_Str");
    }
    if (sender == null || recipient == null || !(Friendship.alreadyFriendly(sender, recipient))) {
        return this.errorResponse("String_Node_Str");
    }
    ObjectNode node = this.successResponseTemplate(WebSocketService.WS_METHOD_RECEIVE_CHAT);
    node.put("String_Node_Str", Json.toJson(sender.getAsJson()));
    node.put("String_Node_Str", text);
    recipientActor.tell(Json.toJson(node), senderActor);
    return Json.toJson("String_Node_Str");
}

Output:
     ActorRef recipientActor = this.getActorForAccountId(recipientAccountId);
-    Account recipient = Account.findById(recipientAccountId);
+    Account recipient = Account.findByIdTransactional(recipientAccountId);
     if (recipientActor == null) {


Input:
public static void crunch(HprofSource source, OutputStream out, Config config) throws IOException, TimeoutException {
    if (config == null) {
        config = new Config();
    }
    Stats.setEnabled(config.collectStats);
    Stats.increment(Stats.Type.TOTAL, Stats.Variant.HPROF, source.getDataSize());
    final long start = System.currentTimeMillis();
    final long limit = config.timeLimit != Config.NO_TIME_LIMIT ? start + config.timeLimit : Long.MAX_VALUE;
    CountingOutputStream cOut = new CountingOutputStream(out);
    if (config.collectStats) {
        out = cOut;
    }
    CrunchProcessor processor = new CrunchProcessor(out, true);
    InputStream in = new BufferedInputStream(source.open());
    HprofReader reader = new HprofReader(in, processor);
    while (reader.hasNext()) {
        reader.next();
        checkTimeLimit(limit);
        iterationSleep(config);
    }
    processor.startSecondPass();
    in.close();
    in = new BufferedInputStream(source.open());
    reader = new HprofReader(in, processor);
    while (reader.hasNext()) {
        reader.next();
        checkTimeLimit(limit);
        iterationSleep(config);
    }
    processor.finishAndWriteOutput();
    Stats.increment(Stats.Type.TOTAL, Stats.Variant.BMD, cOut.getCount());
    Stats.printStats();
}

Output:
     InputStream in = new BufferedInputStream(source.open());
-    HprofReader reader = new HprofReader(in, processor);
-    while (reader.hasNext()) {
-        reader.next();
-        checkTimeLimit(limit);
-        iterationSleep(config);
+    try {
+        HprofReader reader = new HprofReader(in, processor);
+        while (reader.hasNext()) {
+            reader.next();
+            checkTimeLimit(limit);
+            iterationSleep(config);
+        }
+        processor.startSecondPass();
+    } finally {
+        in.close();
     }


Input:
private void migrationTaskFailed() {
    systemLogService.logPartition("String_Node_Str" + migrationRequestOp);
    finalizeMigration(false);
    sendMigrationEvent(migrationInfo, MigrationStatus.FAILED);
}

Output:
 private void migrationTaskFailed() {
-    systemLogService.logPartition("String_Node_Str" + migrationRequestOp);
+    systemLogService.logPartition("String_Node_Str" + migrationInfo);
     finalizeMigration(false);


Input:
private void buildHUD() {
    String[] iconNames = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    UIColor[] colors = new UIColor[] { UIColor.green(), UIColor.blue(), UIColor.yellow(), UIColor.red() };
    double hudX = 30;
    double hudY = getFrame().getSize().getHeight() - 30;
    double hudD = getFrame().getSize().getWidth() / NUM_PLAYERS;
    SKNode hud = new SKNode();
    for (int i = 0; i < NUM_PLAYERS; i++) {
        SKSpriteNode avatar = SKSpriteNode.create(iconNames[i]);
        avatar.setScale(0.5);
        avatar.setAlpha(0.5);
        avatar.setPosition(new CGPoint(hudX + i * hudD + (avatar.getSize().getWidth() * 0.5), getFrame().getSize().getHeight() - avatar.getSize().getHeight() * 0.5 - 8));
        hudAvatars.add(avatar);
        hud.addChild(avatar);
        SKLabelNode label = SKLabelNode.createWithFont("String_Node_Str");
        label.setText("String_Node_Str");
        label.setFontColor(colors[i]);
        label.setFontSize(16);
        label.setHorizontalAlignmentMode(SKLabelHorizontalAlignmentMode.Left);
        label.setPosition(new CGPoint(hudX + i * hudD + (avatar.getSize().getWidth() * 1.0), hudY + 10));
        hudLabels.add(label);
        hud.addChild(label);
        SKLabelNode score = SKLabelNode.createWithFont("String_Node_Str");
        score.setText("String_Node_Str");
        score.setFontColor(colors[i]);
        score.setFontSize(16);
        score.setHorizontalAlignmentMode(SKLabelHorizontalAlignmentMode.Left);
        score.setPosition(new CGPoint(hudX + i * hudD + (avatar.getSize().getWidth() * 1.0), hudY - 40));
        hudScores.add(score);
        hud.addChild(score);
        hudLifeHeartArrays.add(new NSMutableArray<SKSpriteNode>(APAPlayer.START_LIVES));
        for (int j = 0; j < APAPlayer.START_LIVES; j++) {
            SKSpriteNode heart = SKSpriteNode.create("String_Node_Str");
            heart.setScale(0.4);
            heart.setPosition(new CGPoint(hudX + i * hudD + (avatar.getSize().getWidth() * 1.0) + 18 + ((heart.getSize().getWidth() + 5) * j), hudY - 10));
            heart.setAlpha(0.1);
            hudLifeHeartArrays.get(i).add(heart);
            hud.addChild(heart);
        }
    }
    addChild(hud);
}

Output:
     for (int i = 0; i < NUM_PLAYERS; i++) {
-        SKSpriteNode avatar = SKSpriteNode.create(iconNames[i]);
+        SKSpriteNode avatar = new SKSpriteNode(iconNames[i]);
         avatar.setScale(0.5);


Input:
public HearthTreeNode minionSummonEvent(PlayerSide thisMinionPlayerSide, PlayerSide summonedMinionPlayerSide, Minion summonedMinion, HearthTreeNode boardState) {
    if (!ShipsCannon.triggerFilter.targetMatches(thisMinionPlayerSide, this, summonedMinionPlayerSide, summonedMinion, boardState.data_)) {
        return boardState;
    }
    Collection<HearthTreeNode> rngChildren = this.effectRandomCharacterUsingFilter(ShipsCannon.effect, null, ShipsCannon.effectFilter, boardState);
    return this.createRngNodeWithChildren(boardState, rngChildren);
}

Output:
     }
-    Collection<HearthTreeNode> rngChildren = this.effectRandomCharacterUsingFilter(ShipsCannon.effect, null, ShipsCannon.effectFilter, boardState);
+    Collection<HearthTreeNode> rngChildren = this.effectRandomCharacterUsingFilter(ShipsCannon.effect, null, ShipsCannon.effectFilter, summonedMinionPlayerSide, boardState);
     return this.createRngNodeWithChildren(boardState, rngChildren);


Input:
public boolean addRtpDescription(Map<String, RtpDescriptionPacketExtension> map, ColibriConferenceIQ localChannelsInfo) {
    Objects.requireNonNull(map, "String_Node_Str");
    Objects.requireNonNull(localChannelsInfo, "String_Node_Str");
    if (conferenceState == null || StringUtils.isNullOrEmpty(conferenceState.getID())) {
        return false;
    }
    assertRequestType(RequestType.CHANNEL_INFO_UPDATE);
    request.setType(IQ.Type.SET);
    boolean anyUpdates = false;
    for (Map.Entry<String, RtpDescriptionPacketExtension> e : map.entrySet()) {
        String contentName = e.getKey();
        ColibriConferenceIQ.ChannelCommon channel = getColibriChannel(localChannelsInfo, contentName);
        if (channel != null && channel instanceof ColibriConferenceIQ.Channel) {
            RtpDescriptionPacketExtension rtpPE = e.getValue();
            if (rtpPE == null) {
                continue;
            }
            List<PayloadTypePacketExtension> pts = rtpPE.getPayloadTypes();
            if (pts == null || pts.isEmpty()) {
                continue;
            }
            anyUpdates = true;
            ColibriConferenceIQ.Channel channelRequest = request.getOrCreateContent(contentName).getChannel(channel.getID());
            if (channelRequest == null) {
                channelRequest = new ColibriConferenceIQ.Channel();
                channelRequest.setID(channel.getID());
            }
            for (PayloadTypePacketExtension ptPE : pts) {
                channelRequest.addPayloadType(ptPE);
            }
        }
    }
    return anyUpdates;
}

Output:
             anyUpdates = true;
-            ColibriConferenceIQ.Channel channelRequest = request.getOrCreateContent(contentName).getChannel(channel.getID());
+            ColibriConferenceIQ.Channel channelRequest = (ColibriConferenceIQ.Channel) getRequestChannel(request.getOrCreateContent(contentName), channel);
             if (channelRequest == null) {


Input:
public boolean contains(String text) {
    int nodeIndex = 0;
    int n = text.length();
    for (int i = 0; i < n; i++) {
        char cid = charToCode[text.charAt(i)];
        if (cid == 0)
            return false;
        int next = base[nodeIndex] + cid;
        if (check[next] != nodeIndex)
            return false;
        nodeIndex = next;
    }
    return term.get(nodeIndex);
}

Output:
         int next = base[nodeIndex] + cid;
-        if (check[next] != nodeIndex)
+        if (next < 0 || check[next] != nodeIndex)
             return false;


Input:
protected void startedDirectionChanged(MediaDirection oldValue, MediaDirection newValue) {
    super.startedDirectionChanged(oldValue, newValue);
    try {
        Player localPlayer;
        synchronized (localPlayerSyncRoot) {
            localPlayer = this.localPlayer;
        }
        if (newValue.allowsSending()) {
            if (localPlayer == null)
                createLocalVisualComponent();
        } else if (localPlayer != null) {
            disposeLocalPlayer(localPlayer);
        }
    } catch (Throwable t) {
        if (t instanceof ThreadDeath)
            throw (ThreadDeath) t;
        else {
            logger.error("String_Node_Str", t);
        }
    }
    for (Player player : getPlayers()) {
        int state = player.getState();
        if (state < Player.Realized)
            continue;
        if (newValue.allowsReceiving()) {
            if (state != Player.Started) {
                player.start();
                Component visualComponent = getVisualComponent(player);
                if (visualComponent != null) {
                    fireVideoEvent(VideoEvent.VIDEO_ADDED, visualComponent, VideoEvent.REMOTE, false);
                }
            }
        } else if (state > Processor.Configured) {
            Component visualComponent = getVisualComponent(player);
            player.stop();
            if (visualComponent != null) {
                fireVideoEvent(VideoEvent.VIDEO_REMOVED, visualComponent, VideoEvent.REMOTE, false);
            }
        }
    }
}

Output:
         synchronized (localPlayerSyncRoot) {
-            localPlayer = this.localPlayer;
+            localPlayer = getLocalPlayer();
         }


Input:
public Double distance(Identifier<Double> id) {
    MDIdentifier to = (MDIdentifier) id;
    if (this.idSpace.getDimensions() != to.getIdSpace().getDimensions()) {
        throw new RuntimeException("String_Node_Str");
    }
    double squarredResult = 0;
    for (int i = 0; i < this.idSpace.getDimensions(); i++) {
        if (this.idSpace.isWrapAround()) {
            squarredResult += Math.abs(this.coordinates[i] - to.getCoordinate(i)) % (this.idSpace.getModulus(i) / 2.0);
        } else {
            squarredResult += Math.abs(this.coordinates[i] - to.getCoordinate(i));
        }
    }
    return Math.sqrt(squarredResult);
}

Output:
         if (this.idSpace.isWrapAround()) {
-            squarredResult += Math.abs(this.coordinates[i] - to.getCoordinate(i)) % (this.idSpace.getModulus(i) / 2.0);
+            temp = Math.abs(this.coordinates[i] - to.getCoordinate(i)) % (this.idSpace.getModulus(i) / 2.0);
         } else {


Input:
public void messageArrived(Message<BoardsFilter> message) {
    List<Dtos.Filtered<Dtos.BoardDto>> visibleBoards = message.getPayload().getFilterDataDto().getBoards();
    setVisible(false);
    if (visibleBoards == null || visibleBoards.size() == 0) {
        return;
    }
    for (Dtos.Filtered<Dtos.BoardDto> visibleBoard : visibleBoards) {
        if (visibleBoard.getData().getId().equals(boardDto.getId())) {
            setVisible(true);
            break;
        }
    }
}

Output:
 public void messageArrived(Message<BoardsFilter> message) {
-    List<Dtos.Filtered<Dtos.BoardDto>> visibleBoards = message.getPayload().getFilterDataDto().getBoards();
+    List<Dtos.BoardWithSelectedDto> visibleBoards = message.getPayload().getFilterDataDto().getBoards();
     setVisible(false);


Input:
public EF_LearningBayesianNetwork initModel(EF_LearningBayesianNetwork bayesianNetwork, PlateuStructure plateuStructure) {
    for (Variable paramVariable : bayesianNetwork.getParametersVariables().getListOfParamaterVariables()) {
        if (!paramVariable.isNormalParameter())
            continue;
        EF_NormalParameter prior = bayesianNetwork.getDistribution(paramVariable);
        double varPrior = 1;
        double precisionPrior = 1 / varPrior;
        double meanPrior = 0;
        prior.setNaturalWithMeanPrecision(meanPrior, precisionPrior);
        prior.fixNumericalInstability();
        prior.updateMomentFromNaturalParameters();
    }
    for (Variable localVar : this.localHiddenVars) {
        EF_Normal normal = bayesianNetwork.getDistribution(localVar);
        double mean = meanStart;
        double var = 1;
        normal.getNaturalParameters().set(0, mean / (var));
        normal.getNaturalParameters().set(1, -1 / (2 * var));
        normal.fixNumericalInstability();
        normal.updateMomentFromNaturalParameters();
    }
    return bayesianNetwork;
}

Output:
         double var = 1;
-        normal.getNaturalParameters().set(0, mean / (var));
-        normal.getNaturalParameters().set(1, -1 / (2 * var));
+        normal.setNaturalWithMeanPrecision(mean, 1 / var);
         normal.fixNumericalInstability();


Input:
public static boolean isUpdatedReportParameter(ScalarParameterHandle reportParam, OdaDataSetParameterHandle param, DataSetDesign dataSetDesign) {
    if (reportParam == null || param == null || dataSetDesign == null)
        return true;
    ParameterDefinition matchedParam = getValidParameterDefinition(param, dataSetDesign.getParameters());
    if (matchedParam == null)
        return true;
    ParameterDefinition reportParamDefn = DesignFactory.eINSTANCE.createParameterDefinition();
    DataElementAttributes dataAttrs = DesignFactory.eINSTANCE.createDataElementAttributes();
    dataAttrs.setName(param.getNativeName());
    Integer position = param.getPosition();
    if (position != null)
        dataAttrs.setPosition(position.intValue());
    reportParamDefn.setAttributes(dataAttrs);
    reportParamDefn = new ReportParameterAdapter().updateParameterDefinitionFromReportParam(reportParamDefn, reportParam, dataSetDesign);
    String reportParamString = DesignObjectSerializer.toExternalForm(reportParamDefn);
    String matchedParamString = DesignObjectSerializer.toExternalForm(matchedParam);
    if (reportParamString.equals(matchedParamString))
        return true;
    return false;
}

Output:
         return true;
-    ParameterDefinition matchedParam = getValidParameterDefinition(param, dataSetDesign.getParameters());
-    if (matchedParam == null)
-        return true;
-    ParameterDefinition reportParamDefn = DesignFactory.eINSTANCE.createParameterDefinition();
-    DataElementAttributes dataAttrs = DesignFactory.eINSTANCE.createDataElementAttributes();
-    dataAttrs.setName(param.getNativeName());
-    Integer position = param.getPosition();
-    if (position != null)
-        dataAttrs.setPosition(position.intValue());
-    reportParamDefn.setAttributes(dataAttrs);
-    reportParamDefn = new ReportParameterAdapter().updateParameterDefinitionFromReportParam(reportParamDefn, reportParam, dataSetDesign);
-    String reportParamString = DesignObjectSerializer.toExternalForm(reportParamDefn);
-    String matchedParamString = DesignObjectSerializer.toExternalForm(matchedParam);
-    if (reportParamString.equals(matchedParamString))
-        return true;
-    return false;
+    DataElementAttributes dataAttrs = odaParam.getAttributes();
+    boolean allowNull = reportParam.allowNull();
+    Boolean odaAllowNull = getROMNullability(dataAttrs.getNullability());
+    if (odaAllowNull != null && allowNull != odaAllowNull.booleanValue())
+        return false;
+    if (!DesignChoiceConstants.PARAM_TYPE_ANY.equalsIgnoreCase(newDataType)) {
+        if (!isEquals(newDataType, reportParam.getDataType()))
+            return false;
+    }
+    DataElementUIHints dataUiHints = dataAttrs.getUiHints();
+    if (dataUiHints != null) {
+        String newPromptText = dataUiHints.getDisplayName();
+        String newHelpText = dataUiHints.getDescription();
+        if (!isEquals(newPromptText, reportParam.getPromptText()))
+            return false;
+        if (!isEquals(newHelpText, reportParam.getHelpText()))
+            return false;
+    }
+    InputParameterAttributes paramAttrs = odaParam.getInputAttributes();
+    InputParameterAttributes tmpParamDefn = (InputParameterAttributes) EcoreUtil.copy(paramAttrs);
+    DynamicValuesQuery tmpDynamicQuery = tmpParamDefn.getElementAttributes().getDynamicValueChoices();
+    String tmpDataSetName = null;
+    if (tmpDynamicQuery != null) {
+        tmpDataSetName = tmpDynamicQuery.getDataSetDesign().getName();
+        tmpDynamicQuery.setDataSetDesign(null);
+    }
+    if (tmpParamDefn.getUiHints() != null) {
+        tmpParamDefn.setUiHints(null);
+    }
+    InputParameterAttributes tmpParamDefn1 = DesignFactory.eINSTANCE.createInputParameterAttributes();
+    updateInputElementAttrs(tmpParamDefn1, reportParam, null);
+    if (tmpParamDefn1.getUiHints() != null) {
+        tmpParamDefn1.setUiHints(null);
+    }
+    DynamicValuesQuery tmpDynamicQuery1 = tmpParamDefn1.getElementAttributes().getDynamicValueChoices();
+    String tmpDataSetName1 = null;
+    if (tmpDynamicQuery1 != null) {
+        tmpDataSetName1 = tmpDynamicQuery1.getDataSetDesign().getName();
+        tmpDynamicQuery1.setDataSetDesign(null);
+    }
+    if (!isEquals(tmpDataSetName, tmpDataSetName1))
+        return false;
+    return EcoreUtil.equals(tmpParamDefn, tmpParamDefn1);
 }


Input:
public void testReturnDelegateCookies() {
    Cookie[] cookies = new Cookie[] { new Cookie("String_Node_Str", TEST_VALUE_1), new Cookie("String_Node_Str", "String_Node_Str") };
    HttpServletRequest delegate = createMock(HttpServletRequest.class);
    expect(delegate.getCookies()).andStubReturn(cookies);
    replay(delegate);
    ContinuingHttpServletRequest continuingRequest = new ContinuingHttpServletRequest(delegate);
    assertCookieArraysEqual(cookies, continuingRequest.getCookies());
    cookies[0].setValue("String_Node_Str");
    cookies[1].setValue("String_Node_Str");
    cookies[1].setMaxAge(123);
    try {
        assertCookieArraysEqual(cookies, continuingRequest.getCookies());
        fail();
    } catch (AssertionFailedError e) {
    }
    assertEquals(TEST_VALUE_1, continuingRequest.getCookies()[0].getValue());
    assertEquals(TEST_VALUE_2, continuingRequest.getCookies()[1].getValue());
    assertEquals(DEFAULT_MAX_AGE, continuingRequest.getCookies()[1].getMaxAge());
    ContinuingHttpServletRequest furtherContinuingRequest = new ContinuingHttpServletRequest(continuingRequest);
    assertCookieArraysEqual(continuingRequest.getCookies(), furtherContinuingRequest.getCookies());
    verify(delegate);
}

Output:
         assertCookieArraysEqual(cookies, continuingRequest.getCookies());
-        fail();
+        throw new Error();
     } catch (AssertionFailedError e) {


Input:
private Set needCachedDataSetToEnhancePerformance(TabularCubeHandle cubeHandle) {
    Set set = new HashSet();
    set.add(cubeHandle.getDataSet());
    List dimHandles = cubeHandle.getContents(CubeHandle.DIMENSIONS_PROP);
    for (int i = 0; i < dimHandles.size(); i++) {
        DimensionHandle dimHandle = (DimensionHandle) dimHandles.get(i);
        List hiers = dimHandle.getContents(DimensionHandle.HIERARCHIES_PROP);
        TabularHierarchyHandle hierHandle = (TabularHierarchyHandle) hiers.get(0);
        if (hierHandle.getDataSet() != null)
            set.add(hierHandle.getDataSet());
    }
    return set;
}

Output:
         if (hierHandle.getDataSet() != null)
-            set.add(hierHandle.getDataSet());
+            list.add(hierHandle.getDataSet());
+        else
+            list.add(cubeHandle.getDataSet());
     }


Input:
public void run() {
    Context context = null;
    String importDir = null;
    EPerson eperson = null;
    try {
        context = new Context();
        eperson = EPerson.find(context, oldEPerson.getID());
        context.setCurrentUser(eperson);
        context.setIgnoreAuthorization(true);
        boolean isResume = theResumeDir != null;
        List<Collection> collectionList = new ArrayList<Collection>();
        if (theOtherCollections != null) {
            for (String colID : theOtherCollections) {
                int colId = Integer.parseInt(colID);
                if (colId != theOwningCollection.getID()) {
                    Collection col = Collection.find(context, colId);
                    if (col != null) {
                        collectionList.add(col);
                    }
                }
            }
        }
        Collection[] otherCollections = collectionList.toArray(new Collection[collectionList.size()]);
        importDir = ConfigurationManager.getProperty("String_Node_Str") + File.separator + "String_Node_Str" + File.separator + context.getCurrentUser().getID() + File.separator + (isResume ? theResumeDir : (new GregorianCalendar()).getTimeInMillis());
        File importDirFile = new File(importDir);
        if (!importDirFile.exists()) {
            boolean success = importDirFile.mkdirs();
            if (!success) {
                log.info("String_Node_Str");
                throw new Exception("String_Node_Str");
            }
        }
        String dataPath = null;
        String dataDir = null;
        if (theInputType.equals("String_Node_Str")) {
            dataPath = importDirFile + File.separator + "String_Node_Str";
            dataDir = importDirFile + File.separator + "String_Node_Str" + File.separator;
        } else if (theInputType.equals("String_Node_Str")) {
            FileUtils.copyFileToDirectory(new File(theFilePath), importDirFile);
            dataPath = importDirFile + File.separator + (new File(theFilePath)).getName();
            dataDir = importDirFile + File.separator + "String_Node_Str" + File.separator;
        } else {
            dataPath = importDirFile + File.separator + (new File(theFilePath)).getName();
            dataDir = importDirFile + File.separator + "String_Node_Str" + File.separator;
        }
        if (isResume) {
            (new File(dataPath)).delete();
            FileDeleteStrategy.FORCE.delete(new File(dataDir));
        }
        String sourcePath = null;
        if (theInputType.equals("String_Node_Str")) {
            OutputStream os = new FileOutputStream(dataPath);
            byte[] b = new byte[2048];
            int length;
            InputStream is = new URL(theFilePath).openStream();
            while ((length = is.read(b)) != -1) {
                os.write(b, 0, length);
            }
            is.close();
            os.close();
            sourcePath = unzip(new File(dataPath), dataDir);
            FileUtils.moveDirectory(new File(sourcePath), new File(importDirFile + File.separator + "String_Node_Str" + File.separator));
            FileDeleteStrategy.FORCE.delete(new File(dataDir));
            dataDir = importDirFile + File.separator + "String_Node_Str" + File.separator;
        } else if (theInputType.equals("String_Node_Str")) {
            sourcePath = unzip(new File(dataPath), dataDir);
            FileUtils.moveDirectory(new File(sourcePath), new File(importDirFile + File.separator + "String_Node_Str" + File.separator));
            FileDeleteStrategy.FORCE.delete(new File(dataDir));
            dataDir = importDirFile + File.separator + "String_Node_Str" + File.separator;
        }
        String mapFilePath = importDirFile + File.separator + "String_Node_Str";
        Collection[] finalCollections = null;
        if (theOwningCollection != null) {
            finalCollections = new Collection[otherCollections.length + 1];
            finalCollections[0] = theOwningCollection;
            for (int i = 0; i < otherCollections.length; i++) {
                finalCollections[i + 1] = otherCollections[i];
            }
        }
        ItemImport myloader = new ItemImport();
        myloader.isResume = isResume;
        if (theInputType.equals("String_Node_Str") || theInputType.equals("String_Node_Str")) {
            myloader.addItems(context, finalCollections, dataDir, mapFilePath, template);
        } else {
            myloader.addBTEItems(context, finalCollections, theFilePath, mapFilePath, template, theInputType, dataDir);
        }
        emailSuccessMessage(context, eperson, mapFilePath);
        context.complete();
    } catch (Exception e) {
        e.printStackTrace();
        String exceptionString = ExceptionUtils.getStackTrace(e);
        if (mapOut != null) {
            mapOut.close();
        }
        mapOut = null;
        try {
            File importDirFile = new File(importDir + File.separator + "String_Node_Str");
            PrintWriter errorWriter = new PrintWriter(importDirFile);
            errorWriter.print(exceptionString);
            errorWriter.close();
            emailErrorMessage(eperson, exceptionString);
            throw new Exception(e.getMessage());
        } catch (Exception e2) {
        }
    } finally {
        if (mapOut != null) {
            mapOut.close();
        }
        try {
            context.complete();
        } catch (SQLException sqle) {
            context.abort();
        }
    }
}

Output:
         if (isResume) {
-            (new File(dataPath)).delete();
+            if (!theInputType.equals("String_Node_Str")) {
+                (new File(dataPath)).delete();
+            }
+            (new File(importDirFile + File.separator + "String_Node_Str")).delete();
             FileDeleteStrategy.FORCE.delete(new File(dataDir));