Input:
public DatabaseMapping generateMapping(Property property, XMLDescriptor descriptor, JavaClass descriptorJavaClass, NamespaceInfo namespaceInfo) {
    if (property.isSetXmlJavaTypeAdapter()) {
        if (property.isReference()) {
            return generateMappingForReferenceProperty(property, descriptor, namespaceInfo);
        }
        XmlJavaTypeAdapter xja = property.getXmlJavaTypeAdapter();
        JavaClass adapterClass = helper.getJavaClass(xja.getValue());
        JavaClass valueType = null;
        String sValType = xja.getValueType();
        if (sValType.equals("String_Node_Str")) {
            valueType = property.getActualType();
        } else {
            valueType = helper.getJavaClass(xja.getValueType());
        }
        DatabaseMapping mapping;
        boolean isArray = property.getType().isArray() && !property.getType().getRawName().equals("String_Node_Str");
        if (property.isChoice()) {
            if (isCollectionType(property)) {
                mapping = generateChoiceCollectionMapping(property, descriptor, namespaceInfo);
                ((XMLChoiceCollectionMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
            } else {
                mapping = generateChoiceMapping(property, descriptor, namespaceInfo);
                ((XMLChoiceObjectMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
            }
        } else if (typeInfo.containsKey(valueType.getQualifiedName())) {
            TypeInfo reference = typeInfo.get(valueType.getQualifiedName());
            if (isCollectionType(property)) {
                if (reference.isEnumerationType()) {
                    mapping = generateEnumCollectionMapping(property, descriptor, namespaceInfo, (EnumTypeInfo) reference);
                    XMLJavaTypeConverter converter = new XMLJavaTypeConverter(adapterClass.getQualifiedName());
                    converter.setNestedConverter(((XMLCompositeDirectCollectionMapping) mapping).getValueConverter());
                    ((XMLCompositeDirectCollectionMapping) mapping).setValueConverter(converter);
                } else {
                    mapping = generateCompositeCollectionMapping(property, descriptor, descriptorJavaClass, namespaceInfo, valueType.getQualifiedName());
                    ((XMLCompositeCollectionMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                }
            } else {
                if (reference.isEnumerationType()) {
                    mapping = generateDirectEnumerationMapping(property, descriptor, namespaceInfo, (EnumTypeInfo) reference);
                    XMLJavaTypeConverter converter = new XMLJavaTypeConverter(adapterClass.getQualifiedName());
                    converter.setNestedConverter(((XMLDirectMapping) mapping).getConverter());
                    ((XMLDirectMapping) mapping).setConverter(converter);
                } else if (property.isInverseReference()) {
                    mapping = generateInverseReferenceMapping(property, descriptor, namespaceInfo);
                } else {
                    mapping = generateCompositeObjectMapping(property, descriptor, namespaceInfo, valueType.getQualifiedName());
                    ((XMLCompositeObjectMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                }
            }
        } else {
            if (property.isAny()) {
                if (isCollectionType(property)) {
                    mapping = generateAnyCollectionMapping(property, descriptor, namespaceInfo, property.isMixedContent());
                    ((XMLAnyCollectionMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                } else {
                    mapping = generateAnyObjectMapping(property, descriptor, namespaceInfo);
                    ((XMLAnyObjectMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                }
            } else if (isCollectionType(property) || isArray) {
                if (property.isSwaAttachmentRef() || property.isMtomAttachment()) {
                    mapping = generateBinaryDataCollectionMapping(property, descriptor, namespaceInfo);
                    ((XMLBinaryDataCollectionMapping) mapping).setValueConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                } else {
                    mapping = generateDirectCollectionMapping(property, descriptor, namespaceInfo);
                    if (adapterClass.getQualifiedName().equals(CollapsedStringAdapter.class.getName())) {
                        ((XMLCompositeDirectCollectionMapping) mapping).setCollapsingStringValues(true);
                    } else if (adapterClass.getQualifiedName().equals(NormalizedStringAdapter.class.getName())) {
                        ((XMLCompositeDirectCollectionMapping) mapping).setNormalizingStringValues(true);
                    } else {
                        ((XMLCompositeDirectCollectionMapping) mapping).setValueConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                    }
                }
            } else if (property.isSwaAttachmentRef() || property.isMtomAttachment()) {
                mapping = generateBinaryMapping(property, descriptor, namespaceInfo);
                ((XMLBinaryDataMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
            } else {
                if (!property.isAttribute() && areEquals(valueType, Object.class)) {
                    mapping = generateCompositeObjectMapping(property, descriptor, namespaceInfo, null);
                    ((XMLCompositeObjectMapping) mapping).setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
                    ((XMLCompositeObjectMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                    return mapping;
                }
                mapping = generateDirectMapping(property, descriptor, namespaceInfo);
                if (adapterClass.getQualifiedName().equals(CollapsedStringAdapter.class.getName())) {
                    ((XMLDirectMapping) mapping).setCollapsingStringValues(true);
                } else if (adapterClass.getQualifiedName().equals(NormalizedStringAdapter.class.getName())) {
                    ((XMLDirectMapping) mapping).setNormalizingStringValues(true);
                } else {
                    ((XMLDirectMapping) mapping).setConverter(new XMLJavaTypeConverter(adapterClass.getQualifiedName()));
                }
            }
        }
        return mapping;
    }
    if (property.isSetXmlJoinNodes()) {
        if (isCollectionType(property)) {
            return generateXMLCollectionReferenceMapping(property, descriptor, namespaceInfo, property.getActualType());
        }
        return generateXMLObjectReferenceMapping(property, descriptor, namespaceInfo, property.getType());
    }
    if (property.isXmlTransformation()) {
        return generateTransformationMapping(property, descriptor, namespaceInfo);
    }
    if (property.isChoice()) {
        if (this.isCollectionType(property)) {
            return generateChoiceCollectionMapping(property, descriptor, namespaceInfo);
        }
        return generateChoiceMapping(property, descriptor, namespaceInfo);
    }
    if (property.isInverseReference()) {
        return generateInverseReferenceMapping(property, descriptor, namespaceInfo);
    }
    if (property.isAny()) {
        if (isCollectionType(property) || property.getType().isArray()) {
            return generateAnyCollectionMapping(property, descriptor, namespaceInfo, property.isMixedContent());
        }
        return generateAnyObjectMapping(property, descriptor, namespaceInfo);
    }
    if (property.isReference()) {
        return generateMappingForReferenceProperty(property, descriptor, namespaceInfo);
    }
    if (property.isMap()) {
        if (property.isAnyAttribute()) {
            return generateAnyAttributeMapping(property, descriptor, namespaceInfo);
        }
        return generateMapMapping(property, descriptor, descriptorJavaClass, namespaceInfo);
    }
    if (isCollectionType(property)) {
        return generateCollectionMapping(property, descriptor, descriptorJavaClass, namespaceInfo);
    }
    JavaClass referenceClass = property.getType();
    String referenceClassName = referenceClass.getRawName();
    if (referenceClass.isArray() && !referenceClassName.equals("String_Node_Str")) {
        JavaClass componentType = referenceClass.getComponentType();
        TypeInfo reference = typeInfo.get(componentType.getName());
        if (reference != null && reference.isEnumerationType()) {
            return generateEnumCollectionMapping(property, descriptor, namespaceInfo, (EnumTypeInfo) reference);
        }
        if (areEquals(componentType, Object.class)) {
            XMLCompositeCollectionMapping mapping = generateCompositeCollectionMapping(property, descriptor, descriptorJavaClass, namespaceInfo, null);
            mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
            return mapping;
        }
        if (reference != null || componentType.isArray()) {
            return generateCompositeCollectionMapping(property, descriptor, descriptorJavaClass, namespaceInfo, componentType.getQualifiedName());
        }
        return generateDirectCollectionMapping(property, descriptor, namespaceInfo);
    }
    if (property.isXmlIdRef()) {
        return generateXMLObjectReferenceMapping(property, descriptor, namespaceInfo, referenceClass);
    }
    TypeInfo reference = typeInfo.get(referenceClass.getQualifiedName());
    if (reference != null) {
        if (reference.isEnumerationType()) {
            return generateDirectEnumerationMapping(property, descriptor, namespaceInfo, (EnumTypeInfo) reference);
        }
        if (property.isXmlLocation()) {
            XMLCompositeObjectMapping locationMapping = generateCompositeObjectMapping(property, descriptor, namespaceInfo, referenceClass.getQualifiedName());
            reference.getDescriptor().setInstantiationPolicy(new NullInstantiationPolicy());
            descriptor.setLocationAccessor(locationMapping.getAttributeAccessor());
            return locationMapping;
        } else {
            return generateCompositeObjectMapping(property, descriptor, namespaceInfo, referenceClass.getQualifiedName());
        }
    }
    if (property.isSwaAttachmentRef() || property.isMtomAttachment()) {
        return generateBinaryMapping(property, descriptor, namespaceInfo);
    }
    if (referenceClass.getQualifiedName().equals(OBJECT_CLASS_NAME) && !property.isAttribute()) {
        XMLCompositeObjectMapping coMapping = generateCompositeObjectMapping(property, descriptor, namespaceInfo, null);
        coMapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
        return coMapping;
    }
    if (property.isXmlLocation()) {
        return null;
    }
    return generateDirectMapping(property, descriptor, namespaceInfo);
}

Output:
         if (property.isChoice()) {
-            if (isCollectionType(property)) {
+            if (helper.isCollectionType(property.getType())) {
                 mapping = generateChoiceCollectionMapping(property, descriptor, namespaceInfo);


Input:
public boolean next() throws BirtException {
    checkStarted();
    if (this.columnValueMap == null)
        return false;
    currRowIndex++;
    readCurrentRow();
    return this.columnValueMap != null;
}

Output:
     readCurrentRow();
-    return this.columnValueMap != null;
+    return this.columnValueMap != null && this.columnValueMap.size() > 0;
 }


Input:
public void launch(final Object element, String mode) {
    final IProject project;
    if (element instanceof IFile) {
        project = ((IFile) element).getProject();
    } else if (element instanceof IProject) {
        project = (IProject) element;
    } else {
        project = null;
        System.out.println(element);
    }
    if (project == null) {
        MessageDialog.openError(LaunchPlugin.getActiveWorkbenchShell(), OprofileLaunchMessages.getString("String_Node_Str"), OprofileLaunchMessages.getString("String_Node_Str"));
    }
    ConfigRunner configRunner = new ConfigRunner(project);
    ProgressMonitorDialog dialog = new ProgressMonitorDialog(LaunchPlugin.getActiveWorkbenchShell());
    try {
        dialog.run(true, false, configRunner);
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    ArrayList<ILaunchConfiguration> profilingLaunchConfigs = configRunner.getProfilingConfigs();
    if (profilingLaunchConfigs == null) {
        MessageDialog.openError(null, OprofileLaunchMessages.getString("String_Node_Str"), OprofileLaunchMessages.getString("String_Node_Str"));
    } else if (profilingLaunchConfigs.size() == 1) {
        launchProfilingLaunchConfiguration(profilingLaunchConfigs.get(0), mode);
    } else if (profilingLaunchConfigs.size() > 1) {
        openLaunchSelectionDialog(profilingLaunchConfigs, mode);
    }
}

Output:
         MessageDialog.openError(LaunchPlugin.getActiveWorkbenchShell(), OprofileLaunchMessages.getString("String_Node_Str"), OprofileLaunchMessages.getString("String_Node_Str"));
-    }
-    ConfigRunner configRunner = new ConfigRunner(project);
-    ProgressMonitorDialog dialog = new ProgressMonitorDialog(LaunchPlugin.getActiveWorkbenchShell());
-    try {
-        dialog.run(true, false, configRunner);
-    } catch (InvocationTargetException e) {
-        e.printStackTrace();
-    } catch (InterruptedException e) {
-        e.printStackTrace();
-    }
-    ArrayList<ILaunchConfiguration> profilingLaunchConfigs = configRunner.getProfilingConfigs();
-    if (profilingLaunchConfigs == null) {
-        MessageDialog.openError(null, OprofileLaunchMessages.getString("String_Node_Str"), OprofileLaunchMessages.getString("String_Node_Str"));
-    } else if (profilingLaunchConfigs.size() == 1) {
-        launchProfilingLaunchConfiguration(profilingLaunchConfigs.get(0), mode);
-    } else if (profilingLaunchConfigs.size() > 1) {
-        openLaunchSelectionDialog(profilingLaunchConfigs, mode);
+    } else {
+        ConfigRunner configRunner = new ConfigRunner(project);
+        ProgressMonitorDialog dialog = new ProgressMonitorDialog(LaunchPlugin.getActiveWorkbenchShell());
+        try {
+            dialog.run(true, false, configRunner);
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        ArrayList<ILaunchConfiguration> profilingLaunchConfigs = configRunner.getProfilingConfigs();
+        if (profilingLaunchConfigs == null) {
+            MessageDialog.openError(null, OprofileLaunchMessages.getString("String_Node_Str"), OprofileLaunchMessages.getString("String_Node_Str"));
+        } else if (profilingLaunchConfigs.size() == 1) {
+            launchProfilingLaunchConfiguration(profilingLaunchConfigs.get(0), mode);
+        } else if (profilingLaunchConfigs.size() > 1) {
+            openLaunchSelectionDialog(profilingLaunchConfigs, mode);
+        }
     }


Input:
protected double calculateNumericalMean() {
    final double shape = getShape();
    final double scale = getScale();
    return scale * FastMath.exp(Gamma.logGamma(1 + (1 / shape)));
}

Output:
 protected double calculateNumericalMean() {
-    final double shape = getShape();
-    final double scale = getScale();
-    return scale * FastMath.exp(Gamma.logGamma(1 + (1 / shape)));
+    final double sh = getShape();
+    final double sc = getScale();
+    return sc * FastMath.exp(Gamma.logGamma(1 + (1 / sh)));
 }


Input:
private void clearHistory() {
    textArea.clear();
}

Output:
 private void clearHistory() {
-    textArea.clear();
+    threadService.runActionLater(() -> {
+        textArea.clear();
+    });
 }


Input:
protected boolean canInsert(int columnIndex, int insertFlag) {
    int columnCount = adapter.getColumnCount();
    targetColumnIndex = columnIndex;
    if (insertFlag == INSERT_BEFORE)
        targetColumnIndex = targetColumnIndex - 1;
    if (targetColumnIndex > columnCount)
        targetColumnIndex = columnCount;
    if (targetColumnIndex >= columnCount || targetColumnIndex < 1) {
        originalCells = getCellsContextInfo(adapter.getCellsUnderColumn(1));
    } else {
        originalCells = getCellsContextInfo(adapter.getCellsUnderColumn(targetColumnIndex));
        if (!isValidInsertAndPasteArea(originalCells))
            return false;
    }
    return true;
}

Output:
     } else {
-        originalCells = getCellsContextInfo(adapter.getCellsUnderColumn(targetColumnIndex));
+        originalCells = getCellsContextInfo(adapter.getCellsUnderColumn(targetColumnIndex, false));
         if (!isValidInsertAndPasteArea(originalCells))


Input:
public void addReport(Report report) {
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        conn = getConnection();
        String state = "String_Node_Str";
        if (j2.debug)
            j2.log.info("String_Node_Str" + state);
        ps = conn.prepareStatement(state);
        ps.setString(1, stringClean(report.getUser()));
        ps.setString(2, stringClean(report.getMessage()));
        Location loc = report.getLocation();
        ps.setDouble(3, loc.getX());
        ps.setDouble(4, loc.getY());
        ps.setDouble(5, loc.getZ());
        ps.setFloat(6, loc.getPitch());
        ps.setFloat(7, loc.getYaw());
        ps.setInt(8, serverNumber);
        ps.setString(9, loc.getWorld().getName());
        long time = report.getTime();
        ps.setLong(10, time);
        ps.executeUpdate();
        ps = conn.prepareStatement("String_Node_Str");
        ps.setLong(1, time);
        ps.setString(2, report.getMessage());
        ResultSet rs = ps.executeQuery();
        int id = rs.getInt("String_Node_Str");
        j2.reports.reportID(time, id);
    } catch (SQLException ex) {
    } finally {
        try {
            if (ps != null) {
                ps.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException ex) {
        }
    }
}

Output:
         long time = report.getTime();
-        ps.setLong(10, time);
+        String state = "String_Node_Str" + stringClean(report.getUser()) + "String_Node_Str" + stringClean(report.getMessage()) + "String_Node_Str" + loc.getX() + "String_Node_Str" + loc.getY() + "String_Node_Str" + loc.getZ() + "String_Node_Str" + loc.getPitch() + "String_Node_Str" + loc.getYaw() + "String_Node_Str" + serverNumber + "String_Node_Str" + loc.getWorld().getName() + "String_Node_Str" + time + "String_Node_Str";
+        if (j2.debug)
+            j2.log.info("String_Node_Str" + stringClean(report.getUser()) + "String_Node_Str" + stringClean(report.getMessage()) + "String_Node_Str" + loc.getX() + "String_Node_Str" + loc.getY() + "String_Node_Str" + loc.getZ() + "String_Node_Str" + loc.getPitch() + "String_Node_Str" + loc.getYaw() + "String_Node_Str" + serverNumber + "String_Node_Str" + loc.getWorld().getName() + "String_Node_Str" + time + "String_Node_Str");
+        ps = conn.prepareStatement(state);
         ps.executeUpdate();


Input:
private void visitScript(NodeTraversal t, Node script) {
    Preconditions.checkArgument(scriptNodeCount == 1, "String_Node_Str" + "String_Node_Str");
    String moduleName = guessCJSModuleName(script.getSourceFileName());
    script.addChildToFront(IR.var(IR.name(moduleName), IR.objectlit()).copyInformationFromForTree(script));
    if (reportDependencies) {
        CompilerInput ci = t.getInput();
        ci.addProvide(moduleName);
        JSModule m = new JSModule(moduleName);
        m.addAndOverrideModule(ci);
        module = m;
    }
    script.addChildToFront(IR.exprResult(IR.call(IR.getprop(IR.name("String_Node_Str"), IR.string("String_Node_Str")), IR.string(moduleName))).copyInformationFromForTree(script));
    emitOptionalModuleExportsOverride(script, moduleName);
    NodeTraversal.traverse(compiler, script, new SuffixVarsCallback(moduleName));
    compiler.reportCodeChange();
}

Output:
     String moduleName = guessCJSModuleName(script.getSourceFileName());
-    script.addChildToFront(IR.var(IR.name(moduleName), IR.objectlit()).copyInformationFromForTree(script));
+    NodeTraversal.traverse(compiler, script, new SuffixVarsCallback(moduleName));
+    processExports(script, moduleName);
+    moduleExportRefs.clear();
+    exportRefs.clear();
     if (reportDependencies) {


Input:
public static int addRowFactors(int startRow, int numRows, IloLPMatrix mat, List<Factor> factors) throws IloException {
    int numNewFactors = 0;
    double[] lb = new double[numRows];
    double[] ub = new double[numRows];
    int[][] Aind = new int[numRows][];
    double[][] Aval = new double[numRows][];
    mat.getRows(startRow, numRows, lb, ub, Aind, Aval);
    for (int rowIdx = 0; rowIdx < numRows; rowIdx++) {
        if (lb[rowIdx] == ub[rowIdx]) {
            factors.add(new RowFactor(ub[rowIdx], Aind[rowIdx], Aval[rowIdx], rowIdx, RowFactorType.EQ));
            numNewFactors++;
        } else {
            if (lb[rowIdx] != Rlt.CPLEX_NEG_INF) {
                double[] vals = Utilities.copyOf(Aval[rowIdx]);
                Vectors.scale(vals, -1.0);
                factors.add(new RowFactor(-lb[rowIdx], Aind[rowIdx], vals, rowIdx, RowFactorType.LOWER));
                numNewFactors++;
            }
            if (ub[rowIdx] != Rlt.CPLEX_POS_INF) {
                factors.add(new RowFactor(ub[rowIdx], Aind[rowIdx], Aval[rowIdx], rowIdx, RowFactorType.UPPER));
                numNewFactors++;
            }
        }
    }
    return numNewFactors;
}

Output:
         if (lb[rowIdx] == ub[rowIdx]) {
-            factors.add(new RowFactor(ub[rowIdx], Aind[rowIdx], Aval[rowIdx], rowIdx, RowFactorType.EQ));
+            factors.add(new RowFactor(ub[rowIdx], Aind[rowIdx], Aval[rowIdx], rowIdx, RowFactorType.EQ, mat));
             numNewFactors++;


Input:
private static List<TdTable> loadTables(Connection dataPloadTablesrovider, Catalog catalog, Schema schema, String tablePattern) throws Exception {
    List<TdTable> tables = new ArrayList<TdTable>();
    TypedReturnCode<java.sql.Connection> rcConn = MetadataConnectionUtils.checkConnection((DatabaseConnection) dataPloadTablesrovider);
    if (!rcConn.isOk()) {
        log.error(rcConn.getMessage());
        throw new Exception(rcConn.getMessage());
    }
    java.sql.Connection connection = rcConn.getObject();
    String[] tableType = new String[] { TableType.TABLE.toString() };
    try {
        DatabaseMetaData dm = ExtractMetaDataUtils.getDatabaseMetaData(connection, (DatabaseConnection) dataPloadTablesrovider, false);
        if (schema != null) {
            if (PackageHelper.getTables(schema).size() == 0) {
                tables = MetadataFillFactory.getDBInstance().fillTables(schema, dm, null, tablePattern, tableType);
            } else {
                MetadataFillFactory.getDBInstance().setLinked(false);
                tables = MetadataFillFactory.getDBInstance().fillTables(schema, dm, null, tablePattern, tableType);
                MetadataFillFactory.getDBInstance().setLinked(true);
            }
        } else {
            if (PackageHelper.getTables(catalog).size() == 0) {
                tables = MetadataFillFactory.getDBInstance().fillTables(catalog, dm, null, tablePattern, tableType);
            } else {
                MetadataFillFactory.getDBInstance().setLinked(false);
                tables = MetadataFillFactory.getDBInstance().fillTables(catalog, dm, null, tablePattern, tableType);
                MetadataFillFactory.getDBInstance().setLinked(true);
            }
        }
    } finally {
        ConnectionUtils.closeConnection(connection);
    }
    return tables;
}

Output:
             if (PackageHelper.getTables(schema).size() == 0) {
-                tables = MetadataFillFactory.getDBInstance().fillTables(schema, dm, null, tablePattern, tableType);
+                tables = MetadataFillFactory.getDBInstance().fillTables(schema, dm, null, tablePattern, TABLE_TYPES);
             } else {


Input:
public boolean hasNext() {
    if (next != null) {
        return true;
    }
    if (l >= 0 && levelIterator == null) {
        while (levelEmpty[l]) {
            if (--l == -1)
                return false;
        }
        levelIterator = level[l].descendingIterator();
    }
    if (levelIterator == null) {
        return false;
    }
    next = levelIterator.next();
    count++;
    if (levelIterator.hasNext()) {
        return true;
    } else {
        levelIterator = null;
        l--;
        return count <= size;
    }
}

Output:
     if (l >= 0 && levelIterator == null) {
-        while (levelEmpty[l]) {
+        while (levelEmpty(l)) {
             if (--l == -1)


Input:
public int getTypeMatch(IType type) {
    if (this.type.equals(type)) {
        return 3;
    } else if (this.type.isSuperType(type)) {
        return 2;
    }
    return 0;
}

Output:
         return 3;
-    } else if (this.type.isSuperType(type)) {
+    } else if (type.isSuperTypeOf(this.type)) {
         return 2;


Input:
public void loadFileList(Integer type) {
    File dir = Constants.DIR;
    if (dir.exists() && dir.isDirectory()) {
        File[] files = dir.listFiles();
        FileUtils.sortWithLastModified(files);
        if (files != null) {
            mFileModelList.clear();
            for (File file : files) {
                handleFiles(file.getAbsolutePath(), file.length());
            }
        }
    }
    runOnUiThread(() -> {
        mSwipeRefreshLayout.setRefreshing(false);
        mAppshelfAdapter.notifyDataSetChanged();
    });
}

Output:
         FileUtils.sortWithLastModified(files);
-        if (files != null) {
-            mFileModelList.clear();
-            for (File file : files) {
-                handleFiles(file.getAbsolutePath(), file.length());
-            }
+        mFileModelList.clear();
+        for (File file : files) {
+            handleFiles(file.getAbsolutePath(), file.length());
         }


Input:
public void testSubset5() throws IllegalArgumentException, IOException {
    Data data = Data.create("String_Node_Str", ';');
    data.getDefinition().setAttributeType("String_Node_Str", Hierarchy.create("String_Node_Str", ';'));
    data.getDefinition().setAttributeType("String_Node_Str", Hierarchy.create("String_Node_Str", ';'));
    data.getDefinition().setAttributeType("String_Node_Str", AttributeType.INSENSITIVE_ATTRIBUTE);
    DataSelector selector = DataSelector.create(data).field("String_Node_Str").equals("String_Node_Str");
    DataSubset subset = DataSubset.create(data, selector);
    final ARXAnonymizer anonymizer = new ARXAnonymizer();
    final ARXConfiguration config = ARXConfiguration.create();
    config.addCriterion(new Inclusion(subset));
    ARXResult result = anonymizer.anonymize(data, config);
    data.getHandle().sort(true, 0, 1, 2);
    ARXNode n = result.getLattice().getLevels()[2][1];
    DataHandle h = result.getOutput(n, false);
    String[][] given = iteratorToArray(h.getView().iterator());
    String[][] expected = { { "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" } };
    assertTrue(Arrays.deepEquals(given, expected));
}

Output:
     ARXResult result = anonymizer.anonymize(data, config);
-    data.getHandle().sort(true, 0, 1, 2);
+    data.getHandle().sort(false, 0, 1, 2);
     ARXNode n = result.getLattice().getLevels()[2][1];


Input:
public String request(int sid, String msg) {
    int playerIndex = 0;
    for (int i = 0; i < playerNum; i++) {
        if (allPlayers[i].SID == sid) {
            playerIndex = i;
            break;
        }
    }
    String result = "String_Node_Str";
    switch(gameState) {
        case INIT:
            if (playerState[playerIndex] == 0) {
                result = GodHelper.toInit(allUserInfo, "String_Node_Str", heroList);
                playerState[playerIndex] += 1;
            } else if (playerState[playerIndex] == 1) {
                heroChoose(sid, msg);
                gameState = GameState.MAINGAME;
                playerState[playerIndex] = 0;
                result = GodHelper.toChooseHero("String_Node_Str", heroChoices, teamResult);
            }
            break;
        case MAINGAME:
            switch(phaseState) {
                case PREPARE:
                    if (playerState[playerIndex] == 0) {
                        GambleChecker.cardDistribute(cardHeap, allPlayers[playerIndex], 4);
                        int[] playerHandCard = new int[allPlayers[playerIndex].handCardsNum];
                        boolean isSeenCard = true;
                        for (int i = 0; i < allPlayers[playerIndex].handCardsNum; i++) {
                            playerHandCard[i] = allPlayers[playerIndex].handCards[i];
                            if ((allPlayers[playerIndex].handCards[i] == 1) | (allPlayers[playerIndex].handCards[i] == 2) | (allPlayers[playerIndex].handCards[i] == 3))
                                isSeenCard = false;
                        }
                        if (isSeenCard)
                            allPlayers[playerIndex].isSeenCard = true;
                        result = GodHelper.toCardDistribute("String_Node_Str", playerHandCard);
                        playerState[playerIndex] += 1;
                    } else if (playerState[playerIndex] == 1) {
                        MsgChooseDecision dec = GodHelper.getChooseDecision(msg);
                        allPlayers[playerIndex].stratDecision = allPlayers[playerIndex].handCards[dec.decision()];
                        GambleChecker.cardToHeap(cardHeap, dec.decision());
                        allPlayers[playerIndex].handCards[dec.decision()] = GambleChecker.NOTHING;
                        GambleChecker.cardSort(allPlayers[playerIndex].handCards);
                        allPlayers[playerIndex].handCardsNum -= 1;
                        result = GodHelper.toChooseDecision("String_Node_Str");
                        playerState[playerIndex] += 1;
                    } else if (playerState[playerIndex] == 2) {
                        featureChoose(sid, msg, allPlayers[playerIndex]);
                        playerState[playerIndex] += 1;
                        result = GodHelper.toDecisionFeature("String_Node_Str");
                    } else if (playerState[playerIndex] == 3) {
                        if ((allPlayers[playerIndex].isSeenCard) | (GodHelper.getSeenCard(msg).seenCard() != 0)) {
                            allPlayers[playerIndex].gamble = GodHelper.getSeenCard(msg).seenCard();
                            allPlayers[playerIndex].isSeenCard = true;
                        }
                        result = GodHelper.toSeenCard("String_Node_Str");
                        phaseState = PhaseState.GAMBLE;
                        playerState[playerIndex] = 0;
                    }
                    break;
                case GAMBLE:
                    if (playerState[playerIndex] == 0) {
                    }
                    break;
                case ACTION:
                    break;
            }
            break;
    }
    if (result.equals("String_Node_Str")) {
        System.out.printf("String_Node_Str", sid, msg, gameState.toString());
    }
    return result;
}

Output:
                     } else if (playerState[playerIndex] == 3) {
-                        if ((allPlayers[playerIndex].isSeenCard) | (GodHelper.getSeenCard(msg).seenCard() != 0)) {
-                            allPlayers[playerIndex].gamble = GodHelper.getSeenCard(msg).seenCard();
-                            allPlayers[playerIndex].isSeenCard = true;
-                        }
+                        seenCard(sid, msg, allPlayers[playerIndex]);
                         result = GodHelper.toSeenCard("String_Node_Str");


Input:
public void testJSON_multipleEntryProcessorClasses() throws InterruptedException {
    for (int i = 0; i < 2; i++) {
        map.executeOnEntries(getSlowEntryProcessor(2));
    }
    SlowEntryProcessorChild entryProcessorChild = new SlowEntryProcessorChild(2);
    map.executeOnEntries(entryProcessorChild);
    map.executeOnEntries(getSlowEntryProcessor(4));
    awaitSlowEntryProcessors();
    entryProcessorChild.await();
    logger.finest(getOperationStats(instance).toString());
    JsonArray slowOperationLogsJsonArray = getSlowOperationLogsJsonArray(instance);
    JsonObject firstLogJsonObject = slowOperationLogsJsonArray.get(0).asObject();
    JsonObject secondLogJsonObject = slowOperationLogsJsonArray.get(1).asObject();
    assertJSONContainsClassNameJustOnce(firstLogJsonObject, secondLogJsonObject, "String_Node_Str");
    assertJSONContainsClassNameJustOnce(firstLogJsonObject, secondLogJsonObject, "String_Node_Str");
    int firstSize = firstLogJsonObject.get("String_Node_Str").asArray().size();
    int secondSize = secondLogJsonObject.get("String_Node_Str").asArray().size();
    assertTrue(format("String_Node_Str", firstSize, secondSize), (firstSize == 1 ^ secondSize == 1) && (firstSize == 3 ^ secondSize == 3));
}

Output:
     for (int i = 0; i < 2; i++) {
-        map.executeOnEntries(getSlowEntryProcessor(2));
+        map.executeOnEntries(getSlowEntryProcessor(3));
     }


Input:
protected void apply() {
    final CacheQuery cacheQuery = holder.getCacheQuery();
    final Integer offset = fetchOptions.getOffset();
    if (offset != null) {
        cacheQuery.firstResult(offset);
    }
    final Integer limit = fetchOptions.getLimit();
    if (limit != null) {
        cacheQuery.maxResults(limit);
    }
    final Cursor start = fetchOptions.getStartCursor();
    if (start != null) {
        JBossCursorHelper.applyStartCursor(start, cacheQuery);
    }
    final Cursor end = fetchOptions.getEndCursor();
    if (end != null) {
        JBossCursorHelper.applyEndCursor(end, cacheQuery, start);
    }
}

Output:
     final CacheQuery cacheQuery = holder.getCacheQuery();
-    final Integer offset = fetchOptions.getOffset();
-    if (offset != null) {
-        cacheQuery.firstResult(offset);
+    Integer offset = fetchOptions.getOffset();
+    Integer cursorOffset = null;
+    Cursor startCursor = fetchOptions.getStartCursor();
+    if (startCursor != null) {
+        cursorOffset = JBossCursorHelper.readIndex(startCursor);
     }


Input:
public File getFile() {
    String name = fileField.getText();
    if (StringUtil.isEmpty(name))
        return null;
    File file = new File(name);
    return file.exists() ? file : null;
}

Output:
     String name = fileField.getText();
-    if (StringUtil.isEmpty(name))
-        return null;
-    File file = new File(name);
-    return file.exists() ? file : null;
+    return StringUtil.isEmpty(name) ? null : new File(name);
 }


Input:
private void addCommonWebBundleDescriptor(WebBundleDescriptor wbd) {
    super.addBundleDescriptor(wbd);
    WebBundleDescriptorImpl webBundleDescriptor = (WebBundleDescriptorImpl) wbd;
    for (WebComponentDescriptor webComponentDesc : webBundleDescriptor.getWebComponentDescriptors()) {
        WebComponentDescriptorImpl webComponentDescriptor = new WebComponentDescriptorImpl(webComponentDesc);
        webComponentDescriptor.setWebBundleDescriptor(null);
        List<String> removeUrlPatterns = null;
        for (String urlPattern : webComponentDescriptor.getUrlPatternsSet()) {
            String servletName = null;
            if (urlPattern2ServletName != null) {
                servletName = urlPattern2ServletName.get(urlPattern);
            }
            if (servletName != null && (!servletName.equals(webComponentDescriptor.getCanonicalName()))) {
                if (removeUrlPatterns == null) {
                    removeUrlPatterns = new ArrayList<String>();
                }
                removeUrlPatterns.add(urlPattern);
            }
        }
        if (removeUrlPatterns != null) {
            webComponentDescriptor.getUrlPatternsSet().removeAll(removeUrlPatterns);
        }
        addWebComponentDescriptor(webComponentDescriptor);
    }
    getContextParametersSet().addAll(webBundleDescriptor.getContextParametersSet());
    if (conflictedMimeMappingExtensions == null) {
        conflictedMimeMappingExtensions = webBundleDescriptor.getConflictedMimeMappingExtensions();
    } else {
        conflictedMimeMappingExtensions.addAll(webBundleDescriptor.getConflictedMimeMappingExtensions());
    }
    combineMimeMappings(webBundleDescriptor.getMimeMappingsSet());
    for (ErrorPageDescriptor errPageDesc : webBundleDescriptor.getErrorPageDescriptorsSet()) {
        addErrorPageDescriptor(errPageDesc);
    }
    getAppListeners().addAll(webBundleDescriptor.getAppListeners());
    if (webBundleDescriptor.isDenyUncoveredHttpMethods()) {
        setDenyUncoveredHttpMethods(true);
    }
    combineSecurityConstraints(getSecurityConstraintsSet(), webBundleDescriptor.getSecurityConstraintsSet());
    combineServletFilters(webBundleDescriptor);
    combineServletFilterMappings(webBundleDescriptor);
    if (getLocaleEncodingMappingListDescriptor() == null) {
        setLocaleEncodingMappingListDescriptor(webBundleDescriptor.getLocaleEncodingMappingListDescriptor());
    }
    if (webBundleDescriptor.getJspConfigDescriptor() != null) {
        JspConfigDescriptorImpl jspConfigDesc = getJspConfigDescriptor();
        if (jspConfigDesc == null) {
            jspConfigDesc = new JspConfigDescriptorImpl();
            setJspConfigDescriptor(jspConfigDesc);
        }
        jspConfigDescriptor.add(webBundleDescriptor.getJspConfigDescriptor());
    }
    WebServicesDescriptor thisWebServices = this.getWebServices();
    WebServicesDescriptor otherWebServices = webBundleDescriptor.getWebServices();
    for (WebService ws : otherWebServices.getWebServices()) {
        thisWebServices.addWebService(new WebService(ws));
    }
    if (getSessionConfig() == null) {
        setSessionConfig(webBundleDescriptor.getSessionConfig());
    }
    combineLoginConfiguration(webBundleDescriptor);
    Boolean otherIsDistributable = webBundleDescriptor.isDistributable();
    if (otherIsDistributable != null) {
        if (isDistributable != null) {
            setDistributable(isDistributable && otherIsDistributable);
        } else {
            setDistributable(otherIsDistributable);
        }
    }
    combinePostConstructDescriptors(webBundleDescriptor);
    combinePreDestroyDescriptors(webBundleDescriptor);
    addJndiNameEnvironment(webBundleDescriptor);
}

Output:
         } else {
-            setDistributable(otherIsDistributable);
+            setDistributable(false);
         }


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

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


Input:
public Iterator<TypeSymbol> iterator() {
    return new Iterator<TypeSymbol>() {
        List<TypeSymbol> seen = List.nil();
        TypeSymbol currentSym = getSymbol(intype);

        public boolean hasNext() {
            return currentSym != null;
        }
        public TypeSymbol next() {
            TypeSymbol prevSym = currentSym;
            currentSym = getSymbol(types.supertype(currentSym.type));
            return prevSym;
        }
        public void remove() {
            throw new UnsupportedOperationException("String_Node_Str");
        }
        TypeSymbol getSymbol(Type intype) {
            if (intype.tag != CLASS && intype.tag != TYPEVAR) {
                return null;
            }
            while (intype.tag == TYPEVAR) intype = intype.getUpperBound();
            if (seen.contains(intype.tsym)) {
                return null;
            }
            seen = seen.prepend(intype.tsym);
            return intype.tsym;
        }
    };
}

Output:
         List<TypeSymbol> seen = List.nil();
-        TypeSymbol currentSym = getSymbol(intype);
+        TypeSymbol currentSym = symbolFor(intype);
+        TypeSymbol prevSym = null;


Input:
private void zeroPaddingNumber(StringBuffer buf, int value, int minWidth) {
    int b = NUMBER_BASE;
    for (int i = 0; i < minWidth - 1; i++) {
        if (value < b) {
            buf.append('0');
        }
        b *= NUMBER_BASE;
    }
    buf.append(Integer.toString(value));
}

Output:
     }
-    buf.append(Integer.toString(value));
+    buf.append(value);
 }


Input:
private void useNewNearbyLocation(Location newNearbyLocation, boolean force) {
    if (!force && (newNearbyLocation == null || !this.fragmentVisible || LocationUtils.areTheSame(newNearbyLocation, this.nearbyLocation))) {
        return;
    }
    this.nearbyLocation = newNearbyLocation;
    if (this.adapter != null) {
        this.adapter.clearAll();
        this.adapter.notifyDataSetChanged(true);
    }
    final View view = getView();
    if (view != null) {
        if (view.findViewById(R.id.list) != null) {
            ((ListView) view.findViewById(R.id.list)).setSelectionFromTop(0, 0);
        }
    }
    this.ad = LocationUtils.DEFAULT_AROUND_DIFF;
    showLoading();
    if (this.nearbyLocation != null) {
        getLoaderManager().restartLoader(NEARBY_POIS_LOADER, null, this);
    }
}

Output:
     if (this.adapter != null) {
-        this.adapter.clearAll();
-        this.adapter.notifyDataSetChanged(true);
+        this.adapter.clear();
     }


Input:
public List<String> getEntityKinds() {
    Set<String> set = new TreeSet<String>();
    for (Entity entity : getDatastore().prepare(new Query()).asIterable()) {
        if (entity != null) {
            set.add(entity.getKind());
        }
    }
    return new ArrayList<String>(set);
}

Output:
 public List<String> getEntityKinds() {
-    Set<String> set = new TreeSet<String>();
-    for (Entity entity : getDatastore().prepare(new Query()).asIterable()) {
-        if (entity != null) {
-            set.add(entity.getKind());
-        }
-    }
-    return new ArrayList<String>(set);
+    NamespaceServiceInternal namespaceService = NamespaceServiceFactory.getNamespaceService();
+    Set<String> set = namespaceService.getKindsPerNamespace(getSelectedNamespace());
+    List<String> list = new ArrayList<String>(set);
+    Collections.sort(list);
+    return list;
 }


Input:
public void updateBuffer(boolean clearBefore) {
    if (mBuffer == null || mText == null)
        return;
    Paint p = FP.paint;
    p.reset();
    p.setStyle(Style.FILL);
    p.setColor(mColor);
    p.setTextSize(mSize);
    p.setAntiAlias(true);
    p.setTextAlign(Align.LEFT);
    mWidth = (int) (p.measureText(mText));
    mHeight = (int) (mSize);
    Bitmap newBm = Bitmap.createBitmap(mWidth, (int) (mHeight + FP.dip(4)), Config.ARGB_8888);
    mSource.recycle();
    mSource = newBm;
    mBufferRect.set(0, 0, mWidth, mHeight);
    getClipRect().set(mBufferRect);
    mCanvas.setBitmap(mSource);
    mCanvas.drawText(mText, 0, -p.ascent(), p);
    super.updateBuffer(clearBefore);
}

Output:
     mWidth = (int) (p.measureText(mText));
-    mHeight = (int) (mSize);
+    mHeight = (int) (FP.dip(mSize));
     Bitmap newBm = Bitmap.createBitmap(mWidth, (int) (mHeight + FP.dip(4)), Config.ARGB_8888);


Input:
public final static void configure() {
    Properties props = new Properties();
    try {
        props.load(Driver.class.getResourceAsStream("String_Node_Str"));
    } catch (IOException e) {
        throw new ExceptionInInitializerError(e);
    }
    configure(props);
}

Output:
     try {
-        props.load(Driver.class.getResourceAsStream("String_Node_Str"));
+        InputStream inputStream = Driver.class.getResourceAsStream("String_Node_Str");
+        if (inputStream != null) {
+            Properties props = new Properties();
+            props.load(inputStream);
+            configure(props);
+        }
     } catch (IOException e) {


Input:
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
    TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
    if (tileEntity instanceof TileEntityCruiseLauncher) {
        return new ContainerCruiseLauncher(player.inventory, (TileEntityCruiseLauncher) tileEntity);
    } else if (tileEntity instanceof TileLauncherBase) {
        return new ContainerLauncher(player.inventory, (TileLauncherBase) tileEntity);
    } else if (tileEntity instanceof TileMissileCoordinator) {
        return new ContainerMissileCoordinator(player.inventory, (TileMissileCoordinator) tileEntity);
    } else if (tileEntity instanceof TileMissileAssembler) {
        return new ContainerMissileTable(player.inventory, (TileMissileAssembler) tileEntity);
    }
    return null;
}

Output:
     TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
-    if (tileEntity instanceof TileEntityCruiseLauncher) {
-        return new ContainerCruiseLauncher(player.inventory, (TileEntityCruiseLauncher) tileEntity);
+    if (tileEntity instanceof TileCruiseLauncher) {
+        return new ContainerCruiseLauncher(player.inventory, (TileCruiseLauncher) tileEntity);
     } else if (tileEntity instanceof TileLauncherBase) {


Input:
public void before() {
    RestAssured.baseURI = baseUrl();
    api = RamlLoaders.fromClasspath(RestAssuredTest.class).load("String_Node_Str").assumingBaseUri("String_Node_Str");
    restAssured = api.createRestAssured();
}

Output:
 public void before() {
-    RestAssured.baseURI = baseUrl();
+    RestAssured.baseURI = baseUrlWithPort();
     api = RamlLoaders.fromClasspath(RestAssuredTest.class).load("String_Node_Str").assumingBaseUri("String_Node_Str");


Input:
public HE_Mesh createBase() {
    if (container == null) {
        return new HE_Mesh();
    }
    if (points == null) {
        return container;
    }
    if (numberOfPoints == 0) {
        numberOfPoints = points.length;
    }
    if ((cellIndex < 0) || (cellIndex >= numberOfPoints)) {
        return container;
    }
    final HE_Mesh result = container.get();
    final ArrayList<WB_Plane> cutPlanes = new ArrayList<WB_Plane>();
    int id = 0;
    final WB_Point O = new WB_Point();
    WB_Plane P;
    final int[] labels;
    if (limitPoints) {
        labels = new int[pointsToUse.length];
        for (final int element : pointsToUse) {
            if (cellIndex != element) {
                final WB_Vector N = new WB_Vector(points[cellIndex]);
                N.subSelf(points[element]);
                N.normalizeSelf();
                O.set(points[cellIndex]);
                O.addSelf(points[element]);
                O.mulSelf(0.5);
                if (offset != 0) {
                    O.addSelf(N.mul(offset));
                }
                P = new WB_Plane(O, N);
                cutPlanes.add(P);
                labels[id] = element;
                id++;
            }
        }
    } else {
        labels = new int[numberOfPoints - 1];
        for (int j = 0; j < numberOfPoints; j++) {
            if (cellIndex != j) {
                final WB_Vector N = new WB_Vector(points[cellIndex]);
                N.subSelf(points[j]);
                N.normalizeSelf();
                O.set(points[cellIndex]);
                O.addSelf(points[j]);
                O.mulSelf(0.5);
                if (offset != 0) {
                    O.addSelf(N.mul(offset));
                }
                P = new WB_Plane(O, N);
                cutPlanes.add(P);
                labels[id] = j;
                id++;
            }
        }
    }
    final HEM_MultiSlice msm = new HEM_MultiSlice();
    msm.setPlanes(cutPlanes).setCenter(new WB_Point(points[cellIndex])).setCap(!surface).setKeepCenter(true).setLabels(labels).setSimpleCap(simpleCap);
    result.modify(msm);
    inner = new HE_Selection(result);
    for (int i = 0; i < labels.length; i++) {
        final HE_Selection sel = HE_Selection.selectFacesWithInternalLabel(result, labels[i]);
        if (sel.getNumberOfFaces() > 0) {
            final HE_FaceIterator fitr = sel.fItr();
            while (fitr.hasNext()) {
                result.deleteFace(fitr.next());
            }
            result.cleanUnusedElementsByFace();
            for (final HE_Face f : result.capHoles()) {
                f.copyProperties(sel.getFaceWithIndex(0));
            }
        }
    }
    outer = msm.origFaces;
    return result;
}

Output:
     for (int i = 0; i < labels.length; i++) {
-        final HE_Selection sel = HE_Selection.selectFacesWithInternalLabel(result, labels[i]);
+        final HE_Selection sel = HE_Selection.selectFacesWithTemporaryLabel(result, labels[i]);
         if (sel.getNumberOfFaces() > 0) {


Input:
public void perform(GraphRewrite event, EvaluationContext context, ProjectModel payload) {
    GraphContext graphContext = event.getGraphContext();
    GraphService<OverviewReportLineMessageModel> overviewLineService = new GraphService<OverviewReportLineMessageModel>(graphContext, OverviewReportLineMessageModel.class);
    OverviewReportLineMessageModel overviewLine = overviewLineService.create();
    overviewLine.setMessage(message);
    overviewLine.setProject(payload);
    overviewLine.setRuleID(((Rule) context.get(Rule.class)).getId());
}

Output:
     GraphContext graphContext = event.getGraphContext();
-    GraphService<OverviewReportLineMessageModel> overviewLineService = new GraphService<OverviewReportLineMessageModel>(graphContext, OverviewReportLineMessageModel.class);
+    GraphService<OverviewReportLineMessageModel> overviewLineService = new GraphService<>(graphContext, OverviewReportLineMessageModel.class);
     OverviewReportLineMessageModel overviewLine = overviewLineService.create();


Input:
private void measureHeader() {
    int widthMeasureSpec = MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.EXACTLY);
    int heightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
    header.measure(widthMeasureSpec, heightMeasureSpec);
    header.layout(getLeft() + getPaddingLeft(), 0, getRight() - getPaddingRight(), header.getMeasuredHeight());
}

Output:
     int widthMeasureSpec = MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.EXACTLY);
-    int heightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+    int heightMeasureSpec = 0;
+    ViewGroup.LayoutParams params = header.getLayoutParams();
+    if (params != null && params.height > 0) {
+        heightMeasureSpec = MeasureSpec.makeMeasureSpec(params.height, MeasureSpec.EXACTLY);
+    } else {
+        heightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+    }
     header.measure(widthMeasureSpec, heightMeasureSpec);


Input:
public void testCopyLargeFiles() throws IOException {
    byte[] block = new byte[BLOCKSIZE];
    SUBDIR.mkdirs();
    File largeFile = new File(SUBDIR, LARGE_FILE);
    OutputStream os = new BufferedOutputStream(new FileOutputStream(largeFile));
    System.out.println("String_Node_Str");
    for (long l = 0; l < LARGE / ((long) BLOCKSIZE) + 1L; l++) {
        os.write(block);
    }
    System.out.println("String_Node_Str");
    FileUtils.copyDirectory(SUBDIR, SUBDIR2);
    File file1 = new File(SUBDIR, LARGE_FILE);
    File file2 = new File(SUBDIR2, LARGE_FILE);
    assertEquals("String_Node_Str", file1.length(), file2.length());
}

Output:
     File largeFile = new File(SUBDIR, LARGE_FILE);
-    OutputStream os = new BufferedOutputStream(new FileOutputStream(largeFile));
-    System.out.println("String_Node_Str");
-    for (long l = 0; l < LARGE / ((long) BLOCKSIZE) + 1L; l++) {
-        os.write(block);
+    OutputStream os = null;
+    try {
+        os = new BufferedOutputStream(new FileOutputStream(largeFile));
+        System.out.println("String_Node_Str");
+        for (long l = 0; l < LARGE / ((long) BLOCKSIZE) + 1L; l++) {
+            os.write(block);
+        }
+        System.out.println("String_Node_Str");
+        FileUtils.copyDirectory(SUBDIR, SUBDIR2);
+        File file1 = new File(SUBDIR, LARGE_FILE);
+        File file2 = new File(SUBDIR2, LARGE_FILE);
+        assertEquals("String_Node_Str", file1.length(), file2.length());
+    } finally {
+        IOUtils.closeQuietly(os);
     }


Input:
public static EngineTexturesFile getEngineTexturesFile(String dungeonKeeperFolder) {
    String dataDirectory = dungeonKeeperFolder.concat("String_Node_Str").concat(File.separator);
    EngineTexturesFile etFile = new EngineTexturesFile(new File(dataDirectory.concat("String_Node_Str")));
    return etFile;
}

Output:
 public static EngineTexturesFile getEngineTexturesFile(String dungeonKeeperFolder) {
-    String dataDirectory = dungeonKeeperFolder.concat("String_Node_Str").concat(File.separator);
-    EngineTexturesFile etFile = new EngineTexturesFile(new File(dataDirectory.concat("String_Node_Str")));
-    return etFile;
+    try {
+        EngineTexturesFile etFile = new EngineTexturesFile(new File(Utils.getRealFileName(dungeonKeeperFolder, "String_Node_Str".concat(File.separator).concat("String_Node_Str"))));
+        return etFile;
+    } catch (IOException e) {
+        throw new RuntimeException("String_Node_Str", e);
+    }
 }


Input:
public static void addApplication(ApplicationBean appDefinition, ConfigurationContext ctxt, String userName, String tenantDomain) throws RestAPIException {
    try {
        if (AutoscalerServiceClient.getInstance().getApplication(appDefinition.getApplicationId()) != null) {
            String msg = "String_Node_Str" + appDefinition.getApplicationId();
            throw new RestAPIException(msg);
        }
    } catch (RemoteException e) {
        throw new RestAPIException("String_Node_Str", e);
    }
    ApplicationContext applicationContext = ObjectConverter.convertApplicationDefinitionToStubApplicationContext(appDefinition);
    applicationContext.setTenantId(ApplicationManagementUtil.getTenantId(ctxt));
    applicationContext.setTenantDomain(tenantDomain);
    applicationContext.setTeantAdminUsername(userName);
    if (appDefinition.getProperty() != null) {
        org.apache.stratos.autoscaler.stub.Properties properties = new org.apache.stratos.autoscaler.stub.Properties();
        for (PropertyBean propertyBean : appDefinition.getProperty()) {
            org.apache.stratos.autoscaler.stub.Property property = new org.apache.stratos.autoscaler.stub.Property();
            property.setName(propertyBean.getName());
            property.setValue(propertyBean.getValue());
            properties.addProperties(property);
        }
        applicationContext.setProperties(properties);
    }
    try {
        AutoscalerServiceClient.getInstance().addApplication(applicationContext);
    } catch (AutoScalerServiceApplicationDefinitionExceptionException e) {
        throw new RestAPIException(e);
    } catch (RemoteException e) {
        throw new RestAPIException(e);
    }
}

Output:
     applicationContext.setTenantDomain(tenantDomain);
-    applicationContext.setTeantAdminUsername(userName);
+    applicationContext.setTenantAdminUsername(userName);
     if (appDefinition.getProperty() != null) {


Input:
public boolean createGame(String game, String name, String pass) throws RemoteException {
    return false;
}

Output:
 public boolean createGame(String game, String name, String pass) throws RemoteException {
-    return false;
+    Game g = new Game(game, name, pass);
+    return this.games.add(g);
 }


Input:
public synchronized int getMaster() {
    try {
        String root = getRoot();
        List<String> children = zooKeeper.getChildren(root, false);
        int currentMasterId = -1;
        int lowestSeq = Integer.MAX_VALUE;
        long highestTxId = -1;
        for (String child : children) {
            int index = child.indexOf('_');
            int id = Integer.parseInt(child.substring(0, index));
            int seq = Integer.parseInt(child.substring(index + 1));
            try {
                byte[] data = zooKeeper.getData(root + "String_Node_Str" + child, false, null);
                ByteBuffer buf = ByteBuffer.wrap(data);
                long tx = buf.getLong();
                if (tx >= highestTxId) {
                    highestTxId = tx;
                    if (seq < lowestSeq) {
                        currentMasterId = id;
                        lowestSeq = seq;
                    }
                }
            } catch (KeeperException inner) {
                if (inner.code() != KeeperException.Code.NONODE) {
                    throw new ZooKeeperException("String_Node_Str", inner);
                }
            }
        }
        return currentMasterId;
    } catch (KeeperException e) {
        throw new ZooKeeperException("String_Node_Str", e);
    } catch (InterruptedException e) {
        Thread.interrupted();
        throw new ZooKeeperException("String_Node_Str", e);
    }
}

Output:
                 if (tx >= highestTxId) {
-                    highestTxId = tx;
-                    if (seq < lowestSeq) {
+                    if (tx > highestTxId || seq < lowestSeq) {
                         currentMasterId = id;


Input:
private void readVertex(String curLine, int num_vertices) throws Exception {
    String[] parts = null;
    int firstParts = -1;
    String index;
    String label = null;
    if (curLine.indexOf('"') != -1) {
        String[] initial_split = curLine.trim().split("String_Node_Str");
        if (initial_split.length < 1 || initial_split.length > 3) {
            report.logIssue(new Issue(NbBundle.getMessage(ImporterPajek.class, "String_Node_Str", lineReader.getLineNumber()), Issue.Level.SEVERE));
        }
        index = initial_split[0].trim();
        if (initial_split.length > 1) {
            label = initial_split[1].trim();
        }
        if (initial_split.length == 3) {
            parts = initial_split[2].trim().split("String_Node_Str", -1);
        }
        firstParts = 0;
    } else {
        parts = curLine.trim().split("String_Node_Str", -1);
        index = parts[0];
        switch(parts.length) {
            case 1:
                break;
            case 2:
                label = parts[1];
                break;
            case 3:
                firstParts = 1;
                break;
            case 4:
                firstParts = 2;
                break;
        }
    }
    int v_id = Integer.parseInt(index) - 1;
    if (v_id >= num_vertices || v_id < 0) {
        report.logIssue(new Issue(NbBundle.getMessage(ImporterPajek.class, "String_Node_Str", v_id, num_vertices), Issue.Level.SEVERE));
    }
    NodeDraft node = verticesArray[v_id];
    if (label != null && label.length() > 0) {
        node.setLabel(label);
    }
    if (firstParts != -1 && parts != null && parts.length >= firstParts + 2) {
        for (int i = firstParts; i < parts.length; i++) {
            if (i < parts.length - 1) {
                try {
                    float x = Float.parseFloat(parts[i]);
                    float y = Float.parseFloat(parts[i + 1]);
                    node.setX(x);
                    node.setY(y);
                    i++;
                } catch (Exception e) {
                    report.logIssue(new Issue(NbBundle.getMessage(ImporterPajek.class, "String_Node_Str", lineReader.getLineNumber()), Issue.Level.WARNING));
                }
            }
            if (parts[i].equals("String_Node_Str")) {
            }
        }
    }
}

Output:
     if (firstParts != -1 && parts != null && parts.length >= firstParts + 2) {
-        for (int i = firstParts; i < parts.length; i++) {
-            if (i < parts.length - 1) {
-                try {
-                    float x = Float.parseFloat(parts[i]);
-                    float y = Float.parseFloat(parts[i + 1]);
-                    node.setX(x);
-                    node.setY(y);
-                    i++;
-                } catch (Exception e) {
-                    report.logIssue(new Issue(NbBundle.getMessage(ImporterPajek.class, "String_Node_Str", lineReader.getLineNumber()), Issue.Level.WARNING));
-                }
-            }
-            if (parts[i].equals("String_Node_Str")) {
+        int i = firstParts;
+        if (i < parts.length - 1) {
+            try {
+                float x = Float.parseFloat(parts[i]);
+                float y = Float.parseFloat(parts[i + 1]);
+                node.setX(x);
+                node.setY(y);
+                i++;
+            } catch (Exception e) {
+                report.logIssue(new Issue(NbBundle.getMessage(ImporterPajek.class, "String_Node_Str", lineReader.getLineNumber()), Issue.Level.WARNING));
             }


Input:
public void mousePressed(MouseEvent e) {
    if (model == null) {
        return;
    }
    int x = e.getX();
    float w = getWidth();
    int r = 16;
    if (currentState == TimelineState.IDLE) {
        if (inRange(x, (int) sf - 1, (int) sf + r + 1)) {
            highlightedComponent = HighlightedComponent.LEFT_HOOK;
            currentState = TimelineState.RESIZE_FROM;
        } else if (inRange(x, (int) sf + r, (int) st - r)) {
            highlightedComponent = HighlightedComponent.CENTER_HOOK;
            currentState = TimelineState.MOVING;
        } else if (inRange(x, (int) st - r - 1, (int) st + 1)) {
            highlightedComponent = HighlightedComponent.RIGHT_HOOK;
            currentState = TimelineState.RESIZE_TO;
        }
    }
}

Output:
     int x = e.getX();
-    float w = getWidth();
+    latestMousePositionX = x;
+    currentMousePositionX = latestMousePositionX;
     int r = 16;


Input:
public void execute() throws MojoExecutionException, MojoFailureException {
    getLog().info("String_Node_Str" + destinationDirectory);
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    copyResource("String_Node_Str", "String_Node_Str");
    try {
        compile();
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Output:
     getLog().info("String_Node_Str" + destinationDirectory);
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
     copyResource("String_Node_Str", "String_Node_Str");

     copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
-    copyResource("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
+    copyResourceMinifyJS("String_Node_Str", "String_Node_Str");
     try {


Input:
public void testListenersSmartRoutingMultipleServer() throws InterruptedException {
    factory.newInstances(null, 3);
    ClientConfig clientConfig = createClientConfig();
    client = factory.newHazelcastClient(clientConfig);
    testListenersInternal();
}

Output:
     factory.newInstances(null, 3);
-    ClientConfig clientConfig = createClientConfig();
+    ClientConfig clientConfig = getSmartClientConfig();
     client = factory.newHazelcastClient(clientConfig);


Input:
protected State getNAThingProperty(String channelId) {
    switch(channelId) {
        case CHANNEL_BATTERY_LEVEL:
            return ChannelTypeUtils.toDecimalType(getBatteryPercent());
        case CHANNEL_LOW_BATTERY:
            return module.getBatteryVp() < batteryLow ? OnOffType.ON : OnOffType.OFF;
        case CHANNEL_LAST_MESSAGE:
            return ChannelTypeUtils.toDateTimeType(module.getLastMessage());
        case CHANNEL_RF_STATUS:
            Integer rfStatus = module.getRfStatus();
            return ChannelTypeUtils.toDecimalType(getSignalStrength(rfStatus));
        default:
            return super.getNAThingProperty(channelId);
    }
}

Output:
 protected State getNAThingProperty(String channelId) {
-    switch(channelId) {
-        case CHANNEL_BATTERY_LEVEL:
-            return ChannelTypeUtils.toDecimalType(getBatteryPercent());
-        case CHANNEL_LOW_BATTERY:
-            return module.getBatteryVp() < batteryLow ? OnOffType.ON : OnOffType.OFF;
-        case CHANNEL_LAST_MESSAGE:
-            return ChannelTypeUtils.toDateTimeType(module.getLastMessage());
-        case CHANNEL_RF_STATUS:
-            Integer rfStatus = module.getRfStatus();
-            return ChannelTypeUtils.toDecimalType(getSignalStrength(rfStatus));
-        default:
-            return super.getNAThingProperty(channelId);
+    if (module != null) {
+        switch(channelId) {
+            case CHANNEL_BATTERY_LEVEL:
+                return ChannelTypeUtils.toDecimalType(getBatteryPercent());
+            case CHANNEL_LOW_BATTERY:
+                return module.getBatteryVp() < batteryLow ? OnOffType.ON : OnOffType.OFF;
+            case CHANNEL_LAST_MESSAGE:
+                return ChannelTypeUtils.toDateTimeType(module.getLastMessage());
+            case CHANNEL_RF_STATUS:
+                Integer rfStatus = module.getRfStatus();
+                return ChannelTypeUtils.toDecimalType(getSignalStrength(rfStatus));
+        }
     }


Input:
public static String toString(Object target, Class stopClass, Map<String, Object> overrideFields) {
    LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
    addFields(target, target.getClass(), stopClass, map);
    if (overrideFields != null) {
        for (String key : overrideFields.keySet()) {
            Object value = overrideFields.get(key);
            map.put(key, value);
        }
    }
    StringBuffer buffer = new StringBuffer(simpleName(target.getClass()));
    buffer.append("String_Node_Str");
    Set<Entry<String, Object>> entrySet = map.entrySet();
    boolean first = true;
    for (Map.Entry<String, Object> entry : entrySet) {
        Object value = entry.getValue();
        Object key = entry.getKey();
        if (first) {
            first = false;
        } else {
            buffer.append("String_Node_Str");
        }
        buffer.append(key);
        buffer.append("String_Node_Str");
        appendToString(buffer, key, value);
    }
    buffer.append("String_Node_Str");
    return buffer.toString();
}

Output:
     if (overrideFields != null) {
-        for (String key : overrideFields.keySet()) {
-            Object value = overrideFields.get(key);
-            map.put(key, value);
+        for (Entry<String, Object> entry : overrideFields.entrySet()) {
+            map.put(entry.getKey(), entry.getValue());
         }


Input:
public List<ForeignKey> getForeignKeys(String catalogName, String schemaPattern, String tableName) throws SQLException {
    List<ForeignKey> pks = new ArrayList<ForeignKey>();
    ResultSet foreignKeys = null;
    try {
        foreignKeys = ConnectionUtils.getConnectionMetadata(connection).getImportedKeys(catalogName, schemaPattern, tableName);
        try {
            while (foreignKeys.next()) {
                ForeignKey pk = createForeignKey(foreignKeys);
                pks.add(pk);
            }
        } catch (SQLException e) {
            throw e;
        } finally {
            foreignKeys.close();
        }
    } catch (Exception e1) {
        log.warn("String_Node_Str", e1);
    }
    return pks;
}

Output:
         } finally {
-            foreignKeys.close();
+            if (foreignKeys != null) {
+                foreignKeys.close();
+            }
         }


Input:
public static Long parseTo_Long(String s) {
    if (s == null) {
        return null;
    }
    return parseTo_long(s);
}

Output:
     }
-    return parseTo_long(s);
+    return parseTo_long(s, isDecode);
 }


Input:
private void marshal(Object object, MarshalRecord marshalRecord, AbstractSession session, XMLDescriptor descriptor, boolean isXMLRoot) {
    if (getAttachmentMarshaller() != null) {
        marshalRecord.setXOPPackage(getAttachmentMarshaller().isXOPPackage());
    }
    addDescriptorNamespacesToXMLRecord(descriptor, marshalRecord);
    NamespaceResolver nr = marshalRecord.getNamespaceResolver();
    XMLRoot root = null;
    if (isXMLRoot) {
        root = (XMLRoot) object;
    }
    if (getMarshalListener() != null) {
        getMarshalListener().beforeMarshal(object);
    }
    if (!isFragment()) {
        String encoding = getEncoding();
        String version = DEFAULT_XML_VERSION;
        if (!isXMLRoot) {
            marshalRecord.setLeafElementType(descriptor.getDefaultRootElementType());
        } else {
            if (root.getEncoding() != null) {
                encoding = root.getEncoding();
            }
            if (root.getXMLVersion() != null) {
                version = root.getXMLVersion();
            }
        }
        marshalRecord.startDocument(encoding, version);
    }
    if (isXMLRoot) {
        if (root.getObject() instanceof Node) {
            marshalRecord.node((Node) root.getObject(), new NamespaceResolver());
            marshalRecord.endDocument();
            return;
        }
    }
    XPathFragment rootFragment = buildRootFragment(object, descriptor, isXMLRoot, marshalRecord);
    String schemaLocation = getSchemaLocation();
    String noNsSchemaLocation = getNoNamespaceSchemaLocation();
    if (isXMLRoot) {
        object = root.getObject();
        if (root.getSchemaLocation() != null) {
            schemaLocation = root.getSchemaLocation();
        }
        if (root.getNoNamespaceSchemaLocation() != null) {
            noNsSchemaLocation = root.getNoNamespaceSchemaLocation();
        }
        marshalRecord.setLeafElementType(root.getSchemaType());
    }
    String xsiPrefix = null;
    if ((null != getSchemaLocation()) || (null != getNoNamespaceSchemaLocation())) {
        xsiPrefix = nr.resolveNamespaceURI(XMLConstants.SCHEMA_INSTANCE_URL);
        if (null == xsiPrefix) {
            xsiPrefix = XMLConstants.SCHEMA_INSTANCE_PREFIX;
            nr.put(XMLConstants.SCHEMA_INSTANCE_PREFIX, XMLConstants.SCHEMA_INSTANCE_URL);
        }
    }
    TreeObjectBuilder treeObjectBuilder = null;
    if (descriptor != null) {
        treeObjectBuilder = (TreeObjectBuilder) descriptor.getObjectBuilder();
    }
    if (session == null) {
        session = (AbstractSession) xmlContext.getSession(0);
    }
    marshalRecord.setSession(session);
    if (null != rootFragment) {
        marshalRecord.startPrefixMappings(nr);
        if (!isXMLRoot && descriptor.getNamespaceResolver() == null && rootFragment.hasNamespace()) {
            throw XMLMarshalException.namespaceResolverNotSpecified(rootFragment.getShortName());
        }
        marshalRecord.openStartElement(rootFragment, nr);
        if (null != schemaLocation) {
            marshalRecord.attribute(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_LOCATION, xsiPrefix + XMLConstants.COLON + XMLConstants.SCHEMA_LOCATION, schemaLocation);
        }
        if (null != noNsSchemaLocation) {
            marshalRecord.attribute(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.NO_NS_SCHEMA_LOCATION, xsiPrefix + XMLConstants.COLON + XMLConstants.NO_NS_SCHEMA_LOCATION, noNsSchemaLocation);
        }
        marshalRecord.namespaceDeclarations(nr);
        if (descriptor != null) {
            treeObjectBuilder.addXsiTypeAndClassIndicatorIfRequired(marshalRecord, descriptor, null, null, root, object, isXMLRoot, true);
            treeObjectBuilder.marshalAttributes(marshalRecord, object, session);
        }
        marshalRecord.closeStartElement();
    }
    if (treeObjectBuilder != null) {
        treeObjectBuilder.buildRow(marshalRecord, object, session, this, rootFragment, WriteType.UNDEFINED);
    } else if (isXMLRoot) {
        if (null == object) {
            marshalRecord.attribute(XMLConstants.XMLNS_URL, XMLConstants.SCHEMA_INSTANCE_PREFIX, XMLConstants.XMLNS + XMLConstants.COLON + XMLConstants.SCHEMA_INSTANCE_PREFIX, XMLConstants.SCHEMA_INSTANCE_URL);
            marshalRecord.attribute(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_NIL_ATTRIBUTE, XMLConstants.SCHEMA_INSTANCE_PREFIX + XMLConstants.COLON + XMLConstants.SCHEMA_NIL_ATTRIBUTE, "String_Node_Str");
        } else {
            if (root.getDeclaredType() != null && root.getObject() != null && root.getDeclaredType() != root.getObject().getClass()) {
                QName type = (QName) XMLConversionManager.getDefaultJavaTypes().get(object.getClass());
                if (type != null) {
                    xsiPrefix = nr.resolveNamespaceURI(XMLConstants.SCHEMA_INSTANCE_URL);
                    if (null == xsiPrefix) {
                        xsiPrefix = XMLConstants.SCHEMA_INSTANCE_PREFIX;
                        marshalRecord.attribute(XMLConstants.XMLNS_URL, xsiPrefix, XMLConstants.XMLNS + ':' + xsiPrefix, XMLConstants.SCHEMA_INSTANCE_URL);
                    }
                    marshalRecord.attribute(XMLConstants.XMLNS_URL, XMLConstants.SCHEMA_PREFIX, XMLConstants.XMLNS + ':' + XMLConstants.SCHEMA_PREFIX, XMLConstants.SCHEMA_URL);
                    marshalRecord.attribute(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE, xsiPrefix + "String_Node_Str" + XMLConstants.SCHEMA_TYPE_ATTRIBUTE, "String_Node_Str" + type.getLocalPart());
                }
            }
            String value = (String) XMLConversionManager.getDefaultXMLManager().convertObject(object, String.class, root.getSchemaType());
            marshalRecord.characters(value);
        }
    }
    if (null != rootFragment) {
        marshalRecord.endElement(rootFragment, nr);
        marshalRecord.endPrefixMappings(nr);
    }
    if (!isFragment()) {
        marshalRecord.endDocument();
    }
    if (getMarshalListener() != null) {
        getMarshalListener().afterMarshal(object);
    }
}

Output:
     String xsiPrefix = null;
-    if ((null != getSchemaLocation()) || (null != getNoNamespaceSchemaLocation())) {
+    if ((null != getSchemaLocation()) || (null != getNoNamespaceSchemaLocation()) || (isNil)) {
         xsiPrefix = nr.resolveNamespaceURI(XMLConstants.SCHEMA_INSTANCE_URL);


Input:
void invalidate() {
    synchronized (ContactsCache.this) {
        for (ArrayList<Contact> alc : mContactsHash.values()) {
            for (Contact c : alc) {
                c.mIsStale = true;
            }
        }
    }
}

Output:
             for (Contact c : alc) {
-                c.mIsStale = true;
+                synchronized (c) {
+                    c.mIsStale = true;
+                }
             }


Input:
public void setDirty(boolean b) {
    if (!isDirty) {
        isDirty = true;
        context.getSession().internalGetCache().addGeneric(this);
        getPrevValues();
    }
}

Output:
         context.getSession().internalGetCache().addGeneric(this);
-        getPrevValues();
+        if (!isNew) {
+            getPrevValues();
+        }
     }


Input:
public void writeCacheByte(byte b) throws IOException {
    int pageIndex = (int) (pos >> PAGE_SHIFT);
    int offset = (int) (pos & PAGE_MASK);
    byte[] page = getPage(pageIndex);
    page[offset] = b;
    file.seek(pos);
    file.writeByte(b & 0xFF);
    pos++;
}

Output:
     page[offset] = b;
-    file.seek(pos);
+    if (posDirty) {
+        file.seek(pos);
+        posDirty = false;
+    }
     file.writeByte(b & 0xFF);


Input:
public static Neo4jService getService(final HttpServletRequest request) {
    HttpSession session = request.getSession(true);
    Neo4jService service = (Neo4jService) session.getAttribute(SERVICE);
    if (service != null)
        return service;
    service = databaseInfo.shouldCreateNew() ? new Neo4jService() : new Neo4jService(databaseInfo.getDatabase());
    if (databaseInfo.shouldImport()) {
        service.initializeFrom(SubGraph.from(databaseInfo.getDatabase()));
    }
    session.setAttribute(SERVICE, service);
    return service;
}

Output:
 public static Neo4jService getService(final HttpServletRequest request) {
-    HttpSession session = request.getSession(true);
-    Neo4jService service = (Neo4jService) session.getAttribute(SERVICE);
-    if (service != null)
+    try {
+        HttpSession session = request.getSession(true);
+        Neo4jService service = (Neo4jService) session.getAttribute(SERVICE);
+        if (service != null)
+            return service;
+        service = databaseInfo.shouldCreateNew() ? new Neo4jService() : new Neo4jService(databaseInfo.getDatabase());
+        if (databaseInfo.shouldImport()) {
+            service.initializeFrom(SubGraph.from(databaseInfo.getDatabase()));
+        }
+        session.setAttribute(SERVICE, service);
         return service;


Input:
private boolean checkDoubleJump(Point check) {
    int checkX = (int) check.getX();
    int checkY = (int) check.getY();
    int thisCheck = boardState[checkX][checkY];
    for (int dX = -1; dX <= 1; dX++) {
        for (int dY = -1; dY <= 1; dY++) {
            if (dX != 0 && dY != 0) {
                Point moveTo = new Point((int) check.getX() + dX, (int) check.getY() + dY);
                if (isPointInBounds(moveTo)) {
                    if (thisCheck == BLACK_CHECK && dX > 0) {
                        if (ableToJump(check, moveTo))
                            return true;
                    } else if (thisCheck == RED_CHECK && dX < 0) {
                        if (ableToJump(check, moveTo))
                            return true;
                    } else {
                        if (ableToJump(check, moveTo))
                            return true;
                    }
                }
            }
        }
    }
    return false;
}

Output:
             if (dX != 0 && dY != 0) {
-                Point moveTo = new Point((int) check.getX() + dX, (int) check.getY() + dY);
+                Point moveTo = new Point(checkX + dX, checkY + dY);
                 if (isPointInBounds(moveTo)) {


Input:
public static void installI18nMessages(I18n i18n, ProjectOperations projectOperations, FileManager fileManager) {
    Validate.notNull(i18n, "String_Node_Str");
    if (i18n.getLocale() == null) {
        logger.warning("String_Node_Str");
        return;
    }
    String targetDirectory = projectOperations.getPathResolver().getIdentifier(LogicalPath.getInstance(Path.SRC_MAIN_WEBAPP, "String_Node_Str"), "String_Node_Str");
    String messageBundle = targetDirectory + "String_Node_Str" + i18n.getLocale().getLanguage() + "String_Node_Str";
    if (i18n.getLocale().equals(Locale.ENGLISH)) {
        messageBundle = targetDirectory + "String_Node_Str";
    }
    if (!fileManager.exists(messageBundle)) {
        OutputStream outputStream = null;
        try {
            outputStream = fileManager.createFile(messageBundle).getOutputStream();
            IOUtils.copy(i18n.getMessageBundle(), outputStream);
        } catch (IOException e) {
            throw new IllegalStateException("String_Node_Str", e);
        } finally {
            IOUtils.closeQuietly(outputStream);
        }
    }
    return;
}

Output:
     }
-    String targetDirectory = projectOperations.getPathResolver().getIdentifier(LogicalPath.getInstance(Path.SRC_MAIN_WEBAPP, "String_Node_Str"), "String_Node_Str");
-    String messageBundle = targetDirectory + "String_Node_Str" + i18n.getLocale().getLanguage() + "String_Node_Str";
+    LogicalPath webappPath = WebProjectUtils.getWebappPath(projectOperations);
+    String targetDirectory = projectOperations.getPathResolver().getIdentifier(webappPath, "String_Node_Str");
+    String messageBundle = targetDirectory.concat("String_Node_Str").concat(i18n.getLocale().getLanguage()).concat("String_Node_Str");
     if (i18n.getLocale().equals(Locale.ENGLISH)) {


Input:
public Long getPageSizeVal() {
    Long defaultPageSize = MAX_PAGESIZE;
    Integer pageSizeInt = getPageSize();
    if (pageSizeInt != null && pageSizeInt.intValue() != -1) {
        defaultPageSize = pageSizeInt.longValue();
    }
    return defaultPageSize;
}

Output:
     Integer pageSizeInt = getPageSize();
-    if (pageSizeInt != null && pageSizeInt.intValue() != -1) {
-        defaultPageSize = pageSizeInt.longValue();
+    if (pageSizeInt != null) {
+        if (pageSizeInt.longValue() == PAGESIZE_UNLIMITED) {
+            defaultPageSize = null;
+        } else {
+            defaultPageSize = pageSizeInt.longValue();
+        }
     }


Input:
public ArrayList<ItemStack> harvestPlant(Point3I plantPoint, Block plantBlock, int metadata, World worldObj) {
    if ((plantBlock == Blocks.reeds) || (plantBlock == Blocks.cactus)) {
        plantPoint.setY(plantPoint.getY() + 1);
        plantBlock = worldObj.getBlock(plantPoint.getX(), plantPoint.getY(), plantPoint.getZ());
        metadata = worldObj.getBlockMetadata(plantPoint.getX(), plantPoint.getY(), plantPoint.getZ());
    }
    return super.harvestPlant(plantPoint, plantBlock, metadata, worldObj);
}

Output:
         plantPoint.setY(plantPoint.getY() + 1);
-        plantBlock = worldObj.getBlock(plantPoint.getX(), plantPoint.getY(), plantPoint.getZ());
-        metadata = worldObj.getBlockMetadata(plantPoint.getX(), plantPoint.getY(), plantPoint.getZ());
+        state = worldObj.getBlockState(plantPoint.toPosition());
+        plantBlock = state.getBlock();
     }


Input:
public ClusterTree importDimensionTree(String fileName) throws JAXBException, FileNotFoundException {
    ClusterTree tree = importTree(fileName, dataDomain.getDimensionIDType());
    org.caleydo.core.data.collection.table.DataTable set = (org.caleydo.core.data.collection.table.DataTable) dataDomain.getTable();
    tree.createSubDataTables(set);
    return tree;
}

Output:
     ClusterTree tree = importTree(fileName, dataDomain.getDimensionIDType());
-    org.caleydo.core.data.collection.table.DataTable set = (org.caleydo.core.data.collection.table.DataTable) dataDomain.getTable();
-    tree.createSubDataTables(set);
+    org.caleydo.core.data.collection.table.DataTable table = (org.caleydo.core.data.collection.table.DataTable) dataDomain.getTable();
+    tree.createSubDataTables(table);
     return tree;


Input:
public static void main(String[] argv) {
    if (argv.length != 1) {
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str");
        System.exit(1);
    }
    try {
        DataSource dataSource = DatabaseManager.initDataSource();
        String url = ConfigurationManager.getProperty("String_Node_Str");
        Flyway flyway = setupFlyway(dataSource);
        if (argv[0].equalsIgnoreCase("String_Node_Str")) {
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str" + url);
            System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));
            System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));
            System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));
            System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));
            System.out.println("String_Node_Str");
            try {
                Connection connection = dataSource.getConnection();
                connection.close();
            } catch (SQLException sqle) {
                System.err.println("String_Node_Str");
                System.err.println("String_Node_Str" + sqle);
                System.err.println("String_Node_Str");
                System.exit(1);
            }
            System.out.println("String_Node_Str");
        } else if (argv[0].equalsIgnoreCase("String_Node_Str")) {
            Connection connection = dataSource.getConnection();
            DatabaseMetaData meta = connection.getMetaData();
            System.out.println("String_Node_Str" + url);
            System.out.println("String_Node_Str" + meta.getDatabaseProductName() + "String_Node_Str" + meta.getDatabaseProductVersion());
            System.out.println("String_Node_Str" + meta.getDriverName() + "String_Node_Str" + meta.getDriverVersion());
            System.out.println("String_Node_Str" + MigrationInfoDumper.dumpToAsciiTable(flyway.info().all()));
            if (!tableExists(connection, flyway.getTable())) {
                System.out.println("String_Node_Str");
                String dbVersion = determineDBVersion(connection);
                if (dbVersion != null) {
                    System.out.println("String_Node_Str" + dbVersion);
                    System.out.println("String_Node_Str" + dbVersion + "String_Node_Str");
                }
            }
            connection.close();
        } else if (argv[0].equalsIgnoreCase("String_Node_Str")) {
            System.out.println("String_Node_Str" + url);
            System.out.println("String_Node_Str");
            DatabaseManager.getDbName();
            System.out.println("String_Node_Str");
        } else if (argv[0].equalsIgnoreCase("String_Node_Str")) {
            System.out.println("String_Node_Str" + url);
            System.out.println("String_Node_Str");
            flyway.repair();
            System.out.println("String_Node_Str");
        } else if (argv[0].equalsIgnoreCase("String_Node_Str")) {
            BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("String_Node_Str" + url);
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.print("String_Node_Str");
            String choiceString = input.readLine();
            input.close();
            if (choiceString.equalsIgnoreCase("String_Node_Str")) {
                System.out.println("String_Node_Str");
                cleanDatabase(flyway, dataSource);
                System.out.println("String_Node_Str");
            }
        } else {
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
        }
        System.exit(0);
    } catch (Exception e) {
        System.err.println("String_Node_Str");
        e.printStackTrace();
        System.exit(1);
    }
}

Output:
             System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));
-            System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));
+            System.out.println("String_Node_Str");
             System.out.println("String_Node_Str" + ConfigurationManager.getProperty("String_Node_Str"));


Input:
protected void executeOperator(Product targetProduct, ProgressHandleMonitor pm) throws Exception {
    final TargetProductSelectorModel model = getTargetProductSelector().getModel();
    Operator execOp = null;
    if (targetProduct.getProductReader() instanceof OperatorProductReader) {
        final OperatorProductReader opReader = (OperatorProductReader) targetProduct.getProductReader();
        Operator operator = opReader.getOperatorContext().getOperator();
        boolean autoWriteDisabled = operator.getSpi().getOperatorDescriptor().isAutoWriteDisabled();
        if (autoWriteDisabled) {
            execOp = operator;
        }
    }
    if (execOp == null) {
        WriteOp writeOp = new WriteOp(targetProduct, model.getProductFile(), model.getFormatName());
        writeOp.setDeleteOutputOnFailure(true);
        writeOp.setWriteEntireTileRows(true);
        writeOp.setClearCacheAfterRowWrite(false);
        execOp = writeOp;
    }
    final OperatorExecutor executor = OperatorExecutor.create(execOp);
    executor.execute(SubProgressMonitor.create(pm, 95));
}

Output:
     final OperatorExecutor executor = OperatorExecutor.create(execOp);
-    executor.execute(SubProgressMonitor.create(pm, 95));
+    SubProgressMonitor pm2 = (SubProgressMonitor) SubProgressMonitor.create(pm, 95);
+    if (execOp instanceof StoredGraphOp) {
+        executor.execute(ProgressMonitor.NULL);
+        pm2.beginTask("String_Node_Str", 1);
+        pm2.worked(1);
+    } else {
+        executor.execute(pm2);
+    }
+    pm2.done();
 }


Input:
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float fX, float fY, float fZ) {
    boolean update = false;
    if (!world.isRemote) {
        TileEntityTank tank = (TileEntityTank) world.getTileEntity(x, y, z);
        ItemStack stack = player.getCurrentEquippedItem();
        if (stack != null && stack.getItem() != null) {
            FluidStack liquid = FluidContainerRegistry.getFluidForFilledItem(stack);
            if (liquid != null && liquid.getFluid() == FluidRegistry.WATER) {
                int quantity = tank.fill(ForgeDirection.UNKNOWN, liquid, false);
                if (quantity == liquid.amount) {
                    tank.fill(ForgeDirection.UNKNOWN, liquid, true);
                    update = true;
                    if (!player.capabilities.isCreativeMode) {
                        if (stack.stackSize == 1) {
                            if (stack.getItem().hasContainerItem(stack)) {
                                player.inventory.setInventorySlotContents(player.inventory.currentItem, stack.getItem().getContainerItem(stack));
                            } else {
                                player.inventory.setInventorySlotContents(player.inventory.currentItem, null);
                            }
                        } else {
                            stack.splitStack(1);
                            player.inventory.setInventorySlotContents(player.inventory.currentItem, stack);
                        }
                    }
                }
            } else {
                FluidStack tankContents = tank.getTankInfo(ForgeDirection.UNKNOWN)[0].fluid;
                if (tankContents != null) {
                    ItemStack filledContainer = FluidContainerRegistry.fillFluidContainer(tankContents, stack);
                    FluidStack filledLiquid = FluidContainerRegistry.getFluidForFilledItem(filledContainer);
                    if (filledLiquid != null) {
                        if (!player.capabilities.isCreativeMode) {
                            if (stack.stackSize == 1) {
                                if (stack.getItem().hasContainerItem(stack)) {
                                    player.inventory.setInventorySlotContents(player.inventory.currentItem, stack.getItem().getContainerItem(stack));
                                } else {
                                    player.inventory.setInventorySlotContents(player.inventory.currentItem, null);
                                }
                                player.inventory.setInventorySlotContents(player.inventory.currentItem, filledContainer);
                            } else {
                                if (!player.inventory.addItemStackToInventory(filledContainer)) {
                                    return false;
                                } else {
                                    stack.splitStack(1);
                                    player.inventory.setInventorySlotContents(player.inventory.currentItem, stack);
                                    player.inventory.addItemStackToInventory(filledContainer);
                                    player.inventory.markDirty();
                                }
                            }
                        }
                        tank.drain(ForgeDirection.UNKNOWN, filledLiquid.amount, true);
                        update = true;
                    }
                }
            }
        }
        if (update) {
            tank.markDirty();
            world.markBlockForUpdate(x, y, z);
            return true;
        } else {
            return false;
        }
    }
    return true;
}

Output:
         if (update) {
-            tank.markDirty();
+            tank.markDirtyAndMarkForUpdate();
             world.markBlockForUpdate(x, y, z);


Input:
public CSharpXXXAccessorStub deserialize(StubInputStream inputStream, StubElement stubElement) throws IOException {
    StringRef name = inputStream.readName();
    int otherModifiers = inputStream.readInt();
    return new CSharpXXXAccessorStub(stubElement, name, otherModifiers);
}

Output:
     int otherModifiers = inputStream.readInt();
-    return new CSharpXXXAccessorStub(stubElement, name, otherModifiers);
+    return new CSharpXXXAccessorStub(stubElement, otherModifiers);
 }


Input:
public void stop(Throwable cause) throws Exception {
    LOGGER.log(Level.FINE, "String_Node_Str");
    closeQuietly(client, decorator);
}

Output:
     LOGGER.log(Level.FINE, "String_Node_Str");
-    closeQuietly(client, decorator);
+    closeQuietly(client);
 }


Input:
public void checkRandomClick2Download() throws InterruptedException {
    String statusBtnUiSelector = "String_Node_Str";
    List<AndroidElement> eListStatusBtn = mDriver.findElementsByAndroidUIAutomator(statusBtnUiSelector);
    assertEquals(eListStatusBtn.size() > 0, true);
    AndroidElement targetElement = eListStatusBtn.get(RandomUtil.getRandomNum(eListStatusBtn.size() - 1));
    assertEquals(targetElement.getText(), "String_Node_Str");
    targetElement.click();
    mDriver.findElement(By.id("String_Node_Str")).click();
    WaitUtil.forceWait(2);
    assertEquals(targetElement.getText(), "String_Node_Str");
    targetElement.click();
    WaitUtil.forceWait(1);
    assertEquals(targetElement.getText(), "String_Node_Str");
}

Output:
     assertEquals(eListStatusBtn.size() > 0, true);
-    AndroidElement targetElement = eListStatusBtn.get(RandomUtil.getRandomNum(eListStatusBtn.size() - 1));
+    int randomInder = RandomUtil.getRandomNum(eListStatusBtn.size() - 1);
+    AndroidElement targetElement = eListStatusBtn.get(randomInder);
     assertEquals(targetElement.getText(), "String_Node_Str");


Input:
public void setID(String ID) {
    this.ID = (ID == null ? "String_Node_Str" : ID.trim());
}

Output:
 public void setID(String ID) {
-    this.ID = (ID == null ? "String_Node_Str" : ID.trim());
+    this.ID = (ID == null ? null : ID.trim());
 }