Input:
public void keyPresses(String sKey) {
    if (sKey.length() > 1) {
        if (mSolved)
            replaceExpression(sKey);
        else
            insertAtSelection(sKey);
        mSolved = false;
        return;
    }
    if (sKey.matches(regexHasInvalidChars))
        throw new IllegalArgumentException("String_Node_Str");
    if (sKey.matches(regexInvalidStartChar) && (getLastNumb().equals("String_Node_Str") || expresssionToSelection().matches("String_Node_Str")))
        return;
    if (mSolved && sKey.matches("String_Node_Str"))
        clearExpression();
    if (sKey.equals("String_Node_Str") && expresssionToSelection().matches("String_Node_Str"))
        sKey = "String_Node_Str" + sKey;
    if (sKey.matches("String_Node_Str") && expresssionToSelection().matches("String_Node_Str"))
        sKey = "String_Node_Str" + sKey;
    if (sKey.equals("String_Node_Str"))
        if (numOpenPara() <= 0)
            addToExpressionStart("String_Node_Str");
    if (sKey.equals("String_Node_Str") && getLastNumb().matches("String_Node_Str"))
        if (!expresssionToSelection().matches("String_Node_Str" + regexAnyValidOperator + "String_Node_Str"))
            return;
    if (sKey.equals("String_Node_Str") && (getLastNumb().contains("String_Node_Str") || expresssionToSelection().matches("String_Node_Str" + regexAnyValidOperator + "String_Node_Str")))
        return;
    if (getLastNumb().matches("String_Node_Str"))
        if (sKey.matches("String_Node_Str"))
            return;
    if (sKey.matches(regexAnyOperatorOrE) && getLastNumb().equals("String_Node_Str"))
        return;
    if (sKey.matches("String_Node_Str") && expresssionToSelection().matches("String_Node_Str"))
        return;
    if (sKey.matches(regexAnyValidOperator) && expresssionToSelection().matches("String_Node_Str" + regexAnyValidOperator + regexAnyValidOperator + "String_Node_Str")) {
        if (getSelectionEnd() > getSelectionStart())
            backspaceAtSelection();
        backspaceAtSelection();
        backspaceAtSelection();
    } else if (sKey.matches(regexInvalidStartChar) && expresssionToSelection().matches("String_Node_Str" + regexAnyValidOperator + "String_Node_Str")) {
        if (getSelectionEnd() > getSelectionStart())
            backspaceAtSelection();
        backspaceAtSelection();
    }
    insertAtSelection(sKey);
    mSolved = false;
}

Output:
         return;
-    if (sKey.matches(regexAnyValidOperator) && expresssionToSelection().matches("String_Node_Str" + regexAnyValidOperator + regexAnyValidOperator + "String_Node_Str")) {
+    if (sKey.matches("String_Node_Str") && expresssionToSelection().matches("String_Node_Str"))
+        return;
+    if (sKey.matches(regexAnyValidOperator) && expresssionToSelection().matches("String_Node_Str" + regexAnyOpExceptPercent + regexAnyValidOperator + "String_Node_Str")) {
         if (getSelectionEnd() > getSelectionStart())


Input:
public boolean read(Buffer buffer) throws PortAudioException {
    synchronized (readSync) {
        if (readActive) {
            return false;
        }
        readActive = true;
        if (!started) {
            buffer.setLength(0);
            return true;
        }
    }
    Object data = buffer.getData();
    byte[] bufferData;
    if (data instanceof byte[] && ((byte[]) data).length >= bytesPerBuffer) {
        bufferData = (byte[]) data;
    } else {
        bufferData = new byte[bytesPerBuffer];
        buffer.setData(bufferData);
    }
    synchronized (connectedToStreamSync) {
        PortAudio.Pa_ReadStream(stream, bufferData, framesPerBuffer);
    }
    long bufferTimeStamp = System.nanoTime();
    buffer.setFlags(Buffer.FLAG_SYSTEM_TIME);
    buffer.setLength(bytesPerBuffer);
    buffer.setOffset(0);
    buffer.setTimeStamp(bufferTimeStamp);
    int slaveCount = slaves.size();
    for (int slaveIndex = 0; slaveIndex < slaveCount; slaveIndex++) {
        slaves.get(slaveIndex).setBuffer(bufferData, bytesPerBuffer, bufferTimeStamp);
    }
    synchronized (readSync) {
        readActive = false;
        readSync.notify();
    }
    return true;
}

Output:
     }
-    Object data = buffer.getData();
-    byte[] bufferData;
-    if (data instanceof byte[] && ((byte[]) data).length >= bytesPerBuffer) {
-        bufferData = (byte[]) data;
-    } else {
-        bufferData = new byte[bytesPerBuffer];
-        buffer.setData(bufferData);
-    }
-    synchronized (connectedToStreamSync) {
-        PortAudio.Pa_ReadStream(stream, bufferData, framesPerBuffer);
-    }
-    long bufferTimeStamp = System.nanoTime();
-    buffer.setFlags(Buffer.FLAG_SYSTEM_TIME);
-    buffer.setLength(bytesPerBuffer);
-    buffer.setOffset(0);
-    buffer.setTimeStamp(bufferTimeStamp);
-    int slaveCount = slaves.size();
-    for (int slaveIndex = 0; slaveIndex < slaveCount; slaveIndex++) {
-        slaves.get(slaveIndex).setBuffer(bufferData, bytesPerBuffer, bufferTimeStamp);
-    }
-    synchronized (readSync) {
-        readActive = false;
-        readSync.notify();
+    try {
+        Object data = buffer.getData();
+        byte[] bufferData = null;
+        if (data instanceof byte[]) {
+            bufferData = (byte[]) data;
+            if (bufferData.length < bytesPerBuffer)
+                bufferData = null;
+        }
+        if (bufferData == null) {
+            bufferData = new byte[bytesPerBuffer];
+            buffer.setData(bufferData);
+        }
+        synchronized (connectedToStreamSync) {
+            PortAudio.Pa_ReadStream(stream, bufferData, framesPerBuffer);
+        }
+        long bufferTimeStamp = System.nanoTime();
+        buffer.setFlags(Buffer.FLAG_SYSTEM_TIME);
+        buffer.setLength(bytesPerBuffer);
+        buffer.setOffset(0);
+        buffer.setTimeStamp(bufferTimeStamp);
+        int slaveCount = slaves.size();
+        for (int slaveIndex = 0; slaveIndex < slaveCount; slaveIndex++) {
+            slaves.get(slaveIndex).setBuffer(bufferData, bytesPerBuffer, bufferTimeStamp);
+        }
+    } finally {
+        synchronized (readSync) {
+            readActive = false;
+            readSync.notify();
+        }
     }


Input:
public UITableViewCell getCellForRow(UITableView tableView, NSIndexPath indexPath) {
    final String cellIdentifier = "String_Node_Str";
    UITableViewCell cell = tableView.dequeueReusableCell(cellIdentifier);
    if (cell == null) {
        cell = new UITableViewCell(UITableViewCellStyle.Subtitle, cellIdentifier);
        cell.setAccessoryType(UITableViewCellAccessoryType.DisclosureIndicator);
    }
    NSURL fileURL;
    if (indexPath.getSection() == 0) {
        fileURL = new NSURL(new File(NSBundle.getMainBundle().findResourcePath(documents[(int) indexPath.getRow()], null)));
    } else {
        fileURL = documentURLs.get((int) indexPath.getRow());
    }
    setupDocumentController(fileURL);
    cell.getTextLabel().setText(fileURL.getLastPathComponent());
    int iconCount = docInteractionController.getIcons().size();
    if (iconCount > 0) {
        cell.getImageView().setImage(docInteractionController.getIcons().get(iconCount - 1));
    }
    try {
        String fileURLString = docInteractionController.getURL().getPath();
        NSFileAttributes fileAttributes = NSFileManager.getDefaultManager().getAttributesOfItemAtPath(fileURLString);
        long fileSize = fileAttributes.getSize();
        String fileSizeStr = NSByteCountFormatter.format(fileSize, NSByteCountFormatterCountStyle.File);
        cell.getDetailTextLabel().setText(String.format("String_Node_Str", fileSizeStr, docInteractionController.getUTI()));
        UILongPressGestureRecognizer longPressGesture = new UILongPressGestureRecognizer(new UIGestureRecognizer.GestureListener() {

            public void handleGesture(UIGestureRecognizer gestureRecognizer) {
                UILongPressGestureRecognizer longPressGesture = (UILongPressGestureRecognizer) gestureRecognizer;
                if (longPressGesture.getState() == UIGestureRecognizerState.Began) {
                    NSIndexPath cellIndexPath = getTableView().getIndexPathForRow(longPressGesture.getLocationInView(getTableView()));
                    NSURL fileURL;
                    if (cellIndexPath.getSection() == 0) {
                        fileURL = new NSURL(new File(NSBundle.getMainBundle().findResourcePath(documents[(int) cellIndexPath.getRow()], null)));
                    } else {
                        fileURL = documentURLs.get((int) cellIndexPath.getRow());
                    }
                    docInteractionController.setURL(fileURL);
                    docInteractionController.presentOptionsMenu(longPressGesture.getView().getFrame(), longPressGesture.getView(), true);
                }
            }
        });
        cell.getImageView().addGestureRecognizer(longPressGesture);
        cell.getImageView().setUserInteractionEnabled(true);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return cell;
}

Output:
         cell.getDetailTextLabel().setText(String.format("String_Node_Str", fileSizeStr, docInteractionController.getUTI()));
-        UILongPressGestureRecognizer longPressGesture = new UILongPressGestureRecognizer(new UIGestureRecognizer.GestureListener() {
+        UILongPressGestureRecognizer longPressGesture = new UILongPressGestureRecognizer(new UIGestureRecognizer.OnGestureListener() {


Input:
public static <T> List<T> asList(T... array) {
    List<T> accum = new ArrayList<T>();
    for (int i = 0; i < array.length; i++) {
        accum.add(array[i]);
    }
    return accum;
}

Output:
 public static <T> List<T> asList(T... array) {
-    List<T> accum = new ArrayList<T>();
-    for (int i = 0; i < array.length; i++) {
-        accum.add(array[i]);
-    }
-    return accum;
+    return new ArrayList<T>(array);
 }


Input:
private DocumentNodeStore createNodeStore(String workingDir) throws SecurityException, Exception {
    setFinalStatic(ClusterNodeInfo.class.getDeclaredField("String_Node_Str"), workingDir);
    DocumentMK mk1 = createMK(0, 500);
    logger.info("String_Node_Str" + mk1.nodeStore.getClusterId() + "String_Node_Str" + workingDir);
    return mk1.nodeStore;
}

Output:
 private DocumentNodeStore createNodeStore(String workingDir) throws SecurityException, Exception {
-    setFinalStatic(ClusterNodeInfo.class.getDeclaredField("String_Node_Str"), workingDir);
-    DocumentMK mk1 = createMK(0, 500);
-    logger.info("String_Node_Str" + mk1.nodeStore.getClusterId() + "String_Node_Str" + workingDir);
-    return mk1.nodeStore;
+    Object prevWorkingDir = System.getProperty("String_Node_Str", "String_Node_Str");
+    try {
+        prevWorkingDir = setFinalStatic(ClusterNodeInfo.class.getDeclaredField("String_Node_Str"), workingDir);
+        DocumentMK mk1 = createMK(0, 500);
+        logger.info("String_Node_Str" + mk1.nodeStore.getClusterId() + "String_Node_Str" + workingDir);
+        return mk1.nodeStore;
+    } finally {
+        setFinalStatic(ClusterNodeInfo.class.getDeclaredField("String_Node_Str"), prevWorkingDir);
+    }
 }


Input:
public SopremoModule asElementaryOperators() {
    final SopremoModule sopremoModule = new SopremoModule(this.getName(), 1, 1);
    JsonStream input = sopremoModule.getInput(0);
    int itCount = 2;
    TransformAKey[] a = new TransformAKey[itCount];
    TransformBKey[] b = new TransformBKey[itCount];
    TransformXKey[] x = new TransformXKey[itCount];
    BAndXCoGroup[] xb = new BAndXCoGroup[itCount];
    ACoGroup[] axb = new ACoGroup[itCount];
    for (int i = 0; i < itCount; i++) {
        a[i] = new TransformAKey().withInputs(i == 0 ? input : axb[i - 1]);
        a[i].setIterationStep(i + 1);
        b[i] = new TransformBKey().withInputs(i == 0 ? input : axb[i - 1]);
        b[i].setIterationStep(i + 1);
        x[i] = new TransformXKey().withInputs(i == 0 ? input : axb[i - 1]);
        xb[i] = new BAndXCoGroup().withInputs(b[i], x[i]);
        axb[i] = new ACoGroup().withInputs(a[i], xb[i]);
    }
    sopremoModule.getOutput(0).setInput(0, axb[itCount - 1]);
    return sopremoModule;
}

Output:
     JsonStream input = sopremoModule.getInput(0);
-    int itCount = 2;
+    int itCount = 3;
     TransformAKey[] a = new TransformAKey[itCount];


Input:
public void place(int p) {
    point(worldToCamera(p));
}

Output:
 public void place(int p) {
-    point(worldToCamera(p));
+    if (Dungeon.level != null)
+        point(worldToCamera(p));
 }


Input:
public void handleRequest(HttpServerExchange exchange, RequestContext context) throws Exception {
    ObjectId etag = RequestHelper.getUpdateEtag(exchange);
    if (etag == null) {
        ResponseHelper.endExchangeWithMessage(exchange, HttpStatus.SC_CONFLICT, "String_Node_Str" + Headers.ETAG + "String_Node_Str");
        logger.warn("String_Node_Str", Headers.ETAG);
        return;
    }
    if (context.getWarnings() != null && !context.getWarnings().isEmpty()) {
        DocumentRepresentationFactory.sendDocument(exchange.getRequestPath(), exchange, context, new BasicDBObject());
    }
    ResponseHelper.endExchange(exchange, CollectionDAO.deleteCollection(context.getDBName(), context.getCollectionName(), etag));
    LocalCachesSingleton.getInstance().invalidateCollection(context.getDBName(), context.getCollectionName());
}

Output:
     }
-    ResponseHelper.endExchange(exchange, CollectionDAO.deleteCollection(context.getDBName(), context.getCollectionName(), etag));
+    exchange.endExchange();
     LocalCachesSingleton.getInstance().invalidateCollection(context.getDBName(), context.getCollectionName());


Input:
public static void handleOnPageBreak(IListContent content, ExecutionContext context) {
    ReportItemDesign listDesign = (ReportItemDesign) content.getGenerateBy();
    if (!needOnPageBreak(listDesign)) {
        return;
    }
    try {
        IListInstance list = new ListInstance(content, context, RunningState.PAGEBREAK);
        if (handleScript(list, listDesign.getOnPageBreak(), context).didRun())
            return;
        IListEventHandler eh = getEventHandler(listDesign, context);
        if (eh != null)
            eh.onPageBreak(list, context.getReportContext());
    } catch (Exception e) {
        addException(context, e, listDesign.getHandle());
    }
}

Output:
     ReportItemDesign listDesign = (ReportItemDesign) content.getGenerateBy();
-    if (!needOnPageBreak(listDesign)) {
+    if (!needOnPageBreak(listDesign, context)) {
         return;


Input:
String getShortAccessString(TypeName fieldType, String elementName, boolean isModelContainerAdapter) {
    return CodeBlock.builder().add("String_Node_Str", getExistingColumnAccess().getShortAccessString(fieldType, elementName, isModelContainerAdapter)).build().toString();
}

Output:
 String getShortAccessString(TypeName fieldType, String elementName, boolean isModelContainerAdapter) {
-    return CodeBlock.builder().add("String_Node_Str", getExistingColumnAccess().getShortAccessString(fieldType, elementName, isModelContainerAdapter)).build().toString();
+    if (isModelContainerAdapter) {
+        return getExistingColumnAccess().getShortAccessString(fieldType, elementName, isModelContainerAdapter);
+    } else {
+        return CodeBlock.builder().add("String_Node_Str", getExistingColumnAccess().getShortAccessString(fieldType, elementName, isModelContainerAdapter)).build().toString();
+    }
 }


Input:
public MethodHandler getHandler(Object o) {
    return instrumentors.get(o.getClass()).getInvoker(o);
}

Output:
 public MethodHandler getHandler(Object o) {
-    return instrumentors.get(o.getClass()).getInvoker(o);
+    Instrumentor instrumentor = instrumentors.get(o.getClass());
+    return instrumentor != null ? instrumentor.getInvoker(o) : null;
 }


Input:
public Map setup(HttpServletRequest request, HttpServletResponse response, Configuration config, Map errors) {
    String autodetect = request.getParameter(Configuration.APP_REAL_AUTODETECT) != null ? "String_Node_Str" : "String_Node_Str";
    config.setRealAutodetect(autodetect);
    if ("String_Node_Str".equals(autodetect)) {
        config.setRealHost(request.getParameter(Configuration.APP_REAL_HOST));
        String portStr = request.getParameter(Configuration.APP_REAL_PORT);
        config.setRealPort(request.getParameter(Configuration.APP_REAL_PORT));
        if (portStr != null && !"String_Node_Str".equals(portStr)) {
            try {
                Integer.parseInt(portStr);
            } catch (NumberFormatException e) {
                errors.put(Configuration.APP_REAL_PORT, Configuration.APP_REAL_PORT);
            }
        }
    }
    String realProtocol = request.getParameter(Configuration.APP_REAL_PROTOCOL);
    if (null != realProtocol && !"String_Node_Str".equals(realProtocol)) {
        config.setRealPath(realProtocol.trim());
    }
    String realPath = request.getParameter(Configuration.APP_REAL_PATH);
    if (null != realPath && !"String_Node_Str".equals(realPath)) {
        realPath = realPath.trim();
        config.setRealPath(realPath.startsWith("String_Node_Str") ? realPath : "String_Node_Str" + realPath);
    }
    return errors;
}

Output:
     if (null != realProtocol && !"String_Node_Str".equals(realProtocol)) {
-        config.setRealPath(realProtocol.trim());
+        config.setRealProtocol(realProtocol.trim());
     }


Input:
protected boolean isCrossbowInfinite(ItemStack stack, EntityPlayer player) {
    int enchant = net.minecraft.enchantment.EnchantmentHelper.getEnchantmentLevel(net.minecraft.init.Enchantments.INFINITY, stack);
    return enchant > 0;
}

Output:
 protected boolean isCrossbowInfinite(ItemStack stack, EntityPlayer player) {
-    int enchant = net.minecraft.enchantment.EnchantmentHelper.getEnchantmentLevel(net.minecraft.init.Enchantments.INFINITY, stack);
+    int enchant = EnchantmentHelper.getEnchantmentLevel(net.minecraft.init.Enchantments.INFINITY, stack);
     return enchant > 0;


Input:
private void setInstructorComments(String giverEmail, String currentInstructorEmail, String courseId, Map<String, List<CommentAttributes>> comments, Map<String, List<Boolean>> commentModifyPermissions) {
    List<CommentAttributes> commentsForGiverList;
    List<Boolean> canModifyCommentList = new ArrayList<Boolean>();
    commentsForGiverList = getCommentsForGiverInCourse(giverEmail, courseId);
    for (int i = 0; i < commentsForGiverList.size(); i++) {
        canModifyCommentList.add(true);
    }
    String key = giverEmail;
    if (giverEmail.equals(currentInstructorEmail)) {
        key = InstructorCommentsPageData.COMMENT_GIVER_NAME_THAT_COMES_FIRST;
    }
    commentModifyPermissions.put(key, canModifyCommentList);
    comments.put(key, commentsForGiverList);
}

Output:
     if (giverEmail.equals(currentInstructorEmail)) {
-        key = InstructorCommentsPageData.COMMENT_GIVER_NAME_THAT_COMES_FIRST;
+        key = COMMENT_GIVER_NAME_THAT_COMES_FIRST;
     }


Input:
protected String createSqlStatement(Analysis analysis) {
    if (isDelimitedFile) {
        return "String_Node_Str";
    }
    this.cachedAnalysis = analysis;
    StringBuilder sql = new StringBuilder("String_Node_Str");
    EList<Indicator> indicators = analysis.getResults().getIndicators();
    EList<MetadataColumn> analysedElements = null;
    for (Indicator indicator : indicators) {
        if (ColumnsetPackage.eINSTANCE.getColumnSetMultiValueIndicator().isSuperTypeOf(indicator.eClass())) {
            ColumnSetMultiValueIndicator colSetMultValIndicator = (ColumnSetMultiValueIndicator) indicator;
            if (analysedElements == null) {
                analysedElements = colSetMultValIndicator.getAnalyzedColumns();
            } else {
                analysedElements.addAll(colSetMultValIndicator.getAnalyzedColumns());
            }
        }
    }
    if (analysedElements == null || analysedElements.isEmpty()) {
        this.errorMessage = Messages.getString("String_Node_Str", analysis.getName());
        return null;
    }
    Set<ColumnSet> fromPart = new HashSet<ColumnSet>();
    final Iterator<MetadataColumn> iterator = analysedElements.iterator();
    while (iterator.hasNext()) {
        ModelElement modelElement = iterator.next();
        TdColumn col = SwitchHelpers.COLUMN_SWITCH.doSwitch(modelElement);
        if (col == null) {
            this.errorMessage = Messages.getString("String_Node_Str", modelElement);
            return null;
        }
        Classifier owner = col.getOwner();
        if (owner == null) {
            this.errorMessage = Messages.getString("String_Node_Str", col.getName());
        }
        ColumnSet colSet = SwitchHelpers.COLUMN_SET_SWITCH.doSwitch(owner);
        if (colSet == null) {
            this.errorMessage = Messages.getString("String_Node_Str", col.getName(), colSet);
            return null;
        }
        if (!analysis.getParameters().isStoreData()) {
            sql.append(this.quote(col.getName()));
            if (iterator.hasNext()) {
                sql.append(',');
            }
        }
        fromPart.add(colSet);
    }
    if (fromPart.size() != 1) {
        log.error("String_Node_Str" + fromPart.size() + "String_Node_Str");
        this.errorMessage = "String_Node_Str";
        return null;
    }
    if (analysis.getParameters().isStoreData()) {
        List<TdColumn> columnList = TableHelper.getColumns(SwitchHelpers.TABLE_SWITCH.doSwitch(analysedElements.get(0).eContainer()));
        Iterator<TdColumn> iter = columnList.iterator();
        while (iter.hasNext()) {
            TdColumn column = iter.next();
            sql.append(this.quote(column.getName()));
            if (iter.hasNext()) {
                sql.append(',');
            }
        }
    }
    sql.append(dbms().from());
    ModelElement element = fromPart.iterator().next();
    Package parentRelation = PackageHelper.getParentPackage((MetadataTable) fromPart.iterator().next());
    if (parentRelation instanceof Schema) {
        sql.append(dbms().toQualifiedName(null, parentRelation.getName(), element.getName()));
    } else if (parentRelation instanceof Catalog) {
        String ownerUser = null;
        if (ConnectionUtils.isSybaseeDBProducts(dbms().getDbmsName())) {
            ownerUser = ColumnSetHelper.getTableOwner((ModelElement) element);
        }
        sql.append(dbms().toQualifiedName(parentRelation.getName(), ownerUser, element.getName()));
    }
    ModelElementAnalysisHandler handler = new ModelElementAnalysisHandler();
    handler.setAnalysis(analysis);
    String stringDataFilter = handler.getStringDataFilter();
    sql.append(GenericSQLHandler.WHERE_CLAUSE);
    String sqlStatement = sql.toString();
    sqlStatement = dbms().addWhereToStatement(sqlStatement, stringDataFilter);
    return sqlStatement;
}

Output:
     EList<Indicator> indicators = analysis.getResults().getIndicators();
-    EList<MetadataColumn> analysedElements = null;
+    EList<ModelElement> analysedElements = null;
     for (Indicator indicator : indicators) {


Input:
public void setBiomes(LocalChunk<char[]> lc) {
    if (lc.biomes != null) {
        World worldObj = getSpongeWorld();
        int bx = lc.getX() << 4;
        int bz = lc.getX() << 4;
        String last = null;
        BiomeType biome = null;
        for (int x = 0; x < lc.biomes.length; x++) {
            String[] biomes2 = lc.biomes[x];
            if (biomes2 != null) {
                for (int y = 0; y < biomes2.length; y++) {
                    String biomeStr = biomes2[y];
                    if (biomeStr != null) {
                        if (last == null || !StringMan.isEqual(last, biomeStr)) {
                            biome = SpongeUtil.getBiome(biomeStr.toUpperCase());
                        }
                        worldObj.setBiome(bx, bz, biome);
                    }
                }
            }
        }
    }
}

Output:
                         }
-                        worldObj.setBiome(bx, bz, biome);
+                        worldObj.setBiome(bx, 0, bz, biome);
                     }


Input:
public List<DSpaceObject> replaceAll(Context context, DSpaceObject dso, File pkgFile, PackageParameters params) throws PackageException, UnsupportedOperationException, CrosswalkException, AuthorizeException, SQLException, IOException {
    if (!params.recursiveModeEnabled()) {
        params.setRecursiveModeEnabled(true);
    }
    DSpaceObject replacedDso = replace(context, dso, pkgFile, params);
    if (replacedDso != null) {
        addToIngestedList(replacedDso);
        if (replacedDso.getType() != Constants.ITEM) {
            List<String> childPkgRefs = getPackageReferences(replacedDso);
            if (childPkgRefs != null && !childPkgRefs.isEmpty()) {
                for (String childPkgRef : childPkgRefs) {
                    int oldSize = dsoIngestedList.size();
                    File childPkg = new File(pkgFile.getAbsoluteFile().getParent(), childPkgRef);
                    replaceAll(context, null, childPkg, params);
                    if (Constants.COLLECTION == replacedDso.getType() && dsoIngestedList.size() > oldSize) {
                        Item childItem = (Item) dsoIngestedList.get(oldSize);
                        Collection collection = (Collection) replacedDso;
                        if (!childItem.isIn(collection)) {
                            collection.addItem(childItem);
                        }
                    }
                }
            }
        }
    }
    return getIngestedList();
}

Output:
     }
-    DSpaceObject replacedDso = replace(context, dso, pkgFile, params);
+    DSpaceObject replacedDso = null;
+    if (!getIngestedMap().containsKey(pkgFile)) {
+        replacedDso = replace(context, dso, pkgFile, params);
+    } else {
+        log.info(LogManager.getHeader(context, "String_Node_Str", "String_Node_Str" + pkgFile.getName()));
+    }
     if (replacedDso != null) {


Input:
private static String formatList(Collection list, boolean verbose) {
    StringBuffer buffer = new StringBuffer("String_Node_Str");
    boolean first = true;
    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
        if (first) {
            first = false;
        } else {
            buffer.append("String_Node_Str");
        }
        buffer.append(format(iter.next(), verbose));
    }
    buffer.append("String_Node_Str");
    return buffer.toString();
}

Output:
     boolean first = true;
-    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
+    for (Object item : collection) {
         if (first) {


Input:
public void shouldDeleteOneToManyDeep() {
    deleteAndPopulateTables("String_Node_Str", "String_Node_Str", "String_Node_Str");
    a(Address.count()).shouldBeEqual(7);
    a(Room.count()).shouldBeEqual(4);
    User u = User.findById(1);
    u.deleteCascade();
    a(u).shouldBe("String_Node_Str");
    a(User.count()).shouldBeEqual(1);
    a(Address.count()).shouldBeEqual(4);
    a(Address.where("String_Node_Str", 1).size()).shouldBeEqual(0);
    a(Room.count()).shouldBeEqual(2);
    a(Room.count("String_Node_Str", 1)).shouldBeEqual(0);
}

Output:
     a(u).shouldBe("String_Node_Str");
-    a(User.count()).shouldBeEqual(1);
+    a(User.count()).shouldBeEqual(2);
     a(Address.count()).shouldBeEqual(4);


Input:
public Response copyFiles(String pathId, Integer mode, String params) {
    if (mode == null) {
        mode = MODE_RENAME;
    }
    if (!getPolicy().isAllowed(RepositoryCreateAction.NAME)) {
        return Response.status(FORBIDDEN).build();
    }
    try {
        String path = idToPath(pathId);
        RepositoryFile destDir = getRepository().getFile(path);
        String[] sourceFileIds = params.split("String_Node_Str");
        if (mode == MODE_OVERWRITE || mode == MODE_NO_OVERWRITE) {
            for (String sourceFileId : sourceFileIds) {
                RepositoryFile sourceFile = getRepository().getFileById(sourceFileId);
                if (destDir != null && destDir.isFolder() && sourceFile != null && !sourceFile.isFolder()) {
                    String fileName = sourceFile.getName();
                    String sourcePath = sourceFile.getPath().substring(0, sourceFile.getPath().lastIndexOf(PATH_SEPARATOR));
                    if (!sourcePath.equals(destDir.getPath())) {
                        IRepositoryFileData data = getData(sourceFile);
                        RepositoryFileAcl acl = getRepository().getAcl(sourceFileId);
                        RepositoryFile destFile = getRepository().getFile(destDir.getPath() + PATH_SEPARATOR + fileName);
                        if (destFile == null) {
                            RepositoryFile duplicateFile = new RepositoryFile.Builder(fileName).hidden(sourceFile.isHidden()).versioned(sourceFile.isVersioned()).build();
                            final RepositoryFile repositoryFile = getRepository().createFile(destDir.getId(), duplicateFile, data, acl, null);
                            getRepository().setFileMetadata(repositoryFile.getId(), getRepository().getFileMetadata(sourceFileId));
                        } else if (mode == MODE_OVERWRITE) {
                            RepositoryFileDto destFileDto = RepositoryFileAdapter.toFileDto(destFile, null, false);
                            destFileDto.setHidden(sourceFile.isHidden());
                            destFile = RepositoryFileAdapter.toFile(destFileDto);
                            final RepositoryFile repositoryFile = getRepository().updateFile(destFile, data, null);
                            getRepository().updateAcl(acl);
                            getRepository().setFileMetadata(repositoryFile.getId(), getRepository().getFileMetadata(sourceFileId));
                        }
                    }
                }
            }
        } else {
            for (String sourceFileId : sourceFileIds) {
                RepositoryFile sourceFile = getRepository().getFileById(sourceFileId);
                if (destDir != null && destDir.isFolder() && sourceFile != null && !sourceFile.isFolder()) {
                    String fileName = sourceFile.getName();
                    String copyText = "String_Node_Str";
                    String rootCopyText = "String_Node_Str";
                    String nameNoExtension = fileName.substring(0, fileName.lastIndexOf('.'));
                    String extension = fileName.substring(fileName.lastIndexOf('.'));
                    RepositoryFileDto testFile = getRepoWs().getFile(path + PATH_SEPARATOR + nameNoExtension + extension);
                    if (testFile != null) {
                        if (!nameNoExtension.endsWith(Messages.getInstance().getString("String_Node_Str"))) {
                            copyText = rootCopyText = Messages.getInstance().getString("String_Node_Str");
                            fileName = nameNoExtension + copyText + extension;
                            testFile = getRepoWs().getFile(path + PATH_SEPARATOR + fileName);
                        }
                    }
                    Integer nameCount = 1;
                    while (testFile != null) {
                        nameCount++;
                        copyText = rootCopyText + Messages.getInstance().getString("String_Node_Str", nameCount);
                        fileName = nameNoExtension + copyText + extension;
                        testFile = getRepoWs().getFile(path + PATH_SEPARATOR + fileName);
                    }
                    IRepositoryFileData data = getData(sourceFile);
                    RepositoryFileAcl acl = getRepository().getAcl(sourceFileId);
                    RepositoryFile duplicateFile = null;
                    if (!sourceFile.getName().equals(sourceFile.getTitle())) {
                        duplicateFile = new RepositoryFile.Builder(fileName).title(RepositoryFile.DEFAULT_LOCALE, sourceFile.getTitle() + copyText).hidden(sourceFile.isHidden()).versioned(sourceFile.isVersioned()).build();
                    } else {
                        duplicateFile = new RepositoryFile.Builder(fileName).hidden(sourceFile.isHidden()).build();
                    }
                    final RepositoryFile repositoryFile = getRepository().createFile(destDir.getId(), duplicateFile, data, acl, null);
                    getRepository().setFileMetadata(repositoryFile.getId(), getRepository().getFileMetadata(sourceFileId));
                }
            }
        }
    } catch (Throwable t) {
        t.printStackTrace();
        return Response.serverError().entity(new SafeHtmlBuilder().appendEscapedLines(t.getLocalizedMessage()).toSafeHtml().asString()).build();
    }
    return Response.ok().build();
}

Output:
                     String rootCopyText = "String_Node_Str";
-                    String nameNoExtension = fileName.substring(0, fileName.lastIndexOf('.'));
+                    String nameNoExtension = fileName.substring(0, fileName.lastIndexOf('.') == -1 ? fileName.length() : fileName.lastIndexOf('.'));
                     String extension = fileName.substring(fileName.lastIndexOf('.'));


Input:
public JpaProvider createJpaProvider(EntityManager em) {
    return new HibernateJpaProvider(em, getDbms(entityManagerFactory), getCollectionPersisters(em));
}

Output:
 public JpaProvider createJpaProvider(EntityManager em) {
-    return new HibernateJpaProvider(em, getDbms(entityManagerFactory), getCollectionPersisters(em));
+    return new HibernateJpaProvider(em, getDbms(entityManagerFactory));
 }


Input:
public boolean equals(Object object) {
    try {
        if (null == object) {
            return false;
        } else if (this == object) {
            return true;
        }
        XPathFragment xPathFragment = (XPathFragment) object;
        if (null == predicate && null != xPathFragment.predicate) {
            return false;
        }
        if (null != predicate && !predicate.equals(xPathFragment.predicate)) {
            return false;
        }
        if (namespaceAware && xPathFragment.isNamespaceAware()) {
            if (namespaceURI == null) {
                if (xPathFragment.namespaceURI != null) {
                    return false;
                }
            } else {
                if (xPathFragment.namespaceURI == null) {
                    return false;
                } else if (namespaceURI != xPathFragment.namespaceURI && !(namespaceURI.equals(xPathFragment.namespaceURI))) {
                    return false;
                }
            }
        }
        return ((nameIsText && xPathFragment.nameIsText) || (localName == xPathFragment.localName) || ((localName != null) && localName.equals(xPathFragment.localName))) && (this.indexValue == xPathFragment.indexValue) && (nameIsText == xPathFragment.nameIsText);
    } catch (ClassCastException e) {
        return false;
    }
}

Output:
     try {
-        if (null == object) {
-            return false;
-        } else if (this == object) {
+        XPathFragment xPathFragment = (XPathFragment) object;
+        if (nameIsText && xPathFragment.nameIsText) {
             return true;


Input:
public void execute() {
    propagatedChange.clear();
    propagateDatas(true);
    if (currentInputMetadata != null) {
        if (!currentInputMetadata.sameMetadataAs(newInputMetadata, IMetadataColumn.OPTIONS_NONE)) {
            if (!currentInputMetadata.sameMetadataAs(newInputMetadata, IMetadataColumn.OPTIONS_IGNORE_USED)) {
                String type = (String) inputNode.getPropertyValue(EParameterName.SCHEMA_TYPE.getName());
                if (type != null) {
                    if (type.equals(EmfComponent.REPOSITORY)) {
                        inputWasRepository = true;
                        inputNode.setPropertyValue(EParameterName.SCHEMA_TYPE.getName(), EmfComponent.BUILTIN);
                    }
                }
            }
            MetadataToolHelper.copyTable(newInputMetadata, currentInputMetadata);
        }
    }
    if (!currentOutputMetadata.sameMetadataAs(newOutputMetadata, IMetadataColumn.OPTIONS_NONE)) {
        if (!currentOutputMetadata.sameMetadataAs(newOutputMetadata, IMetadataColumn.OPTIONS_IGNORE_USED)) {
            String type = (String) node.getPropertyValue(EParameterName.SCHEMA_TYPE.getName());
            if (type != null && type.equals(EmfComponent.REPOSITORY) && !repositoryMode) {
                if ((node.getElementParameter("String_Node_Str").getContext().equals(currentOutputMetadata.getAttachedConnector()))) {
                    outputWasRepository = true;
                    node.setPropertyValue(EParameterName.SCHEMA_TYPE.getName(), EmfComponent.BUILTIN);
                }
            }
        }
        MetadataToolHelper.copyTable(newOutputMetadata, currentOutputMetadata);
    }
    if (inputSchemaParam != null && inputSchemaParam.getChildParameters().get(EParameterName.SCHEMA_TYPE.getName()) != null && EmfComponent.REPOSITORY.equals(inputSchemaParam.getChildParameters().get(EParameterName.SCHEMA_TYPE.getName()).getValue())) {
        IElementParameter elementParameter = node.getElementParameter(EParameterName.MAPPING.getName());
        if (elementParameter != null) {
            if (elementParameter.getValue() instanceof String) {
                String value = (String) elementParameter.getValue();
                if (!isDBComponent(value)) {
                    schemaParam.getChildParameters().get(EParameterName.SCHEMA_TYPE.getName()).setValue(EmfComponent.REPOSITORY);
                    schemaParam.getChildParameters().get(EParameterName.REPOSITORY_SCHEMA_TYPE.getName()).setValue(inputSchemaParam.getChildParameters().get(EParameterName.REPOSITORY_SCHEMA_TYPE.getName()).getValue());
                }
            }
        }
    }
    for (INodeConnector connector : node.getListConnector()) {
        if ((!connector.getName().equals(currentConnector)) && connector.getBaseSchema().equals(currentConnector)) {
            MetadataToolHelper.copyTable(newOutputMetadata, node.getMetadataFromConnector(connector.getName()));
            updateComponentSchema(node.getMetadataFromConnector(connector.getName()));
        }
    }
    updateComponentSchema(currentOutputMetadata);
    List<ColumnNameChanged> columnNameChanged = MetadataToolHelper.getColumnNameChanged(oldOutputMetadata, newOutputMetadata);
    ColumnListController.updateColumnList(node, columnNameChanged, true);
    if (inputNode != null) {
        List<ColumnNameChanged> inputColumnNameChangedExt = MetadataToolHelper.getColumnNameChangedExt(inputNode, oldInputMetadata, newInputMetadata);
        ColumnListController.updateColumnList(node, inputColumnNameChangedExt);
    }
    List<ColumnNameChanged> outputColumnNameChangedExt = MetadataToolHelper.getColumnNameChangedExt(node, oldOutputMetadata, newOutputMetadata);
    syncOutputNodeColumnsList(outputColumnNameChangedExt);
    setXMLMAPPING();
    if (!internal) {
        updateColumnList(oldOutputMetadata, newOutputMetadata);
        ((Process) node.getProcess()).checkProcess();
    }
    refreshMetadataChanged();
}

Output:
     syncOutputNodeColumnsList(outputColumnNameChangedExt);
-    setXMLMAPPING();
+    setTableMAPPING();
     if (!internal) {


Input:
protected boolean requiresRuntime(OperationContext context) {
    return context.isNormalServer();
}

Output:
 protected boolean requiresRuntime(OperationContext context) {
-    return context.isNormalServer();
+    return true;
 }


Input:
final boolean fillAttributes() {
    int len = unknown.length();
    if (len > 0) {
        if (unknownOffset >= 0) {
            positionIncrementAtt.setPositionIncrement(0);
        }
        int offset = reader.offset();
        if (matchCell != null) {
            offset -= matchCell.depth;
        }
        if (unknownOffset == -1) {
            termAtt.copyBuffer(unknown.buffer, 0, len);
            offsetAtt.setOffset(offset - len, offset);
        } else {
            termAtt.copyBuffer(unknown.buffer, unknownOffset, 2);
            offset = offset - len + unknownOffset;
            offsetAtt.setOffset(offset, offset + 2);
        }
        unknownOffset++;
        typeAtt.setType("String_Node_Str");
        if (len <= 2 || unknownOffset >= len - 1) {
            unknown.reset();
            unknownOffset = -1;
        }
        return true;
    }
    if (matchCell == null) {
        return false;
    }
    int offset = reader.offset();
    if (cellWordOffset > 0) {
        positionIncrementAtt.setPositionIncrement(0);
    }
    typeAtt.setType(matchCell.type);
    if (matchCell.type != "String_Node_Str") {
        termAtt.copyBuffer(pending.buffer, 0, pending.length());
        offsetAtt.setOffset(offset - pending.length(), offset);
        matchCell = null;
        cellWordOffset = 0;
    } else {
        char[][] words = matchCell.words;
        char[] word = words[cellWordOffset];
        termAtt.copyBuffer(word, 0, word.length);
        int start = offset - matchCell.depth + matchCell.offsets[cellWordOffset];
        offsetAtt.setOffset(start, start + word.length);
        cellWordOffset++;
        if (cellWordOffset == words.length) {
            matchCell = null;
            cellWordOffset = 0;
        }
    }
    return true;
}

Output:
         if (matchCell != null) {
-            offset -= matchCell.depth;
+            if (matchCell.type == "String_Node_Str") {
+                offset -= matchCell.depth;
+            } else {
+                offset -= pending.length();
+            }
         }


Input:
public void testExternalGeotiff() throws FileNotFoundException, IOException {
    if (!enabled())
        return;
    deleteAll();
    String storeName = "String_Node_Str";
    String layerName = "String_Node_Str";
    assertTrue(reader.getWorkspaces().isEmpty());
    assertTrue(publisher.createWorkspace(DEFAULT_WS));
    File geotiff = new ClassPathResource("String_Node_Str").getFile();
    assertFalse("String_Node_Str", existsLayer(layerName));
    RESTCoverageStore pc = publisher.publishExternalGeoTIFF(DEFAULT_WS, storeName, geotiff, null, null);
    assertNotNull("String_Node_Str", pc);
    assertTrue(existsLayer(layerName));
    LOGGER.info(pc);
    RESTCoverageStore reloadedCS = reader.getCoverageStore(DEFAULT_WS, storeName);
    assertEquals(pc.getName(), reloadedCS.getName());
    assertEquals(pc.getWorkspaceName(), reloadedCS.getWorkspaceName());
    assertTrue("String_Node_Str", publisher.unpublishCoverage(DEFAULT_WS, storeName, layerName));
    assertTrue("String_Node_Str", publisher.removeCoverageStore(DEFAULT_WS, storeName));
    assertFalse("String_Node_Str", publisher.unpublishCoverage(DEFAULT_WS, storeName, layerName));
    assertFalse(existsLayer(layerName));
}

Output:
     assertFalse("String_Node_Str", existsLayer(layerName));
-    RESTCoverageStore pc = publisher.publishExternalGeoTIFF(DEFAULT_WS, storeName, geotiff, null, null);
-    assertNotNull("String_Node_Str", pc);
+    boolean pc = publisher.publishExternalGeoTIFF(DEFAULT_WS, storeName, geotiff, layerName, "String_Node_Str", ProjectionPolicy.FORCE_DECLARED, "String_Node_Str");
+    assertTrue("String_Node_Str", pc);
     assertTrue(existsLayer(layerName));


Input:
public final void writeUTF(final String str) throws IOException {
    final int strlen = str.length();
    int utflen = 0;
    int c, count = 0;
    for (int i = 0; i < strlen; i++) {
        c = str.charAt(i);
        if ((c >= 0x0001) && (c <= 0x007F)) {
            utflen++;
        } else if (c > 0x07FF) {
            utflen += 3;
        } else {
            utflen += 2;
        }
    }
    if (utflen > 65535)
        throw new UTFDataFormatException("String_Node_Str" + utflen + "String_Node_Str");
    final byte[] bytearr = new byte[utflen + 2];
    bytearr[count++] = (byte) ((utflen >>> 8) & 0xFF);
    bytearr[count++] = (byte) ((utflen >>> 0) & 0xFF);
    int i = 0;
    for (i = 0; i < strlen; i++) {
        c = str.charAt(i);
        if (!((c >= 0x0001) && (c <= 0x007F)))
            break;
        bytearr[count++] = (byte) c;
    }
    for (; i < strlen; i++) {
        c = str.charAt(i);
        if ((c >= 0x0001) && (c <= 0x007F)) {
            bytearr[count++] = (byte) c;
        } else if (c > 0x07FF) {
            bytearr[count++] = (byte) (0xE0 | ((c >> 12) & 0x0F));
            bytearr[count++] = (byte) (0x80 | ((c >> 6) & 0x3F));
            bytearr[count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
        } else {
            bytearr[count++] = (byte) (0xC0 | ((c >> 6) & 0x1F));
            bytearr[count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
        }
    }
    write(bytearr, 0, utflen + 2);
}

Output:
     }
-    if (utflen > 65535)
-        throw new UTFDataFormatException("String_Node_Str" + utflen + "String_Node_Str");
-    final byte[] bytearr = new byte[utflen + 2];
+    final byte[] bytearr = new byte[utflen + 4];
+    bytearr[count++] = (byte) ((utflen >>> 24) & 0xFF);
+    bytearr[count++] = (byte) ((utflen >>> 16) & 0xFF);
     bytearr[count++] = (byte) ((utflen >>> 8) & 0xFF);


Input:
public boolean equals(Object object) {
    try {
        if (null == object) {
            return false;
        } else if (this == object) {
            return true;
        }
        XPathFragment xPathFragment = (XPathFragment) object;
        if (null == predicate && null != xPathFragment.getPredicate()) {
            return false;
        }
        if (null != predicate && !predicate.equals(xPathFragment.getPredicate())) {
            return false;
        }
        if (isNamespaceAware && xPathFragment.isNamespaceAware) {
            if (namespaceURI == null) {
                if (xPathFragment.getNamespaceURI() != null) {
                    return false;
                }
            } else {
                if (xPathFragment.getNamespaceURI() == null) {
                    return false;
                } else if (namespaceURI != xPathFragment.getNamespaceURI() && !(namespaceURI.equals(xPathFragment.getNamespaceURI()))) {
                    return false;
                }
            }
        }
        return ((nameIsText && xPathFragment.nameIsText()) || (getLocalName() == xPathFragment.getLocalName()) || ((getLocalName() != null) && getLocalName().equals(xPathFragment.getLocalName()))) && (this.indexValue == xPathFragment.getIndexValue()) && (nameIsText == xPathFragment.nameIsText());
    } catch (ClassCastException e) {
        return false;
    }
}

Output:
         }
-        if (isNamespaceAware && xPathFragment.isNamespaceAware) {
+        if (namespaceAware && xPathFragment.isNamespaceAware()) {
             if (namespaceURI == null) {


Input:
public static ResponseCodes reconnectPlayer(Passport passport) {
    Drone player = dronestorage.find(passport.getPlayer().getCredentials());
    if (player == null) {
        ResponseCodes code = registerPlayer(passport.getPlayer());
        if (code.equals(ResponseCodes.SUCCESS))
            return ResponseCodes.RECONNECT;
        return code;
    }
    if (!(player instanceof Player)) {
        return ResponseCodes.FAILED;
    }
    if (!player.getCredentials().getPassword().equals(passport.getPlayer().getCredentials().getPassword()))
        return ResponseCodes.INVALID_USER_PASS;
    ((Player) player).setPassport(passport);
    passport.setPlayer((Player) player);
    return ResponseCodes.RECONNECT;
}

Output:
     }
-    if (!player.getCredentials().getPassword().equals(passport.getPlayer().getCredentials().getPassword()))
+    if (!player.getCredentials().getPassword(true).equals(passport.getPlayer().getCredentials().getPassword(true)))
         return ResponseCodes.INVALID_USER_PASS;


Input:
public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table) {
    if (hasItemsToSend())
        return false;
    TileEntity tile = iHost.getTileEntity();
    World w = tile.getWorldObj();
    EnumSet<ForgeDirection> possibleDirections = iHost.getTargets();
    for (ForgeDirection s : possibleDirections) {
        TileEntity te = w.getTileEntity(tile.xCoord + s.offsetX, tile.yCoord + s.offsetY, tile.zCoord + s.offsetZ);
        if (te instanceof ICraftingMachine) {
            ICraftingMachine cm = (ICraftingMachine) te;
            if (cm.acceptsPlans()) {
                if (cm.pushPattern(patternDetails, table, s.getOpposite()))
                    return true;
                continue;
            }
        }
        InventoryAdaptor ad = InventoryAdaptor.getAdaptor(te, s.getOpposite());
        if (ad != null) {
            for (int x = 0; x < table.getSizeInventory(); x++) {
                ItemStack is = table.getStackInSlot(x);
                if (is != null) {
                    addToSendList(ad.addItems(is));
                }
            }
            pushItemsOut(possibleDirections);
            return true;
        }
    }
    return false;
}

Output:
         if (ad != null) {
-            for (int x = 0; x < table.getSizeInventory(); x++) {
-                ItemStack is = table.getStackInSlot(x);
-                if (is != null) {
-                    addToSendList(ad.addItems(is));
+            if (acceptsItems(ad, table)) {
+                for (int x = 0; x < table.getSizeInventory(); x++) {
+                    ItemStack is = table.getStackInSlot(x);
+                    if (is != null) {
+                        addToSendList(ad.addItems(is));
+                    }
                 }


Input:
private void fetchData(boolean fromBottomSheet) {
    dispose(null);
    callItems = new ArrayList<>();
    roomsQueryDisposable = ncApi.getRooms(ApiUtils.getCredentials(userEntity.getUsername(), userEntity.getToken()), ApiUtils.getUrlForGetRooms(userEntity.getBaseUrl())).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(roomsOverall -> {
        if (roomsOverall != null) {
            for (int i = 0; i < roomsOverall.getOcs().getData().size(); i++) {
                callItems.add(new CallItem(roomsOverall.getOcs().getData().get(i), userEntity));
            }
            adapter.updateDataSet(callItems, true);
            Collections.sort(callItems, (callItem, t1) -> Long.compare(t1.getModel().getLastPing(), callItem.getModel().getLastPing()));
            if (searchItem != null) {
                searchItem.setVisible(callItems.size() > 0);
            }
        }
        swipeRefreshLayout.setRefreshing(false);
    }, throwable -> {
        if (searchItem != null) {
            searchItem.setVisible(false);
        }
        if (throwable instanceof HttpException) {
            HttpException exception = (HttpException) throwable;
            switch(exception.code()) {
                case 401:
                    if (getParentController() != null && getParentController().getRouter() != null) {
                        getParentController().getRouter().pushController((RouterTransaction.with(new WebViewLoginController(userEntity.getBaseUrl(), true)).pushChangeHandler(new VerticalChangeHandler()).popChangeHandler(new VerticalChangeHandler())));
                    }
                    break;
                default:
                    break;
            }
        }
        swipeRefreshLayout.setRefreshing(false);
        dispose(roomsQueryDisposable);
    }, () -> {
        dispose(roomsQueryDisposable);
        if (swipeRefreshLayout != null) {
            swipeRefreshLayout.setRefreshing(false);
        }
        if (fromBottomSheet) {
            new Handler().postDelayed(() -> {
                bottomSheet.setCancelable(true);
                if (bottomSheet.isShowing()) {
                    bottomSheet.cancel();
                }
            }, 2500);
        }
    });
}

Output:
         }
-        swipeRefreshLayout.setRefreshing(false);
+        if (swipeRefreshLayout != null) {
+            swipeRefreshLayout.setRefreshing(false);
+        }
     }, throwable -> {


Input:
String formatDate(TemplateDateModel tdm, String formatDescriptor, Expression tdmSourceExpr) throws TemplateModelException {
    Date date = EvalUtil.modelToDate(tdm, tdmSourceExpr);
    boolean sqlDateOrTime = isSQLDateOrTimeClass(date.getClass());
    try {
        return getTemplateDateFormat(tdm.getDateType(), shouldUseSysDefTZ(sqlDateOrTime), formatDescriptor, null).format(tdm, sqlDateOrTime);
    } catch (UnknownDateTypeFormattingUnsupportedException e) {
        throw MessageUtil.newCantFormatUnknownTypeDateException(tdmSourceExpr, e);
    } catch (UnformattableDateException e) {
        throw MessageUtil.newCantFormatDateException(tdmSourceExpr, e);
    }
}

Output:
     Date date = EvalUtil.modelToDate(tdm, tdmSourceExpr);
-    boolean sqlDateOrTime = isSQLDateOrTimeClass(date.getClass());
+    boolean isSQLDateOrTime = isSQLDateOrTimeClass(date.getClass());
     try {


Input:
public void handle(Packet packet) {
    int threadIndex = INT_HOLDER.get().getAndInc() % responseThreads.length;
    responseThreads[threadIndex].responseQueue.add(packet);
}

Output:
 public void handle(Packet packet) {
-    int threadIndex = INT_HOLDER.get().getAndInc() % responseThreads.length;
+    int threadIndex = hashToIndex(INT_HOLDER.get().getAndInc(), responseThreads.length);
     responseThreads[threadIndex].responseQueue.add(packet);


Input:
private boolean space(char c) {
    return Character.isSpace(c) || c == '\0';
}

Output:
 private boolean space(char c) {
-    return Character.isSpace(c) || c == '\0';
+    return Character.isWhitespace(c) || c == '\0';
 }


Input:
public void loadModel(URL modelURL) throws Exception {
    MoMLParser parser = _createMoMLParser();
    HashSet<ComponentEntity> unneededActors = new HashSet<ComponentEntity>();
    HashSet<ComponentEntity> sinks = new HashSet<ComponentEntity>();
    HashSet<ComponentEntity> sources = new HashSet<ComponentEntity>();
    setResolvedTypes(new HashMap<String, String>());
    _topLevelActor = (CompositeActor) parser.parse(null, modelURL);
    for (Object obj : getTopLevelActor().deepEntityList()) {
        ComponentEntity actor = (ComponentEntity) obj;
        Attribute remoteAttribute = actor.getAttribute("String_Node_Str");
        boolean isSinkOrSource = false;
        if (remoteAttribute instanceof Parameter) {
            Parameter parameter = (Parameter) remoteAttribute;
            if (parameter.getExpression().equals("String_Node_Str")) {
                sources.add(actor);
                isSinkOrSource = true;
            } else if (parameter.getExpression().equals("String_Node_Str")) {
                sinks.add(actor);
                isSinkOrSource = true;
            }
        }
        if (!isSinkOrSource && _modelType == RemoteModelType.CLIENT) {
            unneededActors.add(actor);
        }
        _initRemoteAttributes(actor);
    }
    _initRemoteAttributes(_topLevelActor);
    if (_topLevelActor instanceof TypedCompositeActor) {
        TypedCompositeActor typedActor = (TypedCompositeActor) _topLevelActor;
        TypedCompositeActor.resolveTypes(typedActor);
    }
    _captureModelTypes(sources, getResolvedTypes());
    _captureModelTypes(sinks, getResolvedTypes());
    switch(_modelType) {
        case SERVER:
            for (ComponentEntity entity : sources) {
                _createSource(entity, true, getResolvedTypes());
            }
            for (ComponentEntity entity : sinks) {
                _createSink(entity, true, getResolvedTypes());
            }
            break;
        case CLIENT:
            for (ComponentEntity entity : sources) {
                _createSink(entity, false, getResolvedTypes());
            }
            for (ComponentEntity entity : sinks) {
                _createSource(entity, false, getResolvedTypes());
            }
            HashMap<NamedObj, StringAttribute> containerToDummyAttributeMap = new HashMap<NamedObj, StringAttribute>();
            for (Settable settable : _settableAttributesMap.values()) {
                Attribute attribute = (Attribute) settable;
                NamedObj container = attribute.getContainer();
                Attribute lastAttribute = attribute;
                while (container != _topLevelActor) {
                    StringAttribute dummyAttribute = containerToDummyAttributeMap.get(container);
                    if (dummyAttribute == null) {
                        dummyAttribute = new StringAttribute(container.getContainer(), container.getContainer().uniqueName("String_Node_Str"));
                        dummyAttribute.setPersistent(true);
                        containerToDummyAttributeMap.put(container, dummyAttribute);
                    }
                    container = container.getContainer();
                    lastAttribute.setContainer(dummyAttribute);
                    lastAttribute = dummyAttribute;
                }
            }
            for (ComponentEntity componentEntity : unneededActors) {
                componentEntity.setContainer(null);
            }
            for (Entry<NamedObj, StringAttribute> entry : containerToDummyAttributeMap.entrySet()) {
                entry.getValue().setName(entry.getKey().getName());
            }
            break;
    }
}

Output:
     HashSet<ComponentEntity> sources = new HashSet<ComponentEntity>();
-    setResolvedTypes(new HashMap<String, String>());
+    _resolvedTypes = new HashMap<String, Type>();
     _topLevelActor = (CompositeActor) parser.parse(null, modelURL);


Input:
private Injector createInMemoryModules() {
    ImmutableList<Module> inMemoryModules = ImmutableList.of(new ConfigModule(cConf), new LocalConfigModule(), new IOModule(), new AuthModule(), new LocationRuntimeModule().getInMemoryModules(), new DiscoveryRuntimeModule().getInMemoryModules(), new ProgramRunnerRuntimeModule().getInMemoryModules(), new DataFabricModules().getInMemoryModules(), new MetricsClientRuntimeModule().getNoopModules(), new LoggingModules().getInMemoryModules());
    return Guice.createInjector(inMemoryModules);
}

Output:
 private Injector createInMemoryModules() {
-    ImmutableList<Module> inMemoryModules = ImmutableList.of(new ConfigModule(cConf), new LocalConfigModule(), new IOModule(), new AuthModule(), new LocationRuntimeModule().getInMemoryModules(), new DiscoveryRuntimeModule().getInMemoryModules(), new ProgramRunnerRuntimeModule().getInMemoryModules(), new DataFabricModules().getInMemoryModules(), new MetricsClientRuntimeModule().getNoopModules(), new LoggingModules().getInMemoryModules());
+    ImmutableList<Module> inMemoryModules = ImmutableList.of(new ConfigModule(cConf), new LocalConfigModule(), new IOModule(), new AuthModule(), new LocationRuntimeModule().getInMemoryModules(), new DiscoveryRuntimeModule().getInMemoryModules(), new ProgramRunnerRuntimeModule().getInMemoryModules(), new DataFabricModules().getInMemoryModules(), new MetricsClientRuntimeModule().getNoopModules(), new LoggingModules().getInMemoryModules(), new AbstractModule() {
+        protected void configure() {
+            bind(ProgramServiceDiscovery.class).to(DistributedProgramServiceDiscovery.class).in(Scopes.SINGLETON);
+        }
+    });
     return Guice.createInjector(inMemoryModules);


Input:
public Changes continuousChanges() {
    URI uri = uriBuilder.query("String_Node_Str", "String_Node_Str").build();
    httpGet = new HttpGet(uri);
    InputStream in = dbc.get(httpGet);
    InputStreamReader is = new InputStreamReader(in);
    setReader(new BufferedReader(is));
    return this;
}

Output:
 public Changes continuousChanges() {
-    URI uri = uriBuilder.query("String_Node_Str", "String_Node_Str").build();
+    final URI uri = uriBuilder.query("String_Node_Str", "String_Node_Str").build();
     httpGet = new HttpGet(uri);


Input:
private void onGoingFinished() {
    mOnGoingRequest.mResultListener.onRequestFinished();
    startNextRequestIfNecessary();
}

Output:
     mOnGoingRequest.mResultListener.onRequestFinished();
-    startNextRequestIfNecessary();
+    startNextRequestIfAny();
 }


Input:
public void testRemoveNull() {
    List<List<String>> listTypes = new ArrayList<>();
    listTypes.add(new ArrayList<>());
    listTypes.add(new BasicEventList<>());
    listTypes.add(SortedList.create(new BasicEventList<>()));
    for (List<String> list : listTypes) {
        installConsistencyListener(list);
        list.clear();
        list.addAll(Arrays.asList("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str"));
        assertEquals(false, list.remove(null));
        assertEquals(true, list.remove("String_Node_Str"));
        list.clear();
        list.addAll(Arrays.asList(null, "String_Node_Str", null, "String_Node_Str"));
        assertEquals(true, list.remove(null));
        assertEquals(true, list.remove("String_Node_Str"));
        assertEquals(false, list.remove("String_Node_Str"));
    }
}

Output:
     listTypes.add(new BasicEventList<>());
-    listTypes.add(SortedList.create(new BasicEventList<>()));
+    listTypes.add(SortedList.create(new BasicEventList<String>()));
     for (List<String> list : listTypes) {


Input:
public static ArrayList<ISteamToolUpgrade> getUpgrades(ItemStack me) {
    ArrayList<ISteamToolUpgrade> upgrades = new ArrayList<>();
    for (int i = 1; i < 10; i++) {
        if (me.stackTagCompound.getCompoundTag("String_Node_Str").hasKey(Integer.toString(i))) {
            ItemStack stack = ItemStack.loadItemStackFromNBT(me.stackTagCompound.getCompoundTag("String_Node_Str").getCompoundTag(Integer.toString(i)));
            if (stack != null) {
                Item item = stack.getItem();
                if (item != null && item instanceof ISteamToolUpgrade) {
                    upgrades.add((ISteamToolUpgrade) item);
                }
            }
        }
    }
    if (upgrades.isEmpty()) {
        return null;
    }
    return upgrades;
}

Output:
     for (int i = 1; i < 10; i++) {
-        if (me.stackTagCompound.getCompoundTag("String_Node_Str").hasKey(Integer.toString(i))) {
-            ItemStack stack = ItemStack.loadItemStackFromNBT(me.stackTagCompound.getCompoundTag("String_Node_Str").getCompoundTag(Integer.toString(i)));
+        if (unbt.hasKey(Integer.toString(i))) {
+            ItemStack stack = ItemStack.loadItemStackFromNBT(unbt.getCompoundTag(Integer.toString(i)));
             if (stack != null) {


Input:
public void run() {
    JSONObject out = new JSONObject();
    final int[] players = { 0 };
    final int[] playersPlaying = { 0 };
    SocketServer.getConnections().forEach(socketContext -> {
        players[0] += socketContext.getPlayers().size();
        playersPlaying[0] += socketContext.getPlayingPlayers().size();
    });
    out.put("String_Node_Str", "String_Node_Str");
    out.put("String_Node_Str", players[0]);
    out.put("String_Node_Str", playersPlaying[0]);
    out.put("String_Node_Str", System.currentTimeMillis() - Launcher.startTime);
    JSONObject mem = new JSONObject();
    mem.put("String_Node_Str", Runtime.getRuntime().freeMemory());
    mem.put("String_Node_Str", Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());
    mem.put("String_Node_Str", Runtime.getRuntime().totalMemory());
    mem.put("String_Node_Str", Runtime.getRuntime().maxMemory());
    out.put("String_Node_Str", mem);
    SystemInfo si = new SystemInfo();
    HardwareAbstractionLayer hal = si.getHardware();
    JSONObject cpu = new JSONObject();
    cpu.put("String_Node_Str", Runtime.getRuntime().availableProcessors());
    cpu.put("String_Node_Str", hal.getProcessor().getSystemCpuLoad());
    cpu.put("String_Node_Str", getProcessRecentCpuUsage());
    out.put("String_Node_Str", cpu);
    int totalSent = 0;
    int totalNulled = 0;
    int players = 0;
    for (Player player : context.getPlayingPlayers()) {
        AudioLossCounter counter = player.getAudioLossCounter();
        if (!counter.isDataUsable())
            continue;
        players++;
        totalSent += counter.getLastMinuteSuccess();
        totalNulled += counter.getLastMinuteLoss();
    }
    int totalDeficit = players * AudioLossCounter.EXPECTED_PACKET_COUNT_PER_MIN - (totalSent + totalNulled);
    if (players != 0) {
        JSONObject frames = new JSONObject();
        frames.put("String_Node_Str", totalSent / players);
        frames.put("String_Node_Str", totalNulled / players);
        frames.put("String_Node_Str", totalDeficit / players);
        out.put("String_Node_Str", frames);
    }
    context.getSocket().send(out.toString());
}

Output:
     JSONObject out = new JSONObject();
-    final int[] players = { 0 };
+    final int[] playersTotal = { 0 };
     final int[] playersPlaying = { 0 };


Input:
protected void internalDescriptorChanged() {
    if (spacesDescriptor != null) {
        CloudSpace defaultCloudSpace = spacesDescriptor.getOrgsAndSpaces().getDefaultCloudSpace();
        setSelectedSpace(defaultCloudSpace);
    } else {
        setSelectedSpace(null);
    }
}

Output:
     if (spacesDescriptor != null) {
-        CloudSpace defaultCloudSpace = spacesDescriptor.getOrgsAndSpaces().getDefaultCloudSpace();
+        CloudSpace defaultCloudSpace = getSpaceWithNoServerInstance();
         setSelectedSpace(defaultCloudSpace);


Input:
public boolean isInputRestricted() {
    return mShowing || mNeedToReshowWhenReenabled || !mUpdateMonitor.isDeviceProvisioned();
}

Output:
 public boolean isInputRestricted() {
-    return mShowing || mNeedToReshowWhenReenabled || !mUpdateMonitor.isDeviceProvisioned();
+    return mShowing || mNeedToReshowWhenReenabled || shouldWaitForProvisioning();
 }


Input:
protected synchronized boolean hasClique(Map<Integer, Integer> cliqueMap, List<Map<Integer, Integer>> mapGlobal) {
    for (Map<Integer, Integer> storedMap : mapGlobal) {
        if (cliqueMap.size() < storedMap.size()) {
            return true;
        }
        if (cliqueMap.keySet().equals(storedMap.keySet()) && cliqueMap.values().equals(storedMap.values())) {
            return true;
        }
    }
    return false;
}

Output:
             return true;
-        }
-        if (cliqueMap.keySet().equals(storedMap.keySet()) && cliqueMap.values().equals(storedMap.values())) {
+        } else if (cliqueMap.equals(storedMap)) {
             return true;


Input:
protected IMenuComponent getAndCheckMenu() throws StepExecutionException {
    Object menu = getMenuAdapter().getRealComponent();
    if (menu == null) {
        throw new StepExecutionException(I18n.getString(TestErrorEvent.NO_MENU_BAR), EventFactory.createActionError(TestErrorEvent.NO_MENU_BAR));
    }
    return getMenuAdapter();
}

Output:
 protected IMenuComponent getAndCheckMenu() throws StepExecutionException {
-    Object menu = getMenuAdapter().getRealComponent();
-    if (menu == null) {
+    IMenuComponent menuAdapter = getMenuAdapter();
+    if (menuAdapter == null || menuAdapter.getRealComponent() == null) {
         throw new StepExecutionException(I18n.getString(TestErrorEvent.NO_MENU_BAR), EventFactory.createActionError(TestErrorEvent.NO_MENU_BAR));


Input:
public boolean disconnectPhysicalDiskByPath(String localPath) {
    String poolUuid = null;
    if (localPath != null && localPath.startsWith(_mountPoint) && localPath.endsWith("String_Node_Str")) {
        String[] token = localPath.split("String_Node_Str");
        if (token.length > 3) {
            poolUuid = token[2];
        }
    } else {
        return false;
    }
    if (poolUuid == null) {
        return false;
    }
    try {
        Connect conn = LibvirtConnection.getConnection();
        StoragePool pool = conn.storagePoolLookupByUUIDString(poolUuid);
        deleteStoragePool(poolUuid);
        return true;
    } catch (LibvirtException ex) {
        return false;
    } catch (CloudRuntimeException ex) {
        return false;
    }
}

Output:
         Connect conn = LibvirtConnection.getConnection();
-        StoragePool pool = conn.storagePoolLookupByUUIDString(poolUuid);
+        conn.storagePoolLookupByUUIDString(poolUuid);
         deleteStoragePool(poolUuid);


Input:
public Long stopCluster(String clusterName) throws Exception {
    logger.info("String_Node_Str" + clusterName);
    ClusterEntity cluster = clusterEntityMgr.findByName(clusterName);
    if (cluster == null) {
        logger.error("String_Node_Str" + clusterName + "String_Node_Str");
        throw BddException.NOT_FOUND("String_Node_Str", clusterName);
    }
    ValidationUtils.validateVersion(clusterEntityMgr, clusterName);
    if (ClusterStatus.STOPPED.equals(cluster.getStatus())) {
        logger.error("String_Node_Str" + clusterName + "String_Node_Str");
        throw ClusterManagerException.ALREADY_STOPPED_ERROR(clusterName);
    }
    if (!cluster.getStatus().isActiveServiceStatus() && !ClusterStatus.SERVICE_ERROR.equals(cluster.getStatus()) && !ClusterStatus.ERROR.equals(cluster.getStatus())) {
        logger.error("String_Node_Str" + clusterName + "String_Node_Str" + cluster.getStatus() + "String_Node_Str");
        throw ClusterManagerException.STOP_NOT_ALLOWED_ERROR(clusterName, "String_Node_Str");
    }
    Map<String, JobParameter> param = new TreeMap<String, JobParameter>();
    param.put(JobConstants.CLUSTER_NAME_JOB_PARAM, new JobParameter(clusterName));
    param.put(JobConstants.TIMESTAMP_JOB_PARAM, new JobParameter(new Date()));
    param.put(JobConstants.CLUSTER_SUCCESS_STATUS_JOB_PARAM, new JobParameter(ClusterStatus.STOPPED.name()));
    param.put(JobConstants.CLUSTER_FAILURE_STATUS_JOB_PARAM, new JobParameter(ClusterStatus.ERROR.name()));
    JobParameters jobParameters = new JobParameters(param);
    clusterEntityMgr.updateClusterStatus(clusterName, ClusterStatus.STOPPING);
    clusterEntityMgr.cleanupActionError(clusterName);
    try {
        return jobManager.runJob(JobConstants.STOP_CLUSTER_JOB_NAME, jobParameters);
    } catch (Exception e) {
        logger.error("String_Node_Str" + clusterName, e);
        clusterEntityMgr.updateClusterStatus(clusterName, ClusterStatus.ERROR);
        throw e;
    }
}

Output:
     }
-    if (!cluster.getStatus().isActiveServiceStatus() && !ClusterStatus.SERVICE_ERROR.equals(cluster.getStatus()) && !ClusterStatus.ERROR.equals(cluster.getStatus())) {
+    if (!cluster.getStatus().isActiveServiceStatus() && !ClusterStatus.SERVICE_STOPPED.equals(cluster.getStatus()) && !ClusterStatus.ERROR.equals(cluster.getStatus())) {
         logger.error("String_Node_Str" + clusterName + "String_Node_Str" + cluster.getStatus() + "String_Node_Str");


Input:
public void loadUrl(String url) {
    if (url.startsWith("String_Node_Str"))
        loadUrlDirect(url);
    else if (mClient == null || !mClient.shouldOverrideUrlLoading(this, url)) {
        super.loadUrl(url);
    }
}

Output:
     if (url.startsWith("String_Node_Str"))
-        loadUrlDirect(url);
+        LeanUtils.runJavascriptOnWebView(this, url.substring("String_Node_Str".length()));
     else if (mClient == null || !mClient.shouldOverrideUrlLoading(this, url)) {


Input:
public void setWorkingDirectory(Path arg0) {
    throw new UnsupportedOperationException("String_Node_Str");
}

Output:
 public void setWorkingDirectory(Path arg0) {
-    throw new UnsupportedOperationException("String_Node_Str");
+    this.workingDirectory = arg0;
 }


Input:
protected synchronized Client getClient() {
    if (client == null) {
        try {
            client = new Client(address, port);
        } catch (Exception e) {
            throw new RuntimeException("String_Node_Str", e);
        }
    }
    return client;
}

Output:
         } catch (Exception e) {
-            throw new RuntimeException("String_Node_Str", e);
+            throw new RuntimeException("String_Node_Str" + address + "String_Node_Str" + port, e);
         }


Input:
public List<String> getSuggestions(CommandSource source, String arguments) throws CommandException {
    String[] parts = arguments.split("String_Node_Str", 2);
    List<String> suggestions = new ArrayList<String>();
    if (parts.length == 1) {
        String incompleteCommand = parts[0].toLowerCase();
        synchronized (this) {
            for (CommandMapping mapping : this.commands.values()) {
                for (String alias : mapping.getAllAliases()) {
                    if (alias.toLowerCase().startsWith(incompleteCommand)) {
                        suggestions.add(alias);
                    }
                }
            }
        }
    } else {
        Optional<CommandMapping> mapping = get(parts[0]);
        if (mapping.isPresent()) {
            mapping.get().getCallable().getSuggestions(source, parts.length > 1 ? parts[1] : "String_Node_Str");
        }
    }
    return Collections.unmodifiableList(suggestions);
}

Output:
         if (mapping.isPresent()) {
-            mapping.get().getCallable().getSuggestions(source, parts.length > 1 ? parts[1] : "String_Node_Str");
+            suggestions.addAll(mapping.get().getCallable().getSuggestions(source, parts.length > 1 ? parts[1] : "String_Node_Str"));
         }


Input:
private void gatherTerminalStats(Map<GenerationStatField, Object> stats, List<CandidateProgram<TYPE>> pop) {
    if (stats.containsKey(GenerationStatField.NO_TERMINALS_AVE) || stats.containsKey(GenerationStatField.NO_TERMINALS_STDEV) || stats.containsKey(GenerationStatField.NO_TERMINALS_MAX) || stats.containsKey(GenerationStatField.NO_TERMINALS_MIN)) {
        double[] noTerminals = new double[pop.size()];
        for (int i = 0; i < pop.size(); i++) {
            noTerminals[i] = pop.get(i).getNoTerminals();
        }
        if (stats.containsKey(GenerationStatField.NO_TERMINALS_AVE)) {
            stats.put(GenerationStatField.NO_TERMINALS_AVE, Double.toString(ave(noTerminals)));
        }
        if (stats.containsKey(GenerationStatField.NO_TERMINALS_STDEV)) {
            stats.put(GenerationStatField.NO_TERMINALS_STDEV, Double.toString(stdev(noTerminals)));
        }
        if (stats.containsKey(GenerationStatField.NO_TERMINALS_MAX)) {
            stats.put(GenerationStatField.NO_TERMINALS_MAX, Double.toString(max(noTerminals)));
        }
        if (stats.containsKey(GenerationStatField.NO_TERMINALS_MIN)) {
            stats.put(GenerationStatField.NO_TERMINALS_MIN, Double.toString(min(noTerminals)));
        }
    }
}

Output:
         if (stats.containsKey(GenerationStatField.NO_TERMINALS_AVE)) {
-            stats.put(GenerationStatField.NO_TERMINALS_AVE, Double.toString(ave(noTerminals)));
+            stats.put(GenerationStatField.NO_TERMINALS_AVE, new Double(ave(noTerminals)));
         }


Input:
public Object resolveEntity(String publicId, String systemId) throws Exception {
    if (publicId != null && publicId.equals(MoMLParser.MoML_PUBLIC_ID_1)) {
        return new StringReader(MoMLParser.MoML_DTD_1);
    } else {
        return null;
    }
}

Output:
 public Object resolveEntity(String publicId, String systemId) throws Exception {
-    if (publicId != null && publicId.equals(MoMLParser.MoML_PUBLIC_ID_1)) {
-        return new StringReader(MoMLParser.MoML_DTD_1);
+    if (publicId != null && publicId.equals(MoML_PUBLIC_ID_1)) {
+        return new StringReader(MoML_DTD_1);
     } else {


Input:
public void moveFolderRepNode(IRepositoryNode sourceNode, IRepositoryNode targetNode) throws PersistenceException {
    if (sourceNode instanceof JrxmlTempSubFolderNode) {
        MessageUI.openWarning(DefaultMessagesImpl.getString("String_Node_Str"));
        return;
    }
    if (sourceNode instanceof SourceFileSubFolderNode) {
        SourceFileSubFolderNode folderNode = (SourceFileSubFolderNode) sourceNode;
        ReturnCode rc = WorkspaceResourceHelper.checkSourceFileSubFolderNodeOpening(folderNode);
        if (rc.isOk()) {
            WorkspaceResourceHelper.showSourceFilesOpeningWarnMessages(rc.getMessage());
            return;
        }
    }
    if (!canMoveNode(sourceNode, targetNode)) {
        return;
    }
    boolean isReportSubFolderRepNode = sourceNode instanceof ReportSubFolderRepNode;
    Map<IFolder, IFolder> reportGenDocInfoMap = new HashMap<IFolder, IFolder>();
    IFolder folder = null;
    File tarFile = null;
    if (isReportSubFolderRepNode) {
        String tempFolderName = StringUtilities.getRandomString(8);
        folder = RepositoryNodeHelper.getIFolder(sourceNode);
        File srcFile = WorkspaceUtils.ifolderToFile(folder);
        tarFile = WorkspaceUtils.ifolderToFile(folder.getParent().getFolder(new Path(tempFolderName)));
        if (!tarFile.exists()) {
            tarFile.mkdirs();
        }
        if (srcFile.exists() && tarFile.exists()) {
            FilesUtils.copyDirectory(srcFile, tarFile);
        }
        IFolder sourceFolder = RepositoryNodeHelper.getIFolder(sourceNode);
        IFolder targetFolder = RepositoryNodeHelper.getIFolder(targetNode);
        List<ReportRepNode> reportRepNodeList = new ArrayList<ReportRepNode>();
        getAllReportRepNode((ReportSubFolderRepNode) sourceNode, reportRepNodeList);
        if (!reportRepNodeList.isEmpty()) {
            buildReportGenDocInfoMap(reportRepNodeList, sourceFolder, targetFolder, reportGenDocInfoMap);
        }
    }
    RepositoryNodeBuilder instance = RepositoryNodeBuilder.getInstance();
    FolderHelper folderHelper = instance.getFolderHelper();
    IPath sourcePath = WorkbenchUtils.getPath((RepositoryNode) sourceNode);
    IPath targetPath = WorkbenchUtils.getPath((RepositoryNode) targetNode);
    ERepositoryObjectType objectType = targetNode.getContentType();
    IPath nodeFullPath = this.getNodeFullPath(objectType);
    IPath makeRelativeTo = nodeFullPath.makeRelativeTo(ResourceManager.getRootProject().getFullPath());
    computePath(folderHelper, sourcePath, targetPath, makeRelativeTo, objectType, sourceNode, targetNode);
    if (isReportSubFolderRepNode) {
        if (tarFile != null) {
            File file1 = new File(tarFile.getAbsolutePath() + IPath.SEPARATOR + sourceNode.getLabel());
            File file2 = WorkspaceUtils.ifolderToFile(RepositoryNodeHelper.getIFolder(targetNode).getFolder(new Path(sourceNode.getLabel())));
            ReportUtils.moveHiddenFolders(file1, file2);
            FilesUtils.deleteFile(tarFile, Boolean.TRUE);
        }
        if (!reportGenDocInfoMap.isEmpty()) {
            for (IFolder outputFolder : reportGenDocInfoMap.keySet()) {
                ReportUtils.updateReportListFile(outputFolder, reportGenDocInfoMap.get(outputFolder));
            }
        }
    }
}

Output:
     FolderHelper folderHelper = instance.getFolderHelper();
-    IPath sourcePath = WorkbenchUtils.getPath((RepositoryNode) sourceNode);
-    IPath targetPath = WorkbenchUtils.getPath((RepositoryNode) targetNode);
+    IPath sourcePath = WorkbenchUtils.getPath(sourceNode);
+    IPath targetPath = WorkbenchUtils.getPath(targetNode);
     ERepositoryObjectType objectType = targetNode.getContentType();


Input:
public void testUpdateComponentSchema() {
    String TEST_TABLE_NAME = "String_Node_Str";
    String TEST_COL_NAME = "String_Node_Str";
    String ADDED_COL_NAME = "String_Node_Str";
    String SCHEMA_PROP_NAME = "String_Node_Str";
    MetadataTable table = createMetadataTable(TEST_TABLE_NAME);
    MetadataColumn testColumn = ConnectionFactory.eINSTANCE.createMetadataColumn();
    testColumn.setName(TEST_COL_NAME);
    testColumn.setLabel(testColumn.getName());
    testColumn.setDefaultValue("String_Node_Str");
    testColumn.setTalendType(JavaTypesManager.STRING.getId());
    table.getColumns().add(testColumn);
    TestProperties props = (TestProperties) new TestProperties("String_Node_Str").init();
    Schema oldSchema = SchemaBuilder.record(TEST_TABLE_NAME).fields().name(TEST_COL_NAME).type().stringType().noDefault().endRecord();
    props.schema.schema.setValue(oldSchema);
    TaggedValue serializedPropsTV = CoreFactory.eINSTANCE.createTaggedValue();
    serializedPropsTV.setTag(IComponentConstants.COMPONENT_PROPERTIES_TAG);
    serializedPropsTV.setValue(props.toSerialized());
    table.getTaggedValue().add(serializedPropsTV);
    TaggedValue schemaPropertyTV = CoreFactory.eINSTANCE.createTaggedValue();
    schemaPropertyTV.setTag(IComponentConstants.COMPONENT_SCHEMA_TAG);
    schemaPropertyTV.setValue(SCHEMA_PROP_NAME);
    table.getTaggedValue().add(schemaPropertyTV);
    MetadataColumn addedColumn = ConnectionFactory.eINSTANCE.createMetadataColumn();
    addedColumn.setName(ADDED_COL_NAME);
    addedColumn.setLabel(addedColumn.getName());
    addedColumn.setDefaultValue("String_Node_Str");
    addedColumn.setTalendType(JavaTypesManager.STRING.getId());
    table.getColumns().add(addedColumn);
    SchemaUtils.updateComponentSchema(table);
    String componentPropertiesStr = null;
    String schemaPropertyName = null;
    EList<TaggedValue> taggedValues = table.getTaggedValue();
    for (TaggedValue taggedValue : taggedValues) {
        String tag = taggedValue.getTag();
        String tagValue = taggedValue.getValue();
        if (IComponentConstants.COMPONENT_PROPERTIES_TAG.equals(tag)) {
            componentPropertiesStr = tagValue;
        } else if (IComponentConstants.COMPONENT_SCHEMA_TAG.equals(tag)) {
            schemaPropertyName = tagValue;
        }
    }
    Deserialized<ComponentProperties> fromSerialized = Properties.fromSerialized(componentPropertiesStr, ComponentProperties.class);
    ComponentProperties componentProperties = fromSerialized.properties;
    Object schemaValueStr = componentProperties.getValuedProperty(schemaPropertyName).getValue();
    Schema avroSchema = new Schema.Parser().parse((String) schemaValueStr);
    assertNotNull(avroSchema.getField(ADDED_COL_NAME));
    IMetadataTable iMetadataTable = MetadataToolHelper.convert(table);
    SchemaUtils.updateComponentSchema(props, SCHEMA_PROP_NAME, iMetadataTable);
    Map<String, String> additionalProperties = iMetadataTable.getAdditionalProperties();
    componentPropertiesStr = additionalProperties.get(IComponentConstants.COMPONENT_PROPERTIES_TAG);
    fromSerialized = Properties.fromSerialized(componentPropertiesStr, ComponentProperties.class);
    componentProperties = fromSerialized.properties;
    schemaPropertyName = additionalProperties.get(IComponentConstants.COMPONENT_SCHEMA_TAG);
    schemaValueStr = componentProperties.getValuedProperty(schemaPropertyName).getValue();
    avroSchema = new Schema.Parser().parse((String) schemaValueStr);
    assertNotNull(avroSchema.getField(TEST_COL_NAME));
    assertNotNull(avroSchema.getField(ADDED_COL_NAME));
    assertEquals(2, avroSchema.getFields().size());
}

Output:
     }
-    Deserialized<ComponentProperties> fromSerialized = Properties.fromSerialized(componentPropertiesStr, ComponentProperties.class);
-    ComponentProperties componentProperties = fromSerialized.properties;
-    Object schemaValueStr = componentProperties.getValuedProperty(schemaPropertyName).getValue();
-    Schema avroSchema = new Schema.Parser().parse((String) schemaValueStr);
+    ComponentProperties componentProperties = ComponentsUtils.getComponentPropertiesFromSerialized(componentPropertiesStr);
+    Object schemaValue = componentProperties.getValuedProperty(schemaPropertyName).getValue();
+    Schema avroSchema = getAvroSchema(schemaValue);
+    props.schema.schema.setValue(avroSchema);
+    assertNotNull(avroSchema.getField(TEST_COL_NAME));
     assertNotNull(avroSchema.getField(ADDED_COL_NAME));


Input:
protected FieldODEStateAndDerivative<T> computeInterpolatedStateAndDerivatives(final FieldEquationsMapper<T> mapper, final T time, final T theta, final T oneMinusThetaH) {
    final T bDot0 = theta.multiply(theta.multiply(theta.multiply(-10.0).add(16.0)).add(-15.0 / 2.0)).add(1);
    final T bDot1 = getField().getZero();
    final T bDot2 = theta.multiply(theta.multiply(theta.multiply(135.0 / 2.0).add(-729.0 / 8.0)).add(459.0 / 16.0));
    final T bDot3 = theta.multiply(theta.multiply(theta.multiply(-120.0).add(152.0)).add(-44.0));
    final T bDot4 = theta.multiply(theta.multiply(theta.multiply(125.0 / 2.0).add(-625.0 / 8.0)).add(375.0 / 16.0));
    final T bDot5 = theta.multiply(5.0 / 8.0).multiply(theta.multiply(2).subtract(1));
    final T[] interpolatedState;
    final T[] interpolatedDerivatives;
    if (getGlobalPreviousState() != null && theta.getReal() <= 0.5) {
        final T hTheta = h.multiply(theta);
        final T b0 = hTheta.multiply(theta.multiply(theta.multiply(theta.multiply(-5.0 / 2.0).add(16.0 / 3.0)).add(-15.0 / 4.0)).add(1));
        final T b1 = getField().getZero();
        final T b2 = hTheta.multiply(theta.multiply(theta.multiply(theta.multiply(135.0 / 8.0).add(-243.0 / 8.0)).add(459.0 / 32.0)));
        final T b3 = hTheta.multiply(theta.multiply(theta.multiply(theta.multiply(-30.0).add(152.0 / 3.0)).add(-22.0)));
        final T b4 = hTheta.multiply(theta.multiply(theta.multiply(theta.multiply(125.0 / 8.0).add(-625.0 / 24.0)).add(375.0 / 32.0)));
        final T b5 = hTheta.multiply(theta.multiply(theta.multiply(5.0 / 12.0)).add(-5.0 / 16.0));
        interpolatedState = previousStateLinearCombination(b0, b1, b2, b3, b4, b5);
        interpolatedDerivatives = derivativeLinearCombination(bDot0, bDot1, bDot2, bDot3, bDot4, bDot5);
    } else {
        final T theta2 = theta.multiply(theta);
        final T b0 = h.multiply(theta.multiply(theta.multiply(theta.multiply(theta.multiply(-5.0 / 2.0).add(16.0 / 3.0)).add(-15.0 / 4.0)).add(1.0)).add(-1.0 / 12.0));
        final T b1 = getField().getZero();
        final T b2 = h.multiply(theta2.multiply(theta.multiply(theta.multiply(135.0 / 8.0).add(-243.0 / 8.0)).add(459.0 / 32.0)).add(-27.0 / 32.0));
        final T b3 = h.multiply(theta2.multiply(theta.multiply(theta.multiply(-30.0).add(152.0 / 3.0)).add(-22.0)).add(4.0 / 3.0));
        final T b4 = h.multiply(theta2.multiply(theta.multiply(theta.multiply(125.0 / 8.0).add(-625.0 / 24.0)).add(375.0 / 32.0)).add(-125.0 / 96.0));
        final T b5 = h.multiply(theta2.multiply(theta.multiply(5.0 / 12.0).add(-5.0 / 16.0)).add(-5.0 / 48.0));
        interpolatedState = currentStateLinearCombination(b0, b1, b2, b3, b4, b5);
        interpolatedDerivatives = derivativeLinearCombination(bDot0, bDot1, bDot2, bDot3, bDot4, bDot5);
    }
    return new FieldODEStateAndDerivative<T>(time, interpolatedState, interpolatedDerivatives);
}

Output:
         final T b4 = hTheta.multiply(theta.multiply(theta.multiply(theta.multiply(125.0 / 8.0).add(-625.0 / 24.0)).add(375.0 / 32.0)));
-        final T b5 = hTheta.multiply(theta.multiply(theta.multiply(5.0 / 12.0)).add(-5.0 / 16.0));
+        final T b5 = hTheta.multiply(theta.multiply(theta.multiply(5.0 / 12.0).add(-5.0 / 16.0)));
         interpolatedState = previousStateLinearCombination(b0, b1, b2, b3, b4, b5);


Input:
private InstructionList makeClosureInstantiation(Member constructor, BcelVar holder) {
    InstructionFactory fact = getFactory();
    BcelVar arrayVar = genTempVar(TypeX.OBJECTARRAY);
    final InstructionList il = new InstructionList();
    int alen = getArgCount() + (targetVar == null ? 0 : 1) + (thisJoinPointVar == null ? 0 : 1);
    il.append(Utility.createConstant(fact, alen));
    il.append((Instruction) fact.createNewArray(Type.OBJECT, (short) 1));
    arrayVar.appendStore(il, fact);
    int stateIndex = 0;
    if (targetVar != null) {
        arrayVar.appendConvertableArrayStore(il, fact, stateIndex, targetVar);
        targetVar.setPositionInAroundState(stateIndex);
        stateIndex++;
    }
    for (int i = 0, len = getArgCount(); i < len; i++) {
        arrayVar.appendConvertableArrayStore(il, fact, stateIndex, argVars[i]);
        argVars[i].setPositionInAroundState(stateIndex);
        stateIndex++;
    }
    if (thisJoinPointVar != null) {
        arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisJoinPointVar);
        thisJoinPointVar.setPositionInAroundState(stateIndex);
        stateIndex++;
    }
    il.append(fact.createNew(new ObjectType(constructor.getDeclaringType().getName())));
    il.append(new DUP());
    arrayVar.appendLoad(il, fact);
    il.append(Utility.createInvoke(fact, world, constructor));
    if (getKind() == PreInitialization) {
        il.append(fact.DUP);
        holder.appendStore(il, fact);
    }
    return il;
}

Output:
     final InstructionList il = new InstructionList();
-    int alen = getArgCount() + (targetVar == null ? 0 : 1) + (thisJoinPointVar == null ? 0 : 1);
+    int alen = getArgCount() + (thisVar == null ? 0 : 1) + ((targetVar != null && targetVar != thisVar) ? 1 : 0) + (thisJoinPointVar == null ? 0 : 1);
     il.append(Utility.createConstant(fact, alen));


Input:
public static List<Group> getAminoAcids(Chain chain) {
    List<Group> residues = new ArrayList<Group>(chain.getSeqResGroups());
    residues.retainAll(chain.getAtomGroups());
    return residues;
}

Output:
 public static List<Group> getAminoAcids(Chain chain) {
-    List<Group> residues = new ArrayList<Group>(chain.getSeqResGroups());
-    residues.retainAll(chain.getAtomGroups());
+    List<Group> residues = new ArrayList<Group>(chain.getAtomGroups());
+    residues.retainAll(chain.getSeqResGroups());
+    List<Group> otherGroups = new ArrayList<Group>(chain.getAtomGroups());
+    otherGroups.removeAll(chain.getSeqResGroups());
+    for (Group g : otherGroups) {
+        if (g.hasAminoAtoms()) {
+            residues.add(g);
+        }
+    }
     return residues;


Input:
private void startAdvertising() {
    AdvertiseSettings advertiseSettings = new AdvertiseSettings.Builder().setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_BALANCED).setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM).setType(AdvertiseSettings.ADVERTISE_TYPE_CONNECTABLE).build();
    List<ParcelUuid> serviceUuids = new ArrayList<ParcelUuid>();
    serviceUuids.add(new ParcelUuid(BleUuidUtils.fromString("String_Node_Str")));
    AdvertisementData advertiseData = new AdvertisementData.Builder().setIncludeTxPowerLevel(false).setServiceUuids(serviceUuids).setServiceData(new ParcelUuid(BleUuidUtils.fromString("String_Node_Str")), "String_Node_Str".getBytes()).build();
    bluetoothLeAdvertiser.startAdvertising(advertiseSettings, advertiseData, advertiseCallback);
}

Output:
 private void startAdvertising() {
-    AdvertiseSettings advertiseSettings = new AdvertiseSettings.Builder().setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_BALANCED).setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM).setType(AdvertiseSettings.ADVERTISE_TYPE_CONNECTABLE).build();
+    AdvertiseSettings advertiseSettings = new AdvertiseSettings.Builder().setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_BALANCED).setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM).setConnectable(true).build();
     List<ParcelUuid> serviceUuids = new ArrayList<ParcelUuid>();


Input:
private String createLineForJiraTable(Set<TestResult> results) {
    final StringBuilder b = new StringBuilder(SEPARATOR);
    append(b, buildUriForJira(results));
    boolean acceptHeaderUnwritten = true;
    for (final TestResult result : results) {
        if (acceptHeaderUnwritten) {
            append(b, result.getRequestHeader(HttpHeaders.ACCEPT));
            acceptHeaderUnwritten = false;
        }
        append(b, result.getResponseHeader(HttpHeaders.CONTENT_TYPE));
        append(b, result.getSomeValue("String_Node_Str"));
    }
    b.append("String_Node_Str");
    return b.toString();
}

Output:
         append(b, result.getResponseHeader(HttpHeaders.CONTENT_TYPE));
-        append(b, result.getSomeValue("String_Node_Str"));
+        append(b, result.getSomeValue(RESPONSE_STATUS_CODE));
     }


Input:
protected boolean runAnalysis(Analysis analysis, String sqlStatement) {
    boolean ok = true;
    TypedReturnCode<Connection> trc = this.getConnection(analysis);
    if (!trc.isOk()) {
        return traceError("String_Node_Str" + analysis.getName() + "String_Node_Str" + trc.getMessage());
    }
    Connection connection = trc.getObject();
    try {
        Map<ModelElement, List<Indicator>> elementToIndicator = new HashMap<ModelElement, List<Indicator>>();
        Collection<Indicator> indicators = IndicatorHelper.getIndicatorLeaves(analysis.getResults());
        if (canParallel()) {
            ok = runAnalysisIndicatorsParallel(analysis, elementToIndicator, indicators);
        } else {
            ok = runAnalysisIndicators(connection, elementToIndicator, indicators);
        }
        connection.close();
        setRowCountAndNullCount(elementToIndicator);
    } catch (SQLException e) {
        log.error(e, e);
        this.errorMessage = e.getMessage();
        ok = false;
    } finally {
        ConnectionUtils.closeConnection(connection);
    }
    return ok;
}

Output:
     }
-    Connection connection = trc.getObject();
+    Connection connection = null;
+    ConnectionPool connPool = null;
     try {


Input:
protected void drawGuiContainerBackgroundLayer(float v, int i, int i2) {
    if (!init) {
        return;
    }
    updateStorageList();
    updateContentsList();
    requestListsIfNeeded();
    String text = radiusLabel.getText();
    if ("String_Node_Str".equals(text)) {
        text = "String_Node_Str";
    }
    visibleRadiusLabel.setText(text);
    int selected = storageList.getSelected();
    removeButton.setEnabled(selected != -1);
    if (selected <= 0 || storageList.getChildCount() <= 2) {
        upButton.setEnabled(false);
        downButton.setEnabled(false);
        topButton.setEnabled(false);
        bottomButton.setEnabled(false);
    } else if (selected == 1) {
        topButton.setEnabled(false);
        upButton.setEnabled(false);
        downButton.setEnabled(true);
        bottomButton.setEnabled(true);
    } else if (selected == storageList.getChildCount() - 1) {
        topButton.setEnabled(true);
        upButton.setEnabled(true);
        downButton.setEnabled(false);
        bottomButton.setEnabled(false);
    } else {
        topButton.setEnabled(true);
        upButton.setEnabled(true);
        downButton.setEnabled(true);
        bottomButton.setEnabled(true);
    }
    if (!tileEntity.isDummy()) {
        tileEntity.requestRfFromServer(RFTools.MODID);
        int currentRF = GenericEnergyStorageTileEntity.getCurrentRF();
        energyBar.setValue(currentRF);
        exportToStarred.setCurrentChoice(tileEntity.isExportToCurrent() ? 0 : 1);
    } else {
        if (System.currentTimeMillis() - lastTime > 300) {
            lastTime = System.currentTimeMillis();
            tileEntity.requestDataFromServer(RFTools.MODID, StorageScannerTileEntity.CMD_SCANNER_INFO, TypedMap.EMPTY);
        }
        energyBar.setValue(rfReceived);
        exportToStarred.setCurrentChoice(exportToCurrentReceived ? 0 : 1);
    }
    drawWindow();
}

Output:
         tileEntity.requestRfFromServer(RFTools.MODID);
-        int currentRF = GenericEnergyStorageTileEntity.getCurrentRF();
+        long currentRF = GenericEnergyStorageTileEntity.getCurrentRF();
         energyBar.setValue(currentRF);


Input:
protected boolean _transferOutputs(IOPort port) throws IllegalActionException {
    boolean result = false;
    if (_debugging) {
        _debug("String_Node_Str" + port.getFullName());
    }
    if (!port.isOutput() || !port.isOpaque()) {
        throw new IllegalActionException(this, port, "String_Node_Str" + "String_Node_Str");
    }
    for (int i = 0; i < port.getWidthInside(); i++) {
        try {
            if (port.isKnownInside(i)) {
                if (port.hasTokenInside(i)) {
                    Token t = port.getInside(i);
                    if (_debugging) {
                        _debug(getName(), "String_Node_Str" + t + "String_Node_Str" + port.getName());
                    }
                    port.send(i, t);
                    _hadToken.add(port);
                    result = true;
                } else {
                    if (_debugging) {
                        _debug(getName(), "String_Node_Str" + port.getName());
                    }
                    if (!_hadToken.contains(port)) {
                        FSMActor controller = getController();
                        boolean guardsEvaluable = _isSafeToClear(port, controller);
                        if (guardsEvaluable) {
                            port.send(i, null);
                        }
                    }
                }
            }
        } catch (NoTokenException ex) {
            throw new InternalErrorException(this, ex, null);
        }
    }
    return result;
}

Output:
                         FSMActor controller = getController();
-                        boolean guardsEvaluable = _isSafeToClear(port, controller);
-                        if (guardsEvaluable) {
+                        if ((controller.getLastChosenTransition() != null) || _isSafeToClear(port, controller)) {
                             port.send(i, null);


Input:
private EbicsCertificate updateCertificate(X509Certificate certificate, EbicsCertificate cert, byte[] privateKey, String type) throws CertificateEncodingException, IOException {
    if (cert == null) {
        cert = new EbicsCertificate();
        cert.setTypeSelect(type);
    }
    EbicsCertificateService certificateService = Beans.get(EbicsCertificateService.class);
    cert = certificateService.updateCertificate(certificate, cert);
    cert.setPrivateKey(privateKey);
    return cert;
}

Output:
     EbicsCertificateService certificateService = Beans.get(EbicsCertificateService.class);
-    cert = certificateService.updateCertificate(certificate, cert);
+    cert = certificateService.updateCertificate(certificate, cert, true);
     cert.setPrivateKey(privateKey);


Input:
private boolean matchSome(TemplateFieldSuggestions inputSuggestions, TemplateFieldSuggestions recordedSuggestions) {
    return false;
}

Output:
 private boolean matchSome(TemplateFieldSuggestions inputSuggestions, TemplateFieldSuggestions recordedSuggestions) {
-    return false;
+    boolean matchSome = false;
+    for (AbstractTemplateField inputField : inputSuggestions.getTemplateFields()) {
+        for (AbstractTemplateField recordedField : recordedSuggestions.getTemplateFields()) {
+            if (match(inputField, recordedField)) {
+                matchSome = true;
+            }
+        }
+    }
+    logger.debug("String_Node_Str" + matchSome);
+    return matchSome;
 }


Input:
private void checkColumnArrayStatus() {
    if (true)
        return;
    ColumnArrayAdv prev = null;
    System.out.println("String_Node_Str");
    for (ColumnArrayAdv array : columnArrays.values()) {
        System.out.println("String_Node_Str" + array.getIndex() + "String_Node_Str" + array.getLastIndex());
    }
    for (ColumnArrayAdv array : columnArrays.values()) {
        if (prev == null) {
            if (array.getIndex() != 0) {
                throw new IllegalStateException("String_Node_Str" + array.getIndex());
            }
        } else {
            if (prev.getLastIndex() + 1 != array.getIndex()) {
                throw new IllegalStateException("String_Node_Str" + prev.getLastIndex() + "String_Node_Str" + array.getIndex());
            }
        }
        prev = array;
    }
    System.out.println("String_Node_Str");
}

Output:
 private void checkColumnArrayStatus() {
-    if (true)
+    if (!DEBUG)
         return;