Input:
public void run() {
    for (IRFunction irFunction : ir.getFuncs().values()) {
        FuncInfo funcInfo = new FuncInfo();
        for (PhysicalRegister preg : irFunction.getUsedPhysicalGeneralRegs()) {
            if (preg.isCalleeSave())
                funcInfo.usedCalleeSaveRegs.add(preg);
            if (preg.isCallerSave())
                funcInfo.usedCallerSaveRegs.add(preg);
        }
        funcInfo.usedCalleeSaveRegs.add(rbx);
        funcInfo.usedCalleeSaveRegs.add(rbp);
        funcInfo.numStackSlot = irFunction.getStackSlots().size();
        for (int i = 0; i < funcInfo.numStackSlot; ++i) {
            funcInfo.stackSlotOffsetMap.put(irFunction.getStackSlots().get(i), i * Configuration.getRegSize());
        }
        if ((funcInfo.usedCalleeSaveRegs.size() + funcInfo.numStackSlot) % 2 == 0) {
            ++funcInfo.numStackSlot;
        }
        funcInfo.numExtraArgs = irFunction.getArgVRegList().size() - 6;
        if (funcInfo.numExtraArgs < 0)
            funcInfo.numExtraArgs = 0;
        int extraArgOffset = (funcInfo.usedCalleeSaveRegs.size() + funcInfo.numStackSlot + 1) * Configuration.getRegSize();
        for (int i = 6; i < irFunction.getArgVRegList().size(); ++i) {
            funcInfo.stackSlotOffsetMap.put(irFunction.getArgsStackSlotMap().get(irFunction.getArgVRegList().get(i)), extraArgOffset);
            extraArgOffset += Configuration.getRegSize();
        }
        funcInfoMap.put(irFunction, funcInfo);
    }
    for (IRFunction builtinFunc : ir.getBuiltInFuncs().values()) {
        funcInfoMap.put(builtinFunc, new FuncInfo());
    }
    for (IRFunction irFunction : funcInfoMap.keySet()) {
        FuncInfo funcInfo = funcInfoMap.get(irFunction);
        funcInfo.recursiveUsedRegs.addAll(irFunction.getUsedPhysicalGeneralRegs());
        for (IRFunction calleeFunc : irFunction.recursiveCalleeSet) {
            funcInfo.recursiveUsedRegs.addAll(calleeFunc.getUsedPhysicalGeneralRegs());
        }
    }
    for (IRFunction irFunction : ir.getFuncs().values()) {
        FuncInfo funcInfo = funcInfoMap.get(irFunction);
        BasicBlock entryBB = irFunction.getStartBB();
        IRInstruction firstInst = entryBB.getFirstInst();
        for (PhysicalRegister preg : funcInfo.usedCalleeSaveRegs) {
            firstInst.prependInst(new IRPush(entryBB, preg));
        }
        if (funcInfo.numStackSlot > 0)
            firstInst.prependInst(new IRBinaryOperation(entryBB, rsp, IRBinaryOperation.IRBinaryOp.SUB, rsp, new IntImmediate(funcInfo.numStackSlot * Configuration.getRegSize())));
        firstInst.prependInst(new IRMove(entryBB, rbp, rsp));
        for (BasicBlock bb : irFunction.getReversePostOrder()) {
            for (IRInstruction inst = bb.getFirstInst(); inst != null; inst = inst.getNextInst()) {
                if (inst instanceof IRFunctionCall) {
                    IRFunction calleeFunc = ((IRFunctionCall) inst).getFunc();
                    FuncInfo calleeInfo = funcInfoMap.get(calleeFunc);
                    int numPushCallerSave = 0;
                    for (PhysicalRegister preg : funcInfo.usedCallerSaveRegs) {
                        if (calleeInfo.recursiveUsedRegs.contains(preg)) {
                            ++numPushCallerSave;
                            inst.prependInst(new IRPush(inst.getParentBB(), preg));
                        }
                    }
                    int numPushArg6Regs = irFunction.getArgVRegList().size() <= 6 ? irFunction.getArgVRegList().size() : 6;
                    for (int i = 0; i < numPushArg6Regs; ++i) {
                        inst.prependInst(new IRPush(inst.getParentBB(), arg6.get(i)));
                    }
                    numPushCallerSave += numPushArg6Regs;
                    boolean extraPush = false;
                    List<RegValue> args = ((IRFunctionCall) inst).getArgs();
                    List<Integer> arg6BakOffset = new ArrayList<>();
                    Map<PhysicalRegister, Integer> arg6BakOffsetMap = new HashMap<>();
                    if ((numPushCallerSave + calleeInfo.numExtraArgs) % 2 == 1) {
                        extraPush = true;
                        inst.prependInst(new IRPush(inst.getParentBB(), new IntImmediate(0)));
                    }
                    for (int i = args.size() - 1; i > 5; --i) {
                        if (args.get(i) instanceof StackSlot) {
                            inst.prependInst(new IRLoad(inst.getParentBB(), rax, Configuration.getRegSize(), rbp, funcInfo.stackSlotOffsetMap.get(args.get(i))));
                            inst.prependInst(new IRPush(inst.getParentBB(), rax));
                        } else {
                            inst.prependInst(new IRPush(inst.getParentBB(), args.get(i)));
                        }
                    }
                    int bakOffset = 0;
                    for (int i = 0; i < 6; ++i) {
                        if (args.size() <= i)
                            break;
                        if (args.get(i) instanceof PhysicalRegister && ((PhysicalRegister) args.get(i)).isArg6() && ((PhysicalRegister) args.get(i)).getArg6Idx() < args.size()) {
                            PhysicalRegister preg = (PhysicalRegister) args.get(i);
                            if (arg6BakOffsetMap.containsKey(preg)) {
                                arg6BakOffset.add(arg6BakOffsetMap.get(preg));
                            } else {
                                arg6BakOffset.add(bakOffset);
                                arg6BakOffsetMap.put(preg, bakOffset);
                                inst.prependInst(new IRPush(inst.getParentBB(), preg));
                                ++bakOffset;
                            }
                        } else {
                            arg6BakOffset.add(-1);
                        }
                    }
                    for (int i = 0; i < 6; ++i) {
                        if (args.size() <= i)
                            break;
                        if (arg6BakOffset.get(i) == -1) {
                            if (args.get(i) instanceof StackSlot) {
                                inst.prependInst(new IRLoad(inst.getParentBB(), rax, Configuration.getRegSize(), rbp, funcInfo.stackSlotOffsetMap.get(args.get(i))));
                                inst.prependInst(new IRMove(inst.getParentBB(), arg6.get(i), rax));
                            } else {
                                inst.prependInst(new IRMove(inst.getParentBB(), arg6.get(i), args.get(i)));
                            }
                        } else {
                            inst.prependInst(new IRLoad(inst.getParentBB(), arg6.get(i), Configuration.getRegSize(), rbp, Configuration.getRegSize() * (bakOffset - arg6BakOffset.get(i) - 1)));
                        }
                    }
                    if (bakOffset > 0) {
                        inst.prependInst(new IRBinaryOperation(inst.getParentBB(), rsp, IRBinaryOperation.IRBinaryOp.ADD, rsp, new IntImmediate(bakOffset * Configuration.getRegSize())));
                    }
                    if (((IRFunctionCall) inst).getDest() != null) {
                        inst.appendInst(new IRMove(inst.getParentBB(), ((IRFunctionCall) inst).getDest(), rax));
                    }
                    for (PhysicalRegister preg : funcInfo.usedCallerSaveRegs) {
                        if (calleeInfo.recursiveUsedRegs.contains(preg)) {
                            inst.appendInst(new IRPop(inst.getParentBB(), preg));
                        }
                    }
                    for (int i = 0; i < numPushArg6Regs; ++i) {
                        inst.appendInst(new IRPop(inst.getParentBB(), arg6.get(i)));
                    }
                    if (calleeInfo.numExtraArgs > 0 || extraPush) {
                        int numPushArg = extraPush ? calleeInfo.numExtraArgs + 1 : calleeInfo.numExtraArgs;
                        inst.appendInst(new IRBinaryOperation(inst.getParentBB(), rsp, IRBinaryOperation.IRBinaryOp.ADD, rsp, new IntImmediate(numPushArg * Configuration.getRegSize())));
                    }
                } else if (inst instanceof IRHeapAlloc) {
                    int numPushCallerSave = 0;
                    for (PhysicalRegister preg : funcInfo.usedCallerSaveRegs) {
                        ++numPushCallerSave;
                        inst.prependInst(new IRPush(inst.getParentBB(), preg));
                    }
                    inst.prependInst(new IRMove(inst.getParentBB(), rdi, ((IRHeapAlloc) inst).getAllocSize()));
                    if (numPushCallerSave % 2 == 1) {
                        inst.prependInst(new IRPush(inst.getParentBB(), new IntImmediate(0)));
                    }
                    inst.appendInst(new IRMove(inst.getParentBB(), ((IRHeapAlloc) inst).getDest(), rax));
                    for (PhysicalRegister preg : funcInfo.usedCallerSaveRegs) {
                        inst.appendInst(new IRPop(inst.getParentBB(), preg));
                    }
                    if (numPushCallerSave % 2 == 1) {
                        inst.appendInst(new IRBinaryOperation(inst.getParentBB(), rsp, IRBinaryOperation.IRBinaryOp.ADD, rsp, new IntImmediate(Configuration.getRegSize())));
                    }
                } else if (inst instanceof IRLoad) {
                    if (((IRLoad) inst).getAddr() instanceof StackSlot) {
                        ((IRLoad) inst).setAddrOffset(funcInfo.stackSlotOffsetMap.get(((IRLoad) inst).getAddr()));
                        ((IRLoad) inst).setAddr(rbp);
                    }
                } else if (inst instanceof IRStore) {
                    if (((IRStore) inst).getAddr() instanceof StackSlot) {
                        ((IRStore) inst).setAddrOffset(funcInfo.stackSlotOffsetMap.get(((IRStore) inst).getAddr()));
                        ((IRStore) inst).setAddr(rbp);
                    }
                } else if (inst instanceof IRMove) {
                    if (((IRMove) inst).getLhs() == ((IRMove) inst).getRhs()) {
                        inst.remove();
                    }
                }
            }
        }
        IRReturn retInst = irFunction.getRetInstList().get(0);
        if (retInst.getRetValue() != null) {
            retInst.prependInst(new IRMove(retInst.getParentBB(), rax, retInst.getRetValue()));
        }
        BasicBlock exitBB = irFunction.getEndBB();
        IRInstruction lastInst = exitBB.getLastInst();
        if (funcInfo.numStackSlot > 0)
            lastInst.prependInst(new IRBinaryOperation(entryBB, rsp, IRBinaryOperation.IRBinaryOp.ADD, rsp, new IntImmediate(funcInfo.numStackSlot * Configuration.getRegSize())));
        for (int i = funcInfo.usedCalleeSaveRegs.size() - 1; i >= 0; --i) {
            lastInst.prependInst(new IRPop(entryBB, funcInfo.usedCalleeSaveRegs.get(i)));
        }
    }
}

Output:
                         } else {
-                            inst.prependInst(new IRLoad(inst.getParentBB(), arg6.get(i), Configuration.getRegSize(), rbp, Configuration.getRegSize() * (bakOffset - arg6BakOffset.get(i) - 1)));
+                            inst.prependInst(new IRLoad(inst.getParentBB(), arg6.get(i), Configuration.getRegSize(), rsp, Configuration.getRegSize() * (bakOffset - arg6BakOffset.get(i) - 1)));
                         }


Input:
public org.hl7.fhir.dstu2.model.MedicationOrder.MedicationOrderDispenseRequestComponent convertMedicationOrderDispenseRequestComponent(org.hl7.fhir.dstu3.model.MedicationOrder.MedicationOrderDispenseRequestComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.MedicationOrder.MedicationOrderDispenseRequestComponent tgt = new org.hl7.fhir.dstu2.model.MedicationOrder.MedicationOrderDispenseRequestComponent();
    copyElement(src, tgt);
    tgt.setValidityPeriod(convertPeriod(src.getValidityPeriod()));
    tgt.setNumberOfRepeatsAllowed(src.getNumberOfRepeatsAllowed());
    tgt.setQuantity(convertSimpleQuantity(src.getQuantity()));
    tgt.setExpectedSupplyDuration(convertDuration(src.getExpectedSupplyDuration()));
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.MedicationOrder.MedicationOrderDispenseRequestComponent convertMedicationOrderDispenseRequestComponent(org.hl7.fhir.dstu3.model.MedicationOrder.MedicationOrderDispenseRequestComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public boolean callWithNextKey(MatchStub matchFunction, Collector collector) throws Exception {
    final Environment env = this.environment;
    final OutputCollector oc = (OutputCollector) collector;
    if (this.hashJoin.nextRecord()) {
        final HashJoin.HashBucketIterator buildSideIterator = this.hashJoin.getBuildSideIterator();
        PactRecord probeRecord = this.hashJoin.getCurrentProbeRecord();
        PactRecord nextBuildSidePair = this.nextBuildSideObject;
        if (buildSideIterator.next(nextBuildSidePair)) {
            PactRecord tmpPair = new PactRecord();
            if (buildSideIterator.next(tmpPair)) {
                probeRecord.copyTo(this.probeCopy);
                long r1 = probeRecord.getBinaryLength();
                long r2 = nextBuildSidePair.getBinaryLength();
                matchFunction.match(probeRecord, nextBuildSidePair, collector);
                env.reportPACTDataStatistics(r1 + r2, oc.getCollectedPactRecordsInBytes());
                probeRecord = new PactRecord();
                this.probeCopy.copyTo(probeRecord);
                r1 = probeRecord.getBinaryLength();
                r2 = tmpPair.getBinaryLength();
                matchFunction.match(probeRecord, tmpPair, collector);
                env.reportPACTDataStatistics(r1 + r2, oc.getCollectedPactRecordsInBytes());
                tmpPair = new PactRecord();
                while (this.running && buildSideIterator.next(tmpPair)) {
                    probeRecord = new PactRecord();
                    this.probeCopy.copyTo(probeRecord);
                    r1 = probeRecord.getBinaryLength();
                    r2 = tmpPair.getBinaryLength();
                    matchFunction.match(probeRecord, tmpPair, collector);
                    env.reportPACTDataStatistics(r1 + r2, oc.getCollectedPactRecordsInBytes());
                    tmpPair = new PactRecord();
                }
                this.nextBuildSideObject = tmpPair;
            } else {
                this.nextBuildSideObject = tmpPair;
                final long r1 = probeRecord.getBinaryLength();
                final long r2 = nextBuildSidePair.getBinaryLength();
                matchFunction.match(probeRecord, nextBuildSidePair, collector);
                env.reportPACTDataStatistics(r1 + r2, oc.getCollectedPactRecordsInBytes());
            }
        }
        return true;
    } else {
        return false;
    }
}

Output:
                 matchFunction.match(probeRecord, nextBuildSidePair, collector);
-                env.reportPACTDataStatistics(r1 + r2, oc.getCollectedPactRecordsInBytes());
+                env.reportPACTDataStatistics(r1 + r2, collector.getCollectedPactRecordsInBytes());
                 probeRecord = new PactRecord();


Input:
public void transactionsNotCommittedShouldNotReflectInCachedChangeFeed() {
    registerSingleModuleAndCreateReader();
    performChangesWithException();
    Collection<ChangeSet> changes = new CachingGraphChangeReader(getDatabase()).getAllChanges();
    assertEquals(2, changes.size());
    Iterator<ChangeSet> it = changes.iterator();
    ChangeSet set1 = it.next();
    long set1Date = set1.getTimestamp();
    assertEquals(1, set1.getChanges().size());
    assertTrue(set1.getChanges().contains("String_Node_Str"));
    assertEquals(set1.getSequence(), 2);
    ChangeSet set2 = it.next();
    long set2Date = set2.getTimestamp();
    assertEquals(3, set2.getChanges().size());
    assertTrue(set2.getChanges().contains("String_Node_Str"));
    assertTrue(set2.getChanges().contains("String_Node_Str"));
    assertTrue(set2.getChanges().contains("String_Node_Str"));
    assertEquals(1, set2.getSequence());
    assertTrue(set1Date >= set2Date);
}

Output:
 public void transactionsNotCommittedShouldNotReflectInCachedChangeFeed() {
-    registerSingleModuleAndCreateReader();
+    registerSingleModuleAndStart();
     performChangesWithException();


Input:
public static void main(String[] args) {
    GameMap gameMap = new GameMap(MapDriver.readMap("String_Node_Str"));
    ConsolePrinter.printMap(gameMap);
    Score score = new Score();
    score.init(gameMap, Color.BLACK);
    Analyzer analyzer = new Analyzer(gameMap, Color.WHITE, gameMap.getNeighbor(), score, false);
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getFiveAttack());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getFourAttack());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getFourDefence());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getThreeOpenAttack());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getThreeDefence());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getTwoAttack());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getNotKey());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getFourCloseDefence());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getDoubleFourCloseDefence());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getThreeOpenDefence());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getDoubleThreeOpenDefense());
    System.out.println("String_Node_Str");
    System.out.println(analyzer.getFourCloseAndOpenThreeDefense());
}

Output:
 public static void main(String[] args) {
-    GameMap gameMap = new GameMap(MapDriver.readMap("String_Node_Str"));
+    GameMap gameMap = new GameMap(MapDriver.readMap());
     ConsolePrinter.printMap(gameMap);


Input:
public void setImitator(BubbleView bubbleView) {
    mImitator = bubbleView;
    if (mImitator != null) {
        String tag = (String) mFavicon.getTag();
        Drawable drawable = mFavicon.getDrawable();
        if (tag != null && drawable != null) {
            mImitator.setFavicon(((BitmapDrawable) drawable).getBitmap(), tag);
        } else {
            setFallbackFavicon();
        }
        mImitator.mProgressIndicator.setProgress(mProgressIndicator.isIndicatorShowing(), mProgressIndicator.getProgress(), mUrl);
    }
}

Output:
         } else {
-            setFallbackFavicon();
+            mImitator.setFallbackFavicon();
         }


Input:
public void testNotLike() {
    String[] script = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    boolean[] result = new boolean[] { false, false, false, false, false, true };
    for (int i = 0; i < script.length; i++) {
        assertTrue(((Boolean) cx.evaluateString(scope, script[i], "String_Node_Str", 1, null)).booleanValue() == result[i]);
        System.out.println(i);
    }
}

Output:
 public void testNotLike() {
-    String[] script = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
-    boolean[] result = new boolean[] { false, false, false, false, false, true };
+    String[] script = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+    boolean[] result = new boolean[] { false, false, false, false, false, true, true, true, false, true, false, true };
     for (int i = 0; i < script.length; i++) {


Input:
private boolean _matchCompositeEntity(CompositeEntity lhsEntity, CompositeEntity hostEntity) {
    int matchSize = _match.size();
    FastLinkedList<MarkedEntityList> lhsMarkedList = new FastLinkedList<MarkedEntityList>();
    ComponentEntity lhsNextActor = _findFirstChild(lhsEntity, lhsMarkedList, _match.keySet());
    boolean success = true;
    boolean firstEntrance = !_match.containsKey(lhsEntity);
    if (firstEntrance) {
        _match.put(lhsEntity, hostEntity);
        if (lhsEntity instanceof CompositeActor && ((CompositeActor) lhsEntity).isOpaque()) {
            Director lhsDirector = ((CompositeActor) lhsEntity).getDirector();
            if (hostEntity instanceof CompositeActor && ((CompositeActor) hostEntity).isOpaque()) {
                Director hostDirector = ((CompositeActor) hostEntity).getDirector();
                success = _matchDirector(lhsDirector, hostDirector);
            } else {
                success = false;
            }
        }
    }
    if (success) {
        if (lhsNextActor != null) {
            int matchSize2 = _match.size();
            FastLinkedList<Object>.Entry lhsTail = _lhsFrontier.getTail();
            FastLinkedList<Object>.Entry hostTail = _hostFrontier.getTail();
            FastLinkedList<CompositeEntity>.Entry compositeTail = null;
            if (firstEntrance) {
                _visitedLHSCompositeEntities.add(lhsEntity);
                compositeTail = _visitedLHSCompositeEntities.getTail();
            }
            FastLinkedList<MarkedEntityList> hostMarkedList = new FastLinkedList<MarkedEntityList>();
            ComponentEntity hostNextActor = _findFirstChild(hostEntity, hostMarkedList, _match.values());
            success = false;
            while (!success && hostNextActor != null) {
                _lhsFrontier.add(lhsNextActor);
                _lhsObjects.add(lhsNextActor);
                _hostFrontier.add(hostNextActor);
                if (_matchEntryList(lhsTail.getNext(), hostTail.getNext())) {
                    success = true;
                } else {
                    _match.retain(matchSize2);
                    _hostFrontier.removeAllAfter(hostTail);
                    _lhsFrontier.removeAllAfter(lhsTail);
                    if (firstEntrance) {
                        _visitedLHSCompositeEntities.removeAllAfter(compositeTail);
                    }
                    hostNextActor = _findNextChild(hostEntity, hostMarkedList, _match.values());
                }
            }
            if (!success && firstEntrance) {
                compositeTail.remove();
            }
        } else {
            success = _lhsObjects.size() == _match.size() ? _callback.foundMatch(this) : true;
        }
    }
    if (!success && firstEntrance) {
        _match.retain(matchSize);
    }
    return success;
}

Output:
         _match.put(lhsEntity, hostEntity);
-        if (lhsEntity instanceof CompositeActor && ((CompositeActor) lhsEntity).isOpaque()) {
-            Director lhsDirector = ((CompositeActor) lhsEntity).getDirector();
-            if (hostEntity instanceof CompositeActor && ((CompositeActor) hostEntity).isOpaque()) {
-                Director hostDirector = ((CompositeActor) hostEntity).getDirector();
+        if (lhsEntity instanceof CompositeActor) {
+            CompositeActor lhsComposite = (CompositeActor) lhsEntity;
+            Director lhsDirector = lhsComposite.isOpaque() ? lhsComposite.getDirector() : null;
+            if (hostEntity instanceof CompositeActor) {
+                CompositeActor hostComposite = (CompositeActor) hostEntity;
+                Director hostDirector = hostComposite.isOpaque() ? hostComposite.getDirector() : null;
                 success = _matchDirector(lhsDirector, hostDirector);


Input:
private void handleIncomingData(LttngEvent e) {
    long eventTime = e.getTimestamp().getValue();
    ITmfTrace inTrace = e.getTrace();
    LttngTraceState traceModel = traceToTraceStateModel.get(inTrace);
    updateSynEvent(e);
    if (eventTime >= dispatchTime && eventIndex >= dispatchIndex) {
        syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
        fmainRequest.handleData(syntheticEvent);
        syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
        fstateUpdateProcessor.process(syntheticEvent, traceModel);
        syntheticEvent.setSequenceInd(SequenceInd.AFTER);
        fmainRequest.handleData(syntheticEvent);
    } else {
        syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
        fstateUpdateProcessor.process(syntheticEvent, traceModel);
    }
    eventIndex++;
}

Output:
     long eventTime = e.getTimestamp().getValue();
-    ITmfTrace inTrace = e.getTrace();
+    ITmfTrace<?> inTrace = e.getTrace();
     LttngTraceState traceModel = traceToTraceStateModel.get(inTrace);


Input:
public byte[] getExternalPub(int hdSeedId) {
    byte[] pub = null;
    try {
        SQLiteDatabase db = this.mDb.getReadableDatabase();
        Cursor c = db.rawQuery("String_Node_Str", new String[] { Integer.toString(hdSeedId) });
        if (c.moveToNext()) {
            int idColumn = c.getColumnIndex(AbstractDb.HDAccountColumns.ENCRYPT_SEED);
            if (idColumn != -1) {
                String pubStr = c.getString(idColumn);
                pub = Base58.decode(pubStr);
            }
        }
    } catch (AddressFormatException e) {
        e.printStackTrace();
    }
    return pub;
}

Output:
         if (c.moveToNext()) {
-            int idColumn = c.getColumnIndex(AbstractDb.HDAccountColumns.ENCRYPT_SEED);
+            int idColumn = c.getColumnIndex(AbstractDb.HDAccountColumns.EXTERNAL_PUB);
             if (idColumn != -1) {


Input:
private void doElse(ScriptEntry scriptEntry) {
    String elseCommand = ((String) scriptEntry.getObject("String_Node_Str")).toUpperCase();
    String[] elseArgs = Arrays.copyOf((Object[]) scriptEntry.getObject("String_Node_Str"), ((Object[]) scriptEntry.getObject("String_Node_Str")).length, String[].class);
    try {
        denizen.getScriptEngine().getScriptExecuter().execute(new ScriptEntry(elseCommand, elseArgs, scriptEntry.getPlayer(), scriptEntry.getNPC(), scriptEntry.getScript(), scriptEntry.getStep()));
    } catch (ScriptEntryCreationException e) {
        dB.echoError("String_Node_Str");
        if (dB.showStackTraces) {
            dB.echoDebug("String_Node_Str");
            e.printStackTrace();
        } else
            dB.echoDebug("String_Node_Str");
    }
}

Output:
 private void doElse(ScriptEntry scriptEntry) {
-    String elseCommand = ((String) scriptEntry.getObject("String_Node_Str")).toUpperCase();
-    String[] elseArgs = Arrays.copyOf((Object[]) scriptEntry.getObject("String_Node_Str"), ((Object[]) scriptEntry.getObject("String_Node_Str")).length, String[].class);
+    String elseCommand = null;
+    if (scriptEntry.getObject("String_Node_Str") != null)
+        elseCommand = ((String) scriptEntry.getObject("String_Node_Str")).toUpperCase();
+    String[] elseArgs = null;
+    if (scriptEntry.getObject("String_Node_Str") != null)
+        elseArgs = Arrays.copyOf((Object[]) scriptEntry.getObject("String_Node_Str"), ((Object[]) scriptEntry.getObject("String_Node_Str")).length, String[].class);
+    if (elseCommand == null)
+        return;
     try {


Input:
public List<CodeGeneratorConfig> getCodeGenerators() {
    List<CodeGeneratorConfig> list = new ArrayList<>();
    for (TableItem item : generatorsTable.getItems()) {
        list.add((CodeGeneratorConfig) item.getData());
    }
    return list;
}

Output:
 public List<CodeGeneratorConfig> getCodeGenerators() {
-    List<CodeGeneratorConfig> list = new ArrayList<>();
+    List<CodeGeneratorConfig> list = new ArrayList<CodeGeneratorConfig>();
     for (TableItem item : generatorsTable.getItems()) {


Input:
public void process() {
    PerformanceMonitor.startActivity("String_Node_Str");
    prePostComposite.enable();
    sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
    sceneOpaquePingPong = dynamicFBOsManager.get(DefaultDynamicFBOs.WriteOnlyGBuffer.getName());
    sceneReflectiveRefractive = dynamicFBOsManager.get(REFLECTIVE_REFRACTIVE_URN);
    sceneOpaquePingPong.bind();
    setViewportToSizeOf(sceneOpaquePingPong);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    renderFullscreenQuad();
    bindDisplay();
    setViewportToSizeOf(sceneOpaque);
    dynamicFBOsManager.swap(DefaultDynamicFBOs.WriteOnlyGBuffer.getName(), DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
    sceneOpaque.attachDepthBufferTo(sceneReflectiveRefractive);
    PerformanceMonitor.endActivity();
}

Output:
     prePostComposite.enable();
-    sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
-    sceneOpaquePingPong = dynamicFBOsManager.get(DefaultDynamicFBOs.WriteOnlyGBuffer.getName());
+    sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.READ_ONLY_GBUFFER.getName());
+    sceneOpaquePingPong = dynamicFBOsManager.get(DefaultDynamicFBOs.WRITE_ONLY_GBUFFER.getName());
     sceneReflectiveRefractive = dynamicFBOsManager.get(REFLECTIVE_REFRACTIVE_URN);


Input:
public boolean hasTableSubheader(Cell[][] cells, Table table) {
    boolean hasSubheader = false;
    if (table.getNum_of_columns() < 2)
        return false;
    for (int i = 1; i < cells.length; i++) {
        if (cells[i][0].isIs_columnspanning() && table.getNum_of_columns() > 1 && cells[i][0].getCells_columnspanning() >= table.getNum_of_columns() && !cells[i][0].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !cells[i][0].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !(((int) cells[i][0].getCell_content().trim().charAt(0)) == 160)) {
            hasSubheader = true;
            break;
        }
        boolean emptyCells = true;
        for (int j = 1; j < cells[i].length; j++) {
            if (cells[i][j].getCell_content() == null) {
                cells[i][j].setCell_content("String_Node_Str");
            }
            if (!cells[i][0].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !cells[i][0].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !(((int) cells[i][0].getCell_content().trim().charAt(0)) == 160) && (!cells[i][j].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !cells[i][j].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !(((int) cells[i][j].getCell_content().trim().charAt(0)) == 160))) {
                emptyCells = false;
            }
        }
        if (emptyCells == true) {
            hasSubheader = true;
            break;
        }
    }
    return hasSubheader;
}

Output:
     for (int i = 1; i < cells.length; i++) {
-        if (cells[i][0].isIs_columnspanning() && table.getNum_of_columns() > 1 && cells[i][0].getCells_columnspanning() >= table.getNum_of_columns() && !cells[i][0].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !cells[i][0].getCell_content().trim().equalsIgnoreCase("String_Node_Str") && !(((int) cells[i][0].getCell_content().trim().charAt(0)) == 160)) {
+        if (cells[i][0].isIs_columnspanning() && table.getNum_of_columns() > 1 && cells[i][0].getCells_columnspanning() >= table.getNum_of_columns() && !Utilities.isSpaceOrEmpty(cells[i][0].getCell_content())) {
+            hasSubheader = true;
+            break;
+        }
+        if (Utilities.numOfBegeningSpaces(cells[i][0].getCell_content()) > 0) {
             hasSubheader = true;


Input:
private void addUrlField(RestDocumentation.Resource.Method.UrlFields subs, VariableElement var, String annoValue) {
    String name = (annoValue == null || annoValue.isEmpty()) ? var.getSimpleName().toString() : annoValue;
    subs.addField(name, newJsonType(var.asType()));
}

Output:
     String name = (annoValue == null || annoValue.isEmpty()) ? var.getSimpleName().toString() : annoValue;
-    subs.addField(name, newJsonType(var.asType()));
+    subs.addField(name, jsonTypeFromTypeMirror(var.asType(), new HashSet<DeclaredType>()));
 }


Input:
public void onEventMainThread(NotificationEvents.NotificationsSettingsStatusChanged event) {
    if (TextUtils.isEmpty(event.getMessage())) {
        mMessageTextView.setVisibility(View.GONE);
    } else {
        mMessageTextView.setVisibility(View.VISIBLE);
        mMessageTextView.setText(event.getMessage());
    }
}

Output:
     if (TextUtils.isEmpty(event.getMessage())) {
-        mMessageTextView.setVisibility(View.GONE);
+        mMessageContainer.setVisibility(View.GONE);
     } else {


Input:
private void loadInputStream() {
    try {
        InputStream is = getContentResolver().openInputStream(stream);
        byte[] data = null;
        data = readBytesAndClose(is);
        String title = stream.getLastPathSegment();
        String body = stream.getPath();
        mDbHelper.createNote(title, body, data);
        data = null;
        Toast.makeText(this, "String_Node_Str" + title, Toast.LENGTH_LONG).show();
        mDbHelper.close();
        handleDelete();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (OutOfMemoryError e) {
        Toast.makeText(this, "String_Node_Str", Toast.LENGTH_LONG).show();
    } finally {
    }
}

Output:
         InputStream is = getContentResolver().openInputStream(stream);
-        byte[] data = null;
-        data = readBytesAndClose(is);
+        String mimeType = getContentResolver().getType(stream);
+        byte[] data = readBytesAndClose(is);
         String title = stream.getLastPathSegment();


Input:
public Connection getConnection(Address address) throws IOException {
    checkLive();
    if (address == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    final ObjectPool<ConnectionWrapper> pool = getConnectionPool(address);
    if (pool == null) {
        return null;
    }
    Connection connection = null;
    try {
        connection = pool.take();
    } catch (Exception e) {
        logger.log(Level.WARNING, "String_Node_Str", e);
    }
    if (connection != null && !heartbeat.checkHeartBeat(connection)) {
        connection.close();
        connection = null;
    }
    return connection;
}

Output:
     } catch (Exception e) {
-        logger.log(Level.WARNING, "String_Node_Str", e);
+        logger.log(Level.WARNING, "String_Node_Str" + address, e);
     }


Input:
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    BaseModel other = (BaseModel) obj;
    if (this.getUuid() == null) {
        if (other.getUuid() != null)
            return false;
    } else if (!this.getUuid().equals(other.getUuid()))
        return false;
    return true;
}

Output:
 public boolean equals(Object obj) {
-    if (this == obj)
+    if (this == obj) {
         return true;


Input:
private String getItemFullPath(Property property) {
    Item item = property.getItem();
    IPath path = null;
    String fileName = null;
    EElementEName elementEName = EElementEName.getElementEName(item);
    if (elementEName != null) {
        URI uri = EObjectHelper.getURI(property);
        path = new Path(uri.toPlatformString(false));
        path = new Path(path.lastSegment());
        fileName = path.removeFileExtension().addFileExtension(elementEName.getFileExt()).toString();
    }
    IPath typedPath = ResourceManager.getRootProject().getFolder(PropertyHelper.getItemTypedPath(item)).getLocation();
    String fullpath = typedPath.toOSString() + "String_Node_Str" + fileName;
    return fullpath;
}

Output:
     }
-    IPath typedPath = ResourceManager.getRootProject().getFolder(PropertyHelper.getItemTypedPath(item)).getLocation();
-    String fullpath = typedPath.toOSString() + "String_Node_Str" + fileName;
+    String fileName = item.getName() + "String_Node_Str" + item.getProperty().getVersion() + "String_Node_Str" + item.getExtension();
+    IPath typedPath = ResourceManager.getSourceFileFolder().getLocation();
+    String fullpath = typedPath.toOSString() + statePathStr + "String_Node_Str" + fileName;
     return fullpath;


Input:
private List<ManagedObjectReference> getSharedDatastoreInt() throws Exception {
    AuAssert.check(VcContext.isInSession());
    List<HostSystem> hostList = MoUtil.getManagedObjects(host);
    List<ManagedObjectReference> results = new ArrayList<ManagedObjectReference>();
    DatastoreInfo[] candidateList = null;
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    if (hostList.size() == 0) {
        return results;
    }
    for (HostSystem h : hostList) {
        DatastoreInfo[] info = h.queryConnectionInfo().getDatastore();
        if (candidateList == null) {
            candidateList = info;
        }
        for (DatastoreInfo n : info) {
            String name = n.getSummary().getName();
            Integer count = map.get(name);
            if (count != null) {
                map.put(name, count + 1);
            } else {
                map.put(name, Integer.valueOf(1));
            }
        }
    }
    for (DatastoreInfo n : candidateList) {
        if (map.get(n.getSummary().getName()).equals(hostList.size())) {
            results.add(n.getSummary().getDatastore());
        }
    }
    return results;
}

Output:
     }
-    for (DatastoreInfo n : candidateList) {
-        if (map.get(n.getSummary().getName()).equals(hostList.size())) {
-            results.add(n.getSummary().getDatastore());
+    if (candidateList != null) {
+        for (DatastoreInfo n : candidateList) {
+            if (map.get(n.getSummary().getName()).equals(hostList.size())) {
+                results.add(n.getSummary().getDatastore());
+            }
         }


Input:
public C call() throws Exception {
    run.run();
    f.set(null);
    return null;
}

Output:
 public C call() throws Exception {
-    run.run();
-    f.set(null);
+    try {
+        run.run();
+        f.set(null);
+    } catch (Exception ex) {
+        f.setException(ex);
+    }
     return null;


Input:
private static void append(StringBuffer sb, JavaScript js) {
    sb.append("String_Node_Str");
    if (js.getSrc() != null) {
        String url;
        try {
            url = ServletFns.encodeURL(js.getSrc());
        } catch (javax.servlet.ServletException ex) {
            throw new UiException(ex);
        }
        sb.append("String_Node_Str").append(url).append('"');
        final String charset = js.getCharset();
        if (charset != null)
            sb.append("String_Node_Str").append(charset).append('"');
        sb.append('>');
    } else {
        sb.append("String_Node_Str").append(js.getContent());
    }
    sb.append("String_Node_Str");
}

Output:
     } else {
-        sb.append("String_Node_Str").append(js.getContent());
+        sb.append("String_Node_Str").append(js.getContent()).append("String_Node_Str");
     }


Input:
public void transferBalance(Transaction transaction) {
    try {
        EthGetBalance result = web3j.ethGetBalance(transaction.getToAddress(), DefaultBlockParameterName.LATEST).send();
        BigInteger needBalance = TransactionService.DEFAULT_GAS_LIMIT.multiply(TransactionService.DEFAULT_GAS_PRICE);
        BigInteger sendBalance = result.getBalance().subtract(needBalance);
        if (sendGasIfNull(transaction, result, needBalance)) {
            return;
        }
        String contractAddress = getContractAddressByTokenId(transaction);
        if (!transaction.getTokenId().equals(BigInteger.ZERO)) {
            sendBalance = contractService.balanceOf(contractAddress, transaction.getToAddress());
        }
        sendTransaction(transaction.getToAddress(), defaultUser, contractAddress, sendBalance, false);
    } catch (Exception e) {
        e.printStackTrace();
        log.error(e.getMessage());
    }
}

Output:
         }
-        sendTransaction(transaction.getToAddress(), defaultUser, contractAddress, sendBalance, false);
+        sendTransaction(transaction.getToAddress(), address, contractAddress, sendBalance, false);
     } catch (Exception e) {


Input:
public static void setTableValues(ComponentProperties tableProperties, List<Map<String, Object>> value, IElementParameter param) {
    List<Map<String, String>> table = ElementParameterParser.createTableValues(value, param);
    for (Map<String, String> line : table) {
        for (String column : line.keySet()) {
            Property property = tableProperties.getValuedProperty(column);
            if (property.getValue() instanceof List) {
                ((List) property.getValue()).clear();
            }
        }
    }
    for (Map<String, String> line : table) {
        for (String column : line.keySet()) {
            Property property = tableProperties.getValuedProperty(column);
            List<String> values = new ArrayList<>();
            if (property.getValue() == null || (!(property.getValue() instanceof List))) {
                property.setValue(values);
            } else {
                values = (List) property.getValue();
            }
            values.add(line.get(column));
        }
    }
}

Output:
     List<Map<String, String>> table = ElementParameterParser.createTableValues(value, param);
-    for (Map<String, String> line : table) {
-        for (String column : line.keySet()) {
-            Property property = tableProperties.getValuedProperty(column);
-            if (property.getValue() instanceof List) {
-                ((List) property.getValue()).clear();
-            }
+    for (String column : param.getListItemsDisplayCodeName()) {
+        Property property = tableProperties.getValuedProperty(column);
+        if (property.getValue() instanceof List) {
+            ((List) property.getValue()).clear();
         }


Input:
public void close() throws IOException {
    try {
        if (solrServer != null) {
            solrServer.shutdown();
        }
    } catch (Exception e) {
    }
}

Output:
     try {
-        if (solrServer != null) {
-            solrServer.shutdown();
+        synchronized (this) {
+            if (solrServer != null) {
+                solrServer.shutdown();
+            }
         }


Input:
public void run() {
    try {
        super.run();
        ISelection selection = this.server.getViewer().getSelection();
        TreeObject xobject = (TreeObject) ((IStructuredSelection) selection).getFirstElement();
        server.getSite().getWorkbenchWindow().getActivePage().openEditor(new XObjectBrowserInput(xobject, xobject.getDisplayName()), XObjectRevisionBrowser.ID);
    } catch (Exception e) {
        log.error(e.getStackTrace());
        ErrorExceptionDialog.openError(server.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());
    }
}

Output:
     } catch (Exception e) {
-        log.error(e.getStackTrace());
+        log.error(e.getMessage(), e);
         ErrorExceptionDialog.openError(server.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());


Input:
private void startArticleDetailPager(View view, int position) {
    if (mAdapter.getData().size() <= 0 || mAdapter.getData().size() <= position) {
        return;
    }
    articlePosition = position;
    mOptions = ActivityOptions.makeSceneTransitionAnimation(_mActivity, view, getString(R.string.share_view));
    JudgeUtils.startArticleDetailActivity(_mActivity, mOptions, mAdapter.getData().get(position).getId(), mAdapter.getData().get(position).getTitle().trim(), mAdapter.getData().get(position).getLink().trim(), mAdapter.getData().get(position).isCollect(), false, false);
}

Output:
     articlePosition = position;
-    mOptions = ActivityOptions.makeSceneTransitionAnimation(_mActivity, view, getString(R.string.share_view));
-    JudgeUtils.startArticleDetailActivity(_mActivity, mOptions, mAdapter.getData().get(position).getId(), mAdapter.getData().get(position).getTitle().trim(), mAdapter.getData().get(position).getLink().trim(), mAdapter.getData().get(position).isCollect(), false, false);
+    ActivityOptions options = ActivityOptions.makeSceneTransitionAnimation(_mActivity, view, getString(R.string.share_view));
+    JudgeUtils.startArticleDetailActivity(_mActivity, options, mAdapter.getData().get(position).getId(), mAdapter.getData().get(position).getTitle().trim(), mAdapter.getData().get(position).getLink().trim(), mAdapter.getData().get(position).isCollect(), false, false);
 }


Input:
public void run() {
    IRepositoryView repositoryView = RepositoryManagerHelper.getRepositoryView();
    if (repositoryView != null) {
        repositoryView.refresh();
    }
    if (updatePalette && GlobalServiceRegister.getDefault().isServiceRegistered(ICoreService.class)) {
        ICoreService service = (ICoreService) GlobalServiceRegister.getDefault().getService(ICoreService.class);
        service.updatePalette();
    }
}

Output:
     if (repositoryView != null) {
-        repositoryView.refresh();
+        RepositoryManager.refresh(types);
     }


Input:
public Boolean applyState(Event event, Room.EventDirection direction) {
    if (event.stateKey == null) {
        return false;
    }
    JsonObject contentToConsider = (direction == Room.EventDirection.FORWARDS) ? event.getContentAsJsonObject() : event.getPrevContentAsJsonObject();
    try {
        if (Event.EVENT_TYPE_STATE_ROOM_NAME.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            name = (roomState == null) ? null : roomState.name;
        } else if (Event.EVENT_TYPE_STATE_ROOM_TOPIC.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            topic = (roomState == null) ? null : roomState.topic;
        } else if (Event.EVENT_TYPE_STATE_ROOM_CREATE.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            creator = (roomState == null) ? null : roomState.creator;
        } else if (Event.EVENT_TYPE_STATE_ROOM_JOIN_RULES.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            join_rule = (roomState == null) ? null : roomState.join_rule;
        } else if (Event.EVENT_TYPE_STATE_ROOM_ALIASES.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            aliases = (roomState == null) ? null : roomState.aliases;
        } else if (Event.EVENT_TYPE_STATE_CANONICAL_ALIAS.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            alias = (roomState == null) ? null : roomState.alias;
        } else if (Event.EVENT_TYPE_STATE_HISTORY_VISIBILITY.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            history_visibility = (roomState == null) ? null : roomState.history_visibility;
        } else if (Event.EVENT_TYPE_STATE_ROOM_AVATAR.equals(event.type)) {
            RoomState roomState = JsonUtils.toRoomState(contentToConsider);
            url = (roomState == null) ? null : roomState.url;
        } else if (Event.EVENT_TYPE_STATE_ROOM_MEMBER.equals(event.type)) {
            RoomMember member = JsonUtils.toRoomMember(contentToConsider);
            String userId = event.stateKey;
            if (member == null) {
                if (null == getMember(userId)) {
                    return false;
                }
                removeMember(userId);
            } else {
                member.setUserId(userId);
                member.setOriginServerTs(event.getOriginServerTs());
                member.setInviterId(event.getSender());
                RoomMember currentMember = getMember(userId);
                if (member.equals(currentMember)) {
                    return false;
                }
                if ((direction == Room.EventDirection.FORWARDS)) {
                    if (null != currentMember) {
                        if (member.membership.equals(RoomMember.MEMBERSHIP_LEAVE) || member.membership.equals(RoomMember.MEMBERSHIP_BAN)) {
                            if (null == member.avatarUrl) {
                                member.avatarUrl = currentMember.avatarUrl;
                            }
                        }
                    }
                    updateUser(member);
                }
                setMember(userId, member);
            }
        } else if (Event.EVENT_TYPE_STATE_ROOM_POWER_LEVELS.equals(event.type)) {
            powerLevels = JsonUtils.toPowerLevels(contentToConsider);
        }
    } catch (Exception e) {
    }
    return true;
}

Output:
                     }
-                    updateUser(member);
+                    if (null != mDataHandler) {
+                        ((MXDataHandler) mDataHandler).getStore().updateUserWithRoomMemberEvent(member);
+                    }
                 }


Input:
private void checkConnection() {
    checkButton.setEnabled(false);
    if (connectionItem.getConnection() instanceof DatabaseConnection) {
        DatabaseConnection c = (DatabaseConnection) connectionItem.getConnection();
        if (EDatabaseTypeName.ORACLEFORSID.getProduct().equals(c.getProductId())) {
            if (!isContextMode()) {
                schemaText.setText(schemaText.getText().toUpperCase());
            }
        }
    }
    ManagerConnection managerConnection = new ManagerConnection();
    if (isContextMode()) {
        String urlStr = DBConnectionContextUtils.setManagerConnectionValues(managerConnection, connectionItem, dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()), dbTypeCombo.getSelectionIndex());
        if (urlStr == null) {
            if (dbTypeCombo.getText().equals(EDatabaseConnTemplate.GENERAL_JDBC.getDBDisplayName())) {
                DatabaseConnection dbConn = (DatabaseConnection) connectionItem.getConnection();
                ContextType contextType = ConnectionContextHelper.getContextTypeForContextMode(dbConn);
                urlStr = ConnectionContextHelper.getOriginalValue(contextType, dbConn.getURL());
            } else {
                urlStr = getStringConnection();
            }
        }
        urlConnectionStringText.setText(urlStr);
    } else {
        String versionStr = dbVersionCombo.getText();
        EDatabaseVersion4Drivers version = EDatabaseVersion4Drivers.indexOfByVersionDisplay(versionStr);
        if (version != null) {
            versionStr = version.getVersionValue();
        }
        managerConnection.setValue(0, dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()), isGeneralJDBC() ? generalJdbcUrlText.getText() : urlConnectionStringText.getText(), serverText.getText(), isGeneralJDBC() ? generalJdbcUserText.getText() : usernameText.getText(), isGeneralJDBC() ? generalJdbcPasswordText.getText() : passwordText.getText(), sidOrDatabaseText.getText(), portText.getText(), fileField.getText(), datasourceText.getText(), isGeneralJDBC() ? jDBCschemaText.getText() : schemaText.getText(), additionParamText.getText(), generalJdbcClassNameText.getText(), generalJdbcDriverjarText.getText(), enableDbVersion() ? versionStr : null);
        managerConnection.setDbRootPath(directoryField.getText());
    }
    managerConnection.setValueProperties(sqlSyntaxCombo.getItem(sqlSyntaxCombo.getSelectionIndex()), stringQuoteText.getText(), nullCharText.getText());
    databaseSettingIsValide = managerConnection.check();
    checkButton.setEnabled(true);
    if (databaseSettingIsValide) {
        if (!isReadOnly()) {
            updateStatus(IStatus.OK, null);
        }
        MessageDialog.openInformation(getShell(), Messages.getString("String_Node_Str"), "String_Node_Str" + connectionItem.getProperty().getDisplayName() + "String_Node_Str" + Messages.getString("String_Node_Str"));
        if (!isReadOnly()) {
            if (isContextMode()) {
                adaptFormToEditable();
            } else {
                setPropertiesFormEditable(true);
            }
        }
        String msg = checkDBVersion();
        if (msg != null) {
            updateStatus(IStatus.WARNING, msg);
        }
    } else {
        String mainMsg = Messages.getString("String_Node_Str") + "String_Node_Str" + Messages.getString("String_Node_Str");
        if (!isReadOnly()) {
            updateStatus(IStatus.WARNING, mainMsg);
        }
        new ErrorDialogWidthDetailArea(getShell(), PID, mainMsg, managerConnection.getMessageException());
    }
}

Output:
     if (isContextMode()) {
-        String urlStr = DBConnectionContextUtils.setManagerConnectionValues(managerConnection, connectionItem, dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()), dbTypeCombo.getSelectionIndex());
+        selectedContextType = ConnectionContextHelper.getContextTypeForContextMode(connectionItem.getConnection());
+        String urlStr = DBConnectionContextUtils.setManagerConnectionValues(managerConnection, connectionItem, selectedContextType, dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()), dbTypeCombo.getSelectionIndex());
         if (urlStr == null) {


Input:
public String toJava(int indent, BytecodeMappingTracer tracer) {
    String indstr = InterpreterUtil.getIndentString(indent);
    String indstr1 = null;
    String new_line_separator = DecompilerContext.getNewLineSeparator();
    StringBuilder buf = new StringBuilder();
    buf.append(ExprProcessor.listToJava(varDefinitions, indent, tracer));
    boolean labeled = isLabeled();
    if (labeled) {
        buf.append(indstr).append("String_Node_Str").append(this.id).append("String_Node_Str").append(new_line_separator);
        tracer.incrementSourceLine();
    }
    List<StatEdge> lstSuccs = first.getSuccessorEdges(STATEDGE_DIRECT_ALL);
    if (first.type == TYPE_TRYCATCH && first.varDefinitions.isEmpty() && isFinally && !labeled && !first.isLabeled() && (lstSuccs.isEmpty() || !lstSuccs.get(0).explicit)) {
        String content = ExprProcessor.jmpWrapper(first, indent, true, tracer);
        content = content.substring(0, content.length() - new_line_separator.length());
        buf.append(content);
    } else {
        buf.append(indstr).append("String_Node_Str").append(new_line_separator);
        tracer.incrementSourceLine();
        buf.append(ExprProcessor.jmpWrapper(first, indent + 1, true, tracer));
        buf.append(indstr).append("String_Node_Str");
    }
    buf.append(isFinally ? "String_Node_Str" : "String_Node_Str" + vars.get(0).toJava(indent, tracer) + "String_Node_Str").append("String_Node_Str").append(new_line_separator);
    tracer.incrementSourceLine();
    if (monitor != null) {
        indstr1 = InterpreterUtil.getIndentString(indent + 1);
        buf.append(indstr1).append("String_Node_Str").append(monitor.toJava(indent, tracer)).append("String_Node_Str").append(new_line_separator);
        tracer.incrementSourceLine();
    }
    buf.append(ExprProcessor.jmpWrapper(handler, indent + 1 + (monitor != null ? 1 : 0), true, tracer));
    if (monitor != null) {
        buf.append(indstr1).append("String_Node_Str").append(new_line_separator);
        tracer.incrementSourceLine();
    }
    buf.append(indstr).append("String_Node_Str").append(new_line_separator);
    tracer.incrementSourceLine();
    return buf.toString();
}

Output:
         buf.append(indstr).append("String_Node_Str").append(this.id).append("String_Node_Str").append(new_line_separator);
-        tracer.incrementSourceLine();
+        tracer.incrementCurrentSourceLine();
     }


Input:
public static Set<String> getUserNamesForGroup(ServiceConfiguration configuration, String groupName, String effectiveUserId) throws Exception {
    Set<String> users = Sets.newLinkedHashSet();
    boolean seenAllUsers = false;
    String userMarker = null;
    while (!seenAllUsers) {
        GetGroupType getGroupType = MessageHelper.createMessage(GetGroupType.class, effectiveUserId);
        getGroupType.setGroupName(groupName);
        if (userMarker != null) {
            getGroupType.setMarker(userMarker);
        }
        GetGroupResponseType getGroupResponseType = AsyncRequests.<GetGroupType, GetGroupResponseType>sendSync(configuration, getGroupType);
        if (getGroupResponseType.getGetGroupResult().getIsTruncated() == Boolean.TRUE) {
            userMarker = getGroupResponseType.getGetGroupResult().getMarker();
        } else {
            seenAllUsers = true;
        }
        if (getGroupResponseType.getGetGroupResult() != null && getGroupResponseType.getGetGroupResult().getUsers().getMemberList() != null) {
            for (UserType userType : getGroupResponseType.getGetGroupResult().getUsers().getMemberList()) {
                users.add(userType.getUserName());
            }
        }
    }
    return users;
}

Output:
         GetGroupResponseType getGroupResponseType = AsyncRequests.<GetGroupType, GetGroupResponseType>sendSync(configuration, getGroupType);
-        if (getGroupResponseType.getGetGroupResult().getIsTruncated() == Boolean.TRUE) {
+        if (Boolean.TRUE.equals(getGroupResponseType.getGetGroupResult().getIsTruncated())) {
             userMarker = getGroupResponseType.getGetGroupResult().getMarker();


Input:
public void send() {
    if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE)) {
        LogTag.debug("String_Node_Str");
    }
    prepareForSave(true);
    final Conversation conv = mConversation;
    String msgTxt = mText.toString();
    if (requiresMms() || addressContainsEmailToMms(conv, msgTxt)) {
        final Uri mmsUri = mMessageUri;
        final PduPersister persister = PduPersister.getPduPersister(mContext);
        final SlideshowModel slideshow = mSlideshow;
        final SendReq sendReq = makeSendReq(conv, mSubject);
        if (sendReq != null) {
            slideshow.prepareForSend();
            new Thread(new Runnable() {

                public void run() {
                    sendMmsWorker(conv, mmsUri, persister, slideshow, sendReq);
                }
            }).start();
        } else {
            Log.e(LogTag.TAG, "String_Node_Str");
        }
    } else {
        final String msgText = mText.toString();
        new Thread(new Runnable() {
            public void run() {
                sendSmsWorker(conv, msgText);
            }
        }).start();
    }
    mDiscarded = true;
}

Output:
         final SendReq sendReq = makeSendReq(conv, mSubject);
-        if (sendReq != null) {
-            slideshow.prepareForSend();
-            new Thread(new Runnable() {
+        slideshow.prepareForSend();
+        new Thread(new Runnable() {


Input:
private void createSimpleRecordMatcher(List<Map<String, String>> matchRule) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    final int recordSize = matchRule.size();
    double[] arrAttrWeights = new double[recordSize];
    String[] attributeNames = new String[recordSize];
    String[][] algorithmName = new String[recordSize][2];
    String[] arrMatchHandleNull = new String[recordSize];
    double recordMatchThreshold = acceptableThreshold;
    int recordIdx = 0;
    for (Map<String, String> recordMap : matchRule) {
        arrAttrWeights[recordIdx] = Double.parseDouble(recordMap.get(IRecordGrouping.CONFIDENCE_WEIGHT));
        attributeNames[recordIdx] = recordMap.get(IRecordGrouping.ATTRIBUTE_NAME);
        algorithmName[recordIdx][0] = recordMap.get(IRecordGrouping.MATCHING_TYPE);
        algorithmName[recordIdx][1] = recordMap.get(IRecordGrouping.CUSTOMER_MATCH_CLASS);
        arrMatchHandleNull[recordIdx] = recordMap.get(IRecordGrouping.HANDLE_NULL);
        String rcdMathThresholdEach = recordMap.get(IRecordGrouping.RECORD_MATCH_THRESHOLD);
        if (!StringUtils.isEmpty(rcdMathThresholdEach)) {
            recordMatchThreshold = Double.valueOf(rcdMathThresholdEach);
        }
        recordIdx++;
    }
    IAttributeMatcher[] attributeMatcher = new IAttributeMatcher[recordSize];
    for (int indx = 0; indx < recordSize; indx++) {
        AttributeMatcherType attrMatcherType = AttributeMatcherType.valueOf(algorithmName[indx][0]);
        attributeMatcher[indx] = org.talend.dataquality.record.linkage.attribute.AttributeMatcherFactory.createMatcher(attrMatcherType, algorithmName[indx][1]);
        attributeMatcher[indx].setNullOption(arrMatchHandleNull[indx]);
        attributeMatcher[indx].setAttributeName(attributeNames[indx]);
    }
    IRecordMatcher simpleRecordMatcher = RecordMatcherFactory.createMatcher(RecordMatcherType.simpleVSRMatcher);
    simpleRecordMatcher.setRecordSize(recordSize);
    simpleRecordMatcher.setAttributeWeights(arrAttrWeights);
    simpleRecordMatcher.setAttributeMatchers(attributeMatcher);
    simpleRecordMatcher.setRecordMatchThreshold(recordMatchThreshold);
    combinedRecordMatcher.add(simpleRecordMatcher);
}

Output:
     for (int indx = 0; indx < recordSize; indx++) {
-        AttributeMatcherType attrMatcherType = AttributeMatcherType.valueOf(algorithmName[indx][0]);
+        AttributeMatcherType attrMatcherType = AttributeMatcherType.get(algorithmName[indx][0]);
         attributeMatcher[indx] = org.talend.dataquality.record.linkage.attribute.AttributeMatcherFactory.createMatcher(attrMatcherType, algorithmName[indx][1]);


Input:
public Mod parse(byte[] data) {
    ByteReader reader = new ByteReader(data);
    reader.seek(1080);
    if (reader.available() < 4)
        return null;
    String id = reader.string(4);
    ModFormat format = checkType(id);
    if (format == null)
        format = testLegacy(reader);
    if (format == null)
        return null;
    reader.seek(0);
    String title = reader.string(20);
    Instrument[] instruments = readInstruments(reader, format);
    if (instruments == null)
        return null;
    int songLength = reader.u1();
    reader.skip(1);
    int[] order = readPatternOrder(reader);
    int totalPatterns = countPatterns(order, songLength);
    if (!format.isLegacy())
        reader.skip(4);
    Block[] patterns = readPatterns(reader, totalPatterns, format, instruments);
    if (patterns == null)
        return null;
    readInstrumentSamples(reader, instruments);
    Mod mod = new Mod(format.tracks);
    mod.tracker = format.description;
    mod.title = Tools.trimEnd(title, nulChar);
    mod.instruments = instruments;
    mod.songLength = songLength;
    mod.blockOrder = order;
    mod.blocks = patterns;
    return mod;
}

Output:
     Instrument[] instruments = readInstruments(reader, format);
-    if (instruments == null)
-        return null;
+    format = updateDescription(format, id, instruments);
     int songLength = reader.u1();


Input:
protected void afterCreate(Bundle savedInstanceState) {
    completedAllocationIds = allocationService.getReceivedAllocationIds();
    setupAllocationIdTextView();
    setupReceiveButton();
    if (presetAllocationId != null) {
        textViewAllocationId.setText(presetAllocationId);
    }
}

Output:
 protected void afterCreate(Bundle savedInstanceState) {
-    completedAllocationIds = allocationService.getReceivedAllocationIds();
+    completedAllocationIds = new ArrayList<>(allocationService.getReceivedAllocationIds());
     setupAllocationIdTextView();


Input:
public void testCursorModel4() throws DataException, OLAPException {
    ICubeQueryDefinition cqd = creator.createQueryDefinition();
    IBinding rowGrandTotal = new Binding("String_Node_Str");
    rowGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    rowGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    rowGrandTotal.addAggregateOn("String_Node_Str");
    rowGrandTotal.addAggregateOn("String_Node_Str");
    IBinding columnGrandTotal = new Binding("String_Node_Str");
    columnGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    columnGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    cqd.addBinding(rowGrandTotal);
    cqd.addBinding(columnGrandTotal);
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    List rowEdgeBindingNames = new ArrayList();
    rowEdgeBindingNames.add("String_Node_Str");
    rowEdgeBindingNames.add("String_Node_Str");
    List measureBindingNames = new ArrayList();
    measureBindingNames.add("String_Node_Str");
    List dimCursorOnColumn = cubeView.getColumnEdgeView().getEdgeCursor().getDimensionCursor();
    List dimCursorOnRow = cubeView.getRowEdgeView().getEdgeCursor().getDimensionCursor();
    testOut.print(creator.printCubeAlongDimension(dataCursor, (DimensionCursor) dimCursorOnColumn.get(0), (DimensionCursor) dimCursorOnColumn.get(1), (DimensionCursor) dimCursorOnColumn.get(2), (DimensionCursor) dimCursorOnColumn.get(3), (DimensionCursor) dimCursorOnRow.get(0), (DimensionCursor) dimCursorOnRow.get(1)));
    try {
        this.checkOutputFile();
    } catch (Exception e) {
        fail("String_Node_Str");
    }
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor();
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign());
     List columnEdgeBindingNames = new ArrayList();


Input:
public static void getRotationMatrixFromVector(float[] R, float[] rotationVector) {
    float q0;
    float q1 = rotationVector[0];
    float q2 = rotationVector[1];
    float q3 = rotationVector[2];
    if (rotationVector.length == 4) {
        q0 = rotationVector[3];
    } else {
        q0 = (float) Math.sqrt(1 - q1 * q1 - q2 * q2 - q3 * q3);
    }
    float sq_q1 = 2 * q1 * q1;
    float sq_q2 = 2 * q2 * q2;
    float sq_q3 = 2 * q3 * q3;
    float q1_q2 = 2 * q1 * q2;
    float q3_q0 = 2 * q3 * q0;
    float q1_q3 = 2 * q1 * q3;
    float q2_q0 = 2 * q2 * q0;
    float q2_q3 = 2 * q2 * q3;
    float q1_q0 = 2 * q1 * q0;
    if (R.length == 9) {
        R[0] = 1 - sq_q2 - sq_q3;
        R[1] = q1_q2 - q3_q0;
        R[2] = q1_q3 + q2_q0;
        R[3] = q1_q2 + q3_q0;
        R[4] = 1 - sq_q1 - sq_q3;
        R[5] = q2_q3 - q1_q0;
        R[6] = q1_q3 - q2_q0;
        R[7] = q2_q3 + q1_q0;
        R[8] = 1 - sq_q1 - sq_q2;
    } else if (R.length == 16) {
        R[0] = 1 - sq_q2 - sq_q3;
        R[1] = q1_q2 - q3_q0;
        R[2] = q1_q3 + q2_q0;
        R[3] = 0.0f;
        R[4] = q1_q2 + q3_q0;
        R[5] = 1 - sq_q1 - sq_q3;
        R[6] = q2_q3 - q1_q0;
        R[7] = 0.0f;
        R[8] = q1_q3 - q2_q0;
        R[9] = q2_q3 + q1_q0;
        R[10] = 1 - sq_q1 - sq_q2;
        R[11] = 0.0f;
        R[12] = R[13] = R[14] = 0.0f;
        R[15] = 1.0f;
    }
}

Output:
     } else {
-        q0 = (float) Math.sqrt(1 - q1 * q1 - q2 * q2 - q3 * q3);
+        q0 = 1 - q1 * q1 - q2 * q2 - q3 * q3;
+        q0 = (q0 > 0) ? (float) Math.sqrt(q0) : 0;
     }


Input:
final int startActivityMayWait(IApplicationThread caller, Intent intent, String resolvedType, Uri[] grantedUriPermissions, int grantedMode, IBinder resultTo, String resultWho, int requestCode, boolean onlyIfNeeded, boolean debug, WaitResult outResult, Configuration config) {
    if (intent != null && intent.hasFileDescriptors()) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    boolean componentSpecified = intent.getComponent() != null;
    intent = new Intent(intent);
    ActivityInfo aInfo;
    try {
        ResolveInfo rInfo = AppGlobals.getPackageManager().resolveIntent(intent, resolvedType, PackageManager.MATCH_DEFAULT_ONLY | ActivityManagerService.STOCK_PM_FLAGS);
        aInfo = rInfo != null ? rInfo.activityInfo : null;
    } catch (RemoteException e) {
        aInfo = null;
    }
    if (aInfo != null) {
        intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
        if (debug) {
            if (!aInfo.processName.equals("String_Node_Str")) {
                mService.setDebugApp(aInfo.processName, true, false);
            }
        }
    }
    synchronized (mService) {
        int callingPid;
        int callingUid;
        if (caller == null) {
            callingPid = Binder.getCallingPid();
            callingUid = Binder.getCallingUid();
        } else {
            callingPid = callingUid = -1;
        }
        mConfigWillChange = config != null && mService.mConfiguration.diff(config) != 0;
        if (DEBUG_CONFIGURATION)
            Slog.v(TAG, "String_Node_Str" + mConfigWillChange);
        final long origId = Binder.clearCallingIdentity();
        if (mMainStack && aInfo != null && (aInfo.applicationInfo.flags & ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
            if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
                if (mService.mHeavyWeightProcess != null && (mService.mHeavyWeightProcess.info.uid != aInfo.applicationInfo.uid || !mService.mHeavyWeightProcess.processName.equals(aInfo.processName))) {
                    int realCallingPid = callingPid;
                    int realCallingUid = callingUid;
                    if (caller != null) {
                        ProcessRecord callerApp = mService.getRecordForAppLocked(caller);
                        if (callerApp != null) {
                            realCallingPid = callerApp.pid;
                            realCallingUid = callerApp.info.uid;
                        } else {
                            Slog.w(TAG, "String_Node_Str" + caller + "String_Node_Str" + realCallingPid + "String_Node_Str" + intent.toString());
                            return START_PERMISSION_DENIED;
                        }
                    }
                    IIntentSender target = mService.getIntentSenderLocked(IActivityManager.INTENT_SENDER_ACTIVITY, "String_Node_Str", realCallingUid, null, null, 0, intent, resolvedType, PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT);
                    Intent newIntent = new Intent();
                    if (requestCode >= 0) {
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true);
                    }
                    newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT, new IntentSender(target));
                    if (mService.mHeavyWeightProcess.activities.size() > 0) {
                        ActivityRecord hist = mService.mHeavyWeightProcess.activities.get(0);
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP, hist.packageName);
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK, hist.task.taskId);
                    }
                    newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP, aInfo.packageName);
                    newIntent.setFlags(intent.getFlags());
                    newIntent.setClassName("String_Node_Str", HeavyWeightSwitcherActivity.class.getName());
                    intent = newIntent;
                    resolvedType = null;
                    caller = null;
                    callingUid = Binder.getCallingUid();
                    callingPid = Binder.getCallingPid();
                    componentSpecified = true;
                    try {
                        ResolveInfo rInfo = AppGlobals.getPackageManager().resolveIntent(intent, null, PackageManager.MATCH_DEFAULT_ONLY | ActivityManagerService.STOCK_PM_FLAGS);
                        aInfo = rInfo != null ? rInfo.activityInfo : null;
                    } catch (RemoteException e) {
                        aInfo = null;
                    }
                }
            }
        }
        int res = startActivityLocked(caller, intent, resolvedType, grantedUriPermissions, grantedMode, aInfo, resultTo, resultWho, requestCode, callingPid, callingUid, onlyIfNeeded, componentSpecified);
        if (mConfigWillChange && mMainStack) {
            mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION, "String_Node_Str");
            mConfigWillChange = false;
            if (DEBUG_CONFIGURATION)
                Slog.v(TAG, "String_Node_Str");
            mService.updateConfigurationLocked(config, null);
        }
        Binder.restoreCallingIdentity(origId);
        if (outResult != null) {
            outResult.result = res;
            if (res == IActivityManager.START_SUCCESS) {
                mWaitingActivityLaunched.add(outResult);
                do {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                } while (!outResult.timeout && outResult.who == null);
            } else if (res == IActivityManager.START_TASK_TO_FRONT) {
                ActivityRecord r = this.topRunningActivityLocked(null);
                if (r.nowVisible) {
                    outResult.timeout = false;
                    outResult.who = new ComponentName(r.info.packageName, r.info.name);
                    outResult.totalTime = 0;
                    outResult.thisTime = 0;
                } else {
                    outResult.thisTime = SystemClock.uptimeMillis();
                    mWaitingActivityVisible.add(outResult);
                    do {
                        try {
                            wait();
                        } catch (InterruptedException e) {
                        }
                    } while (!outResult.timeout && outResult.who == null);
                }
            }
        }
        return res;
    }
}

Output:
                     try {
-                        wait();
+                        mService.wait();
                     } catch (InterruptedException e) {


Input:
public String getJSON() {
    return "String_Node_Str";
}

Output:
 public String getJSON() {
-    return "String_Node_Str";
+    return responseJSON;
 }


Input:
public void setThumbnail(Context context, ThingView v, String url) {
    if (!TextUtils.isEmpty(url)) {
        Bitmap b = BITMAP_CACHE.get(url);
        v.setThumbnailBitmap(b);
        if (b == null) {
            LoadThumbnailTask task = (LoadThumbnailTask) v.getTag();
            if (task == null || !url.equals(task.url)) {
                if (task != null) {
                    task.cancel(true);
                }
                task = new LoadThumbnailTask(v, url);
                v.setTag(task);
                task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
            }
        }
    } else {
        LoadThumbnailTask task = (LoadThumbnailTask) v.getTag();
        if (task != null) {
            task.cancel(true);
            v.setTag(null);
        }
        v.setThumbnailBitmap(null);
    }
}

Output:
         v.setThumbnailBitmap(b);
-        if (b == null) {
+        if (b != null) {
+            clearLoadThumbnailTask(v);
+        } else {
             LoadThumbnailTask task = (LoadThumbnailTask) v.getTag();


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    int inputValue = game.getBattlefield().countAll(filter, getControllerId(), game);
    return ComparisonType.compare(value, type, inputValue);
}

Output:
     int inputValue = game.getBattlefield().countAll(filter, getControllerId(), game);
-    return ComparisonType.compare(value, type, inputValue);
+    return ComparisonType.compare(inputValue, type, value);
 }


Input:
public void buildTaxonomyTree(String name) {
    IndexHits<Node> hits = nodeIndex.get("String_Node_Str", name);
    Node firstNode = hits.getSingle();
    hits.close();
    if (firstNode == null) {
        System.out.println("String_Node_Str");
        return;
    }
    TraversalDescription CHILDOF_TRAVERSAL = Traversal.description().relationships(RelTypes.CHILDOF, Direction.INCOMING);
    System.out.println(firstNode.getProperty("String_Node_Str"));
    JadeNode root = new JadeNode();
    root.setName(((String) firstNode.getProperty("String_Node_Str")).replace("String_Node_Str", "String_Node_Str"));
    HashMap<Node, JadeNode> nodes = new HashMap<Node, JadeNode>();
    nodes.put(firstNode, root);
    int count = 0;
    for (Relationship friendrel : CHILDOF_TRAVERSAL.traverse(firstNode).relationships()) {
        count += 1;
        if (nodes.containsKey(friendrel.getStartNode()) == false) {
            JadeNode node = new JadeNode();
            node.setName(((String) friendrel.getStartNode().getProperty("String_Node_Str")).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str"));
            nodes.put(friendrel.getStartNode(), node);
        }
        if (nodes.containsKey(friendrel.getEndNode()) == false) {
            JadeNode node = new JadeNode();
            node.setName(((String) friendrel.getEndNode().getProperty("String_Node_Str")).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str"));
            nodes.put(friendrel.getEndNode(), node);
        }
        nodes.get(friendrel.getEndNode()).addChild(nodes.get(friendrel.getStartNode()));
        if (count % 100000 == 0)
            System.out.println(count);
    }
    JadeTree tree = new JadeTree(root);
    PrintWriter outFile;
    try {
        outFile = new PrintWriter(new FileWriter("String_Node_Str"));
        outFile.write(tree.getRoot().getNewick(false));
        outFile.write("String_Node_Str");
        outFile.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
     }
-    TraversalDescription CHILDOF_TRAVERSAL = Traversal.description().relationships(RelTypes.CHILDOF, Direction.INCOMING);
+    TraversalDescription CHILDOF_TRAVERSAL = Traversal.description().relationships(RelTypes.TAXCHILDOF, Direction.INCOMING);
     System.out.println(firstNode.getProperty("String_Node_Str"));


Input:
public static List<Status> getTechnicalStatus() {
    org.talend.core.model.properties.Project loadProject = null;
    try {
        loadProject = loadProject();
    } catch (Exception e) {
        log.error(e, e);
        return null;
    }
    if (loadProject == null) {
        return null;
    }
    return copyList(loadProject.getTechnicalStatus());
}

Output:
 public static List<Status> getTechnicalStatus() {
-    org.talend.core.model.properties.Project loadProject = null;
-    try {
-        loadProject = loadProject();
-    } catch (Exception e) {
-        log.error(e, e);
-        return null;
+    Project project = ReponsitoryContextBridge.getProject();
+    if (project != null) {
+        return copyList(project.getTechnicalStatus());
+    } else {
+        return new ArrayList<Status>();
     }


Input:
public boolean equals(Object o) {
    EnvironmentVariable e = (EnvironmentVariable) o;
    if (stringValues.length != e.stringValues.length)
        return false;
    if (floatValues.length != e.floatValues.length)
        return false;
    if (isStringValuesSupported()) {
        for (int i = 0; i < stringValues.length; i++) {
            if (!stringValues[i].equals(e.stringValues[i])) {
                return false;
            }
        }
    }
    if (isFloatValuesSupported()) {
        for (int i = 0; i < floatValues.length; i++) {
            if (!(floatValues[i] == e.floatValues[i])) {
                return false;
            }
        }
    }
    return true;
}

Output:
     EnvironmentVariable e = (EnvironmentVariable) o;
-    if (stringValues.length != e.stringValues.length)
-        return false;
-    if (floatValues.length != e.floatValues.length)
+    if (!getVariableType().equals(e.getVariableType()))
         return false;


Input:
public void clear() {
    this.registedResourceMap.clear();
}

Output:
 public void clear() {
-    this.registedResourceMap.clear();
+    registedResourceMap.clear();
 }


Input:
public void write(final Kryo kryo, final Output output) {
    kryo.writeObject(output, this.jobID);
    output.writeString(this.jobName);
    final AbstractJobVertex[] allVertices = this.getAllJobVertices();
    try {
        writeRequiredJarFiles(kryo, output, allVertices);
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }
    output.writeInt(allVertices.length);
    for (int i = 0; i < allVertices.length; i++) {
        final String className = allVertices[i].getClass().getName();
        output.writeString(className);
        kryo.writeObject(output, allVertices[i].getID());
        output.writeString(allVertices[i].getName());
    }
    for (int i = 0; i < allVertices.length; i++) {
        kryo.writeObject(output, allVertices[i].getID());
        allVertices[i].write(kryo, output);
    }
    this.jobConfiguration.write(kryo, output);
    this.taskManagerConfiguration.write(kryo, output);
}

Output:
     try {
-        writeRequiredJarFiles(kryo, output, allVertices);
+        writeRequiredJarFiles(kryo, output);
     } catch (IOException ioe) {


Input:
public void populateDynamicChoices(ItemsetBinding itemset, TreeReference curQRef) {
    DataInstance formInstance;
    if (itemset.nodesetRef.getInstanceName() != null) {
        formInstance = getNonMainInstance(itemset.nodesetRef.getInstanceName());
        if (formInstance == null) {
            throw new XPathException("String_Node_Str" + itemset.nodesetRef.getInstanceName() + "String_Node_Str");
        }
    } else {
        formInstance = getMainInstance();
    }
    EvaluationContext ec = new EvaluationContext(exprEvalContext, itemset.contextRef.contextualize(curQRef));
    ReducingTraceReporter reporter = null;
    if (mProfilingEnabled) {
        reporter = new ReducingTraceReporter();
        ec.setDebugModeOn(reporter);
    }
    Vector<TreeReference> matches = itemset.nodesetExpr.evalNodeset(formInstance, ec);
    if (reporter != null) {
        InstrumentationUtils.printAndClearTraces(reporter, "String_Node_Str");
    }
    if (matches == null) {
        String instanceName = itemset.nodesetRef.getInstanceName();
        if (instanceName == null) {
            throw new XPathException("String_Node_Str" + itemset.nodesetRef + "String_Node_Str");
        } else {
            throw new XPathException("String_Node_Str" + instanceName + "String_Node_Str");
        }
    }
    Vector<SelectChoice> choices = new Vector<>();
    QueryContext newContext = ec.getCurrentQueryContext().checkForDerivativeContextAndReturn(matches.size());
    ec.setQueryContext(newContext);
    for (int i = 0; i < matches.size(); i++) {
        choices.addElement(buildSelectChoice(matches.elementAt(i), itemset, formInstance, ec, i));
    }
    itemset.setChoices(choices);
}

Output:
     for (int i = 0; i < matches.size(); i++) {
-        choices.addElement(buildSelectChoice(matches.elementAt(i), itemset, formInstance, ec, i));
+        choices.addElement(buildSelectChoice(matches.elementAt(i), itemset, formInstance, ec, reporter, i));
     }


Input:
private static Connection connect(String host, int port, int type) {
    Connection ret = null;
    if (type == OLD)
        ret = new Connection(host, port);
    else if (type == LEAF)
        ret = new Connection(host, port, new LeafProperties(), new EmptyResponder(), false);
    else if (type == ULTRAPEER)
        ret = new Connection(host, port, new UltrapeerProperties(), new EmptyResponder(), false);
    else
        Assert.that(false, "String_Node_Str" + type);
    try {
        ret.initialize();
        ret.send(new PingRequest((byte) 7));
        ret.flush();
        Message m = ret.receive();
        return ret;
    } catch (IOException e) {
        return null;
    } catch (BadPacketException e) {
        return null;
    }
}

Output:
     Connection ret = null;
-    if (type == OLD)
+    if (type == OLD_04)
         ret = new Connection(host, port);


Input:
public void unmarshalEntity(PacketInput in) throws IOException {
    in.align(Alignment.FOUR);
    this.offset = readIndex("String_Node_Str", in);
    final int actualCount = readIndex("String_Node_Str", in);
    this.length = (isNullTerminated() ? (actualCount - 1) : actualCount);
}

Output:
     this.offset = readIndex("String_Node_Str", in);
-    final int actualCount = readIndex("String_Node_Str", in);
-    this.length = (isNullTerminated() ? (actualCount - 1) : actualCount);
+    this.actualCount = readIndex("String_Node_Str", in);
 }


Input:
private static StringBuilder generateAJAXCallForClientBehavior(FacesContext context, IAJAXComponent component, ClientBehavior ajaxBehavior) {
    StringBuilder cJS = new StringBuilder(150);
    String update = component.getUpdate();
    String oncomplete = component.getOncomplete();
    String process = component.getProcess();
    String onevent = "String_Node_Str";
    if (ajaxBehavior != null) {
        if (ajaxBehavior instanceof AjaxBehavior) {
            boolean disabled = ((AjaxBehavior) ajaxBehavior).isDisabled();
            if (!disabled) {
                String onerror = ((AjaxBehavior) ajaxBehavior).getOnerror();
                onevent = ((AjaxBehavior) ajaxBehavior).getOnevent();
                if (onevent == null)
                    onevent = "String_Node_Str";
                else if (onevent.length() > 0)
                    onevent = onevent + "String_Node_Str";
                Collection<String> execute = ((AjaxBehavior) ajaxBehavior).getExecute();
                if (null != execute && (!execute.isEmpty())) {
                    for (String u : execute) {
                        process += "String_Node_Str" + u;
                    }
                }
                Collection<String> render = ((AjaxBehavior) ajaxBehavior).getRender();
                if (null != render && (!render.isEmpty())) {
                    update = "String_Node_Str";
                    for (String u : render) {
                        update += u + "String_Node_Str";
                    }
                }
                oncomplete = component.getOncomplete();
            }
        }
    }
    process = ExpressionResolver.getComponentIDs(context, (UIComponent) component, process);
    update = ExpressionResolver.getComponentIDs(context, (UIComponent) component, update);
    cJS.append(encodeClick(component)).append(onevent).append("String_Node_Str").append(update == null ? "String_Node_Str" : ("String_Node_Str" + update + "String_Node_Str")).append(process == null ? "String_Node_Str" : ("String_Node_Str" + process.trim() + "String_Node_Str"));
    if (oncomplete != null) {
        cJS.append("String_Node_Str" + oncomplete + "String_Node_Str");
    }
    cJS.append("String_Node_Str");
    return cJS;
}

Output:
                     for (String u : execute) {
-                        process += "String_Node_Str" + u;
+                        if (null == process)
+                            process = u;
+                        else
+                            process += "String_Node_Str" + u;
                     }


Input:
public String call() {
    Iterator<Window> iter = Window.impl_getWindows();
    while (iter.hasNext()) {
        Window window = iter.next();
        if (window instanceof Tooltip) {
            return ((Tooltip) window).getText();
        }
    }
    return null;
}

Output:
 public String call() {
-    Iterator<Window> iter = Window.impl_getWindows();
+    Iterator<Window> iter = WindowsUtil.getWindowIterator();
     while (iter.hasNext()) {


Input:
public boolean isActive(String eventType) {
    EventNotification eventNotification = (EventNotification) notificationsTable.get(eventType);
    if (eventNotification == null)
        return false;
    return eventNotification.isActive();
}

Output:
 public boolean isActive(String eventType) {
-    EventNotification eventNotification = (EventNotification) notificationsTable.get(eventType);
+    EventNotification eventNotification = notificationsTable.get(eventType);
     if (eventNotification == null)


Input:
public void setOptions(String options) throws Exception {
    if (options == null)
        return;
    _options = StringUtility.trim(options, '\"');
    JSONObject json = null;
    try {
        json = new JSONObject(_options);
    } catch (Exception ex) {
        throw new ParseException(ex.getMessage(), 0);
    }
    if (json.has("String_Node_Str")) {
        try {
            _maxSpeed = json.getDouble("String_Node_Str");
        } catch (Exception ex) {
            throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_FORMAT, "String_Node_Str", json.getString("String_Node_Str"));
        }
    }
    if (json.has("String_Node_Str")) {
        String keyValue = json.getString("String_Node_Str");
        if (!Helper.isEmpty(keyValue)) {
            String[] avoidFeatures = keyValue.split("String_Node_Str");
            if (avoidFeatures != null && avoidFeatures.length > 0) {
                int flags = 0;
                for (int i = 0; i < avoidFeatures.length; i++) {
                    String featName = avoidFeatures[i];
                    if (featName != null) {
                        int flag = AvoidFeatureFlags.getFromString(featName);
                        if (flag == 0)
                            throw new UnknownParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, "String_Node_Str", featName);
                        if (!AvoidFeatureFlags.isValid(_profileType, flag))
                            throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, "String_Node_Str", featName);
                        flags |= flag;
                    }
                }
                if (flags != 0)
                    _avoidFeaturesTypes = flags;
            }
        }
    }
    if (json.has("String_Node_Str")) {
        if (RoutingProfileType.isCycling(_profileType)) {
            CyclingParameters cyclingParams = new CyclingParameters();
            JSONObject jFitnessParams = json.getJSONObject("String_Node_Str");
            if (jFitnessParams.has("String_Node_Str"))
                cyclingParams.setDifficultyLevel(jFitnessParams.getInt("String_Node_Str"));
            if (jFitnessParams.has("String_Node_Str"))
                cyclingParams.setMaximumGradient(jFitnessParams.getInt("String_Node_Str"));
            _profileParams = cyclingParams;
        } else if (RoutingProfileType.isWalking(_profileType)) {
            WalkingParameters walkingParams = new WalkingParameters();
            JSONObject walkingProfileParams = json.getJSONObject("String_Node_Str");
            if (walkingProfileParams.has("String_Node_Str"))
                walkingParams.setGreenRouting(walkingProfileParams.getBoolean("String_Node_Str"));
            if (walkingProfileParams.has("String_Node_Str"))
                walkingParams.setQuietRouting(walkingProfileParams.getBoolean("String_Node_Str"));
            if (walkingProfileParams.has("String_Node_Str"))
                walkingParams.setDifficultyLevel(walkingProfileParams.getInt("String_Node_Str"));
            if (walkingProfileParams.has("String_Node_Str"))
                walkingParams.setMaximumGradient(walkingProfileParams.getInt("String_Node_Str"));
            if (walkingProfileParams.has("String_Node_Str"))
                walkingParams.setGreenWeightingFactor(walkingProfileParams.getDouble("String_Node_Str"));
            if (walkingProfileParams.has("String_Node_Str"))
                walkingParams.setQuietWeightingFactor(walkingProfileParams.getDouble("String_Node_Str"));
            _profileParams = walkingParams;
        } else if (RoutingProfileType.isHeavyVehicle(_profileType) == true) {
            VehicleParameters vehicleParams = new VehicleParameters();
            if (json.has("String_Node_Str")) {
                String vehicleType = json.getString("String_Node_Str");
                _vehicleType = HeavyVehicleAttributes.getFromString(vehicleType);
                JSONObject jVehicleParams = json.getJSONObject("String_Node_Str");
                if (jVehicleParams.has("String_Node_Str"))
                    vehicleParams.setLength(jVehicleParams.getDouble("String_Node_Str"));
                if (jVehicleParams.has("String_Node_Str"))
                    vehicleParams.setWidth(jVehicleParams.getDouble("String_Node_Str"));
                if (jVehicleParams.has("String_Node_Str"))
                    vehicleParams.setHeight(jVehicleParams.getDouble("String_Node_Str"));
                if (jVehicleParams.has("String_Node_Str"))
                    vehicleParams.setWeight(jVehicleParams.getDouble("String_Node_Str"));
                if (jVehicleParams.has("String_Node_Str"))
                    vehicleParams.setAxleload(jVehicleParams.getDouble("String_Node_Str"));
                int loadCharacteristics = 0;
                if (jVehicleParams.has("String_Node_Str") && jVehicleParams.getBoolean("String_Node_Str") == true)
                    loadCharacteristics |= VehicleLoadCharacteristicsFlags.HAZMAT;
                if (loadCharacteristics != 0)
                    vehicleParams.setLoadCharacteristics(loadCharacteristics);
            }
            _profileParams = vehicleParams;
        } else if (_profileType == RoutingProfileType.WHEELCHAIR) {
            WheelchairParameters wheelchairParams = new WheelchairParameters();
            JSONObject jWheelchairParams = json.getJSONObject("String_Node_Str");
            if (jWheelchairParams.has("String_Node_Str"))
                wheelchairParams.setSurfaceType(WheelchairTypesEncoder.getSurfaceType(jWheelchairParams.getString("String_Node_Str")));
            if (jWheelchairParams.has("String_Node_Str"))
                wheelchairParams.setTrackType(WheelchairTypesEncoder.getTrackType(jWheelchairParams.getString("String_Node_Str")));
            if (jWheelchairParams.has("String_Node_Str"))
                wheelchairParams.setSmoothnessType(WheelchairTypesEncoder.getSmoothnessType(jWheelchairParams.getString("String_Node_Str")));
            if (jWheelchairParams.has("String_Node_Str"))
                wheelchairParams.setMaximumSlopedCurb((float) jWheelchairParams.getDouble("String_Node_Str"));
            if (jWheelchairParams.has("String_Node_Str"))
                wheelchairParams.setMaximumIncline((float) jWheelchairParams.getDouble("String_Node_Str"));
            _profileParams = wheelchairParams;
        }
    }
    if (json.has("String_Node_Str")) {
        JSONObject jFeature = (JSONObject) json.get("String_Node_Str");
        Geometry geom = null;
        try {
            geom = GeometryJSON.parse(jFeature);
        } catch (Exception ex) {
            throw new ParameterValueException(RoutingErrorCodes.INVALID_JSON_FORMAT, "String_Node_Str");
        }
        if (geom instanceof Polygon) {
            _avoidAreas = new Polygon[] { (Polygon) geom };
        } else if (geom instanceof MultiPolygon) {
            MultiPolygon multiPoly = (MultiPolygon) geom;
            _avoidAreas = new Polygon[multiPoly.getNumGeometries()];
            for (int i = 0; i < multiPoly.getNumGeometries(); i++) _avoidAreas[i] = (Polygon) multiPoly.getGeometryN(i);
        } else {
            throw new Exception("String_Node_Str");
        }
    }
}

Output:
         } else {
-            throw new Exception("String_Node_Str");
+            throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, "String_Node_Str");
         }


Input:
public void runSimulation() {
    Observation initialObs;
    try {
        try {
            initialObs = Observation.createObservation(this.simulationName, startTime, startCoordinates, null, null, null);
        } catch (TimeOrderException e) {
            e.printStackTrace();
            return;
        }
        final SnappedEdges initialEdges = Api.getGraph().snapToGraph(null, initialObs.getObsCoords());
        List<InferredEdge> edges = Lists.newArrayList(InferredGraph.getEmptyEdge());
        for (Edge edge : initialEdges.getSnappedEdges()) {
            edges.add(inferredGraph.getInferredEdge(edge));
        }
        final InferredEdge currentInferredEdge = edges.get(rng.nextInt(edges.size()));
        InferredPath currentPath = currentInferredEdge == InferredGraph.getEmptyEdge() ? InferredPath.getEmptyPath() : new InferredPath(currentInferredEdge);
        PathEdge currentPathEdge = Iterables.getOnlyElement(currentPath.getEdges());
        VehicleState vehicleState = new VehicleState(this.inferredGraph, initialObs, currentInferredEdge);
        Vector thisStateSample = sampleBelief(vehicleState);
        vehicleState.getBelief().setMean(thisStateSample);
        for (long time = startTime.getTime() + frequency * 1000; time < endTime.getTime(); time += frequency * 1000) {
            vehicleState.getMovementFilter().setCurrentTimeDiff(frequency);
            final MultivariateGaussian currentLocBelief = vehicleState.getBelief();
            final EdgeTransitionDistributions currentEdgeTrans = vehicleState.getEdgeTransitionDist();
            currentPath = traverseEdge(vehicleState.getEdgeTransitionDist(), currentLocBelief, currentPathEdge, vehicleState.getMovementFilter());
            Vector transStateSample = sampleBelief(vehicleState);
            vehicleState.getBelief().setMean(transStateSample);
            currentPathEdge = Iterables.getLast(currentPath.getEdges());
            Vector thisLoc = sampleObservation(vehicleState, currentPathEdge);
            Coordinate obsCoord = GeoUtils.convertToLatLon(thisLoc);
            Observation thisObs;
            try {
                thisObs = Observation.createObservation(simulationName, new Date(time), obsCoord, null, null, null);
            } catch (TimeOrderException e) {
                e.printStackTrace();
                continue;
            }
            InferenceResultRecord result = InferenceResultRecord.createInferenceResultRecord(thisObs, currentLocBelief, currentPath.getEdges());
            InferenceService.addSimulationRecords(simulationName, result);
            Logger.info("String_Node_Str" + thisObs);
            vehicleState = new VehicleState(this.inferredGraph, thisObs, vehicleState.getMovementFilter(), currentLocBelief, currentEdgeTrans, currentPathEdge, currentPath, vehicleState);
        }
    } catch (NumberFormatException e) {
        e.printStackTrace();
    }
}

Output:
         }
-        final SnappedEdges initialEdges = Api.getGraph().snapToGraph(null, initialObs.getObsCoords());
+        inferredGraph.getNearbyEdges(initialObs.getProjectedPoint());
         List<InferredEdge> edges = Lists.newArrayList(InferredGraph.getEmptyEdge());


Input:
public void onSuccess(Map<String, Object> map) {
    if (null != callback) {
        callback.onSuccess(new URLPreview(map));
    }
}

Output:
     if (null != callback) {
-        callback.onSuccess(new URLPreview(map));
+        callback.onSuccess(new URLPreview(map, url));
     }