Input:
public void testMultiLevelMemberConstraintWithNull() {
    String dimension = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    String cube = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    String query = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    String necjSql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    TestContext testContext = TestContext.create(dimension, cube, null, null, null);
    SqlPattern[] patterns = new SqlPattern[] { new SqlPattern(SqlPattern.getDialect(testContext.getDialect()), necjSql, necjSql) };
    assertQuerySql(testContext, query, patterns);
}

Output:
     String query = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
-    String necjSql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
+    String necjSqlDerby = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
     TestContext testContext = TestContext.create(dimension, cube, null, null, null);


Input:
public void run() {
    if (solutionRoot.getMainSolutionMetaData() == null) {
        selectAndOpenSolution();
    }
}

Output:
 public void run() {
-    if (solutionRoot.getMainSolutionMetaData() == null) {
+    if (!isSelectAndOpenSolutionStarted && solutionRoot.getMainSolutionMetaData() == null) {
         selectAndOpenSolution();


Input:
public void syncForDead(Address deadAddress) {
    Collection<Block> blocks = mapBlocks.values();
    for (Block block : blocks) {
        if (deadAddress.equals(block.owner)) {
            MemberImpl member = getNextMemberBeforeSync(block.owner, true, 1);
            block.owner = (member == null) ? thisAddress : member.getAddress();
        }
        if (block.migrationAddress != null) {
            if (deadAddress.equals(block.migrationAddress)) {
                MemberImpl member = getNextMemberBeforeSync(block.migrationAddress, true, 1);
                block.migrationAddress = (member == null) ? thisAddress : member.getAddress();
            }
        }
    }
    Collection<CMap> cmaps = maps.values();
    for (CMap map : cmaps) {
        Collection<Record> records = map.mapRecords.values();
        for (Record record : records) {
            record.onDisconnect(deadAddress);
        }
    }
    doResetRecords();
}

Output:
     }
-    doResetRecords();
+    doResetRecords(deadAddress);
 }


Input:
private void deleteServerFromLBConfig(String configName, String serverName) {
    LbConfig lbConfig = lbconfigs.getLbConfig(configName);
    ServerRef sRef = lbConfig.getRefByRef(ServerRef.class, serverName);
    if (sRef == null) {
        String msg = localStrings.getLocalString("String_Node_Str", "String_Node_Str", target);
        logger.finest("String_Node_Str" + serverName + "String_Node_Str");
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        report.setMessage(msg);
        return;
    }
    if (!Boolean.parseBoolean(force)) {
        if (Boolean.parseBoolean(sRef.getLbEnabled())) {
            String msg = localStrings.getLocalString("String_Node_Str", "String_Node_Str", serverName);
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            report.setMessage(msg);
            return;
        }
        Server s = domain.getServerNamed(serverName);
        if (s == null) {
            String msg = localStrings.getLocalString("String_Node_Str", "String_Node_Str", target);
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            report.setMessage(msg);
            return;
        }
        List<ApplicationRef> appRefs = domain.getApplicationRefsInTarget(target);
        if (appRefs == null || appRefs.size() == 0) {
            String msg = localStrings.getLocalString("String_Node_Str", "String_Node_Str", target);
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            report.setMessage(msg);
            return;
        }
        boolean appLbEnabled = false;
        for (ApplicationRef aRef : appRefs) {
            if (Boolean.parseBoolean(aRef.getLbEnabled())) {
                appLbEnabled = true;
                break;
            }
        }
        if (appLbEnabled) {
            String msg = localStrings.getLocalString("String_Node_Str", "String_Node_Str");
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            report.setMessage(msg);
            return;
        }
    }
    removeServerRef(lbConfig, sRef);
}

Output:
         List<ApplicationRef> appRefs = domain.getApplicationRefsInTarget(target);
-        if (appRefs == null || appRefs.size() == 0) {
+        if (appRefs == null || appRefs.isEmpty()) {
             String msg = localStrings.getLocalString("String_Node_Str", "String_Node_Str", target);


Input:
public void shouldNotAcceptNullElements() {
    lca.get(null, null, null);
}

Output:
 public void shouldNotAcceptNullElements() {
-    lca.get(null, null, null);
+    lca.getRecursive(null, null, null);
 }


Input:
private void refreshDynamicProperty() {
    if (this.dynamicProperty == null)
        return;
    dynamicProperty.refresh();
}

Output:
 private void refreshDynamicProperty() {
-    if (this.dynamicProperty == null)
+    if (this.dynamicProperty == null) {
         return;


Input:
public void validate(ValidationHandler handler) {
    if (!superTypes.isEmpty()) {
        List<TypeMetadata> thisSuperTypes = new LinkedList<TypeMetadata>(superTypes);
        for (TypeMetadata superType : thisSuperTypes) {
            if (isInstantiable() == superType.isInstantiable()) {
                if (superType instanceof ComplexTypeMetadata) {
                    Collection<FieldMetadata> thisTypeKeyFields = getKeyFields();
                    for (FieldMetadata thisTypeKeyField : thisTypeKeyFields) {
                        if (!((ComplexTypeMetadata) superType).hasField(thisTypeKeyField.getName())) {
                            handler.error(superType, "String_Node_Str" + name + "String_Node_Str" + "String_Node_Str" + superType.getName() + "String_Node_Str", superType.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), superType.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_CANNOT_OVERRIDE_SUPER_TYPE_KEY);
                        }
                    }
                }
            }
        }
    }
    for (FieldMetadata value : fieldMetadata.values()) {
        value.validate(handler);
    }
    for (FieldMetadata keyField : keyFields.values()) {
        if (keyField.isMany()) {
            handler.error(keyField, "String_Node_Str", keyField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), keyField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.FIELD_KEY_CANNOT_BE_REPEATABLE);
        }
    }
    for (FieldMetadata pkInfo : primaryKeyInfo) {
        if (!this.equals(pkInfo.getContainingType())) {
            handler.error(pkInfo, "String_Node_Str", pkInfo.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), pkInfo.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.PRIMARY_KEY_INFO_NOT_IN_ENTITY);
            continue;
        }
        int previousErrorCount = handler.getErrorCount();
        pkInfo.validate(handler);
        if (handler.getErrorCount() == previousErrorCount) {
            if (pkInfo.isMany()) {
                handler.error(pkInfo, "String_Node_Str", pkInfo.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), pkInfo.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.PRIMARY_KEY_INFO_CANNOT_BE_REPEATABLE);
                continue;
            }
            if (!isPrimitiveTypeField(pkInfo)) {
                handler.warning(pkInfo, "String_Node_Str", pkInfo.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), pkInfo.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.PRIMARY_KEY_INFO_TYPE_NOT_PRIMITIVE);
            }
        }
    }
    for (FieldMetadata lookupField : lookupFields) {
        int errorCount = handler.getErrorCount();
        lookupField.validate(handler);
        if (handler.getErrorCount() > errorCount) {
            continue;
        }
        if (!this.equals(lookupField.getContainingType())) {
            handler.error(lookupField, "String_Node_Str", lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_NOT_IN_ENTITY);
            continue;
        }
        if (lookupField.isKey()) {
            handler.error(lookupField, "String_Node_Str", lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_CANNOT_BE_KEY);
            continue;
        }
        lookupField.validate(handler);
        if (!isPrimitiveTypeField(lookupField)) {
            handler.error(lookupField, "String_Node_Str", lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_MUST_BE_SIMPLE_TYPE);
        }
    }
}

Output:
                         if (!((ComplexTypeMetadata) superType).hasField(thisTypeKeyField.getName())) {
-                            handler.error(superType, "String_Node_Str" + name + "String_Node_Str" + "String_Node_Str" + superType.getName() + "String_Node_Str", superType.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), superType.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_CANNOT_OVERRIDE_SUPER_TYPE_KEY);
+                            handler.error(superType, "String_Node_Str" + name + "String_Node_Str" + "String_Node_Str" + superType.getName() + "String_Node_Str", superType.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), superType.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), superType.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_CANNOT_OVERRIDE_SUPER_TYPE_KEY);
                         }


Input:
private String getContractAddressByTokenId(Transaction transaction) {
    String contractAddress = null;
    if (!transaction.getTokenId().equals(BigInteger.ZERO)) {
        Project project = projectService.getByTokenId(transaction.getTokenId());
        contractAddress = project.getContractAddress();
    }
    return contractAddress;
}

Output:
 private String getContractAddressByTokenId(Transaction transaction) {
-    String contractAddress = null;
-    if (!transaction.getTokenId().equals(BigInteger.ZERO)) {
-        Project project = projectService.getByTokenId(transaction.getTokenId());
-        contractAddress = project.getContractAddress();
-    }
-    return contractAddress;
+    return configService.getByTokenId(transaction.getTokenId()).getContractAddress();
 }


Input:
private Component toComponentConfig(ComponentConfig annotation, Class<?> clazz) throws Exception {
    Component config = new Component();
    if (annotation.id().length() > 0) {
        config.setId(annotation.id());
    }
    Class<?> type = annotation.type() == void.class ? clazz : annotation.type();
    config.setType(type.getName());
    if (annotation.template().length() > 0) {
        config.setTemplate(annotation.template());
    }
    if (annotation.lifecycle() != void.class) {
        config.setLifecycle(annotation.lifecycle().getName());
    }
    if (annotation.decorator().length() > 0) {
        config.setDecorator(annotation.decorator());
    }
    config.setInitParams(toInitParams(annotation.initParams()));
    EventConfig[] eventAnnotations = annotation.events();
    List<Event> events;
    if (eventAnnotations.length != 0) {
        events = new ArrayList<Event>();
        for (EventConfig eventAnnotation : eventAnnotations) {
            events.add(toEventConfig(eventAnnotation));
        }
    } else {
        events = Collections.emptyList();
    }
    config.setEvents(events);
    EventInterceptorConfig[] eventInterceptorAnnotations = annotation.eventInterceptors();
    List<EventInterceptor> eventInterceptors;
    if (eventInterceptorAnnotations.length != 0) {
        eventInterceptors = new ArrayList<EventInterceptor>();
        for (EventInterceptorConfig eventAnnotation : eventInterceptorAnnotations) {
            eventInterceptors.add(toEventInterceptorConfig(eventAnnotation));
        }
    } else {
        eventInterceptors = Collections.emptyList();
    }
    config.setEventInterceptors(eventInterceptors);
    ValidatorConfig[] validatorAnnotations = annotation.validators();
    List<Validator> validators;
    if (validatorAnnotations.length != 0) {
        validators = new ArrayList<Validator>();
        for (ValidatorConfig ele : validatorAnnotations) {
            validators.add(toValidator(ele));
        }
    } else {
        validators = Collections.emptyList();
    }
    config.setValidators(validators);
    return config;
}

Output:
     EventConfig[] eventAnnotations = annotation.events();
-    List<Event> events;
+    ArrayList<Event> events;
     if (eventAnnotations.length != 0) {


Input:
public List<Record> getResult() {
    while (!queue.isEmpty() && !callback.isInterrupted()) {
        Record currentRecord = queue.poll();
        matchOneRecord(callback, mergedRecords, queue, currentRecord);
    }
    callback.onEndProcessing();
    return this.mergedRecords;
}

Output:
         Record currentRecord = queue.poll();
-        matchOneRecord(callback, mergedRecords, queue, currentRecord);
+        execute(currentRecord, mergedRecords, queue, callback);
     }


Input:
public boolean hasReturnValue() {
    if (it == null) {
        return false;
    } else {
        return it.hasReturnValue();
    }
}

Output:
 public boolean hasReturnValue() {
-    if (it == null) {
+    if (definition) {
         return false;


Input:
public static DataSourceAndDataSet newInstance(IBaseDataSourceDesign dataSourceDesign, IBaseDataSetDesign dataSetDesign, Collection parameterBindings) {
    DataSourceAndDataSet dataSourceAndSet = new DataSourceAndDataSet();
    dataSourceAndSet.dataSourceDesign = dataSourceDesign;
    dataSourceAndSet.dataSetDesign = dataSetDesign;
    dataSourceAndSet.parameterBindings = parameterBindings;
    return dataSourceAndSet;
}

Output:
     dataSourceAndSet.dataSetDesign = dataSetDesign;
-    dataSourceAndSet.parameterBindings = parameterBindings;
+    dataSourceAndSet.paramterHints = paramterHints;
     return dataSourceAndSet;


Input:
private void collectAll() {
    DeviceData info = display.getDeviceData();
    if (!info.tracking) {
        MessageBox dialog = new MessageBox(shell, SWT.ICON_WARNING | SWT.OK);
        dialog.setText(shell.getText());
        dialog.setMessage("String_Node_Str");
        dialog.open();
    }
    newObjects = info.objects;
    newErrors = info.errors;
    Map<String, Integer> objectTypesTimes = new TreeMap<String, Integer>();
    Map<String, Object> objectSameStackTrace = new HashMap<String, Object>();
    final Map<Object, Integer> objectSameStackTraceTimes = new HashMap<Object, Integer>();
    Map<Object, Integer> objectSameStackTraceIDX = new HashMap<Object, Integer>();
    for (int i = 0; i < newObjects.length; i++) {
        String className = newObjects[i].getClass().getSimpleName();
        Integer count = objectTypesTimes.get(className);
        if (count == null) {
            objectTypesTimes.put(className, 1);
        } else {
            objectTypesTimes.put(className, count + 1);
        }
        String stackTrace = getStackTrace(newErrors[i]);
        if (!objectSameStackTrace.containsKey(stackTrace)) {
            objectSameStackTrace.put(stackTrace, newObjects[i]);
            objectSameStackTraceTimes.put(newObjects[i], 1);
            objectSameStackTraceIDX.put(newObjects[i], i);
        } else {
            Object object = objectSameStackTrace.get(stackTrace);
            objectSameStackTraceTimes.put(object, objectSameStackTraceTimes.get(object) + 1);
        }
    }
    equalObjects = new Object[objectSameStackTrace.size()];
    equalErrors = new Error[objectSameStackTrace.size()];
    int idx = 0;
    for (Entry<String, Object> entry : objectSameStackTrace.entrySet()) {
        equalObjects[idx++] = entry.getValue();
    }
    Arrays.sort(equalObjects, new Comparator<Object>() {

        public int compare(Object o1, Object o2) {
            return objectSameStackTraceTimes.get(o2) - objectSameStackTraceTimes.get(o1);
        }
    });
    for (int i = 0; i < equalErrors.length; i++) {
        equalErrors[i] = newErrors[objectSameStackTraceIDX.get(equalObjects[i])];
    }
    StringBuilder statistics = new StringBuilder();
    for (Entry<String, Integer> entry : objectTypesTimes.entrySet()) {
        statistics.append(entry.getKey());
        statistics.append("String_Node_Str");
        statistics.append(entry.getValue());
        statistics.append("String_Node_Str");
    }
    statistics.append("String_Node_Str");
    statistics.append(newObjects.length);
    statistics.append("String_Node_Str");
    listNewObjects.removeAll();
    for (int i = 0; i < newObjects.length; i++) {
        listNewObjects.add(newObjects[i].getClass().getSimpleName() + "String_Node_Str" + newObjects[i].hashCode() + "String_Node_Str");
    }
    listEqualObjects.removeAll();
    for (int i = 0; i < equalObjects.length; i++) {
        listEqualObjects.add(equalObjects[i].getClass().getSimpleName() + "String_Node_Str" + equalObjects[i].hashCode() + "String_Node_Str" + "String_Node_Str" + objectSameStackTraceTimes.get(equalObjects[i]) + "String_Node_Str");
    }
    objectStatistics.setText(statistics.toString());
}

Output:
     }
-    Arrays.sort(equalObjects, new Comparator<Object>() {
+    final IntComparator c = new IntComparator() {


Input:
public Server get(Key server) throws EntityNotFoundException {
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    return new Server(service.get(server));
}

Output:
     DatastoreService service = DatastoreServiceFactory.getDatastoreService();
-    return new Server(service.get(server));
+    try {
+        Entity entity = service.get(server);
+        if (entity != null)
+            return new Server(entity);
+    } catch (Exception e) {
+    }
+    return null;
 }


Input:
public void testGroupTree() throws Exception {
    NodeExecutionContext nec = HitchhikerMocks.nodeExecutionContext();
    TableExecutionContext tec = mock(TableExecutionContext.class);
    when(nec.tableContext(anyString(), anyString())).thenReturn(tec);
    when(tec.getCollectorExpression(any(ValueNode.class))).thenReturn(fakeExpression);
    SQLParseService parseService = new SQLParseService(nec);
    ParsedStatement stmt = parseService.parse("String_Node_Str");
    CacheRecycler cacheRecycler = new CacheRecycler(ImmutableSettings.EMPTY);
    GroupTree t1 = new GroupTree(1, stmt, cacheRecycler);
    GroupTree t2 = new GroupTree(1, stmt, cacheRecycler);
    GroupByRow row = t1.getRow();
    row = t1.getRow();
    BytesStreamOutput out = new BytesStreamOutput();
    t1.writeBucket(out, 0);
    BytesStreamInput in = new BytesStreamInput(out.bytes());
    t2.readBucket(in, 0);
    assertEquals(t2.maps().length, t2.maps().length);
    assertMapEquals(t1.maps()[0], t2.maps()[0]);
}

Output:
     ParsedStatement stmt = parseService.parse("String_Node_Str");
-    CacheRecycler cacheRecycler = new CacheRecycler(ImmutableSettings.EMPTY);
+    SQLMapperResultRequest requestSender = new SQLMapperResultRequest();
     GroupTree t1 = new GroupTree(1, stmt, cacheRecycler);


Input:
public void remove(Residence residence) {
    final ResidenceArea residenceArea = getDatabase().find(ResidenceArea.class).where().eq("String_Node_Str", residence.getId()).findUnique();
    final ResidenceSign residenceSign = getDatabase().find(ResidenceSign.class).where().eq("String_Node_Str", residence.getId()).findUnique();
    final HomePoint residenceHomes = getDatabase().find(HomePoint.class).where().eq("String_Node_Str", residence.getId()).findUnique();
    final List<ResidenceFlag> residenceFlags = getDatabase().find(ResidenceFlag.class).where().eq("String_Node_Str", residence.getId()).findList();
    final List<ResidenceMember> residenceMembers = getDatabase().find(ResidenceMember.class).where().eq("String_Node_Str", residence.getId()).findList();
    final List<Like> residenceLikes = getDatabase().find(Like.class).where().eq("String_Node_Str", residence.getId()).findList();
    World signWorld = Bukkit.getServer().getWorld(residenceSign.getWorld());
    final Sign sign = (Sign) signWorld.getBlockAt(residenceSign.getX(), residenceSign.getY(), residenceSign.getZ()).getState();
    getDatabase().delete(residence);
    getDatabase().delete(residenceArea);
    getDatabase().delete(residenceSign);
    getDatabase().delete(residenceHomes);
    getDatabase().delete(residenceMembers);
    getDatabase().delete(residenceFlags);
    getDatabase().delete(residenceLikes);
}

Output:
     final ResidenceSign residenceSign = getDatabase().find(ResidenceSign.class).where().eq("String_Node_Str", residence.getId()).findUnique();
-    final HomePoint residenceHomes = getDatabase().find(HomePoint.class).where().eq("String_Node_Str", residence.getId()).findUnique();
+    final List<HomePoint> residenceHomes = getDatabase().find(HomePoint.class).where().eq("String_Node_Str", residence.getId()).findList();
     final List<ResidenceFlag> residenceFlags = getDatabase().find(ResidenceFlag.class).where().eq("String_Node_Str", residence.getId()).findList();


Input:
public boolean isCompatible(PDGNodeMapping nodeMapping) {
    if (edgeG1.getClass() == edgeG2.getClass()) {
        if (edgeG1 instanceof PDGControlDependence) {
            return true;
        }
        if (edgeG1 instanceof PDGAbstractDataDependence) {
            AbstractVariable edgeG1Variable = ((PDGAbstractDataDependence) edgeG1).getData();
            AbstractVariable edgeG2Variable = ((PDGAbstractDataDependence) edgeG2).getData();
            CFGBranchNode edgeG1LoopNode = ((PDGAbstractDataDependence) edgeG1).getLoop();
            CFGBranchNode edgeG2LoopNode = ((PDGAbstractDataDependence) edgeG2).getLoop();
            if (equalData(edgeG1Variable, edgeG2Variable) || nodeMapping.matchingVariableDifference(edgeG1Variable, edgeG2Variable)) {
                if (edgeG1LoopNode == null && edgeG2LoopNode == null) {
                    return true;
                } else if (edgeG1LoopNode != null && edgeG2LoopNode != null) {
                    ASTNodeMatcher matcher = new ASTNodeMatcher(nodeMapping.getTypeRoot1(), nodeMapping.getTypeRoot2());
                    boolean nodeDiff = edgeG1LoopNode.getASTStatement().subtreeMatch(matcher, edgeG2LoopNode.getASTStatement());
                    return nodeDiff;
                }
            }
        }
    }
    return false;
}

Output:
                 } else if (edgeG1LoopNode != null && edgeG2LoopNode != null) {
-                    ASTNodeMatcher matcher = new ASTNodeMatcher(nodeMapping.getTypeRoot1(), nodeMapping.getTypeRoot2());
-                    boolean nodeDiff = edgeG1LoopNode.getASTStatement().subtreeMatch(matcher, edgeG2LoopNode.getASTStatement());
-                    return nodeDiff;
+                    ASTNodeMatcher astNodeMatcher = new ASTNodeMatcher(nodeMapping.getTypeRoot1(), nodeMapping.getTypeRoot2());
+                    boolean match = edgeG1LoopNode.getASTStatement().subtreeMatch(astNodeMatcher, edgeG2LoopNode.getASTStatement());
+                    return match && astNodeMatcher.isParameterizable();
                 }


Input:
public static IDBConnection createDBConnection(final Properties databaseProperties) throws DatabaseAnonymizerException {
    String database = databaseProperties.getProperty("String_Node_Str");
    if (database.equalsIgnoreCase("String_Node_Str")) {
        return new MySQLDBConnection();
    } else if (database.equalsIgnoreCase("String_Node_Str")) {
        return new MSSQLDBConnection();
    } else if (database.equalsIgnoreCase("String_Node_Str")) {
        return new OracleDBConnection();
    }
    throw new IllegalArgumentException("String_Node_Str" + database + "String_Node_Str");
}

Output:
 public static IDBConnection createDBConnection(final Properties databaseProperties) throws DatabaseAnonymizerException {
-    String database = databaseProperties.getProperty("String_Node_Str");
-    if (database.equalsIgnoreCase("String_Node_Str")) {
+    String vendor = databaseProperties.getProperty("String_Node_Str");
+    if (vendor.equalsIgnoreCase("String_Node_Str")) {
         return new MySQLDBConnection();


Input:
public void actionPerformed(ActionEvent event) {
    ProductSceneView sceneView = SnapApp.getDefault().getSelectedProductSceneView();
    if (sceneView != null) {
        Product product = sceneView.getProduct();
        if (product.isMultiSize()) {
            final Product resampledProduct = MultiSizeIssue0.maybeResample(product);
            if (resampledProduct != null) {
                product = resampledProduct;
            } else {
                return;
            }
        }
        exportMaskPixels(product);
    }
}

Output:
         if (product.isMultiSize()) {
-            final Product resampledProduct = MultiSizeIssue0.maybeResample(product);
+            final Product resampledProduct = _MultiSizeIssue.maybeResample(product);
             if (resampledProduct != null) {


Input:
public MediaResource handle(String relPath, HttpServletRequest request) {
    StringBuilder sb = new StringBuilder();
    sb.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(themeBaseUri).append("String_Node_Str").append("String_Node_Str").append(themeBaseUri).append("String_Node_Str").append("String_Node_Str");
    List<KalendarEventRenderWrapper> sortedEventsWithin = new ArrayList<KalendarEventRenderWrapper>();
    collectEvents(sortedEventsWithin, calendarWrappers);
    collectEvents(sortedEventsWithin, importedCalendarWrappers);
    Collections.sort(sortedEventsWithin, KalendarEventDateComparator.getInstance());
    renderEvents(sb, sortedEventsWithin, from, to);
    renderCalendars(sb);
    sb.append("String_Node_Str");
    StringMediaResource smr = new StringMediaResource();
    smr.setContentType("String_Node_Str");
    smr.setEncoding("String_Node_Str");
    smr.setData(sb.toString());
    return smr;
}

Output:
     StringBuilder sb = new StringBuilder();
-    sb.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(themeBaseUri).append("String_Node_Str").append("String_Node_Str").append(themeBaseUri).append("String_Node_Str").append("String_Node_Str");
+    sb.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(themeBaseUri).append("String_Node_Str").append("String_Node_Str").append(themeBaseUri).append("String_Node_Str").append("String_Node_Str");
     List<KalendarEventRenderWrapper> sortedEventsWithin = new ArrayList<KalendarEventRenderWrapper>();


Input:
private <T> boolean processAnnotatedMethod(AnnotatedMethod<T> method, boolean classHasEncodedAnnotation, Map<AnnotatedParameter<T>, PatchInformation> parameterToPatchInfoMap, Set<AnnotatedMethod<T>> setterMethodsWithoutInject) {
    boolean mustPatch = false;
    if (method.getAnnotation(Inject.class) != null) {
        boolean methodHasEncodedAnnotation = method.isAnnotationPresent(Encoded.class);
        for (AnnotatedParameter<T> parameter : method.getParameters()) {
            for (Annotation annotation : parameter.getAnnotations()) {
                Set<DiscoveredParameter> discovered = discoveredParameterMap.get(annotation.annotationType());
                if (discovered != null) {
                    if (knownParameterQualifiers.contains(annotation.annotationType())) {
                        if (methodHasEncodedAnnotation || classHasEncodedAnnotation || parameter.isAnnotationPresent(DefaultValue.class)) {
                            mustPatch = true;
                        }
                        boolean encoded = parameter.isAnnotationPresent(Encoded.class) || methodHasEncodedAnnotation || classHasEncodedAnnotation;
                        DefaultValue defaultValue = parameter.getAnnotation(DefaultValue.class);
                        if (defaultValue != null) {
                            mustPatch = true;
                        }
                        DiscoveredParameter jerseyParameter = new DiscoveredParameter(annotation, parameter.getBaseType(), defaultValue, encoded);
                        discovered.add(jerseyParameter);
                        LOGGER.fine("String_Node_Str" + jerseyParameter);
                        parameterToPatchInfoMap.put(parameter, new PatchInformation(jerseyParameter, getSyntheticQualifierFor(jerseyParameter), false));
                    }
                }
            }
        }
    } else {
        if (isSetterMethod(method)) {
            boolean methodHasEncodedAnnotation = method.isAnnotationPresent(Encoded.class);
            for (Annotation annotation : method.getAnnotations()) {
                Set<DiscoveredParameter> discovered = discoveredParameterMap.get(annotation.annotationType());
                if (discovered != null) {
                    if (knownParameterQualifiers.contains(annotation.annotationType())) {
                        mustPatch = true;
                        setterMethodsWithoutInject.add(method);
                        for (AnnotatedParameter<T> parameter : method.getParameters()) {
                            boolean encoded = parameter.isAnnotationPresent(Encoded.class) || methodHasEncodedAnnotation || classHasEncodedAnnotation;
                            DefaultValue defaultValue = parameter.getAnnotation(DefaultValue.class);
                            if (defaultValue == null) {
                                defaultValue = method.getAnnotation(DefaultValue.class);
                            }
                            DiscoveredParameter jerseyParameter = new DiscoveredParameter(annotation, parameter.getBaseType(), defaultValue, encoded);
                            discovered.add(jerseyParameter);
                            LOGGER.fine("String_Node_Str" + jerseyParameter);
                            SyntheticQualifier syntheticQualifier = getSyntheticQualifierFor(jerseyParameter);
                            Annotation addedAnnotation = syntheticQualifier == null ? annotation : null;
                            parameterToPatchInfoMap.put(parameter, new PatchInformation(jerseyParameter, syntheticQualifier, addedAnnotation, false));
                        }
                        break;
                    }
                }
            }
        }
    }
    return mustPatch;
}

Output:
         boolean methodHasEncodedAnnotation = method.isAnnotationPresent(Encoded.class);
-        for (AnnotatedParameter<T> parameter : method.getParameters()) {
+        for (AnnotatedParameter<? super T> parameter : method.getParameters()) {
             for (Annotation annotation : parameter.getAnnotations()) {


Input:
public String toString() {
    return "String_Node_Str" + emailId + "String_Node_Str" + address + "String_Node_Str" + country + "String_Node_Str" + state + "String_Node_Str" + zipcode + "String_Node_Str" + contactNumber + "String_Node_Str" + fax + "String_Node_Str" + helpText + "String_Node_Str" + type + "String_Node_Str" + validFrom + "String_Node_Str" + validUpto + "String_Node_Str" + repoURL + "String_Node_Str" + status + "String_Node_Str" + id + "String_Node_Str" + name + "String_Node_Str" + description + "String_Node_Str" + creationDate + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + emailId + "String_Node_Str" + address + "String_Node_Str" + country + "String_Node_Str" + state + "String_Node_Str" + zipcode + "String_Node_Str" + contactNumber + "String_Node_Str" + fax + "String_Node_Str" + helpText + "String_Node_Str" + type + "String_Node_Str" + validFrom + "String_Node_Str" + validUpto + "String_Node_Str" + repoURL + "String_Node_Str" + status + "String_Node_Str" + id + "String_Node_Str" + name + "String_Node_Str" + description + "String_Node_Str" + creationDate + "String_Node_Str";
+    return new ToStringBuilder(this, ToStringStyle.DEFAULT_STYLE).append(super.toString()).append("String_Node_Str", emailId).append("String_Node_Str", address).append("String_Node_Str", country).append("String_Node_Str", state).append("String_Node_Str", zipcode).append("String_Node_Str", contactNumber).append("String_Node_Str", fax).append("String_Node_Str", helpText).append("String_Node_Str", validFrom).append("String_Node_Str", validUpto).append("String_Node_Str", repoURL).append("String_Node_Str", status).append("String_Node_Str", type).toString();
 }


Input:
public void startPage(float pageWidth, float pageHeight, String orientation) {
    this.orientation = orientation;
    this.pageHeight = pageHeight;
    out.println("String_Node_Str" + pageIndex + "String_Node_Str" + pageIndex);
    boolean isLandscape = orientation != null && orientation.equalsIgnoreCase("String_Node_Str");
    if (autoPaperSizeSelection) {
        if (isLandscape) {
            setPaperSize("String_Node_Str", (int) pageHeight, (int) pageWidth);
        } else {
            setPaperSize("String_Node_Str", (int) pageWidth, (int) pageHeight);
        }
        setPaperTray(AUTO_PAPER_TRAY_STRING);
    }
    out.println("String_Node_Str" + (int) Math.round(pageWidth) + "String_Node_Str" + (int) Math.round(pageHeight));
    out.println("String_Node_Str");
    if (fitToPaper && paperWidth != 0 && paperHeight != 0) {
        int height = isLandscape ? (int) pageWidth : (int) pageHeight;
        int width = isLandscape ? (int) pageHeight : (int) pageWidth;
        out.println(paperWidth + "String_Node_Str" + width + "String_Node_Str" + paperHeight + "String_Node_Str" + height + "String_Node_Str");
    }
    if (isLandscape) {
        gSave();
        out.println("String_Node_Str");
        out.println("String_Node_Str");
        out.print("String_Node_Str");
        out.println(pageHeight + "String_Node_Str");
    }
    setScale((int) pageHeight, scale);
    ++pageIndex;
}

Output:
     out.println("String_Node_Str" + pageIndex + "String_Node_Str" + pageIndex);
-    boolean isLandscape = orientation != null && orientation.equalsIgnoreCase("String_Node_Str");
-    if (autoPaperSizeSelection) {
+    if (autoPaperSizeSelection && (!isDuplex || paperChanged)) {
         if (isLandscape) {


Input:
public ClassMeta extract(String sourceCodeString) {
    ClassMeta meta = new ClassMeta();
    String modifiedSourceCodeString = TrimFilterUtil.doAllFilters(sourceCodeString);
    Matcher matcherGroupingPackageName = RegExp.PatternObject.Pacakge_Group.matcher(modifiedSourceCodeString);
    if (matcherGroupingPackageName.find()) {
        meta.packageName = matcherGroupingPackageName.group(1);
    }
    String outOfBrace = modifiedSourceCodeString.split("String_Node_Str")[0];
    String[] splittedBySpace = outOfBrace.replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str").split("String_Node_Str");
    if (!outOfBrace.matches("String_Node_Str") && !outOfBrace.matches("String_Node_Str")) {
        meta.isAbstract = true;
    } else {
        for (String each : splittedBySpace) {
            if (each.equals("String_Node_Str") || each.equals("String_Node_Str") || each.equals("String_Node_Str")) {
                meta.isAbstract = true;
                break;
            }
        }
        if (outOfBrace.matches("String_Node_Str")) {
            meta.isEnum = true;
        }
    }
    meta.name = splittedBySpace[splittedBySpace.length - 1].replaceFirst(RegExp.Generics, StringValue.Empty);
    for (int i = 0; i < splittedBySpace.length; i++) {
        if (splittedBySpace[i].equals("String_Node_Str") || splittedBySpace[i].equals("String_Node_Str")) {
            meta.name = splittedBySpace[i - 1].replaceFirst(RegExp.Generics, StringValue.Empty);
            break;
        }
    }
    meta.importedList = importedListExtractor.extract(modifiedSourceCodeString);
    meta.constructors = constructorMetaExtractor.initialize(meta, modifiedSourceCodeString).extract(modifiedSourceCodeString);
    meta.methods = methodMetaExtractor.initialize(meta, modifiedSourceCodeString).extract(modifiedSourceCodeString);
    if (meta.constructors.size() > 0) {
        for (ConstructorMeta cons : meta.constructors) {
            int len = cons.argNames.size();
            for (int i = 0; i < len; i++) {
                if (isDuplicatedVariableName(cons.argNames.get(i))) {
                    cons.argNames.set(i, cons.argNames.get(i) + "String_Node_Str");
                }
            }
        }
        ConstructorMeta constructor = meta.constructors.get(0);
        for (MethodMeta method : meta.methods) {
            int len = method.argNames.size();
            for (int i = 0; i < len; i++) {
                String targetArgName = method.argNames.get(i);
                List<String> methodArgNames = new ArrayList<String>();
                for (String methodArgName : method.argNames) {
                    if (!targetArgName.equals(methodArgName)) {
                        methodArgNames.add(methodArgName);
                    }
                }
                method.argNames.set(i, renameIfDuplicatedToConstructorArgNames(targetArgName, constructor.argNames, methodArgNames));
            }
        }
    }
    return meta;
}

Output:
     String outOfBrace = modifiedSourceCodeString.split("String_Node_Str")[0];
-    String[] splittedBySpace = outOfBrace.replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str").split("String_Node_Str");
+    int lenForOutOfBrace = outOfBrace.length();
+    StringBuilder bufForOutOfBrace = new StringBuilder();
+    boolean isInsideOfGenerics = false;
+    int depth = 0;
+    for (int i = 0; i < lenForOutOfBrace; i++) {
+        char current = outOfBrace.charAt(i);
+        if (current == '<') {
+            isInsideOfGenerics = true;
+            depth++;
+        }
+        if (current == '>') {
+            depth--;
+            if (depth <= 0) {
+                isInsideOfGenerics = false;
+                continue;
+            }
+        }
+        if (!isInsideOfGenerics) {
+            bufForOutOfBrace.append(current);
+        }
+    }
+    String outOfBraceWithoutGenerics = bufForOutOfBrace.toString();
+    String[] splittedBySpace = outOfBraceWithoutGenerics.split("String_Node_Str");
     if (!outOfBrace.matches("String_Node_Str") && !outOfBrace.matches("String_Node_Str")) {


Input:
public static void main(String[] args) {
    int startIndex = Integer.valueOf(args[0]);
    int stepSize = Integer.valueOf(args[1]);
    BufferedReader reader_erpnext = new BufferedReader(new InputStreamReader(Runner.class.getResourceAsStream("String_Node_Str")));
    Stream<String> erpnext = reader_erpnext.lines();
    BufferedReader reader_espocrm = new BufferedReader(new InputStreamReader(Runner.class.getResourceAsStream("String_Node_Str")));
    Stream<String> espocrm = reader_espocrm.lines();
    BufferedReader reader_suitecrm = new BufferedReader(new InputStreamReader(Runner.class.getResourceAsStream("String_Node_Str")));
    Stream<String> suitecrm = reader_suitecrm.lines();
    try {
        reader_erpnext.close();
        reader_espocrm.close();
        reader_suitecrm.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    QueryReader queryReader = new QueryReader();
    List<String> allQueries = queryReader.readQueries(erpnext, espocrm, suitecrm);
    ConnectionData connectionDataProd = CONNECTION_DATA_ERPNEXT_PROD;
    ConnectionData connectionDataTest = CONNECTION_DATA_ERPNEXT_TEST;
    for (int i = startIndex; i < allQueries.size(); i += stepSize) {
        if (i >= AMOUNT_QUERIES_ERPNEXT && i < AMOUNT_QUERIES_ERPNEXT + AMOUNT_QUERIES_ESPOCRM) {
            connectionDataProd = CONNECTION_DATA_ESPOCRM_PROD;
            connectionDataTest = CONNECTION_DATA_ESPOCRM_TEST;
        } else if (i >= AMOUNT_QUERIES_ERPNEXT + AMOUNT_QUERIES_ESPOCRM) {
            connectionDataProd = CONNECTION_DATA_SUITECRM_PROD;
            connectionDataTest = CONNECTION_DATA_SUITECRM_TEST;
        }
        runForQuery(allQueries.get(i), connectionDataProd, connectionDataTest, String.valueOf(i));
    }
}

Output:
     int stepSize = Integer.valueOf(args[1]);
-    BufferedReader reader_erpnext = new BufferedReader(new InputStreamReader(Runner.class.getResourceAsStream("String_Node_Str")));
+    BufferedReader reader_erpnext = new BufferedReader(new InputStreamReader(Runner.class.getClassLoader().getResourceAsStream("String_Node_Str")));
     Stream<String> erpnext = reader_erpnext.lines();


Input:
protected void addValueSeriesAggregateBindingForGrouping(BaseQueryDefinition query, EList<SeriesDefinition> seriesDefinitions, GroupDefinition innerMostGroupDef, Map<String, String[]> valueExprMap, SeriesDefinition baseSD) throws ChartException {
    for (SeriesDefinition orthSD : seriesDefinitions) {
        Series series = orthSD.getDesignTimeSeries();
        List<Query> qlist = ChartEngine.instance().getDataSetProcessor(series.getClass()).getDataDefinitionsForGrouping(series);
        for (Query qry : series.getDataDefinition()) {
            String expr = qry.getDefinition();
            if (expr == null || "String_Node_Str".equals(expr)) {
                continue;
            }
            String aggName = ChartUtil.getAggregateFuncExpr(orthSD, baseSD, qry);
            if (aggName == null) {
                if (!bCreateBindingForExpression || ChartExpressionUtil.isRowBinding(expr, false)) {
                    continue;
                }
            }
            String name = ChartUtil.generateBindingNameOfValueSeries(qry, orthSD, baseSD);
            if (fNameSet.contains(name)) {
                continue;
            }
            fNameSet.add(name);
            Binding colBinding = new Binding(name);
            colBinding.setDataType(org.eclipse.birt.core.data.DataType.ANY_TYPE);
            if (qlist.contains(qry)) {
                try {
                    colBinding.setExportable(false);
                    if (aggName != null) {
                        setBindingExpressionDueToAggregation(colBinding, expr, aggName);
                        if (innerMostGroupDef != null) {
                            colBinding.addAggregateOn(innerMostGroupDef.getName());
                        }
                        colBinding.setAggrFunction(ChartReportItemUtil.convertToDtEAggFunction(aggName));
                        IAggregateFunction aFunc = PluginSettings.instance().getAggregateFunction(aggName);
                        if (aFunc.getParametersCount() > 0) {
                            String[] parameters = ChartUtil.getAggFunParameters(orthSD, baseSD, qry);
                            for (int i = 0; i < parameters.length && i < aFunc.getParametersCount(); i++) {
                                String param = parameters[i];
                                colBinding.addArgument(new ScriptExpression(param));
                            }
                        }
                    } else {
                        exprCodec.decode(expr);
                        colBinding.setExpression(ChartReportItemUtil.adaptExpression(exprCodec, modelAdapter, false));
                    }
                } catch (DataException e1) {
                    throw new ChartException(ChartReportItemPlugin.ID, ChartException.DATA_BINDING, e1);
                }
            } else {
                colBinding.setExpression(new ScriptExpression(expr));
            }
            String newExpr = getExpressionForEvaluator(name);
            try {
                query.addBinding(colBinding);
            } catch (DataException e) {
                throw new ChartException(ChartReportItemPlugin.ID, ChartException.DATA_BINDING, e);
            }
            valueExprMap.put(expr, new String[] { name, newExpr });
        }
    }
}

Output:
             if (aggName == null) {
-                if (!bCreateBindingForExpression || ChartExpressionUtil.isRowBinding(expr, false)) {
+                if (!bCreateBindingForExpression || exprCodec.isRowBinding(expr, false)) {
                     continue;


Input:
public ItemStack transferStackInSlot(EntityPlayer player, int slot) {
    ItemStack stack = ItemStackUtil.getEmptyStack();
    net.minecraft.inventory.Slot slotObject = inventorySlots.get(slot);
    ItemStack stackInSlot;
    if (slotObject != null && !ItemStackUtil.isEmpty(stackInSlot = slotObject.getStack())) {
        stack = stackInSlot.copy();
        if (slot < tile.getSlots().length) {
            if (!this.mergeItemStack(stackInSlot, tile.getSlots().length, tile.getSlots().length + 36, true)) {
                return null;
            }
        } else if (!this.mergeItemStack(stackInSlot, 0, tile.getSlots().length, false)) {
            return null;
        }
        if (ItemStackUtil.getCount(stack) == 0) {
            slotObject.putStack(ItemStackUtil.getEmptyStack());
        } else {
            slotObject.onSlotChanged();
        }
        if (ItemStackUtil.getCount(stackInSlot) == ItemStackUtil.getCount(stack)) {
            return ItemStackUtil.getEmptyStack();
        }
        slotObject.onTake(player, stackInSlot);
    }
    return stack;
}

Output:
             if (!this.mergeItemStack(stackInSlot, tile.getSlots().length, tile.getSlots().length + 36, true)) {
-                return null;
+                return ItemStackUtil.getEmptyStack();
             }


Input:
public void widgetSelected(SelectionEvent e) {
    if (e.getSource().equals(btnAddLine)) {
        MarkerLine line = MarkerLineImpl.create(getAxisForProcessing(), createDefaultDataElement(), ColorDefinitionImpl.RED());
        line.eAdapters().addAll(getAxisForProcessing().eAdapters());
        iLineCount++;
        buildList();
        lstMarkers.select(lstMarkers.getItemCount() - 1);
        updateUIForSelection();
        if (lstMarkers.getItemCount() == 1) {
            setState(true);
        }
        refreshButtons();
    } else if (e.getSource().equals(btnAddRange)) {
        MarkerRange range = MarkerRangeImpl.create(getAxisForProcessing(), createDefaultDataElement(), createDefaultDataElement(), ColorDefinitionImpl.TRANSPARENT(), ColorDefinitionImpl.RED());
        range.eAdapters().addAll(getAxisForProcessing().eAdapters());
        iRangeCount++;
        buildList();
        lstMarkers.select(lstMarkers.getItemCount() - 1);
        updateUIForSelection();
        if (lstMarkers.getItemCount() == 1) {
            setState(true);
        }
        refreshButtons();
    } else if (e.getSource().equals(btnRemove)) {
        if (lstMarkers.getSelection().length == 0) {
            return;
        }
        String sSelectedMarker = lstMarkers.getSelection()[0];
        boolean bLine = sSelectedMarker.startsWith(MARKER_LINE_LABEL);
        int iMarkerIndex = getMarkerIndex();
        if (bLine) {
            getAxisForProcessing().getMarkerLines().remove(iMarkerIndex);
            iLineCount--;
        } else {
            getAxisForProcessing().getMarkerRanges().remove(iMarkerIndex);
            iRangeCount--;
        }
        buildList();
        if (lstMarkers.getItemCount() > 0) {
            lstMarkers.select(0);
            updateUIForSelection();
        } else {
            setState(false);
            resetUI();
        }
        refreshButtons();
    } else if (e.getSource().equals(lstMarkers)) {
        updateUIForSelection();
        refreshButtons();
    } else if (e.getSource().equals(cmbLineAnchor)) {
        getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).setLabelAnchor(ChartUIUtil.getFlippedAnchor(Anchor.getByName(LiteralHelper.anchorSet.getNameByDisplayName(cmbLineAnchor.getText())), isFlippedAxes()));
    } else if (e.getSource().equals(cmbRangeAnchor)) {
        getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()).setLabelAnchor(ChartUIUtil.getFlippedAnchor(Anchor.getByName(LiteralHelper.anchorSet.getNameByDisplayName(cmbRangeAnchor.getText())), isFlippedAxes()));
    } else if (e.getSource().equals(btnLineFormatSpecifier)) {
        String sAxisTitle = "String_Node_Str";
        try {
            sAxisTitle = new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { getAxisForProcessing().getTitle().getCaption().getValue() });
        } catch (NullPointerException e1) {
        }
        FormatSpecifier formatspecifier = null;
        if (getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).getFormatSpecifier() != null) {
            formatspecifier = getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).getFormatSpecifier();
        }
        FormatSpecifierDialog editor = new FormatSpecifierDialog(cmpContent.getShell(), formatspecifier, getAxisForProcessing().getType(), new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { Integer.valueOf(getMarkerIndex() + 1), sAxisTitle }));
        if (editor.open() == Window.OK) {
            if (editor.getFormatSpecifier() == null) {
                getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).eUnset(ComponentPackage.eINSTANCE.getMarkerLine_FormatSpecifier());
                return;
            }
            getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).setFormatSpecifier(editor.getFormatSpecifier());
        }
    } else if (e.getSource().equals(btnStartFormatSpecifier) || e.getSource().equals(btnEndFormatSpecifier)) {
        String sAxisTitle = "String_Node_Str";
        try {
            String sTitleString = getAxisForProcessing().getTitle().getCaption().getValue();
            int iSeparatorIndex = sTitleString.indexOf(ExternalizedTextEditorComposite.SEPARATOR);
            if (iSeparatorIndex > 0) {
                sTitleString = sTitleString.substring(iSeparatorIndex);
            } else if (iSeparatorIndex == 0) {
                sTitleString = sTitleString.substring(ExternalizedTextEditorComposite.SEPARATOR.length());
            }
            sAxisTitle = new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { sTitleString });
        } catch (NullPointerException e1) {
        }
        FormatSpecifier formatspecifier = null;
        if (getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()).getFormatSpecifier() != null) {
            formatspecifier = getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()).getFormatSpecifier();
        }
        FormatSpecifierDialog editor = new FormatSpecifierDialog(cmpContent.getShell(), formatspecifier, getAxisForProcessing().getType(), new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { Integer.valueOf(getMarkerIndex() + 1), sAxisTitle }));
        if (editor.open() == Window.OK) {
            if (editor.getFormatSpecifier() == null) {
                getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()).eUnset(ComponentPackage.eINSTANCE.getMarkerRange_FormatSpecifier());
                return;
            }
            getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()).setFormatSpecifier(editor.getFormatSpecifier());
        }
    } else if (e.widget.equals(btnLineTriggers)) {
        new TriggerEditorDialog(cmpContent.getShell(), getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).getTriggers(), getAxisForProcessing().getMarkerLines().get(getMarkerIndex()), getContext(), Messages.getString("String_Node_Str"), TriggerSupportMatrix.TYPE_MARKERLINE, false, true).open();
    } else if (e.widget.equals(btnRangeTriggers)) {
        new TriggerEditorDialog(cmpContent.getShell(), getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()).getTriggers(), getAxisForProcessing().getMarkerRanges().get(getMarkerIndex()), getContext(), Messages.getString("String_Node_Str"), TriggerSupportMatrix.TYPE_MARKERRANGE, false, true).open();
    }
}

Output:
         }
-        FormatSpecifierDialog editor = new FormatSpecifierDialog(cmpContent.getShell(), formatspecifier, getAxisForProcessing().getType(), new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { Integer.valueOf(getMarkerIndex() + 1), sAxisTitle }));
+        FormatSpecifierDialog editor = new FormatSpecifierDialog(cmpContent.getShell(), formatspecifier, getDataElementType(getAxisForProcessing().getMarkerLines().get(getMarkerIndex()).getValue()), new MessageFormat(Messages.getString("String_Node_Str")).format(new Object[] { Integer.valueOf(getMarkerIndex() + 1), sAxisTitle }));
         if (editor.open() == Window.OK) {


Input:
public void setMaximumInformationLoss(final InformationLoss<?> a) {
    node.maxInformationLoss = InformationLoss.createInformationLoss(a, metric);
}

Output:
 public void setMaximumInformationLoss(final InformationLoss<?> a) {
-    node.maxInformationLoss = InformationLoss.createInformationLoss(a, metric);
+    node.maxInformationLoss = InformationLoss.createInformationLoss(a, metric, DESERIALIZATION_CONTEXT_MIN_LEVEL, DESERIALIZATION_CONTEXT_MAX_LEVEL);
 }


Input:
private static <K, V> void assertSameEntries(List<ReferenceEntry<K, V>> expectedEntries, List<ReferenceEntry<K, V>> actualEntries) {
    int size = expectedEntries.size();
    assertEquals(size, actualEntries.size());
    for (int i = 0; i < size; i++) {
        ReferenceEntry<K, V> expectedEntry = expectedEntries.get(0);
        ReferenceEntry<K, V> actualEntry = actualEntries.get(0);
        assertSame(expectedEntry.getKey(), actualEntry.getKey());
        assertSame(expectedEntry.getValueReference().get(), actualEntry.getValueReference().get());
    }
}

Output:
     for (int i = 0; i < size; i++) {
-        ReferenceEntry<K, V> expectedEntry = expectedEntries.get(0);
-        ReferenceEntry<K, V> actualEntry = actualEntries.get(0);
+        ReferenceEntry<K, V> expectedEntry = expectedEntries.get(i);
+        ReferenceEntry<K, V> actualEntry = actualEntries.get(i);
         assertSame(expectedEntry.getKey(), actualEntry.getKey());


Input:
public Map<String, String> getIPAddresses() {
    Map<String, String> idToIpAddressMap = new HashMap<>();
    for (Id id : ids()) {
        Conf conf = repo.conf(id);
        if (conf.isExposeContainerIp()) {
            String containerName = repo.containerName(id);
            InspectContainerResponse containerInspectResponse = docker.inspectContainerCmd(containerName).exec();
            idToIpAddressMap.put(id.toString(), containerInspectResponse.getNetworkSettings().getIpAddress());
        }
    }
    return idToIpAddressMap;
}

Output:
         Conf conf = repo.conf(id);
-        if (conf.isExposeContainerIp()) {
+        if (inclusive(id) && conf.isExposeContainerIp()) {
             String containerName = repo.containerName(id);


Input:
public void viewAction() {
    IndexedPreservationEvent event = bundle.getEvent();
    eventIdValue.setText(event.getId());
    eventTypeLabel.setText(event.getEventType());
    eventDetailLabel.setText(event.getEventDetail());
    eventDatetimeLabel.setText(DateTimeFormat.getFormat(RodaConstants.DEFAULT_DATETIME_FORMAT).format(event.getEventDateTime()));
    Map<String, IndexedPreservationAgent> agents = bundle.getAgents();
    boolean hasAgents = false;
    for (LinkingIdentifier agentId : event.getLinkingAgentIds()) {
        IndexedPreservationAgent agent = agents.get(agentId.getValue());
        if (agent != null) {
            FlowPanel layout = createAgentPanel(agentId, agent);
            agentsPanel.add(layout);
            hasAgents = true;
        }
    }
    agentsHeader.setVisible(hasAgents);
    boolean showSourceObjects = false;
    for (LinkingIdentifier sourceObjectId : event.getSourcesObjectIds()) {
        if (sourceObjectId.getRoles() != null && sourceObjectId.getRoles().contains(RodaConstants.PRESERVATION_LINKING_OBJECT_SOURCE)) {
            addObjectPanel(sourceObjectId, bundle, sourceObjectsPanel);
            showSourceObjects = true;
        }
    }
    sourceObjectsHeader.setVisible(showSourceObjects);
    sourceObjectsPanel.setVisible(showSourceObjects);
    boolean showOutcomeObjects = false;
    for (LinkingIdentifier outcomeObjectId : event.getOutcomeObjectIds()) {
        if (outcomeObjectId.getRoles() != null && outcomeObjectId.getRoles().contains(RodaConstants.PRESERVATION_LINKING_OBJECT_OUTCOME)) {
            addObjectPanel(outcomeObjectId, bundle, outcomeObjectsPanel);
            showOutcomeObjects = true;
        }
    }
    outcomeObjectsHeader.setVisible(showOutcomeObjects);
    outcomeObjectsPanel.setVisible(showOutcomeObjects);
    PluginState eventOutcome = PluginState.valueOf(event.getEventOutcome());
    eventOutcomeLabel.setText(messages.pluginStateMessage(eventOutcome));
    if (PluginState.SUCCESS.equals(eventOutcome)) {
        eventOutcomeLabel.setStyleName("String_Node_Str");
    } else if (PluginState.FAILURE.equals(eventOutcome)) {
        eventOutcomeLabel.setStyleName("String_Node_Str");
    } else if (PluginState.PARTIAL_SUCCESS.equals(eventOutcome)) {
        eventOutcomeLabel.setStyleName("String_Node_Str");
    }
    getEventDetailsHTML(new AsyncCallback<SafeHtml>() {
        public void onFailure(Throwable caught) {
            if (!AsyncCallbackUtils.treatCommonFailures(caught)) {
                Toast.showError(messages.errorLoadingPreservationEventDetails(caught.getMessage()));
            }
        }
        public void onSuccess(SafeHtml result) {
            eventOutcomeDetails.setHTML(result);
            outcomeDetailHeader.setVisible(result.asString().length() > 0);
        }
    });
}

Output:
     eventDetailLabel.setText(event.getEventDetail());
-    eventDatetimeLabel.setText(DateTimeFormat.getFormat(RodaConstants.DEFAULT_DATETIME_FORMAT).format(event.getEventDateTime()));
+    eventDatetimeLabel.setText(Humanize.formatDateTime(event.getEventDateTime()));
     Map<String, IndexedPreservationAgent> agents = bundle.getAgents();


Input:
private void addDir(SessionContext context, AddParams args) throws SVNException, IOException {
    final EntryUpdater parent = getParent(args.parentToken);
    final VcsFile source;
    if (args.copyParams.copyFrom != null) {
        log.info("String_Node_Str", args.name, args.copyParams.copyFrom, args.copyParams.rev);
        source = context.getFile(args.copyParams.rev, args.copyParams.copyFrom);
        if (source == null) {
            throw new SVNException(SVNErrorMessage.create(SVNErrorCode.ENTRY_NOT_FOUND, "String_Node_Str" + args.copyParams.copyFrom + "String_Node_Str" + args.copyParams.rev));
        }
    } else {
        log.info("String_Node_Str", args.name);
        source = null;
    }
    final EntryUpdater updater = new EntryUpdater(parent.entry, false);
    paths.put(args.token, updater);
    parent.changes.add(treeBuilder -> {
        treeBuilder.addDir(StringHelper.baseName(args.name), source);
        updateDir(treeBuilder, updater);
        treeBuilder.checkDirProperties(updater.props);
        treeBuilder.closeDir();
    });
}

Output:
     }
-    final EntryUpdater updater = new EntryUpdater(parent.entry, false);
+    final EntryUpdater updater = new EntryUpdater(parent.entry, source, false);
     paths.put(args.token, updater);


Input:
public final void read() {
    PropagationTaskTO taskTO = restTemplate.getForObject(BASE_URL + "String_Node_Str", PropagationTaskTO.class, 1);
    assertNotNull(taskTO);
    assertNotNull(taskTO.getExecutions());
    assertFalse(taskTO.getExecutions().isEmpty());
}

Output:
 public final void read() {
-    PropagationTaskTO taskTO = restTemplate.getForObject(BASE_URL + "String_Node_Str", PropagationTaskTO.class, 1);
+    PropagationTaskTO taskTO = restTemplate.getForObject(BASE_URL + "String_Node_Str", PropagationTaskTO.class, 3);
     assertNotNull(taskTO);


Input:
private void updateForcedScroll() {
    if (mForcedScroll != null && (!mForcedScroll.hasFocus() || !mForcedScroll.isAttachedToWindow())) {
        mForcedScroll = null;
    }
    if (mForcedScroll != null) {
        ExpandableView expandableView = (ExpandableView) mForcedScroll;
        int positionInLinearLayout = getPositionInLinearLayout(expandableView);
        int targetScroll = targetScrollForView(expandableView, positionInLinearLayout);
        int outOfViewScroll = positionInLinearLayout + expandableView.getIntrinsicHeight();
        targetScroll = Math.max(0, Math.min(targetScroll, getScrollRange()));
        if (mOwnScrollY < targetScroll || outOfViewScroll < mOwnScrollY) {
            mOwnScrollY = targetScroll;
        }
    }
}

Output:
         if (mOwnScrollY < targetScroll || outOfViewScroll < mOwnScrollY) {
-            mOwnScrollY = targetScroll;
+            setOwnScrollY(targetScroll);
         }


Input:
public void testApplication() {
    ApplicationId appId = new ApplicationId("String_Node_Str", "String_Node_Str", "String_Node_Str");
    Authorizable authorizable = Authorizable.fromEntityId(appId);
    String appIdNoVer = appId.toString().replace("String_Node_Str", "String_Node_Str");
    Assert.assertEquals(appIdNoVer, authorizable.toString());
    try {
        Authorizable.fromString(appId.toString());
        Assert.fail();
    } catch (UnsupportedOperationException e) {
    }
    String widcardId = appIdNoVer.replace("String_Node_Str", "String_Node_Str");
    Assert.assertEquals(widcardId, Authorizable.fromString(widcardId).toString());
}

Output:
     Assert.assertEquals(appIdNoVer, authorizable.toString());
-    try {
-        Authorizable.fromString(appId.toString());
-        Assert.fail();
-    } catch (UnsupportedOperationException e) {
-    }
+    verifyInvalidString(appId.toString());
     String widcardId = appIdNoVer.replace("String_Node_Str", "String_Node_Str");


Input:
public static Connection connect(final int port) throws IOException {
    return new Connection(port, "String_Node_Str", null, null);
}

Output:
 public static Connection connect(final int port) throws IOException {
-    return new Connection(port, "String_Node_Str", null, null);
+    final ContextualLogger logger = new ContextualLogger(LoggerFactory.getLogger(Iris.class.getPackage().getName()), "String_Node_Str", String.valueOf(nextConnId.incrementAndGet()));
+    try {
+        logger.loadContext();
+        logger.info("String_Node_Str", "String_Node_Str", String.valueOf(port));
+        final Connection conn = new Connection(port, "String_Node_Str", null, null, logger);
+        logger.info("String_Node_Str");
+        return conn;
+    } catch (IOException e) {
+        logger.warn("String_Node_Str", "String_Node_Str", e.getMessage());
+        throw e;
+    } finally {
+        logger.unloadContext();
+    }
 }


Input:
private void initialize(IEmitterServices services) {
    this.services = services;
    IReportRunnable reportRunnable = services.getReportRunnable();
    if (reportRunnable != null) {
        reportDesign = (ReportDesignHandle) reportRunnable.getDesignHandle();
    }
    this.context = services.getReportContext();
    Object fd = services.getOption(RenderOption.OUTPUT_FILE_NAME);
    File file = null;
    try {
        if (fd != null) {
            file = new File(fd.toString());
            File parent = file.getParentFile();
            if (parent != null && !parent.exists()) {
                parent.mkdirs();
            }
            output = new FileOutputStream(file);
        }
    } catch (FileNotFoundException fnfe) {
        logger.log(Level.WARNING, fnfe.getMessage(), fnfe);
    }
    if (output == null) {
        Object value = services.getOption(RenderOption.OUTPUT_STREAM);
        if (value != null && value instanceof OutputStream) {
            output = (OutputStream) value;
        } else {
            try {
                file = new File("String_Node_Str");
                output = new FileOutputStream(file);
            } catch (FileNotFoundException e) {
                logger.log(Level.SEVERE, e.getMessage(), e);
            }
        }
    }
}

Output:
     this.context = services.getReportContext();
-    Object fd = services.getOption(RenderOption.OUTPUT_FILE_NAME);
-    File file = null;
-    try {
-        if (fd != null) {
-            file = new File(fd.toString());
-            File parent = file.getParentFile();
-            if (parent != null && !parent.exists()) {
-                parent.mkdirs();
-            }
-            output = new FileOutputStream(file);
-        }
-    } catch (FileNotFoundException fnfe) {
-        logger.log(Level.WARNING, fnfe.getMessage(), fnfe);
-    }
-    if (output == null) {
-        Object value = services.getOption(RenderOption.OUTPUT_STREAM);
-        if (value != null && value instanceof OutputStream) {
-            output = (OutputStream) value;
-        } else {
-            try {
-                file = new File("String_Node_Str");
-                output = new FileOutputStream(file);
-            } catch (FileNotFoundException e) {
-                logger.log(Level.SEVERE, e.getMessage(), e);
-            }
-        }
-    }
+    this.output = EmitterUtil.getOuputStream(services, "String_Node_Str");
 }


Input:
public void runInDQViewer(TdDataProvider tdDataProvider, String query, String editorName) {
    SQLEditor sqlEditor = openInSqlEditor(tdDataProvider, query, editorName);
    if (sqlEditor != null) {
        ExecSQLAction execSQLAction = new ExecSQLAction(sqlEditor);
        execSQLAction.run();
    }
}

Output:
     SQLEditor sqlEditor = openInSqlEditor(tdDataProvider, query, editorName);
-    if (sqlEditor != null) {
-        ExecSQLAction execSQLAction = new ExecSQLAction(sqlEditor);
-        execSQLAction.run();
+    Session session = sqlEditor.getSession();
+    if (sqlEditor != null && session != null) {
+        new ExecSQLAction(sqlEditor).run();
     }


Input:
public static DefaultFeatureType city() {
    final Map<String, Object> identification = new HashMap<>();
    final DefaultAttributeType<String> city = DefaultAttributeTypeTest.city(identification);
    final DefaultAttributeType<Integer> population = DefaultAttributeTypeTest.population(identification);
    identification.clear();
    assertNull(identification.put(DefaultFeatureType.NAME_KEY, "String_Node_Str"));
    return new DefaultFeatureType(identification, false, null, city, population);
}

Output:
     final DefaultAttributeType<Integer> population = DefaultAttributeTypeTest.population(identification);
-    identification.clear();
-    assertNull(identification.put(DefaultFeatureType.NAME_KEY, "String_Node_Str"));
-    return new DefaultFeatureType(identification, false, null, city, population);
+    return new DefaultFeatureType(name("String_Node_Str"), false, null, city, population);
 }


Input:
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str");
    }
    String username = request.getParameter("String_Node_Str");
    MessageSourceAccessor text = new MessageSourceAccessor(messageSource);
    if (username == null) {
        log.warn("String_Node_Str");
        request.setAttribute("String_Node_Str", text.getMessage("String_Node_Str", new Object[] { text.getMessage("String_Node_Str") }));
        return new ModelAndView("String_Node_Str");
    }
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str");
    }
    try {
        User user = (User) mgr.getUser(username);
        StringBuffer msg = new StringBuffer();
        msg.append("String_Node_Str" + user.getPasswordHint());
        msg.append("String_Node_Str" + RequestUtil.getAppURL(request));
        message.setTo(user.getEmail());
        String subject = text.getMessage("String_Node_Str") + text.getMessage("String_Node_Str");
        message.setSubject(subject);
        message.setText(msg.toString());
        mailEngine.send(message);
        saveMessage(request, text.getMessage("String_Node_Str", new Object[] { username, user.getEmail() }));
    } catch (Exception e) {
        saveError(request, text.getMessage("String_Node_Str", new Object[] { username }));
    }
    return new ModelAndView(new RedirectView(request.getContextPath()));
}

Output:
     String username = request.getParameter("String_Node_Str");
-    MessageSourceAccessor text = new MessageSourceAccessor(messageSource);
+    MessageSourceAccessor text = new MessageSourceAccessor(messageSource, request.getLocale());
     if (username == null) {


Input:
private void makeNetworkRequest(final T batch, boolean isRetry) {
    if (isConnectedToNetwork()) {
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str", batch);
        }
        if (!isRetry) {
            resetRetryCounters();
        }
        waitingForCallback = true;
        networkBatchListener.performNetworkRequest(batch, new ValueCallback<NetworkRequestResponse>() {
            public void onReceiveValue(NetworkRequestResponse value) {
                waitingForCallback = false;
                if (!value.complete || (value.httpErrorCode >= HTTP_SERVER_ERROR_CODE_RANGE_START && value.httpErrorCode <= HTTP_SERVER_ERROR_CODE_RANGE_END)) {
                    retryCount++;
                    if (retryCount < maxRetryCount) {
                        int backOff = exponentialBackOff();
                        if (log.isDebugEnabled()) {
                            log.debug("String_Node_Str", value.complete, value.httpErrorCode, batch, backOff);
                        }
                        handler.postDelayed(new Runnable() {
                            public void run() {
                                makeNetworkRequest(batch, true);
                            }
                        }, backOff);
                    } else {
                        if (log.isDebugEnabled()) {
                            log.debug("String_Node_Str", getQueueFile());
                        }
                        retryLimitReached = true;
                    }
                } else {
                    finish(batch);
                }
            }
        });
    } else {
        resetRetryCounters();
        waitingForCallback = false;
    }
}

Output:
         if (log.isDebugEnabled()) {
-            log.debug("String_Node_Str", batch);
+            log.debug("String_Node_Str", batch, this);
         }


Input:
public Sentence firstSentence() throws ConcreteException {
    SentenceSegmentation s = this.firstSentenceSegmentation();
    if (s.isSetSentenceList() && s.getSentenceListSize() > 0)
        return s.getSentenceList().get(0);
    else
        throw new ConcreteException("String_Node_Str" + s.getUuid() + "String_Node_Str" + "String_Node_Str");
}

Output:
 public Sentence firstSentence() throws ConcreteException {
-    SentenceSegmentation s = this.firstSentenceSegmentation();
-    if (s.isSetSentenceList() && s.getSentenceListSize() > 0)
-        return s.getSentenceList().get(0);
-    else
-        throw new ConcreteException("String_Node_Str" + s.getUuid() + "String_Node_Str" + "String_Node_Str");
+    throw new UnsupportedOperationException("String_Node_Str");
 }


Input:
public boolean deletedServiceFunctionClassifier(ServiceFunctionClassifier scf) {
    if (scf == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    LOG.debug("String_Node_Str", scf.getName(), scf.getAccessList(), scf.getSclServiceFunctionForwarder());
    Acl acl = SfcProviderAclAPI.readAccessList(scf.getAccessList());
    if (acl == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    String aclName = acl.getAclName();
    if (aclName == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    AccessListEntries accessListEntries = acl.getAccessListEntries();
    if (accessListEntries == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    List<Ace> acesList = accessListEntries.getAce();
    if (acesList == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    List<SclServiceFunctionForwarder> sfflist = scf.getSclServiceFunctionForwarder();
    if (sfflist == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    for (SclServiceFunctionForwarder sclsff : sfflist) {
        for (Ace ace : acesList) {
            String ruleName = ace.getRuleName();
            if (ruleName == null) {
                LOG.error("String_Node_Str");
                continue;
            }
            Actions actions = ace.getActions();
            if (ruleName == null) {
                LOG.error("String_Node_Str");
                continue;
            }
            Actions1 a1 = actions.getAugmentation(Actions1.class);
            if (a1 == null) {
                LOG.error("String_Node_Str");
                continue;
            }
            AclRenderedServicePath path = (AclRenderedServicePath) a1.getSfcAction();
            if (path == null) {
                LOG.error("String_Node_Str");
                continue;
            }
            RspName rspName = new RspName(path.getRenderedServicePath());
            SfcNshHeader nsh = SfcNshHeader.getSfcNshHeader(rspName);
            SffName sffName = new SffName(sclsff.getName());
            ServiceFunctionForwarder sff = SfcProviderServiceForwarderAPI.readServiceFunctionForwarder(sffName);
            if (sff == null) {
                LOG.error("String_Node_Str");
                continue;
            }
            SffOvsBridgeAugmentation ovsSff = sff.getAugmentation(SffOvsBridgeAugmentation.class);
            if (ovsSff == null) {
                LOG.debug("String_Node_Str");
                continue;
            }
            String nodeName = SfcOvsUtil.getOpenFlowNodeIdForSff(sff);
            if (nodeName == null) {
                LOG.error("String_Node_Str");
                continue;
            }
            StringBuffer key = new StringBuffer();
            key.append(scf.getName()).append(aclName).append(ruleName).append("String_Node_Str");
            SfcScfOfUtils.deleteClassifierFlow(nodeName, key.toString());
            RspName reverseRspName = null;
            if (path.getRenderedServicePath().endsWith("String_Node_Str")) {
                reverseRspName = new RspName(path.getRenderedServicePath().replaceFirst("String_Node_Str", "String_Node_Str"));
            } else {
                reverseRspName = new RspName(path.getRenderedServicePath() + "String_Node_Str");
            }
            SfcNshHeader reverseNsh = SfcNshHeader.getSfcNshHeader(reverseRspName);
            if (reverseNsh == null) {
                LOG.debug("String_Node_Str");
            } else {
                key = new StringBuffer();
                key.append(scf.getName()).append(aclName).append(ruleName).append("String_Node_Str");
                if (!SfcScfOfUtils.deleteClassifierFlow(nodeName, key.toString())) {
                    LOG.error("String_Node_Str");
                }
                SffName lastSffName = reverseNsh.getSffName();
                if (lastSffName != null && !reverseNsh.getSffName().equals(sffName)) {
                    ServiceFunctionForwarder lastSff = SfcProviderServiceForwarderAPI.readServiceFunctionForwarder(lastSffName);
                    String lastNodeName = SfcOvsUtil.getOpenFlowNodeIdForSff(lastSff);
                    if (lastNodeName == null) {
                        LOG.error("String_Node_Str");
                    } else {
                        LOG.debug("String_Node_Str", lastNodeName);
                    }
                    key = new StringBuffer();
                    key.append(scf.getName()).append(aclName).append(ruleName).append("String_Node_Str");
                    if (!SfcScfOfUtils.deleteClassifierFlow(lastNodeName, key.toString())) {
                        LOG.error("String_Node_Str");
                    }
                }
            }
        }
    }
    return true;
}

Output:
             Actions actions = ace.getActions();
-            if (ruleName == null) {
+            if (actions == null) {
                 LOG.error("String_Node_Str");


Input:
protected void okPressed() {
    IProxyRepositoryFactory prf = CorePlugin.getDefault().getProxyRepositoryFactory();
    try {
        prf.saveProject(project);
        ShowStandardAction.getInstance().doRun();
        if (needCodeGen) {
            IComponentsFactory components = ComponentsFactoryProvider.getInstance();
            CorePlugin.getDefault().getCodeGeneratorService().refreshTemplates();
            CorePlugin.getDefault().getLibrariesService().resetModulesNeeded();
        }
    } catch (Exception ex) {
        ExceptionHandler.process(ex);
    }
}

Output:
             IComponentsFactory components = ComponentsFactoryProvider.getInstance();
-            CorePlugin.getDefault().getCodeGeneratorService().refreshTemplates();
-            CorePlugin.getDefault().getLibrariesService().resetModulesNeeded();
+            Job refreshTemplates = CorePlugin.getDefault().getCodeGeneratorService().refreshTemplates();
+            refreshTemplates.addJobChangeListener(new JobChangeAdapter() {
+                public void done(IJobChangeEvent event) {
+                    CorePlugin.getDefault().getLibrariesService().resetModulesNeeded();
+                }
+            });
         }


Input:
public EcqArgs findMecq(List<EcqArgs> allMecqs) {
    if (allMecqs == null)
        return null;
    for (EcqArgs currentMecq : allMecqs) {
        if (currentMecq.getName().equalsIgnoreCase(this.mecq.trim())) {
            return currentMecq;
        }
    }
    return null;
}

Output:
     for (EcqArgs currentMecq : allMecqs) {
-        if (currentMecq.getName().equalsIgnoreCase(this.mecq.trim())) {
+        if (currentMecq.getName().equalsIgnoreCase(this.ecq.trim())) {
             return currentMecq;


Input:
public BufferedImage toImage(int frame, List<Tag> tags, RECT displayRect, HashMap<Integer, CharacterTag> characters) {
    RECT bound = getBounds();
    BufferedImage ret = new BufferedImage(bound.Xmax / 20, bound.Ymax / 20, BufferedImage.TYPE_INT_ARGB);
    Color textColor = new Color(0, 0, 0);
    FontTag font = null;
    int textHeight = 12;
    int x = bound.Xmin;
    int y = 0;
    Graphics2D g = (Graphics2D) ret.getGraphics();
    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    SHAPE[] glyphs = new SHAPE[0];
    for (TEXTRECORD rec : textRecords) {
        if (rec.styleFlagsHasColor) {
            textColor = rec.textColor.toColor();
        }
        if (rec.styleFlagsHasFont) {
            font = (FontTag) characters.get(rec.fontId);
            glyphs = font.getGlyphShapeTable();
            textHeight = rec.textHeight;
        }
        if (rec.styleFlagsHasXOffset) {
            x = rec.xOffset * 1000 / textHeight;
        }
        if (rec.styleFlagsHasYOffset) {
            y = rec.yOffset * 1000 / textHeight;
        }
        for (GLYPHENTRY entry : rec.glyphEntries) {
            RECT rect = SHAPERECORD.getBounds(glyphs[entry.glyphIndex].shapeRecords);
            rect.Xmax /= font.getDivider();
            rect.Xmin /= font.getDivider();
            rect.Ymax /= font.getDivider();
            rect.Ymin /= font.getDivider();
            BufferedImage img = SHAPERECORD.shapeToImage(tags, 1, null, null, glyphs[entry.glyphIndex].shapeRecords, textColor);
            g.setTransform(AffineTransform.getScaleInstance(textHeight / 1000f / 20, textHeight / 1000f / 20));
            g.drawImage(img, x, y + rect.Ymin, null);
            x += entry.glyphAdvance * 1000 / textHeight;
        }
    }
    return ret;
}

Output:
             BufferedImage img = SHAPERECORD.shapeToImage(tags, 1, null, null, glyphs[entry.glyphIndex].shapeRecords, textColor);
-            g.setTransform(AffineTransform.getScaleInstance(textHeight / 1000f / 20, textHeight / 1000f / 20));
-            g.drawImage(img, x, y + rect.Ymin, null);
+            AffineTransform tr = new AffineTransform();
+            tr.setToIdentity();
+            float rat = textHeight / 1000f;
+            tr.translate(rat * x / 20, rat * (y + rect.Ymin) / 20);
+            tr.scale(rat / font.getDivider(), rat / font.getDivider());
+            g.drawImage(img, tr, null);
             x += entry.glyphAdvance * 1000 / textHeight;


Input:
public void testFindAllResourcesUnpaginated() {
    this.request("String_Node_Str").jsonPost(new Sample("String_Node_Str"));
    this.request("String_Node_Str").jsonPost(new Sample("String_Node_Str"));
    Response r = this.request("String_Node_Str").setQueryParameter("String_Node_Str", "String_Node_Str").getXml();
    Assertions.assertThat(r).isNotNull();
    Assertions.assertThat(r.getStatus()).isEqualTo(Http.NOT_IMPLEMENTED);
}

Output:
     this.request("String_Node_Str").jsonPost(new Sample("String_Node_Str"));
-    Response r = this.request("String_Node_Str").setQueryParameter("String_Node_Str", "String_Node_Str").getXml();
+    Response r = this.request("String_Node_Str").setQueryParameter("String_Node_Str", "String_Node_Str").xmlGet();
     Assertions.assertThat(r).isNotNull();


Input:
public void setEntityMetaDatas(Set<EntityMetaData> entityMetaDatas) {
    this.entityMetaDatas = entityMetaDatas;
    for (EntityMetaData emd : entityMetaDatas) {
        ((EntityMetaDataImpl) emd).setModelMetaData(this);
    }
}

Output:
 public void setEntityMetaDatas(Set<EntityMetaData> entityMetaDatas) {
-    this.entityMetaDatas = entityMetaDatas;
+    this.entityMetaDatas.clear();
+    this.entityMetaDatas.addAll(entityMetaDatas);
     for (EntityMetaData emd : entityMetaDatas) {


Input:
private int getHealthDisplay() {
    IInventory inventory = getInternalInventory();
    if (inventory == null || inventory.getStackInSlot(SLOT_QUEEN) == null)
        return 0;
    if (PluginApiculture.beeInterface.isMated(inventory.getStackInSlot(SLOT_QUEEN)))
        return PluginApiculture.beeInterface.getMember(inventory.getStackInSlot(SLOT_QUEEN)).getHealth();
    else if (!PluginApiculture.beeInterface.isDrone(inventory.getStackInSlot(SLOT_QUEEN)))
        return displayHealth;
    else
        return 0;
}

Output:
 private int getHealthDisplay() {
-    IInventory inventory = getInternalInventory();
+    IInventory inventory = getStructureInventory();
     if (inventory == null || inventory.getStackInSlot(SLOT_QUEEN) == null)


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object objectValue, AbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    Object fieldValue = directMapping.getFieldValue(objectValue, session);
    if ((null == fieldValue) || (null == namespaceResolver)) {
        return false;
    }
    XMLField xmlField = (XMLField) directMapping.getField();
    QName schemaType = getSchemaType(xmlField, fieldValue, session);
    if (null == schemaType) {
        return false;
    }
    if (xmlField.getSchemaType() == null) {
        if (schemaType.equals(XMLConstants.STRING_QNAME)) {
            return false;
        }
    } else {
        if (xmlField.isSchemaType(schemaType)) {
            return false;
        }
    }
    XPathFragment groupingFragment = marshalRecord.openStartGroupingElements(namespaceResolver);
    String typeQName = namespaceResolver.resolveNamespaceURI(XMLConstants.SCHEMA_INSTANCE_URL) + XMLConstants.COLON + XMLConstants.SCHEMA_TYPE_ATTRIBUTE;
    String schemaTypePrefix = namespaceResolver.resolveNamespaceURI(schemaType.getNamespaceURI());
    if (schemaTypePrefix == null) {
        if (XMLConstants.SCHEMA_URL.equals(schemaType.getNamespaceURI())) {
            schemaTypePrefix = namespaceResolver.generatePrefix(XMLConstants.SCHEMA_PREFIX);
        } else {
            schemaTypePrefix = namespaceResolver.generatePrefix();
        }
        marshalRecord.attribute(XMLConstants.XMLNS_URL, schemaTypePrefix, XMLConstants.XMLNS + XMLConstants.COLON + schemaTypePrefix, schemaType.getNamespaceURI());
    }
    marshalRecord.attribute(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE, typeQName, schemaTypePrefix + XMLConstants.COLON + schemaType.getLocalPart());
    marshalRecord.closeStartGroupingElements(groupingFragment);
    return true;
}

Output:
         }
-        marshalRecord.attribute(XMLConstants.XMLNS_URL, schemaTypePrefix, XMLConstants.XMLNS + XMLConstants.COLON + schemaTypePrefix, schemaType.getNamespaceURI());
+        marshalRecord.namespaceDeclaration(schemaTypePrefix, schemaType.getNamespaceURI());
     }


Input:
public void adjustBeginLineColumn(int newLine, final int newCol) {
    int start = m_nTokenBegin;
    int len;
    if (m_nBufpos >= m_nTokenBegin) {
        len = m_nBufpos - m_nTokenBegin + m_nInBuf + 1;
    } else {
        len = m_nBufsize - m_nTokenBegin + m_nBufpos + 1 + m_nInBuf;
    }
    int i = 0, j = 0, k = 0;
    int nextColDiff = 0, columnDiff = 0;
    while (i < len && m_aBufLine[j = start % m_nBufsize] == m_aBufLine[k = ++start % m_nBufsize]) {
        m_aBufLine[j] = newLine;
        nextColDiff = columnDiff + m_aBufColumn[k] - m_aBufColumn[j];
        m_aBufColumn[j] = newCol + columnDiff;
        columnDiff = nextColDiff;
        i++;
    }
    if (i < len) {
        m_aBufLine[j] = newLine++;
        m_aBufColumn[j] = newCol + columnDiff;
        while (i++ < len) {
            if (m_aBufLine[j = start % m_nBufsize] != m_aBufLine[++start % m_nBufsize])
                m_aBufLine[j] = newLine++;
            else
                m_aBufLine[j] = newLine;
        }
    }
    m_nLine = m_aBufLine[j];
    m_nColumn = m_aBufColumn[j];
}

Output:
     }
-    int i = 0, j = 0, k = 0;
-    int nextColDiff = 0, columnDiff = 0;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    int nextColDiff = 0;
+    int columnDiff = 0;
     while (i < len && m_aBufLine[j = start % m_nBufsize] == m_aBufLine[k = ++start % m_nBufsize]) {


Input:
public void finish() {
    LOGGER.info("String_Node_Str");
    buildAnnotationNameToClassInfoMap();
    buildInterfaceNameToClassInfoMap();
    registerDefaultTypeConverters();
    List<ClassInfo> transientClasses = new ArrayList<>();
    for (ClassInfo classInfo : classNameToClassInfo.values()) {
        if (classInfo.name() == null || classInfo.name().equals("String_Node_Str"))
            continue;
        LOGGER.debug("String_Node_Str", classInfo.name());
        if (classInfo.isTransient()) {
            LOGGER.debug("String_Node_Str", classInfo.name());
            transientClasses.add(classInfo);
            continue;
        }
        if (classInfo.superclassName() == null || classInfo.superclassName().equals("String_Node_Str")) {
            extend(classInfo, classInfo.directSubclasses());
        }
        for (InterfaceInfo interfaceInfo : classInfo.interfacesInfo().list()) {
            implement(classInfo, interfaceInfo);
        }
    }
    LOGGER.debug("String_Node_Str");
    Collection<ArrayList<ClassInfo>> interfaceInfos = interfaceNameToClassInfo.values();
    for (ArrayList<ClassInfo> classInfos : interfaceInfos) {
        for (ClassInfo classInfo : classInfos) {
            if (classInfo.isTransient()) {
                LOGGER.debug("String_Node_Str", classInfo.name());
                transientClasses.add(classInfo);
            }
        }
    }
    for (ClassInfo transientClass : transientClasses) {
        removeTransientClass(transientClass);
    }
    checkOutOfPackageRefferences();
    LOGGER.info("String_Node_Str");
}

Output:
     for (ClassInfo transientClass : transientClasses) {
-        removeTransientClass(transientClass);
+        transientClassesRemoved.addAll(removeTransientClass(transientClass));
     }


Input:
private void createCustomPreviewPart(Composite parent) {
    Group group;
    if (!isFormStyle())
        group = new Group(parent, SWT.NONE);
    else
        group = FormWidgetFactory.getInstance().createGroup(parent, "String_Node_Str");
    group.setText(LABEL_PREVIEW_GROUP);
    if (pageAlignment == PAGE_ALIGN_HORIZONTAL) {
        group.setLayoutData(new GridData(GridData.FILL_BOTH));
        group.setLayout(new GridLayout(1, false));
    } else {
        group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        group.setLayout(new GridLayout(2, false));
    }
    FormWidgetFactory.getInstance().createLabel(group, isFormStyle()).setText(LABEL_PREVIEW_DATETIME);
    if (!isFormStyle())
        previewTextBox = new Text(group, SWT.SINGLE | SWT.BORDER);
    else
        previewTextBox = FormWidgetFactory.getInstance().createText(group, "String_Node_Str", SWT.SINGLE);
    previewTextBox.setText(defaultDateTime == null ? "String_Node_Str" : defaultDateTime);
    GridData data = new GridData(GridData.FILL_HORIZONTAL);
    if (pageAlignment == PAGE_ALIGN_HORIZONTAL) {
        data.horizontalIndent = 10;
    }
    previewTextBox.setLayoutData(data);
    previewTextBox.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            setDefaultPreviewText(previewTextBox.getText());
            if (hasLoaded) {
                updatePreview();
            }
            if (StringUtil.isBlank(previewTextBox.getText())) {
                guideLabel.setText("String_Node_Str");
            } else {
                guideLabel.setText(ENTER_DATE_TIME_GUIDE_TEXT);
            }
        }
    });
    if (pageAlignment == PAGE_ALIGN_VIRTICAL) {
        FormWidgetFactory.getInstance().createLabel(group, isFormStyle());
    }
    guideLabel = FormWidgetFactory.getInstance().createLabel(group, isFormStyle());
    guideLabel.setText("String_Node_Str");
    Font font = JFaceResources.getDialogFont();
    FontData fData = font.getFontData()[0];
    fData.setHeight(fData.getHeight() - 1);
    guideLabel.setFont(new Font(Display.getCurrent(), fData));
    data = new GridData(GridData.FILL_HORIZONTAL);
    data.horizontalIndent = 10;
    guideLabel.setLayoutData(data);
    Label label = FormWidgetFactory.getInstance().createLabel(group, isFormStyle());
    label.setText(LABEL_PREVIEW_LABEL);
    label.setLayoutData(new GridData());
    cusPreviewLabel = FormWidgetFactory.getInstance().createLabel(group, SWT.CENTER | SWT.HORIZONTAL | SWT.VIRTUAL, isFormStyle());
    cusPreviewLabel.setText("String_Node_Str");
    data = new GridData(GridData.FILL_BOTH);
    data.horizontalSpan = 1;
    cusPreviewLabel.setLayoutData(data);
}

Output:
     fData.setHeight(fData.getHeight() - 1);
-    guideLabel.setFont(new Font(Display.getCurrent(), fData));
+    guideLabel.setFont(FontManager.getFont(fData));
     data = new GridData(GridData.FILL_HORIZONTAL);


Input:
public void add(int first, int count) {
    int start = first;
    int iBeforeStart = this.ranges.indexAtOrBefore(start);
    boolean startsInExistingRange = (iBeforeStart % 2 == 0);
    if (!startsInExistingRange && iBeforeStart >= 0 && start == this.ranges.v(iBeforeStart)) {
        start--;
        iBeforeStart--;
        startsInExistingRange = true;
    }
    int end = first + count;
    int iAfterEnd = this.ranges.indexAtOrAfter(end);
    boolean endsInExistingRange = (iAfterEnd % 2 == 1);
    if (!endsInExistingRange && iAfterEnd < this.ranges.n && end == this.ranges.v(iAfterEnd)) {
        end++;
        iAfterEnd++;
        endsInExistingRange = true;
    }
    if (startsInExistingRange && endsInExistingRange) {
        this.ranges.removeRange(iBeforeStart + 1, iAfterEnd);
    } else if (startsInExistingRange) {
        this.ranges.a[iBeforeStart + 1] = end;
        this.ranges.removeRange(iBeforeStart + 2, iAfterEnd);
    } else if (endsInExistingRange) {
        this.ranges.a[iAfterEnd - 1] = start;
        this.ranges.removeRange(iBeforeStart + 1, iAfterEnd - 1);
    } else {
        this.ranges.removeRange(iBeforeStart + 1, iAfterEnd);
        this.ranges.prepForInsert(iBeforeStart, 2);
        this.ranges.a[iBeforeStart + 0] = start;
        this.ranges.a[iBeforeStart + 1] = end;
    }
}

Output:
 public void add(int first, int count) {
-    int start = first;
-    int iBeforeStart = this.ranges.indexAtOrBefore(start);
-    boolean startsInExistingRange = (iBeforeStart % 2 == 0);
-    if (!startsInExistingRange && iBeforeStart >= 0 && start == this.ranges.v(iBeforeStart)) {
-        start--;
-        iBeforeStart--;
-        startsInExistingRange = true;
-    }
-    int end = first + count;
-    int iAfterEnd = this.ranges.indexAtOrAfter(end);
-    boolean endsInExistingRange = (iAfterEnd % 2 == 1);
-    if (!endsInExistingRange && iAfterEnd < this.ranges.n && end == this.ranges.v(iAfterEnd)) {
-        end++;
-        iAfterEnd++;
-        endsInExistingRange = true;
-    }
-    if (startsInExistingRange && endsInExistingRange) {
-        this.ranges.removeRange(iBeforeStart + 1, iAfterEnd);
-    } else if (startsInExistingRange) {
-        this.ranges.a[iBeforeStart + 1] = end;
-        this.ranges.removeRange(iBeforeStart + 2, iAfterEnd);
-    } else if (endsInExistingRange) {
-        this.ranges.a[iAfterEnd - 1] = start;
-        this.ranges.removeRange(iBeforeStart + 1, iAfterEnd - 1);
-    } else {
-        this.ranges.removeRange(iBeforeStart + 1, iAfterEnd);
-        this.ranges.prepForInsert(iBeforeStart, 2);
-        this.ranges.a[iBeforeStart + 0] = start;
-        this.ranges.a[iBeforeStart + 1] = end;
+    if (count > 0) {
+        int start = first;
+        int iBeforeStart = this.ranges.indexAtOrBefore(start);
+        boolean startsInExistingRange = (iBeforeStart % 2 == 0);
+        if (!startsInExistingRange && iBeforeStart >= 0 && start == this.ranges.v(iBeforeStart)) {
+            start--;
+            iBeforeStart--;
+            startsInExistingRange = true;
+        }
+        int end = first + count;
+        int iAfterEnd = this.ranges.indexAtOrAfter(end);
+        boolean endsInExistingRange = (iAfterEnd % 2 == 1);
+        if (!endsInExistingRange && iAfterEnd < this.ranges.n && end == this.ranges.v(iAfterEnd)) {
+            end++;
+            iAfterEnd++;
+            endsInExistingRange = true;
+        }
+        if (startsInExistingRange && endsInExistingRange) {
+            this.ranges.removeRange(iBeforeStart + 1, iAfterEnd);
+        } else if (startsInExistingRange) {
+            this.ranges.a[iBeforeStart + 1] = end;
+            this.ranges.removeRange(iBeforeStart + 2, iAfterEnd);
+        } else if (endsInExistingRange) {
+            this.ranges.a[iAfterEnd - 1] = start;
+            this.ranges.removeRange(iBeforeStart + 1, iAfterEnd - 1);
+        } else {
+            this.ranges.removeRange(iBeforeStart + 1, iAfterEnd);
+            this.ranges.prepForInsert(iBeforeStart + 1, 2);
+            this.ranges.a[iBeforeStart + 1] = start;
+            this.ranges.a[iBeforeStart + 2] = end;
+        }
     }


Input:
public void halt() throws IOException, InterruptedException {
    if (running) {
        running = false;
        startComplete.await();
        for (int i = 0; i < workers.size(); i++) {
            workers.getQuick(i).halt();
        }
        haltLatch.await();
        dispatcher.close();
        for (int i = 0; i < ioQueue.getCapacity(); i++) {
            IOEvent ev = ioQueue.get(i);
            if (ev != null && ev.context != null) {
                ev.context.close();
            }
        }
    }
}

Output:
             if (ev != null && ev.context != null) {
-                ev.context.close();
+                ev.context = Misc.free(ev.context);
             }


Input:
public void haircut(double threshold) {
    if (this.size() == 0)
        return;
    do {
        int minIdx = this.members.first();
        double minInWeight = this.inWeights[minIdx];
        double limit = 2 * this.totalInternalEdgeWeight / this.size() * threshold;
        for (int i : this.members) {
            if (this.inWeights[i] < minInWeight) {
                minInWeight = this.inWeights[i];
                minIdx = i;
            }
        }
        if (minInWeight < limit)
            this.remove(minIdx);
        else
            break;
    } while (true);
}

Output:
 public void haircut(double threshold) {
-    if (this.size() == 0)
-        return;
-    do {
+    while (!this.members.isEmpty()) {
         int minIdx = this.members.first();