Input:
protected List<GraphTargetItem> printGraph(List<GraphPart> visited, BaseLocalData localData, TranslateStack stack, List<GraphPart> allParts, GraphPart parent, GraphPart part, List<GraphPart> stopPart, List<Loop> loops, List<GraphTargetItem> ret, int staticOperation, String path, int recursionLevel) throws InterruptedException {
    if (Thread.currentThread().isInterrupted()) {
        throw new InterruptedException();
    }
    if (stopPart == null) {
        stopPart = new ArrayList<>();
    }
    if (recursionLevel > allParts.size() + 1) {
        throw new TranslateException("String_Node_Str");
    }
    if (visited.contains(part)) {
    } else {
        visited.add(part);
    }
    if (ret == null) {
        ret = new ArrayList<>();
    }
    boolean debugMode = false;
    if (debugMode) {
        System.err.println("String_Node_Str" + part + "String_Node_Str" + part.nextParts.size());
    }
    if (part == null) {
        return ret;
    }
    part = checkPart(stack, localData, part, allParts);
    if (part == null) {
        return ret;
    }
    if (part.ignored) {
        return ret;
    }
    List<GraphPart> loopContinues = getLoopsContinues(loops);
    boolean isLoop = false;
    Loop currentLoop = null;
    for (Loop el : loops) {
        if ((el.loopContinue == part) && (el.phase == 0)) {
            currentLoop = el;
            currentLoop.phase = 1;
            isLoop = true;
            break;
        }
    }
    if (debugMode) {
        System.err.println("String_Node_Str" + loops.size());
    }
    for (int l = loops.size() - 1; l >= 0; l--) {
        Loop el = loops.get(l);
        if (el == currentLoop) {
            if (debugMode) {
                System.err.println("String_Node_Str" + el);
            }
            continue;
        }
        if (el.phase != 1) {
            if (debugMode) {
            }
            continue;
        }
        if (el.loopBreak == part) {
            if (currentLoop != null) {
                currentLoop.phase = 0;
            }
            if (debugMode) {
                System.err.println("String_Node_Str");
            }
            ret.add(new BreakItem(null, el.id));
            return ret;
        }
        if (el.loopPreContinue == part) {
            if (currentLoop != null) {
                currentLoop.phase = 0;
            }
            if (debugMode) {
                System.err.println("String_Node_Str");
            }
            ret.add(new ContinueItem(null, el.id));
            return ret;
        }
        if (el.loopContinue == part) {
            if (currentLoop != null) {
                currentLoop.phase = 0;
            }
            if (debugMode) {
                System.err.println("String_Node_Str");
            }
            ret.add(new ContinueItem(null, el.id));
            return ret;
        }
    }
    if (stopPart.contains(part)) {
        if (currentLoop != null) {
            currentLoop.phase = 0;
        }
        switch(part.stopPartType) {
            case AND_OR:
                part.setAndOrStack(stack);
                break;
            case COMMONPART:
                part.setCommonPartStack(stack);
                break;
            case NONE:
                break;
        }
        return ret;
    }
    if ((part != null) && (code.size() <= part.start)) {
        ret.add(new ScriptEndItem());
        return ret;
    }
    List<GraphTargetItem> currentRet = ret;
    UniversalLoopItem loopItem = null;
    if (isLoop) {
        loopItem = new UniversalLoopItem(null, currentLoop);
        currentRet.add(loopItem);
        loopItem.commands = new ArrayList<>();
        currentRet = loopItem.commands;
    }
    boolean parseNext = true;
    List<GraphTargetItem> output = new ArrayList<>();
    List<GraphPart> parts = new ArrayList<>();
    if (part instanceof GraphPartMulti) {
        parts = ((GraphPartMulti) part).parts;
    } else {
        parts.add(part);
    }
    for (GraphPart p : parts) {
        int end = p.end;
        int start = p.start;
        output.addAll(code.translatePart(p, localData, stack, start, end, staticOperation, path));
        if ((end >= code.size() - 1) && p.nextParts.isEmpty()) {
            output.add(new ScriptEndItem());
        }
    }
    if (parseNext) {
        List<GraphTargetItem> retCheck = check(code, localData, allParts, stack, parent, part, stopPart, loops, output, currentLoop, staticOperation, path);
        if (retCheck != null) {
            if (!retCheck.isEmpty()) {
                currentRet.addAll(retCheck);
            }
            parseNext = false;
        } else {
            currentRet.addAll(output);
        }
    }
    if (parseNext && part.nextParts.size() == 2) {
        if ((stack.size() >= 2) && (stack.get(stack.size() - 1) instanceof NotItem) && (((NotItem) (stack.get(stack.size() - 1))).getOriginal().getNotCoerced() == stack.get(stack.size() - 2).getNotCoerced())) {
            GraphPart sp0 = getNextNoJump(part.nextParts.get(0), localData);
            GraphPart sp1 = getNextNoJump(part.nextParts.get(1), localData);
            boolean reversed = false;
            loopContinues = getLoopsContinues(loops);
            loopContinues.add(part);
            if (sp1.leadsTo(localData, this, code, sp0, loops)) {
            } else if (sp0.leadsTo(localData, this, code, sp1, loops)) {
                reversed = true;
            }
            GraphPart next = reversed ? sp0 : sp1;
            GraphTargetItem ti;
            if ((ti = checkLoop(next, stopPart, loops)) != null) {
                currentRet.add(ti);
            } else {
                List<GraphPart> stopPart2 = new ArrayList<>(stopPart);
                GraphPart andOrStopPart = reversed ? sp1 : sp0;
                andOrStopPart.stopPartType = GraphPart.StopPartType.AND_OR;
                stopPart2.add(andOrStopPart);
                printGraph(visited, localData, stack, allParts, parent, next, stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                stack = andOrStopPart.andOrStack;
                GraphTargetItem second = stack.pop();
                GraphTargetItem first = stack.pop();
                andOrStopPart.stopPartType = GraphPart.StopPartType.NONE;
                if (!reversed) {
                    AndItem a = new AndItem(null, first, second);
                    stack.push(a);
                    a.firstPart = part;
                    if (second instanceof AndItem) {
                        a.firstPart = ((AndItem) second).firstPart;
                    }
                    if (second instanceof OrItem) {
                        a.firstPart = ((OrItem) second).firstPart;
                    }
                } else {
                    OrItem o = new OrItem(null, first, second);
                    stack.push(o);
                    o.firstPart = part;
                    if (second instanceof AndItem) {
                        o.firstPart = ((AndItem) second).firstPart;
                    }
                    if (second instanceof OrItem) {
                        o.firstPart = ((OrItem) second).firstPart;
                    }
                }
                next = reversed ? sp1 : sp0;
                if ((ti = checkLoop(next, stopPart, loops)) != null) {
                    currentRet.add(ti);
                } else {
                    currentRet.addAll(printGraph(visited, localData, stack, allParts, parent, next, stopPart, loops, null, staticOperation, path, recursionLevel + 1));
                }
            }
            parseNext = false;
        } else if ((stack.size() >= 2) && (stack.get(stack.size() - 1).getNotCoerced() == stack.get(stack.size() - 2).getNotCoerced())) {
            GraphPart sp0 = getNextNoJump(part.nextParts.get(0), localData);
            GraphPart sp1 = getNextNoJump(part.nextParts.get(1), localData);
            boolean reversed = false;
            loopContinues = getLoopsContinues(loops);
            loopContinues.add(part);
            if (sp1.leadsTo(localData, this, code, sp0, loops)) {
            } else if (sp0.leadsTo(localData, this, code, sp1, loops)) {
                reversed = true;
            }
            GraphPart next = reversed ? sp0 : sp1;
            GraphTargetItem ti;
            if ((ti = checkLoop(next, stopPart, loops)) != null) {
                currentRet.add(ti);
            } else {
                List<GraphPart> stopPart2 = new ArrayList<>(stopPart);
                GraphPart andOrStopPart = reversed ? sp1 : sp0;
                andOrStopPart.stopPartType = GraphPart.StopPartType.AND_OR;
                stopPart2.add(andOrStopPart);
                printGraph(visited, localData, stack, allParts, parent, next, stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                stack = andOrStopPart.andOrStack;
                GraphTargetItem second = stack.pop();
                GraphTargetItem first = stack.pop();
                andOrStopPart.stopPartType = GraphPart.StopPartType.NONE;
                if (reversed) {
                    AndItem a = new AndItem(null, first, second);
                    stack.push(a);
                    a.firstPart = part;
                    if (second instanceof AndItem) {
                        a.firstPart = ((AndItem) second).firstPart;
                    }
                    if (second instanceof OrItem) {
                        a.firstPart = ((AndItem) second).firstPart;
                    }
                } else {
                    OrItem o = new OrItem(null, first, second);
                    stack.push(o);
                    o.firstPart = part;
                    if (second instanceof OrItem) {
                        o.firstPart = ((OrItem) second).firstPart;
                    }
                    if (second instanceof OrItem) {
                        o.firstPart = ((OrItem) second).firstPart;
                    }
                }
                next = reversed ? sp1 : sp0;
                if ((ti = checkLoop(next, stopPart, loops)) != null) {
                    currentRet.add(ti);
                } else {
                    currentRet.addAll(printGraph(visited, localData, stack, allParts, parent, next, stopPart, loops, null, staticOperation, path, recursionLevel + 1));
                }
            }
            parseNext = false;
        }
    }
    if (parseNext) {
        if (false && part.nextParts.size() > 2) {
            GraphPart next = getMostCommonPart(localData, part.nextParts, loops);
            List<GraphPart> vis = new ArrayList<>();
            GraphTargetItem switchedItem = stack.pop();
            List<GraphTargetItem> caseValues = new ArrayList<>();
            List<List<GraphTargetItem>> caseCommands = new ArrayList<>();
            List<GraphTargetItem> defaultCommands = new ArrayList<>();
            List<Integer> valueMappings = new ArrayList<>();
            Loop swLoop = new Loop(loops.size(), null, next);
            swLoop.phase = 1;
            loops.add(swLoop);
            boolean first = false;
            int pos = 0;
            for (GraphPart p : part.nextParts) {
                if (!first) {
                    caseValues.add(new IntegerValueItem(null, pos++));
                    if (vis.contains(p)) {
                        valueMappings.add(caseCommands.size() - 1);
                        continue;
                    }
                    valueMappings.add(caseCommands.size());
                }
                List<GraphPart> stopPart2 = new ArrayList<>();
                if (next != null) {
                    stopPart2.add(next);
                } else if (!stopPart.isEmpty()) {
                    stopPart2.add(stopPart.get(stopPart.size() - 1));
                }
                for (GraphPart p2 : part.nextParts) {
                    if (p2 == p) {
                        continue;
                    }
                    if (!stopPart2.contains(p2)) {
                        stopPart2.add(p2);
                    }
                }
                if (next != p) {
                    if (first) {
                        defaultCommands = printGraph(visited, prepareBranchLocalData(localData), stack, allParts, part, p, stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                    } else {
                        caseCommands.add(printGraph(visited, prepareBranchLocalData(localData), stack, allParts, part, p, stopPart2, loops, null, staticOperation, path, recursionLevel + 1));
                    }
                    vis.add(p);
                }
                first = false;
            }
            SwitchItem sw = new SwitchItem(null, swLoop, switchedItem, caseValues, caseCommands, defaultCommands, valueMappings);
            currentRet.add(sw);
            swLoop.phase = 2;
            if (next != null) {
                currentRet.addAll(printGraph(visited, localData, stack, allParts, part, next, stopPart, loops, null, staticOperation, path, recursionLevel + 1));
            }
        }
        GraphPart nextOnePart = null;
        if (part.nextParts.size() == 2) {
            GraphTargetItem expr = stack.pop();
            if (expr instanceof LogicalOpItem) {
                expr = ((LogicalOpItem) expr).invert();
            } else {
                expr = new NotItem(null, expr);
            }
            if (staticOperation != SOP_USE_STATIC) {
                if (expr.isCompileTime()) {
                    boolean doJump = EcmaScript.toBoolean(expr.getResult());
                    if (doJump) {
                        nextOnePart = part.nextParts.get(0);
                    } else {
                        nextOnePart = part.nextParts.get(1);
                    }
                    if (staticOperation == SOP_REMOVE_STATIC) {
                    }
                }
            }
            if (nextOnePart == null) {
                List<GraphPart> nps;
                nps = part.nextParts;
                GraphPart next = getCommonPart(localData, nps, loops);
                TranslateStack trueStack = (TranslateStack) stack.clone();
                TranslateStack falseStack = (TranslateStack) stack.clone();
                int trueStackSizeBefore = trueStack.size();
                int falseStackSizeBefore = falseStack.size();
                List<GraphTargetItem> onTrue = new ArrayList<>();
                boolean isEmpty = nps.get(0) == nps.get(1);
                if (isEmpty) {
                    next = nps.get(0);
                }
                List<GraphPart> stopPart2 = new ArrayList<>(stopPart);
                GraphPart.CommonPartStack commonPartStack = null;
                if ((!isEmpty) && (next != null)) {
                    commonPartStack = next.new CommonPartStack();
                    if (next.commonPartStacks == null) {
                        next.commonPartStacks = new ArrayList<>();
                    }
                    next.stopPartType = GraphPart.StopPartType.COMMONPART;
                    stopPart2.add(next);
                }
                if (!isEmpty) {
                    if (next != null) {
                        next.commonPartStacks.add(commonPartStack);
                        commonPartStack.isTrueStack = true;
                    }
                    onTrue = printGraph(visited, prepareBranchLocalData(localData), trueStack, allParts, part, nps.get(1), stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                }
                List<GraphTargetItem> onFalse = new ArrayList<>();
                if (!isEmpty) {
                    if (next != null) {
                        commonPartStack.isTrueStack = false;
                    }
                    onFalse = printGraph(visited, prepareBranchLocalData(localData), falseStack, allParts, part, nps.get(0), stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                }
                if ((!isEmpty) && (next != null)) {
                    if ((commonPartStack.trueStack != null) && (commonPartStack.falseStack != null)) {
                        trueStack = commonPartStack.trueStack;
                        falseStack = commonPartStack.falseStack;
                    }
                    next.commonPartStacks.remove(next.commonPartStacks.size() - 1);
                    if (next.commonPartStacks.isEmpty()) {
                        next.stopPartType = GraphPart.StopPartType.NONE;
                    }
                }
                if (isEmpty(onTrue) && isEmpty(onFalse) && (trueStack.size() == trueStackSizeBefore + 1) && (falseStack.size() == falseStackSizeBefore + 1)) {
                    stack.push(new TernarOpItem(null, expr, trueStack.pop(), falseStack.pop()));
                } else {
                    currentRet.add(new IfItem(null, expr, onTrue, onFalse));
                }
                if (next != null) {
                    if (trueStack.size() != trueStackSizeBefore || falseStack.size() != falseStackSizeBefore) {
                        onTrue = printGraph(visited, localData, trueStack, allParts, part, next, stopPart, loops, null, staticOperation, path, recursionLevel + 1);
                        onFalse = printGraph(visited, localData, falseStack, allParts, part, next, stopPart, loops, null, staticOperation, path, recursionLevel + 1);
                        if (isEmpty(onTrue) && isEmpty(onFalse) && (trueStack.size() == trueStackSizeBefore + 1) && (falseStack.size() == falseStackSizeBefore + 1)) {
                            stack.push(new TernarOpItem(null, expr, trueStack.pop(), falseStack.pop()));
                        } else {
                            currentRet.add(new IfItem(null, expr, onTrue, onFalse));
                        }
                    } else {
                        printGraph(visited, localData, stack, allParts, part, next, stopPart, loops, currentRet, staticOperation, path, recursionLevel + 1);
                    }
                }
            }
        }
        if (part.nextParts.size() == 1) {
            nextOnePart = part.nextParts.get(0);
        }
        if (nextOnePart != null) {
            printGraph(visited, localData, stack, allParts, part, part.nextParts.get(0), stopPart, loops, currentRet, staticOperation, path, recursionLevel + 1);
        }
    }
    if (isLoop) {
        LoopItem li = loopItem;
        boolean loopTypeFound = false;
        boolean hasContinue = false;
        processIfs(loopItem.commands);
        checkContinueAtTheEnd(loopItem.commands, currentLoop);
        List<ContinueItem> continues = loopItem.getContinues();
        for (ContinueItem c : continues) {
            if (c.loopId == currentLoop.id) {
                hasContinue = true;
                break;
            }
        }
        if (!hasContinue) {
            if (currentLoop.loopPreContinue != null) {
                List<GraphPart> stopContPart = new ArrayList<>();
                stopContPart.add(currentLoop.loopContinue);
                GraphPart precoBackup = currentLoop.loopPreContinue;
                currentLoop.loopPreContinue = null;
                loopItem.commands.addAll(printGraph(visited, localData, new TranslateStack(), allParts, null, precoBackup, stopContPart, loops, null, staticOperation, path, recursionLevel + 1));
            }
        }
        if (!loopTypeFound && (!loopItem.commands.isEmpty())) {
            if (loopItem.commands.get(0) instanceof IfItem) {
                IfItem ifi = (IfItem) loopItem.commands.get(0);
                List<GraphTargetItem> bodyBranch = null;
                boolean inverted = false;
                boolean breakpos2 = false;
                if ((ifi.onTrue.size() == 1) && (ifi.onTrue.get(0) instanceof BreakItem)) {
                    BreakItem bi = (BreakItem) ifi.onTrue.get(0);
                    if (bi.loopId == currentLoop.id) {
                        bodyBranch = ifi.onFalse;
                        inverted = true;
                    }
                } else if ((ifi.onFalse.size() == 1) && (ifi.onFalse.get(0) instanceof BreakItem)) {
                    BreakItem bi = (BreakItem) ifi.onFalse.get(0);
                    if (bi.loopId == currentLoop.id) {
                        bodyBranch = ifi.onTrue;
                    }
                } else if (loopItem.commands.size() == 2 && (loopItem.commands.get(1) instanceof BreakItem)) {
                    BreakItem bi = (BreakItem) loopItem.commands.get(1);
                    if (bi.loopId == currentLoop.id) {
                        bodyBranch = ifi.onTrue;
                        breakpos2 = true;
                    }
                }
                if (bodyBranch != null) {
                    int index = ret.indexOf(loopItem);
                    ret.remove(index);
                    List<GraphTargetItem> exprList = new ArrayList<>();
                    GraphTargetItem expr = ifi.expression;
                    if (inverted) {
                        if (expr instanceof LogicalOpItem) {
                            expr = ((LogicalOpItem) expr).invert();
                        } else {
                            expr = new NotItem(null, expr);
                        }
                    }
                    exprList.add(expr);
                    List<GraphTargetItem> commands = new ArrayList<>();
                    commands.addAll(bodyBranch);
                    loopItem.commands.remove(0);
                    if (breakpos2) {
                        loopItem.commands.remove(0);
                    }
                    commands.addAll(loopItem.commands);
                    checkContinueAtTheEnd(commands, currentLoop);
                    List<GraphTargetItem> finalComm = new ArrayList<>();
                    if (currentLoop.loopPreContinue != null) {
                        GraphPart backup = currentLoop.loopPreContinue;
                        currentLoop.loopPreContinue = null;
                        List<GraphPart> stopPart2 = new ArrayList<>(stopPart);
                        stopPart2.add(currentLoop.loopContinue);
                        finalComm = printGraph(visited, localData, new TranslateStack(), allParts, null, backup, stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                        currentLoop.loopPreContinue = backup;
                        checkContinueAtTheEnd(finalComm, currentLoop);
                    }
                    if (!finalComm.isEmpty()) {
                        ret.add(index, li = new ForItem(null, currentLoop, new ArrayList<GraphTargetItem>(), exprList.get(exprList.size() - 1), finalComm, commands));
                    } else {
                        ret.add(index, li = new WhileItem(null, currentLoop, exprList, commands));
                    }
                    loopTypeFound = true;
                }
            }
        }
        if (!loopTypeFound && (!loopItem.commands.isEmpty())) {
            if (loopItem.commands.get(loopItem.commands.size() - 1) instanceof IfItem) {
                IfItem ifi = (IfItem) loopItem.commands.get(loopItem.commands.size() - 1);
                List<GraphTargetItem> bodyBranch = null;
                boolean inverted = false;
                if ((ifi.onTrue.size() == 1) && (ifi.onTrue.get(0) instanceof BreakItem)) {
                    BreakItem bi = (BreakItem) ifi.onTrue.get(0);
                    if (bi.loopId == currentLoop.id) {
                        bodyBranch = ifi.onFalse;
                        inverted = true;
                    }
                } else if ((ifi.onFalse.size() == 1) && (ifi.onFalse.get(0) instanceof BreakItem)) {
                    BreakItem bi = (BreakItem) ifi.onFalse.get(0);
                    if (bi.loopId == currentLoop.id) {
                        bodyBranch = ifi.onTrue;
                    }
                }
                if (bodyBranch != null) {
                    int index = ret.indexOf(loopItem);
                    ret.remove(index);
                    List<GraphTargetItem> exprList = new ArrayList<>();
                    GraphTargetItem expr = ifi.expression;
                    if (inverted) {
                        if (expr instanceof LogicalOpItem) {
                            expr = ((LogicalOpItem) expr).invert();
                        } else {
                            expr = new NotItem(null, expr);
                        }
                    }
                    checkContinueAtTheEnd(bodyBranch, currentLoop);
                    List<GraphTargetItem> commands = new ArrayList<>();
                    if (!bodyBranch.isEmpty()) {
                        ret.add(index, loopItem);
                    } else {
                        loopItem.commands.remove(loopItem.commands.size() - 1);
                        commands.addAll(loopItem.commands);
                        commands.addAll(bodyBranch);
                        exprList.add(expr);
                        checkContinueAtTheEnd(commands, currentLoop);
                        ret.add(index, li = new DoWhileItem(null, currentLoop, commands, exprList));
                    }
                    loopTypeFound = true;
                }
            }
        }
        if (!loopTypeFound) {
            if (currentLoop.loopPreContinue != null) {
                loopTypeFound = true;
                GraphPart backup = currentLoop.loopPreContinue;
                currentLoop.loopPreContinue = null;
                List<GraphPart> stopPart2 = new ArrayList<>(stopPart);
                stopPart2.add(currentLoop.loopContinue);
                List<GraphTargetItem> finalComm = printGraph(visited, localData, new TranslateStack(), allParts, null, backup, stopPart2, loops, null, staticOperation, path, recursionLevel + 1);
                currentLoop.loopPreContinue = backup;
                checkContinueAtTheEnd(finalComm, currentLoop);
                if (!finalComm.isEmpty()) {
                    if (finalComm.get(finalComm.size() - 1) instanceof IfItem) {
                        IfItem ifi = (IfItem) finalComm.get(finalComm.size() - 1);
                        boolean ok = false;
                        boolean invert = false;
                        if (((ifi.onTrue.size() == 1) && (ifi.onTrue.get(0) instanceof BreakItem) && (((BreakItem) ifi.onTrue.get(0)).loopId == currentLoop.id)) && ((ifi.onTrue.size() == 1) && (ifi.onFalse.get(0) instanceof ContinueItem) && (((ContinueItem) ifi.onFalse.get(0)).loopId == currentLoop.id))) {
                            ok = true;
                            invert = true;
                        }
                        if (((ifi.onTrue.size() == 1) && (ifi.onTrue.get(0) instanceof ContinueItem) && (((ContinueItem) ifi.onTrue.get(0)).loopId == currentLoop.id)) && ((ifi.onTrue.size() == 1) && (ifi.onFalse.get(0) instanceof BreakItem) && (((BreakItem) ifi.onFalse.get(0)).loopId == currentLoop.id))) {
                            ok = true;
                        }
                        if (ok) {
                            finalComm.remove(finalComm.size() - 1);
                            int index = ret.indexOf(loopItem);
                            ret.remove(index);
                            List<GraphTargetItem> exprList = new ArrayList<>(finalComm);
                            GraphTargetItem expr = ifi.expression;
                            if (invert) {
                                if (expr instanceof LogicalOpItem) {
                                    expr = ((LogicalOpItem) expr).invert();
                                } else {
                                    expr = new NotItem(null, expr);
                                }
                            }
                            exprList.add(expr);
                            ret.add(index, li = new DoWhileItem(null, currentLoop, loopItem.commands, exprList));
                        }
                    }
                }
            }
        }
        if (!loopTypeFound) {
            checkContinueAtTheEnd(loopItem.commands, currentLoop);
        }
        currentLoop.phase = 2;
        GraphTargetItem replaced = checkLoop(li, localData, loops);
        if (replaced != li) {
            int index = ret.indexOf(li);
            ret.remove(index);
            if (replaced != null) {
                ret.add(index, replaced);
            }
        }
        if (currentLoop.loopBreak != null) {
            ret.addAll(printGraph(visited, localData, stack, allParts, part, currentLoop.loopBreak, stopPart, loops, null, staticOperation, path, recursionLevel + 1));
        }
    }
    return ret;
}

Output:
                     if (second instanceof OrItem) {
-                        a.firstPart = ((AndItem) second).firstPart;
+                        a.firstPart = ((OrItem) second).firstPart;
                     }


Input:
protected List<TdColumn> extractColumns(DatabaseMetaData dbMetaData, IMetadataConnection metadataConnection, String databaseType, String catalogName, String schemaName, String tableName) {
    MappingTypeRetriever mappingTypeRetriever = null;
    columnIndex = 0;
    List<TdColumn> metadataColumns = new ArrayList<TdColumn>();
    Map<String, String> primaryKeys = new HashMap<String, String>();
    ResultSet columns = null;
    Statement stmt = null;
    try {
        primaryKeys = retrievePrimaryKeys(dbMetaData, catalogName, schemaName, tableName);
        columns = getColumnsResultSet(dbMetaData, catalogName, schemaName, tableName);
        IRepositoryService repositoryService = CoreRuntimePlugin.getInstance().getRepositoryService();
        while (columns.next()) {
            Boolean b = false;
            String fetchTableName = ExtractMetaDataUtils.getStringMetaDataInfo(columns, ExtractManager.TABLE_NAME, null);
            fetchTableName = ManagementTextUtils.filterSpecialChar(fetchTableName);
            if (fetchTableName.equals(tableName) || databaseType.equals(EDatabaseTypeName.SQLITE.getDisplayName())) {
                TdColumn metadataColumn = RelationalFactory.eINSTANCE.createTdColumn();
                String label = ExtractMetaDataUtils.getStringMetaDataInfo(columns, "String_Node_Str", null);
                label = ManagementTextUtils.filterSpecialChar(label);
                String sub = "String_Node_Str";
                String sub2 = "String_Node_Str";
                String label2 = label;
                if (label != null && label.length() > 0 && label.startsWith("String_Node_Str")) {
                    sub = label.substring(1);
                    if (sub != null && sub.length() > 0) {
                        sub2 = sub.substring(1);
                    }
                }
                if (coreService != null && (coreService.isKeyword(label) || coreService.isKeyword(sub) || coreService.isKeyword(sub2))) {
                    label = "String_Node_Str" + label;
                    b = true;
                }
                metadataColumn.setLabel(label);
                metadataColumn.setOriginalField(label2);
                if (repositoryService != null) {
                    label = repositoryService.validateColumnName(label, columnIndex);
                    metadataColumn.setLabel(label);
                }
                columnIndex++;
                if (primaryKeys != null && !primaryKeys.isEmpty() && primaryKeys.get(metadataColumn.getOriginalField()) != null) {
                    metadataColumn.setKey(true);
                } else {
                    metadataColumn.setKey(false);
                }
                String typeName = "String_Node_Str";
                if (ExtractMetaDataUtils.isUseAllSynonyms()) {
                    typeName = "String_Node_Str";
                }
                String dbType = ExtractMetaDataUtils.getStringMetaDataInfo(columns, typeName, null).toUpperCase();
                dbType = dbType.trim();
                dbType = ManagementTextUtils.filterSpecialChar(dbType);
                dbType = handleDBtype(dbType);
                metadataColumn.setSourceType(dbType);
                Integer columnSize;
                columnSize = ExtractMetaDataUtils.getIntMetaDataInfo(columns, "String_Node_Str");
                metadataColumn.setLength(columnSize);
                String talendType = null;
                if (metadataConnection.getMapping() != null) {
                    mappingTypeRetriever = MetadataTalendType.getMappingTypeRetriever(metadataConnection.getMapping());
                }
                Integer intMetaDataInfo = ExtractMetaDataUtils.getIntMetaDataInfo(columns, "String_Node_Str");
                talendType = mappingTypeRetriever.getDefaultSelectedTalendType(dbType, columnSize, intMetaDataInfo);
                talendType = ManagementTextUtils.filterSpecialChar(talendType);
                if (talendType == null) {
                    if (LanguageManager.getCurrentLanguage() == ECodeLanguage.JAVA) {
                        talendType = JavaTypesManager.getDefaultJavaType().getId();
                        log.warn(Messages.getString("String_Node_Str", dbType));
                    }
                } else {
                }
                metadataColumn.setTalendType(talendType);
                boolean isNullable = ExtractMetaDataUtils.getBooleanMetaDataInfo(columns, "String_Node_Str");
                metadataColumn.setNullable(isNullable);
                String commentInfo = ExtractMetaDataUtils.getStringMetaDataInfo(columns, ExtractManager.REMARKS, null);
                if (commentInfo != null && commentInfo.length() > 0) {
                    commentInfo = ManagementTextUtils.filterSpecialChar(commentInfo);
                }
                metadataColumn.setComment(commentInfo);
                addColumnAttributes(metadataConnection, columns, metadataColumn, label, label2, dbType, columnSize, intMetaDataInfo, commentInfo);
                checkPrecision(metadataColumn, tableName, dbType, intMetaDataInfo);
                String stringMetaDataInfo = ExtractMetaDataUtils.getStringMetaDataInfo(columns, "String_Node_Str", dbMetaData);
                if (stringMetaDataInfo != null && stringMetaDataInfo.length() > 0 && stringMetaDataInfo.charAt(0) == 0x0) {
                    stringMetaDataInfo = "String_Node_Str";
                }
                stringMetaDataInfo = ManagementTextUtils.filterSpecialChar(stringMetaDataInfo);
                metadataColumn.setDefaultValue(stringMetaDataInfo);
                ExtractMetaDataUtils.handleDefaultValue(metadataColumn, dbMetaData);
                checkTypeForTimestamp(metadataConnection, metadataColumn, dbType);
                metadataColumns.add(metadataColumn);
            }
        }
        checkComments(metadataConnection, tableName, metadataColumns);
    } catch (SQLException e) {
        ExceptionHandler.process(e);
        log.error(e.toString());
        throw new RuntimeException(e);
    } catch (Exception e) {
        ExceptionHandler.process(e);
        log.error(e.toString());
        throw new RuntimeException(e);
    } finally {
        try {
            if (columns != null) {
                columns.close();
            }
            if (stmt != null) {
                stmt.close();
            }
        } catch (SQLException e) {
            log.error(e.toString());
        }
    }
    return metadataColumns;
}

Output:
                 metadataColumn.setOriginalField(label2);
-                if (repositoryService != null) {
-                    label = repositoryService.validateColumnName(label, columnIndex);
-                    metadataColumn.setLabel(label);
-                }
+                label = MetadataToolHelper.validateColumnName(label, columnIndex, columnLabels);
+                metadataColumn.setLabel(label);
                 columnIndex++;


Input:
private void checkServerConnection(String name, String urlStr) {
    URL url = null;
    try {
        url = new URL(urlStr);
    } catch (MalformedURLException e) {
        logger.error("String_Node_Str" + e.getMessage());
        throw SoftwareManagerCollectorException.CONNECT_FAILURE(name, e.getMessage());
    }
    final String host = url.getHost();
    final int port = url.getPort();
    logger.info("String_Node_Str");
    try {
        ExecutorService exec = Executors.newFixedThreadPool(1);
        Future<Boolean> futureResult = exec.submit(new Callable<Boolean>() {
            public Boolean call() throws Exception {
                try {
                    new Socket(host, port);
                    return true;
                } catch (UnknownHostException e) {
                    throw e;
                } catch (IOException e) {
                    throw e;
                }
            }
        });
        waitForThreadResult(futureResult);
    } catch (Exception e) {
        logger.error("String_Node_Str" + name + "String_Node_Str", e);
        throw SoftwareManagerCollectorException.CONNECT_FAILURE(name, e.getMessage());
    }
}

Output:
         logger.error("String_Node_Str" + e.getMessage());
-        throw SoftwareManagerCollectorException.CONNECT_FAILURE(name, e.getMessage());
+        throw SoftwareManagerCollectorException.CONNECT_FAILURE(appMgrName, e.getMessage());
     }


Input:
private void extract() {
    if (urlIsConnectable()) {
        message.setText("String_Node_Str");
        mon = new ProgressMonitor(this, "String_Node_Str", "String_Node_Str", 0, 100);
        extractTask = new OntologyExtractingTask(mon);
        extractTask.addPropertyChangeListener(this);
        extractTask.execute();
    } else {
        message.setText("String_Node_Str");
    }
}

Output:
 private void extract() {
-    if (urlIsConnectable()) {
-        message.setText("String_Node_Str");
-        mon = new ProgressMonitor(this, "String_Node_Str", "String_Node_Str", 0, 100);
-        extractTask = new OntologyExtractingTask(mon);
-        extractTask.addPropertyChangeListener(this);
-        extractTask.execute();
-    } else {
-        message.setText("String_Node_Str");
-    }
+    message.setText("String_Node_Str");
+    setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+    mon = new ProgressMonitor(this, "String_Node_Str", "String_Node_Str", 0, 100);
+    extractTask = new OntologyExtractingTask(this, mon);
+    extractTask.addPropertyChangeListener(this);
+    extractTask.execute();
 }


Input:
public CharSequence getFlyweightStr(int col) {
    return rec().getFlyweightStr(col);
}

Output:
 public CharSequence getFlyweightStr(int col) {
-    return rec().getFlyweightStr(col);
+    return rec.getFlyweightStr(col);
 }


Input:
public void addImageData(IImageContent image, IStyle style, HyperlinkDef link, BookmarkDef bookmark) {
    int imageWidthDpi;
    int imageHeightDpi;
    try {
        Image imageInfo = EmitterUtil.parseImage(image, image.getImageSource(), image.getURI(), image.getMIMEType(), image.getExtension());
        int imageFileWidthDpi = imageInfo.getPhysicalWidthDpi() == -1 ? 0 : imageInfo.getPhysicalWidthDpi();
        int imageFileHeightDpi = imageInfo.getPhysicalHeightDpi() == -1 ? 0 : imageInfo.getPhysicalHeightDpi();
        imageWidthDpi = PropertyUtil.getImageDpi(image, imageFileWidthDpi, 0);
        imageHeightDpi = PropertyUtil.getImageDpi(image, imageFileHeightDpi, 0);
    } catch (IOException ex) {
        imageWidthDpi = reportDpi;
        imageHeightDpi = reportDpi;
    }
    XlsContainer container = getCurrentContainer();
    ContainerSizeInfo parentSizeInfo = container.getSizeInfo();
    ColumnsInfo imageColumnsInfo = LayoutUtil.createImage(image, parentSizeInfo.getWidth(), imageWidthDpi);
    splitColumns(imageColumnsInfo, parentSizeInfo);
    ContainerSizeInfo imageSize = new ContainerSizeInfo(parentSizeInfo.getStartCoordinate(), imageColumnsInfo.getTotalWidth());
    StyleEntry entry = engine.getStyle(style, imageSize, parentSizeInfo, getParentStyle(container));
    setlinkStyle(entry, link);
    SheetData data = createImageData(image, entry, container, imageHeightDpi, imageWidthDpi);
    data.setHyperlinkDef(link);
    data.setBookmark(bookmark);
    data.setStartX(imageSize.getStartCoordinate());
    data.setEndX(imageSize.getEndCoordinate());
    addData(data);
}

Output:
         int imageFileHeightDpi = imageInfo.getPhysicalHeightDpi() == -1 ? 0 : imageInfo.getPhysicalHeightDpi();
-        imageWidthDpi = PropertyUtil.getImageDpi(image, imageFileWidthDpi, 0);
-        imageHeightDpi = PropertyUtil.getImageDpi(image, imageFileHeightDpi, 0);
+        if (image.getWidth() == null) {
+            imageWidthDpi = PropertyUtil.getImageDpi(image, imageFileWidthDpi, 0);
+        } else {
+            imageWidthDpi = reportDpi;
+        }
+        if (image.getHeight() == null) {
+            imageHeightDpi = PropertyUtil.getImageDpi(image, imageFileHeightDpi, 0);
+        } else {
+            imageHeightDpi = reportDpi;
+        }
     } catch (IOException ex) {


Input:
public void run() throws IOFailure {
    ViewerArcRepositoryClient arcrep = ArcRepositoryClientFactory.getViewerInstance();
    String timestamp = new Long(new Date().getTime()).toString();
    String jobName = BatchGUI.getJobName(batchJob.getClass().getName());
    if (batchJob instanceof LoadableJarBatchJob) {
        LoadableJarBatchJob ljbj = (LoadableJarBatchJob) batchJob;
        jobName = BatchGUI.getJobName(ljbj.getLoadedJobClass());
        log.debug("String_Node_Str" + jobName + "String_Node_Str");
    }
    try {
        File outputFile = new File(BatchGUI.getBatchDir(), jobName + Constants.NAME_TIMSTAMP_SEPARATOR + timestamp + Constants.OUTPUT_FILE_EXTENSION);
        outputFile.createNewFile();
        File eventLogFile = new File(BatchGUI.getBatchDir(), jobName + Constants.NAME_TIMSTAMP_SEPARATOR + timestamp + Constants.ERROR_FILE_EXTENSION);
        eventLogFile.createNewFile();
        batchJob.processOnlyFilesMatching(regex);
        FileWriter fw = new FileWriter(eventLogFile, APPEND);
        String processInfo = "String_Node_Str" + jobName + "String_Node_Str" + timestamp + "String_Node_Str" + rep.getId() + "String_Node_Str" + regex + "String_Node_Str";
        log.info(processInfo);
        fw.write(processInfo + "String_Node_Str");
        BatchStatus status = arcrep.batch(batchJob, rep.getId());
        final Collection<File> failedFiles = status.getFilesFailed();
        Collection<ExceptionOccurrence> exceptions = status.getExceptions();
        processInfo = "String_Node_Str" + jobName + "String_Node_Str" + status.getNoOfFilesProcessed() + "String_Node_Str";
        log.info(processInfo);
        fw.write(processInfo + "String_Node_Str");
        processInfo = "String_Node_Str" + jobName + "String_Node_Str" + failedFiles.size() + "String_Node_Str" + exceptions.size() + "String_Node_Str";
        log.info(processInfo);
        fw.write(processInfo + "String_Node_Str");
        if (outputFile != null && outputFile.exists()) {
            status.copyResults(outputFile);
        } else {
            log.warn("String_Node_Str" + "String_Node_Str" + StreamUtils.getInputStreamAsString(status.getResultFile().getInputStream()));
        }
        if (!failedFiles.isEmpty()) {
            fw.write("String_Node_Str" + failedFiles.size() + "String_Node_Str");
            for (File f : failedFiles) {
                fw.write(f.getPath() + "String_Node_Str");
            }
        }
        log.info("String_Node_Str" + jobName + "String_Node_Str" + exceptions.size() + "String_Node_Str");
        fw.write("String_Node_Str" + exceptions.size() + "String_Node_Str");
        if (!exceptions.isEmpty()) {
            for (ExceptionOccurrence e : exceptions) {
                fw.write(e.getFileName() + "String_Node_Str");
                fw.write(e.getException() + "String_Node_Str");
            }
        }
        fw.flush();
        fw.close();
    } catch (IOException e) {
        String errMsg = "String_Node_Str" + jobName + "String_Node_Str" + timestamp + "String_Node_Str";
        log.error(errMsg, e);
        throw new IOFailure(errMsg, e);
    } catch (Throwable e) {
        log.error("String_Node_Str", e);
        throw new IOFailure("String_Node_Str", e);
    }
}

Output:
     ViewerArcRepositoryClient arcrep = ArcRepositoryClientFactory.getViewerInstance();
-    String timestamp = new Long(new Date().getTime()).toString();
+    String timestamp = Long.valueOf(new Date().getTime()).toString();
     String jobName = BatchGUI.getJobName(batchJob.getClass().getName());


Input:
public void loadInMemoryStorage(final ColumnBinary columnBinary, final IMemoryAllocator allocator) throws IOException {
    for (ColumnBinary childColumnBinary : columnBinary.columnBinaryList) {
        IColumnBinaryMaker maker = FindColumnBinaryMaker.get(childColumnBinary.makerClassName);
        IMemoryAllocator childMemoryAllocator = allocator.getChild(childColumnBinary.columnName, childColumnBinary.columnType);
        maker.loadInMemoryStorage(childColumnBinary, childMemoryAllocator);
    }
    ICompressor compressor = FindCompressor.get(columnBinary.compressorClassName);
    byte[] decompressBuffer = compressor.decompress(columnBinary.binary, columnBinary.binaryStart, columnBinary.binaryLength);
    IntBuffer buffer = ByteBuffer.wrap(decompressBuffer).asIntBuffer();
    int length = buffer.capacity();
    int currentIndex = 0;
    for (int i = 0; i < length; i++) {
        int arrayLength = buffer.get();
        if (arrayLength != 0) {
            int start = currentIndex;
            allocator.setArrayIndex(i, start, arrayLength);
            currentIndex += arrayLength;
        } else {
            allocator.setNull(i);
        }
    }
    allocator.setValueCount(length);
}

Output:
         IColumnBinaryMaker maker = FindColumnBinaryMaker.get(childColumnBinary.makerClassName);
-        IMemoryAllocator childMemoryAllocator = allocator.getChild(childColumnBinary.columnName, childColumnBinary.columnType);
+        IMemoryAllocator childMemoryAllocator = allocator.getArrayChild(childColumnBinary.rowCount, childColumnBinary.columnType);
         maker.loadInMemoryStorage(childColumnBinary, childMemoryAllocator);


Input:
public StockItem getItem(int slot, TraderStatus status) {
    if (status.equals(TraderStatus.PLAYER_MANAGE_BUY) || status.equals(TraderStatus.PLAYER_BUY)) {
        for (StockItem item : buyStock) if (item.getSlot() == slot)
            return item;
    }
    if (status.equals(TraderStatus.PLAYER_MANAGE_SELL) || status.equals(TraderStatus.PLAYER_SELL)) {
        for (StockItem item : sellStock) if (item.getSlot() == slot)
            return item;
    }
    return null;
}

Output:
     if (status.equals(TraderStatus.PLAYER_MANAGE_BUY) || status.equals(TraderStatus.PLAYER_BUY)) {
-        for (StockItem item : buyStock) if (item.getSlot() == slot)
-            return item;
+        for (StockItem item : buyStock) {
+            equal = false;
+            if (itemStack.getType().equals(item.getItemStack().getType()) && itemStack.getData().equals(item.getItemStack().getData())) {
+                equal = true;
+                if (dura)
+                    equal = itemStack.getDurability() >= item.getItemStack().getDurability();
+                if (amount && equal)
+                    equal = itemStack.getAmount() == item.getItemStack().getAmount();
+                if (equal)
+                    return item;
+            }
+        }
     }


Input:
public boolean movePlot(IWorld world, String idFrom, String idTo) {
    if (!getGenManager(world).movePlot(world, idFrom, idTo)) {
        return false;
    }
    Plot plot1 = getPlotById(idFrom, world);
    Plot plot2 = getPlotById(idTo, world);
    if (plot1 != null) {
        if (plot2 != null) {
            int idX = getIdX(idTo);
            int idZ = getIdZ(idTo);
            plugin.getSqlManager().deletePlot(idX, idZ, world.getName());
            removePlot(world, idFrom);
            removePlot(world, idTo);
            idX = getIdX(idFrom);
            idZ = getIdZ(idFrom);
            plugin.getSqlManager().deletePlot(idX, idZ, world.getName());
            plot2.setId(idFrom);
            plugin.getSqlManager().addPlot(plot2, idX, idZ, topX(idFrom, world), bottomX(idFrom, world), topZ(idFrom, world), bottomZ(idFrom, world));
            addPlot(world, idFrom, plot2);
            HashMap<String, UUID> allowed = plot2.allowed().getAllPlayers();
            for (String player : allowed.keySet()) {
                plugin.getSqlManager().addPlotAllowed(player, allowed.get(player), idX, idZ, world.getName());
            }
            HashMap<String, UUID> denied = plot2.denied().getAllPlayers();
            for (String player : denied.keySet()) {
                plugin.getSqlManager().addPlotDenied(player, denied.get(player), idX, idZ, world.getName());
            }
            idX = getIdX(idTo);
            idZ = getIdZ(idTo);
            plot1.setId(idTo);
            plugin.getSqlManager().addPlot(plot1, idX, idZ, topX(idTo, world), bottomX(idTo, world), topZ(idTo, world), bottomZ(idTo, world));
            addPlot(world, idTo, plot1);
            allowed = plot1.allowed().getAllPlayers();
            for (String player : allowed.keySet()) {
                plugin.getSqlManager().addPlotAllowed(player, allowed.get(player), idX, idZ, world.getName());
            }
            denied = plot1.denied().getAllPlayers();
            for (String player : denied.keySet()) {
                plugin.getSqlManager().addPlotDenied(player, denied.get(player), idX, idZ, world.getName());
            }
            setOwnerSign(world, plot1);
            setSellSign(world, plot1);
            setOwnerSign(world, plot2);
            setSellSign(world, plot2);
        }
    } else if (plot2 != null) {
        int idX = getIdX(idTo);
        int idZ = getIdZ(idTo);
        plugin.getSqlManager().deletePlot(idX, idZ, world.getName());
        removePlot(world, idTo);
        idX = getIdX(idFrom);
        idZ = getIdZ(idFrom);
        plot2.setId(idFrom);
        plugin.getSqlManager().addPlot(plot2, idX, idZ, topX(idFrom, world), bottomX(idFrom, world), topZ(idFrom, world), bottomZ(idFrom, world));
        addPlot(world, idFrom, plot2);
        HashMap<String, UUID> allowed = plot2.allowed().getAllPlayers();
        for (String player : allowed.keySet()) {
            plugin.getSqlManager().addPlotAllowed(player, allowed.get(player), idX, idZ, world.getName());
        }
        HashMap<String, UUID> denied = plot2.denied().getAllPlayers();
        for (String player : denied.keySet()) {
            plugin.getSqlManager().addPlotDenied(player, denied.get(player), idX, idZ, world.getName());
        }
        setOwnerSign(world, plot2);
        setSellSign(world, plot2);
        removeOwnerSign(world, idTo);
        getGenManager(world).removeSellerDisplay(world, idTo);
    }
    return true;
}

Output:
             setOwnerSign(world, plot1);
-            setSellSign(world, plot1);
+            removeSellSign(world, plot1.getId());
+            removeAuctionSign(world, plot1.getId());
             setOwnerSign(world, plot2);


Input:
private void upgradeSettingsValues(SharedPreferences sp) {
    if (AnyApplication.DEBUG)
        Log.d(TAG, "String_Node_Str");
    int configurationVersion = sp.getInt(CONFIGURATION_VERSION, 4);
    if (configurationVersion < 1) {
        boolean oldLandscapeFullScreenValue = sp.getBoolean("String_Node_Str", mContext.getResources().getBoolean(R.bool.settings_default_landscape_fullscreen));
        if (AnyApplication.DEBUG)
            Log.d(TAG, "String_Node_Str");
        Editor e = sp.edit();
        e.putBoolean(mContext.getString(R.string.settings_key_landscape_fullscreen), oldLandscapeFullScreenValue);
        e.remove("String_Node_Str");
        e.putInt(CONFIGURATION_VERSION, 1);
        e.commit();
    }
    if (configurationVersion < 2) {
        if (AnyApplication.DEBUG)
            Log.d(TAG, "String_Node_Str");
        Editor e = sp.edit();
        e.putString("String_Node_Str", mContext.getString(R.string.settings_default_portrait_keyboard_height_factor));
        e.putString("String_Node_Str", mContext.getString(R.string.settings_default_landscape_keyboard_height_factor));
        e.putInt(CONFIGURATION_VERSION, 2);
        e.commit();
    }
    if (configurationVersion < 3) {
        Editor e = sp.edit();
        if (Workarounds.getApiLevel() <= 7) {
            if (AnyApplication.DEBUG)
                Log.d(TAG, "String_Node_Str");
            final String bottomRowKey = mContext.getString(R.string.settings_key_ext_kbd_bottom_row_key);
            String currentBottomRowId = sp.getString(bottomRowKey, mContext.getString(R.string.settings_default_ext_kbd_bottom_row_key));
            String newBottomRowId = "String_Node_Str";
            if (currentBottomRowId.equals("String_Node_Str")) {
                newBottomRowId = "String_Node_Str";
            } else if (currentBottomRowId.equals("String_Node_Str")) {
                newBottomRowId = "String_Node_Str";
            }
            if (!TextUtils.isEmpty(newBottomRowId)) {
                Log.i(TAG, "String_Node_Str" + currentBottomRowId + "String_Node_Str" + newBottomRowId + "String_Node_Str");
                e.putString(bottomRowKey, newBottomRowId);
            }
        }
        e.putInt(CONFIGURATION_VERSION, 3);
        e.commit();
    }
    if (configurationVersion < 4) {
        Editor e = sp.edit();
        if (AnyApplication.DEBUG)
            Log.d(TAG, "String_Node_Str");
        e.putBoolean(mContext.getString(R.string.settings_key_landscape_fullscreen), mContext.getResources().getBoolean(R.bool.settings_default_landscape_fullscreen));
        e.putInt(CONFIGURATION_VERSION, 4);
        e.commit();
    }
}

Output:
         Log.d(TAG, "String_Node_Str");
-    int configurationVersion = sp.getInt(CONFIGURATION_VERSION, 4);
+    int configurationVersion = sp.getInt(CONFIGURATION_VERSION, 5);
     if (configurationVersion < 1) {


Input:
protected Options getOptions() {
    if (options != null) {
        options = new Options();
    }
    return options;
}

Output:
 protected Options getOptions() {
-    if (options != null) {
+    if (options == null) {
         options = new Options();


Input:
private List getSelectedValueList() {
    if (needRefreshList == false) {
        return selValueList;
    }
    CubeHandle cube = null;
    CrosstabReportItemHandle crosstab = null;
    if (designHandle instanceof ExtendedItemHandle) {
        try {
            Object obj = ((ExtendedItemHandle) designHandle).getReportItem();
            if (obj instanceof CrosstabReportItemHandle) {
                crosstab = (CrosstabReportItemHandle) obj;
            }
            crosstab = (CrosstabReportItemHandle) ((ExtendedItemHandle) designHandle).getReportItem();
            cube = crosstab.getCube();
        } catch (ExtendedElementException e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
        }
    }
    if (cube == null || (!(cube instanceof CubeHandle)) || expressionCCombo.getText().length() == 0) {
        return new ArrayList();
    }
    Iterator iter = null;
    ICubeQueryDefinition cubeQueryDefn = null;
    DataRequestSession session = null;
    try {
        String expression = null;
        if (ExpressionType.JAVASCRIPT.equals(ExpressionButtonUtil.getExpression(expressionCCombo).getType())) {
            expression = expressionCCombo.getText();
        } else {
            expression = ExpressionButtonUtil.getCurrentExpressionConverter(expressionCCombo).convertExpression(expressionCCombo.getText(), ExpressionType.JAVASCRIPT, IExpressionConverter.EXPRESSION_CLASS_CUBE);
        }
        ReportDesignHandle copy = (ReportDesignHandle) (designHandle.getModuleHandle().copy().getHandle(null));
        EngineConfig config = new EngineConfig();
        config.setProperty(EngineConstants.APPCONTEXT_CLASSLOADER_KEY, DataSetProvider.getCustomScriptClassLoader(Thread.currentThread().getContextClassLoader(), copy));
        ReportEngine engine = (ReportEngine) new ReportEngineFactory().createReportEngine(config);
        DummyEngineTask engineTask = new DummyEngineTask(engine, new ReportEngineHelper(engine).openReportDesign((ReportDesignHandle) copy), copy);
        session = engineTask.getDataSession();
        engineTask.run();
        DataService.getInstance().registerSession(cube, session);
        cubeQueryDefn = CrosstabUIHelper.createBindingQuery(crosstab);
        Map context = session.getDataSessionContext().getAppContext();
        iter = CubeValueSelector.getMemberValueIterator(session, cube, expression, cubeQueryDefn, context);
    } catch (Exception e) {
        logger.log(Level.SEVERE, e.getMessage(), e);
    }
    selValueList = new ArrayList();
    int count = 0;
    int MAX_COUNT = PreferenceFactory.getInstance().getPreferences(CrosstabPlugin.getDefault(), UIUtil.getCurrentProject()).getInt(CrosstabPlugin.PREFERENCE_FILTER_LIMIT);
    while (iter != null && iter.hasNext()) {
        Object obj = iter.next();
        if (obj != null) {
            if (selValueList.indexOf(obj) < 0) {
                selValueList.add(obj);
                if (++count >= MAX_COUNT) {
                    break;
                }
            }
        }
    }
    needRefreshList = false;
    if (session != null) {
        session.shutdown();
    }
    return selValueList;
}

Output:
     }
-    if (cube == null || (!(cube instanceof CubeHandle)) || expressionCCombo.getText().length() == 0) {
+    if (cube == null || expressionCCombo.getText().length() == 0) {
         return new ArrayList();


Input:
public void handleFree(DownloadLink link) throws Exception {
    this.setBrowserExclusive();
    br.clearCookies(link.getDownloadURL());
    br.getPage(link.getDownloadURL());
    int sleep = Integer.parseInt(br.getRegex("String_Node_Str").getMatch(0));
    if (br.containsHTML("String_Node_Str")) {
        int block = Integer.parseInt(br.getRegex("String_Node_Str").getMatch(0)) * 1000 + 1;
        throw new PluginException(LinkStatus.ERROR_IP_BLOCKED, block);
    }
    String Captcha = getCaptchaCode(br.getRegex("String_Node_Str").getMatch(0), link);
    br.getPage("String_Node_Str" + Captcha);
    if (br.containsHTML("String_Node_Str"))
        throw new PluginException(LinkStatus.ERROR_CAPTCHA);
    sleep(sleep * 1001, link);
    br.getPage("String_Node_Str");
    String dllink = null;
    dllink = br.getRegex("String_Node_Str").getMatch(0);
    if (dllink == null)
        throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFEKT);
    dl = jd.plugins.BrowserAdapter.openDownload(br, link, dllink, false, 1);
    dl.startDownload();
}

Output:
     }
-    String Captcha = getCaptchaCode(br.getRegex("String_Node_Str").getMatch(0), link);
+    String Captcha = getCaptchaCode("String_Node_Str" + br.getRegex("String_Node_Str").getMatch(0), link);
     br.getPage("String_Node_Str" + Captcha);


Input:
private void processTableUpdates(TableData updates, ISqlTransaction transaction) {
    Table table = databasePlatform.getTableFromCache(null, null, updates.getTableName(), false);
    excludeColumns(table);
    DmlStatement stmt = databasePlatform.createDmlStatement(DmlType.UPDATE, table.getCatalog(), table.getSchema(), table.getName(), table.getPrimaryKeyColumns(), getUpdateColumns(table), null, null, true);
    for (LinkedCaseInsensitiveMap<Object> row : updates.getTableData()) {
        transaction.prepareAndExecute(stmt.getSql(), row);
    }
}

Output:
     DmlStatement stmt = databasePlatform.createDmlStatement(DmlType.UPDATE, table.getCatalog(), table.getSchema(), table.getName(), table.getPrimaryKeyColumns(), getUpdateColumns(table), null, null, true);
-    for (LinkedCaseInsensitiveMap<Object> row : updates.getTableData()) {
+    Iterator<String> itr = updates.getTableData().keySet().iterator();
+    while (itr.hasNext()) {
+        String key = itr.next();
+        LinkedCaseInsensitiveMap<Object> row = updates.getTableData().get(key);
         transaction.prepareAndExecute(stmt.getSql(), row);


Input:
protected float readX() {
    return (float) mouseInput.getPosition().getY();
}

Output:
 protected float readX() {
-    return (float) mouseInput.getPosition().getY();
+    return (float) mouseInput.getPosition().getX();
 }


Input:
public PrestoTopic getTopicAfterSave() {
    return topic.getDataProvider().getTopicById(topic.getId());
}

Output:
 public PrestoTopic getTopicAfterSave() {
-    return topic.getDataProvider().getTopicById(topic.getId());
+    if (topic.isInline()) {
+        return topic;
+    } else {
+        return topic.getDataProvider().getTopicById(topic.getId());
+    }
 }


Input:
private Hashtable<String, String> getEnvironment(final String principal, final String password, final String providerUrl, final boolean isSystemContext) {
    final String factory = _ldapConfiguration.getFactory();
    final String url = providerUrl == null ? _ldapConfiguration.getProviderUrl() : providerUrl;
    final Hashtable<String, String> environment = new Hashtable<String, String>();
    environment.put(Context.INITIAL_CONTEXT_FACTORY, factory);
    environment.put(Context.PROVIDER_URL, url);
    environment.put("String_Node_Str", "String_Node_Str");
    environment.put("String_Node_Str", "String_Node_Str");
    enableSSL(environment);
    setAuthentication(environment, isSystemContext);
    if (principal != null) {
        environment.put(Context.SECURITY_PRINCIPAL, principal);
    }
    if (password != null) {
        environment.put(Context.SECURITY_CREDENTIALS, password);
    }
    return environment;
}

Output:
     environment.put(Context.PROVIDER_URL, url);
-    environment.put("String_Node_Str", "String_Node_Str");
+    environment.put("String_Node_Str", _ldapConfiguration.getReadTimeout().toString());
     environment.put("String_Node_Str", "String_Node_Str");


Input:
public List<Object> find(MetamodelImpl metaModel, EntityMetadata metadata, Object rowId, List<String> relationNames) {
    CQLTranslator translator = new CQLTranslator();
    String select_Query = translator.SELECTALL_QUERY;
    select_Query = StringUtils.replace(select_Query, CQLTranslator.COLUMN_FAMILY, translator.ensureCase(new StringBuilder(), metadata.getTableName(), false).toString());
    StringBuilder builder = new StringBuilder(select_Query);
    onWhereClause(metadata, rowId, translator, builder, metaModel);
    return CassandraClientBase.this.executeQuery(builder.toString(), metadata.getEntityClazz(), relationNames);
}

Output:
     onWhereClause(metadata, rowId, translator, builder, metaModel);
-    return CassandraClientBase.this.executeQuery(builder.toString(), metadata.getEntityClazz(), relationNames);
+    return CassandraClientBase.this.executeQuery(builder.toString(), metadata.getEntityClazz(), relationNames, false);
 }


Input:
public static void refreshMap() {
    Map<ItemWrapper, IItemRenderer> tempMap = new THashMap(itemRenders.size());
    for (Entry<ItemWrapper, IItemRenderer> entry : itemRenders.entrySet()) {
        ItemWrapper tempItem = new ItemWrapper(entry.getKey().item, entry.getKey().metadata);
        tempMap.put(tempItem, entry.getValue());
    }
    itemRenders.clear();
    itemRenders = tempMap;
}

Output:
 public static void refreshMap() {
-    Map<ItemWrapper, IItemRenderer> tempMap = new THashMap(itemRenders.size());
+    Map<ItemWrapper, IItemRenderer> tempMap = new THashMap<ItemWrapper, IItemRenderer>(itemRenders.size());
     for (Entry<ItemWrapper, IItemRenderer> entry : itemRenders.entrySet()) {


Input:
Rule compile() throws CompileException {
    Env.c("String_Node_Str");
    if (debug2) {
        Util.println("String_Node_Str");
        Util.println("String_Node_Str" + rs);
        Util.println(rs.leftMem + "String_Node_Str" + rs.guardMem + "String_Node_Str" + rs.rightMem + "String_Node_Str");
    }
    liftupActiveAtoms(rs.leftMem);
    simplify();
    theRule = new Rule(rs.leftMem.getFirstAtomName(), rs.toString());
    theRule.name = rs.name;
    hc = new HeadCompiler();
    hc.enumFormals(rs.leftMem);
    hc2 = new HeadCompiler();
    hc2.enumFormals(rs.leftMem);
    if (true) {
        theRule.guardLabel = new InstructionList();
        guard = theRule.guardLabel.insts;
    } else
        guard = null;
    theRule.bodyLabel = new InstructionList();
    body = theRule.bodyLabel.insts;
    contLabel = (guard != null ? theRule.guardLabel : theRule.bodyLabel);
    compile_l();
    compile_g();
    if (debug2) {
        Util.println("String_Node_Str");
        Rule tmpRule = new Rule();
        tmpRule.memMatch = memMatch;
        tmpRule.tempMatch = tempMatch;
        tmpRule.atomMatch = atomMatch;
        tmpRule.guard = guard;
        tmpRule.body = body;
        tmpRule.showDetail();
    }
    hc = new HeadCompiler();
    hc.enumFormals(rs.leftMem);
    hc.firsttime = false;
    theRule.guardLabel = new InstructionList();
    guard = theRule.guardLabel.insts;
    contLabel = (guard != null ? theRule.guardLabel : theRule.bodyLabel);
    compile_l();
    compile_g();
    compile_r();
    theRule.memMatch = memMatch;
    theRule.tempMatch = tempMatch;
    theRule.atomMatch = atomMatch;
    theRule.guard = guard;
    theRule.body = body;
    theRule.body.add(1, Instruction.commit(theRule.name, theRule.lineno));
    if (debug2) {
        Util.println("String_Node_Str");
        theRule.showDetail();
        Util.println("String_Node_Str");
    }
    optimize();
    return theRule;
}

Output:
     theRule.body = body;
-    theRule.body.add(1, Instruction.commit(theRule.name, theRule.lineno));
+    if (theRule.name != null)
+        theRule.body.add(1, Instruction.commit(theRule.name, theRule.lineno));
+    else
+        theRule.body.add(1, Instruction.commit(rs.toString(), theRule.lineno));
     if (debug2) {


Input:
private static FolderConfiguration getConfigForArtifact(RuleContext ruleContext, Artifact artifact) {
    String containingFolder = getContainingFolder(artifact);
    FolderConfiguration config = FolderConfiguration.getConfigForFolder(containingFolder);
    if (config == null) {
        ruleContext.ruleError("String_Node_Str" + containingFolder + "String_Node_Str");
        return FolderConfiguration.getConfigForQualifierString("String_Node_Str");
    }
    config.setVersionQualifier(VersionQualifier.getQualifier("String_Node_Str"));
    return config;
}

Output:
     if (config == null) {
-        ruleContext.ruleError("String_Node_Str" + containingFolder + "String_Node_Str");
+        ruleErrorConsumer.ruleError("String_Node_Str" + containingFolder + "String_Node_Str");
         return FolderConfiguration.getConfigForQualifierString("String_Node_Str");


Input:
public void addCLRFiles(final File folder) throws BindException {
    try (final LoggingScope ls = this.loggingScopeFactory.getNewLoggingScope("String_Node_Str")) {
        ConfigurationModule result = this.driverConfigModule;
        for (final File f : folder.listFiles()) {
            if (f.canRead() && f.exists() && f.isFile()) {
                result = result.set(DriverConfiguration.GLOBAL_FILES, f.getAbsolutePath());
            }
        }
        this.driverConfigModule = result.set(DriverConfiguration.DRIVER_MEMORY, this.driverMemory).set(DriverConfiguration.DRIVER_IDENTIFIER, this.driverId).set(DriverConfiguration.DRIVER_JOB_SUBMISSION_DIRECTORY, this.jobSubmissionDirectory);
        final Path globalLibFile = Paths.get(NativeInterop.GLOBAL_LIBRARIES_FILENAME);
        if (!Files.exists(globalLibFile)) {
            LOG.log(Level.FINE, "String_Node_Str", globalLibFile.toAbsolutePath());
        } else {
            String globalLibString = "String_Node_Str";
            try {
                globalLibString = new String(Files.readAllBytes(globalLibFile), StandardCharsets.UTF_8);
            } catch (final Exception e) {
                LOG.log(Level.WARNING, "String_Node_Str" + globalLibFile.toAbsolutePath());
            }
            for (final String s : globalLibString.split("String_Node_Str")) {
                final File f = new File(s);
                this.driverConfigModule = this.driverConfigModule.set(DriverConfiguration.GLOBAL_LIBRARIES, f.getPath());
            }
        }
        this.driverConfiguration = Configurations.merge(this.driverConfigModule.build(), getHTTPConfiguration(), getNameServerConfiguration());
    }
}

Output:
         ConfigurationModule result = this.driverConfigModule;
-        for (final File f : folder.listFiles()) {
-            if (f.canRead() && f.exists() && f.isFile()) {
-                result = result.set(DriverConfiguration.GLOBAL_FILES, f.getAbsolutePath());
+        final File[] files = folder.listFiles();
+        if (files != null) {
+            for (final File f : files) {
+                if (f.canRead() && f.exists() && f.isFile()) {
+                    result = result.set(DriverConfiguration.GLOBAL_FILES, f.getAbsolutePath());
+                }
             }


Input:
protected void startTOCEntry(IContent content) {
    TOCBuilder tocBuilder = context.getTOCBuilder();
    if (tocBuilder != null) {
        if (content != null) {
            TOCEntry parentTOCEntry = getParentTOCEntry();
            String hiddenFormats = content.getStyle().getVisibleFormat();
            Object tocValue = content.getTOC();
            if (tocValue != null) {
                long elementId = ((ReportElementDesign) content.getGenerateBy()).getID();
                String bookmark = content.getBookmark();
                tocEntry = tocBuilder.startEntry(parentTOCEntry, tocValue, bookmark, hiddenFormats, elementId);
                String tocId = tocEntry.getNode().getNodeID();
                if (bookmark == null) {
                    content.setBookmark(tocId);
                }
                return;
            } else if (hiddenFormats != null) {
                tocEntry = tocBuilder.startDummyEntry(parentTOCEntry, hiddenFormats);
            }
        }
    }
}

Output:
             if (tocValue != null) {
-                long elementId = ((ReportElementDesign) content.getGenerateBy()).getID();
+                long elementId = getElementId(content);
                 String bookmark = content.getBookmark();


Input:
public void run() throws IOException {
    for (GenericIndicator indicator : indicatorList) {
        System.out.println(indicator.getName());
        for (TaggedAlgorithm algorithm : configuration.getAlgorithmList()) {
            String algorithmDirectory;
            algorithmDirectory = configuration.getExperimentBaseDirectory() + "String_Node_Str" + algorithm.getTag();
            for (int problemId = 0; problemId < configuration.getProblemList().size(); problemId++) {
                String problemDirectory = algorithmDirectory + "String_Node_Str" + configuration.getProblemList().get(problemId).getName();
                String referenceFrontDirectory = configuration.getReferenceFrontDirectory();
                String referenceFrontName = referenceFrontDirectory + "String_Node_Str" + configuration.getReferenceFrontFileNames().get(problemId);
                Front referenceFront = new ArrayFront(referenceFrontName);
                Front normalizedReferenceFront = new FrontNormalizer(referenceFront).normalize(referenceFront);
                String qualityIndicatorFile = problemDirectory + "String_Node_Str" + indicator.getName();
                System.out.println("String_Node_Str" + qualityIndicatorFile);
                resetFile(qualityIndicatorFile);
                indicator.setReferenceParetoFront(normalizedReferenceFront);
                for (int i = 0; i < configuration.getIndependentRuns(); i++) {
                    String frontFileName;
                    frontFileName = problemDirectory + "String_Node_Str" + configuration.getOutputParetoFrontFileName() + i + "String_Node_Str";
                    Front front = new ArrayFront(frontFileName);
                    Front normalizedFront = new FrontNormalizer(normalizedReferenceFront).normalize(front);
                    Double indicatorValue = (Double) indicator.evaluate(FrontUtils.convertFrontToSolutionList(normalizedFront));
                    System.out.println(indicator.getName() + "String_Node_Str" + indicatorValue);
                    FileWriter os;
                    try {
                        os = new FileWriter(qualityIndicatorFile, true);
                        os.write("String_Node_Str" + indicatorValue + "String_Node_Str");
                        os.close();
                    } catch (IOException ex) {
                        throw new JMetalException("String_Node_Str" + ex);
                    }
                }
            }
        }
    }
}

Output:
     for (GenericIndicator indicator : indicatorList) {
-        System.out.println(indicator.getName());
+        JMetalLogger.logger.info("String_Node_Str" + indicator.getName());
+        ;
         for (TaggedAlgorithm algorithm : configuration.getAlgorithmList()) {


Input:
public static String getDecodedJWT(String serverMessage) {
    String[] headerArray = serverMessage.split("String_Node_Str");
    String[] jwtEncodedArray = headerArray[1].trim().split("String_Node_Str");
    String[] jwtTokenArray = jwtEncodedArray[1].split(Pattern.quote("String_Node_Str"));
    byte[] jwtByteArray = Base64.decodeBase64(jwtTokenArray[1].getBytes());
    return new String(jwtByteArray);
}

Output:
     String[] jwtTokenArray = jwtEncodedArray[1].split(Pattern.quote("String_Node_Str"));
-    byte[] jwtByteArray = Base64.decodeBase64(jwtTokenArray[1].getBytes());
-    return new String(jwtByteArray);
+    byte[] jwtByteArray = Base64.decodeBase64(jwtTokenArray[1].getBytes("String_Node_Str"));
+    return new String(jwtByteArray, "String_Node_Str");
 }


Input:
public void raise_alarm(String faultMember) {
    if (!manager.hasActiveAlarm(clientInfo.getName()))
        send_alarm(faultMember, ACSFaultState.ACTIVE);
}

Output:
     if (!manager.hasActiveAlarm(clientInfo.getName()))
-        send_alarm(faultMember, ACSFaultState.ACTIVE);
+        send_alarm(faultMember, true);
 }


Input:
private void refreshViews(Cursor cursor) {
    if (!cursor.moveToFirst())
        return;
    mTitleView.setText(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mCaptionView.setText(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mDescriptionView.setText(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    String state = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    mIsLocal = MediaUtils.isLocalFile(state);
    if (mIsLocal)
        getActivity().invalidateOptionsMenu();
    inflateImageView();
    String date = MediaUtils.getDate(cursor.getLong(cursor.getColumnIndex("String_Node_Str")));
    if (mIsLocal)
        mDateView.setText("String_Node_Str" + date);
    else
        mDateView.setText("String_Node_Str" + date);
    String fileName = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    mFileNameView.setText("String_Node_Str" + fileName);
    String fileURL = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    if (fileURL != null) {
        String fileType = fileURL.replaceAll("String_Node_Str", "String_Node_Str").toUpperCase();
        mFileTypeView.setText("String_Node_Str" + fileType);
        mFileTypeView.setVisibility(View.VISIBLE);
    } else {
        mFileTypeView.setVisibility(View.GONE);
    }
    String imageUri = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    if (imageUri == null)
        imageUri = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    if (MediaUtils.isValidImage(imageUri)) {
        int width = cursor.getInt(cursor.getColumnIndex("String_Node_Str"));
        int height = cursor.getInt(cursor.getColumnIndex("String_Node_Str"));
        float screenWidth;
        View parentView = (View) mImageView.getParent();
        if (this.isInLayout()) {
            screenWidth = parentView.getMeasuredWidth();
        } else {
            screenWidth = getActivity().getResources().getDisplayMetrics().widthPixels;
        }
        float screenHeight = getActivity().getResources().getDisplayMetrics().heightPixels;
        if (width > 0 && height > 0) {
            String dimensions = width + "String_Node_Str" + height;
            mDimensionsView.setText("String_Node_Str" + dimensions);
            mDimensionsView.setVisibility(View.VISIBLE);
        } else {
            mDimensionsView.setVisibility(View.GONE);
        }
        if (width > screenWidth) {
            height = (int) (height / (width / screenWidth));
        } else if (height > screenHeight) {
            width = (int) (width / (height / screenHeight));
        }
        if (mIsLocal) {
            final String filePath = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
            loadLocalImage(mImageView, filePath, width, height);
        } else {
            ((NetworkImageView) mImageView).setImageUrl(imageUri + "String_Node_Str" + screenWidth, WordPress.imageLoader);
        }
        mImageView.setVisibility(View.VISIBLE);
        mImageView.setLayoutParams(new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, height));
    } else {
        mImageView.setVisibility(View.GONE);
        mDimensionsView.setVisibility(View.GONE);
    }
}

Output:
     if (mIsLocal)
-        getActivity().invalidateOptionsMenu();
+        getSherlockActivity().invalidateOptionsMenu();
     inflateImageView();


Input:
public ColumnBinaryMakerConfig getColumnBinaryMakerConfig(final ColumnBinaryMakerConfig commonConfig, final IColumnAnalizeResult analizeResult) {
    ColumnBinaryMakerConfig currentConfig = new ColumnBinaryMakerConfig(commonConfig);
    DoubleColumnAnalizeResult castColumnAnalizeResult = (DoubleColumnAnalizeResult) analizeResult;
    IColumnBinaryMaker makerClass;
    if (castColumnAnalizeResult.maybeSorted()) {
        int dump = rangeDumpColumnBinaryMaker.calcBinarySize(analizeResult);
        int uniq = rangeUniqColumnBinaryMaker.calcBinarySize(analizeResult);
        if (dump < uniq) {
            makerClass = rangeDumpColumnBinaryMaker;
        } else {
            makerClass = rangeUniqColumnBinaryMaker;
        }
    } else {
        int dump = dumpColumnBinaryMaker.calcBinarySize(analizeResult);
        int uniq = uniqColumnBinaryMaker.calcBinarySize(analizeResult);
        if (dump < uniq) {
            makerClass = dumpColumnBinaryMaker;
        } else {
            makerClass = uniqColumnBinaryMaker;
        }
    }
    if (currentConfig.doubleMakerClass.getClass().getName().equals(makerClass.getClass().getName())) {
        return null;
    }
    currentConfig.doubleMakerClass = makerClass;
    return currentConfig;
}

Output:
     if (castColumnAnalizeResult.maybeSorted()) {
-        int dump = rangeDumpColumnBinaryMaker.calcBinarySize(analizeResult);
-        int uniq = rangeUniqColumnBinaryMaker.calcBinarySize(analizeResult);
-        if (dump < uniq) {
-            makerClass = rangeDumpColumnBinaryMaker;
-        } else {
-            makerClass = rangeUniqColumnBinaryMaker;
-        }
+        makerClass = rangeUniqColumnBinaryMaker;
     } else {


Input:
public void onPlayerLeaveIsland(IslandExitEvent e) {
    final Player player = plugin.getServer().getPlayer(e.getPlayer());
    if (!plugin.getGrid().playerIsOnIsland(player)) {
        if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && player.isFlying() && player.getGameMode().equals(GameMode.SURVIVAL)) {
            plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {

                public void run() {
                    if (!plugin.getGrid().playerIsOnIsland(player) && player.isFlying()) {
                        player.setAllowFlight(false);
                        player.setFlying(false);
                    }
                }
            }, 20 * Settings.flyTimeOutside);
        }
        for (String perm : Settings.temporaryPermissions) {
            if (temporaryPerms.containsKey(player.getUniqueId()) && VaultHelper.checkPerm(player, perm)) {
                VaultHelper.removePerm(player, perm);
                List<String> perms = temporaryPerms.get(player.getUniqueId());
                perms.remove(perm);
                if (perms.isEmpty())
                    temporaryPerms.remove(player.getUniqueId());
                else
                    temporaryPerms.put(player.getUniqueId(), perms);
            }
        }
    }
}

Output:
         if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && player.isFlying() && player.getGameMode().equals(GameMode.SURVIVAL)) {
-            plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
+            if (DEBUG)
+                plugin.getLogger().info("String_Node_Str" + Settings.flyTimeOutside + "String_Node_Str");
+            if (Settings.flyTimeOutside == 0) {
+                player.setAllowFlight(false);
+                player.setFlying(false);
+                if (DEBUG)
+                    plugin.getLogger().info("String_Node_Str");
+            } else {
+                plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {


Input:
protected void buildProperties(IContent content, LayoutContext context) {
    IStyle style = content.getStyle();
    if (style != null && !style.isEmpty()) {
        boxStyle = new BoxStyle();
        IStyle cs = content.getComputedStyle();
        Color color = PropertyUtil.getColor(cs.getProperty(IStyle.STYLE_BACKGROUND_COLOR));
        if (color != null) {
            boxStyle.setBackgroundColor(color);
        }
        String url = style.getBackgroundImage();
        if (url != null) {
            boxStyle.setBackgroundImage(new BackgroundImageInfo(getImageUrl(url), cs.getProperty(IStyle.STYLE_BACKGROUND_REPEAT), getDimensionValue(cs.getProperty(IStyle.STYLE_BACKGROUND_POSITION_X), 100), getDimensionValue(cs.getProperty(IStyle.STYLE_BACKGROUND_POSITION_Y), 100), 0, 0));
        }
        localProperties = new LocalProperties();
        int maw = parent.getMaxAvaWidth();
        localProperties.setMarginBottom(getDimensionValue(cs.getProperty(IStyle.STYLE_MARGIN_BOTTOM), maw));
        localProperties.setMarginLeft(getDimensionValue(cs.getProperty(IStyle.STYLE_MARGIN_LEFT), maw));
        localProperties.setMarginTop(getDimensionValue(cs.getProperty(IStyle.STYLE_MARGIN_TOP), maw));
        localProperties.setMarginRight(getDimensionValue(cs.getProperty(IStyle.STYLE_MARGIN_RIGHT), maw));
        if (!isInInlineStacking) {
            pageBreakAfter = cs.getProperty(IStyle.STYLE_PAGE_BREAK_AFTER);
            pageBreakInside = cs.getProperty(IStyle.STYLE_PAGE_BREAK_INSIDE);
            pageBreakBefore = cs.getProperty(IStyle.STYLE_PAGE_BREAK_BEFORE);
        }
    } else {
        hasStyle = false;
        boxStyle = BoxStyle.DEFAULT;
        localProperties = LocalProperties.DEFAULT;
    }
    bookmark = content.getBookmark();
    action = content.getHyperlinkAction();
}

Output:
         if (url != null) {
-            boxStyle.setBackgroundImage(new BackgroundImageInfo(getImageUrl(url), cs.getProperty(IStyle.STYLE_BACKGROUND_REPEAT), getDimensionValue(cs.getProperty(IStyle.STYLE_BACKGROUND_POSITION_X), 100), getDimensionValue(cs.getProperty(IStyle.STYLE_BACKGROUND_POSITION_Y), 100), 0, 0));
+            boxStyle.setBackgroundImage(new BackgroundImageInfo(getImageUrl(url), cs.getProperty(IStyle.STYLE_BACKGROUND_REPEAT), 0, 0, 0, 0));
         }


Input:
private void resolveRules(int layoutDirection) {
    final boolean isLayoutRtl = (layoutDirection == View.LAYOUT_DIRECTION_RTL);
    System.arraycopy(mInitialRules, LEFT_OF, mRules, LEFT_OF, VERB_COUNT);
    if (mRules[ALIGN_START] != 0) {
        mRules[isLayoutRtl ? ALIGN_RIGHT : ALIGN_LEFT] = mRules[ALIGN_START];
    }
    if (mRules[ALIGN_END] != 0) {
        mRules[isLayoutRtl ? ALIGN_LEFT : ALIGN_RIGHT] = mRules[ALIGN_END];
    }
    if (mRules[START_OF] != 0) {
        mRules[isLayoutRtl ? RIGHT_OF : LEFT_OF] = mRules[START_OF];
    }
    if (mRules[END_OF] != 0) {
        mRules[isLayoutRtl ? LEFT_OF : RIGHT_OF] = mRules[END_OF];
    }
    if (mRules[ALIGN_PARENT_START] != 0) {
        mRules[isLayoutRtl ? ALIGN_PARENT_RIGHT : ALIGN_PARENT_LEFT] = mRules[ALIGN_PARENT_START];
    }
    if (mRules[ALIGN_PARENT_END] != 0) {
        mRules[isLayoutRtl ? ALIGN_PARENT_LEFT : ALIGN_PARENT_RIGHT] = mRules[ALIGN_PARENT_END];
    }
    mRulesChanged = false;
}

Output:
     System.arraycopy(mInitialRules, LEFT_OF, mRules, LEFT_OF, VERB_COUNT);
-    if (mRules[ALIGN_START] != 0) {
-        mRules[isLayoutRtl ? ALIGN_RIGHT : ALIGN_LEFT] = mRules[ALIGN_START];
-    }
-    if (mRules[ALIGN_END] != 0) {
-        mRules[isLayoutRtl ? ALIGN_LEFT : ALIGN_RIGHT] = mRules[ALIGN_END];
-    }
-    if (mRules[START_OF] != 0) {
-        mRules[isLayoutRtl ? RIGHT_OF : LEFT_OF] = mRules[START_OF];
-    }
-    if (mRules[END_OF] != 0) {
-        mRules[isLayoutRtl ? LEFT_OF : RIGHT_OF] = mRules[END_OF];
-    }
-    if (mRules[ALIGN_PARENT_START] != 0) {
-        mRules[isLayoutRtl ? ALIGN_PARENT_RIGHT : ALIGN_PARENT_LEFT] = mRules[ALIGN_PARENT_START];
-    }
-    if (mRules[ALIGN_PARENT_END] != 0) {
-        mRules[isLayoutRtl ? ALIGN_PARENT_LEFT : ALIGN_PARENT_RIGHT] = mRules[ALIGN_PARENT_END];
+    if (mIsRtlCompatibilityMode) {
+        if (mRules[ALIGN_START] != 0) {
+            if (mRules[ALIGN_LEFT] == 0) {
+                mRules[ALIGN_LEFT] = mRules[ALIGN_START];
+            }
+            mRules[ALIGN_START] = 0;
+        }
+        if (mRules[ALIGN_END] != 0) {
+            if (mRules[ALIGN_RIGHT] == 0) {
+                mRules[ALIGN_RIGHT] = mRules[ALIGN_END];
+            }
+            mRules[ALIGN_END] = 0;
+        }
+        if (mRules[START_OF] != 0) {
+            if (mRules[LEFT_OF] == 0) {
+                mRules[LEFT_OF] = mRules[START_OF];
+            }
+            mRules[START_OF] = 0;
+        }
+        if (mRules[END_OF] != 0) {
+            if (mRules[RIGHT_OF] == 0) {
+                mRules[RIGHT_OF] = mRules[END_OF];
+            }
+            mRules[END_OF] = 0;
+        }
+        if (mRules[ALIGN_PARENT_START] != 0) {
+            if (mRules[ALIGN_PARENT_LEFT] == 0) {
+                mRules[ALIGN_PARENT_LEFT] = mRules[ALIGN_PARENT_START];
+            }
+            mRules[ALIGN_PARENT_START] = 0;
+        }
+        if (mRules[ALIGN_PARENT_RIGHT] == 0) {
+            if (mRules[ALIGN_PARENT_RIGHT] == 0) {
+                mRules[ALIGN_PARENT_RIGHT] = mRules[ALIGN_PARENT_END];
+            }
+            mRules[ALIGN_PARENT_END] = 0;
+        }
+    } else {
+        if ((mRules[ALIGN_START] != 0 || mRules[ALIGN_END] != 0) && (mRules[ALIGN_LEFT] != 0 || mRules[ALIGN_RIGHT] != 0)) {
+            mRules[ALIGN_LEFT] = 0;
+            mRules[ALIGN_RIGHT] = 0;
+        }
+        if (mRules[ALIGN_START] != 0) {
+            mRules[isLayoutRtl ? ALIGN_RIGHT : ALIGN_LEFT] = mRules[ALIGN_START];
+            mRules[ALIGN_START] = 0;
+        }
+        if (mRules[ALIGN_END] != 0) {
+            mRules[isLayoutRtl ? ALIGN_LEFT : ALIGN_RIGHT] = mRules[ALIGN_END];
+            mRules[ALIGN_END] = 0;
+        }
+        if ((mRules[START_OF] != 0 || mRules[END_OF] != 0) && (mRules[LEFT_OF] != 0 || mRules[RIGHT_OF] != 0)) {
+            mRules[LEFT_OF] = 0;
+            mRules[RIGHT_OF] = 0;
+        }
+        if (mRules[START_OF] != 0) {
+            mRules[isLayoutRtl ? RIGHT_OF : LEFT_OF] = mRules[START_OF];
+            mRules[START_OF] = 0;
+        }
+        if (mRules[END_OF] != 0) {
+            mRules[isLayoutRtl ? LEFT_OF : RIGHT_OF] = mRules[END_OF];
+            mRules[END_OF] = 0;
+        }
+        if ((mRules[ALIGN_PARENT_START] != 0 || mRules[ALIGN_PARENT_END] != 0) && (mRules[ALIGN_PARENT_LEFT] != 0 || mRules[ALIGN_PARENT_RIGHT] != 0)) {
+            mRules[ALIGN_PARENT_LEFT] = 0;
+            mRules[ALIGN_PARENT_RIGHT] = 0;
+        }
+        if (mRules[ALIGN_PARENT_START] != 0) {
+            mRules[isLayoutRtl ? ALIGN_PARENT_RIGHT : ALIGN_PARENT_LEFT] = mRules[ALIGN_PARENT_START];
+            mRules[ALIGN_PARENT_START] = 0;
+        }
+        if (mRules[ALIGN_PARENT_END] != 0) {
+            mRules[isLayoutRtl ? ALIGN_PARENT_LEFT : ALIGN_PARENT_RIGHT] = mRules[ALIGN_PARENT_END];
+            mRules[ALIGN_PARENT_END] = 0;
+        }
     }


Input:
public void configCluster(final String name, final String specFilePath, final boolean skipConfigValidation) {
    if (name.indexOf("String_Node_Str") != -1) {
        CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CONFIG, Constants.OUTPUT_OP_RESULT_FAIL, Constants.PARAM_CLUSTER + Constants.PARAM_NOT_CONTAIN_HORIZONTAL_LINE);
        return;
    }
    try {
        ClusterRead clusterRead = restClient.get(name);
        ClusterCreate clusterConfig = new ClusterCreate();
        clusterConfig.setName(clusterRead.getName());
        ClusterCreate clusterSpec = CommandsUtils.getObjectByJsonString(ClusterCreate.class, CommandsUtils.dataFromFile(specFilePath));
        clusterConfig.setNodeGroups(clusterSpec.getNodeGroups());
        clusterConfig.setConfiguration(clusterSpec.getConfiguration());
        if (!skipConfigValidation) {
            if (!validateConfiguration(clusterConfig)) {
                return;
            }
        } else {
            clusterConfig.setValidateConfig(false);
        }
        restClient.configCluster(clusterConfig);
    } catch (Exception e) {
        CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CONFIG, Constants.OUTPUT_OP_RESULT_FAIL, e.getMessage());
        return;
    }
}

Output:
         if (!skipConfigValidation) {
-            if (!validateConfiguration(clusterConfig)) {
+            ValidateResult whiteListResult = validateWhiteList(clusterConfig);
+            if (!showWhiteListWarning(clusterConfig.getName(), whiteListResult)) {
                 return;


Input:
public List<FilePath> listFiles() throws IOException {
    if (!isDirectory())
        throw new SilenceException("String_Node_Str");
    if (!exists())
        throw new SilenceException("String_Node_Str");
    if (getResourceType() == ResourceType.FILE)
        return FilePath.getExternalFile(getIDEPath()).listFiles();
    List<FilePath> filePaths = new ArrayList<>();
    List<JarEntry> entries = getJarEntries();
    entries.forEach(e -> filePaths.add(FilePath.getResourceFile(e.getName())));
    return Collections.unmodifiableList(filePaths);
}

Output:
     List<FilePath> filePaths = new ArrayList<>();
-    List<JarEntry> entries = getJarEntries();
-    entries.forEach(e -> filePaths.add(FilePath.getResourceFile(e.getName())));
+    if (getResourceType() == ResourceType.FILE) {
+        File file = new File(getIDEPath());
+        File[] children = file.listFiles();
+        if (children != null)
+            for (File child : children) filePaths.add(new ResourceFilePath(path + SEPARATOR + child.getPath().replace(file.getPath(), "String_Node_Str")));
+    } else {
+        List<JarEntry> entries = getJarEntries();
+        entries.forEach(e -> filePaths.add(FilePath.getResourceFile(e.getName())));
+    }
     return Collections.unmodifiableList(filePaths);


Input:
public void loadCards(CardsView showCards, SortSetting sortSetting, BigCard bigCard, UUID gameId, boolean merge) {
    boolean drawImage = showCards.size() < MAX_IMAGES;
    this.bigCard = bigCard;
    this.gameId = gameId;
    if (merge) {
        for (CardView card : showCards.values()) {
            if (!cards.containsKey(card.getId())) {
                addCard(card, bigCard, gameId, drawImage);
            }
        }
        for (Iterator<Entry<UUID, MageCard>> i = cards.entrySet().iterator(); i.hasNext(); ) {
            Entry<UUID, MageCard> entry = i.next();
            if (!showCards.containsKey(entry.getKey())) {
                removeCardImg(entry.getKey());
                i.remove();
            }
        }
    } else {
        this.clearCards();
        for (CardView card : showCards.values()) {
            addCard(card, bigCard, gameId, drawImage);
        }
    }
    drawCards(sortSetting);
    this.setVisible(true);
}

Output:
 public void loadCards(CardsView showCards, SortSetting sortSetting, BigCard bigCard, UUID gameId, boolean merge) {
-    boolean drawImage = showCards.size() < MAX_IMAGES;
+    boolean drawImage = showCards.size() <= MAX_IMAGES;
     this.bigCard = bigCard;


Input:
public void modifyText(final ModifyEvent e) {
    if (isContextMode()) {
        return;
    }
    IHDistribution newDistribution = getHBaseDistribution(hbaseDistributionCombo.getText(), true);
    if (newDistribution == null) {
        return;
    }
    String originalDistributionName = getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_HBASE_DISTRIBUTION);
    IHDistribution originalDistribution = getHBaseDistribution(originalDistributionName, false);
    boolean doSupportMapRTicket = false;
    IHadoopDistributionService hadoopService = getHadoopDistributionService();
    if (hadoopService != null && newDistribution != null) {
        doSupportMapRTicket = hadoopService.doSupportMapRTicket(newDistribution.getDefaultVersion());
    }
    useMaprTForHBase.setEnabled(doSupportMapRTicket);
    hideControl(useMaprTForHBase, !doSupportMapRTicket);
    hideControl(authenticationMaprTComForHBase, !useMaprTForHBase.getSelection());
    hideControl(authenticationUserPassComForHBase, !useMaprTForHBase.getSelection());
    if (originalDistribution == null || !newDistribution.getName().equals(originalDistribution.getName())) {
        getConnection().getParameters().put(ConnParameterKeys.CONN_PARA_KEY_HBASE_DISTRIBUTION, newDistribution.getName());
        updateHBaseVersionPart(newDistribution);
        fillDefaultsWhenHBaseVersionChanged();
        checkFieldsValue();
    }
}

Output:
     hideControl(useMaprTForHBase, !doSupportMapRTicket);
-    hideControl(authenticationMaprTComForHBase, !useMaprTForHBase.getSelection());
-    hideControl(authenticationUserPassComForHBase, !useMaprTForHBase.getSelection());
+    hideControl(authenticationMaprTComForHBase, !(useMaprTForHBase.getSelection() && doSupportMapRTicket));
+    hideControl(authenticationUserPassComForHBase, useKerberosForHBase.getSelection() && doSupportMapRTicket);
+    authenticationGrpForHBase.layout();
+    authenticationGrpForHBase.getParent().layout();
     if (originalDistribution == null || !newDistribution.getName().equals(originalDistribution.getName())) {


Input:
private boolean checkLimits(MapContainer mapContainer) {
    MaxSizeConfig maxSizeConfig = mapContainer.getMapConfig().getMaxSizeConfig();
    MaxSizeConfig.MaxSizePolicy maxSizePolicy = maxSizeConfig.getMaxSizePolicy();
    String mapName = mapContainer.getName();
    if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_NODE || maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
        int totalSize = 0;
        for (int i = 0; i < nodeEngine.getPartitionService().getPartitionCount(); i++) {
            Address owner = nodeEngine.getPartitionService().getPartitionOwner(i);
            if (nodeEngine.getThisAddress().equals(owner)) {
                int size = partitionContainers[i].getRecordStore(mapName).getRecords().size();
                if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
                    if (size >= maxSizeConfig.getSize())
                        return true;
                } else {
                    totalSize += size;
                }
            }
        }
        if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_NODE)
            return totalSize >= maxSizeConfig.getSize();
        else
            return false;
    }
    if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_SIZE || maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_PERCENTAGE) {
        long total = Runtime.getRuntime().totalMemory();
        long used = (total - Runtime.getRuntime().freeMemory());
        if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_SIZE) {
            return maxSizeConfig.getSize() > (used / 1024 / 1024);
        } else {
            return maxSizeConfig.getSize() > (used / total);
        }
    }
    return false;
}

Output:
                 if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
-                    if (size >= maxSizeConfig.getSize())
+                    if (size >= maxSize)
                         return true;


Input:
public PImage createImage(int wide, int high, int format) {
    PImage image = new PImage(wide, high, format);
    image.parent = this;
    if (g instanceof PGraphicsAndroid3D) {
        image.format = ARGB;
        image.initTexture();
    }
    return image;
}

Output:
     if (g instanceof PGraphicsAndroid3D) {
-        image.format = ARGB;
-        image.initTexture();
+        image.format = params.format;
+        image.initTexture(params);
     }


Input:
public void write(K key, V value) throws IOException {
    long startTime = System.nanoTime();
    String stringValue = gson.toJson(value) + "String_Node_Str";
    byteChannel.write(ByteBuffer.wrap(stringValue.getBytes(StandardCharsets.UTF_8)));
    long duration = System.nanoTime() - startTime;
    increment(Counter.WRITE_CALLS);
    increment(Counter.WRITE_TOTAL_TIME, duration);
}

Output:
     String stringValue = gson.toJson(value) + "String_Node_Str";
-    byteChannel.write(ByteBuffer.wrap(stringValue.getBytes(StandardCharsets.UTF_8)));
+    byte[] valueBytes = stringValue.getBytes(StandardCharsets.UTF_8);
+    bytesWritten += valueBytes.length;
+    byteChannel.write(ByteBuffer.wrap(valueBytes));
     long duration = System.nanoTime() - startTime;


Input:
public int getNumberOfCoveredSegments() {
    if (executionCount == 0) {
        return 0;
    }
    if (noBranchesYet()) {
        return 1;
    }
    return getSegmentsCovered();
}

Output:
 public int getNumberOfCoveredSegments() {
-    if (executionCount == 0) {
-        return 0;
-    }
-    if (noBranchesYet()) {
-        return 1;
-    }
-    return getSegmentsCovered();
+    return noBranchesYet() ? 1 : getSegmentsCovered();
 }