Input:
public boolean execute(ICommandSender sender, String[] args) throws Exception {
    if (args.length < 2 && args.length >= 3) {
        throw new BadUsageException(getUsage());
    }
    if (args[1].length() > 16 || !validUserPattern.matcher(args[1]).matches()) {
        throw new IllegalArgumentException(C("String_Node_Str"));
    }
    if ("String_Node_Str".equals(args[1]) && plugin.getConfig().getBoolean("String_Node_Str")) {
        sender.sendMessage("String_Node_Str");
        return true;
    }
    IPlayer player = (IPlayer) sender;
    if (player.hasPermission(PermissionNames.ADMIN_DENY) || player.hasPermission(PermissionNames.USER_DENY)) {
        IWorld world = player.getWorld();
        if (manager.isPlotWorld(world)) {
            Plot plot = manager.getPlot(player);
            if (plot == null) {
                player.sendMessage(C("String_Node_Str"));
                return true;
            }
            PlotMapInfo pmi = manager.getMap(world);
            String denied;
            IPlayer deniedPlayer = serverBridge.getPlayer(args[1]);
            if ("String_Node_Str".equals(args[1])) {
                denied = "String_Node_Str";
            } else if (deniedPlayer != null) {
                denied = deniedPlayer.getUniqueId().toString();
            } else {
                player.sendMessage(args[1] + "String_Node_Str");
                return true;
            }
            if (player.getUniqueId().equals(plot.getOwnerId()) || player.hasPermission(PermissionNames.ADMIN_DENY)) {
                if (!"String_Node_Str".equals(denied)) {
                    if (plot.getOwnerId().equals(deniedPlayer.getUniqueId())) {
                        player.sendMessage(C("String_Node_Str"));
                        return true;
                    }
                }
                if (plot.isDeniedConsulting(denied)) {
                    player.sendMessage(C("String_Node_Str") + "String_Node_Str" + args[1] + "String_Node_Str" + C("String_Node_Str"));
                } else {
                    double price = 0.0;
                    PlotAddDeniedEvent event = new PlotAddDeniedEvent(world, plot, player, denied);
                    if (manager.isEconomyEnabled(pmi)) {
                        price = pmi.getDenyPlayerPrice();
                        if (serverBridge.has(player, price)) {
                            plugin.getEventBus().post(event);
                            if (event.isCancelled()) {
                                return true;
                            }
                            EconomyResponse er = serverBridge.withdrawPlayer(player, price);
                            if (!er.transactionSuccess()) {
                                player.sendMessage(er.errorMessage);
                                serverBridge.getLogger().warning(er.errorMessage);
                                return true;
                            }
                        } else {
                            player.sendMessage(C("String_Node_Str") + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + serverBridge.getEconomy().format(price));
                            return true;
                        }
                    } else {
                        plugin.getEventBus().post(event);
                    }
                    if (!event.isCancelled()) {
                        plot.addDenied(denied);
                        plot.removeAllowed(denied);
                        if ("String_Node_Str".equals(denied)) {
                            List<IPlayer> playersInPlot = manager.getPlayersInPlot(id, world);
                            for (IPlayer iPlayer : playersInPlot) {
                                if (!plot.isAllowed(iPlayer.getUniqueId())) {
                                    iPlayer.setLocation(manager.getPlotHome(plot.getId(), player.getWorld()));
                                }
                            }
                        } else {
                            IPlayer deniedPlayer = serverBridge.getPlayer(denied);
                            if (deniedPlayer != null && deniedPlayer.getWorld().equals(world)) {
                                PlotId plotId = manager.getPlotId(deniedPlayer);
                                if (plot.getId().equals(plotId)) {
                                    deniedPlayer.setLocation(manager.getPlotHome(plot.getId(), player.getWorld()));
                                }
                            }
                        }
                        player.sendMessage(C("String_Node_Str") + "String_Node_Str" + denied + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + serverBridge.getEconomy().get().format(price));
                        if (isAdvancedLogging()) {
                            if (price == 0) {
                                serverBridge.getLogger().info(player.getName() + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + denied + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + plot.getId().getID());
                            } else {
                                serverBridge.getLogger().info(player.getName() + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + denied + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + plot.getId().getID() + ("String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + price));
                            }
                        }
                    }
                }
            } else {
                player.sendMessage(C("String_Node_Str") + "String_Node_Str" + plot.getId().getID() + "String_Node_Str" + C("String_Node_Str"));
            }
        } else {
            player.sendMessage(C("String_Node_Str"));
        }
    } else {
        return false;
    }
    return true;
}

Output:
                         } else {
-                            player.sendMessage(C("String_Node_Str") + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + serverBridge.getEconomy().format(price));
+                            player.sendMessage(C("String_Node_Str") + "String_Node_Str" + C("String_Node_Str") + "String_Node_Str" + serverBridge.getEconomy().get().format(price));
                             return true;


Input:
public Figure createBackgroundFigure() {
    Figure result = null;
    Nameable container = getContainer();
    if (container instanceof CompositeEntity) {
        CompositeEntity myContainer = ((CompositeEntity) container);
        ComponentEntity entity = null;
        Iterator entities = myContainer.entityList().iterator();
        while (entities.hasNext()) {
            entity = (ComponentEntity) entities.next();
        }
        if (entity != null) {
            EditorIcon icon = null;
            Iterator icons = entity.attributeList(EditorIcon.class).iterator();
            while (icons.hasNext()) {
                icon = (EditorIcon) icons.next();
            }
            if (icon != null) {
                result = icon.createBackgroundFigure();
            } else {
                try {
                    SingletonConfigurableAttribute description = (SingletonConfigurableAttribute) entity.getAttribute("String_Node_Str", SingletonConfigurableAttribute.class);
                    if (description != null) {
                        SingletonConfigurableAttribute myDescription = (SingletonConfigurableAttribute) myContainer.getAttribute("String_Node_Str", SingletonConfigurableAttribute.class);
                        if (myDescription != null) {
                            myDescription.configure(null, null, description.getText());
                        }
                    }
                } catch (Exception e) {
                }
            }
        }
    }
    if (result == null) {
        result = super.createBackgroundFigure();
    }
    Rectangle2D bounds = result.getBounds();
    CompositeFigure composite = new CompositeFigure();
    BasicRectangle rectangle = new BasicRectangle(bounds.getX() + 10.0, bounds.getY() + 10.0, bounds.getWidth(), bounds.getHeight(), Color.white);
    composite.add(rectangle);
    BasicRectangle rectangle2 = new BasicRectangle(bounds.getX() + 5.0, bounds.getY() + 5.0, bounds.getWidth(), bounds.getHeight(), Color.white);
    composite.add(rectangle2);
    BasicRectangle rectangle3 = new BasicRectangle(bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight(), Color.white);
    composite.add(rectangle3);
    composite.add(result);
    return composite;
}

Output:
         }
-        if (entity != null) {
-            EditorIcon icon = null;
-            Iterator icons = entity.attributeList(EditorIcon.class).iterator();
-            while (icons.hasNext()) {
-                icon = (EditorIcon) icons.next();
-            }
-            if (icon != null) {
-                result = icon.createBackgroundFigure();
-            } else {
-                try {
+        try {
+            if (entity != null) {
+                EditorIcon icon = null;
+                Iterator icons = entity.attributeList(EditorIcon.class).iterator();
+                while (icons.hasNext()) {
+                    icon = (EditorIcon) icons.next();
+                }
+                if (icon != null) {
+                    result = icon.createBackgroundFigure();
+                } else {
                     SingletonConfigurableAttribute description = (SingletonConfigurableAttribute) entity.getAttribute("String_Node_Str", SingletonConfigurableAttribute.class);


Input:
private void threadPopulationCallback(HttpResponse<JsonNode> response) {
    DefaultListModel model = new DefaultListModel();
    try {
        JSONObject resJson = response.getBody().getObject();
        if (resJson.has("String_Node_Str")) {
            Object error = resJson.get("String_Node_Str");
            throw new JSONException("String_Node_Str" + statusToPhrase((int) error));
        }
        threadResults = resJson.getJSONObject("String_Node_Str").getJSONArray("String_Node_Str");
        JSONObject r;
        model = new DefaultListModel();
        for (int i = 0; i < threadResults.length(); i++) {
            r = threadResults.getJSONObject(i).getJSONObject("String_Node_Str");
            StringBuilder titleBuilder = new StringBuilder();
            titleBuilder.append("String_Node_Str").append(r.getString("String_Node_Str")).append("String_Node_Str").append(r.getString("String_Node_Str")).append("String_Node_Str").append(r.getString("String_Node_Str"));
            model.add(i, titleBuilder.toString());
        }
    } catch (Exception e) {
        model.add(0, e.getMessage());
    } finally {
        threadResList.setModel(model);
        threadSearchSubmit.setText("String_Node_Str");
        threadSearchSubmit.setEnabled(true);
    }
}

Output:
             StringBuilder titleBuilder = new StringBuilder();
-            titleBuilder.append("String_Node_Str").append(r.getString("String_Node_Str")).append("String_Node_Str").append(r.getString("String_Node_Str")).append("String_Node_Str").append(r.getString("String_Node_Str"));
+            titleBuilder.append("String_Node_Str").append(r.getString("String_Node_Str")).append("String_Node_Str").append(r.getString("String_Node_Str")).append("String_Node_Str").append(r.getInt("String_Node_Str"));
             model.add(i, titleBuilder.toString());


Input:
private void initParamterBindings() {
    if (targetReportHandle != null) {
        bindingList.clear();
        parameterList.clear();
        String errorMessage = null;
        String newFilename = null;
        if (reportDesignButton.getSelection()) {
            newFilename = locationEditor.getText();
        } else if (reportDocumentButton.getSelection()) {
            newFilename = documentEditor.getText();
        }
        if (newFilename == null || newFilename.length() == 0) {
            errorMessage = ERROR_MSG_REPORT_REQUIRED;
        } else {
            ReportDesignHandle tmpReportDesign = null;
            if (targetReportHandle instanceof IReportDocument) {
                tmpReportDesign = ((IReportDocument) targetReportHandle).getReportDesign();
            } else if (targetReportHandle instanceof ReportDesignHandle) {
                tmpReportDesign = (ReportDesignHandle) targetReportHandle;
            }
            if (tmpReportDesign != null) {
                if (targetReportHandle instanceof ReportDesignHandle) {
                    paramTypes.clear();
                    for (Iterator iter = ((ReportDesignHandle) tmpReportDesign).getAllParameters().iterator(); iter.hasNext(); ) {
                        Object obj = iter.next();
                        if (obj instanceof ParameterHandle) {
                            ParameterHandle param = (ParameterHandle) obj;
                            parameterList.add(param);
                            if (param instanceof ScalarParameterHandle) {
                                paramTypes.put(param.getName(), ((ScalarParameterHandle) param).getDataType());
                            }
                        }
                    }
                }
            }
        }
        if (errorMessage != null) {
            messageLine.setText(errorMessage);
            messageLine.setImage(ERROR_ICON);
        } else {
            messageLine.setText("String_Node_Str");
            messageLine.setImage(null);
        }
        updateButtons();
    }
    bindingList.clear();
    for (Iterator iter = inputHandle.paramBindingsIterator(); iter.hasNext(); ) {
        ParamBindingHandle handle = (ParamBindingHandle) iter.next();
        bindingList.add((ParamBinding) handle.getStructure());
    }
    paramBindingTable.getTable().setEnabled(true);
    paramBindingTable.refresh();
}

Output:
                     paramTypes.clear();
-                    for (Iterator iter = ((ReportDesignHandle) tmpReportDesign).getAllParameters().iterator(); iter.hasNext(); ) {
+                    for (Iterator iter = tmpReportDesign.getAllParameters().iterator(); iter.hasNext(); ) {
                         Object obj = iter.next();


Input:
private void aggregateHostSampleChunks(final List<TimelineChunk> timelineChunks, final int aggregationLevel, final boolean previouslyAggregated) throws IOException {
    final TimelineChunk firstTimesChunk = timelineChunks.get(0);
    final TimelineChunk lastTimesChunk = timelineChunks.get(timelineChunks.size() - 1);
    final int chunkCount = computeChunkCount(timelineChunks.size(), aggregationLevel, previouslyAggregated);
    final int hostId = firstTimesChunk.getHostId();
    final DateTime startTime = firstTimesChunk.getStartTime();
    final DateTime endTime = lastTimesChunk.getEndTime();
    final List<byte[]> timeParts = new ArrayList<byte[]>(chunkCount);
    final List<byte[]> sampleParts = new ArrayList<byte[]>(chunkCount);
    final List<Long> timelineChunkIds = new ArrayList<Long>(chunkCount);
    int sampleCount = 0;
    for (final TimelineChunk timelineChunk : timelineChunks) {
        timeParts.add(timelineChunk.getTimes());
        sampleParts.add(timelineChunk.getSamples());
        sampleCount += timelineChunk.getSampleCount();
        timelineChunkIds.add(timelineChunk.getObjectId());
    }
    final byte[] combinedTimeBytes = TimelineCoder.combineTimelines(timeParts);
    final byte[] combinedSampleBytes = SampleCoder.combineSampleBytes(sampleParts);
    final int timeBytesLength = combinedTimeBytes.length;
    final int totalSize = 4 + timeBytesLength + combinedSampleBytes.length;
    log.debug("String_Node_Str", new Object[] { firstTimesChunk.getHostId(), firstTimesChunk.getAggregationLevel(), timelineChunks.size(), totalSize, sampleCount });
    timelineChunksBytesCreated.addAndGet(totalSize);
    final int totalSampleCount = sampleCount;
    final TimelineChunk chunk = new TimelineChunk(0, hostId, firstTimesChunk.getSampleKindId(), startTime, endTime, combinedTimeBytes, combinedSampleBytes, totalSampleCount, aggregationLevel + 1, false, false);
    chunksToWrite.add(chunk);
    chunkIdsToInvalidateOrDelete.addAll(timelineChunkIds);
    timelineChunksQueuedForCreation.incrementAndGet();
    if (chunkIdsToInvalidateOrDelete.size() >= config.getMaxChunkIdsToInvalidateOrDelete()) {
        performWrites();
    }
}

Output:
     }
-    final byte[] combinedTimeBytes = TimelineCoder.combineTimelines(timeParts);
+    final byte[] combinedTimeBytes = TimelineCoder.combineTimelines(timeParts, sampleCount);
     final byte[] combinedSampleBytes = SampleCoder.combineSampleBytes(sampleParts);


Input:
private Row4Aggregation retrieveOneDetailRow() throws IOException {
    Row4Aggregation row = null;
    if (this.existReferenceDate) {
        row = (Row4Aggregation) this.sortedFactRows.pop();
    }
    return row;
}

Output:
     Row4Aggregation row = null;
-    if (this.existReferenceDate) {
+    if (!avoidExtraSort && this.existReferenceDate) {
         row = (Row4Aggregation) this.sortedFactRows.pop();


Input:
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
    URL url = invoker.getUrl();
    String methodName = invocation.getMethodName();
    Semaphore executesLimit = null;
    boolean acquireResult = false;
    int max = url.getMethodParameter(methodName, Constants.EXECUTES_KEY, 0);
    if (max > 0) {
        RpcStatus count = RpcStatus.getStatus(url, invocation.getMethodName());
        executesLimit = count.getSemaphore(max);
        if (executesLimit != null && !(acquireResult = executesLimit.tryAcquire())) {
            throw new RpcException("String_Node_Str" + invocation.getMethodName() + "String_Node_Str" + url + "String_Node_Str" + max + "String_Node_Str");
        }
    }
    long begin = System.currentTimeMillis();
    boolean isException = false;
    RpcStatus.beginCount(url, methodName);
    try {
        Result result = invoker.invoke(invocation);
        return result;
    } catch (Throwable t) {
        isException = true;
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RpcException("String_Node_Str", t);
        }
    } finally {
        RpcStatus.endCount(url, methodName, System.currentTimeMillis() - begin, isException);
        if (acquireResult) {
            executesLimit.release();
        }
    }
}

Output:
     long begin = System.currentTimeMillis();
-    boolean isException = false;
+    boolean isSuccess = true;
     RpcStatus.beginCount(url, methodName);


Input:
public void testDifferentDelimiter() {
    try {
        final String DELIMITER = "String_Node_Str";
        String testData = TEST_DATA1.replace("String_Node_Str", DELIMITER);
        final String tempFile = TestFileUtils.createTempFile(testData);
        final Configuration conf = new Configuration();
        conf.setString(FileInputFormat.FILE_PARAMETER_KEY, "String_Node_Str" + tempFile);
        conf.setString(TestDelimitedInputFormat.RECORD_DELIMITER, DELIMITER);
        final TestDelimitedInputFormat format = new TestDelimitedInputFormat();
        format.configure(conf);
        BaseStatistics stats = format.getStatistics(null);
        final int numLines = TEST_DATA_1_LINES;
        final float avgWidth = ((float) testData.length()) / TEST_DATA_1_LINES;
        Assert.assertTrue("String_Node_Str", stats.getNumberOfRecords() < numLines + 1 & stats.getNumberOfRecords() > numLines - 1);
        Assert.assertTrue("String_Node_Str", stats.getAverageRecordWidth() < avgWidth + 1 & stats.getAverageRecordWidth() > avgWidth - 1);
    } catch (Exception e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
}

Output:
         final Configuration conf = new Configuration();
-        conf.setString(FileInputFormat.FILE_PARAMETER_KEY, "String_Node_Str" + tempFile);
+        conf.setString(FileInputFormat.FILE_PARAMETER_KEY, tempFile);
         conf.setString(TestDelimitedInputFormat.RECORD_DELIMITER, DELIMITER);


Input:
public Collection<BootstrapInspector.SummaryAggregator<DocLevelLinkingScoring>> createSummaryAggregators() {
    return ImmutableList.<BootstrapInspector.SummaryAggregator<DocLevelLinkingScoring>>of(new BootstrapInspector.SummaryAggregator<DocLevelLinkingScoring>() {
        private final AggregateLinkingScoreRecord.Builder aggregateRecordB = new AggregateLinkingScoreRecord.Builder();
        private final ImmutableMap.Builder<Symbol, AggregateLinkingScoreRecord> aggregateRecordsPerEventTypeB = ImmutableMap.builder();

        private static final String F1 = "String_Node_Str";
        private static final String PRECISION = "String_Node_Str";
        private static final String RECALL = "String_Node_Str";
        private final BootstrapWriter writer = new BootstrapWriter.Builder().measures(ImmutableList.of(F1, PRECISION, RECALL)).percentilesToPrint(ImmutableList.of(0.005, 0.025, 0.05, 0.25, 0.5, 0.75, 0.95, 0.975, 0.995)).percentileComputer(PercentileComputer.nistPercentileComputer()).build();
        public void observeSample(final Collection<DocLevelLinkingScoring> collection) {
            {
                final ImmutableList.Builder<LinkingScoreDocRecord> docRecordsB = ImmutableList.builder();
                for (final DocLevelLinkingScoring linkingScoring : collection) {
                    docRecordsB.add(linkingScoring.linkingScoreDocRecord());
                }
                aggregateRecordB.from(aggregateScores(docRecordsB.build()));
            }
            {
                final ImmutableSet.Builder<Symbol> eventTypesB = ImmutableSet.builder();
                for (final DocLevelLinkingScoring linkingScoring : collection) {
                    eventTypesB.addAll(linkingScoring.docRecordsPerEventType().keySet());
                }
                final ImmutableSet<Symbol> eventTypes = eventTypesB.build();
                for (final Symbol eventType : eventTypes) {
                    final ImmutableList.Builder<LinkingScoreDocRecord> docRecordsB = ImmutableList.builder();
                    for (final DocLevelLinkingScoring linkingScoring : collection) {
                        if (linkingScoring.docRecordsPerEventType().containsKey(eventType)) {
                            docRecordsB.add(linkingScoring.docRecordsPerEventType().get(eventType));
                        }
                    }
                    aggregateRecordsPerEventTypeB.put(eventType, aggregateScores(docRecordsB.build()));
                }
            }
        }
        public void finish() throws IOException {
            final AggregateLinkingScoreRecord aggregateRecord = aggregateRecordB.build();
            writer.writeBootstrapData("String_Node_Str", ImmutableMap.of(F1, aggregateRecord.f1s(), PRECISION, aggregateRecord.precisions(), RECALL, aggregateRecord.recalls()), new File(outputDir, "String_Node_Str"));
            final ImmutableMap<Symbol, AggregateLinkingScoreRecord> aggregateRecordsPerEvent = aggregateRecordsPerEventTypeB.build();
            for (Symbol eventType : aggregateRecordsPerEvent.keySet()) {
                AggregateLinkingScoreRecord recordForEventType = aggregateRecordsPerEvent.get(eventType);
                writer.writeBootstrapData("String_Node_Str" + eventType.asString(), ImmutableMap.of(F1, recordForEventType.f1s(), PRECISION, recordForEventType.precisions(), RECALL, recordForEventType.recalls()), new File(outputDir, "String_Node_Str" + eventType.asString()));
            }
        }
        private AggregateLinkingScoreRecord aggregateScores(ImmutableList<LinkingScoreDocRecord> docRecords) {
            double precision = 0.0;
            double recall = 0.0;
            double f1 = 0.0;
            double linkNormalizerSum = 0.0;
            final ImmutableListMultimap.Builder<String, Double> f1sB = ImmutableListMultimap.builder();
            final ImmutableListMultimap.Builder<String, Double> precisionsB = ImmutableListMultimap.builder();
            final ImmutableListMultimap.Builder<String, Double> recallsB = ImmutableListMultimap.builder();
            for (final LinkingScoreDocRecord docRecord : docRecords) {
                precision += docRecord.fMeasureInfo().precision() * docRecord.predictedCounts();
                recall += docRecord.fMeasureInfo().recall() * docRecord.actualCounts();
                f1 += docRecord.fMeasureInfo().f1() * docRecord.actualCounts();
                linkNormalizerSum += docRecord.linkingArgCounts();
            }
            f1sB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? f1 / linkNormalizerSum : 0.0);
            precisionsB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? precision / linkNormalizerSum : 0.0);
            recallsB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? recall / linkNormalizerSum : 0.0);
            return new AggregateLinkingScoreRecord.Builder().f1s(f1sB.build()).precisions(precisionsB.build()).recalls(recallsB.build()).build();
        }
    });
}

Output:
         private final AggregateLinkingScoreRecord.Builder aggregateRecordB = new AggregateLinkingScoreRecord.Builder();
-        private final ImmutableMap.Builder<Symbol, AggregateLinkingScoreRecord> aggregateRecordsPerEventTypeB = ImmutableMap.builder();
+        private final ImmutableListMultimap.Builder<Symbol, AggregateLinkingScoreRecord> aggregateRecordsPerEventTypeB = ImmutableListMultimap.builder();


Input:
private LinkedHashSet<UserWrapper> searchSingleCriteriaUserinfo(String fieldId, String op, String term) throws KeyNotFoundException, PersistenceException, ConnectionNotAvailableException {
    ArrayList<UserWrapper> users = getUsers();
    LinkedHashSet<UserWrapper> ret = new LinkedHashSet<UserWrapper>();
    for (UserWrapper user : users) {
        String target;
        if (fieldId.equals("String_Node_Str")) {
            target = user.getGivenName();
        } else if (fieldId.equals("String_Node_Str")) {
            target = user.getFamilyName();
        } else if (fieldId.equals("String_Node_Str")) {
            target = user.getStudentId();
        } else {
            debug += "String_Node_Str";
            return ret;
        }
        debug += "String_Node_Str" + target + "String_Node_Str" + term + "String_Node_Str";
        if (op.equals("String_Node_Str")) {
            if (target.contains(term) || term.isEmpty()) {
                ret.add(user);
            }
        } else if (op.equals("String_Node_Str")) {
            if (target.equals(term)) {
                ret.add(user);
            }
        } else if (op.equals("String_Node_Str")) {
            if (!target.contains(term)) {
                ret.add(user);
            }
        } else if (op.equals("String_Node_Str")) {
            try {
                double right = Double.parseDouble(term);
                double left = Double.parseDouble(target);
                if (left > right) {
                    ret.add(user);
                }
            } catch (NumberFormatException e) {
            }
        } else if (op.equals("String_Node_Str")) {
            try {
                double right = Double.parseDouble(term);
                double left = Double.parseDouble(target);
                if (left == right) {
                    ret.add(user);
                }
            } catch (NumberFormatException e) {
            }
        } else if (op.equals("String_Node_Str")) {
            try {
                double right = Double.parseDouble(term);
                double left = Double.parseDouble(target);
                if (left < right) {
                    ret.add(user);
                }
            } catch (NumberFormatException e) {
            }
        } else {
            debug += "String_Node_Str";
            return new LinkedHashSet<UserWrapper>();
        }
    }
    return ret;
}

Output:
     for (UserWrapper user : users) {
-        String target;
-        if (fieldId.equals("String_Node_Str")) {
-            target = user.getGivenName();
-        } else if (fieldId.equals("String_Node_Str")) {
-            target = user.getFamilyName();
-        } else if (fieldId.equals("String_Node_Str")) {
-            target = user.getStudentId();
-        } else {
+        String target = getValueFromUserInfoField(user, fieldId);
+        if (target.isEmpty()) {
             debug += "String_Node_Str";


Input:
public void createPartControl(Composite parent) {
    pageBook = new PageBook(parent, SWT.NONE);
    createHelpMessage(pageBook);
    setupTreeViewer(pageBook);
    pageBook.showPage(helpMessageLabel);
}

Output:
     setupTreeViewer(pageBook);
-    pageBook.showPage(helpMessageLabel);
+    if (rosterAccounts.size() == 0)
+        pageBook.showPage(helpMessageLabel);
 }


Input:
public void testBatchRevokeCleansUpCorrectPoolsWithSourceEnt() throws Exception {
    Consumer c = TestUtil.createConsumer(owner);
    Pool pool2 = TestUtil.createPool(owner, product);
    Entitlement e = new Entitlement(pool, c, 1);
    Entitlement e2 = new Entitlement(pool2, c, 1);
    Entitlement e3 = new Entitlement(pool2, c, 1);
    List<Entitlement> entsToDelete = Util.newList();
    entsToDelete.add(e);
    entsToDelete.add(e2);
    List<Pool> poolsWithSource = createPoolsWithSourceEntitlement(e, product);
    poolsWithSource.get(0).getEntitlements().add(e3);
    when(mockPoolCurator.listBySourceEntitlements(entsToDelete)).thenReturn(poolsWithSource);
    PreUnbindHelper preHelper = mock(PreUnbindHelper.class);
    ValidationResult result = new ValidationResult();
    when(preHelper.getResult()).thenReturn(result);
    when(mockConfig.getBoolean(ConfigProperties.STANDALONE)).thenReturn(true);
    when(mockPoolCurator.lockAndLoad(eq(pool))).thenReturn(pool);
    when(mockPoolCurator.lockAndLoad(eq(pool2))).thenReturn(pool2);
    manager.revokeEntitlements(entsToDelete);
    entsToDelete.add(e3);
    verify(entitlementCurator).batchDelete(eq(entsToDelete));
    verify(mockPoolCurator).batchDelete(eq(poolsWithSource), anySetOf(String.class));
}

Output:
     poolsWithSource.get(0).getEntitlements().add(e3);
-    when(mockPoolCurator.listBySourceEntitlements(entsToDelete)).thenReturn(poolsWithSource);
+    Set<Pool> poolsWithSourceAsSet = new HashSet<Pool>(poolsWithSource);
+    when(mockPoolCurator.listBySourceEntitlements(entsToDelete)).thenReturn(poolsWithSourceAsSet);
     PreUnbindHelper preHelper = mock(PreUnbindHelper.class);


Input:
public void process(EndpointNode endpointNode, List<AnnotationAttachmentNode> annotations) {
    DockerDataHolder.getInstance().setCanProcess(true);
    String endpointType = endpointNode.getEndPointType().getTypeName().getValue();
    if (isBlank(endpointType) || !endpointType.endsWith(LISTENER)) {
        dlog.logDiagnostic(Diagnostic.Kind.ERROR, endpointNode.getPosition(), "String_Node_Str" + "String_Node_Str");
        return;
    }
    try {
        for (AnnotationAttachmentNode attachmentNode : annotations) {
            DockerAnnotation dockerAnnotation = DockerAnnotation.valueOf(attachmentNode.getAnnotationName().getValue());
            switch(dockerAnnotation) {
                case Config:
                    DockerDataHolder.getInstance().setDockerModel(dockerAnnotationProcessor.processConfigAnnotation(attachmentNode));
                    break;
                case CopyFiles:
                    DockerDataHolder.getInstance().addExternalFile(dockerAnnotationProcessor.processCopyFileAnnotation(attachmentNode));
                    break;
                case Expose:
                    List<BLangRecordLiteral.BLangRecordKeyValue> config = ((BLangRecordLiteral) endpointNode.getConfigurationExpression()).getKeyValuePairs();
                    DockerDataHolder.getInstance().addPort(extractPort(config));
                    break;
                default:
                    break;
            }
        }
    } catch (DockerPluginException e) {
        dlog.logDiagnostic(Diagnostic.Kind.ERROR, endpointNode.getPosition(), e.getMessage());
    }
}

Output:
 public void process(EndpointNode endpointNode, List<AnnotationAttachmentNode> annotations) {
-    DockerDataHolder.getInstance().setCanProcess(true);
+    DockerDataHolder dataHolder = DockerContext.getInstance().getDataHolder();
+    dataHolder.setCanProcess(true);
     String endpointType = endpointNode.getEndPointType().getTypeName().getValue();


Input:
private void structureGroup(ResultGroup group, StringBuffer buf) {
    buf.append("String_Node_Str" + group.value.replaceAll("String_Node_Str", "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + (group.rank + 1) + "String_Node_Str" + "String_Node_Str" + group.totalSubGroups + "String_Node_Str" + "String_Node_Str" + group.totalDocs + "String_Node_Str" + "String_Node_Str" + (group.endDoc > 0 ? group.startDoc + 1 : 0) + "String_Node_Str" + "String_Node_Str" + (group.endDoc) + "String_Node_Str");
    if (group.docHits != null)
        structureDocHits(group.docHits, group.startDoc, buf);
    if (group.subGroups != null) {
        for (int i = 0; i < group.subGroups.length; i++) structureGroup(group.subGroups[i], buf);
    }
    buf.append("String_Node_Str");
}

Output:
 private void structureGroup(ResultGroup group, StringBuffer buf) {
-    buf.append("String_Node_Str" + group.value.replaceAll("String_Node_Str", "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + (group.rank + 1) + "String_Node_Str" + "String_Node_Str" + group.totalSubGroups + "String_Node_Str" + "String_Node_Str" + group.totalDocs + "String_Node_Str" + "String_Node_Str" + (group.endDoc > 0 ? group.startDoc + 1 : 0) + "String_Node_Str" + "String_Node_Str" + (group.endDoc) + "String_Node_Str");
+    buf.append("String_Node_Str" + TextServlet.makeHtmlString(group.value) + "String_Node_Str" + "String_Node_Str" + (group.rank + 1) + "String_Node_Str" + "String_Node_Str" + group.totalSubGroups + "String_Node_Str" + "String_Node_Str" + group.totalDocs + "String_Node_Str" + "String_Node_Str" + (group.endDoc > 0 ? group.startDoc + 1 : 0) + "String_Node_Str" + "String_Node_Str" + (group.endDoc) + "String_Node_Str");
     if (group.docHits != null)


Input:
private static List<ArgCV> findAllBranchCVs(CongruentVars parentState, CongruenceType congType, List<CongruentVars> branchStates, List<ArgCV> alreadyAdded) {
    List<ArgCV> allBranchCVs = new ArrayList<ArgCV>();
    CongruentVars firstState = branchStates.get(0);
    for (RecCV val : firstState.availableThisScope(congType)) {
        ArgCV convertedVal = parentState.convertToArgs(val, congType);
        if (convertedVal != null) {
            if (!alreadyAdded.contains(val) && !parentState.isAvailable(val, congType)) {
                int nBranches = branchStates.size();
                boolean presentInAll = true;
                for (CongruentVars otherState : branchStates.subList(1, nBranches)) {
                    if (!otherState.isAvailable(val, congType)) {
                        presentInAll = false;
                        break;
                    }
                }
                if (presentInAll) {
                    allBranchCVs.add(convertedVal);
                }
            }
        }
    }
    return allBranchCVs;
}

Output:
         if (convertedVal != null) {
-            if (!alreadyAdded.contains(val) && !parentState.isAvailable(val, congType)) {
+            if (!alreadyAdded.contains(convertedVal) && !parentState.isAvailable(convertedVal, congType)) {
                 int nBranches = branchStates.size();


Input:
public void loadComponents(IRepositoryIdProvider repoId, HashMap<String, List> ghResources) {
    this.repoId = repoId;
    StatusBar.displayMessage(MESSAGE_LOADING_PROJECT_CONFIG);
    DataManager.getInstance().loadProjectConfig(getRepoId());
    cachedGithubComments = new ConcurrentHashMap<Integer, List<Comment>>();
    boolean isTurboResource = false;
    if (ghResources.get(ServiceManager.KEY_COLLABORATORS) != null) {
        if (ghResources.get(ServiceManager.KEY_COLLABORATORS).get(0).getClass() == TurboUser.class) {
            isTurboResource = true;
        }
    }
    if (isTurboResource) {
        StatusBar.displayMessage(MESSAGE_LOADING_COLLABS);
        loadTurboCollaborators((List<TurboUser>) ghResources.get(ServiceManager.KEY_COLLABORATORS));
        StatusBar.displayMessage(MESSAGE_LOADING_LABELS);
        loadTurboLabels((List<TurboLabel>) ghResources.get(ServiceManager.KEY_LABELS));
        StatusBar.displayMessage(MESSAGE_LOADING_MILESTONES);
        loadTurboMilestones((List<TurboMilestone>) ghResources.get(ServiceManager.KEY_MILESTONES));
        Platform.runLater(() -> {
            List<TurboIssue> issues = dcHandler.getRepo().getIssues(ServiceManager.getInstance().getModel());
            StatusBar.displayMessage(MESSAGE_LOADING_ISSUES);
            loadTurboIssues(issues);
        });
    } else {
        StatusBar.displayMessage(MESSAGE_LOADING_COLLABS);
        loadCollaborators((List<User>) ghResources.get(ServiceManager.KEY_COLLABORATORS));
        StatusBar.displayMessage(MESSAGE_LOADING_LABELS);
        loadLabels((List<Label>) ghResources.get(ServiceManager.KEY_LABELS));
        StatusBar.displayMessage(MESSAGE_LOADING_MILESTONES);
        loadMilestones((List<Milestone>) ghResources.get(ServiceManager.KEY_MILESTONES));
        StatusBar.displayMessage(MESSAGE_LOADING_ISSUES);
        loadIssues((List<Issue>) ghResources.get(ServiceManager.KEY_ISSUES));
    }
}

Output:
     boolean isTurboResource = false;
-    if (ghResources.get(ServiceManager.KEY_COLLABORATORS) != null) {
-        if (ghResources.get(ServiceManager.KEY_COLLABORATORS).get(0).getClass() == TurboUser.class) {
+    if (resources.get(ServiceManager.KEY_COLLABORATORS) != null) {
+        if (resources.get(ServiceManager.KEY_COLLABORATORS).get(0).getClass() == TurboUser.class) {
             isTurboResource = true;


Input:
public void shiftLine(GameField gameField, boolean horizontal, int row, int steps) {
    if (horizontal) {
        Tile[] line = new Tile[gameField.getField().length - 2];
        for (int i = 0; i < gameField.getField().length - 2; i++) {
            line[i] = gameField.getField()[i + 1][row + 1];
            gameField.getField()[i + 1][row + 1] = null;
        }
        for (int i = 0; i < gameField.getField().length - 2; i++) {
            int newPosition = i + steps;
            newPosition = shiftToPositive(newPosition, gameField.getField().length - 2);
            newPosition = newPosition % (gameField.getField().length - 2);
            gameField.getField()[newPosition + 1][row + 1] = line[i];
        }
    } else {
        Tile[] line = new Tile[gameField.getField()[0].length - 2];
        for (int i = 0; i < gameField.getField()[0].length - 2; i++) {
            line[i] = gameField.getField()[row + 1][i + 1];
            gameField.getField()[row + 1][i + 1] = null;
        }
        for (int i = 0; i < gameField.getField()[0].length - 2; i++) {
            int newPosition = (i + steps);
            newPosition = shiftToPositive(newPosition, gameField.getField()[0].length - 2);
            newPosition = newPosition % (gameField.getField()[0].length - 2);
            gameField.getField()[row + 1][newPosition + 1] = line[i];
        }
    }
}

Output:
     if (horizontal) {
-        Tile[] line = new Tile[gameField.getField().length - 2];
-        for (int i = 0; i < gameField.getField().length - 2; i++) {
-            line[i] = gameField.getField()[i + 1][row + 1];
-            gameField.getField()[i + 1][row + 1] = null;
-        }
-        for (int i = 0; i < gameField.getField().length - 2; i++) {
-            int newPosition = i + steps;
-            newPosition = shiftToPositive(newPosition, gameField.getField().length - 2);
-            newPosition = newPosition % (gameField.getField().length - 2);
-            gameField.getField()[newPosition + 1][row + 1] = line[i];
+        if (row < gameField.getField().length - 2) {
+            Tile[] line = new Tile[gameField.getField().length - 2];
+            for (int i = 0; i < gameField.getField().length - 2; i++) {
+                line[i] = gameField.getField()[i + 1][row + 1];
+                gameField.getField()[i + 1][row + 1] = null;
+            }
+            for (int i = 0; i < gameField.getField().length - 2; i++) {
+                int newPosition = i + steps;
+                newPosition = shiftToPositive(newPosition, gameField.getField().length - 2);
+                newPosition = newPosition % (gameField.getField().length - 2);
+                gameField.getField()[newPosition + 1][row + 1] = line[i];
+            }
         }


Input:
public boolean isAvailable(String componentName) {
    if (Boolean.getBoolean("String_Node_Str")) {
        if (!componentName.equals("String_Node_Str")) {
            return false;
        }
    }
    return true;
}

Output:
     if (Boolean.getBoolean("String_Node_Str")) {
-        if (!componentName.equals("String_Node_Str")) {
+        if (componentName.equals("String_Node_Str")) {
             return false;


Input:
public void createPartControl(Composite parent) {
    super.createPartControl(parent);
    unsetJavaBreakpointUpdater();
    installGroovySemanticHighlighting();
    IPreferenceStore preferenceStore = getPreferenceStore();
    boolean closeBrackets = preferenceStore.getBoolean(CLOSE_BRACKETS);
    boolean closeStrings = preferenceStore.getBoolean(CLOSE_STRINGS);
    boolean closeBraces = preferenceStore.getBoolean(CLOSE_BRACES);
    boolean closeAngularBrackets = JavaCore.VERSION_1_5.compareTo(preferenceStore.getString(JavaCore.COMPILER_SOURCE)) <= 0;
    groovyBracketInserter.setCloseBracketsEnabled(closeBrackets);
    groovyBracketInserter.setCloseStringsEnabled(closeStrings);
    groovyBracketInserter.setCloseAngularBracketsEnabled(closeAngularBrackets);
    groovyBracketInserter.setCloseBracesEnabled(closeBraces);
    ISourceViewer sourceViewer = getSourceViewer();
    if (sourceViewer instanceof ITextViewerExtension) {
        ((ITextViewerExtension) sourceViewer).prependVerifyKeyListener(groovyBracketInserter);
    }
    disableBracketInserter();
}

Output:
     IPreferenceStore preferenceStore = getPreferenceStore();
-    boolean closeBrackets = preferenceStore.getBoolean(CLOSE_BRACKETS);
-    boolean closeStrings = preferenceStore.getBoolean(CLOSE_STRINGS);
-    boolean closeBraces = preferenceStore.getBoolean(CLOSE_BRACES);
-    boolean closeAngularBrackets = JavaCore.VERSION_1_5.compareTo(preferenceStore.getString(JavaCore.COMPILER_SOURCE)) <= 0;
-    groovyBracketInserter.setCloseBracketsEnabled(closeBrackets);
-    groovyBracketInserter.setCloseStringsEnabled(closeStrings);
-    groovyBracketInserter.setCloseAngularBracketsEnabled(closeAngularBrackets);
-    groovyBracketInserter.setCloseBracesEnabled(closeBraces);
+    groovyBracketInserter.setCloseBracesEnabled(preferenceStore.getBoolean(CLOSE_BRACES));
+    groovyBracketInserter.setCloseBracketsEnabled(preferenceStore.getBoolean(CLOSE_BRACKETS));
+    groovyBracketInserter.setCloseStringsEnabled(preferenceStore.getBoolean(CLOSE_STRINGS));
+    groovyBracketInserter.setCloseAngularBracketsEnabled(preferenceStore.getString(JavaCore.COMPILER_SOURCE).compareTo(JavaCore.VERSION_1_5) >= 0);
     ISourceViewer sourceViewer = getSourceViewer();


Input:
private void createDisplayNodeList() {
    displayNodeList = new ArrayList();
    JoinPredicate joinPredicate = (JoinPredicate) this.getLanguageObject();
    if (joinPredicate.isOptional()) {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, OPTIONAL_COMMENTS));
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
    }
    if (joinPredicate.hasHint()) {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, LTPAREN));
    }
    DisplayNode child = (DisplayNode) childNodeList.get(0);
    if (child instanceof JoinPredicateDisplayNode && !joinPredicate.getLeftClause().hasHint()) {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, LTPAREN));
        if (child.hasDisplayNodes()) {
            displayNodeList.addAll(child.getDisplayNodeList());
        } else {
            displayNodeList.add(child);
        }
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, RTPAREN));
    } else {
        if (child.hasDisplayNodes()) {
            displayNodeList.addAll(child.getDisplayNodeList());
        } else {
            displayNodeList.add(child);
        }
    }
    JoinType joinType = joinPredicate.getJoinType();
    if (joinType == null) {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, ERROR));
    } else {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, joinType.toString()));
    }
    displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
    child = (DisplayNode) childNodeList.get(1);
    if (child instanceof JoinPredicateDisplayNode && !joinPredicate.getRightClause().hasHint()) {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, LTPAREN));
        if (child.hasDisplayNodes()) {
            displayNodeList.addAll(child.getDisplayNodeList());
        } else {
            displayNodeList.add(child);
        }
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, RTPAREN));
    } else {
        if (child.hasDisplayNodes()) {
            displayNodeList.addAll(child.getDisplayNodeList());
        } else {
            displayNodeList.add(child);
        }
    }
    if (childNodeList.size() > 2) {
        Iterator iter = childNodeList.iterator();
        if (iter.hasNext())
            iter.next();
        if (iter.hasNext())
            iter.next();
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, ReservedWords.ON));
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
        while (iter.hasNext()) {
            child = (DisplayNode) iter.next();
            if (child instanceof PredicateCriteriaDisplayNode) {
                if (child.hasDisplayNodes()) {
                    displayNodeList.addAll(child.getDisplayNodeList());
                } else {
                    displayNodeList.add(child);
                }
            } else {
                displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, LTPAREN));
                if (child.hasDisplayNodes()) {
                    displayNodeList.addAll(child.getDisplayNodeList());
                } else {
                    displayNodeList.add(child);
                }
                displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, RTPAREN));
            }
            if (iter.hasNext()) {
                displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
                displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, ReservedWords.AND));
                displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));
            }
        }
    }
    if (joinPredicate.hasHint()) {
        displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, RTPAREN));
    }
    addFromClauseDepOptions(joinPredicate);
}

Output:
     }
-    if (childNodeList.size() > 2) {
-        Iterator iter = childNodeList.iterator();
-        if (iter.hasNext())
-            iter.next();
-        if (iter.hasNext())
-            iter.next();
+    List joinCriteria = joinPredicate.getJoinCriteria();
+    if (joinCriteria != null && joinCriteria.size() > 0) {
         displayNodeList.add(DisplayNodeFactory.createDisplayNode(this, SPACE));


Input:
protected void writeValue(String value, boolean isAttribute) {
    CharacterEscapeHandler escapeHandler = marshaller.getCharacterEscapeHandler();
    if (escapeHandler != null) {
        try {
            escapeHandler.escape(value.toCharArray(), 0, value.length(), isAttribute, writer);
        } catch (IOException e) {
            throw XMLMarshalException.marshalException(e);
        }
        return;
    }
    try {
        if (value.indexOf('"') > -1 || value.indexOf('&') > -1 || value.indexOf('<') > -1) {
            char[] chars = value.toCharArray();
            for (int x = 0, charsSize = chars.length; x < charsSize; x++) {
                char character = chars[x];
                switch(character) {
                    case '&':
                        {
                            writer.write("String_Node_Str");
                            break;
                        }
                    case '<':
                        {
                            writer.write("String_Node_Str");
                            break;
                        }
                    case '"':
                        {
                            writer.write("String_Node_Str");
                            break;
                        }
                    default:
                        writer.write(character);
                }
            }
        } else {
            writer.write(value);
        }
    } catch (IOException e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
 protected void writeValue(String value, boolean isAttribute) {
-    CharacterEscapeHandler escapeHandler = marshaller.getCharacterEscapeHandler();
+    CharacterEscapeHandler escapeHandler = null;
+    if (marshaller != null) {
+        escapeHandler = marshaller.getCharacterEscapeHandler();
+    }
     if (escapeHandler != null) {


Input:
public boolean wasUnloaded() {
    return unloaded;
}

Output:
 public boolean wasUnloaded() {
-    return unloaded;
+    return wasUnloaded;
 }


Input:
private <T> Object getValue(final VPackSlice parent, final VPackSlice vpack, final Type type, final FieldInfo fieldInfo) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, VPackException {
    final Object value;
    if (vpack.isNull()) {
        value = null;
    } else {
        final VPackDeserializer<?> deserializer = getDeserializer(fieldInfo, type);
        if (deserializer != null) {
            value = ((VPackDeserializer<Object>) deserializer).deserialize(parent, vpack, deserializationContext);
        } else if (type instanceof ParameterizedType) {
            final ParameterizedType pType = ParameterizedType.class.cast(type);
            final Type rawType = pType.getRawType();
            if (Collection.class.isAssignableFrom((Class<?>) rawType)) {
                value = deserializeCollection(parent, vpack, type, pType.getActualTypeArguments()[0]);
            } else if (Map.class.isAssignableFrom((Class<?>) rawType)) {
                final Type[] parameterizedTypes = pType.getActualTypeArguments();
                value = deserializeMap(parent, vpack, type, parameterizedTypes[0], parameterizedTypes[1]);
            } else {
                value = deserializeObject(parent, vpack, type, fieldInfo);
            }
        } else if (Collection.class.isAssignableFrom((Class<?>) type)) {
            value = deserializeCollection(parent, vpack, type, Object.class);
        } else if (Map.class.isAssignableFrom((Class<?>) type)) {
            value = deserializeMap(parent, vpack, type, String.class, Object.class);
        } else if (((Class) type).isArray()) {
            value = deserializeArray(parent, vpack, type, fieldInfo);
        } else if (((Class) type).isEnum()) {
            value = Enum.valueOf((Class<? extends Enum>) type, vpack.getAsString());
        } else {
            value = deserializeObject(parent, vpack, type, fieldInfo);
        }
    }
    return value;
}

Output:
     } else {
-        final VPackDeserializer<?> deserializer = getDeserializer(fieldInfo, type);
+        final VPackDeserializer<?> deserializer = getDeserializer(fieldName, type);
         if (deserializer != null) {


Input:
protected AbstractGroup[][] prepareGroups() {
    String valid = isValid();
    if (valid != null) {
        throw new IllegalArgumentException(valid);
    }
    Range<T> tempLower = new Range<T>(null, null, null);
    Range<T> tempUpper = new Range<T>(null, null, null);
    if (lowerRange.getRepeatBound() != null) {
        tempLower.setRepeatBound(lowerRange.getRepeatBound());
    } else {
        tempLower.setRepeatBound(intervals.get(0).min);
    }
    if (lowerRange.getSnapBound() != null) {
        tempLower.setSnapBound(lowerRange.getSnapBound());
    } else {
        tempLower.setSnapBound(tempLower.getRepeatBound());
    }
    if (lowerRange.getLabelBound() != null) {
        tempLower.setLabelBound(lowerRange.getLabelBound());
    } else {
        tempLower.setLabelBound(tempLower.getSnapBound());
    }
    if (upperRange.getRepeatBound() != null) {
        tempUpper.setRepeatBound(upperRange.getRepeatBound());
    } else {
        tempUpper.setRepeatBound(intervals.get(intervals.size() - 1).max);
    }
    if (upperRange.getSnapBound() != null) {
        tempUpper.setSnapBound(upperRange.getSnapBound());
    } else {
        tempUpper.setSnapBound(tempUpper.getRepeatBound());
    }
    if (upperRange.getLabelBound() != null) {
        tempUpper.setLabelBound(upperRange.getLabelBound());
    } else {
        tempUpper.setLabelBound(tempUpper.getSnapBound());
    }
    ArrayList<IndexNode> nodes = new ArrayList<IndexNode>();
    for (int i = 0, len = intervals.size(); i < len; i += INDEX_FANOUT) {
        int min = i;
        int max = Math.min(i + INDEX_FANOUT - 1, len - 1);
        List<Interval<T>> leafs = new ArrayList<Interval<T>>();
        for (int j = min; j <= max; j++) {
            leafs.add(intervals.get(j));
        }
        nodes.add(new IndexNode(intervals.get(min).min, intervals.get(max).max, leafs.toArray(new Interval[leafs.size()])));
    }
    while (nodes.size() > 1) {
        List<IndexNode> current = (List<IndexNode>) nodes.clone();
        nodes.clear();
        for (int i = 0, len = current.size(); i < len; i += INDEX_FANOUT) {
            int min = i;
            int max = Math.min(i + INDEX_FANOUT - 1, len - 1);
            List<IndexNode> temp = new ArrayList<IndexNode>();
            for (int j = min; j <= max; j++) {
                temp.add(current.get(j));
            }
            nodes.add(new IndexNode(current.get(min).min, current.get(max).max, temp.toArray(new HierarchyBuilderIntervalBased.IndexNode[temp.size()])));
        }
    }
    String[] data = getData();
    List<AbstractGroup[]> result = new ArrayList<AbstractGroup[]>();
    IndexNode index = nodes.get(0);
    DataTypeWithRatioScale<T> type = (DataTypeWithRatioScale<T>) getDataType();
    Map<AbstractGroup, AbstractGroup> cache = new HashMap<AbstractGroup, AbstractGroup>();
    Interval<T> lowerSnap = getInterval(index, type, tempLower.repeatBound);
    lowerSnap = new Interval<T>(this, getDataType(), tempLower.snapBound, lowerSnap.max, lowerSnap.function);
    Interval<T> upperSnap = getIntervalSnap(index, type, tempUpper.repeatBound);
    upperSnap = new Interval<T>(this, getDataType(), upperSnap.min, tempUpper.snapBound, upperSnap.function);
    AbstractGroup[] first = new AbstractGroup[data.length];
    for (int i = 0; i < data.length; i++) {
        T value = type.parse(data[i]);
        Interval<T> interval = getInterval(index, type, value);
        if (type.compare(value, tempLower.labelBound) < 0) {
            throw new IllegalArgumentException(type.format(value) + "String_Node_Str");
        } else if (type.compare(value, tempLower.snapBound) < 0) {
            interval = new Interval<T>(this, true, tempLower.snapBound);
        }
        if (type.compare(value, tempUpper.labelBound) >= 0) {
            throw new IllegalArgumentException(type.format(value) + "String_Node_Str");
        } else if (type.compare(value, tempUpper.snapBound) >= 0) {
            interval = new Interval<T>(this, false, tempUpper.snapBound);
        }
        if (interval.min != null && interval.max != null) {
            if (type.compare(interval.min, tempLower.repeatBound) < 0) {
                interval = lowerSnap;
            }
            if (type.compare(interval.max, tempUpper.repeatBound) >= 0) {
                interval = upperSnap;
            }
        }
        first[i] = getGroup(cache, interval);
    }
    result.add(first);
    index = null;
    List<Group<T>> groups = super.getLevel(0).getGroups();
    if (cache.size() > 1 && !groups.isEmpty()) {
        List<Interval<T>> newIntervals = new ArrayList<Interval<T>>();
        int intervalIndex = 0;
        int multiplier = 0;
        T width = type.subtract(intervals.get(intervals.size() - 1).max, intervals.get(0).min);
        for (Group<T> group : groups) {
            T min = null;
            T max = null;
            for (int i = 0; i < group.getSize(); i++) {
                Interval<T> current = intervals.get(intervalIndex++);
                T offset = type.multiply(width, multiplier);
                T cMin = type.add(current.min, offset);
                T cMax = type.add(current.max, offset);
                if (min == null || type.compare(min, cMin) > 0) {
                    min = cMin;
                }
                if (max == null || type.compare(max, cMax) < 0) {
                    max = cMax;
                }
                if (intervalIndex == intervals.size()) {
                    intervalIndex = 0;
                    multiplier++;
                }
            }
            newIntervals.add(new Interval<T>(this, getDataType(), min, max, group.getFunction()));
        }
        HierarchyBuilderIntervalBased<T> builder = new HierarchyBuilderIntervalBased<T>(getDataType(), lowerRange, upperRange);
        for (Interval<T> interval : newIntervals) {
            builder.addInterval(interval.min, interval.max, interval.function);
        }
        for (int i = 1; i < super.getLevels().size(); i++) {
            for (Group<T> sgroup : super.getLevel(i).getGroups()) {
                builder.getLevel(i - 1).addGroup(sgroup.getSize(), sgroup.getFunction());
            }
        }
        builder.prepare(data);
        AbstractGroup[][] columns = builder.prepareGroups();
        for (AbstractGroup[] column : columns) {
            result.add(column);
        }
    } else if (cache.size() > 1) {
        AbstractGroup[] column = new AbstractGroup[data.length];
        AbstractGroup element = new AbstractGroup("String_Node_Str") {
        };
        for (int i = 0; i < column.length; i++) {
            column[i] = element;
        }
        result.add(column);
    }
    return result.toArray(new AbstractGroup[0][0]);
}

Output:
     lowerSnap = new Interval<T>(this, getDataType(), tempLower.snapBound, lowerSnap.max, lowerSnap.function);
-    Interval<T> upperSnap = getIntervalSnap(index, type, tempUpper.repeatBound);
+    Interval<T> upperSnap = getInterval(index, type, tempUpper.repeatBound);
     upperSnap = new Interval<T>(this, getDataType(), upperSnap.min, tempUpper.snapBound, upperSnap.function);


Input:
private void groupDimletsAndModifiers(List<DimletDescriptor> descriptors, Map<DimletType, List<Integer>> dimlets, Map<DimletType, List<DimletDescriptor>> modifiers, List<DimletDescriptor> currentModifiers) {
    for (DimletDescriptor descriptor : descriptors) {
        DimletType type = descriptor.getType();
        int id = descriptor.getId();
        if (type.isModifier()) {
            currentModifiers.add(descriptor);
        } else {
            if (!currentModifiers.isEmpty()) {
                List<DimletDescriptor> newModifiers = new ArrayList<DimletDescriptor>();
                for (DimletDescriptor modifier : currentModifiers) {
                    if (type.isModifiedBy(modifier.getType())) {
                        add(modifiers, type, modifier);
                    } else {
                        newModifiers.add(modifier);
                    }
                }
                currentModifiers = newModifiers;
            }
            add(dimlets, type, id);
        }
    }
}

Output:
             if (!currentModifiers.isEmpty()) {
-                List<DimletDescriptor> newModifiers = new ArrayList<DimletDescriptor>();
-                for (DimletDescriptor modifier : currentModifiers) {
+                List<DimletDescriptor> copy = new ArrayList<DimletDescriptor>(currentModifiers);
+                for (DimletDescriptor modifier : copy) {
                     if (type.isModifiedBy(modifier.getType())) {


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View rootView = inflater.inflate(R.layout.fragment_profile, container, false);
    context = getActivity();
    api = new WaniKaniApi(getActivity());
    dataMan = new OfflineDataManager(getActivity());
    prefMan = new PrefManager(getActivity());
    mAvatar = (ImageView) rootView.findViewById(R.id.profile_avatar);
    mUsername = (TextView) rootView.findViewById(R.id.profile_username);
    mTitle = (TextView) rootView.findViewById(R.id.profile_title);
    mLevel = (TextView) rootView.findViewById(R.id.profile_level);
    mTopicsCount = (TextView) rootView.findViewById(R.id.profile_topics_count);
    mPostsCount = (TextView) rootView.findViewById(R.id.profile_posts_count);
    mCreationDate = (TextView) rootView.findViewById(R.id.profile_creation_date);
    mAbout = (TextView) rootView.findViewById(R.id.profile_about);
    mWebsite = (TextView) rootView.findViewById(R.id.profile_website);
    mTwitter = (TextView) rootView.findViewById(R.id.profile_twitter);
    mAboutHolder = (LinearLayout) rootView.findViewById(R.id.profile_about_holder);
    mWebsiteHolder = (RelativeLayout) rootView.findViewById(R.id.profile_website_holder);
    mTwitterHolder = (RelativeLayout) rootView.findViewById(R.id.profile_twitter_holder);
    mViewFlipper = (ViewFlipper) rootView.findViewById(R.id.profile_view_flipper);
    mViewFlipper.setInAnimation(getActivity(), R.anim.abc_fade_in);
    mViewFlipper.setInAnimation(getActivity(), R.anim.abc_fade_out);
    mPullToRefreshLayout = (PullToRefreshLayout) rootView.findViewById(R.id.dashboard_pull_to_refresh);
    ActionBarPullToRefresh.from(getActivity()).allChildrenArePullable().listener(this).setup(mPullToRefreshLayout);
    if (prefMan.isProfileFirstTime()) {
        if (mViewFlipper.getDisplayedChild() == 0) {
            mViewFlipper.showNext();
        }
    }
    setOldValues();
    mPullToRefreshLayout.setRefreshing(true);
    new LoadTask().execute();
    return rootView;
}

Output:
     setOldValues();
-    mPullToRefreshLayout.setRefreshing(true);
-    new LoadTask().execute();
+    if (!MainActivity.isFirstSyncProfileDone) {
+        mPullToRefreshLayout.setRefreshing(true);
+        new LoadTask().execute();
+        MainActivity.isFirstSyncProfileDone = true;
+    }
     return rootView;


Input:
public Vector3 rotate(Vector3 axis, float angle) {
    Quaternion temp = Quaternion.REUSABLE_STACK.pop();
    temp.set(axis, angle);
    temp.multiply(this, this);
    Quaternion.REUSABLE_STACK.push(temp);
    return this;
}

Output:
     Quaternion temp = Quaternion.REUSABLE_STACK.pop();
-    temp.set(axis, angle);
+    temp.set(rotation.x, rotation.y, rotation.z);
     temp.multiply(this, this);


Input:
public void actionCriterionPull(ModelCriterion criterion) {
    List<ModelExplicitCriterion> others = new ArrayList<ModelExplicitCriterion>();
    if (criterion instanceof ModelLDiversityCriterion) {
        for (ModelLDiversityCriterion other : model.getLDiversityModel().values()) {
            if (!other.equals(criterion) && other.isActive() && other.isEnabled()) {
                others.add((ModelExplicitCriterion) other);
            }
        }
    } else if (criterion instanceof ModelTClosenessCriterion) {
        for (ModelTClosenessCriterion other : model.getTClosenessModel().values()) {
            if (!other.equals(criterion) && other.isActive() && other.isEnabled()) {
                others.add((ModelExplicitCriterion) other);
            }
        }
    } else {
        throw new RuntimeException("String_Node_Str");
    }
    if (others.isEmpty()) {
        main.showErrorDialog(main.getShell(), Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
        return;
    }
    ModelExplicitCriterion element = main.showSelectCriterionDialog(others);
    if (element == null) {
        return;
    } else {
        ((ModelExplicitCriterion) criterion).pull(element);
        update(new ModelEvent(this, ModelPart.CRITERION_DEFINITION, criterion));
    }
}

Output:
     if (others.isEmpty()) {
-        main.showErrorDialog(main.getShell(), Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
+        main.showInfoDialog(main.getShell(), Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
         return;


Input:
public boolean overrides(MethodInfo superMethod, boolean checkSignature) {
    if (this.equals(superMethod)) {
        return true;
    }
    if (isStatic()) {
        return false;
    }
    if (superMethod.isStatic()) {
        logger.warn("String_Node_Str" + getSignature() + "String_Node_Str" + superMethod.getSignature());
    }
    if (checkSignature) {
        if (!getMemberSignature().equals(superMethod.getMemberSignature())) {
            return false;
        }
        if (!getClassInfo().isInstanceOf(superMethod.getClassInfo())) {
            return false;
        }
    }
    return getClassInfo().canAccess(superMethod);
}

Output:
         }
-        if (!getClassInfo().isInstanceOf(superMethod.getClassInfo())) {
+        if (!getClassInfo().isSubclassOf(superMethod.getClassInfo())) {
             return false;


Input:
private void handleDeleteLastCharacter(boolean forMultiTap) {
    InputConnection ic = getCurrentInputConnection();
    if (!forMultiTap && performOnTextDeletion(ic))
        return;
    boolean deleteChar = false;
    if (mPredicting) {
        final boolean wordManipulation = mWord.length() > 0 && mWord.cursorPosition() > 0;
        if (wordManipulation) {
            mWord.deleteLast();
            final int cursorPosition;
            if (mWord.cursorPosition() != mWord.length())
                cursorPosition = getCursorPosition(ic);
            else
                cursorPosition = -1;
            if (cursorPosition >= 0)
                ic.beginBatchEdit();
            ic.setComposingText(mWord.getTypedWord(), 1);
            if (mWord.length() == 0) {
                mPredicting = false;
            } else if (cursorPosition >= 0) {
                ic.setSelection(cursorPosition - 1, cursorPosition - 1);
            }
            if (cursorPosition >= 0)
                ic.endBatchEdit();
            postUpdateSuggestions();
        } else {
            ic.deleteSurroundingText(1, 0);
        }
    } else {
        deleteChar = true;
    }
    TextEntryState.backspace();
    if (TextEntryState.getState() == TextEntryState.State.UNDO_COMMIT) {
        revertLastWord(deleteChar);
    } else if (deleteChar) {
        if (mCandidateView != null && mCandidateView.dismissAddToDictionaryHint()) {
            revertLastWord(true);
        } else {
            if (!forMultiTap) {
                sendDownUpKeyEvents(KeyEvent.KEYCODE_DEL);
            } else {
                final CharSequence beforeText = ic == null ? null : ic.getTextBeforeCursor(1, 0);
                final int textLengthBeforeDelete = (TextUtils.isEmpty(beforeText)) ? 0 : beforeText.length();
                if (textLengthBeforeDelete > 0)
                    ic.deleteSurroundingText(1, 0);
                else
                    sendDownUpKeyEvents(KeyEvent.KEYCODE_DEL);
            }
        }
    }
}

Output:
     } else if (deleteChar) {
-        if (mCandidateView != null && mCandidateView.dismissAddToDictionaryHint()) {
-            revertLastWord(true);
+        if (mCandidateView != null)
+            mCandidateView.dismissAddToDictionaryHint();
+        if (!forMultiTap) {
+            sendDownUpKeyEvents(KeyEvent.KEYCODE_DEL);
         } else {


Input:
public boolean isDict() {
    if (isObject()) {
        FunctionType ctor = toObjectType().getConstructor();
        return ctor != null && ctor.makesDicts();
    }
    return false;
}

Output:
     if (isObject()) {
-        FunctionType ctor = toObjectType().getConstructor();
+        ObjectType objType = toObjectType();
+        ObjectType iproto = objType.getImplicitPrototype();
+        if (iproto != null && iproto.isDict()) {
+            return true;
+        }
+        FunctionType ctor = objType.getConstructor();
         return ctor != null && ctor.makesDicts();


Input:
void add(ObjectType newObj) {
    boolean addedObj = false;
    for (int i = 0; i < this.objs.size(); i++) {
        ObjectType oldObj = this.objs.get(i);
        if (NominalType.equalRawTypes(oldObj.getNominalType(), newObj.getNominalType())) {
            addedObj = true;
            if (this.resolution == ResolveConflictsBy.JOIN) {
                this.objs.set(i, ObjectType.join(oldObj, newObj));
            } else {
                this.objs.set(i, ObjectType.meet(oldObj, newObj));
            }
        }
    }
    if (!addedObj) {
        this.objs.add(newObj);
    }
}

Output:
             addedObj = true;
-            if (this.resolution == ResolveConflictsBy.JOIN) {
-                this.objs.set(i, ObjectType.join(oldObj, newObj));
-            } else {
-                this.objs.set(i, ObjectType.meet(oldObj, newObj));
-            }
+            this.objs.set(i, ObjectType.meet(oldObj, newObj));
         }


Input:
public void accept(PurchaseOrderSupplierLine purchaseOrderSupplierLine) {
    PurchaseOrderLine purchaseOrderLine = purchaseOrderSupplierLine.getPurchaseOrderLine();
    purchaseOrderLine.setEstimatedDelivDate(purchaseOrderSupplierLine.getEstimatedDelivDate());
    purchaseOrderLine.setSupplierPartner(purchaseOrderSupplierLine.getSupplierPartner());
    purchaseOrderLine.setPrice(purchaseOrderSupplierLine.getPrice());
    purchaseOrderLine.setExTaxTotal(PurchaseOrderLineService.computeAmount(purchaseOrderLine.getQty(), purchaseOrderLine.getPrice()));
    purchaseOrderLine.save();
}

Output:
     purchaseOrderLine.setExTaxTotal(PurchaseOrderLineService.computeAmount(purchaseOrderLine.getQty(), purchaseOrderLine.getPrice()));
-    purchaseOrderLine.save();
+    purchaseOrderSupplierLine.setStateSelect(IPurchaseOrderSupplierLine.ACCEPTED);
+    purchaseOrderSupplierLine.save();
 }


Input:
private int midPointSelect(Token[] tokens, int p, int r, int i) {
    if (p == r) {
        return p;
    }
    int q = midPointPartition(tokens, p, r);
    int k = q - p + 1;
    if (i == k) {
        return q;
    } else if (i < k) {
        return midPointSelect(tokens, p, q - 1, i);
    } else {
        return midPointSelect(tokens, q + 1, r, i - k);
    }
}

Output:
     }
-    int q = midPointPartition(tokens, p, r);
-    int k = q - p + 1;
-    if (i == k) {
-        return q;
-    } else if (i < k) {
-        return midPointSelect(tokens, p, q - 1, i);
+    if (start == end) {
+        return start;
+    }
+    int partitionToken = midPointPartition(tokens, start, end);
+    int newSize = partitionToken - start + 1;
+    if (targetSize == newSize) {
+        return partitionToken;
+    } else if (targetSize < newSize) {
+        return midPointSelect(tokens, start, partitionToken - 1, targetSize, depth + 1);
     } else {


Input:
public void testGetMulti() {
    assertEquals(8, n.length());
    assertEquals(true, Arrays.equals(ArrayUtil.of(2, 2, 2), n.shape()));
    float val = (float) n.getScalar(1, 1, 1).element();
    assertEquals(8.0, val, 1e-6);
}

Output:
     assertEquals(true, Arrays.equals(ArrayUtil.of(2, 2, 2), n.shape()));
-    float val = (float) n.getScalar(1, 1, 1).element();
+    float val = (float) n.getScalar(new int[] { 1, 1, 1 }).element();
     assertEquals(8.0, val, 1e-6);


Input:
private boolean restoreRecentTaskLocked(TaskRecord task, int stackId) {
    if (stackId == INVALID_STACK_ID) {
        stackId = task.getLaunchStackId();
    }
    if (task.stack != null) {
        if (task.stack.mStackId == stackId) {
            return true;
        }
        task.stack.removeTask(task, "String_Node_Str", MOVING);
    }
    ActivityStack stack = getStack(stackId, CREATE_IF_NEEDED, !ON_TOP);
    if (stack == null) {
        if (DEBUG_RECENTS)
            Slog.v(TAG_RECENTS, "String_Node_Str" + task);
        return false;
    }
    stack.addTask(task, false, false);
    if (DEBUG_RECENTS)
        Slog.v(TAG_RECENTS, "String_Node_Str" + task + "String_Node_Str" + stack);
    final ArrayList<ActivityRecord> activities = task.mActivities;
    for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
        stack.addConfigOverride(activities.get(activityNdx), task);
    }
    return true;
}

Output:
     }
-    ActivityStack stack = getStack(stackId, CREATE_IF_NEEDED, !ON_TOP);
+    final ActivityStack stack = getStack(stackId, CREATE_IF_NEEDED, !ON_TOP);
     if (stack == null) {


Input:
private void processInternalMethodInvocation(ClassObject classObject, MethodObject methodObject, AbstractVariable variableDeclaration, Set<String> processedMethods) {
    SystemObject systemObject = ASTReader.getSystemObject();
    if (methodObject.isAbstract() || classObject.isInterface()) {
        TypeDeclaration typeDeclaration = classObject.getTypeDeclaration();
        IMethodBinding superMethodDeclarationBinding = methodObject.getMethodDeclaration().resolveBinding();
        IType superType = (IType) typeDeclaration.resolveBinding().getJavaElement();
        processedMethods.add(superMethodDeclarationBinding.getKey());
        Set<IType> subTypes = CompilationUnitCache.getInstance().getSubTypes(superType);
        Set<IType> subTypesToBeAnalyzed = new LinkedHashSet<IType>();
        if (variableDeclaration != null) {
            String initialReferenceType = variableDeclaration.getVariableType();
            for (IType subType : subTypes) {
                if (subType.getFullyQualifiedName('.').equals(initialReferenceType)) {
                    subTypesToBeAnalyzed.add(subType);
                    break;
                }
            }
            if (subTypesToBeAnalyzed.isEmpty())
                subTypesToBeAnalyzed.addAll(subTypes);
        } else
            subTypesToBeAnalyzed.addAll(subTypes);
        for (IType subType : subTypesToBeAnalyzed) {
            ClassObject subClassObject = systemObject.getClassObject(subType.getFullyQualifiedName('.'));
            if (subClassObject != null) {
                ListIterator<MethodObject> methodIterator = subClassObject.getMethodIterator();
                while (methodIterator.hasNext()) {
                    MethodObject subMethod = methodIterator.next();
                    if (equalSignature(subMethod.getMethodDeclaration().resolveBinding(), superMethodDeclarationBinding)) {
                        processInternalMethodInvocation(subClassObject, subMethod, variableDeclaration, processedMethods);
                        break;
                    }
                }
            }
        }
    } else {
        for (PlainVariable originalField : methodObject.getDefinedFieldsThroughThisReference()) {
            boolean alreadyContainsOriginalField = false;
            if (variableDeclaration != null && originalField instanceof PlainVariable) {
                if (variableDeclaration.containsPlainVariable((PlainVariable) originalField))
                    alreadyContainsOriginalField = true;
            }
            if (!alreadyContainsOriginalField) {
                AbstractVariable field = null;
                if (variableDeclaration != null)
                    field = composeVariable(variableDeclaration, originalField);
                else
                    field = originalField;
                definedVariables.add(field);
            }
        }
        for (PlainVariable originalField : methodObject.getUsedFieldsThroughThisReference()) {
            boolean alreadyContainsOriginalField = false;
            if (variableDeclaration != null && originalField instanceof PlainVariable) {
                if (variableDeclaration.containsPlainVariable((PlainVariable) originalField))
                    alreadyContainsOriginalField = true;
            }
            if (!alreadyContainsOriginalField) {
                AbstractVariable field = null;
                if (variableDeclaration != null)
                    field = composeVariable(variableDeclaration, originalField);
                else
                    field = originalField;
                usedVariables.add(field);
            }
        }
        thrownExceptionTypes.addAll(methodObject.getExceptionsInThrowStatements());
        processedMethods.add(methodObject.getMethodDeclaration().resolveBinding().getKey());
        Map<AbstractVariable, LinkedHashSet<MethodInvocationObject>> invokedMethodsThroughFields = methodObject.getInvokedMethodsThroughFields();
        for (AbstractVariable originalField : invokedMethodsThroughFields.keySet()) {
            boolean alreadyContainsOriginalField = false;
            if (variableDeclaration != null && originalField instanceof PlainVariable) {
                if (variableDeclaration.containsPlainVariable((PlainVariable) originalField))
                    alreadyContainsOriginalField = true;
            }
            if (!alreadyContainsOriginalField) {
                LinkedHashSet<MethodInvocationObject> methodInvocations = invokedMethodsThroughFields.get(originalField);
                AbstractVariable field = null;
                if (variableDeclaration != null)
                    field = composeVariable(variableDeclaration, originalField);
                else
                    field = originalField;
                for (MethodInvocationObject methodInvocationObject : methodInvocations) {
                    MethodInvocation methodInvocation2 = methodInvocationObject.getMethodInvocation();
                    ClassObject classObject2 = systemObject.getClassObject(methodInvocationObject.getOriginClassName());
                    if (classObject2 != null) {
                        MethodObject methodObject2 = classObject2.getMethod(methodInvocationObject);
                        if (methodObject2 != null) {
                            processInternalMethodInvocation(classObject2, methodObject2, field, new LinkedHashSet<String>());
                        }
                    } else {
                        LibraryClassStorage instance = LibraryClassStorage.getInstance();
                        IMethodBinding invokedMethodBinding = methodInvocation2.resolveMethodBinding();
                        if (instance.isAnalyzed(invokedMethodBinding.getKey())) {
                            handleAlreadyAnalyzedMethod(invokedMethodBinding.getKey(), field, instance);
                        } else {
                            MethodDeclaration invokedMethodDeclaration = getInvokedMethodDeclaration(invokedMethodBinding);
                            if (invokedMethodDeclaration != null)
                                processExternalMethodInvocation(invokedMethodDeclaration, field, new LinkedHashSet<String>(), 0);
                        }
                    }
                }
            }
        }
        for (MethodInvocationObject methodInvocationObject : methodObject.getInvokedMethodsThroughThisReference()) {
            MethodObject methodObject2 = classObject.getMethod(methodInvocationObject);
            if (methodObject2 != null) {
                if (!methodObject2.equals(methodObject)) {
                    MethodInvocation methodInvocation2 = methodInvocationObject.getMethodInvocation();
                    if (!processedMethods.contains(methodInvocation2.resolveMethodBinding().getKey()))
                        processInternalMethodInvocation(classObject, methodObject2, variableDeclaration, processedMethods);
                }
            } else {
                ClassObject classObject2 = systemObject.getClassObject(methodInvocationObject.getOriginClassName());
                if (classObject2 != null) {
                    methodObject2 = classObject2.getMethod(methodInvocationObject);
                    if (methodObject2 != null) {
                        thrownExceptionTypes.addAll(methodObject2.getExceptionsInThrowStatements());
                    }
                }
            }
        }
        for (SuperMethodInvocationObject superMethodInvocationObject : methodObject.getSuperMethodInvocations()) {
            ClassObject classObject2 = systemObject.getClassObject(superMethodInvocationObject.getOriginClassName());
            if (classObject2 != null) {
                MethodObject methodObject2 = classObject2.getMethod(superMethodInvocationObject);
                if (methodObject2 != null) {
                    SuperMethodInvocation superMethodInvocation = superMethodInvocationObject.getSuperMethodInvocation();
                    if (!processedMethods.contains(superMethodInvocation.resolveMethodBinding().getKey()))
                        processInternalMethodInvocation(classObject2, methodObject2, variableDeclaration, processedMethods);
                }
            }
        }
    }
}

Output:
                         if (methodObject2 != null) {
-                            processInternalMethodInvocation(classObject2, methodObject2, field, new LinkedHashSet<String>());
+                            if (!processedMethods.contains(methodInvocation2.resolveMethodBinding().getKey()))
+                                processInternalMethodInvocation(classObject2, methodObject2, field, new LinkedHashSet<String>());
                         }


Input:
private static void doTest(int equations, boolean print) {
    for (int i = 0; i < 6; i++) {
        c0[i] = myRandom.nextDouble() * 100.0F;
        c1[i] = myRandom.nextDouble() * 100.0F;
    }
    float[] destCoords = new float[2 * equations];
    for (int i = 0; i < 2 * equations; i++) {
        destCoords[i] = myRandom.nextFloat() * 100.0F;
    }
    float[] sourceCoords = new float[2 * equations];
    for (int i = 0; i < equations; i++) {
        sourceCoords[2 * i] = xpoly(destCoords[2 * i], destCoords[2 * i + 1]);
        sourceCoords[2 * i + 1] = ypoly(destCoords[2 * i], destCoords[2 * i + 1]);
    }
    float[] coeffs = getCoeffs(sourceCoords, 0, destCoords, 0, sourceCoords.length, 0.5F, 0.5F, 2.0F, 2.0F, 2);
    if (print) {
        System.out.println("String_Node_Str" + equations + "String_Node_Str");
        for (int i = 0; i < 6; i++) {
            System.out.println("String_Node_Str" + i + "String_Node_Str" + c0[i] + "String_Node_Str" + coeffs[i] + "String_Node_Str" + (c0[i] / coeffs[i]) + "String_Node_Str");
            System.out.println("String_Node_Str" + i + "String_Node_Str" + c1[i] + "String_Node_Str" + coeffs[i + 6] + "String_Node_Str" + (c1[i] / coeffs[i + 6]) + "String_Node_Str");
        }
    }
}

Output:
     }
-    float[] coeffs = getCoeffs(sourceCoords, 0, destCoords, 0, sourceCoords.length, 0.5F, 0.5F, 2.0F, 2.0F, 2);
+    float[] coeffs = getCoeffs(sourceCoords, 0, destCoords, 0, sourceCoords.length, (float) preScaleX, (float) preScaleY, (float) postScaleX, (float) postScaleY, 2);
     if (print) {


Input:
public boolean close() {
    for (Thread t : comsumerThreads) {
        t.interrupt();
    }
    for (int i = 0; i < threadNum; i++) {
        metrics.remove((MetricRegistry.name(TKStore.class, "String_Node_Str" + partitionId + "String_Node_Str" + i, "String_Node_Str")));
    }
    return true;
}

Output:
     for (int i = 0; i < threadNum; i++) {
-        metrics.remove((MetricRegistry.name(TKStore.class, "String_Node_Str" + partitionId + "String_Node_Str" + i, "String_Node_Str")));
+        synchronized (metrics) {
+            metrics.remove((MetricRegistry.name(TKStore.class, "String_Node_Str" + partitionId + "String_Node_Str" + i, "String_Node_Str")));
+        }
     }


Input:
public static PendingIntent buildSnoozeIntent(Context context, Habit habit) {
    Uri data = habit.getUri();
    Intent snoozeIntent = new Intent(context, HabitBroadcastReceiver.class);
    snoozeIntent.setData(data);
    snoozeIntent.setAction(ACTION_SNOOZE);
    return PendingIntent.getBroadcast(context, 0, snoozeIntent, 0);
}

Output:
     snoozeIntent.setAction(ACTION_SNOOZE);
-    return PendingIntent.getBroadcast(context, 0, snoozeIntent, 0);
+    return PendingIntent.getBroadcast(context, 0, snoozeIntent, PendingIntent.FLAG_CANCEL_CURRENT);
 }


Input:
public boolean isAlreadyBuilt(IBuilderContext context, BlockPos pos) {
    Block block = context.world().getBlockState(pos).getBlock();
    return block == Blocks.farmland;
}

Output:
     Block block = context.world().getBlockState(pos).getBlock();
-    return block == Blocks.farmland;
+    return block == Blocks.FARMLAND;
 }


Input:
public String getVersion() {
    return (_version);
}

Output:
 public String getVersion() {
-    return (_version);
+    return (_network.getVersion());
 }


Input:
public void setParameters(Parameters params) {
    if (params == null) {
        Log.v(TAG, "String_Node_Str");
        return;
    }
    mCameraHandler.obtainMessage(SET_PARAMETERS, params.flatten()).sendToTarget();
}

Output:
     }
-    mCameraHandler.obtainMessage(SET_PARAMETERS, params.flatten()).sendToTarget();
+    mSig.close();
+    mCameraHandler.obtainMessage(SET_PARAMETERS, params).sendToTarget();
+    mSig.block();
 }


Input:
public void save(MainGrid grid, OutputStream out) throws IOException {
    final ObjectOutputStream oos = new ObjectOutputStream(out);
    Thread t = new Thread(null, new GameSaveTask(grid, oos), "String_Node_Str", SAVE_STACK_SIZE);
    t.start();
    try {
        t.join();
    } catch (InterruptedException e) {
        throw new IOException(e);
    }
    oos.flush();
    oos.close();
}

Output:
     final ObjectOutputStream oos = new ObjectOutputStream(out);
-    Thread t = new Thread(null, new GameSaveTask(grid, oos), "String_Node_Str", SAVE_STACK_SIZE);
+    GameSaveTask runnable = new GameSaveTask(grid, oos);
+    Thread t = new Thread(null, runnable, "String_Node_Str", SAVE_STACK_SIZE);
     t.start();


Input:
public void runOperation(VariableMap variableMap, IProgressMonitor monitor) throws Exception {
    IOseeBranch branch = variableMap.getBranch("String_Node_Str");
    if (branch == null) {
        throw new OseeArgumentException("String_Node_Str");
    }
    List<TraceTypeEnum> traceTypes = getCheckedTraceItems(variableMap);
    if (traceTypes.isEmpty()) {
        throw new OseeArgumentException("String_Node_Str");
    }
    boolean isExcelOutput = variableMap.getBoolean("String_Node_Str");
    boolean isResultEditorOutput = variableMap.getBoolean("String_Node_Str");
    OutputType output = OutputType.asType(isExcelOutput, isResultEditorOutput);
    if (output == null) {
        throw new OseeArgumentException("String_Node_Str");
    }
    ISheetWriter writer = null;
    CharBackedInputStream excelInputStream = null;
    Map<String, AbstractArtifactRelationReport> reports = new LinkedHashMap<>();
    List<BaseTraceDataCache> traceCache = new ArrayList<>();
    RequirementData reqData = new RequirementData(branch);
    CodeUnitData codeUnit = null;
    TestUnitData testUnit = null;
    try {
        int TOTAL_WORK = Integer.MAX_VALUE;
        int TASK_WORK = TOTAL_WORK / 5;
        monitor.beginTask("String_Node_Str", TOTAL_WORK);
        SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, TASK_WORK);
        reqData.initialize(subMonitor);
        traceCache.add(reqData);
        subMonitor = new SubProgressMonitor(monitor, TASK_WORK);
        if (TraceTypeEnum.Code_Unit_Trace.isIn(traceTypes)) {
            codeUnit = new CodeUnitData(branch);
            codeUnit.initialize(subMonitor);
            traceCache.add(codeUnit);
        } else {
            subMonitor.done();
        }
        subMonitor = new SubProgressMonitor(monitor, TASK_WORK);
        if (TraceTypeEnum.containsTestEnum(traceTypes)) {
            testUnit = new TestUnitData(branch);
            testUnit.initialize(subMonitor);
            traceCache.add(testUnit);
        } else {
            subMonitor.done();
        }
        if (!monitor.isCanceled()) {
            if (isExcelOutput(output)) {
                excelInputStream = new CharBackedInputStream();
                writer = new ExcelXmlWriter(excelInputStream.getWriter());
            }
            buildReport(reports, "String_Node_Str", output, writer, getTraceUnitToReqReport(codeUnit, testUnit, traceTypes));
            buildReport(reports, "String_Node_Str", output, writer, getDisconnectedTraceUnitReport(codeUnit, testUnit, traceTypes));
            buildReport(reports, "String_Node_Str", output, writer, getTraceCountReport(reqData, traceTypes));
            subMonitor = new SubProgressMonitor(monitor, TASK_WORK);
            executeReports(subMonitor, reports);
        }
        subMonitor = new SubProgressMonitor(monitor, TASK_WORK);
        displayReports(subMonitor, writer, excelInputStream, output);
    } finally {
        try {
            for (AbstractArtifactRelationReport report : reports.values()) {
                report.clear();
            }
            for (BaseTraceDataCache cache : traceCache) {
                cache.reset();
            }
            reports.clear();
            traceCache.clear();
            resultsTabs.clear();
        } finally {
            monitor.done();
        }
    }
}

Output:
 public void runOperation(VariableMap variableMap, IProgressMonitor monitor) throws Exception {
-    IOseeBranch branch = variableMap.getBranch("String_Node_Str");
+    BranchId branch = variableMap.getBranch("String_Node_Str");
     if (branch == null) {


Input:
public TileInfo call() {
    if (tileFile == null) {
        return null;
    }
    GeoImageReader gir2 = imagePool.get();
    String next = buildTileId(level, i, j);
    if (gir2 == null) {
        return new TileInfo(next, tileFile, null);
    }
    try {
        int x = i * (1 << level) * Constant.TILE_SIZE_IMG_LAYER - xpadding;
        int y = j * (1 << level) * Constant.TILE_SIZE_IMG_LAYER - ypadding;
        float zoom = (1 << level);
        final BufferedImage out = createImage(gir2, x, y, Constant.TILE_SIZE_IMG_LAYER, Constant.TILE_SIZE_IMG_LAYER, zoom);
        ImageIO.write(out, "String_Node_Str", tileFile);
        return new TileInfo(next, tileFile, out);
    } catch (Exception ex) {
        logger.error(ex.getMessage(), ex);
    } finally {
        imagePool.release(gir2);
    }
    return new TileInfo(next, tileFile, null);
}

Output:
         float zoom = (1 << level);
-        final BufferedImage out = createImage(gir2, x, y, Constant.TILE_SIZE_IMG_LAYER, Constant.TILE_SIZE_IMG_LAYER, zoom);
-        ImageIO.write(out, "String_Node_Str", tileFile);
-        return new TileInfo(next, tileFile, out);
+        final BufferedImage out = createImage(activeGir, x, y, Constant.TILE_SIZE_IMG_LAYER, Constant.TILE_SIZE_IMG_LAYER, zoom);
+        ImageIO.write(out, "String_Node_Str", f);
+        return new Object[] { f.getAbsolutePath(), next, out };
     } catch (Exception ex) {


Input:
public boolean replaceEvent(GameEvent event, Game game) {
    boolean caught = false;
    List<UUID> consumed = new ArrayList<UUID>();
    do {
        List<ReplacementEffect> rEffects = getApplicableReplacementEffects(event, game);
        for (Iterator<ReplacementEffect> i = rEffects.iterator(); i.hasNext(); ) {
            ReplacementEffect entry = i.next();
            if (consumed.contains(entry.getId()))
                i.remove();
        }
        if (rEffects.isEmpty())
            break;
        int index;
        if (rEffects.size() == 1) {
            index = 0;
        } else {
            Player player = game.getPlayer(event.getPlayerId());
            index = player.chooseEffect(rEffects, game);
        }
        ReplacementEffect rEffect = rEffects.get(index);
        caught = rEffect.replaceEvent(event, this.getAbility(rEffect.getId()), game);
        if (caught)
            break;
        consumed.add(rEffect.getId());
        game.applyEffects();
    } while (true);
    return caught;
}

Output:
             ReplacementEffect entry = i.next();
-            if (consumed.contains(entry.getId()))
+            if (consumed.contains(entry.getId())) {
                 i.remove();


Input:
public String getRowsMatchStatement() {
    Table tablea = (Table) indicator.getAnalyzedElement();
    String tableA = tablea.getName();
    String query = "String_Node_Str" + dbmsLanguage.from() + getFullyQualifiedTableName(tablea);
    if (ColumnsetPackage.eINSTANCE.getRowMatchingIndicator() == indicator.eClass()) {
        Table tableb = (Table) ColumnHelper.getColumnSetOwner(((RowMatchingIndicator) indicator).getColumnSetB().get(0));
        String tableB = tableb.getName();
        EList<Column> columnSetA = ((RowMatchingIndicator) indicator).getColumnSetA();
        EList<Column> columnSetB = ((RowMatchingIndicator) indicator).getColumnSetB();
        String where = null;
        for (int i = 0; i < columnSetA.size(); i++) {
            where = dbmsLanguage.and();
            if (i == 0) {
                where = dbmsLanguage.where();
            }
            String clause = "String_Node_Str" + dbmsLanguage.quote(tableB) + "String_Node_Str" + dbmsLanguage.quote(columnSetB.get(i).getName()) + dbmsLanguage.from() + getFullyQualifiedTableName(tableb);
            query += where + dbmsLanguage.quote(tableA) + "String_Node_Str" + dbmsLanguage.quote(columnSetA.get(i).getName()) + dbmsLanguage.in() + inBrackets(clause);
        }
    }
    return query;
}

Output:
             }
-            String clause = "String_Node_Str" + dbmsLanguage.quote(tableB) + "String_Node_Str" + dbmsLanguage.quote(columnSetB.get(i).getName()) + dbmsLanguage.from() + getFullyQualifiedTableName(tableb);
+            String fullColumnName = dbmsLanguage.quote(tableB) + "String_Node_Str" + dbmsLanguage.quote(columnSetB.get(i).getName());
+            String clause = "String_Node_Str" + fullColumnName + dbmsLanguage.from() + getFullyQualifiedTableName(tableb) + dbmsLanguage.where() + fullColumnName + dbmsLanguage.isNotNull();
             query += where + dbmsLanguage.quote(tableA) + "String_Node_Str" + dbmsLanguage.quote(columnSetA.get(i).getName()) + dbmsLanguage.in() + inBrackets(clause);


Input:
private void updateItemInCommentsList(TurboComment comment) {
    for (TurboComment item : comments) {
        if (item.getId() == comment.getId()) {
            item.copyValues(comment);
            return;
        }
    }
    addItemToObservedCommentList(comment);
}

Output:
         if (item.getId() == comment.getId()) {
-            item.copyValues(comment);
+            replaceItemInObservedCommentsList(item, comment);
             return;


Input:
public boolean encode() {
    int i, j;
    int est_binlen;
    EccMode ecc_level;
    int max_cw;
    int autosize;
    int target_binlen, version, blocks;
    int size;
    int bitmask;
    String bin;
    if (debug) {
        System.out.printf("String_Node_Str", content);
    }
    inputMode = new qrMode[content.length()];
    define_mode();
    est_binlen = estimate_binary_length();
    ecc_level = preferredEccLevel;
    switch(preferredEccLevel) {
        case L:
            max_cw = 2956;
            break;
        case M:
            max_cw = 2334;
            break;
        case Q:
            max_cw = 1666;
            break;
        case H:
            max_cw = 1276;
            break;
        default:
            max_cw = 2956;
            break;
    }
    if (est_binlen > (8 * max_cw)) {
        error_msg = "String_Node_Str";
        return false;
    }
    autosize = 40;
    for (i = 39; i >= 0; i--) {
        switch(ecc_level) {
            case L:
                if ((8 * qr_data_codewords_L[i]) >= est_binlen) {
                    autosize = i + 1;
                }
                break;
            case M:
                if ((8 * qr_data_codewords_M[i]) >= est_binlen) {
                    autosize = i + 1;
                }
                break;
            case Q:
                if ((8 * qr_data_codewords_Q[i]) >= est_binlen) {
                    autosize = i + 1;
                }
                break;
            case H:
                if ((8 * qr_data_codewords_H[i]) >= est_binlen) {
                    autosize = i + 1;
                }
                break;
        }
    }
    version = autosize;
    if ((preferredVersion >= 1) && (preferredVersion <= 40)) {
        if (preferredVersion > autosize) {
            version = preferredVersion;
        }
    }
    if (est_binlen <= qr_data_codewords_M[version - 1]) {
        ecc_level = EccMode.M;
    }
    if (est_binlen <= qr_data_codewords_Q[version - 1]) {
        ecc_level = EccMode.Q;
    }
    if (est_binlen <= qr_data_codewords_H[version - 1]) {
        ecc_level = EccMode.H;
    }
    target_binlen = qr_data_codewords_L[version - 1];
    blocks = qr_blocks_L[version - 1];
    switch(ecc_level) {
        case M:
            target_binlen = qr_data_codewords_M[version - 1];
            blocks = qr_blocks_M[version - 1];
            break;
        case Q:
            target_binlen = qr_data_codewords_Q[version - 1];
            blocks = qr_blocks_Q[version - 1];
            break;
        case H:
            target_binlen = qr_data_codewords_H[version - 1];
            blocks = qr_blocks_H[version - 1];
            break;
    }
    datastream = new int[target_binlen + 1];
    fullstream = new int[qr_total_codewords[version - 1] + 1];
    if (!(qr_binary(version, target_binlen, est_binlen))) {
        return false;
    }
    add_ecc(version, target_binlen, blocks);
    size = qr_sizes[version - 1];
    grid = new byte[size * size];
    encodeInfo += "String_Node_Str" + version + "String_Node_Str";
    encodeInfo += "String_Node_Str";
    switch(ecc_level) {
        case L:
            encodeInfo += "String_Node_Str";
            break;
        case M:
            encodeInfo += "String_Node_Str";
            break;
        case Q:
            encodeInfo += "String_Node_Str";
            break;
        case H:
        default:
            encodeInfo += "String_Node_Str";
            break;
    }
    for (i = 0; i < size; i++) {
        for (j = 0; j < size; j++) {
            grid[(i * size) + j] = 0;
        }
    }
    setup_grid(size, version);
    populate_grid(size, qr_total_codewords[version - 1]);
    bitmask = apply_bitmask(size);
    encodeInfo += "String_Node_Str" + Integer.toBinaryString(bitmask) + "String_Node_Str";
    add_format_info(size, ecc_level, bitmask);
    if (version >= 7) {
        add_version_info(size, version);
    }
    readable = "String_Node_Str";
    pattern = new String[size];
    row_count = size;
    row_height = new int[size];
    for (i = 0; i < size; i++) {
        bin = "String_Node_Str";
        for (j = 0; j < size; j++) {
            if ((grid[(i * size) + j] & 0x01) != 0) {
                bin += "String_Node_Str";
            } else {
                bin += "String_Node_Str";
            }
        }
        pattern[i] = bin2pat(bin);
        row_height[i] = 1;
    }
    plotSymbol();
    return true;
}

Output:
     int autosize;
-    int target_binlen, version, blocks;
+    int targetCwCount, version, blocks;
     int size;