Input:
public Connection getConnection(Address address) {
    MockConnection conn = mapConnections.get(address);
    if (conn == null || !conn.isAlive()) {
        NodeEngineImpl nodeEngine = nodes.get(address);
        if (nodeEngine != null && nodeEngine.getNode().getState() != NodeState.SHUT_DOWN) {
            MockConnection thisConnection = new MockConnection(address, node.getThisAddress(), node.nodeEngine);
            conn = new MockConnection(node.getThisAddress(), address, nodeEngine);
            conn.localConnection = thisConnection;
            thisConnection.localConnection = conn;
            mapConnections.put(address, conn);
        }
    }
    return conn;
}

Output:
 public Connection getConnection(Address address) {
-    MockConnection conn = mapConnections.get(address);
-    if (conn == null || !conn.isAlive()) {
-        NodeEngineImpl nodeEngine = nodes.get(address);
-        if (nodeEngine != null && nodeEngine.getNode().getState() != NodeState.SHUT_DOWN) {
-            MockConnection thisConnection = new MockConnection(address, node.getThisAddress(), node.nodeEngine);
-            conn = new MockConnection(node.getThisAddress(), address, nodeEngine);
-            conn.localConnection = thisConnection;
-            thisConnection.localConnection = conn;
-            mapConnections.put(address, conn);
-        }
-    }
-    return conn;
+    return mapConnections.get(address);
 }


Input:
protected File[] getResourcesBundles() throws MojoExecutionException {
    List<File> resouceBundles = new ArrayList<File>();
    for (Artifact artifact : getDependencyArtifacts()) {
        if (!"String_Node_Str".equals(artifact.getType())) {
            continue;
        }
        for (String locale : locales) {
            Artifact localeArtifact = artifactFactory.createArtifactWithClassifier(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), artifact.getType(), locale);
            resolveArtifact(localeArtifact, resolver, localRepository, resouceBundles);
            resouceBundles.add(localeArtifact.getFile());
        }
    }
    return resouceBundles.toArray(new File[resouceBundles.size()]);
}

Output:
 protected File[] getResourcesBundles() throws MojoExecutionException {
-    List<File> resouceBundles = new ArrayList<File>();
+    List<File> resourceBundles = new ArrayList<File>();
     for (Artifact artifact : getDependencyArtifacts()) {


Input:
public boolean equals(Object o) {
    return o instanceof Left && ((Left) o).value.equals(value);
}

Output:
 public boolean equals(Object o) {
-    return o instanceof Left && ((Left) o).value.equals(value);
+    return o instanceof Left && equalTo(((Left) o).value, value);
 }


Input:
public void truncate() {
    if (fd == -1) {
        return;
    }
    this.size = 0;
    releaseCurrentPage();
    if (!ff.truncate(fd, pageSize)) {
        throw CairoException.instance(Os.errno()).put("String_Node_Str").put(fd).put("String_Node_Str").put(pageSize).put("String_Node_Str");
    }
    updateLimits(0, pageAddress = mapPage(0));
}

Output:
     releaseCurrentPage();
-    if (!ff.truncate(fd, pageSize)) {
-        throw CairoException.instance(Os.errno()).put("String_Node_Str").put(fd).put("String_Node_Str").put(pageSize).put("String_Node_Str");
+    if (!ff.truncate(fd, getMapPageSize())) {
+        throw CairoException.instance(Os.errno()).put("String_Node_Str").put(fd).put("String_Node_Str").put(getMapPageSize()).put("String_Node_Str");
     }


Input:
private static void generateBuildInfo(JobInfo jobInfo, IProgressMonitor progressMonitor, boolean isMainJob, IProcess currentProcess, String currentJobName) throws ProcessorException {
    if (isMainJob) {
        progressMonitor.subTask(Messages.getString("String_Node_Str") + currentJobName);
        CorePlugin.getDefault().getRunProcessService().updateLibraries(LastGenerationInfo.getInstance().getModulesNeededWithSubjobPerJob(jobInfo.getJobId(), jobInfo.getJobVersion()), currentProcess);
        if (LanguageManager.getCurrentLanguage() == ECodeLanguage.JAVA && codeModified) {
            try {
                ((IJavaProject) CorePlugin.getDefault().getRunProcessService().getJavaProject()).getProject().build(IncrementalProjectBuilder.AUTO_BUILD, null);
            } catch (CoreException e) {
                throw new ProcessorException(e);
            }
        }
        codeModified = false;
    }
}

Output:
         progressMonitor.subTask(Messages.getString("String_Node_Str") + currentJobName);
-        CorePlugin.getDefault().getRunProcessService().updateLibraries(LastGenerationInfo.getInstance().getModulesNeededWithSubjobPerJob(jobInfo.getJobId(), jobInfo.getJobVersion()), currentProcess);
+        Set<String> jarList = new HashSet<String>();
+        Set<ModuleNeeded> neededModules = LastGenerationInfo.getInstance().getModulesNeededWithSubjobPerJob(jobInfo.getJobId(), jobInfo.getJobVersion());
+        for (ModuleNeeded module : neededModules) {
+            jarList.add(module.getModuleName());
+        }
+        CorePlugin.getDefault().getRunProcessService().updateLibraries(jarList, currentProcess);
         if (LanguageManager.getCurrentLanguage() == ECodeLanguage.JAVA && codeModified) {


Input:
private XPathFragment getLastGroupingFragment() {
    XPathFragment fragment = ((XMLField) this.getMapping().getField()).getXPathFragment();
    if (fragment.isAttribute() || fragment.nameIsText()) {
        return null;
    }
    while (fragment.getNextFragment() != null) {
        if (fragment.getNextFragment().nameIsText() || fragment.getNextFragment().isAttribute()) {
            return fragment;
        }
        fragment = fragment.getNextFragment();
    }
    return fragment;
}

Output:
     XPathFragment fragment = ((XMLField) this.getMapping().getField()).getXPathFragment();
-    if (fragment.isAttribute() || fragment.nameIsText()) {
+    if (fragment.hasAttribute || fragment.nameIsText) {
         return null;


Input:
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    int widthSize = MeasureSpec.getSize(widthMeasureSpec);
    int heightSize = MeasureSpec.getSize(heightMeasureSpec);
    if ((widthMode == MeasureSpec.AT_MOST || widthMode == MeasureSpec.UNSPECIFIED) && !singleLine) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    int width = 0;
    if (widthMode == MeasureSpec.EXACTLY) {
        width = widthSize;
    } else if ((widthMode == MeasureSpec.AT_MOST || widthMode == MeasureSpec.UNSPECIFIED) && !TextUtils.isEmpty(text)) {
        width = (int) Layout.getDesiredWidth(text, paint) + getPaddingLeft() + getPaddingRight();
        if (widthMode == MeasureSpec.AT_MOST) {
            width = Math.min(width, widthSize);
        }
    }
    if (width > 0) {
        if (this.width != width) {
            this.width = width;
            update = true;
        }
        updateLayout();
        if (layout != null) {
            int height;
            if (heightMode == MeasureSpec.EXACTLY) {
                height = heightSize;
            } else {
                height = layout.getHeight() + getPaddingTop() + getPaddingBottom();
                if (heightMode == MeasureSpec.AT_MOST) {
                    height = Math.min(height, heightSize);
                }
            }
            setMeasuredDimension(width, height);
        } else {
            int height;
            if (heightMode == MeasureSpec.EXACTLY) {
                height = heightSize;
            } else {
                height = 0;
            }
            setMeasuredDimension(width, height);
        }
    } else {
        Logger.w(TAG, "String_Node_Str");
        setMeasuredDimension(0, 0);
    }
}

Output:
     } else if ((widthMode == MeasureSpec.AT_MOST || widthMode == MeasureSpec.UNSPECIFIED) && !TextUtils.isEmpty(text)) {
-        width = (int) Layout.getDesiredWidth(text, paint) + getPaddingLeft() + getPaddingRight();
+        width = Math.round(Layout.getDesiredWidth(text, paint) + getPaddingLeft() + getPaddingRight());
         if (widthMode == MeasureSpec.AT_MOST) {


Input:
final boolean navigateUpToLocked(IBinder token, Intent destIntent, int resultCode, Intent resultData) {
    final ActivityRecord srec = ActivityRecord.forToken(token);
    final TaskRecord task = srec.task;
    final ArrayList<ActivityRecord> activities = task.mActivities;
    final int start = activities.indexOf(srec);
    if (!mTaskHistory.contains(task) || (start < 0)) {
        return false;
    }
    int finishTo = start - 1;
    ActivityRecord parent = finishTo < 0 ? null : activities.get(finishTo);
    boolean foundParentInTask = false;
    final ComponentName dest = destIntent.getComponent();
    if (start > 0 && dest != null) {
        for (int i = finishTo; i >= 0; i--) {
            ActivityRecord r = activities.get(i);
            if (r.info.packageName.equals(dest.getPackageName()) && r.info.name.equals(dest.getClassName())) {
                finishTo = i;
                parent = r;
                foundParentInTask = true;
                break;
            }
        }
    }
    IActivityController controller = mService.mController;
    if (controller != null) {
        ActivityRecord next = topRunningActivityLocked(srec.appToken, 0);
        if (next != null) {
            boolean resumeOK = true;
            try {
                resumeOK = controller.activityResuming(next.packageName);
            } catch (RemoteException e) {
                mService.mController = null;
                Watchdog.getInstance().setActivityController(null);
            }
            if (!resumeOK) {
                return false;
            }
        }
    }
    final long origId = Binder.clearCallingIdentity();
    for (int i = start; i > finishTo; i--) {
        ActivityRecord r = activities.get(i);
        requestFinishActivityLocked(r.appToken, resultCode, resultData, "String_Node_Str", true);
        resultCode = Activity.RESULT_CANCELED;
        resultData = null;
    }
    if (parent != null && foundParentInTask) {
        final int parentLaunchMode = parent.info.launchMode;
        final int destIntentFlags = destIntent.getFlags();
        if (parentLaunchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE || parentLaunchMode == ActivityInfo.LAUNCH_SINGLE_TASK || parentLaunchMode == ActivityInfo.LAUNCH_SINGLE_TOP || (destIntentFlags & Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {
            parent.deliverNewIntentLocked(srec.info.applicationInfo.uid, destIntent);
        } else {
            try {
                ActivityInfo aInfo = AppGlobals.getPackageManager().getActivityInfo(destIntent.getComponent(), 0, srec.userId);
                int res = mStackSupervisor.startActivityLocked(srec.app.thread, destIntent, null, aInfo, null, null, parent.appToken, null, 0, -1, parent.launchedFromUid, parent.launchedFromPackage, 0, null, true, null, null, null);
                foundParentInTask = res == ActivityManager.START_SUCCESS;
            } catch (RemoteException e) {
                foundParentInTask = false;
            }
            requestFinishActivityLocked(parent.appToken, resultCode, resultData, "String_Node_Str", true);
        }
    }
    Binder.restoreCallingIdentity(origId);
    return foundParentInTask;
}

Output:
                 ActivityInfo aInfo = AppGlobals.getPackageManager().getActivityInfo(destIntent.getComponent(), 0, srec.userId);
-                int res = mStackSupervisor.startActivityLocked(srec.app.thread, destIntent, null, aInfo, null, null, parent.appToken, null, 0, -1, parent.launchedFromUid, parent.launchedFromPackage, 0, null, true, null, null, null);
+                int res = mStackSupervisor.startActivityLocked(srec.app.thread, destIntent, null, aInfo, null, null, parent.appToken, null, 0, -1, parent.launchedFromUid, parent.launchedFromPackage, -1, parent.launchedFromUid, 0, null, true, null, null, null);
                 foundParentInTask = res == ActivityManager.START_SUCCESS;


Input:
public static void write(FactorGraph fg, BufferedWriter out) {
    try {
        out.write(String.format("String_Node_Str", fg.getNumFactors(), fg.getNumVars(), fg.getNumEdges()));
        out.write(getNumNonGlobalFactors(fg) + "String_Node_Str");
        out.write("String_Node_Str");
        for (Factor f : fg.getFactors()) {
            if (!(f instanceof GlobalFactor)) {
                VarSet vars = f.getVars();
                out.write(vars.size() + "String_Node_Str");
                for (int v = vars.size() - 1; v >= 0; v--) {
                    out.write("String_Node_Str" + vars.get(v).getId());
                    if (v > 0) {
                        out.write("String_Node_Str");
                    }
                }
                out.write("String_Node_Str");
                for (int v = vars.size() - 1; v >= 0; v--) {
                    out.write("String_Node_Str" + vars.get(v).getNumStates());
                    if (v > 0) {
                        out.write("String_Node_Str");
                    }
                }
                out.write("String_Node_Str");
                int n = vars.calcNumConfigs();
                out.write(n + "String_Node_Str");
                for (int c = 0; c < n; c++) {
                    out.write(String.format("String_Node_Str", c, Math.exp(f.getLogUnormalizedScore(c))));
                }
                out.write("String_Node_Str");
            } else {
                log.warn("String_Node_Str", f.getClass());
            }
        }
        out.close();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

Output:
                 out.write(vars.size() + "String_Node_Str");
-                for (int v = vars.size() - 1; v >= 0; v--) {
-                    out.write("String_Node_Str" + vars.get(v).getId());
-                    if (v > 0) {
-                        out.write("String_Node_Str");
-                    }
-                }
+                out.write(vars.stream().map(v -> Integer.toString(v.getId())).collect(Collectors.joining("String_Node_Str")));
                 out.write("String_Node_Str");


Input:
public int evaluate(int x, int y) {
    int ans = 0;
    if (!infoBoard.canMove(x, y))
        return -100;
    if (isWinner(x, y))
        ans += 500;
    if (isBlocker(x, y))
        ans += 250;
    if (isCenter(x, y))
        ans += 100;
    if (isCorner(x, y))
        ans += 25;
    return ans + (int) (Math.random() * 10);
}

Output:
     if (isCorner(x, y))
-        ans += 25;
-    return ans + (int) (Math.random() * 10);
+        ans += 10;
+    if (catchCornerTrap(x, y))
+        ans += 50;
+    return ans + (int) (Math.random() * 5);
 }


Input:
public static void main(String[] args) throws FileNotFoundException, IOException {
    CommandOption.setSummary(Vectors2Vectors.class, "String_Node_Str");
    CommandOption.process(Vectors2Vectors.class, args);
    if (args.length == 0) {
        CommandOption.getList(Vectors2Vectors.class).printUsage(false);
        System.exit(-1);
    }
    if (false && !inputFile.wasInvoked()) {
        System.err.println("String_Node_Str");
        System.exit(-1);
    }
    Random r = randomSeed.wasInvoked() ? new Random(randomSeed.value) : new Random();
    double t = trainingProportion.value;
    double v = validationProportion.value;
    logger.info("String_Node_Str" + t);
    logger.info("String_Node_Str" + v);
    logger.info("String_Node_Str" + (1 - v - t));
    logger.info("String_Node_Str" + pruneInfogain.value);
    logger.info("String_Node_Str" + pruneCount.value);
    InstanceList instances = InstanceList.load(inputFile.value);
    if (t == 1.0 && !(pruneInfogain.wasInvoked() || pruneCount.wasInvoked()) && !(hideTargets.wasInvoked() || revealTargets.wasInvoked())) {
        System.err.println("String_Node_Str");
        instances.save(trainingFile.value());
        System.exit(0);
    }
    if (pruneInfogain.wasInvoked() || pruneCount.wasInvoked()) {
        if (t != 1.0) {
            throw new UnsupportedOperationException("String_Node_Str");
        }
        if (pruneCount.value > 0) {
            Instance firstInstance = instances.get(0);
            if (firstInstance.getData() instanceof FeatureSequence) {
                Alphabet oldAlphabet = instances.getDataAlphabet();
                Alphabet newAlphabet = new Alphabet();
                Noop newPipe = new Noop(newAlphabet, instances.getTargetAlphabet());
                InstanceList newInstanceList = new InstanceList(newPipe);
                int numFeatures = oldAlphabet.size();
                double[] counts = new double[numFeatures];
                for (int ii = 0; ii < instances.size(); ii++) {
                    Instance instance = instances.get(ii);
                    FeatureSequence fs = (FeatureSequence) instance.getData();
                    fs.addFeatureWeightsTo(counts);
                }
                Instance instance, newInstance;
                while (instances.size() > 0) {
                    instance = instances.get(0);
                    FeatureSequence fs = (FeatureSequence) instance.getData();
                    fs.prune(counts, newAlphabet, pruneCount.value);
                    newInstanceList.add(newPipe.instanceFrom(new Instance(fs, instance.getTarget(), instance.getName(), instance.getSource())));
                    instances.remove(0);
                }
                logger.info("String_Node_Str" + oldAlphabet.size() + "String_Node_Str" + newAlphabet.size());
                instances = newInstanceList;
            } else if (firstInstance.getData() instanceof FeatureVector) {
                Alphabet alpha2 = new Alphabet();
                Noop pipe2 = new Noop(alpha2, instances.getTargetAlphabet());
                InstanceList instances2 = new InstanceList(pipe2);
                int numFeatures = instances.getDataAlphabet().size();
                double[] counts = new double[numFeatures];
                for (int ii = 0; ii < instances.size(); ii++) {
                    Instance instance = instances.get(ii);
                    FeatureVector fv = (FeatureVector) instance.getData();
                    fv.addTo(counts);
                }
                BitSet bs = new BitSet(numFeatures);
                for (int fi = 0; fi < numFeatures; fi++) {
                    if (counts[fi] > pruneCount.value) {
                        bs.set(fi);
                    }
                }
                logger.info("String_Node_Str" + (numFeatures - bs.cardinality()) + "String_Node_Str" + numFeatures + "String_Node_Str" + (bs.cardinality()) + "String_Node_Str");
                FeatureSelection fs = new FeatureSelection(instances.getDataAlphabet(), bs);
                for (int ii = 0; ii < instances.size(); ii++) {
                    Instance instance = instances.get(ii);
                    FeatureVector fv = (FeatureVector) instance.getData();
                    FeatureVector fv2 = FeatureVector.newFeatureVector(fv, alpha2, fs);
                    instances2.add(new Instance(fv2, instance.getTarget(), instance.getName(), instance.getSource()), instances.getInstanceWeight(ii));
                    instance.unLock();
                    instance.setData(null);
                }
                instances = instances2;
            } else {
                throw new UnsupportedOperationException("String_Node_Str" + firstInstance.getClass().getName() + "String_Node_Str");
            }
        }
        if (pruneInfogain.value > 0) {
            Alphabet alpha2 = new Alphabet();
            Noop pipe2 = new Noop(alpha2, instances.getTargetAlphabet());
            InstanceList instances2 = new InstanceList(pipe2);
            InfoGain ig = new InfoGain(instances);
            FeatureSelection fs = new FeatureSelection(ig, pruneInfogain.value);
            for (int ii = 0; ii < instances.size(); ii++) {
                Instance instance = instances.get(ii);
                FeatureVector fv = (FeatureVector) instance.getData();
                FeatureVector fv2 = FeatureVector.newFeatureVector(fv, alpha2, fs);
                instance.unLock();
                instance.setData(null);
                instances2.add(pipe2.instanceFrom(new Instance(fv2, instance.getTarget(), instance.getName(), instance.getSource())), instances.getInstanceWeight(ii));
            }
            instances = instances2;
        }
        if (vectorToSequence.value) {
            Alphabet alpha = instances.getDataAlphabet();
            Noop pipe2 = new Noop(alpha, instances.getTargetAlphabet());
            InstanceList instances2 = new InstanceList(pipe2);
            for (int ii = 0; ii < instances.size(); ii++) {
                Instance instance = instances.get(ii);
                FeatureVector fv = (FeatureVector) instance.getData();
                ArrayList seq = new ArrayList();
                for (int loc = 0; loc < fv.numLocations(); loc++) for (int count = 0; count < fv.valueAtLocation(loc); count++) seq.add(new Integer(fv.indexAtLocation(loc)));
                Collections.shuffle(seq);
                int[] indices = new int[seq.size()];
                for (int i = 0; i < indices.length; i++) indices[i] = ((Integer) seq.get(i)).intValue();
                FeatureSequence fs = new FeatureSequence(alpha, indices);
                instance.unLock();
                instance.setData(null);
                instances2.add(pipe2.instanceFrom(new Instance(fs, instance.getTarget(), instance.getName(), instance.getSource())), instances.getInstanceWeight(ii));
            }
            instances = instances2;
        }
        if (outputFile.wasInvoked()) {
            writeInstanceList(instances, outputFile.value());
        } else if (trainingFile.wasInvoked()) {
            writeInstanceList(instances, trainingFile.value());
        } else {
            throw new IllegalArgumentException("String_Node_Str");
        }
    } else if (trainingProportion.wasInvoked() || validationProportion.wasInvoked()) {
        InstanceList[] instanceLists = instances.split(r, new double[] { t, 1 - t - v, v });
        if (instanceLists[0].size() > 0)
            writeInstanceList(instanceLists[0], trainingFile.value());
        if (instanceLists[1].size() > 0)
            writeInstanceList(instanceLists[1], testFile.value());
        if (instanceLists[2].size() > 0)
            writeInstanceList(instanceLists[2], validationFile.value());
    } else if (hideTargets.wasInvoked()) {
        Iterator<Instance> iter = instances.iterator();
        while (iter.hasNext()) {
            Instance instance = iter.next();
            instance.unLock();
            instance.setProperty("String_Node_Str", instance.getTarget());
            instance.setTarget(null);
            instance.lock();
        }
        writeInstanceList(instances, outputFile.value());
    } else if (revealTargets.wasInvoked()) {
        Iterator<Instance> iter = instances.iterator();
        while (iter.hasNext()) {
            Instance instance = iter.next();
            instance.unLock();
            instance.setTarget(instance.getProperty("String_Node_Str"));
            instance.lock();
        }
        writeInstanceList(instances, outputFile.value());
    }
}

Output:
     InstanceList instances = InstanceList.load(inputFile.value);
-    if (t == 1.0 && !(pruneInfogain.wasInvoked() || pruneCount.wasInvoked()) && !(hideTargets.wasInvoked() || revealTargets.wasInvoked())) {
+    if (t == 1.0 && !vectorToSequence.value && !(pruneInfogain.wasInvoked() || pruneCount.wasInvoked()) && !(hideTargets.wasInvoked() || revealTargets.wasInvoked())) {
         System.err.println("String_Node_Str");


Input:
public void testNamespaceResolver() {
    assertNotNull("String_Node_Str", xmlContext);
    XMLDescriptor xdesc = xmlContext.getDescriptor(new QName("String_Node_Str", "String_Node_Str"));
    assertNotNull("String_Node_Str", xdesc);
    String prefix = xdesc.getNamespaceResolver().resolveNamespaceURI("String_Node_Str");
    String prefix2 = xdesc.getNamespaceResolver().resolveNamespaceURI("String_Node_Str");
    assertEquals("String_Node_Str", prefix);
    assertEquals("String_Node_Str", prefix2);
}

Output:
     assertNotNull("String_Node_Str", xdesc);
-    String prefix = xdesc.getNamespaceResolver().resolveNamespaceURI("String_Node_Str");
-    String prefix2 = xdesc.getNamespaceResolver().resolveNamespaceURI("String_Node_Str");
-    assertEquals("String_Node_Str", prefix);
-    assertEquals("String_Node_Str", prefix2);
+    String uriA = "String_Node_Str";
+    String uriB = "String_Node_Str";
+    String prefixA = "String_Node_Str";
+    String prefixNewA = "String_Node_Str";
+    String prefixB = "String_Node_Str";
+    assertEquals(uriA, xdesc.getNamespaceResolver().resolveNamespacePrefix(prefixA));
+    assertEquals(uriA, xdesc.getNamespaceResolver().resolveNamespacePrefix(prefixNewA));
+    assertEquals(uriB, xdesc.getNamespaceResolver().resolveNamespacePrefix(prefixB));
 }


Input:
public void test_DaxosGotBoostWithLoseFlyAndGotItAgain() {
    addCard(Zone.HAND, playerA, daxosCard, 1);
    addCard(Zone.BATTLEFIELD, playerA, "String_Node_Str", 4);
    addCard(Zone.HAND, playerA, "String_Node_Str", 1);
    addCard(Zone.BATTLEFIELD, playerA, "String_Node_Str", 3);
    castSpell(1, PhaseStep.PRECOMBAT_MAIN, playerA, daxosCard);
    castSpell(1, PhaseStep.POSTCOMBAT_MAIN, playerA, "String_Node_Str");
    setStopAt(1, PhaseStep.END_TURN);
    execute();
    assertHandCount(playerA, daxosCard, 0);
    assertPermanentCount(playerA, daxosCard, 1);
    assertHandCount(playerA, "String_Node_Str", 0);
    assertPermanentCount(playerA, "String_Node_Str", 1);
    assertPowerToughness(playerA, daxosCard, 5, 5);
    assertType(daxosCard, CardType.CREATURE, SubType.DEMON);
    assertAbility(playerA, daxosCard, FlyingAbility.getInstance(), true);
    assertAbility(playerA, daxosCard, HasteAbility.getInstance(), true);
}

Output:
     addCard(Zone.HAND, playerA, daxosCard, 1);
-    addCard(Zone.BATTLEFIELD, playerA, "String_Node_Str", 4);
+    addCard(Zone.BATTLEFIELD, playerA, "String_Node_Str", 1);
     addCard(Zone.HAND, playerA, "String_Node_Str", 1);


Input:
public void onChildEvent(MonitorStatusEvent statusEvent) {
    String id = statusEvent.getId();
    LifeCycleState status1 = statusEvent.getStatus();
    if (status1 == ClusterStatus.Active || status1 == GroupStatus.Active) {
        onChildActivatedEvent(id);
    } else if (status1 == ClusterStatus.Inactive || status1 == GroupStatus.Inactive) {
        onChildInActiveEvent(id);
    } else if (status1 == ClusterStatus.Terminating || status1 == GroupStatus.Terminated) {
        this.markMonitorAsInactive(id);
    } else if (status1 == ClusterStatus.Terminated || status1 == GroupStatus.Terminated) {
        if (this.aliasToInActiveMonitorsMap.containsKey(id)) {
            this.aliasToInActiveMonitorsMap.remove(id);
        } else {
            log.warn("String_Node_Str" + id + "String_Node_Str");
        }
        if (this.status != ApplicationStatus.Terminating || this.status != ApplicationStatus.Terminated) {
            onChildTerminatedEvent(id);
        } else {
            StatusChecker.getInstance().onChildStatusChange(id, this.id, this.appId);
            log.info("String_Node_Str" + id);
        }
    }
}

Output:
         onChildInActiveEvent(id);
-    } else if (status1 == ClusterStatus.Terminating || status1 == GroupStatus.Terminated) {
+    } else if (status1 == ClusterStatus.Terminating || status1 == GroupStatus.Terminating) {
         this.markMonitorAsInactive(id);


Input:
private SortedMap<Integer, FabricLink> defaultLinkToColumn(SortedMap<Integer, SortedSet<Integer>> rankedLinks, Map<Link, SortedMap<FabricLink.AugRelation, FabricLink>> relsForPair, HashMap<Integer, String> rowToTarg, BioFabricNetwork.RelayoutBuildData rbd) {
    TreeMap<Integer, FabricLink> linkOrder = new TreeMap<Integer, FabricLink>();
    ArrayList<String> microRels;
    ArrayList<String> macroRels;
    if (rbd.layoutMode == BioFabricNetwork.LayoutMode.PER_NODE_MODE) {
        microRels = new ArrayList<String>(rbd.linkGroups);
        macroRels = null;
    } else if (rbd.layoutMode == BioFabricNetwork.LayoutMode.PER_NETWORK_MODE) {
        microRels = new ArrayList<String>();
        macroRels = new ArrayList<String>(rbd.linkGroups);
    } else {
        microRels = new ArrayList<String>();
        macroRels = null;
    }
    if (microRels.isEmpty()) {
        microRels.add("String_Node_Str");
    }
    int numRel = microRels.size();
    int colCount = 0;
    int rowCount = rbd.nodeOrder.size();
    for (int k = 0; k < rowCount; k++) {
        Integer topRow = Integer.valueOf(k);
        for (int i = 0; i < numRel; i++) {
            String relOnly = microRels.get(i);
            if (relOnly.equals("String_Node_Str")) {
                relOnly = null;
            }
            colCount = shadowLinkToColumn(topRow.intValue(), rankedLinks, relsForPair, relOnly, microRels, colCount, rowToTarg, rbd, linkOrder);
            SortedSet<Integer> perSrc = rankedLinks.get(topRow);
            if (perSrc == null) {
                continue;
            }
            Iterator<Integer> psit = perSrc.iterator();
            while (psit.hasNext()) {
                Integer botRow = psit.next();
                String topNode = rowToTarg.get(topRow);
                String botNode = rowToTarg.get(botRow);
                SortedMap<FabricLink.AugRelation, FabricLink> forPair1 = relsForPair.get(new Link(topNode, botNode));
                if (forPair1 != null) {
                    Iterator<FabricLink> fp1it = forPair1.values().iterator();
                    while (fp1it.hasNext()) {
                        FabricLink nextLink = fp1it.next();
                        if (!nextLink.isShadow()) {
                            if (bestSuffixMatch(nextLink, relOnly, microRels)) {
                                Integer shadowKey = Integer.valueOf(colCount++);
                                linkOrder.put(shadowKey, nextLink);
                            }
                        }
                    }
                }
                if (!topNode.equals(botNode)) {
                    SortedMap<FabricLink.AugRelation, FabricLink> forPair2 = relsForPair.get(new Link(botNode, topNode));
                    if (forPair2 != null) {
                        Iterator<FabricLink> fp2it = forPair2.values().iterator();
                        while (fp2it.hasNext()) {
                            FabricLink nextLink = fp2it.next();
                            if (!nextLink.isShadow()) {
                                if (bestSuffixMatch(nextLink, relOnly, microRels)) {
                                    Integer shadowKey = Integer.valueOf(colCount++);
                                    linkOrder.put(shadowKey, nextLink);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    if (rbd.getMode() == BioFabricNetwork.BuildMode.GROUP_PER_NETWORK_CHANGE) {
        orderNetworkByGroups(linkOrder, macroRels);
    }
    return (linkOrder);
}

Output:
                         if (!nextLink.isShadow()) {
-                            if (bestSuffixMatch(nextLink, relOnly, microRels)) {
+                            String augRel = nextLink.getAugRelation().relation;
+                            if (bestSuffixMatch(augRel, relOnly, microRels)) {
                                 Integer shadowKey = Integer.valueOf(colCount++);


Input:
protected void internalTransform(Body b, String phaseName, Map<String, String> options) {
    if (!b.getTraps().isEmpty())
        return;
    Unit u1 = null, u2 = null;
    for (Iterator<Unit> uIt = b.getUnits().snapshotIterator(); uIt.hasNext(); ) {
        Unit u = uIt.next();
        if (!(u instanceof AssignStmt) || !((Stmt) u).getBoxesPointingToThis().isEmpty()) {
            u1 = null;
            u2 = null;
            continue;
        }
        AssignStmt assignStmt = (AssignStmt) u;
        if (assignStmt.getLeftOp() instanceof ArrayRef) {
            if (u1 != null && u2 != null) {
                ArrayRef arrayRef = (ArrayRef) assignStmt.getLeftOp();
                Value u1val = u1.getDefBoxes().get(0).getValue();
                Value u2val = u2.getDefBoxes().get(0).getValue();
                if (arrayRef.getIndex() == u1val)
                    arrayRef.setIndex(((AssignStmt) u1).getRightOp());
                else if (arrayRef.getIndex() == u2val)
                    arrayRef.setIndex(((AssignStmt) u2).getRightOp());
                if (assignStmt.getRightOp() == u1val)
                    assignStmt.setRightOp(((AssignStmt) u1).getRightOp());
                else if (assignStmt.getRightOp() == u2val)
                    assignStmt.setRightOp(((AssignStmt) u2).getRightOp());
                Unit checkU = u;
                boolean foundU1 = false, foundU2 = false, doneU1 = false, doneU2 = false;
                while (!(doneU1 && doneU2) && !(foundU1 && foundU2) && checkU != null) {
                    for (ValueBox vb : checkU.getUseBoxes()) {
                        if (!doneU1 && vb.getValue() == u1val)
                            foundU1 = true;
                        if (!doneU2 && vb.getValue() == u2val)
                            foundU2 = true;
                    }
                    for (ValueBox vb : checkU.getDefBoxes()) {
                        if (vb.getValue() == u1val)
                            doneU1 = true;
                        else if (vb.getValue() == u2val)
                            doneU2 = true;
                    }
                    if (checkU.branches()) {
                        foundU1 = true;
                        foundU2 = true;
                        break;
                    }
                    checkU = b.getUnits().getSuccOf(checkU);
                }
                if (!foundU1) {
                    if (u1val instanceof Local) {
                        b.getUnits().remove(u1);
                        if (Options.v().verbose()) {
                            G.v().out.println("String_Node_Str" + b.getMethod().getName() + "String_Node_Str" + u1);
                        }
                    }
                }
                if (!foundU2) {
                    if (u2val instanceof Local) {
                        b.getUnits().remove(u2);
                        if (Options.v().verbose()) {
                            G.v().out.println("String_Node_Str" + b.getMethod().getName() + "String_Node_Str" + u2);
                        }
                    }
                }
                u1 = null;
                u2 = null;
            } else {
                u1 = null;
                u2 = null;
                continue;
            }
        }
        if (!(assignStmt.getRightOp() instanceof Constant)) {
            u1 = null;
            u2 = null;
            continue;
        }
        if (u1 == null) {
            u1 = assignStmt;
        } else if (u2 == null) {
            u2 = assignStmt;
        } else {
            u1 = u2;
            u2 = assignStmt;
        }
    }
    UnusedLocalEliminator.v().transform(b);
}

Output:
         if (assignStmt.getLeftOp() instanceof ArrayRef) {
-            if (u1 != null && u2 != null) {
+            if (u1 != null && u2 != null && u2.getBoxesPointingToThis().isEmpty() && assignStmt.getBoxesPointingToThis().isEmpty()) {
                 ArrayRef arrayRef = (ArrayRef) assignStmt.getLeftOp();


Input:
public Object getAdapter(Object adaptableObject, Class adapterType) {
    if (adapterType == IBindingDialogHelper.class && ChartReportItemUtil.isChartHandle(adaptableObject)) {
        if (ChartXTabUtil.getBindingCube((ExtendedItemHandle) adaptableObject) != null) {
            return new ChartCubeBindingDialogHelper();
        } else {
            return new BindingDialogHelper();
        }
    }
    return null;
}

Output:
         } else {
-            return new BindingDialogHelper();
+            return new ChartDataSetBindingDialogHelper();
         }


Input:
public boolean apply(Game game, Ability source) {
    Card card;
    Player player = game.getPlayer(source.getControllerId());
    ExileZone exile = game.getExile().createZone(source.getSourceId(), player.getName() + "String_Node_Str");
    int sourceCost = game.getCard(source.getSourceId()).getManaCost().convertedManaCost();
    do {
        card = player.getLibrary().removeFromTop(game);
        if (card == null) {
            break;
        }
        card.moveToExile(exile.getId(), exile.getName(), source.getId(), game);
    } while (card.getCardType().contains(CardType.LAND) || card.getManaCost().convertedManaCost() >= sourceCost);
    if (card != null) {
        if (player.chooseUse(outcome, "String_Node_Str" + card.getName() + "String_Node_Str", game)) {
            player.cast(card.getSpellAbility(), game, true);
            exile.remove(card.getId());
        }
    }
    while (exile.size() > 0) {
        card = exile.getRandom(game);
        exile.remove(card.getId());
        card.moveToZone(Zone.LIBRARY, source.getId(), game, false);
    }
    return true;
}

Output:
     ExileZone exile = game.getExile().createZone(source.getSourceId(), player.getName() + "String_Node_Str");
-    int sourceCost = game.getCard(source.getSourceId()).getManaCost().convertedManaCost();
+    Card stackCard = game.getCard(targetPointer.getFirst(game, source));
+    if (stackCard == null) {
+        return false;
+    }
+    int sourceCost = stackCard.getManaCost().convertedManaCost();
     do {


Input:
private ClassNode loadNode(String type) {
    if (type == null) {
        return null;
    } else if (nodes.containsKey(type)) {
        return nodes.get(type);
    }
    String nameStr = type.replace("String_Node_Str", "String_Node_Str");
    try {
        Class<?> clazz = Class.forName(nameStr);
        if (clazz == null) {
            return null;
        }
        return recaf.asm.getNode(clazz);
    } catch (IOException e) {
        return null;
    } catch (ClassNotFoundException e) {
        return null;
    }
}

Output:
         Class<?> clazz = Class.forName(nameStr);
-        if (clazz == null) {
-            return null;
+        if (clazz != null) {
+            return recaf.asm.getNode(clazz);
         }


Input:
public Stack getPublicStack(String name, CbUser cbUser) {
    Stack stack = stackRepository.findByNameInAccount(name, cbUser.getAccount(), cbUser.getUserId());
    if (stack == null) {
        throw new NotFoundException(String.format("String_Node_Str", name));
    }
    MDCBuilder.buildMdcContext(stack);
    return stack;
}

Output:
 public Stack getPublicStack(String name, CbUser cbUser) {
-    Stack stack = stackRepository.findByNameInAccount(name, cbUser.getAccount(), cbUser.getUserId());
+    Stack stack = stackRepository.findOneByName(name);
     if (stack == null) {


Input:
public void listAssets() {
    try {
        Statement queryStatement = dbConnection.createStatement();
        ResultSet result = queryStatement.executeQuery(strGetListEntries);
        logger.fine("String_Node_Str");
        while (result.next()) {
            StringBuilder sb = new StringBuilder();
            sb.append(result.getString("String_Node_Str") + "String_Node_Str");
            sb.append(result.getString("String_Node_Str") + "String_Node_Str");
            sb.append(result.getString("String_Node_Str") + "String_Node_Str");
            sb.append(result.getString("String_Node_Str") + "String_Node_Str");
            sb.append(result.getLong("String_Node_Str") + "String_Node_Str");
            sb.append(result.getLong("String_Node_Str") + "String_Node_Str");
            logger.fine(sb.toString());
        }
        logger.fine("String_Node_Str");
    } catch (SQLException sqle) {
        sqle.printStackTrace();
    }
}

Output:
         ResultSet result = queryStatement.executeQuery(strGetListEntries);
-        logger.fine("String_Node_Str");
+        logger.warning("String_Node_Str");
         while (result.next()) {


Input:
private void addConverterDependsOnTrackings(Converter conv, BindContext ctx) {
    final Class convClz = conv.getClass();
    if (_doneConverterDependsOn.contains(convClz)) {
        return;
    }
    _doneConverterDependsOn.add(convClz);
    final Method m = getConverterMethod(convClz);
    final String srcpath = getPropertyString();
    BindELContext.addDependsOnTrackings(m, srcpath, null, this, ctx);
}

Output:
 private void addConverterDependsOnTrackings(Converter conv, BindContext ctx) {
-    final Class convClz = conv.getClass();
+    final Class<? extends Converter> convClz = conv.getClass();
     if (_doneConverterDependsOn.contains(convClz)) {


Input:
public String decryptWithSessionKey(String ciphertext) throws CryptoHelperException {
    status = false;
    if (password == null) {
        String msg = "String_Node_Str";
        throw new CryptoHelperException(msg);
    }
    if ((ciphertext == null) || (ciphertext == "String_Node_Str")) {
        return "String_Node_Str";
    }
    String cipherSessionKey = null;
    try {
        cipherSessionKey = ciphertext.substring(0, 96);
        ciphertext = ciphertext.substring(96);
    } catch (IndexOutOfBoundsException e) {
        Log.e(TAG, "String_Node_Str");
        return "String_Node_Str";
    }
    byte[] byteCipherSessionKey = hexStringToBytes(cipherSessionKey);
    byte[] byteSessionKey = {};
    try {
        pbeCipher.init(Cipher.DECRYPT_MODE, pbeKey, pbeParamSpec);
        byteSessionKey = pbeCipher.doFinal(byteCipherSessionKey);
        status = true;
    } catch (IllegalBlockSizeException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (BadPaddingException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidKeyException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidAlgorithmParameterException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    String stringSessionKey = new String(byteSessionKey);
    PBEKeySpec sessionPbeKeySpec = new PBEKeySpec(stringSessionKey.toCharArray());
    SecretKey sessionPbeKey = null;
    try {
        sessionPbeKey = keyFac.generateSecret(sessionPbeKeySpec);
    } catch (InvalidKeySpecException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    byte[] byteCiphertext = hexStringToBytes(ciphertext);
    byte[] plaintext = {};
    try {
        pbeCipher.init(Cipher.DECRYPT_MODE, sessionPbeKey, pbeParamSpec);
        plaintext = pbeCipher.doFinal(byteCiphertext);
        status = true;
    } catch (IllegalBlockSizeException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (BadPaddingException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidKeyException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidAlgorithmParameterException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    return new String(plaintext);
}

Output:
     try {
-        cipherSessionKey = ciphertext.substring(0, 96);
-        ciphertext = ciphertext.substring(96);
+        cipherVersion = ciphertext.substring(0, 1);
+        if (cipherVersion.equals("String_Node_Str")) {
+            cipherSessionKey = ciphertext.substring(1, 97);
+            ciphertext = ciphertext.substring(97);
+        } else {
+            Log.e(TAG, "String_Node_Str" + cipherVersion);
+            return "String_Node_Str";
+        }
     } catch (IndexOutOfBoundsException e) {


Input:
public void testCreateItemWith2Args() throws Exception {
    String propLabel = "String_Node_Str";
    String nextId = "String_Node_Str";
    Item mockItem = mock(Item.class);
    ItemState mockItemState = mock(ItemState.class);
    when(mockItem.getState()).thenReturn(mockItemState);
    when(mockItem.getState().getPath()).thenReturn("String_Node_Str");
    IProxyRepositoryFactory repositoryFactory = mock(IProxyRepositoryFactory.class);
    when(CoreRuntimePlugin.getInstance().getProxyRepositoryFactory()).thenReturn(repositoryFactory);
    RepositoryContext mockContext = mock(RepositoryContext.class);
    when(repositoryFactory.getRepositoryContext()).thenReturn(mockContext);
    when(repositoryFactory.getNextId()).thenReturn(nextId);
    Property mockProperty = mock(Property.class);
    when(mockItem.getProperty()).thenReturn(mockProperty);
    PropertiesFactory proFactory = PropertiesFactory.eINSTANCE;
    PropertiesFactory spyProFactory = PowerMockito.spy(proFactory);
    when(spyProFactory.createProperty()).thenReturn(mockProperty);
    User user = mock(User.class);
    when(mockContext.getUser()).thenReturn(user);
    RecycleBinNodeConfiguration mockRBNConf = mock(RecycleBinNodeConfiguration.class);
    PowerMockito.whenNew(RecycleBinNodeConfiguration.class).withNoArguments().thenReturn(mockRBNConf);
    PowerMockito.mockStatic(RepositoryNodeConfigurationManager.class);
    IRepositoryNodeConfiguration mockConfManager = mock(IRepositoryNodeConfiguration.class);
    when(RepositoryNodeConfigurationManager.getConfiguration(Mockito.any(Item.class))).thenReturn(mockConfManager);
    IRepositoryNodeResourceProvider mockResourceProvider = mock(IRepositoryNodeResourceProvider.class);
    when(mockConfManager.getResourceProvider()).thenReturn(mockResourceProvider);
    when(mockResourceProvider.needSaveReferenceFile()).thenReturn(true);
    when(repositoryFactory.isEditableAndLockIfPossible(mockItem)).thenReturn(true);
    boolean createItem = RepositoryResourceUtil.createItem(mockItem, propLabel);
    verify(mockProperty, times(1)).setId(nextId);
    verify(mockProperty, times(1)).setVersion(Mockito.anyString());
    verify(mockProperty, times(1)).setAuthor(user);
    verify(mockProperty, times(1)).setLabel(propLabel);
    verify(repositoryFactory, times(1)).create(Mockito.any(Item.class), Mockito.any(IPath.class), Mockito.any(Boolean.class));
    verify(mockResourceProvider, times(1)).handleReferenceFile(mockItem);
    verify(repositoryFactory, times(1)).unlock(mockItem);
    assertTrue(createItem);
}

Output:
     verify(mockProperty, times(1)).setLabel(propLabel);
-    verify(repositoryFactory, times(1)).create(Mockito.any(Item.class), Mockito.any(IPath.class), Mockito.any(Boolean.class));
+    verify(repositoryFactory, times(1)).create(Mockito.any(Item.class), Mockito.any(IPath.class));
     verify(mockResourceProvider, times(1)).handleReferenceFile(mockItem);


Input:
public void update(final Cluster cluster, final List<ClusterAddressInfo> ccList) {
    if (!cluster.getState().isAddressingInitialized()) {
        Helper.loadStoredAddresses(cluster);
        cluster.getState().setAddressingInitialized(true);
    }
    for (final ClusterAddressInfo addrInfo : ccList) {
        try {
            final Address address = Helper.lookupOrCreate(cluster, addrInfo);
            if (address.isAssigned() && !addrInfo.hasMapping() && !address.isPending()) {
                if (Principals.nobodyFullName().equals(address.getOwner())) {
                    Helper.markAsAllocated(cluster, addrInfo, address);
                }
                try {
                    final VmInstance vm = VmInstances.lookupByInstanceIp(addrInfo.getInstanceIp());
                    clearOrphan(addrInfo);
                } catch (final NoSuchElementException e) {
                    try {
                        final VmInstance vm = VmInstances.lookup(address.getInstanceId());
                        clearOrphan(addrInfo);
                    } catch (final NoSuchElementException ex) {
                        InetAddress addr = null;
                        try {
                            addr = Inet4Address.getByName(addrInfo.getInstanceIp());
                        } catch (final UnknownHostException e1) {
                            LOG.debug(e1, e1);
                        }
                        if ((addr == null) || !addr.isLoopbackAddress()) {
                            handleOrphan(cluster.getName(), addrInfo);
                        }
                    }
                }
            } else if (address.isAllocated() && Principals.nobodyFullName().equals(address.getOwner()) && !address.isPending()) {
                Helper.markAsAllocated(cluster, addrInfo, address);
            }
        } catch (final Exception e) {
            LOG.debug(e, e);
        }
    }
}

Output:
                 try {
-                    final VmInstance vm = VmInstances.lookupByInstanceIp(addrInfo.getInstanceIp());
+                    final VmInstance vm = VmInstances.lookupByPrivateIp(addrInfo.getInstanceIp());
                     clearOrphan(addrInfo);


Input:
public boolean applies(Ability abilityToModify, Ability source, Game game) {
    if (abilityToModify instanceof SpellAbility) {
        Card card = game.getCard(abilityToModify.getSourceId());
        if (card != null && !card.getCardType().contains(CardType.CREATURE)) {
            return true;
        }
    }
    return false;
}

Output:
 public boolean applies(Ability abilityToModify, Ability source, Game game) {
-    if (abilityToModify instanceof SpellAbility) {
+    if (abilityToModify instanceof SpellAbility || abilityToModify instanceof FlashbackAbility || abilityToModify instanceof RetraceAbility) {
         Card card = game.getCard(abilityToModify.getSourceId());


Input:
public void addAbility(Ability ability, MageObject attachedTo) {
    if (ability instanceof StaticAbility) {
        if (ability instanceof KickerAbility) {
            return;
        }
        for (Mode mode : ability.getModes().values()) {
            for (Effect effect : mode.getEffects()) {
                if (effect instanceof ContinuousEffect) {
                    addEffect((ContinuousEffect) effect, ability);
                }
            }
        }
    } else if (ability instanceof TriggeredAbility) {
        this.triggers.add((TriggeredAbility) ability, attachedTo);
    }
}

Output:
                 if (effect instanceof ContinuousEffect) {
-                    addEffect((ContinuousEffect) effect, ability);
+                    addEffect((ContinuousEffect) effect, sourceId, ability);
                 }


Input:
public void OnEnterPressed(KeyEvent keyEvent) {
    textFieldValidated();
}

Output:
 public void OnEnterPressed(KeyEvent keyEvent) {
-    textFieldValidated();
+    if (textFieldValidated())
+        folderChangeCompleted(false);
+    keyEvent.consume();
 }


Input:
public void testZeroLengthMessage() {
    File tmpDir = getTmpDir();
    try (ChronicleQueue chronicle = SingleChronicleQueueBuilder.binary(tmpDir).wireType(this.wireType).build()) {
        ExcerptAppender appender = chronicle.createAppender();
        appender.writeDocument(w -> {
        });
        System.out.println(chronicle.dump());
    }
}

Output:
     File tmpDir = getTmpDir();
-    try (ChronicleQueue chronicle = SingleChronicleQueueBuilder.binary(tmpDir).wireType(this.wireType).build()) {
+    try (ChronicleQueue chronicle = SingleChronicleQueueBuilder.binary(tmpDir).rollCycle(RollCycles.TEST_DAILY).wireType(this.wireType).build()) {
         ExcerptAppender appender = chronicle.createAppender();


Input:
private void placeComponents() {
    GridLayout glContent = new GridLayout(3, true);
    glContent.marginHeight = 2;
    glContent.marginWidth = 2;
    this.setLayout(glContent);
    grpAccLine = new Group(this, SWT.NONE);
    GridData gdGRPAccLine = new GridData(GridData.FILL_HORIZONTAL);
    GridLayout glGRPAccline = new GridLayout(2, false);
    glGRPAccline.verticalSpacing = 0;
    grpAccLine.setLayout(glGRPAccline);
    grpAccLine.setLayoutData(gdGRPAccLine);
    grpAccLine.setText(Messages.getString("String_Node_Str"));
    liacAccLine = new LineAttributesComposite(grpAccLine, SWT.NONE, context, ((BubbleSeries) series).getAccLineAttributes(), true, true, true);
    GridData gdLIACAccLine = new GridData(GridData.FILL_BOTH);
    gdLIACAccLine.horizontalSpan = 2;
    liacAccLine.setLayoutData(gdLIACAccLine);
    liacAccLine.addListener(this);
    Composite cmpOrientation = new Composite(grpAccLine, SWT.NONE);
    {
        GridLayout gl = new GridLayout(2, false);
        gl.marginHeight = 0;
        gl.marginBottom = 0;
        gl.verticalSpacing = 0;
        cmpOrientation.setLayout(gl);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = 2;
        cmpOrientation.setLayoutData(gd);
    }
    lblOrientation = new Label(cmpOrientation, SWT.NONE);
    lblOrientation.setText(Messages.getString("String_Node_Str"));
    cmbOrientation = new Combo(cmpOrientation, SWT.DROP_DOWN | SWT.READ_ONLY);
    GridData gdCMBOrientation = new GridData(GridData.FILL_HORIZONTAL);
    cmbOrientation.setLayoutData(gdCMBOrientation);
    cmbOrientation.addSelectionListener(this);
    grpLine = new Group(this, SWT.NONE);
    GridData gdGRPLine = new GridData(GridData.FILL_HORIZONTAL);
    gdGRPLine.horizontalSpan = 2;
    grpLine.setLayoutData(gdGRPLine);
    GridLayout glLine = new GridLayout(2, false);
    glLine.horizontalSpacing = 0;
    grpLine.setLayout(glLine);
    grpLine.setText(Messages.getString("String_Node_Str"));
    Composite cmpLine = new Composite(grpLine, SWT.NONE);
    {
        GridLayout gl = new GridLayout(2, false);
        gl.marginHeight = 0;
        gl.marginWidth = 0;
        gl.horizontalSpacing = 0;
        gl.verticalSpacing = 0;
        cmpLine.setLayout(gl);
        cmpLine.setLayoutData(new GridData(GridData.FILL_BOTH));
    }
    liacLine = new LineAttributesComposite(cmpLine, SWT.NONE, context, ((BubbleSeries) series).getLineAttributes(), true, true, true);
    GridData gdLIACLine = new GridData(GridData.FILL_HORIZONTAL);
    gdLIACLine.horizontalSpan = 2;
    liacLine.setLayoutData(gdLIACLine);
    liacLine.addListener(this);
    Composite cmpShadow = new Composite(cmpLine, SWT.NONE);
    {
        GridLayout gl = new GridLayout(2, false);
        gl.marginHeight = 0;
        gl.marginBottom = 0;
        gl.verticalSpacing = 0;
        cmpShadow.setLayout(gl);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = 2;
        cmpShadow.setLayoutData(gd);
    }
    lblShadow = new Label(cmpShadow, SWT.NONE);
    lblShadow.setText(Messages.getString("String_Node_Str"));
    fccShadow = new FillChooserComposite(cmpShadow, SWT.NONE, context, ((BubbleSeries) series).getShadowColor(), false, false);
    GridData gdFCCShadow = new GridData(GridData.FILL_HORIZONTAL);
    fccShadow.setLayoutData(gdFCCShadow);
    fccShadow.addListener(this);
    Composite cmp = new Composite(grpLine, SWT.NONE);
    cmp.setLayout(new GridLayout());
    btnPalette = new Button(cmp, SWT.CHECK);
    {
        btnPalette.setText(Messages.getString("String_Node_Str"));
        btnPalette.setSelection(((BubbleSeries) series).isPaletteLineColor());
        btnPalette.addSelectionListener(this);
    }
    btnCurve = new Button(cmp, SWT.CHECK);
    {
        btnCurve.setText(Messages.getString("String_Node_Str"));
        btnCurve.setSelection(((BubbleSeries) series).isCurve());
        btnCurve.addSelectionListener(this);
    }
    enableLineSettings(((BubbleSeries) series).getLineAttributes().isVisible());
    enableAccLineSettings(((BubbleSeries) series).getAccLineAttributes().isVisible());
    populateLists();
}

Output:
     lblShadow.setText(Messages.getString("String_Node_Str"));
-    fccShadow = new FillChooserComposite(cmpShadow, SWT.NONE, context, ((BubbleSeries) series).getShadowColor(), false, false);
+    int iFillOption = FillChooserComposite.DISABLE_PATTERN_FILL | FillChooserComposite.ENABLE_TRANSPARENT | FillChooserComposite.ENABLE_TRANSPARENT_SLIDER;
+    fccShadow = new FillChooserComposite(cmpShadow, SWT.DROP_DOWN | SWT.READ_ONLY, iFillOption, context, ((BubbleSeries) series).getShadowColor());
     GridData gdFCCShadow = new GridData(GridData.FILL_HORIZONTAL);


Input:
protected void onDraw(Canvas canvas) {
    for (int i = 0; i < 5; i++) {
        mPaint.setColor(itemcolors[i]);
        canvas.drawRect(itemWidth * i, 0, itemWidth * (i + 1), barHeight, mPaint);
        canvas.save();
    }
    mPaint.setColor(backGroundColor);
    canvas.drawRect(0, 0, itemMoveLeft, barHeight, mPaint);
    canvas.drawRect(itemMoveRight, 0, itemWidth * 5, barHeight, mPaint);
    canvas.save();
    for (int i = 0; i < itemCount; i++) {
        int deltaX = Math.abs(itemMoveCenter - itemCenterX[i]);
        if (deltaX < itemWidth) {
            itemScale[i] = (float) (-0.5 * deltaX / itemWidth + 1);
        } else
            itemScale[i] = 0.5f;
        View childImageView = getChildAt(i);
        childImageView.setScaleX(itemScale[i]);
        childImageView.setScaleY(itemScale[i]);
        View childTextView = getChildAt(itemCount + i);
        childTextView.setScaleX(itemScale[i]);
        childTextView.setScaleY(itemScale[i]);
    }
    Log.d("String_Node_Str", "String_Node_Str" + selectIndex + "String_Node_Str" + itemScale[selectIndex]);
    super.onDraw(canvas);
}

Output:
             itemScale[i] = 0.5f;
-        View childImageView = getChildAt(i);
-        childImageView.setScaleX(itemScale[i]);
-        childImageView.setScaleY(itemScale[i]);
-        View childTextView = getChildAt(itemCount + i);
-        childTextView.setScaleX(itemScale[i]);
-        childTextView.setScaleY(itemScale[i]);
+        mImageViews.get(i).setScaleX(itemScale[i]);
+        mImageViews.get(i).setScaleY(itemScale[i]);
+        mTextViews.get(i).setScaleX(itemScale[i]);
+        mTextViews.get(i).setScaleY(itemScale[i]);
     }


Input:
public void addItem(String line) throws Exception {
    boolean last = false;
    if (line.endsWith(fieldSeparator)) {
        last = true;
        line += "String_Node_Str";
    }
    String[] parts = line.split(escapedFieldSeparator);
    ArrayList<String> bits = new ArrayList<String>();
    bits.addAll(Arrays.asList(parts));
    boolean alldone = false;
    while (!alldone) {
        boolean found = false;
        int i = 0;
        for (String part : bits) {
            int bitcounter = part.length() - part.replaceAll("String_Node_Str", "String_Node_Str").length();
            if ((part.startsWith("String_Node_Str")) && ((!part.endsWith("String_Node_Str")) || ((bitcounter % 2) == 1))) {
                found = true;
                String add = bits.get(i) + fieldSeparator + bits.get(i + 1);
                bits.remove(i);
                bits.add(i, add);
                bits.remove(i + 1);
                break;
            }
            i++;
        }
        alldone = !found;
    }
    int i = 0;
    for (String part : bits) {
        if ((part.startsWith("String_Node_Str")) && (part.endsWith("String_Node_Str"))) {
            part = part.substring(1, part.length() - 1);
            bits.set(i, part);
        }
        i++;
    }
    i = 0;
    for (String part : bits) {
        if (part.contains("String_Node_Str")) {
            part = part.replaceAll("String_Node_Str", "String_Node_Str");
            bits.set(i, part);
        }
        i++;
    }
    String id = parts[0].replaceAll("String_Node_Str", "String_Node_Str");
    DSpaceCSVLine csvLine;
    if ("String_Node_Str".equals(id)) {
        csvLine = new DSpaceCSVLine();
    } else {
        try {
            csvLine = new DSpaceCSVLine(Integer.parseInt(id));
        } catch (NumberFormatException nfe) {
            System.err.println("String_Node_Str" + id);
            System.err.println("String_Node_Str" + "String_Node_Str");
            throw (nfe);
        }
    }
    i = 0;
    for (String part : bits) {
        if (i > 0) {
            if ((last) && (i == headings.size())) {
                part = "String_Node_Str";
            }
            csvLine.add(headings.get(i - 1), null);
            String[] elements = part.split(escpaedValueSeparator);
            for (String element : elements) {
                if ((element != null) && (!"String_Node_Str".equals(element))) {
                    csvLine.add(headings.get(i - 1), element);
                }
            }
        }
        i++;
    }
    lines.add(csvLine);
    counter++;
}

Output:
             csvLine.add(headings.get(i - 1), null);
-            String[] elements = part.split(escpaedValueSeparator);
+            String[] elements = part.split(escapedValueSeparator);
             for (String element : elements) {


Input:
public TicketTaxInfo[] getTaxLines() {
    return taxes.toArray(new TicketTaxInfo[taxes.size()]);
}

Output:
 public TicketTaxInfo[] getTaxLines() {
-    return taxes.toArray(new TicketTaxInfo[taxes.size()]);
+    Map<String, TicketTaxInfo> m = new HashMap<String, TicketTaxInfo>();
+    TicketLineInfo oLine;
+    for (Iterator<TicketLineInfo> i = m_aLines.iterator(); i.hasNext(); ) {
+        oLine = i.next();
+        TicketTaxInfo t = m.get(oLine.getTaxInfo().getId());
+        if (t == null) {
+            t = new TicketTaxInfo(oLine.getTaxInfo());
+            m.put(t.getTaxInfo().getId(), t);
+        }
+        t.add(oLine.getSubValue());
+    }
+    Collection<TicketTaxInfo> avalues = m.values();
+    return avalues.toArray(new TicketTaxInfo[avalues.size()]);
 }


Input:
final static private void algebraicToPolarAndColor(final byte[] ipXPixels, final byte[] ipYPixels, final float[] ipRPixels, final float[] ipPhiPixels, final int[] ipColorPixels, final double max) {
    final int n = ipXPixels.length;
    for (int i = 0; i < n; ++i) {
        final double x = ipXPixels[i] / max;
        final double y = ipYPixels[i] / max;
        final double r = Math.sqrt(x * x + y * y);
        final double phi = Math.atan2(x / r, y / r);
        ipRPixels[i] = (float) r;
        ipPhiPixels[i] = (float) phi;
        if (r == 0.0)
            ipColorPixels[i] = 0;
        else {
            final double red, green, blue;
            double o = (phi + Math.PI) / Math.PI * 3;
            if (o < 3)
                red = Math.min(1.0, Math.max(0.0, 2.0 - o)) * r;
            else
                red = Math.min(1.0, Math.max(0.0, o - 4.0)) * r;
            o += 2;
            if (o >= 6)
                o -= 6;
            if (o < 3)
                green = Math.min(1.0, Math.max(0.0, 2.0 - o)) * r;
            else
                green = Math.min(1.0, Math.max(0.0, o - 4.0)) * r;
            o += 2;
            if (o >= 6)
                o -= 6;
            if (o < 3)
                blue = Math.min(1.0, Math.max(0.0, 2.0 - o)) * r;
            else
                blue = Math.min(1.0, Math.max(0.0, o - 4.0)) * r;
            ipColorPixels[i] = (((int) (red * 255) << 8) | (int) (green * 255) << 8) | (int) (blue * 255);
        }
    }
}

Output:
                 blue = Math.min(1.0, Math.max(0.0, o - 4.0)) * r;
-            ipColorPixels[i] = (((int) (red * 255) << 8) | (int) (green * 255) << 8) | (int) (blue * 255);
+            ipColorPixels[i] = ((((int) (red * 255) << 8) | (int) (green * 255)) << 8) | (int) (blue * 255);
         }


Input:
public boolean putArray(Object[] element) {
    if (_queuearray.length - _queuesize >= element.length) {
        int i;
        if (element.length <= (_queuearray.length - _queuefront)) {
            System.arraycopy(element, 0, _queuearray, _queuefront, element.length);
            _queuefront += element.length;
            if (_queuefront >= _queuearray.length)
                _queuefront = _queuefront % _queuearray.length;
            _queuesize += element.length;
        } else {
            System.arraycopy(element, 0, _queuearray, _queuefront, _queuearray.length - _queuefront);
            System.arraycopy(element, _queuearray.length - _queuefront, _queuearray, 0, element.length - (_queuearray.length - _queuefront));
            _queuefront += element.length;
            if (_queuefront >= _queuearray.length)
                _queuefront = _queuefront % _queuearray.length;
            _queuesize += element.length;
        }
        return true;
    } else {
        if (_queuemaxcapacity == INFINITE_CAPACITY) {
            try {
                _resizeArray(_queuearray.length * 2);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return putArray(element);
        } else
            return false;
    }
}

Output:
 public boolean putArray(Object[] element) {
-    if (_queuearray.length - _queuesize >= element.length) {
+    if (_queueArray.length - _queueSize >= element.length) {
         int i;


Input:
private void onActionZoom(View view) {
    int originalWidth = view.getWidth();
    int originalHeight = view.getHeight();
    long currentTime = System.nanoTime();
    if (time != 0 && (currentTime - time) > 10000000) {
        int leftOffset = (int) (originalWidth - (originalWidth * scaleListener.scaleFactor));
        int topOffset = (int) (originalHeight - (originalHeight * scaleListener.scaleFactor));
        Log.e(TAG, "String_Node_Str" + leftOffset + "String_Node_Str" + topOffset);
        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) view.getLayoutParams();
        layoutParams.setMargins(leftOffset, topOffset, leftOffset, topOffset);
        view.setLayoutParams(layoutParams);
        if (view.getX() >= 0) {
            view.setX(0);
        }
        if (view.getX() + view.getWidth() <= screenWidth) {
            view.setX(screenWidth - view.getWidth());
        }
    }
    time = System.nanoTime();
}

Output:
         }
-        if (view.getX() + view.getWidth() <= screenWidth) {
-            view.setX(screenWidth - view.getWidth());
+        if (view.getX() + view.getWidth() <= getScreenWidth()) {
+            view.setX(getScreenWidth() - view.getWidth());
         }


Input:
private boolean computeCounts(List<Object[]> objects) {
    boolean ok = true;
    this.setDistinctCount(Long.valueOf(objects.size()));
    Long uniq = 0L;
    Long rowcount = 0L;
    for (Object[] row : objects) {
        Object c = row[row.length - 1];
        if (c != null) {
            Long val = Long.valueOf(String.valueOf(c));
            rowcount += val;
            if (val == 1) {
                uniq++;
            }
        } else {
            ok = false;
        }
    }
    this.setCount(rowcount);
    this.setUniqueCount(uniq);
    return ok;
}

Output:
         if (c != null) {
-            Long val = Long.valueOf(String.valueOf(c));
+            Long val = Long.valueOf(getLongFromObject(String.valueOf(c)));
             rowcount += val;


Input:
public IntIntEntry next() {
    return new IntIntEntryImpl(i);
}

Output:
 public IntIntEntry next() {
-    return new IntIntEntryImpl(i);
+    entry.i++;
+    return entry;
 }


Input:
public T in(Iterable<?> vals) {
    return this.hasAnyOf(vals, this.query.isValidatingTypes());
}

Output:
 public T in(Iterable<?> vals) {
-    return this.hasAnyOf(vals, this.query.isValidatingTypes());
+    return this.hasAnyOf(vals);
 }


Input:
public void addMemberVariable(FElement element, boolean isTopLevel) {
    if ((isTopLevel && !this.incompleteBuilders.empty()) || null != this.incompleteLocalBuilder) {
        String typeName = "String_Node_Str";
        if (SchemaHelper.isBuiltinTypedElement(element)) {
            typeName = this.mapper.lookup(this.getFabricTypeName(element.getSchemaType()));
            LOGGER.debug(String.format("String_Node_Str", typeName));
        } else {
            typeName = element.getSchemaType().getName();
            LOGGER.debug(String.format("String_Node_Str", typeName));
            if (isTopLevel && !element.getSchemaType().isTopLevel() && !element.getSchemaType().isSimple()) {
                typeName += "String_Node_Str";
            }
        }
        AttributeContainer.Builder current = (isTopLevel ? this.incompleteBuilders.pop() : this.incompleteLocalBuilder);
        AttributeContainer.Restriction restrictions = new AttributeContainer.Restriction();
        if (element.getSchemaType().isSimple() && (!element.getSchemaType().isTopLevel() || this.generatedElements.containsKey(typeName))) {
            restrictions = this.createRestrictions((FSimpleType) (element.getSchemaType()));
        }
        if (!element.getSchemaType().isTopLevel() && FSchemaTypeHelper.isEnum(element.getSchemaType())) {
            Object[] constants = FSchemaTypeHelper.extractEnumArray((FSimpleType) element.getSchemaType());
            String[] enumConstants = Arrays.copyOf(constants, constants.length, String[].class);
            current.addEnumElement(element.getName() + "String_Node_Str", element.getName(), enumConstants);
        } else if (FSchemaTypeHelper.isArray(element)) {
            current.addElementArray(typeName, element.getName(), element.getMinOccurs(), element.getMaxOccurs());
        } else if (FSchemaTypeHelper.hasDefaultValue(element)) {
            current.addElement(typeName, element.getName(), element.getDefaultValue(), restrictions);
        } else if (FSchemaTypeHelper.hasFixedValue(element)) {
            current.addConstantElement(typeName, element.getName(), element.getFixedValue());
        } else {
            current.addElement(typeName, element.getName(), restrictions);
        }
        if (isTopLevel) {
            this.incompleteBuilders.push(current);
        } else {
            this.incompleteLocalBuilder = current;
        }
        LOGGER.debug(String.format("String_Node_Str", element.getName(), (SchemaHelper.isBuiltinTypedElement(element) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str", typeName, current.getName()));
    }
}

Output:
 public void addMemberVariable(FElement element, boolean isTopLevel) {
-    if ((isTopLevel && !this.incompleteBuilders.empty()) || null != this.incompleteLocalBuilder) {
+    if ((isTopLevel && !this.incompleteBuilders.empty()) || this.hasIncompleteLocalBuilders()) {
         String typeName = "String_Node_Str";


Input:
private static void printJmolScript4Block(Atom[] atoms, List<List<Integer>> alignRes, Color[] colors, StringWriter jmol, int str, int colorPos, int blockNum) {
    Color start = ColorUtils.lighter(colors[str % colors.length], 1);
    double fraction = (colorPos * 1.0) / blockNum;
    Color color = ColorUtils.darker(start, fraction);
    List<String> pdb = new ArrayList<String>();
    for (int i = 0; i < alignRes.get(str).size(); i++) {
        if (alignRes.get(str).get(i) != null) {
            int pos = alignRes.get(str).get(i);
            pdb.add(JmolTools.getPdbInfo(atoms[pos]));
        }
    }
    StringBuffer buf = new StringBuffer("String_Node_Str");
    int count = 0;
    for (String res : pdb) {
        if (count > 0)
            buf.append("String_Node_Str");
        buf.append(res);
        buf.append("String_Node_Str" + (str + 1));
        count++;
    }
    buf.append("String_Node_Str" + color.getRed() + "String_Node_Str" + color.getGreen() + "String_Node_Str" + color.getBlue() + "String_Node_Str");
    jmol.append(buf);
}

Output:
 private static void printJmolScript4Block(Atom[] atoms, List<List<Integer>> alignRes, Color[] colors, StringWriter jmol, int str, int colorPos, int blockNum) {
-    Color start = ColorUtils.lighter(colors[str % colors.length], 1);
-    double fraction = (colorPos * 1.0) / blockNum;
+    Color start = colors[str % colors.length];
+    double fraction = (colorPos * 1.0) / (blockNum + 1.0);
     Color color = ColorUtils.darker(start, fraction);


Input:
public static int processCount(String countStr) throws BadRequestException {
    int count = 0;
    if (countStr == null) {
        count = CharonConfiguration.getInstance().getCountValueForPagination();
    }
    try {
        count = Integer.parseInt(countStr);
    } catch (NumberFormatException e) {
        throw new BadRequestException("String_Node_Str");
    }
    if (count < 0) {
        count = 0;
    }
    return count;
}

Output:
 public static int processCount(String countStr) throws BadRequestException {
-    int count = 0;
-    if (countStr == null) {
+    int count;
+    if (countStr == null || countStr.isEmpty()) {
         count = CharonConfiguration.getInstance().getCountValueForPagination();


Input:
public void run() {
    try {
        super.run();
        if (Util.IsEnterPrise()) {
            universes = new ArrayList<WSUniversePK>();
            WSUniversePK[] universePKs = null;
            List<XtentisPort> ports = view.getPorts();
            if (ports != null) {
                for (Iterator iterator = ports.iterator(); iterator.hasNext(); ) {
                    XtentisPort port = (XtentisPort) iterator.next();
                    universePKs = port.getUniversePKs(new WSGetUniversePKs("String_Node_Str")).getWsUniversePK();
                    if (universePKs != null && universePKs.length > 0)
                        CollectionUtils.addAll(universes, universePKs);
                }
            }
        }
        dialog = new LoginDialog(this, view.getSite().getShell(), IConstants.TALEND + "String_Node_Str", universes);
        dialog.setBlockOnOpen(true);
        dialog.open();
    } catch (Exception e) {
        log.error(e.getStackTrace());
    }
}

Output:
     } catch (Exception e) {
-        log.error(e.getStackTrace());
+        log.error(e.getMessage(), e);
     }


Input:
public void runOperation(VariableMap variableMap, IProgressMonitor monitor) throws Exception {
    List<Artifact> artifacts = variableMap.getArtifacts("String_Node_Str");
    if (artifacts.isEmpty()) {
        throw new OseeArgumentException("String_Node_Str");
    }
    IOseeBranch branch = artifacts.get(0).getBranch();
    init();
    String scriptDir = variableMap.getString(SCRIPT_ROOT_DIR);
    Boolean checked = variableMap.getBoolean(USE_TRACE_IN_OSEE);
    Collection<String> traceHandlerIds = new LinkedList<String>();
    for (String handler : availableTraceHandlers) {
        if (variableMap.getBoolean(handler)) {
            traceHandlerIds.add(handler);
        }
    }
    if (!checked) {
        File dir = new File(scriptDir);
        if (dir.exists()) {
            ScriptTraceabilityOperation traceOperation = new ScriptTraceabilityOperation(dir.getParentFile(), branch, false, traceHandlerIds);
            Operations.executeWorkAndCheckStatus(traceOperation, monitor);
            requirementsToCodeUnits = traceOperation.getRequirementToCodeUnitsMap();
        }
    }
    writeMainSheet(prepareSubsystemRequirements(artifacts));
    writer.endWorkbook();
    IFile iFile = OseeData.getIFile("String_Node_Str" + Lib.getDateTimeString() + "String_Node_Str");
    AIFile.writeToFile(iFile, charBak);
    Program.launch(iFile.getLocation().toOSString());
}

Output:
     Boolean checked = variableMap.getBoolean(USE_TRACE_IN_OSEE);
-    Collection<String> traceHandlerIds = new LinkedList<String>();
+    Collection<TraceHandler> traceHandlers = new LinkedList<TraceHandler>();
     for (String handler : availableTraceHandlers) {


Input:
protected boolean internalRefreshModule(IProgressMonitor monitor) throws CoreException {
    synchronized (REFRESH_MODULES) {
        if (REFRESH_MODULES[0]) {
            final CloudFoundryServer cloudServer = getCloudFoundryServer();
            List<CloudApplication> applications = getApplications(monitor);
            Map<String, CloudApplication> deployedApplicationsByName = new LinkedHashMap<String, CloudApplication>();
            for (CloudApplication application : applications) {
                deployedApplicationsByName.put(application.getName(), application);
            }
            cloudServer.updateModules(deployedApplicationsByName);
        }
        return REFRESH_MODULES[0];
    }
}

Output:
         if (REFRESH_MODULES[0]) {
-            final CloudFoundryServer cloudServer = getCloudFoundryServer();
-            List<CloudApplication> applications = getApplications(monitor);
-            Map<String, CloudApplication> deployedApplicationsByName = new LinkedHashMap<String, CloudApplication>();
-            for (CloudApplication application : applications) {
-                deployedApplicationsByName.put(application.getName(), application);
+            try {
+                final CloudFoundryServer cloudServer = getCloudFoundryServer();
+                List<CloudApplication> applications = getApplications(monitor);
+                Map<String, CloudApplication> deployedApplicationsByName = new LinkedHashMap<String, CloudApplication>();
+                for (CloudApplication application : applications) {
+                    deployedApplicationsByName.put(application.getName(), application);
+                }
+                cloudServer.updateModules(deployedApplicationsByName);
+                return true;
+            } catch (Throwable t) {
+                CloudFoundryPlugin.logError("String_Node_Str" + t.getMessage(), t);
             }


Input:
public void cleanUp() {
    saveSettings();
    chatPanelMain.cleanUp();
}

Output:
 public void cleanUp() {
-    saveSettings();
+    saveGuiSettings();
     chatPanelMain.cleanUp();


Input:
public void update(RemoteEvent remoteEvent) {
    if (!logger.isInfoEnabled())
        return;
    if (remoteEvent instanceof SenderReportEvent) {
        numberOfReceivedSenderReports++;
        SenderReport report = ((SenderReportEvent) remoteEvent).getReport();
        if (report.getFeedbackReports().size() > 0) {
            Feedback feedback = (Feedback) report.getFeedbackReports().get(0);
            long remoteJitter = feedback.getJitter();
            if (remoteJitter < minRemoteInterArrivalJitter || minRemoteInterArrivalJitter == -1)
                minRemoteInterArrivalJitter = remoteJitter;
            if (maxRemoteInterArrivalJitter < remoteJitter)
                maxRemoteInterArrivalJitter = remoteJitter;
            if (numberOfReceivedSenderReports % 4 != 1)
                return;
            StringBuilder buff = new StringBuilder(StatisticsEngine.RTP_STAT_PREFIX);
            buff.append("String_Node_Str").append(getFormat().getMediaType().toString()).append("String_Node_Str").append(getLocalSourceID()).append("String_Node_Str").append(report.getSenderPacketCount()).append("String_Node_Str").append(report.getSenderByteCount()).append("String_Node_Str").append(remoteJitter).append("String_Node_Str").append(feedback.getNumLost()).append("String_Node_Str").append((int) (feedback.getDLSR() / 65.536)).append("String_Node_Str");
            logger.info(buff);
        }
    }
}

Output:
             StringBuilder buff = new StringBuilder(StatisticsEngine.RTP_STAT_PREFIX);
-            buff.append("String_Node_Str").append(getFormat().getMediaType().toString()).append("String_Node_Str").append(getLocalSourceID()).append("String_Node_Str").append(report.getSenderPacketCount()).append("String_Node_Str").append(report.getSenderByteCount()).append("String_Node_Str").append(remoteJitter).append("String_Node_Str").append(feedback.getNumLost()).append("String_Node_Str").append((int) (feedback.getDLSR() / 65.536)).append("String_Node_Str");
+            buff.append("String_Node_Str").append(getFormat() != null ? getFormat().getMediaType().toString() : "String_Node_Str").append("String_Node_Str").append(getLocalSourceID()).append("String_Node_Str").append(report.getSenderPacketCount()).append("String_Node_Str").append(report.getSenderByteCount()).append("String_Node_Str").append(remoteJitter).append("String_Node_Str").append(feedback.getNumLost()).append("String_Node_Str").append((int) (feedback.getDLSR() / 65.536)).append("String_Node_Str");
             logger.info(buff);


Input:
public void run() {
    Log.d("String_Node_Str", "String_Node_Str");
    boolean result = videoChatHelper.switchMic();
}

Output:
     Log.d("String_Node_Str", "String_Node_Str");
-    boolean result = videoChatHelper.switchMic();
+    videoChatHelper.switchMic();
 }


Input:
public void addMessage(Message msg, int amount) {
    try {
        PreparedStatement statement = connection.prepareStatement("String_Node_Str", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
        statement.closeOnCompletion();
        try (ResultSet results = statement.executeQuery()) {
            results.moveToInsertRow();
            results.updateLong("String_Node_Str", msg.getIdLong());
            results.updateLong("String_Node_Str", msg.getTextChannel().getIdLong());
            results.updateLong("String_Node_Str", msg.getGuild().getIdLong());
            results.updateInt("String_Node_Str", amount);
            results.insertRow();
        }
    } catch (SQLException e) {
        LOG.error("String_Node_Str", msg.getIdLong(), msg.getTextChannel().getIdLong(), e);
    }
}

Output:
         try (ResultSet results = statement.executeQuery()) {
-            results.moveToInsertRow();
-            results.updateLong("String_Node_Str", msg.getIdLong());
-            results.updateLong("String_Node_Str", msg.getTextChannel().getIdLong());
-            results.updateLong("String_Node_Str", msg.getGuild().getIdLong());
-            results.updateInt("String_Node_Str", amount);
-            results.insertRow();
+            if (!(results.next())) {
+                results.moveToInsertRow();
+                results.updateLong("String_Node_Str", msg.getIdLong());
+                results.updateLong("String_Node_Str", msg.getTextChannel().getIdLong());
+                results.updateLong("String_Node_Str", msg.getGuild().getIdLong());
+                results.updateInt("String_Node_Str", amount);
+                results.insertRow();
+            }
         }


Input:
private String[] getSources() {
    String path = null;
    String renderer = parent.getAttribute(XMLConstants.RENDERER_ATTR);
    if (renderer.equals(XMLConstants.ATLAS_VALUE)) {
        path = Ctx.project.getProjectPath() + Project.ATLASES_PATH + "String_Node_Str" + Ctx.project.getResDir();
        ext = "String_Node_Str";
    } else if (renderer.equals(XMLConstants.S3D_VALUE)) {
        path = Ctx.project.getProjectPath() + Project.SPRITE3D_PATH;
        ext = "String_Node_Str";
    } else if (renderer.equals(XMLConstants.SPINE_VALUE)) {
        path = Ctx.project.getProjectPath() + Project.SPINE_PATH;
        ext = "String_Node_Str";
    } else if (renderer.equals(XMLConstants.IMAGE_VALUE)) {
        path = Ctx.project.getProjectPath() + Project.IMAGE_PATH + "String_Node_Str" + Ctx.project.getResDir();
        ext = "String_Node_Str";
    }
    File f = new File(path);
    String[] sources = f.list(new FilenameFilter() {
        public boolean accept(File arg0, String arg1) {
            if (arg1.endsWith(ext))
                return true;
            return false;
        }
    });
    if (sources != null) {
        Arrays.sort(sources);
        for (int i = 0; i < sources.length; i++) sources[i] = sources[i].substring(0, sources[i].length() - ext.length());
    } else {
        sources = new String[0];
    }
    return sources;
}

Output:
         path = Ctx.project.getProjectPath() + Project.ATLASES_PATH + "String_Node_Str" + Ctx.project.getResDir();
-        ext = "String_Node_Str";
+        ext = ATLAS_EXT;
     } else if (renderer.equals(XMLConstants.S3D_VALUE)) {


Input:
public static void configure() throws Exception {
    DataSet kv = new Table("String_Node_Str");
    DataSet t1 = new Table("String_Node_Str");
    DataSet t2 = new Table("String_Node_Str");
    DataSet t3 = new Table("String_Node_Str");
    DataSet t4 = new Table("String_Node_Str");
    setupInstantiator(Lists.newArrayList(kv, t1, t2, t3, t4));
    table = instantiator.getDataSet("String_Node_Str");
}

Output:
     DataSet t4 = new Table("String_Node_Str");
-    setupInstantiator(Lists.newArrayList(kv, t1, t2, t3, t4));
+    DataSet tBatch = new Table("String_Node_Str");
+    setupInstantiator(Lists.newArrayList(kv, t1, t2, t3, t4, tBatch));
     table = instantiator.getDataSet("String_Node_Str");


Input:
public void onOK() {
    try {
        Checkbox mfp_locked = (Checkbox) Path.getComponent("String_Node_Str");
        Checkbox mfp_hidden = (Checkbox) Path.getComponent("String_Node_Str");
        int left = spreadsheet.getSelection().getLeft();
        int right = spreadsheet.getSelection().getRight();
        int top = spreadsheet.getSelection().getTop();
        int bottom = spreadsheet.getSelection().getBottom();
        XSheet sheet = spreadsheet.getSelectedXSheet();
        for (int row = top; row <= bottom; row++) {
            for (int col = left; col <= right; col++) {
                final Cell cell = Utils.getCell(sheet, row, col);
                if (cell != null) {
                    CellStyle cs = cell.getCellStyle();
                    cs.setHidden(mfp_hidden.isChecked());
                    cs.setLocked(mfp_hidden.isChecked());
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("String_Node_Str");
    }
    Window formatMainWin = (Window) Path.getComponent("String_Node_Str");
    formatMainWin.setVisible(false);
    spreadsheet.setHighlight(null);
}

Output:
         int bottom = spreadsheet.getSelection().getBottom();
-        XSheet sheet = spreadsheet.getSelectedXSheet();
+        Sheet sheet = spreadsheet.getSelectedSheet();
         for (int row = top; row <= bottom; row++) {


Input:
public void run() {
    new ChangePerspectiveAction(PluginConstant.SE_ID).run();
    TdDataProvider tdDataProvider = DataProviderHelper.getDataProvider(table);
    String qualifiedName = ColumnSetNameHelper.getColumnSetQualifiedName(tdDataProvider, table);
    String query = "String_Node_Str" + qualifiedName;
    CorePlugin.getDefault().runInDQViewer(tdDataProvider, query);
}

Output:
     String query = "String_Node_Str" + qualifiedName;
-    CorePlugin.getDefault().runInDQViewer(tdDataProvider, query);
+    CorePlugin.getDefault().runInDQViewer(tdDataProvider, query, null);
 }


Input:
public void testSetTagDefinition() throws CTFReaderException {
    VariantDeclaration vDecl;
    VariantDefinition vDef;
    StructDefinition structDef;
    EnumDefinition tagDefinition;
    String fName = "String_Node_Str";
    vDecl = new VariantDeclaration();
    vDecl.setTag(fName);
    vDef = new VariantDefinition(vDecl, TestParams.createTrace(), fName);
    structDef = new StructDefinition(new StructDeclaration(1L), vDef, fName);
    tagDefinition = new EnumDefinition(new EnumDeclaration(new IntegerDeclaration(1, true, 1, ByteOrder.BIG_ENDIAN, Encoding.ASCII, fName)), structDef, fName);
    fixture.setTagDefinition(tagDefinition);
}

Output:
     structDef = new StructDefinition(new StructDeclaration(1L), vDef, fName);
-    tagDefinition = new EnumDefinition(new EnumDeclaration(new IntegerDeclaration(1, true, 1, ByteOrder.BIG_ENDIAN, Encoding.ASCII, fName)), structDef, fName);
+    tagDefinition = new EnumDefinition(new EnumDeclaration(new IntegerDeclaration(1, true, 1, ByteOrder.BIG_ENDIAN, Encoding.ASCII, fName, 8)), structDef, fName);
     fixture.setTagDefinition(tagDefinition);


Input:
private void startLoading() {
    ExtractingLoadable loadable = new ExtractingLoadable(uri, dataSource, extractorHolder, loadCondition);
    if (prepared) {
        Assertions.checkState(isPendingReset());
        if (durationUs != C.UNSET_TIME_US && pendingResetPositionUs >= durationUs) {
            loadingFinished = true;
            pendingResetPositionUs = C.UNSET_TIME_US;
            return;
        }
        loadable.setLoadPosition(seekMap.getPosition(pendingResetPositionUs));
        pendingResetPositionUs = C.UNSET_TIME_US;
    }
    extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount();
    int minRetryCount = minLoadableRetryCount;
    if (minRetryCount == MIN_RETRY_COUNT_DEFAULT_FOR_MEDIA) {
        minRetryCount = !prepared || (length != C.LENGTH_UNBOUNDED || (seekMap != null && seekMap.getDurationUs() != C.UNSET_TIME_US)) ? DEFAULT_MIN_LOADABLE_RETRY_COUNT_ON_DEMAND : DEFAULT_MIN_LOADABLE_RETRY_COUNT_LIVE;
    }
    loader.startLoading(loadable, this, minRetryCount);
}

Output:
     extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount();
-    int minRetryCount = minLoadableRetryCount;
-    if (minRetryCount == MIN_RETRY_COUNT_DEFAULT_FOR_MEDIA) {
-        minRetryCount = !prepared || (length != C.LENGTH_UNBOUNDED || (seekMap != null && seekMap.getDurationUs() != C.UNSET_TIME_US)) ? DEFAULT_MIN_LOADABLE_RETRY_COUNT_ON_DEMAND : DEFAULT_MIN_LOADABLE_RETRY_COUNT_LIVE;
-    }
-    loader.startLoading(loadable, this, minRetryCount);
+    loader.startLoading(loadable, this, 0);
 }


Input:
public void needMore(boolean needMore) {
    if (needMore) {
        ctx.setBucket(0, b11, true, mock(PageResultListener.class));
    }
}

Output:
 public void needMore(boolean needMore) {
-    if (needMore) {
-        ctx.setBucket(0, b11, true, mock(PageResultListener.class));
-    }
+    needMoreResult = needMore;
 }


Input:
public static void removeAroundPoint(Location loc, double radius) {
    for (Player player : instances.keySet()) {
        Combustion combustion = instances.get(player);
        if (combustion.location.distance(loc) <= radius) {
            explode(player);
            instances.remove(player);
        }
    }
}

Output:
         Combustion combustion = instances.get(player);
-        if (combustion.location.distance(loc) <= radius) {
-            explode(player);
-            instances.remove(player);
+        if (combustion.location.getWorld() == loc.getWorld()) {
+            if (combustion.location.distance(loc) <= radius) {
+                explode(player);
+                instances.remove(player);
+            }
         }


Input:
protected String isGetter(final Method<?, ?> method) {
    String methodName = method.getName();
    String propertyName;
    if (methodName.startsWith(ClassUtils.JAVABEAN_GET_PREFIX)) {
        propertyName = methodName.substring(ClassUtils.JAVABEAN_GET_PREFIX.length());
    } else if (methodName.startsWith(ClassUtils.JAVABEAN_IS_PREFIX) && boolean.class.equals(method.getReturnType().getQualifiedName())) {
        propertyName = methodName.substring(ClassUtils.JAVABEAN_IS_PREFIX.length());
    } else {
        return null;
    }
    return StringUtils.decapitalize(propertyName);
}

Output:
         propertyName = methodName.substring(ClassUtils.JAVABEAN_GET_PREFIX.length());
-    } else if (methodName.startsWith(ClassUtils.JAVABEAN_IS_PREFIX) && boolean.class.equals(method.getReturnType().getQualifiedName())) {
+    } else if (methodName.startsWith(ClassUtils.JAVABEAN_IS_PREFIX) && method.getReturnType() != null && boolean.class.equals(method.getReturnType().getQualifiedName())) {
         propertyName = methodName.substring(ClassUtils.JAVABEAN_IS_PREFIX.length());


Input:
public void component(MetaContextItem<ODocument, ?> rowItem, IVisit<Void> visit) {
    rowItem.getModelObject().save();
    visit.dontGoDeeper();
}

Output:
 public void component(MetaContextItem<ODocument, ?> rowItem, IVisit<Void> visit) {
-    rowItem.getModelObject().save();
+    ODocument doc = rowItem.getModelObject();
+    if (doc.isDirty())
+        doc.save();
     visit.dontGoDeeper();


Input:
public String getPointRefer() {
    return argument[6];
}

Output:
 public String getPointRefer() {
-    return argument[6];
+    return arguments[6];
 }


Input:
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack itemstack) {
    TileEntity te = world.getBlockTileEntity(x, y, z);
    if (te instanceof TileTurret && entity instanceof EntityPlayer) {
        ((TileTurret) te).getAccessProfile().getOwnerGroup().addMemeber(new AccessUser(((EntityPlayer) entity).username));
    }
}

Output:
 public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack itemstack) {
-    TileEntity te = world.getBlockTileEntity(x, y, z);
-    if (te instanceof TileTurret && entity instanceof EntityPlayer) {
-        ((TileTurret) te).getAccessProfile().getOwnerGroup().addMemeber(new AccessUser(((EntityPlayer) entity).username));
+    if (!world.isRemote) {
+        TileEntity te = world.getBlockTileEntity(x, y, z);
+        if (te instanceof TileTurret && entity instanceof EntityPlayer) {
+            ((TileTurret) te).getAccessProfile().setUserAccess(((EntityPlayer) entity).username, ((TileTurret) te).getAccessProfile().getOwnerGroup(), false);
+            ((TileTurret) te).onProfileChange();
+        }
     }


Input:
public void renderTo(Target<?> target) {
    target.drawTriangles(WATER, getTriangulation(), globalTexCoordLists(getTriangulation(), WATER, false));
    double width = 0.1;
    double height = 0.5;
    List<VectorXYZ> wallShape = asList(new VectorXYZ(-width / 2, 0, 0), new VectorXYZ(-width / 2, height, 0), new VectorXYZ(+width / 2, height, 0), new VectorXYZ(+width / 2, 0, 0));
    List<VectorXYZ> path = area.getElevationProfile().getWithEle(area.getOuterPolygon().getVertexLoop());
    List<List<VectorXYZ>> strips = createShapeExtrusionAlong(wallShape, path, nCopies(path.size(), VectorXYZ.Y_UNIT));
    for (List<VectorXYZ> strip : strips) {
        target.drawTriangleStrip(Materials.ASPHALT, strip, null);
    }
}

Output:
     for (List<VectorXYZ> strip : strips) {
-        target.drawTriangleStrip(Materials.ASPHALT, strip, null);
+        target.drawTriangleStrip(Materials.CONCRETE, strip, wallTexCoordLists(strip, Materials.CONCRETE));
     }


Input:
public void setOnCompletionListener(final OnCompletionListener listener) {
    _mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {

        public void onCompletion(MediaPlayer mp) {
            listener.onCompletion(MusicPlayer.this);
        }
    });
}

Output:
 public void setOnCompletionListener(final OnCompletionListener listener) {
-    _mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
+    if (_state != RELEASED) {
+        _mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {


Input:
public int hashCode() {
    return productId.hashCode() * 31;
}

Output:
 public int hashCode() {
-    return productId.hashCode() * 31;
+    if (productId != null) {
+        return productId.hashCode() * 31;
+    }
+    return 31;
 }


Input:
public String getDateLiteral(String isoDate) {
    String normalLiteral = super.getDateLiteral(isoDate);
    if (isDateOnly(isoDate)) {
        StringBuffer val = new StringBuffer();
        val.append("String_Node_Str");
        val.append(normalLiteral);
        val.append("String_Node_Str");
        return val.toString();
    } else if (isTimeOnly(isoDate)) {
        StringBuffer val = new StringBuffer();
        val.append("String_Node_Str");
        val.append(normalLiteral);
        val.append("String_Node_Str");
        return val.toString();
    } else if (isDateTime(isoDate)) {
        StringBuffer val = new StringBuffer();
        val.append("String_Node_Str");
        val.append(normalLiteral);
        val.append("String_Node_Str");
        return val.toString();
    } else {
        return "String_Node_Str" + isoDate;
    }
}

Output:
         val.append(normalLiteral);
-        val.append("String_Node_Str");
+        val.append(')');
         return val.toString();


Input:
public void testBasicProbeMechanicsFromUltrapeer() throws Exception {
    drainAll();
    QueryRequest request = QueryRequest.createQuery("String_Node_Str");
    request.setTTL((byte) 1);
    ULTRAPEER_2.send(request);
    ULTRAPEER_2.flush();
    QueryRequest reqRecvd = (QueryRequest) LEAF.receive(TIMEOUT);
    assertTrue(reqRecvd.getQuery().equals("String_Node_Str"));
    assertTrue(Arrays.equals(request.getGUID(), reqRecvd.getGUID()));
    try {
        ULTRAPEER_1.receive(TIMEOUT);
        assertTrue(false);
    } catch (InterruptedIOException expected) {
    }
    Response response1 = new Response(0L, 0L, "String_Node_Str");
    byte[] guid1 = GUID.makeGuid();
    QueryReply reply1 = new QueryReply(request.getGUID(), (byte) 2, 6346, new byte[4], 56, new Response[] { response1 }, guid1, false);
    drain(ULTRAPEER_2);
    LEAF.send(reply1);
    LEAF.flush();
    QueryReply qRep = (QueryReply) ULTRAPEER_2.receive(TIMEOUT);
    assertEquals(new GUID(guid1), new GUID(qRep.getClientGUID()));
    Thread.sleep(2 * 1000);
    request.setTTL((byte) 2);
    ULTRAPEER_2.send(request);
    ULTRAPEER_2.flush();
    try {
        LEAF.receive(TIMEOUT);
        assertTrue(false);
    } catch (InterruptedIOException expected) {
    }
    reqRecvd = (QueryRequest) ULTRAPEER_1.receive(TIMEOUT);
    assertTrue(reqRecvd.getQuery().equals("String_Node_Str"));
    assertTrue(Arrays.equals(request.getGUID(), reqRecvd.getGUID()));
    assertEquals(reqRecvd.getHops(), (byte) 1);
}

Output:
     LEAF.flush();
-    QueryReply qRep = (QueryReply) ULTRAPEER_2.receive(TIMEOUT);
+    QueryReply qRep = getFirstQueryReply(ULTRAPEER_2);
+    assertTrue(qRep != null);
     assertEquals(new GUID(guid1), new GUID(qRep.getClientGUID()));


Input:
private void recalculateAggregation(List<IAggregationResultRow> aggregationRows) throws DataException, IOException {
    Set<Integer> duplicatedIndex = new HashSet<Integer>();
    for (int i = 0; i < aggregationRows.size(); i++) {
        this.calculator.start();
        List<Integer> positions = getRowsPositionInAggregationRows(i, aggregationRows);
        for (int k = 0; k < positions.size(); k++) {
            this.calculator.onRow(aggregationRows.get(positions.get(k)));
            if (k != 0)
                duplicatedIndex.add(positions.get(k));
        }
        this.calculator.finish(aggregationRows.get(i));
        int baseIndex = 0;
        Iterator<Integer> iter = duplicatedIndex.iterator();
        while (iter.hasNext()) {
            int index = iter.next().intValue();
            aggregationRows.remove(index - baseIndex);
            baseIndex++;
        }
        duplicatedIndex.clear();
    }
}

Output:
 private void recalculateAggregation(List<IAggregationResultRow> aggregationRows) throws DataException, IOException {
-    Set<Integer> duplicatedIndex = new HashSet<Integer>();
+    Set<Integer> duplicatedIndex = new LinkedHashSet<Integer>();
     for (int i = 0; i < aggregationRows.size(); i++) {


Input:
public FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler) {
    return getConnectionAsync(resultHandler);
}

Output:
 public FutureResult<Connection> getConnectionAsync(ResultHandler<? super Connection> resultHandler) {
-    return getConnectionAsync(resultHandler);
+    return factory.getConnectionAsync(resultHandler);
 }


Input:
public String getPlugin() {
    return ReportPlugin.REPORT_UI;
}

Output:
 public String getPlugin() {
-    return ReportPlugin.REPORT_UI;
+    return fPluginID == null ? ReportPlugin.REPORT_UI : fPluginID;
 }


Input:
public static UtxoOutput toOutput(UtxoOutputPo po) {
    UtxoOutput output = new UtxoOutput();
    output.setTxHash(new NulsDigestData(Hex.decode(po.getTxHash())));
    output.setIndex(po.getOutIndex());
    output.setLockTime(po.getLockTime());
    output.setValue(po.getValue());
    output.setAddress(po.getAddress());
    try {
        output.setScript(new P2PKHScript(po.getScript()));
    } catch (Exception e) {
        Log.error(e);
    }
    output.setStatus(po.getStatus());
    if (po.getCreateTime() != null) {
        output.setCreateTime(po.getCreateTime());
    }
    if (po.getTxType() != null) {
        output.setTxType(po.getTxType());
    }
    return output;
}

Output:
     try {
-        output.setScript(new P2PKHScript(po.getScript()));
+        output.setP2PKHScript(new P2PKHScript(po.getScript()));
     } catch (Exception e) {