Input:
public HearthTreeNode performAction(Minion minion, PlayerSide playerSide, HearthTreeNode boardState, Deck deckPlayer0, Deck deckPlayer1) throws HSException {
    HearthTreeNode toRet = super.performAction(minion, playerSide, boardState, deckPlayer0, deckPlayer1);
    for (int index = 0; index < numMinions_; ++index) {
        try {
            Minion newMinion = (Minion) minionClass_.newInstance();
            Minion placementTarget = toRet.data_.getCharacter(playerSide, toRet.data_.getMinions(playerSide).indexOf(minion));
            toRet.data_.removeMinion(minion);
            toRet = newMinion.summonMinion(playerSide, placementTarget, toRet, deckPlayer0, deckPlayer1, false, true);
        } catch (InstantiationException | IllegalAccessException e) {
            throw new HSException();
        }
    }
    return toRet;
}

Output:
     HearthTreeNode toRet = super.performAction(minion, playerSide, boardState, deckPlayer0, deckPlayer1);
-    for (int index = 0; index < numMinions_; ++index) {
+    Minion placementTarget = toRet.data_.getCharacter(playerSide, toRet.data_.getMinions(playerSide).indexOf(minion));
+    toRet.data_.removeMinion(minion);
+    int numMinionsToActuallySummon = numMinions_;
+    if (playerSide.getPlayer(toRet).getMinions().size() + numMinions_ > 7)
+        numMinionsToActuallySummon = 7 - playerSide.getPlayer(toRet).getMinions().size();
+    for (int index = 0; index < numMinionsToActuallySummon; ++index) {
         try {


Input:
public void characters(char[] ch, int start, int length) throws SAXException {
    tempValue = new String(ch, start, length);
}

Output:
 public void characters(char[] ch, int start, int length) throws SAXException {
-    tempValue = new String(ch, start, length);
+    if (tempValue == null) {
+        tempValue = new StringBuilder();
+    }
+    tempValue.append(new String(ch, start, length));
 }


Input:
public static ThingListing get(Context context, String accountName, String sessionId, String subredditName, int filter, String more, String query, String cookie) throws IOException {
    long t1 = System.currentTimeMillis();
    URL url;
    if (!TextUtils.isEmpty(query)) {
        url = Urls.searchUrl(query, more);
    } else {
        url = Urls.subredditUrl(subredditName, filter, more);
    }
    HttpURLConnection conn = RedditApi.connect(url, cookie, false);
    InputStream input = new BufferedInputStream(conn.getInputStream());
    long t2 = System.currentTimeMillis();
    try {
        JsonReader reader = new JsonReader(new InputStreamReader(input));
        ThingListing listing = new ThingListing(context, accountName, sessionId, t1);
        listing.parseListingObject(reader);
        if (BuildConfig.DEBUG) {
            long t3 = System.currentTimeMillis();
            listing.networkTimeMs = t2 - t1;
            listing.parseTimeMs = t3 - t2;
        }
        return listing;
    } finally {
        input.close();
        conn.disconnect();
    }
}

Output:
         JsonReader reader = new JsonReader(new InputStreamReader(input));
-        ThingListing listing = new ThingListing(context, accountName, sessionId, t1);
+        ThingListing listing = new ThingListing(context, accountName, sessionId, sessionTimestamp);
         listing.parseListingObject(reader);


Input:
public boolean isFileAddable(File file) {
    if (file == null) {
        return false;
    }
    if (file.isDirectory()) {
        return isDirectoryAllowed(file);
    }
    Category category = categoryManager.getCategoryForExtension(FileUtils.getFileExtension(file));
    if (category == Category.PROGRAM && !LibrarySettings.ALLOW_PROGRAMS.getValue()) {
        return false;
    }
    return true;
}

Output:
     }
-    Category category = categoryManager.getCategoryForExtension(FileUtils.getFileExtension(file));
+    Category category = categoryManager.getCategoryForFile(file);
     if (category == Category.PROGRAM && !LibrarySettings.ALLOW_PROGRAMS.getValue()) {


Input:
private void simulateNetworkLatency() {
    try {
        int i = 0;
        System.out.println();
        while (i < 10) {
            System.out.print("String_Node_Str");
            Thread.currentThread().sleep(500);
            i++;
        }
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    }
}

Output:
             System.out.print("String_Node_Str");
-            Thread.currentThread().sleep(500);
+            Thread.sleep(500);
             i++;


Input:
private void addParticleDetail(XSDSchema xsdSchema, XSDParticle xsdParticle, ATreeNode parentNode, String currentPath) throws OdaException, IllegalAccessException, InvocationTargetException {
    XSDTerm xsdTerm = xsdParticle.getTerm();
    if (xsdTerm instanceof XSDElementDeclaration) {
        XSDElementDeclaration xsdElementDeclarationParticle = (XSDElementDeclaration) xsdTerm;
        if (particleToTreeNode.containsKey(xsdElementDeclarationParticle)) {
            ATreeNode originalTreeNode = particleToTreeNode.get(xsdElementDeclarationParticle);
            ATreeNode partNode = new ATreeNode();
            partNode.setCurrentNamespace(originalTreeNode.getCurrentNamespace());
            partNode.setValue(originalTreeNode.getValue());
            partNode.setType(ATreeNode.ELEMENT_TYPE);
            partNode.setDataType(originalTreeNode.getDataType());
            partNode.addChild(originalTreeNode.getChildren());
            parentNode.addChild(partNode);
            return;
        }
        ATreeNode partNode = new ATreeNode();
        particleToTreeNode.put(xsdElementDeclarationParticle, partNode);
        String elementName = xsdElementDeclarationParticle.getName();
        String prefix = null;
        String namespace = xsdElementDeclarationParticle.getTargetNamespace();
        XSDTypeDefinition typeDef = xsdElementDeclarationParticle.getTypeDefinition();
        if (typeDef == null) {
            XSDSchema schemaFromNamespace = getXSDSchemaFromNamespace(namespace);
            if (schemaFromNamespace == null) {
                schemaFromNamespace = xsdSchema;
            }
            xsdElementDeclarationParticle = schemaFromNamespace.resolveElementDeclarationURI(xsdElementDeclarationParticle.getURI());
            typeDef = xsdElementDeclarationParticle.getTypeDefinition();
        }
        String typeNamespace = typeDef.getTargetNamespace();
        if (typeNamespace != null && !typeNamespace.equals(namespace)) {
            XSDSchema schemaOfType = getXSDSchemaFromNamespace(typeNamespace);
            if (schemaOfType != null) {
                XSDTypeDefinition typeDefinition = schemaOfType.resolveComplexTypeDefinitionURI(typeDef.getURI());
                if (typeDefinition != null && typeDefinition.getContainer() != null) {
                    typeDef = typeDefinition;
                }
            }
        }
        if (namespace != null) {
            prefix = namespaceToPrefix.get(namespace);
            if (prefix == null) {
                prefix = ((XSDElementDeclaration) xsdTerm).getQName().contains("String_Node_Str") ? ((XSDElementDeclaration) xsdTerm).getQName().split("String_Node_Str")[0] : "String_Node_Str";
                if (isEnableGeneratePrefix() && (prefix == null || prefix.isEmpty())) {
                    prefix = "String_Node_Str" + prefixNumberGenerated;
                    prefixNumberGenerated++;
                }
                if (namespaceToPrefix.containsValue(prefix)) {
                    prefix = prefix + prefixNumberGenerated;
                    prefixNumberGenerated++;
                }
                if (prefix != null && !prefix.isEmpty()) {
                    namespaceToPrefix.put(namespace, prefix);
                } else {
                    ATreeNode namespaceNode = new ATreeNode();
                    namespaceNode.setDataType("String_Node_Str");
                    namespaceNode.setType(ATreeNode.NAMESPACE_TYPE);
                    namespaceNode.setValue(namespace);
                    partNode.addChild(namespaceNode);
                }
            }
        }
        partNode.setCurrentNamespace(namespace);
        if (prefix != null && !prefix.isEmpty()) {
            elementName = prefix + "String_Node_Str" + elementName;
        }
        partNode.setValue(elementName);
        partNode.setType(ATreeNode.ELEMENT_TYPE);
        partNode.setDataType(xsdElementDeclarationParticle.getName());
        parentNode.addChild(partNode);
        boolean resolvedAsComplex = false;
        if (typeDef instanceof XSDComplexTypeDefinition) {
            if (!currentPath.contains("String_Node_Str" + elementName + "String_Node_Str")) {
                String path = currentPath + elementName + "String_Node_Str";
                XSDTypeDefinition xsdTypeDefinition = typeDef;
                if (xsdTypeDefinition != null && xsdTypeDefinition.getName() != null) {
                    partNode.setDataType(xsdTypeDefinition.getQName());
                }
                addComplexTypeDetails(xsdSchema, partNode, xsdTypeDefinition, prefix, namespace, path);
            }
            resolvedAsComplex = true;
        } else if (typeDef.getTargetNamespace() != null) {
            resolvedAsComplex = true;
            if (!currentPath.contains("String_Node_Str" + elementName + "String_Node_Str")) {
                String path = currentPath + elementName + "String_Node_Str";
                XSDComplexTypeDefinition generalType = xsdSchema.resolveComplexTypeDefinition(typeDef.getQName());
                XSDTypeDefinition xsdTypeDefinition = xsdElementDeclarationParticle.getTypeDefinition();
                if (generalType.getContainer() != null) {
                    xsdTypeDefinition = generalType;
                }
                if (xsdTypeDefinition != null && xsdTypeDefinition.getName() != null) {
                    partNode.setDataType(xsdTypeDefinition.getName());
                }
                if (xsdTypeDefinition instanceof XSDComplexTypeDefinition) {
                    addComplexTypeDetails(xsdSchema, partNode, xsdTypeDefinition, prefix, namespace, path);
                } else {
                    resolvedAsComplex = false;
                }
            }
        }
        if (!resolvedAsComplex) {
            String dataType = xsdElementDeclarationParticle.getTypeDefinition().getQName();
            if (!XSDConstants.isSchemaForSchemaNamespace(xsdElementDeclarationParticle.getTypeDefinition().getTargetNamespace()) && xsdElementDeclarationParticle.getTypeDefinition().getBaseType() != null) {
                if (!"String_Node_Str".equals(xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName())) {
                    dataType = xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName();
                }
            }
            partNode.setDataType(dataType);
        }
        handleOptionalAttribute(partNode, xsdParticle);
        addSubstitutionDetails(xsdSchema, partNode, xsdElementDeclarationParticle, null);
    } else if (xsdTerm instanceof XSDModelGroup) {
        XSDModelGroup xsdModelGroup = (XSDModelGroup) xsdTerm;
        ATreeNode node = addChoiceDetails(parentNode, xsdModelGroup);
        handleOptionalAttribute(node, xsdParticle);
        for (Object element : xsdModelGroup.getParticles()) {
            XSDParticle childParticle = (XSDParticle) element;
            addParticleDetail(xsdSchema, childParticle, node, currentPath);
        }
    }
}

Output:
                 } else {
-                    ATreeNode namespaceNode = new ATreeNode();
-                    namespaceNode.setDataType("String_Node_Str");
-                    namespaceNode.setType(ATreeNode.NAMESPACE_TYPE);
-                    namespaceNode.setValue(namespace);
-                    partNode.addChild(namespaceNode);
+                    boolean namespaceFoundInParent = false;
+                    ATreeNode node = parentNode;
+                    do {
+                        for (Object child : node.getChildren()) {
+                            if (child instanceof ATreeNode) {
+                                ATreeNode childNode = (ATreeNode) child;
+                                if (childNode.getType() == ATreeNode.NAMESPACE_TYPE && namespace.equals(childNode.getValue())) {
+                                    namespaceFoundInParent = true;
+                                    break;
+                                }
+                            }
+                        }
+                        node = node.getParent();
+                    } while (node != null && !namespaceFoundInParent);
+                    if (!namespaceFoundInParent) {
+                        ATreeNode namespaceNode = new ATreeNode();
+                        namespaceNode.setDataType("String_Node_Str");
+                        namespaceNode.setType(ATreeNode.NAMESPACE_TYPE);
+                        namespaceNode.setValue(namespace);
+                        partNode.addChild(namespaceNode);
+                    }
                 }


Input:
public JobSubmissionResult submitJob() throws IOException {
    synchronized (this.jobSubmitClient) {
        return this.jobSubmitClient.submitJob(this.jobGraph);
    }
}

Output:
 public JobSubmissionResult submitJob() throws IOException {
-    synchronized (this.jobSubmitClient) {
-        return this.jobSubmitClient.submitJob(this.jobGraph);
-    }
+    return this.jobSubmitClient.submitJob(this.jobGraph);
 }


Input:
private Table processTableWithSubheadersWithoutHeader(Cell[][] cells, Table table, Article art, String tableFileName) {
    if (!hasTableSubheader(cells, table)) {
        return table;
    }
    if (table.getTableStructureType() != Table.StructureType.SUBHEADER && table.getTableStructureType() != null) {
        return table;
    }
    Statistics.addSubheaderTable();
    table.setTableStructureType(Table.StructureType.SUBHEADER);
    if (TablInExMain.ExportLinkedData) {
        TablInExMain.linkedData.AddTable(table.getTable_title(), table.getTable_caption(), "String_Node_Str", "String_Node_Str", table.getTable_footer(), table.getXml());
    }
    String[] headerStackA = new String[20];
    String[] headerStackIndexes = new String[20];
    int currentSubHeaderLevel = 0;
    String prevSubheader = "String_Node_Str";
    String prevSubheaderIndex = "String_Node_Str";
    boolean hasSpaceSubheaders = false;
    if (table.isHasHeader() == false) {
        table = checkHeaders(table);
    }
    cells = table.cells;
    Cell[][] original_cells = table.original_cells;
    for (int j = 0; j < cells.length; j++) {
        if (cells[j][0].isIs_header())
            continue;
        boolean emptyLine = true;
        for (int h = 0; h < cells[j].length; h++) {
            if (!Utilities.isSpaceOrEmpty(cells[j][h].getCell_content())) {
                emptyLine = false;
                break;
            }
        }
        if (emptyLine)
            continue;
        if (cells[j][0].isIs_columnspanning() && table.getNum_of_columns() > 1 && cells[j][0].getCells_columnspanning() >= table.getNum_of_columns()) {
            if (Utilities.numOfBegeningSpaces(cells[j][0].getCell_content()) == currentSubHeaderLevel) {
                headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
                currentSubHeaderLevel++;
            } else {
                currentSubHeaderLevel = Utilities.numOfBegeningSpaces(cells[j][0].getCell_content());
                headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
                currentSubHeaderLevel++;
            }
            SetUnderSubheaderRow(cells[j]);
            SetUnderSubheaderRow(original_cells[cells[j][0].getRow_number()]);
            continue;
        }
        boolean emptyCells = true;
        for (int h = 1; h < cells[j].length; h++) {
            if (cells[j][h].getCell_content() == null) {
                cells[j][h].setCell_content("String_Node_Str");
            }
            if (Utilities.isSpaceOrEmpty(cells[j][0].getCell_content()) || !Utilities.isSpaceOrEmpty(cells[j][h].getCell_content())) {
                emptyCells = false;
            }
        }
        if (emptyCells) {
            if (currentSubHeaderLevel != 0 && currentSubHeaderLevel == j - 1) {
                if (Utilities.numOfBegeningSpaces(cells[j][0].getCell_content()) == currentSubHeaderLevel) {
                    headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                    headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
                    currentSubHeaderLevel++;
                    SetUnderSubheaderRow(cells[j]);
                    SetUnderSubheaderRow(original_cells[cells[j][0].getRow_number()]);
                } else {
                    currentSubHeaderLevel = Utilities.numOfBegeningSpaces(cells[j][0].getCell_content());
                    headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                    headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
                    currentSubHeaderLevel++;
                    SetUnderSubheaderRow(cells[j]);
                    SetUnderSubheaderRow(original_cells[cells[j][0].getRow_number()]);
                }
            } else {
                if (Utilities.numOfBegeningSpaces(cells[j][0].getCell_content()) == currentSubHeaderLevel) {
                    headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                    headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
                    currentSubHeaderLevel++;
                    SetUnderSubheaderRow(cells[j]);
                    SetUnderSubheaderRow(original_cells[cells[j][0].getRow_number()]);
                } else {
                    currentSubHeaderLevel = Utilities.numOfBegeningSpaces(cells[j][0].getCell_content());
                    headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                    headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
                    currentSubHeaderLevel++;
                    SetUnderSubheaderRow(cells[j]);
                    SetUnderSubheaderRow(original_cells[cells[j][0].getRow_number()]);
                }
                if (j > 0 && isRowSubheader(cells[j - 1], table)) {
                    prevSubheader = cells[j - 1][0].getCell_content();
                    prevSubheaderIndex = cells[j - 1][0].getRow_number() + cells[j - 1][0].getColumn_number() + "String_Node_Str";
                }
                continue;
            }
        }
        if (isRowSubheader(cells[j], table)) {
            if (j > 0 && isRowSubheader(cells[j - 1], table)) {
                prevSubheader = cells[j - 1][0].getCell_content();
                prevSubheaderIndex = cells[j - 1][0].getRow_number() + cells[j - 1][0].getColumn_number() + "String_Node_Str";
            }
            continue;
        }
        if (cells[j][0].getCell_content() == null) {
            cells[j][0].setCell_content("String_Node_Str");
        }
        if ((cells != null && cells[j] != null && cells[j][0] != null && cells[j][0].getCell_content() != null) && (cells[j][0].getCell_content().length() > 0 && Utilities.isSpace(cells[j][0].getCell_content().trim().charAt(0))) || Utilities.isSpaceOrEmpty(cells[j][0].getCell_content())) {
            hasSpaceSubheaders = true;
            SetUnderSubheaderRow(cells[j]);
            SetUnderSubheaderRow(original_cells[cells[j][0].getRow_number()]);
            if (Utilities.numOfBegeningSpaces(cells[j][0].getCell_content()) == currentSubHeaderLevel || Utilities.isSpaceOrEmpty(cells[j][0].getCell_content())) {
                headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
            } else {
                currentSubHeaderLevel = Utilities.numOfBegeningSpaces(cells[j][0].getCell_content());
                headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
                headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
            }
        } else {
            if (hasSpaceSubheaders)
                currentSubHeaderLevel = 0;
            headerStackA[currentSubHeaderLevel] = cells[j][0].getCell_content();
            headerStackIndexes[currentSubHeaderLevel] = "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getRow_number() + "String_Node_Str" + original_cells[cells[j][0].getRow_number()][cells[j][0].getColumn_number()].getColumn_number();
        }
        for (int k = 1; k < cells[j].length; k++) {
            try {
                DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
                DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
                Document doc = docBuilder.newDocument();
                Element rootElement = doc.createElement("String_Node_Str");
                doc.appendChild(rootElement);
                Element cell = doc.createElement("String_Node_Str");
                rootElement.appendChild(cell);
                Element NavigationPath = doc.createElement("String_Node_Str");
                if (!Utilities.isSpaceOrEmpty(cells[0][0].getCell_content()) && cells[0][0].isIs_header()) {
                    Element Head00 = doc.createElement("String_Node_Str");
                    Head00.setTextContent(cells[0][0].getCell_content());
                    cells[j][k].setHead00(cells[0][0].getCell_content());
                    NavigationPath.appendChild(Head00);
                }
                Element Stub = doc.createElement("String_Node_Str");
                if (currentSubHeaderLevel > 0) {
                    getStackAsElements(headerStackA, prevSubheader, currentSubHeaderLevel, doc, Stub);
                    getStackIndex(headerStackIndexes, prevSubheaderIndex, currentSubHeaderLevel, cells[j][k], table);
                }
                String subheaderValues = "String_Node_Str";
                String[] SubHeaders = new String[Stub.getChildNodes().getLength()];
                for (int l = 0; l < Stub.getChildNodes().getLength(); l++) {
                    subheaderValues += "String_Node_Str" + Stub.getChildNodes().item(l).getTextContent();
                    SubHeaders[l] = Stub.getChildNodes().item(l).getTextContent();
                }
                cells[j][k].setSubheader_values(subheaderValues);
                Element ss = doc.createElement("String_Node_Str");
                ss.setTextContent(cells[j][0].getCell_content());
                cells[j][k].setStub_values(cells[j][0].getCell_content());
                Stub.appendChild(ss);
                NavigationPath.appendChild(Stub);
                if (cells[0][k].isIs_header()) {
                    for (int s = 0; s < cells[0][k].headers.size(); s++) {
                        Element Header = doc.createElement("String_Node_Str" + s);
                        Header.setTextContent(cells[0][k].headers.get(s));
                        cells[j][k].setHeader_values(cells[0][k].getCell_content());
                        NavigationPath.appendChild(Header);
                    }
                }
                cell.appendChild(NavigationPath);
                Element info = doc.createElement("String_Node_Str");
                info.setTextContent(cells[j][k].getCell_content());
                cell.appendChild(info);
                Element CellType = doc.createElement("String_Node_Str");
                CellType.setTextContent(cells[j][k].getCellType());
                cell.appendChild(CellType);
                Element tableEl = doc.createElement("String_Node_Str");
                rootElement.appendChild(tableEl);
                Element tname = doc.createElement("String_Node_Str");
                tname.setTextContent(table.getTable_caption());
                tableEl.appendChild(tname);
                Element TableType = doc.createElement("String_Node_Str");
                TableType.setTextContent("String_Node_Str");
                tableEl.appendChild(TableType);
                Element torder = doc.createElement("String_Node_Str");
                torder.setTextContent(table.getTable_title());
                tableEl.appendChild(torder);
                Element tfooter = doc.createElement("String_Node_Str");
                tfooter.setTextContent(table.getTable_footer());
                tableEl.appendChild(tfooter);
                Element document = doc.createElement("String_Node_Str");
                rootElement.appendChild(document);
                Element docTitle = doc.createElement("String_Node_Str");
                docTitle.setTextContent(art.getTitle());
                document.appendChild(docTitle);
                Element pmc = doc.createElement("String_Node_Str");
                pmc.setTextContent(art.getPmc());
                document.appendChild(pmc);
                if (TablInExMain.ExportLinkedData) {
                    TablInExMain.linkedData.AddCell(cells[j][0].getCell_content(), SubHeaders, cells[j][k].getCell_content(), cells[j][k].getCellType(), cells[0][k].headers.toArray(new String[0]), cells[0][0].getCell_content(), j, k);
                }
                DataExtractionOutputObj dataExtObj = new DataExtractionOutputObj(folder + tableFileName + "String_Node_Str" + j + "String_Node_Str" + k + "String_Node_Str", doc);
                table.output.add(dataExtObj);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
    table.cells = cells;
    return table;
}

Output:
         }
-        if ((cells != null && cells[j] != null && cells[j][0] != null && cells[j][0].getCell_content() != null) && (cells[j][0].getCell_content().length() > 0 && Utilities.isSpace(cells[j][0].getCell_content().trim().charAt(0))) || Utilities.isSpaceOrEmpty(cells[j][0].getCell_content())) {
+        if ((cells != null && cells[j] != null && cells[j][0] != null && cells[j][0].getCell_content() != null) && (cells[j][0].getCell_content().length() > 0 && Utilities.isSpace(cells[j][0].getCell_content().trim().charAt(0)))) {
             hasSpaceSubheaders = true;


Input:
public static float getRainStrengthAndControlVisuals(EntityPlayer entP, boolean forOvercast) {
    Minecraft mc = FMLClientHandler.instance().getClient();
    double maxStormDist = 512 / 4 * 3;
    Vec3 plPos = new Vec3(entP.posX, StormObject.static_YPos_layer0, entP.posZ);
    StormObject storm = null;
    ClientTickHandler.checkClientWeather();
    storm = ClientTickHandler.weatherManager.getClosestStorm(plPos, maxStormDist, StormObject.STATE_FORMING, true);
    if (forOvercast) {
    } else {
    }
    boolean closeEnough = false;
    double stormDist = 9999;
    float tempAdj = 1F;
    float sizeToUse = 0;
    float overcastModeMinPrecip = 0.2F;
    if (storm != null) {
        sizeToUse = storm.size;
        if (forOvercast) {
            sizeToUse *= 1F;
        }
        stormDist = storm.pos.distanceTo(plPos);
        if (sizeToUse > stormDist) {
            closeEnough = true;
        }
    }
    if (closeEnough) {
        double stormIntensity = (sizeToUse - stormDist) / sizeToUse;
        tempAdj = storm.levelTemperature > 0 ? 1F : -1F;
        if (storm.levelCurIntensityStage == StormObject.STATE_NORMAL) {
            if (stormIntensity > 0.3)
                stormIntensity = 0.3;
        }
        if (ConfigStorm.Storm_NoRainVisual) {
            stormIntensity = 0;
        }
        mc.world.getWorldInfo().setRaining(true);
        mc.world.getWorldInfo().setThundering(true);
        if (forOvercast) {
            curOvercastStrTarget = (float) stormIntensity;
        } else {
            curPrecipStrTarget = (float) stormIntensity;
        }
    } else {
        if (!ConfigMisc.overcastMode) {
            mc.world.getWorldInfo().setRaining(false);
            mc.world.getWorldInfo().setThundering(false);
            if (forOvercast) {
                curOvercastStrTarget = 0;
            } else {
                curPrecipStrTarget = 0;
            }
        } else {
            if (ClientTickHandler.weatherManager.isVanillaRainActiveOnServer) {
                mc.world.getWorldInfo().setRaining(true);
                mc.world.getWorldInfo().setThundering(true);
                if (forOvercast) {
                    curOvercastStrTarget = overcastModeMinPrecip;
                } else {
                    curPrecipStrTarget = overcastModeMinPrecip;
                }
            } else {
                if (forOvercast) {
                    curOvercastStrTarget = 0;
                } else {
                    curPrecipStrTarget = 0;
                }
            }
        }
    }
    if (forOvercast) {
        if (curOvercastStr > curOvercastStrTarget) {
            curOvercastStr -= 0.001F;
        } else if (curOvercastStr < curOvercastStrTarget) {
            curOvercastStr += 0.001F;
        }
        if (curOvercastStr < 0.0001 && curOvercastStr > -0.0001F) {
            curOvercastStr = 0;
        }
        return curOvercastStr * tempAdj;
    } else {
        if (curPrecipStr > curPrecipStrTarget) {
            curPrecipStr -= 0.001F;
        } else if (curPrecipStr < curPrecipStrTarget) {
            curPrecipStr += 0.001F;
        }
        if (curPrecipStr < 0.0001 && curPrecipStr > -0.0001F) {
            curPrecipStr = 0;
        }
        return curPrecipStr * tempAdj;
    }
}

Output:
     float sizeToUse = 0;
-    float overcastModeMinPrecip = 0.2F;
+    float overcastModeMinPrecip = 0.23F;
     if (storm != null) {


Input:
public boolean isAvatarThumbnailCached(String url, int side) {
    boolean isCached = false;
    if (null != url) {
        String thumbnailUrl = downloadableUrl(url, side, side);
        isCached = MXMediaDownloadWorkerTask.isUrlCached(thumbnailUrl);
        if (!isCached) {
            try {
                isCached = (new File(getThumbnailsFolderFile(), MXMediaDownloadWorkerTask.buildFileName(thumbnailUrl, "String_Node_Str"))).exists();
            } catch (Throwable t) {
                Log.e(LOG_TAG, "String_Node_Str" + t.getMessage());
            }
        }
    }
    return isCached;
}

Output:
     boolean isCached = false;
-    if (null != url) {
-        String thumbnailUrl = downloadableUrl(url, side, side);
+    String thumbnailUrl = downloadableUrl(url, side, side);
+    if (null != thumbnailUrl) {
         isCached = MXMediaDownloadWorkerTask.isUrlCached(thumbnailUrl);


Input:
public WeatherInfo workInBackground(Boolean... params) throws TaskException {
    boolean isForce = params[0];
    WeatherInfo weatherInfo = null;
    if (isNeedRequestNet() || isForce) {
        weatherInfo = loadWeatherInfoFromNetwork();
    } else {
        weatherInfo = loadWeatherInfoFromLocal();
    }
    return weatherInfo;
}

Output:
     if (isNeedRequestNet() || isForce) {
-        weatherInfo = loadWeatherInfoFromNetwork();
+        try {
+            weatherInfo = loadWeatherInfoFromNetwork();
+        } catch (Exception e) {
+        }
+        if (WeatherSpider.isEmpty(weatherInfo)) {
+            weatherInfo = loadWeatherInfoFromLocal();
+            weatherInfo.setNewData(false);
+        } else {
+            weatherInfo.setNewData(true);
+        }
     } else {


Input:
private void sendPacket(Peer peer) {
    if (peer != null) {
        writeBuffer.clear();
        protocol.reset();
        if (this.isServer) {
            long currentTime = System.currentTimeMillis();
            if (currentTime - peer.getLastPingTime() >= config.getPingRate()) {
                peer.setLastPingTime(currentTime);
                peer.send(new PingMessage());
            }
        }
        writeBuffer.position(protocol.size());
        if (peer.isConnecting()) {
            protocol.setPeerId(INVALID_PEER_ID);
        } else {
            protocol.setPeerId(peer.getId());
        }
        byte numberOfMessages = 0;
        numberOfMessages += packReliableMessages(writeBuffer, protocol, peer);
        numberOfMessages += packUnreliableMessages(writeBuffer, protocol, peer);
        protocol.setNumberOfMessages(numberOfMessages);
        if (numberOfMessages > 0) {
            int endPosition = writeBuffer.position();
            writeBuffer.position(0);
            {
                protocol.setSendSequence(peer.nextSequenceNumber());
                protocol.setAcknowledge(peer.getRemoteSequence());
                protocol.setAckHistory(peer.getAckHistory());
                protocol.writeTo(writeBuffer);
            }
            writeBuffer.position(endPosition);
            send(writeBuffer, peer);
        } else {
            long amountOfTimeSinceLastPacket = System.currentTimeMillis() - peer.getLastSendTime();
            if (amountOfTimeSinceLastPacket >= config.getHeartbeatTime()) {
                peer.send(new HeartbeatMessage());
            }
        }
    }
}

Output:
                 peer.setLastPingTime(currentTime);
-                peer.send(new PingMessage());
+                peer.send(PingMessage.INSTANCE);
             }


Input:
void maybeFinishPendingAttribute(SourceLocation.Point currentPoint) {
    if (hasUnquotedAttributeValueParts()) {
        createUnquotedAttributeValue(currentPoint);
    } else if (hasQuotedAttributeValueParts()) {
        errorReporter.report(currentPoint.asLocation(filePath), FOUND_END_OF_ATTRIBUTE_STARTED_IN_ANOTHER_BLOCK);
        resetAttribute();
    }
    if (attributeName != null) {
        createAttributeNode();
    }
}

Output:
         errorReporter.report(currentPoint.asLocation(filePath), FOUND_END_OF_ATTRIBUTE_STARTED_IN_ANOTHER_BLOCK);
-        resetAttribute();
+        throw new AbortParsingBlockError();
     }


Input:
protected Change[] createInverses() {
    DropColumnChange inverse = new DropColumnChange();
    inverse.setColumnName(getColumn().getName());
    inverse.setTableName(getTableName());
    return new Change[] { inverse };
}

Output:
     inverse.setTableName(getTableName());
-    return new Change[] { inverse };
+    inverses.add(inverse);
+    return inverses.toArray(new Change[inverses.size()]);
 }


Input:
public void handleStopKeepalive(NetworkAgentInfo nai, int slot, int reason) {
    HashMap<Integer, KeepaliveInfo> networkKeepalives = mKeepalives.get(nai);
    if (networkKeepalives == null) {
        Log.e(TAG, "String_Node_Str" + nai.name());
        return;
    }
    KeepaliveInfo ki = networkKeepalives.get(slot);
    if (ki == null) {
        Log.e(TAG, "String_Node_Str" + slot + "String_Node_Str" + nai.name());
        return;
    }
    ki.stop(reason);
    networkKeepalives.remove(slot);
    if (networkKeepalives.isEmpty()) {
        mKeepalives.remove(nai);
    }
}

Output:
     if (networkKeepalives == null) {
-        Log.e(TAG, "String_Node_Str" + nai.name());
+        Log.e(TAG, "String_Node_Str" + networkName);
         return;


Input:
protected void adjustForNumColumns(int numColumns) {
    Control control = getLabelControl();
    if (control != null) {
        ((GridData) control.getLayoutData()).horizontalSpan = 1;
        numColumns--;
    }
    ((GridData) getTextControl(null).getLayoutData()).horizontalSpan = 1;
    ((GridData) getTextControl(null).getLayoutData()).widthHint = 85;
    numColumns--;
    ((GridData) getButtonControl(null).getLayoutData()).horizontalSpan = numColumns;
    ((GridData) getButtonControl(null).getLayoutData()).widthHint = 85;
}

Output:
     ((GridData) getButtonControl(null).getLayoutData()).horizontalSpan = numColumns;
-    ((GridData) getButtonControl(null).getLayoutData()).widthHint = 85;
+    ((GridData) getButtonControl(null).getLayoutData()).widthHint = Math.max(getButtonControl(null).computeSize(SWT.DEFAULT, SWT.DEFAULT).x, 85);
 }


Input:
public IAEStack injectItems(IAEStack input, Actionable type, BaseActionSource src) {
    if (input instanceof IAEItemStack && type == Actionable.SIMULATE && false) {
        IAEItemStack what = (IAEItemStack) input.copy();
        IAEItemStack is = waitingFor.findPrecise(what);
        if (is != null && is.getStackSize() > 0) {
            if (is.getStackSize() >= what.getStackSize()) {
                if (finalOutput.equals(what)) {
                    if (myLastLink != null)
                        return ((CraftingLink) myLastLink).injectItems((IAEItemStack) what, type);
                    return what;
                }
                return null;
            }
            if (finalOutput.equals(what)) {
                if (myLastLink != null)
                    return ((CraftingLink) myLastLink).injectItems((IAEItemStack) what, type);
                return what;
            }
            IAEItemStack leftOver = what.copy();
            leftOver.decStackSize(is.getStackSize());
            return leftOver;
        }
    } else if (input instanceof IAEItemStack && type == Actionable.MODULATE) {
        IAEItemStack what = (IAEItemStack) input;
        IAEItemStack is = waitingFor.findPrecise(what);
        if (is != null && is.getStackSize() > 0) {
            waiting = false;
            postChange((IAEItemStack) input, src);
            if (is.getStackSize() >= input.getStackSize()) {
                is.decStackSize(input.getStackSize());
                markDirty();
                if (finalOutput.equals(input)) {
                    finalOutput.decStackSize(input.getStackSize());
                    if (finalOutput.getStackSize() <= 0)
                        completeJob();
                    if (myLastLink != null)
                        return ((CraftingLink) myLastLink).injectItems((IAEItemStack) input, type);
                    return input;
                }
                return inventory.injectItems(what, type, src);
            }
            IAEItemStack insert = what.copy();
            insert.setStackSize(is.getStackSize());
            what.decStackSize(is.getStackSize());
            is.setStackSize(0);
            if (finalOutput.equals(input)) {
                finalOutput.decStackSize(input.getStackSize());
                if (finalOutput.getStackSize() <= 0)
                    completeJob();
                if (myLastLink != null)
                    return ((CraftingLink) myLastLink).injectItems((IAEItemStack) input, type);
                return input;
            }
            inventory.injectItems(insert, type, src);
            markDirty();
            return what;
        }
    }
    return input;
}

Output:
 public IAEStack injectItems(IAEStack input, Actionable type, BaseActionSource src) {
-    if (input instanceof IAEItemStack && type == Actionable.SIMULATE && false) {
+    if (input instanceof IAEItemStack && type == Actionable.SIMULATE) {
         IAEItemStack what = (IAEItemStack) input.copy();


Input:
private EntityMetadata belongsToPersistenceUnit(EntityMetadata metadata) {
    if ((metadata.getPersistenceUnit() == null && !(Constants.RDBMS_CLIENT_FACTORY.equalsIgnoreCase(client) || Constants.NEO4J_CLIENT_FACTORY.equalsIgnoreCase(client))) || metadata.getPersistenceUnit() != null && !metadata.getPersistenceUnit().equals(persistenceUnit)) {
        metadata = null;
    }
    return metadata;
}

Output:
 private EntityMetadata belongsToPersistenceUnit(EntityMetadata metadata) {
-    if ((metadata.getPersistenceUnit() == null && !(Constants.RDBMS_CLIENT_FACTORY.equalsIgnoreCase(client) || Constants.NEO4J_CLIENT_FACTORY.equalsIgnoreCase(client))) || metadata.getPersistenceUnit() != null && !metadata.getPersistenceUnit().equals(persistenceUnit)) {
+    if (metadata.getPersistenceUnit() != null && !metadata.getPersistenceUnit().equals(persistenceUnit)) {
         metadata = null;


Input:
public Vector<DebugVariable> getWatchList() {
    if (DebugState.paused(this.state)) {
        this.waitForEOL = DebugVariableType.LOCAL;
        this.watchProcessing = true;
        this.watchList = new Vector<DebugVariable>();
        this.waitingThread = Thread.currentThread();
        this.wasWatchEOL = false;
        getVariablesPrivate(DebugVariableType.GLOBAL);
        getVariablesPrivate(DebugVariableType.LOCAL);
        if (this.classPosition.length() > 0) {
            this.waitForEOL = DebugVariableType.INSTANCE;
            getVariablesPrivate(DebugVariableType.CLASS);
            getVariablesPrivate(DebugVariableType.INSTANCE);
        }
        do {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        } while (!(this.wasWatchEOL && (this.lastWatchEOL == this.waitForEOL)));
        this.watchProcessing = false;
        return this.watchList;
    }
    return null;
}

Output:
         this.watchProcessing = false;
-        return this.watchList;
+        result = this.watchList;
+        this.watchList = null;
     }


Input:
private List<AutocryptPeer> getAutocryptPeers(String packageName, String... autocryptId) {
    ArrayList<AutocryptPeer> result = new ArrayList<>(autocryptId.length);
    SqlDelightQuery query = AutocryptPeer.FACTORY.selectByIdentifiers(packageName, autocryptId);
    try (Cursor cursor = getReadableDb().query(query)) {
        if (cursor.moveToNext()) {
            AutocryptPeer autocryptPeer = AutocryptPeer.PEER_MAPPER.map(cursor);
            result.add(autocryptPeer);
        }
    }
    return result;
}

Output:
     SqlDelightQuery query = AutocryptPeer.FACTORY.selectByIdentifiers(packageName, autocryptId);
-    try (Cursor cursor = getReadableDb().query(query)) {
-        if (cursor.moveToNext()) {
-            AutocryptPeer autocryptPeer = AutocryptPeer.PEER_MAPPER.map(cursor);
-            result.add(autocryptPeer);
-        }
-    }
-    return result;
+    return mapAllRows(query, AutocryptPeer.PEER_MAPPER);
 }


Input:
private double calculateHsPenalty(final int coverageGoal) {
    if (this.metrics.HS_LIBRARY_SIZE == null)
        return 0;
    final double meanCoverage = this.ON_TARGET_FROM_PAIR_BASES / (double) this.metrics.TARGET_TERRITORY;
    final double fold80 = this.metrics.FOLD_80_BASE_PENALTY;
    final long hsLibrarySize = this.metrics.HS_LIBRARY_SIZE;
    final long pairs = this.PF_SELECTED_PAIRS;
    final long uniquePairs = this.PF_SELECTED_UNIQUE_PAIRS;
    final double onTargetPct = (double) this.metrics.ON_TARGET_BASES / (double) this.metrics.PF_UQ_BASES_ALIGNED;
    final double uniquePairGoalMultiplier = (coverageGoal / meanCoverage) * fold80;
    double pairMultiplier = uniquePairGoalMultiplier;
    double increment = 1;
    boolean goingUp = uniquePairGoalMultiplier >= 1;
    double finalPairMultiplier = -1;
    for (int i = 0; i < 10000; ++i) {
        double uniquePairMultiplier = DuplicationMetrics.estimateRoi(hsLibrarySize, pairMultiplier, pairs, uniquePairs);
        if (Math.abs(uniquePairMultiplier - uniquePairGoalMultiplier) <= 0.01) {
            finalPairMultiplier = pairMultiplier;
            break;
        } else if ((uniquePairMultiplier > uniquePairGoalMultiplier && goingUp) || (uniquePairMultiplier < uniquePairGoalMultiplier && !goingUp)) {
            increment /= 2;
            goingUp = !goingUp;
        }
        pairMultiplier += (goingUp ? increment : -increment);
    }
    if (finalPairMultiplier == -1) {
        return -1;
    } else {
        double uniqueFraction = (uniquePairs * uniquePairGoalMultiplier) / (pairs * finalPairMultiplier);
        return (1 / uniqueFraction) * fold80 * (1 / onTargetPct);
    }
}

Output:
         double uniquePairMultiplier = DuplicationMetrics.estimateRoi(hsLibrarySize, pairMultiplier, pairs, uniquePairs);
-        if (Math.abs(uniquePairMultiplier - uniquePairGoalMultiplier) <= 0.01) {
+        if (Math.abs(uniquePairMultiplier - uniquePairGoalMultiplier) / uniquePairGoalMultiplier <= 0.001) {
             finalPairMultiplier = pairMultiplier;


Input:
private void loadAndRegisterDriver(String className) throws OdaException {
    if (className == null || className.length() == 0)
        return;
    if (isDeregistered(className)) {
        throw new JDBCException(ResourceConstants.CANNOT_LOAD_DRIVER, null, className);
    } else if (this.registeredDrivers.containsKey(className)) {
        return;
    }
    if (logger.isLoggable(Level.INFO)) {
        logger.info("String_Node_Str" + className);
    }
    Driver driver = findDriver(className);
    if (driver != null) {
        try {
            if (logger.isLoggable(Level.FINER))
                logger.finer("String_Node_Str" + className);
            DriverManager.registerDriver(new WrappedDriver(driver, className));
        } catch (SQLException e) {
            logger.log(Level.WARNING, "String_Node_Str", e);
        }
    }
    registeredDrivers.put(className, DRIVER_REGISTERED);
}

Output:
     }
-    Driver driver = findDriver(className);
+    Driver driver = findDriver(className, driverClassPath);
     if (driver != null) {


Input:
public boolean accept(EdgeIteratorState edgeIterState) {
    int adj = edgeIterState.getAdjNode();
    if (baseNode >= maxNodes || adj >= maxNodes)
        return true;
    if (baseNodeLevel <= graph.getLevel(adj))
        return edgeIterState.isBackward(encoder);
    else
        return false;
}

Output:
     int adj = edgeIterState.getAdjNode();
-    if (baseNode >= maxNodes || adj >= maxNodes)
-        return true;
-    if (baseNodeLevel <= graph.getLevel(adj))
+    if (baseNode >= maxNodes || adj >= maxNodes || baseNodeLevel <= graph.getLevel(adj))
         return edgeIterState.isBackward(encoder);


Input:
public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(source.getFirstTarget());
    if (player != null) {
        player.revealCards("String_Node_Str", player.getHand(), game);
        Player you = game.getPlayer(source.getControllerId());
        if (you != null) {
            TargetCard target = new TargetCard(Zone.HAND, filter);
            target.setRequired(true);
            if (target.canChoose(source.getControllerId(), game) && you.chooseTarget(outcome, player.getHand(), target, source, game)) {
                Card card = player.getHand().get(target.getFirstTarget(), game);
                if (card != null) {
                    return player.discard(card, source, game);
                }
            }
        }
    }
    return false;
}

Output:
             target.setRequired(true);
-            if (target.canChoose(source.getControllerId(), game) && you.chooseTarget(outcome, player.getHand(), target, source, game)) {
+            if (target.canChoose(source.getControllerId(), player.getId(), game) && you.chooseTarget(outcome, player.getHand(), target, source, game)) {
                 Card card = player.getHand().get(target.getFirstTarget(), game);


Input:
public boolean containsAll(final Collection<?> objects) {
    if (objects.isEmpty()) {
        return true;
    }
    final List<String> list = stack.get();
    return list != null && list.containsAll(objects);
}

Output:
     }
-    final List<String> list = stack.get();
-    return list != null && list.containsAll(objects);
+    final MutableThreadContextStack values = stack.get();
+    return values != null && values.containsAll(objects);
 }


Input:
public void run() {
    for (BlurIndex index : _indexes) {
        try {
            index.refresh();
        } catch (IOException e) {
            LOG.error("String_Node_Str", e, index);
        }
    }
}

Output:
 public void run() {
-    for (BlurIndex index : _indexes) {
-        try {
-            index.refresh();
-        } catch (IOException e) {
-            LOG.error("String_Node_Str", e, index);
-        }
+    try {
+        refreshInternal();
+    } catch (Throwable e) {
+        LOG.error("String_Node_Str", e);
     }


Input:
public boolean onTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
        return false;
    }
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);
    final int action = ev.getAction();
    switch(action & MotionEvent.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN:
            {
                final float y = ev.getY();
                if (!(mIsBeingDragged = inChild((int) ev.getX(), (int) y))) {
                    return false;
                }
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }
                mLastMotionY = y;
                mActivePointerId = ev.getPointerId(0);
                break;
            }
        case MotionEvent.ACTION_MOVE:
            if (mIsBeingDragged) {
                final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
                final float y = ev.getY(activePointerIndex);
                final int deltaY = (int) (mLastMotionY - y);
                mLastMotionY = y;
                final int oldX = mScrollX;
                final int oldY = mScrollY;
                final int range = getScrollRange();
                if (overscrollBy(0, deltaY, 0, mScrollY, 0, range, 0, mOverscrollDistance, true)) {
                    mVelocityTracker.clear();
                }
                onScrollChanged(mScrollX, mScrollY, oldX, oldY);
                final int overscrollMode = getOverscrollMode();
                if (overscrollMode == OVERSCROLL_ALWAYS || (overscrollMode == OVERSCROLL_IF_CONTENT_SCROLLS && range > 0)) {
                    final int pulledToY = oldY + deltaY;
                    if (pulledToY < 0) {
                        mEdgeGlowTop.onPull((float) deltaY / getHeight());
                    } else if (pulledToY > range) {
                        mEdgeGlowBottom.onPull((float) deltaY / getHeight());
                    }
                }
            }
            break;
        case MotionEvent.ACTION_UP:
            if (mIsBeingDragged) {
                final VelocityTracker velocityTracker = mVelocityTracker;
                velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                int initialVelocity = (int) velocityTracker.getYVelocity(mActivePointerId);
                if (getChildCount() > 0) {
                    if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
                        fling(-initialVelocity);
                    } else {
                        final int bottom = getScrollRange();
                        if (mScroller.springback(mScrollX, mScrollY, 0, 0, 0, bottom)) {
                            invalidate();
                        }
                    }
                }
                mActivePointerId = INVALID_POINTER;
                mIsBeingDragged = false;
                if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
                if (mEdgeGlowTop != null) {
                    mEdgeGlowTop.onRelease();
                    mEdgeGlowBottom.onRelease();
                }
            }
            break;
        case MotionEvent.ACTION_CANCEL:
            if (mIsBeingDragged && getChildCount() > 0) {
                if (mScroller.springback(mScrollX, mScrollY, 0, 0, 0, getScrollRange())) {
                    invalidate();
                }
                mActivePointerId = INVALID_POINTER;
                mIsBeingDragged = false;
                if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
                if (mEdgeGlowTop != null) {
                    mEdgeGlowTop.onRelease();
                    mEdgeGlowBottom.onRelease();
                }
            }
            break;
        case MotionEvent.ACTION_POINTER_UP:
            onSecondaryPointerUp(ev);
            break;
    }
    return true;
}

Output:
                 final float y = ev.getY();
-                if (!(mIsBeingDragged = inChild((int) ev.getX(), (int) y))) {
-                    return false;
-                }
+                mIsBeingDragged = true;
                 if (!mScroller.isFinished()) {


Input:
public List<NativeProcess> getMacProcesses() throws NativeAccessException {
    List<NativeProcess> processList = new ArrayList<NativeProcess>();
    try {
        IntByReference _ = new IntByReference(sizeOfInt);
        IntByReference size = new IntByReference(sizeOfInt);
        Memory m;
        int nRetry = 0;
        while (true) {
            if (LIBC.sysctl(MIB_PROC_ALL, 3, NULL, size, NULL, _) != 0) {
                throw new IOException("String_Node_Str" + LIBC.strerror(Native.getLastError()));
            }
            m = new Memory(size.getValue());
            if (LIBC.sysctl(MIB_PROC_ALL, 3, m, size, NULL, _) != 0) {
                if (Native.getLastError() == ENOMEM && nRetry++ < 16) {
                    continue;
                }
                throw new IOException("String_Node_Str" + LIBC.strerror(Native.getLastError()));
            }
            break;
        }
        int count = size.getValue() / sizeOf_kinfo_proc;
        LOGGER.log(Level.FINE, "String_Node_Str", count);
        for (int base = 0; base < size.getValue(); base += sizeOf_kinfo_proc) {
            int pid = m.getInt(base + 24);
            int ppid = m.getInt(base + 416);
            processList.add(new NativeMacProcess(pid, ppid));
        }
    } catch (IOException e) {
        LOGGER.log(Level.WARNING, "String_Node_Str", e);
    }
    return processList;
}

Output:
         for (int base = 0; base < size.getValue(); base += sizeOf_kinfo_proc) {
-            int pid = m.getInt(base + 24);
-            int ppid = m.getInt(base + 416);
+            int pid = m.getInt(base + kinfo_proc_pid_offset);
+            int ppid = m.getInt(base + kinfo_proc_ppid_offset);
             processList.add(new NativeMacProcess(pid, ppid));


Input:
public static ClassInfo getTestClassInfoFromTargetClass(String testTargetClassname, IFile javaFile) throws InvalidPreferenceException, IOException {
    PreferenceLoader pref = new PreferenceLoader();
    ClassInfo classInfo = new ClassInfo();
    classInfo.name = testTargetClassname;
    List<ConstructorInfo> constructors = new ArrayList<ConstructorInfo>();
    List<MethodInfo> testMethods = new ArrayList<MethodInfo>();
    InputStream is = null;
    InputStreamReader isr = null;
    BufferedReader br = null;
    try {
        String encoding = FileResourceUtil.detectEncoding(javaFile);
        is = FileResourceUtil.readFile(javaFile);
        isr = new InputStreamReader(is, encoding);
        br = new BufferedReader(isr);
        StringBuilder tmpsb = new StringBuilder();
        String line = null;
        while ((line = br.readLine()) != null) {
            line += StrConst.lineFeed;
            tmpsb.append(SourceCodeParseUtil.trimLineComments(line));
            tmpsb.append(StrConst.space);
        }
        String targetClassSourceStrWithoutComments = SourceCodeParseUtil.trimAllComments(tmpsb.toString());
        String targetClassSourceStr = SourceCodeParseUtil.trimInsideOfBraces(targetClassSourceStrWithoutComments);
        if (pref.isTestMethodGenNotBlankEnabled) {
            if (testMethods.size() <= 0 || testMethods.get(0) == null)
                testMethods.add(new MethodInfo());
            String[] importLines = targetClassSourceStr.split("String_Node_Str");
            for (String importLine : importLines) {
                importLine = importLine.replaceAll(StrConst.lineFeed, StrConst.empty);
                if (!importLine.matches("String_Node_Str") && !importLine.matches("String_Node_Str")) {
                    String importedPackage = importLine.split("String_Node_Str")[0];
                    classInfo.importList.add(importedPackage);
                }
            }
            if (pref.isJUnitVersion3) {
            } else if (pref.isJUnitVersion4) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
            }
            if (pref.isTestMethodGenEnabledSupportJMock2) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
                if (pref.isUsingJUnitHelperRuntime) {
                    classInfo.importList.add("String_Node_Str");
                }
            }
            if (pref.isTestMethodGenEnabledSupportEasyMock) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
            }
            if (pref.isTestMethodGenEnabledSupportMockito) {
                classInfo.importList.add("String_Node_Str");
            }
        }
        List<String> targetConstructors = SourceCodeParseUtil.getTargetConstructors(classInfo.name, targetClassSourceStr, true, true, true);
        for (String target : targetConstructors) {
            String groupConstructor = RegExp.wsAsteriskMax + classInfo.name + "String_Node_Str" + RegExp.wsAsteriskMax + "String_Node_Str" + RegExp.wsAsteriskMax + "String_Node_Str";
            Matcher constructorMatcher = Pattern.compile(groupConstructor).matcher(target);
            if (constructorMatcher.find()) {
                ConstructorInfo each = new ConstructorInfo();
                String args = constructorMatcher.group(1);
                String[] tmpArr = args.split(StrConst.comma);
                int tmpArrLen = tmpArr.length;
                List<String> tmpArrList = new ArrayList<String>();
                String buf = StrConst.empty;
                for (int i = 0; i < tmpArrLen; i++) {
                    String element = tmpArr[i].trim();
                    if (element.matches("String_Node_Str")) {
                        tmpArrList.add(element);
                        continue;
                    }
                    if (element.matches("String_Node_Str")) {
                        buf += element;
                        continue;
                    }
                    if (element.matches("String_Node_Str")) {
                        String result = buf + StrConst.comma + element;
                        tmpArrList.add(result);
                        buf = StrConst.empty;
                        continue;
                    }
                    if (!buf.equals(StrConst.empty)) {
                        buf += StrConst.comma + element;
                        continue;
                    }
                    tmpArrList.add(element);
                }
                String[] argArr = tmpArrList.toArray(new String[0]);
                if (pref.isTestMethodGenNotBlankEnabled) {
                    int argArrLen = argArr.length;
                    for (int i = 0; i < argArrLen; i++) {
                        ArgType argType = new ArgType();
                        String argTypeFull = argArr[i];
                        Matcher toGenericsMatcher = Pattern.compile(RegExp.genericsGroup).matcher(argTypeFull);
                        while (toGenericsMatcher.find()) {
                            String[] generics = toGenericsMatcher.group().replaceAll("String_Node_Str", StrConst.empty).replaceAll("String_Node_Str", StrConst.empty).split(StrConst.comma);
                            for (String generic : generics) {
                                generic = getClassInSourceCode(generic, StrConst.empty, classInfo.importList);
                                argType.generics.add(generic);
                            }
                        }
                        String argTypeStr = argTypeFull.replaceAll(RegExp.generics, StrConst.empty);
                        argType.name = getType(argTypeStr);
                        argType.nameInMethodName = getTypeAvailableInMethodName(argTypeStr);
                        each.argTypes.add(argType);
                        Matcher nameMatcher = RegExp.groupMethodArgNamePattern.matcher(argTypeFull);
                        if (nameMatcher.find()) {
                            each.argNames.add(nameMatcher.group(1));
                        } else {
                            each.argNames.add("String_Node_Str" + i);
                        }
                    }
                }
                constructors.add(each);
            }
        }
        List<String> targets = SourceCodeParseUtil.getTargetMethods(targetClassSourceStr, pref.isTestMethodGenIncludePublic, pref.isTestMethodGenIncludeProtected, pref.isTestMethodGenIncludePackageLocal);
        for (String target : targets) {
            Matcher matcher = RegExp.groupMethodPattern.matcher(target);
            if (matcher.find()) {
                MethodInfo each = new MethodInfo();
                if (pref.isTestMethodGenNotBlankEnabled || pref.isTestMethodGenReturnEnabled) {
                    String returnTypeFull = getType(matcher.group(1));
                    Matcher toGenericsMatcher = Pattern.compile(RegExp.genericsGroup).matcher(returnTypeFull);
                    while (toGenericsMatcher.find()) {
                        String[] generics = toGenericsMatcher.group().replaceAll("String_Node_Str", StrConst.empty).replaceAll("String_Node_Str", StrConst.empty).split(StrConst.comma);
                        for (String generic : generics) {
                            generic = getClassInSourceCode(generic, StrConst.empty, classInfo.importList);
                            each.returnType.generics.add(generic);
                        }
                    }
                    each.returnType.name = returnTypeFull.replace(RegExp.generics, StrConst.empty);
                    each.returnType.nameInMethodName = getTypeAvailableInMethodName(each.returnType.name);
                }
                each.methodName = matcher.group(2);
                String args = matcher.group(3);
                String[] tmpArr = args.split(StrConst.comma);
                int tmpArrLen = tmpArr.length;
                List<String> tmpArrList = new ArrayList<String>();
                String buf = StrConst.empty;
                for (int i = 0; i < tmpArrLen; i++) {
                    String element = tmpArr[i].trim();
                    if (element.matches("String_Node_Str")) {
                        tmpArrList.add(element);
                        continue;
                    }
                    if (element.matches("String_Node_Str")) {
                        buf += element;
                        continue;
                    }
                    if (element.matches("String_Node_Str")) {
                        String result = buf + StrConst.comma + element;
                        tmpArrList.add(result);
                        buf = StrConst.empty;
                        continue;
                    }
                    if (!buf.equals(StrConst.empty)) {
                        buf += StrConst.comma + element;
                        continue;
                    }
                    tmpArrList.add(element);
                }
                String[] argArr = tmpArrList.toArray(new String[0]);
                if (pref.isTestMethodGenNotBlankEnabled || pref.isTestMethodGenArgsEnabled) {
                    int argArrLen = argArr.length;
                    for (int i = 0; i < argArrLen; i++) {
                        ArgType argType = new ArgType();
                        String argTypeFull = argArr[i];
                        Matcher toGenericsMatcher = Pattern.compile(RegExp.genericsGroup).matcher(argTypeFull);
                        while (toGenericsMatcher.find()) {
                            String[] generics = toGenericsMatcher.group().replaceAll("String_Node_Str", StrConst.empty).replaceAll("String_Node_Str", StrConst.empty).split(StrConst.comma);
                            for (String generic : generics) {
                                generic = getClassInSourceCode(generic, StrConst.empty, classInfo.importList);
                                argType.generics.add(generic);
                            }
                        }
                        String argTypeStr = argTypeFull.replaceAll(RegExp.generics, StrConst.empty);
                        argType.name = getType(argTypeStr);
                        argType.nameInMethodName = getTypeAvailableInMethodName(argTypeStr);
                        each.argTypes.add(argType);
                        Matcher nameMatcher = RegExp.groupMethodArgNamePattern.matcher(argTypeFull);
                        if (nameMatcher.find()) {
                            each.argNames.add(nameMatcher.group(1));
                        } else {
                            each.argNames.add("String_Node_Str" + i);
                        }
                    }
                }
                if (pref.isTestMethodGenExecludeAccessors) {
                    String fieldName = null;
                    String fieldType = null;
                    if (each.methodName.matches("String_Node_Str")) {
                        fieldName = each.methodName.substring(3);
                        if (each.argTypes.size() > 0) {
                            fieldType = each.argTypes.get(0).name;
                        }
                    } else if (each.methodName.matches("String_Node_Str")) {
                        fieldName = each.methodName.substring(3);
                        fieldType = each.returnType.name;
                    } else if (each.methodName.matches("String_Node_Str")) {
                        fieldName = each.methodName.substring(2);
                        fieldType = each.returnType.name;
                    }
                    if (fieldName != null) {
                        fieldName = fieldName.substring(0, 1).toLowerCase() + fieldName.substring(1);
                        fieldType = fieldType.replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str");
                        String searchRegexp = "String_Node_Str" + fieldType + "String_Node_Str" + RegExp.generics + "String_Node_Str" + RegExp.wsPlusMax + fieldName + "String_Node_Str";
                        if (targetClassSourceStr.replaceAll(RegExp.crlf, StrConst.empty).matches(searchRegexp)) {
                            continue;
                        }
                    }
                }
                String prefix = pref.isJUnitVersion3 ? StrConst.testMethodPrefix4Version3 + pref.testMethodDelimiter : StrConst.empty;
                each.testMethodName = prefix + each.methodName;
                if (pref.isTestMethodGenArgsEnabled) {
                    each.testMethodName += pref.testMethodDelimiter + pref.testMethodArgsPrefix;
                    if (each.argTypes.size() == 0) {
                        each.testMethodName += pref.testMethodArgsDelimiter;
                    }
                    for (ArgType argType : each.argTypes) {
                        each.testMethodName += pref.testMethodArgsDelimiter + argType.nameInMethodName;
                    }
                }
                if (pref.isTestMethodGenReturnEnabled) {
                    each.testMethodName += pref.testMethodDelimiter + pref.testMethodReturnPrefix + pref.testMethodReturnDelimiter + each.returnType.nameInMethodName;
                }
                if (target.matches(RegExp.matchesStaticMethod)) {
                    each.isStatic = true;
                }
                testMethods.add(each);
                if (pref.isTestMethodGenExceptions) {
                    String throwsExceptions = matcher.group(4);
                    if (throwsExceptions != null) {
                        String[] exceptions = throwsExceptions.replaceAll("String_Node_Str" + RegExp.wsPlusMax, StrConst.empty).split(StrConst.comma);
                        for (String exp : exceptions) {
                            exp = exp.trim();
                            MethodInfo expTest = ObjectUtil.deepCopy(each);
                            expTest.testingTargetException = new ExceptionInfo();
                            expTest.testingTargetException.name = exp;
                            expTest.testingTargetException.nameInMethodName = TestCaseGenerateUtil.getTypeAvailableInMethodName(exp);
                            expTest.testMethodName = expTest.testMethodName + pref.testMethodDelimiter + pref.testMethodExceptionPrefix + pref.testMethodExceptionDelimiter + expTest.testingTargetException.nameInMethodName;
                            testMethods.add(expTest);
                        }
                    }
                }
            }
        }
    } finally {
        FileResourceUtil.close(br);
        FileResourceUtil.close(isr);
        FileResourceUtil.close(is);
    }
    classInfo.constructors = constructors;
    classInfo.methods = testMethods;
    return classInfo;
}

Output:
         }
-        List<String> targetConstructors = SourceCodeParseUtil.getTargetConstructors(classInfo.name, targetClassSourceStr, true, true, true);
-        for (String target : targetConstructors) {
-            String groupConstructor = RegExp.wsAsteriskMax + classInfo.name + "String_Node_Str" + RegExp.wsAsteriskMax + "String_Node_Str" + RegExp.wsAsteriskMax + "String_Node_Str";
-            Matcher constructorMatcher = Pattern.compile(groupConstructor).matcher(target);
-            if (constructorMatcher.find()) {
-                ConstructorInfo each = new ConstructorInfo();
-                String args = constructorMatcher.group(1);
-                String[] tmpArr = args.split(StrConst.comma);
-                int tmpArrLen = tmpArr.length;
-                List<String> tmpArrList = new ArrayList<String>();
-                String buf = StrConst.empty;
-                for (int i = 0; i < tmpArrLen; i++) {
-                    String element = tmpArr[i].trim();
-                    if (element.matches("String_Node_Str")) {
-                        tmpArrList.add(element);
-                        continue;
-                    }
-                    if (element.matches("String_Node_Str")) {
-                        buf += element;
-                        continue;
-                    }
-                    if (element.matches("String_Node_Str")) {
-                        String result = buf + StrConst.comma + element;
-                        tmpArrList.add(result);
-                        buf = StrConst.empty;
-                        continue;
-                    }
-                    if (!buf.equals(StrConst.empty)) {
-                        buf += StrConst.comma + element;
-                        continue;
-                    }
-                    tmpArrList.add(element);
-                }
-                String[] argArr = tmpArrList.toArray(new String[0]);
-                if (pref.isTestMethodGenNotBlankEnabled) {
-                    int argArrLen = argArr.length;
-                    for (int i = 0; i < argArrLen; i++) {
-                        ArgType argType = new ArgType();
-                        String argTypeFull = argArr[i];
-                        Matcher toGenericsMatcher = Pattern.compile(RegExp.genericsGroup).matcher(argTypeFull);
-                        while (toGenericsMatcher.find()) {
-                            String[] generics = toGenericsMatcher.group().replaceAll("String_Node_Str", StrConst.empty).replaceAll("String_Node_Str", StrConst.empty).split(StrConst.comma);
-                            for (String generic : generics) {
-                                generic = getClassInSourceCode(generic, StrConst.empty, classInfo.importList);
-                                argType.generics.add(generic);
-                            }
-                        }
-                        String argTypeStr = argTypeFull.replaceAll(RegExp.generics, StrConst.empty);
-                        argType.name = getType(argTypeStr);
-                        argType.nameInMethodName = getTypeAvailableInMethodName(argTypeStr);
-                        each.argTypes.add(argType);
-                        Matcher nameMatcher = RegExp.groupMethodArgNamePattern.matcher(argTypeFull);
-                        if (nameMatcher.find()) {
-                            each.argNames.add(nameMatcher.group(1));
-                        } else {
-                            each.argNames.add("String_Node_Str" + i);
-                        }
-                    }
-                }
-                constructors.add(each);
-            }
-        }
+        constructors = getConstructors(pref, classInfo, targetClassSourceStr);
         List<String> targets = SourceCodeParseUtil.getTargetMethods(targetClassSourceStr, pref.isTestMethodGenIncludePublic, pref.isTestMethodGenIncludeProtected, pref.isTestMethodGenIncludePackageLocal);


Input:
public static JsonTreeNode getSchemaTree(String jsonString, int numberOfElementsAccessiable) {
    JsonTreeNode jsonTreeNode = null;
    try {
        ObjectMapper objMapper = new ObjectMapper();
        JsonNode jsonNode = objMapper.readTree(jsonString);
        jsonTreeNode = new JsonTreeNode();
        jsonTreeNode.addValue(jsonNode);
        jsonTreeNode.setLabel("String_Node_Str");
        jsonTreeNode.setJsonPath("String_Node_Str");
        fetchTreeNode(jsonTreeNode, numberOfElementsAccessiable - 1);
    } catch (IOException e) {
        CommonExceptionHandler.process(e);
    }
    return jsonTreeNode;
}

Output:
         jsonTreeNode.addValue(jsonNode);
-        jsonTreeNode.setLabel("String_Node_Str");
-        jsonTreeNode.setJsonPath("String_Node_Str");
+        String label = "String_Node_Str";
+        if (jsonNode.isArray()) {
+            label = label + "String_Node_Str";
+        }
+        jsonTreeNode.setLabel(label);
+        jsonTreeNode.setJsonPath(label);
         fetchTreeNode(jsonTreeNode, numberOfElementsAccessiable - 1);


Input:
public void skip() {
    moves++;
}

Output:
 public void skip() {
-    moves++;
+    timesteps++;
 }


Input:
public void success(T t, Response response) {
    if (null != mEventDescription) {
        Log.d(LOG_TAG, "String_Node_Str" + mEventDescription + "String_Node_Str");
    }
    if ((null != mUnsentEventsManager) && !mUnsentEventsManager.getNetworkConnectivityReceiver().isConnected()) {
        Log.d(LOG_TAG, "String_Node_Str");
        mUnsentEventsManager.getNetworkConnectivityReceiver().checkNetworkConnection(mUnsentEventsManager.getContext());
    }
    try {
        if (null != mUnsentEventsManager) {
            try {
                mUnsentEventsManager.onEventSent(mApiCallback);
            } catch (Exception e) {
                Log.d(LOG_TAG, "String_Node_Str" + e.getMessage());
            }
        }
        if (null != mApiCallback) {
            try {
                mApiCallback.onSuccess(t);
            } catch (Exception e) {
                Log.d(LOG_TAG, "String_Node_Str" + e.getMessage());
            }
        }
    } catch (Exception e) {
        Log.e(LOG_TAG, "String_Node_Str" + e.getMessage());
    }
}

Output:
     try {
-        if (null != mUnsentEventsManager) {
-            try {
-                mUnsentEventsManager.onEventSent(mApiCallback);
-            } catch (Exception e) {
-                Log.d(LOG_TAG, "String_Node_Str" + e.getMessage());
-            }
-        }
+        onEventSent();
         if (null != mApiCallback) {


Input:
public void testInMemoryFrame() throws Exception {
    Assert.assertNotNull(context);
    GraphService<FooModel> fooModelService = context.getService(FooModel.class);
    FooModel inMemoryModel = fooModelService.create();
    inMemoryModel.setProp1("String_Node_Str").setProp2("String_Node_Str").setProp3("String_Node_Str");
    Iterable<Vertex> vertices = context.getFramed().query().has("String_Node_Str", Text.CONTAINS, FooModel.class.getAnnotation(TypeValue.class).value()).vertices();
    int numberFound = 0;
    for (Vertex v : vertices) {
        numberFound++;
        FooModel framed = (FooModel) context.getFramed().frame(v, WindupVertexFrame.class);
        Assert.assertTrue(framed instanceof FooModel);
        Assert.assertEquals("String_Node_Str", framed.getProp1());
        Assert.assertEquals("String_Node_Str", framed.getProp2());
        Assert.assertEquals("String_Node_Str", framed.getProp3());
    }
    Assert.assertEquals(1, numberFound);
}

Output:
     Assert.assertNotNull(context);
-    GraphService<FooModel> fooModelService = context.getService(FooModel.class);
-    FooModel inMemoryModel = fooModelService.create();
+    GraphService<TestFooModel> fooModelService = context.getService(TestFooModel.class);
+    TestFooModel inMemoryModel = fooModelService.create();
     inMemoryModel.setProp1("String_Node_Str").setProp2("String_Node_Str").setProp3("String_Node_Str");


Input:
public static String getApiClasspath(String executablePath) {
    StringBuilder classpathStr = new StringBuilder(executablePath);
    File apiDir = getPlatformApiDirectory();
    if (apiDir.exists() && apiDir.isDirectory()) {
        classpathStr.append(File.pathSeparator);
        classpathStr.append(apiDir);
    }
    return classpathStr.toString();
}

Output:
     StringBuilder classpathStr = new StringBuilder(executablePath);
-    File apiDir = getPlatformApiDirectory();
+    File apiDir = FileUtil.toFile(aProject.getApiRoot());
     if (apiDir.exists() && apiDir.isDirectory()) {


Input:
public void validateRegistration() {
    if (registNumber == null) {
        return;
    }
    URL registURL = null;
    try {
        IBrandingService brandingService = (IBrandingService) GlobalServiceRegister.getDefault().getService(IBrandingService.class);
        registURL = new URL("String_Node_Str" + brandingService.getAcronym() + "String_Node_Str" + registNumber);
        PlatformUI.getWorkbench().getBrowserSupport().getExternalBrowser().openURL(registURL);
    } catch (PartInitException e) {
        try {
            Runtime.getRuntime().exec("String_Node_Str" + registURL.toString());
        } catch (IOException e2) {
            if (PlatformUI.getWorkbench().getBrowserSupport().isInternalWebBrowserAvailable()) {
                IWebBrowser browser;
                try {
                    browser = PlatformUI.getWorkbench().getBrowserSupport().createBrowser("String_Node_Str");
                    browser.openURL(registURL);
                } catch (PartInitException e1) {
                    ExceptionHandler.process(e);
                }
            } else {
                ExceptionHandler.process(e);
            }
        }
    } catch (MalformedURLException e) {
        ExceptionHandler.process(e);
    }
}

Output:
         IBrandingService brandingService = (IBrandingService) GlobalServiceRegister.getDefault().getService(IBrandingService.class);
-        registURL = new URL("String_Node_Str" + brandingService.getAcronym() + "String_Node_Str" + registNumber);
+        registURL = new URL("String_Node_Str" + DefaultTokenCollector.calcUniqueId() + "String_Node_Str" + brandingService.getAcronym());
         PlatformUI.getWorkbench().getBrowserSupport().getExternalBrowser().openURL(registURL);


Input:
public String getText(Object element) {
    if (isRecycleBin(element)) {
        return ERepositoryObjectType.RECYCLE_BIN.toString();
    }
    return super.getText(element);
}

Output:
     }
-    return super.getText(element);
+    return null;
 }


Input:
public String getDefaultMetaVariable() {
    String n = enumType.getName();
    int idx = n.lastIndexOf(n, '.');
    if (idx >= 0)
        n = n.substring(idx + 1);
    return n.toUpperCase();
}

Output:
     String n = enumType.getName();
-    int idx = n.lastIndexOf(n, '.');
+    int idx = n.lastIndexOf('.');
     if (idx >= 0)


Input:
private static Field findField(MetaBean metaBean, String propertyName) {
    Field field = null;
    Class<?> cls = metaBean.beanType();
    while (cls != DirectBean.class) {
        try {
            field = cls.getDeclaredField(propertyName);
            break;
        } catch (NoSuchFieldException ex) {
            try {
                field = cls.getDeclaredField("String_Node_Str" + propertyName);
                break;
            } catch (NoSuchFieldException ex2) {
                cls = cls.getSuperclass();
            }
        }
    }
    return field;
}

Output:
     Class<?> cls = metaBean.beanType();
-    while (cls != DirectBean.class) {
+    while (cls != DirectBean.class && cls != Object.class && cls != null) {
         try {


Input:
public FloatCContainer normalize() {
    return new FloatCContainer(ConversionTools.normalize(fArContainer, (int) getMin(), (int) getMax()));
}

Output:
 public FloatCContainer normalize() {
-    return new FloatCContainer(ConversionTools.normalize(fArContainer, (int) getMin(), (int) getMax()));
+    return new FloatCContainer(ConversionTools.normalize(container, (int) getMin(), (int) getMax()));
 }


Input:
public static void fixupFunction(Logger logger, GlobalConstants constants, Function fn, Set<Var> referencedGlobals, boolean updateLists) {
    HierarchicalSet<Var> fnargs = new HierarchicalSet<Var>();
    for (Var v : fn.getInputList()) {
        fnargs.add(v);
    }
    for (Var v : fn.getOutputList()) {
        fnargs.add(v);
    }
    fnargs.addAll(constants.vars());
    AliasTracker aliases = new AliasTracker();
    Result res = fixupBlockRec(logger, fn, fn.mainBlock(), ExecContext.CONTROL, fnargs, referencedGlobals, aliases, updateLists);
    if (updateLists) {
        for (int i = 0; i < fn.getOutputList().size(); i++) {
            Var output = fn.getOutput(i);
            if (!res.read.contains(output) && !Types.hasReadableSideChannel(output.type())) {
                fn.makeOutputWriteOnly(i);
            }
        }
    }
    res.removeRead(fn.getInputList());
    res.removeReadWrite(fn.getOutputList());
    for (Var v : fn.getInputList()) {
        if (Types.isPrimUpdateable(v.type())) {
            res.removeWritten(v);
        }
    }
    if (res.read.size() > 0) {
        throw new STCRuntimeError("String_Node_Str" + fn.getName() + "String_Node_Str" + res.read.toString());
    }
    if (res.written.size() > 0) {
        throw new STCRuntimeError("String_Node_Str" + fn.getName() + "String_Node_Str" + res.written.toString());
    }
    if (res.aliasWritten.size() > 0) {
        throw new STCRuntimeError("String_Node_Str" + fn.getName() + "String_Node_Str" + res.aliasWritten.toString());
    }
}

Output:
     AliasTracker aliases = new AliasTracker();
-    Result res = fixupBlockRec(logger, fn, fn.mainBlock(), ExecContext.CONTROL, fnargs, referencedGlobals, aliases, updateLists);
-    if (updateLists) {
+    Result res = fixupBlockRec(logger, fn, fn.mainBlock(), ExecContext.CONTROL, fnargs, referencedGlobals, aliases, fixupMode);
+    if (fixupMode != FixupVarMode.NO_UPDATE) {
         for (int i = 0; i < fn.getOutputList().size(); i++) {


Input:
public <T> T unwrap(java.lang.Class<T> cls) {
    if (cls.isAssignableFrom(this.getClass())) {
        return cls.cast(this);
    }
    throw new IllegalArgumentException("String_Node_Str" + cls + "String_Node_Str");
}

Output:
 public <T> T unwrap(java.lang.Class<T> cls) {
-    if (cls.isAssignableFrom(this.getClass())) {
+    if (cls.isAssignableFrom(((Object) this).getClass())) {
         return cls.cast(this);


Input:
private void checkDataTypeForChartWithAxes(Chart cm) {
    List<SeriesDefinition> sdList = new ArrayList<SeriesDefinition>();
    sdList.addAll(ChartUIUtil.getBaseSeriesDefinitions(cm));
    for (int i = 0; i < sdList.size(); i++) {
        SeriesDefinition sd = sdList.get(i);
        Series series = sd.getDesignTimeSeries();
        checkDataTypeForBaseSeries(ChartUIUtil.getDataQuery(sd, 0), series);
    }
    sdList.clear();
    sdList.addAll(ChartUIUtil.getAllOrthogonalSeriesDefinitions(cm));
    for (int i = 0; i < sdList.size(); i++) {
        SeriesDefinition sd = sdList.get(i);
        Series series = sd.getDesignTimeSeries();
        checkDataTypeForOrthoSeries(ChartUIUtil.getDataQuery(sd, 0), series);
    }
}

Output:
     List<SeriesDefinition> sdList = new ArrayList<SeriesDefinition>();
-    sdList.addAll(ChartUIUtil.getBaseSeriesDefinitions(cm));
+    sdList.addAll(ChartUIUtil.getBaseSeriesDefinitions(getChartModel()));
     for (int i = 0; i < sdList.size(); i++) {


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

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


Input:
public void checkForNameInList(Integer errorCode, String userName, String filename, Integer serverId, Callback userExistsCallback, Callback userNoExistsCallback) throws SecurityException, ClassNotFoundException, NoSuchMethodException {
    String[] failParamTypes = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    Method tryAgain = Callback.getMethod("String_Node_Str", this, failParamTypes);
    Object[] failParams = { null, userName, filename, null, userExistsCallback, userNoExistsCallback };
    Callback tryAgainCallback = new Callback(tryAgain, this, failParams);
    String[] pTypes = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    Method checkForName = Callback.getMethod("String_Node_Str", this, pTypes);
    Object[] p = { null, userName, userExistsCallback, userNoExistsCallback };
    Callback checkForNameCallback = new Callback(checkForName, this, p);
    get(serverId, filename, checkForNameCallback, tryAgainCallback);
}

Output:
     Callback tryAgainCallback = new Callback(tryAgain, this, failParams);
-    String[] pTypes = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+    String[] pTypes = { "String_Node_Str", byte[].class.getName(), String.class.getName(), "String_Node_Str", "String_Node_Str" };
     Method checkForName = Callback.getMethod("String_Node_Str", this, pTypes);


Input:
public void testAggrSort2Cache() throws Exception {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    ILevelDefinition level12 = hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    ILevelDefinition level21 = hier2.createLevel("String_Node_Str");
    createSortTestBindings(cqd);
    CubeSortDefinition sorter1 = new CubeSortDefinition();
    sorter1.setExpression("String_Node_Str");
    sorter1.setAxisQualifierLevels(null);
    sorter1.setAxisQualifierValues(null);
    sorter1.setTargetLevel(level21);
    sorter1.setSortDirection(ISortDefinition.SORT_DESC);
    CubeSortDefinition sorter2 = new CubeSortDefinition();
    sorter2.setExpression("String_Node_Str");
    sorter2.setAxisQualifierLevels(new ILevelDefinition[] { level21 });
    sorter2.setAxisQualifierValues(new Object[] { "String_Node_Str" });
    sorter2.setTargetLevel(level12);
    sorter2.setSortDirection(ISortDefinition.SORT_DESC);
    cqd.addSort(sorter1);
    cqd.addSort(sorter2);
    DataEngine engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
    this.createCube(engine);
    cqd.setCacheQueryResults(true);
    IPreparedCubeQuery pcq = engine.prepare(cqd, null);
    ICubeQueryResults queryResults = pcq.execute(null);
    CubeCursor cursor = queryResults.getCubeCursor();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    cqd.setQueryResultsID(queryResults.getID());
    pcq = engine.prepare(cqd, null);
    queryResults = pcq.execute(null);
    cursor = queryResults.getCubeCursor();
    printCube(cursor, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }, "String_Node_Str", "String_Node_Str");
}

Output:
     cqd.addSort(sorter2);
-    DataEngine engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
+    DataEngineImpl engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
     this.createCube(engine);


Input:
void register() {
    if (isVirtual()) {
        return;
    }
    ArrayList list = new ArrayList();
    Member[] measures = getMeasures();
    for (int i = 0; i < measures.length; i++) {
        if (measures[i] instanceof RolapStoredMeasure) {
            list.add(measures[i]);
        }
    }
    RolapStoredMeasure[] storedMeasures = (RolapStoredMeasure[]) list.toArray(new RolapStoredMeasure[list.size()]);
    for (int i = 0; i < storedMeasures.length; i++) {
        RolapStoredMeasure storedMeasure = storedMeasures[i];
        RolapStar star = RolapStar.Pool.instance().getOrCreateStar(schema, this.fact);
        RolapStar.Measure measure = new RolapStar.Measure();
        measure.table = star.factTable;
        measure.expression = storedMeasure.expression;
        measure.aggregator = storedMeasure.aggregator;
        measure.isNumeric = true;
        storedMeasure.starMeasure = measure;
        star.factTable.columns.add(measure);
        RolapDimension[] dimensions = (RolapDimension[]) this.getDimensions();
        for (int j = 0; j < dimensions.length; j++) {
            RolapDimension dimension = dimensions[j];
            RolapHierarchy[] hierarchies = (RolapHierarchy[]) dimension.getHierarchies();
            for (int k = 0; k < hierarchies.length; k++) {
                RolapHierarchy hierarchy = hierarchies[k];
                HierarchyUsage hierarchyUsage = schema.getUsage(hierarchy, this);
                MondrianDef.Relation relation = hierarchy.getRelation();
                if (relation == null) {
                    continue;
                }
                RolapStar.Table table = star.factTable;
                if (!relation.equals(table.relation)) {
                    RolapStar.Condition joinCondition = new RolapStar.Condition(table.getAlias(), hierarchyUsage.foreignKey, hierarchyUsage.primaryKeyTable.getAlias(), hierarchyUsage.primaryKey);
                    table = table.addJoin(relation, joinCondition);
                }
                RolapLevel[] levels = (RolapLevel[]) hierarchy.getLevels();
                for (int l = 0; l < levels.length; l++) {
                    RolapLevel level = levels[l];
                    if (level.nameExp == null) {
                        continue;
                    } else {
                        RolapStar.Column column = new RolapStar.Column();
                        if (level.nameExp instanceof MondrianDef.Column) {
                            column.table = table.findDescendant(((MondrianDef.Column) level.nameExp).table);
                        } else {
                            column.table = table;
                        }
                        column.expression = level.nameExp;
                        column.isNumeric = (level.flags & RolapLevel.NUMERIC) != 0;
                        table.columns.add(column);
                        star.mapLevelToColumn.put(level, column);
                    }
                }
            }
        }
    }
}

Output:
                         if (level.nameExp instanceof MondrianDef.Column) {
-                            column.table = table.findDescendant(((MondrianDef.Column) level.nameExp).table);
+                            String tableName = ((MondrianDef.Column) level.nameExp).table;
+                            column.table = table.findAncestor(tableName);
+                            if (column.table == null) {
+                                throw Util.newError("String_Node_Str" + level.getUniqueName() + "String_Node_Str" + this + "String_Node_Str" + tableName + "String_Node_Str");
+                            }
                         } else {


Input:
public final void process(final Class<?> entityClass, EntityMetadata metadata) {
    EntityListeners entityListeners = (EntityListeners) entityClass.getAnnotation(EntityListeners.class);
    if (entityListeners != null) {
        Class<?>[] entityListenerClasses = entityListeners.value();
        if (entityListenerClasses != null) {
            for (Class<?> entityListener : entityListenerClasses) {
                try {
                    entityListener.getConstructor();
                } catch (NoSuchMethodException nsme) {
                    throw new MetamodelLoaderException("String_Node_Str" + entityListener.getName() + "String_Node_Str");
                }
                for (Method method : entityListener.getDeclaredMethods()) {
                    List<Class<?>> jpaAnnotations = getValidJPAAnnotationsFromMethod(entityListener, method, 1);
                    for (Class<?> jpaAnnotation : jpaAnnotations) {
                        CallbackMethod callBackMethod = new ExternalCallbackMethod(entityListener, method);
                        addCallBackMethod(metadata, jpaAnnotation, callBackMethod);
                    }
                }
            }
        }
    }
    for (Method method : entityClass.getDeclaredMethods()) {
        List<Class<?>> jpaAnnotations = getValidJPAAnnotationsFromMethod(entityClass, method, 0);
        for (Class<?> jpaAnnotation : jpaAnnotations) {
            CallbackMethod callbackMethod = new InternalCallbackMethod(metadata, method);
            addCallBackMethod(metadata, jpaAnnotation, callbackMethod);
        }
    }
}

Output:
                 for (Method method : entityListener.getDeclaredMethods()) {
-                    List<Class<?>> jpaAnnotations = getValidJPAAnnotationsFromMethod(entityListener, method, 1);
+                    List<Class<?>> jpaAnnotations = getValidJPAAnnotationsFromMethod(entityListener, method, 1, entityClass);
                     for (Class<?> jpaAnnotation : jpaAnnotations) {


Input:
public List<String> call() throws IOException {
    List<String> validFiles = new ArrayList<String>();
    HashSet<String> buildSpecFiles = new HashSet<String>();
    populateFileList();
    try (Scanner scanner = new Scanner(Paths.get(buildSpec))) {
        while (scanner.hasNextLine()) {
            processBuildSpecLine(scanner.nextLine(), buildSpecFiles);
        }
    }
    for (String file : fileList) {
        if (buildSpecFiles.contains(file)) {
            validFiles.add(file);
        }
    }
    return validFiles;
}

Output:
     for (String file : fileList) {
-        if (buildSpecFiles.contains(file)) {
-            validFiles.add(file);
+        for (String bsFile : buildSpecFiles) {
+            if ((bsFile.contains("String_Node_Str") && bsFile.toLowerCase().equals(file.toLowerCase())) || (!bsFile.contains("String_Node_Str") && bsFile.equals(file))) {
+                validFiles.add(file);
+            }
         }


Input:
private void selectPagesAllIndicator() {
    IIndicatorNode[] branchNodes = IndicatorTreeModelBuilder.buildIndicatorCategory();
    for (ModelElementIndicator modelEleIndi : getResult()) {
        List<IndicatorEnum> tempIndicator = modelEleIndi.getTempIndicator();
        if (null != tempIndicator) {
            tempIndicator.clear();
        }
        for (IIndicatorNode iIndicatorNode : branchNodes) {
            addModelElementIndicator(modelEleIndi, iIndicatorNode);
        }
    }
}

Output:
         }
-        for (IIndicatorNode iIndicatorNode : branchNodes) {
-            addModelElementIndicator(modelEleIndi, iIndicatorNode);
+    } else {
+        for (ModelElementIndicator modelEleIndi : getResult()) {
+            modelEleIndi.getTempIndicator().clear();
         }


Input:
private String getAxisLabel(DataType type, String field) {
    String label = FIELD_AXIS_NAMES.get(field);
    if (label != null) {
        return label;
    } else if (field.endsWith("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.contains("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.startsWith("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.startsWith("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.endsWith("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.endsWith("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.contains("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.contains("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.endsWith("String_Node_Str")) {
        return "String_Node_Str";
    } else if (field.contains("String_Node_Str")) {
        return "String_Node_Str";
    } else {
        return getAxisLabel(type);
    }
}

Output:
         return "String_Node_Str";
-    } else if (field.contains("String_Node_Str")) {
+    } else if (field.toLowerCase().contains("String_Node_Str")) {
+        return "String_Node_Str";
+    } else if (field.toLowerCase().contains("String_Node_Str")) {
+        return "String_Node_Str";
+    } else if (field.toLowerCase().contains("String_Node_Str")) {
+        return "String_Node_Str";
+    } else if (field.toLowerCase().contains("String_Node_Str")) {
         return "String_Node_Str";