Input:
public void updateRow(RowArea rowArea, int specifiedHeight, boolean finished) {
    hasDropCell = !finished;
    Row lastRow = getPreviousRow();
    if (lastRow == null && existDropCells() && (!LayoutUtil.isRepeatableRow((IRowContent) rowArea.getContent()))) {
        lastRow = unresolvedRow;
    }
    Row row = new Row(rowArea, startCol, endCol, finished);
    int height = specifiedHeight;
    for (int i = startCol; i <= endCol; i++) {
        CellArea lastCell = null;
        if (lastRow != null) {
            lastCell = lastRow.getCell(i);
        }
        CellArea cell = row.getCell(i);
        if (lastCell != null && ((lastCell.getRowSpan() > 1) || isDropCell(lastCell))) {
            if (cell != null && (lastCell instanceof DummyCell)) {
                row.remove(i);
            }
            if (lastCell.getRowSpan() == 2) {
                if (lastCell instanceof DummyCell) {
                    height = Math.max(height, lastCell.getHeight());
                } else {
                    height = Math.max(height, lastCell.getHeight() - lastRow.getArea().getHeight());
                }
            }
            i = i + lastCell.getColSpan() - 1;
        } else {
            if (cell != null) {
                if (cell.getRowSpan() == 1) {
                    height = Math.max(height, cell.getHeight());
                }
            }
            if (cell == null) {
                ICellContent cellContent = null;
                if (unresolvedRow != null) {
                    CellArea ca = unresolvedRow.getCell(i);
                    if (ca != null) {
                        ICellContent cc = (ICellContent) ca.getContent();
                        cellContent = new ClonedCellContent(cc, getRowSpan((IRowContent) rowArea.getContent(), ca, unresolvedRow.row));
                    }
                }
                if (cellContent == null) {
                    cellContent = tableContent.getReportContent().createCellContent();
                    cellContent.setColumn(i);
                    cellContent.setColSpan(1);
                    cellContent.setRowSpan(1);
                    cellContent.setParent(rowArea.getContent());
                }
                int startColumn = cellContent.getColumn();
                int endColumn = cellContent.getColSpan() + startColumn;
                CellArea emptyCell = AreaFactory.createCellArea(cellContent);
                resolveBorderConflict(emptyCell, false);
                IStyle areaStyle = emptyCell.getStyle();
                areaStyle.setProperty(IStyle.STYLE_PADDING_TOP, IStyle.NUMBER_0);
                areaStyle.setProperty(IStyle.STYLE_MARGIN_TOP, IStyle.NUMBER_0);
                emptyCell.setWidth(getCellWidth(startColumn, endColumn));
                emptyCell.setPosition(layoutInfo.getXPosition(i), 0);
                rowArea.addChild(emptyCell);
                i = i + emptyCell.getColSpan() - 1;
            }
        }
    }
    if (specifiedHeight == 0 && isEmptyRow(row)) {
        height = Math.max(height, getHeightOfEmptyRow(row));
    }
    if (height >= 0) {
        Iterator iter = rowArea.getChildren();
        while (iter.hasNext()) {
            CellArea cell = (CellArea) iter.next();
            if (cell.getRowSpan() == 1) {
                cell.setHeight(height);
                verticalAlign(cell);
            }
        }
        rowArea.setHeight(height);
    }
    if (firstRow && existDropCells() && (!LayoutUtil.isRepeatableRow((IRowContent) rowArea.getContent()))) {
        mergeDropCell(rowArea);
    }
}

Output:
         if (lastCell != null && ((lastCell.getRowSpan() > 1) || isDropCell(lastCell))) {
-            if (cell != null && (lastCell instanceof DummyCell)) {
-                row.remove(i);
+            if (isDropCell(lastCell)) {
+                if (cell != null) {
+                    row.remove(i);
+                }
             }


Input:
private void byteLoop(Raster source, WritableRaster dest, Rectangle destRect) {
    float src_rect_x1 = source.getMinX();
    float src_rect_y1 = source.getMinY();
    float src_rect_x2 = src_rect_x1 + source.getWidth();
    float src_rect_y2 = src_rect_y1 + source.getHeight();
    MultiPixelPackedSampleModel sourceSM = (MultiPixelPackedSampleModel) source.getSampleModel();
    DataBufferByte sourceDB = (DataBufferByte) source.getDataBuffer();
    int sourceTransX = source.getSampleModelTranslateX();
    int sourceTransY = source.getSampleModelTranslateY();
    int sourceDataBitOffset = sourceSM.getDataBitOffset();
    int sourceScanlineStride = sourceSM.getScanlineStride();
    MultiPixelPackedSampleModel destSM = (MultiPixelPackedSampleModel) dest.getSampleModel();
    DataBufferByte destDB = (DataBufferByte) dest.getDataBuffer();
    int destMinX = dest.getMinX();
    int destMinY = dest.getMinY();
    int destTransX = dest.getSampleModelTranslateX();
    int destTransY = dest.getSampleModelTranslateY();
    int destDataBitOffset = destSM.getDataBitOffset();
    int destScanlineStride = destSM.getScanlineStride();
    byte[] sourceData = sourceDB.getData();
    int sourceDBOffset = sourceDB.getOffset();
    byte[] destData = destDB.getData();
    int destDBOffset = destDB.getOffset();
    Point2D dst_pt = new Point2D.Float();
    Point2D src_pt = new Point2D.Float();
    int dst_min_x = destRect.x;
    int dst_min_y = destRect.y;
    int dst_max_x = destRect.x + destRect.width;
    int dst_max_y = destRect.y + destRect.height;
    int incyStride = incy * sourceScanlineStride;
    int incy1Stride = incy1 * sourceScanlineStride;
    black = ((int) backgroundValues[0]) & 1;
    for (int y = dst_min_y; y < dst_max_y; y++) {
        dst_pt.setLocation((double) dst_min_x + 0.5, (double) y + 0.5);
        mapDestPoint(dst_pt, src_pt);
        float s_x = (float) src_pt.getX();
        float s_y = (float) src_pt.getY();
        int s_ix = (int) Math.floor(s_x);
        int s_iy = (int) Math.floor(s_y);
        double fracx = s_x - (double) s_ix;
        double fracy = s_y - (double) s_iy;
        int ifracx = (int) Math.floor(fracx * geom_frac_max);
        int ifracy = (int) Math.floor(fracy * geom_frac_max);
        int start_s_ix = s_ix;
        int start_s_iy = s_iy;
        int start_ifracx = ifracx;
        int start_ifracy = ifracy;
        Range clipRange = performScanlineClipping(src_rect_x1, src_rect_y1, src_rect_x2, src_rect_y2, s_ix, s_iy, ifracx, ifracy, dst_min_x, dst_max_x, 0, 0, 0, 0);
        int clipMinX = ((Integer) clipRange.getMinValue()).intValue();
        int clipMaxX = ((Integer) clipRange.getMaxValue()).intValue();
        if (clipMinX > clipMaxX)
            continue;
        int destYOffset = (y - destTransY) * destScanlineStride + destDBOffset;
        int destXOffset = destDataBitOffset + (dst_min_x - destTransX);
        int sourceYOffset = (s_iy - sourceTransY) * sourceScanlineStride + sourceDBOffset;
        int sourceXOffset = s_ix - sourceTransX + sourceDataBitOffset;
        for (int x = dst_min_x; x < clipMinX; x++) {
            if (setBackground) {
                int dindex = destYOffset + (destXOffset >> 3);
                int dshift = 7 - (destXOffset & 7);
                int delement = destData[dindex];
                delement |= black << dshift;
                destData[dindex] = (byte) delement;
            }
            if (ifracx < ifracdx1) {
                s_ix += incx;
                ifracx += ifracdx;
                sourceXOffset += incx;
            } else {
                s_ix += incx1;
                ifracx -= ifracdx1;
                sourceXOffset += incx1;
            }
            if (ifracy < ifracdy1) {
                s_iy += incy;
                ifracy += ifracdy;
                sourceYOffset += incyStride;
            } else {
                s_iy += incy1;
                ifracy -= ifracdy1;
                sourceYOffset += incy1Stride;
            }
            ++destXOffset;
        }
        for (int x = clipMinX; x < clipMaxX; x++) {
            int sindex = sourceYOffset + (sourceXOffset >> 3);
            byte selement = sourceData[sindex];
            int val = (selement >> (7 - (sourceXOffset & 7))) & 1;
            int dindex = destYOffset + (destXOffset >> 3);
            int dshift = 7 - (destXOffset & 7);
            int delement = destData[dindex];
            delement |= val << dshift;
            destData[dindex] = (byte) delement;
            if (ifracx < ifracdx1) {
                s_ix += incx;
                ifracx += ifracdx;
                sourceXOffset += incx;
            } else {
                s_ix += incx1;
                ifracx -= ifracdx1;
                sourceXOffset += incx1;
            }
            if (ifracy < ifracdy1) {
                s_iy += incy;
                ifracy += ifracdy;
                sourceYOffset += incyStride;
            } else {
                s_iy += incy1;
                ifracy -= ifracdy1;
                sourceYOffset += incy1Stride;
            }
            ++destXOffset;
        }
        for (int x = clipMaxX; x < dst_max_x; x++) {
            if (setBackground) {
                int dindex = destYOffset + (destXOffset >> 3);
                int dshift = 7 - (destXOffset & 7);
                int delement = destData[dindex];
                delement |= black << dshift;
                destData[dindex] = (byte) delement;
            }
            if (ifracx < ifracdx1) {
                s_ix += incx;
                ifracx += ifracdx;
                sourceXOffset += incx;
            } else {
                s_ix += incx1;
                ifracx -= ifracdx1;
                sourceXOffset += incx1;
            }
            if (ifracy < ifracdy1) {
                s_iy += incy;
                ifracy += ifracdy;
                sourceYOffset += incyStride;
            } else {
                s_iy += incy1;
                ifracy -= ifracdy1;
                sourceYOffset += incy1Stride;
            }
            ++destXOffset;
        }
    }
}

Output:
         int start_ifracy = ifracy;
-        Range clipRange = performScanlineClipping(src_rect_x1, src_rect_y1, src_rect_x2, src_rect_y2, s_ix, s_iy, ifracx, ifracy, dst_min_x, dst_max_x, 0, 0, 0, 0);
+        Range clipRange = performScanlineClipping(src_rect_x1, src_rect_y1, src_rect_x2 - 1, src_rect_y2 - 1, s_ix, s_iy, ifracx, ifracy, dst_min_x, dst_max_x, 0, 0, 0, 0);
         int clipMinX = ((Integer) clipRange.getMinValue()).intValue();


Input:
private AliasedQuerySource enterQueryContext(Expression target) {
    QueryContext queryContext = new QueryContext();
    queryContext.setIsImplicit(true);
    List<AliasedQuerySource> sources = new ArrayList<>();
    AliasedQuerySource source = of.createAliasedQuerySource().withExpression(target).withAlias("String_Node_Str");
    source.setResultType(target.getResultType());
    sources.add(source);
    queryContext.addQuerySources(sources);
    builder.pushQueryContext(queryContext);
    return source;
}

Output:
     sources.add(source);
-    queryContext.addQuerySources(sources);
+    queryContext.addPrimaryQuerySources(sources);
     builder.pushQueryContext(queryContext);


Input:
private void modifySourceMemberAccessesInTargetClass(MethodDeclaration newMethodDeclaration) {
    ExpressionExtractor extractor = new ExpressionExtractor();
    List<Expression> sourceMethodInvocations = extractor.getMethodInvocations(sourceMethod.getBody());
    List<Expression> newMethodInvocations = extractor.getMethodInvocations(newMethodDeclaration.getBody());
    List<Expression> expressionsToBeRemoved = new ArrayList<Expression>();
    for (MethodInvocation methodInvocation : additionalMethodsToBeMoved.keySet()) {
        for (Expression expression : sourceMethodInvocations) {
            if (expression instanceof MethodInvocation) {
                MethodInvocation sourceMethodInvocation = (MethodInvocation) expression;
                if (methodInvocation.equals(sourceMethodInvocation)) {
                    expressionsToBeRemoved.add(methodInvocation);
                }
            }
        }
    }
    for (Expression expression : expressionsToBeRemoved) {
        int index = sourceMethodInvocations.indexOf(expression);
        sourceMethodInvocations.remove(index);
        newMethodInvocations.remove(index);
    }
    expressionsToBeRemoved.clear();
    int k = 0;
    for (Expression expression : sourceMethodInvocations) {
        if (expression instanceof MethodInvocation) {
            MethodInvocation methodInvocation = (MethodInvocation) expression;
            ITypeBinding methodInvocationDeclaringClassTypeBinding = methodInvocation.resolveMethodBinding().getDeclaringClass();
            if (methodInvocationDeclaringClassTypeBinding.getQualifiedName().equals(sourceTypeDeclaration.resolveBinding().getQualifiedName()) && (methodInvocation.getExpression() == null || methodInvocation.getExpression() instanceof ThisExpression)) {
                MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
                for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                    if (identicalSignature(sourceMethodDeclaration, methodInvocation)) {
                        MethodInvocation delegation = isDelegate(sourceMethodDeclaration);
                        if (delegation != null) {
                            ITypeBinding delegationDeclaringClassTypeBinding = delegation.resolveMethodBinding().getDeclaringClass();
                            if (delegationDeclaringClassTypeBinding.getQualifiedName().equals(targetTypeDeclaration.resolveBinding().getQualifiedName())) {
                                if (delegation.getExpression() != null) {
                                    MethodInvocation newMethodInvocation = (MethodInvocation) ASTNode.copySubtree(newMethodDeclaration.getAST(), delegation);
                                    targetRewriter.remove(newMethodInvocation.getExpression(), null);
                                    targetRewriter.replace(newMethodInvocations.get(k), newMethodInvocation, null);
                                }
                                expressionsToBeRemoved.add(methodInvocation);
                            }
                        }
                    }
                }
            } else if (methodInvocationDeclaringClassTypeBinding.getQualifiedName().equals(targetTypeDeclaration.resolveBinding().getQualifiedName()) && methodInvocation.getExpression() != null) {
                Expression methodInvocationExpression = methodInvocation.getExpression();
                if (methodInvocationExpression instanceof MethodInvocation) {
                    MethodInvocation invoker = (MethodInvocation) methodInvocationExpression;
                    if (invoker.getExpression() == null || invoker.getExpression() instanceof ThisExpression) {
                        MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
                        for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                            if (identicalSignature(sourceMethodDeclaration, invoker)) {
                                SimpleName fieldInstruction = isGetter(sourceMethodDeclaration);
                                if (fieldInstruction != null && fieldInstruction.resolveTypeBinding().getQualifiedName().equals(targetTypeDeclaration.resolveBinding().getQualifiedName())) {
                                    int index = sourceMethodInvocations.indexOf(invoker);
                                    targetRewriter.remove(newMethodInvocations.get(index), null);
                                    expressionsToBeRemoved.add(invoker);
                                    expressionsToBeRemoved.add(methodInvocation);
                                }
                            }
                        }
                    }
                }
            }
        }
        k++;
    }
    for (Expression expression : expressionsToBeRemoved) {
        int index = sourceMethodInvocations.indexOf(expression);
        sourceMethodInvocations.remove(index);
        newMethodInvocations.remove(index);
    }
    List<Expression> sourceFieldInstructions = extractor.getVariableInstructions(sourceMethod.getBody());
    List<Expression> newFieldInstructions = extractor.getVariableInstructions(newMethodDeclaration.getBody());
    int i = 0;
    for (Expression expression : sourceFieldInstructions) {
        SimpleName simpleName = (SimpleName) expression;
        IBinding binding = simpleName.resolveBinding();
        if (binding.getKind() == IBinding.VARIABLE) {
            IVariableBinding variableBinding = (IVariableBinding) binding;
            if (variableBinding.isField() && variableBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding()) && (variableBinding.getModifiers() & Modifier.STATIC) == 0) {
                SimpleName expressionName = (SimpleName) newFieldInstructions.get(i);
                if (expressionName.getParent() instanceof FieldAccess) {
                    FieldAccess fieldAccess = (FieldAccess) expressionName.getParent();
                    if (fieldAccess.getExpression() instanceof ThisExpression && !expressionName.getIdentifier().equals(targetClassVariableName)) {
                        targetRewriter.replace(expressionName.getParent(), expressionName, null);
                        if (!additionalArgumentsAddedToMovedMethod.contains(expressionName.getIdentifier()))
                            addParameterToMovedMethod(newMethodDeclaration, expressionName);
                    }
                } else if (!expressionName.getIdentifier().equals(targetClassVariableName) && !additionalArgumentsAddedToMovedMethod.contains(expressionName.getIdentifier()))
                    addParameterToMovedMethod(newMethodDeclaration, expressionName);
            }
        }
        i++;
    }
    SimpleName parameterName = null;
    int j = 0;
    for (Expression expression : sourceMethodInvocations) {
        if (expression instanceof MethodInvocation) {
            MethodInvocation methodInvocation = (MethodInvocation) expression;
            if (methodInvocation.getExpression() == null || methodInvocation.getExpression() instanceof ThisExpression) {
                IMethodBinding methodBinding = methodInvocation.resolveMethodBinding();
                if (methodBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding())) {
                    MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
                    for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                        if (identicalSignature(sourceMethodDeclaration, methodInvocation)) {
                            SimpleName fieldName = isGetter(sourceMethodDeclaration);
                            MethodInvocation newMethodInvocation = (MethodInvocation) newMethodInvocations.get(j);
                            if (fieldName != null) {
                                AST ast = newMethodDeclaration.getAST();
                                targetRewriter.replace(newMethodInvocation, ast.newSimpleName(fieldName.getIdentifier()), null);
                                if (!fieldName.getIdentifier().equals(targetClassVariableName) && !additionalArgumentsAddedToMovedMethod.contains(fieldName.getIdentifier()))
                                    addParameterToMovedMethod(newMethodDeclaration, fieldName);
                            } else {
                                if (!additionalArgumentsAddedToMovedMethod.contains("String_Node_Str")) {
                                    parameterName = addSourceClassParameterToMovedMethod(newMethodDeclaration);
                                }
                                targetRewriter.set(newMethodInvocation, MethodInvocation.EXPRESSION_PROPERTY, parameterName, null);
                                setPublicModifierToSourceMethod(methodInvocation);
                            }
                        }
                    }
                }
            }
        }
        j++;
    }
}

Output:
             IVariableBinding variableBinding = (IVariableBinding) binding;
-            if (variableBinding.isField() && variableBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding()) && (variableBinding.getModifiers() & Modifier.STATIC) == 0) {
+            if (variableBinding.isField() && sourceTypeDeclaration.resolveBinding().equals(variableBinding.getDeclaringClass()) && (variableBinding.getModifiers() & Modifier.STATIC) == 0) {
                 SimpleName expressionName = (SimpleName) newFieldInstructions.get(i);


Input:
private void doReceivedMessageOnConnectionWithBrokerDefinedPrefixPropertiesTestImpl(Class<? extends Destination> destType, String destPrefix, String destName, String replyName, String destAddress, String replyAddress, String annotationName, Object annotationValue, String replyAnnotationName, Object replyAnnotationValue) throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer(IntegrationTestFixture.PORT)) {
        Map<Symbol, Object> properties = new HashMap<Symbol, Object>();
        properties.put(AmqpConnectionProperties.QUEUE_PREFIX, destPrefix);
        properties.put(AmqpConnectionProperties.TOPIC_PREFIX, destPrefix);
        Connection connection = testFixture.establishConnecton(testPeer, null, null, properties);
        connection.start();
        testPeer.expectBegin(true);
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination dest = null;
        if (destType == Topic.class) {
            dest = session.createTopic(destName);
        } else if (destType == Queue.class) {
            dest = session.createQueue(destName);
        } else {
            fail("String_Node_Str");
        }
        MessageAnnotationsDescribedType msgAnnotations = null;
        if (annotationName != null || replyAnnotationName != null) {
            msgAnnotations = new MessageAnnotationsDescribedType();
            if (annotationName != null) {
                msgAnnotations.setSymbolKeyedAnnotation(annotationName, annotationValue);
            }
            if (replyAnnotationName != null) {
                msgAnnotations.setSymbolKeyedAnnotation(replyAnnotationName, replyAnnotationValue);
            }
        }
        PropertiesDescribedType props = new PropertiesDescribedType();
        props.setTo(destAddress);
        props.setReplyTo(replyAddress);
        DescribedType amqpValueNullContent = new AmqpValueDescribedType(null);
        SourceMatcher sourceMatcher = new SourceMatcher();
        sourceMatcher.withAddress(equalTo(destAddress));
        testPeer.expectReceiverAttach(notNullValue(), sourceMatcher);
        testPeer.expectLinkFlowRespondWithTransfer(null, msgAnnotations, props, null, amqpValueNullContent);
        testPeer.expectDispositionThatIsAcceptedAndSettled();
        MessageConsumer messageConsumer = session.createConsumer(dest);
        Message receivedMessage = messageConsumer.receive(1000);
        testPeer.waitForAllHandlersToComplete(2000);
        assertNotNull(receivedMessage);
        Destination jmsDest = receivedMessage.getJMSDestination();
        Destination jmsReplyTo = receivedMessage.getJMSReplyTo();
        assertNotNull("String_Node_Str", jmsDest);
        assertNotNull("String_Node_Str", jmsReplyTo);
        String recievedName = null;
        String recievedReplyName = null;
        if (destType == Topic.class) {
            recievedName = ((Topic) jmsDest).getTopicName();
            recievedReplyName = ((Topic) jmsReplyTo).getTopicName();
        } else if (destType == Queue.class) {
            recievedName = ((Queue) jmsDest).getQueueName();
            recievedReplyName = ((Queue) jmsReplyTo).getQueueName();
        }
        assertEquals("String_Node_Str", destName, recievedName);
        assertEquals("String_Node_Str", replyName, recievedReplyName);
    }
}

Output:
 private void doReceivedMessageOnConnectionWithBrokerDefinedPrefixPropertiesTestImpl(Class<? extends Destination> destType, String destPrefix, String destName, String replyName, String destAddress, String replyAddress, String annotationName, Object annotationValue, String replyAnnotationName, Object replyAnnotationValue) throws Exception {
-    try (TestAmqpPeer testPeer = new TestAmqpPeer(IntegrationTestFixture.PORT)) {
+    try (TestAmqpPeer testPeer = new TestAmqpPeer(testFixture.getAvailablePort())) {
         Map<Symbol, Object> properties = new HashMap<Symbol, Object>();


Input:
public static Record create(ResultSet rs) {
    try {
        Record re = new Record();
        ResultSetMetaData meta = rs.getMetaData();
        int count = meta.getColumnCount();
        for (int i = 1; i <= count; i++) {
            String name = meta.getColumnLabel(i);
            if (meta.getColumnType(i) == Types.CLOB) {
                re.set(name.toLowerCase(), rs.getString(i));
            } else {
                re.set(name.toLowerCase(), rs.getObject(i));
            }
        }
        return re;
    } catch (SQLException e) {
        throw Lang.wrapThrow(e);
    }
}

Output:
             if (meta.getColumnType(i) == Types.CLOB) {
-                re.set(name.toLowerCase(), rs.getString(i));
+                re.set(name, rs.getString(i));
             } else {


Input:
protected Control createDialogArea(final Composite parent) {
    parent.setLayout(new GridLayout());
    if (message != null) {
        final Label label = new Label(parent, SWT.NONE);
        label.setText(message);
        final GridData d = SWTUtil.createFillHorizontallyGridData();
        d.heightHint = 20;
        label.setLayoutData(d);
    }
    if (error != null) {
        final Text text = new Text(parent, SWT.NONE | SWT.MULTI | SWT.V_SCROLL | SWT.H_SCROLL | SWT.BORDER);
        text.setText(error);
        final GridData d = SWTUtil.createFillGridData();
        d.heightHint = 100;
        text.setLayoutData(d);
    }
    return parent;
}

Output:
         final Label label = new Label(parent, SWT.NONE);
-        label.setText(message);
-        final GridData d = SWTUtil.createFillHorizontallyGridData();
-        d.heightHint = 20;
-        label.setLayoutData(d);
+        label.setText(message.replaceAll("String_Node_Str", "String_Node_Str"));
+        label.setLayoutData(SWTUtil.createFillHorizontallyGridData());
     }


Input:
public ResourceDownloadInfo get(ResourceDownloadInfo rdi) throws Exception {
    return get(new URL(rdi.getDownloadableUrl()));
}

Output:
 public ResourceDownloadInfo get(ResourceDownloadInfo rdi) throws Exception {
-    return get(new URL(rdi.getDownloadableUrl()));
+    rdi = get(new URL(rdi.getDownloadableUrl()));
+    return rdi;
 }


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(R.layout.activity_radarchart);
    mChart = (RadarChart) findViewById(R.id.chart1);
    tf = Typeface.createFromAsset(getAssets(), "String_Node_Str");
    mChart.setDescription("String_Node_Str");
    mChart.setWebLineWidth(1.5f);
    mChart.setWebLineWidthInner(0.75f);
    mChart.setWebAlpha(100);
    MyMarkerView mv = new MyMarkerView(this, R.layout.custom_marker_view);
    mChart.setMarkerView(mv);
    setData();
    XAxis xl = mChart.getXAxis();
    xl.setTypeface(tf);
    xl.setTextSize(9f);
    YAxis yl = mChart.getYAxis();
    yl.setTypeface(tf);
    yl.setLabelCount(5);
    yl.setTextSize(9f);
    Legend l = mChart.getLegend();
    l.setPosition(LegendPosition.RIGHT_OF_CHART);
    l.setTypeface(tf);
    l.setXEntrySpace(7f);
    l.setYEntrySpace(5f);
}

Output:
     setData();
-    XAxis xl = mChart.getXAxis();
-    xl.setTypeface(tf);
-    xl.setTextSize(9f);
-    YAxis yl = mChart.getYAxis();
-    yl.setTypeface(tf);
-    yl.setLabelCount(5);
-    yl.setTextSize(9f);
+    XAxis xAxis = mChart.getXAxis();
+    xAxis.setTypeface(tf);
+    xAxis.setTextSize(9f);
+    YAxis yAxis = mChart.getYAxis();
+    yAxis.setTypeface(tf);
+    yAxis.setLabelCount(5);
+    yAxis.setTextSize(9f);
+    yAxis.setStartAtZero(true);
     Legend l = mChart.getLegend();


Input:
private void reportComError(String errMsg) {
    for (MavLinkConnectionListener listener : mListeners) {
        listener.onComError(errMsg);
    }
}

Output:
 private void reportComError(String errMsg) {
-    for (MavLinkConnectionListener listener : mListeners) {
+    if (mListeners.isEmpty())
+        return;
+    for (MavLinkConnectionListener listener : mListeners.values()) {
         listener.onComError(errMsg);


Input:
public void onAnimationComplete() {
    MainApplication.postEvent(getContext(), mEndBubbleDragEvent);
    MainController mainController = MainController.get();
    if (mCurrentSnapTarget.getAction() == Config.BubbleAction.Destroy) {
        mainController.destroyAllBubbles();
        mMode = Mode.BubbleView;
    } else {
        if (mainController.destroyCurrentBubble(mCurrentSnapTarget.getAction())) {
            doAnimateToBubbleView();
        } else {
            mMode = Mode.BubbleView;
        }
    }
    onAnimComplete();
    mFlickActive = false;
    mCurrentSnapTarget.endSnapping();
    mCurrentSnapTarget = null;
}

Output:
     MainController mainController = MainController.get();
-    if (mCurrentSnapTarget.getAction() == Config.BubbleAction.Destroy) {
+    onAnimComplete();
+    mFlickActive = false;
+    Config.BubbleAction action = mCurrentSnapTarget.getAction();
+    mCurrentSnapTarget.endSnapping();
+    mCurrentSnapTarget = null;
+    if (action == Config.BubbleAction.Destroy) {
         mainController.destroyAllBubbles();


Input:
<T> Result okResult(List<T> list, String typeName) {
    JsonNode node = mapper.valueToTree(new ResourceList<T>(list));
    ArrayNode items = (ArrayNode) node.get("String_Node_Str");
    for (int i = 0; i < items.size(); i++) {
        ((ObjectNode) items.get(0)).put("String_Node_Str", typeName);
    }
    return ok(node);
}

Output:
     for (int i = 0; i < items.size(); i++) {
-        ((ObjectNode) items.get(0)).put("String_Node_Str", typeName);
+        ((ObjectNode) items.get(i)).put("String_Node_Str", typeName);
     }


Input:
public void setSession(AbstractSession session) {
    this.session = session.getRootSession(null);
}

Output:
 public void setSession(AbstractSession session) {
-    this.session = session.getRootSession(null);
+    if (session != null) {
+        this.session = session.getRootSession(null);
+    } else {
+        this.session = null;
+    }
 }


Input:
protected void createTabsLoader() {
    mLoader = new GameTabsGsonLoader(this);
}

Output:
 protected void createTabsLoader() {
-    mLoader = new GameTabsGsonLoader(this);
+    mLoader = new GameTabsGsonLoader(this, null);
 }


Input:
public void testXRD() throws Exception {
    QName qname = new QName(XRDConstants.XRD_NS, XRD.DEFAULT_ELEMENT_LOCAL_NAME, XRDConstants.XRD_PREFIX);
    XRD xrd = (XRD) buildXMLObject(qname);
    xrd.setID("String_Node_Str");
    addSignature(xrd);
    Marshaller marshaller = Configuration.getMarshallerFactory().getMarshaller(xrd);
    marshaller.marshall(xrd);
    Signer.signObject(xrd.getSignature());
    printXRD(xrd);
    System.out.println("String_Node_Str");
    printXRD2(xrd);
}

Output:
 public void testXRD() throws Exception {
-    QName qname = new QName(XRDConstants.XRD_NS, XRD.DEFAULT_ELEMENT_LOCAL_NAME, XRDConstants.XRD_PREFIX);
-    XRD xrd = (XRD) buildXMLObject(qname);
+    XRD xrd = (XRD) buildXMLObject(XRD.DEFAULT_ELEMENT_NAME);
     xrd.setID("String_Node_Str");


Input:
private int parseCodeIndex(List<String> content) {
    for (int index = annotationIndex; index < content.size(); index++) {
        if (content.get(index).trim().startsWith("String_Node_Str") == false) {
            if (content.get(index).trim().length() == 0) {
                throw new RuntimeException("String_Node_Str" + annotationIndex + "String_Node_Str");
            }
            return index;
        }
    }
    throw new RuntimeException("String_Node_Str" + annotationIndex);
}

Output:
 private int parseCodeIndex(List<String> content) {
-    for (int index = annotationIndex; index < content.size(); index++) {
+    for (int index = propertyIndex; index < content.size(); index++) {
         if (content.get(index).trim().startsWith("String_Node_Str") == false) {


Input:
public static org.hl7.fhir.dstu3.model.Type convertType(org.hl7.fhir.r4.model.Type src) throws FHIRException {
    if (src == null)
        return null;
    if (src instanceof org.hl7.fhir.r4.model.Base64BinaryType)
        return convertBase64Binary((org.hl7.fhir.r4.model.Base64BinaryType) src);
    if (src instanceof org.hl7.fhir.r4.model.BooleanType)
        return convertBoolean((org.hl7.fhir.r4.model.BooleanType) src);
    if (src instanceof org.hl7.fhir.r4.model.CodeType)
        return convertCode((org.hl7.fhir.r4.model.CodeType) src);
    if (src instanceof org.hl7.fhir.r4.model.DateType)
        return convertDate((org.hl7.fhir.r4.model.DateType) src);
    if (src instanceof org.hl7.fhir.r4.model.DateTimeType)
        return convertDateTime((org.hl7.fhir.r4.model.DateTimeType) src);
    if (src instanceof org.hl7.fhir.r4.model.DecimalType)
        return convertDecimal((org.hl7.fhir.r4.model.DecimalType) src);
    if (src instanceof org.hl7.fhir.r4.model.IdType)
        return convertId((org.hl7.fhir.r4.model.IdType) src);
    if (src instanceof org.hl7.fhir.r4.model.InstantType)
        return convertInstant((org.hl7.fhir.r4.model.InstantType) src);
    if (src instanceof org.hl7.fhir.r4.model.IntegerType)
        return convertInteger((org.hl7.fhir.r4.model.IntegerType) src);
    if (src instanceof org.hl7.fhir.r4.model.MarkdownType)
        return convertMarkdown((org.hl7.fhir.r4.model.MarkdownType) src);
    if (src instanceof org.hl7.fhir.r4.model.OidType)
        return convertOid((org.hl7.fhir.r4.model.OidType) src);
    if (src instanceof org.hl7.fhir.r4.model.PositiveIntType)
        return convertPositiveInt((org.hl7.fhir.r4.model.PositiveIntType) src);
    if (src instanceof org.hl7.fhir.r4.model.StringType)
        return convertString((org.hl7.fhir.r4.model.StringType) src);
    if (src instanceof org.hl7.fhir.r4.model.TimeType)
        return convertTime((org.hl7.fhir.r4.model.TimeType) src);
    if (src instanceof org.hl7.fhir.r4.model.UnsignedIntType)
        return convertUnsignedInt((org.hl7.fhir.r4.model.UnsignedIntType) src);
    if (src instanceof org.hl7.fhir.r4.model.UriType)
        return convertUri((org.hl7.fhir.r4.model.UriType) src);
    if (src instanceof org.hl7.fhir.r4.model.UuidType)
        return convertUuid((org.hl7.fhir.r4.model.UuidType) src);
    if (src instanceof org.hl7.fhir.r4.model.Extension)
        return convertExtension((org.hl7.fhir.r4.model.Extension) src);
    if (src instanceof org.hl7.fhir.r4.model.Narrative)
        return convertNarrative((org.hl7.fhir.r4.model.Narrative) src);
    if (src instanceof org.hl7.fhir.r4.model.Age)
        return convertAge((org.hl7.fhir.r4.model.Age) src);
    if (src instanceof org.hl7.fhir.r4.model.Annotation)
        return convertAnnotation((org.hl7.fhir.r4.model.Annotation) src);
    if (src instanceof org.hl7.fhir.r4.model.Attachment)
        return convertAttachment((org.hl7.fhir.r4.model.Attachment) src);
    if (src instanceof org.hl7.fhir.r4.model.CodeableConcept)
        return convertCodeableConcept((org.hl7.fhir.r4.model.CodeableConcept) src);
    if (src instanceof org.hl7.fhir.r4.model.Coding)
        return convertCoding((org.hl7.fhir.r4.model.Coding) src);
    if (src instanceof org.hl7.fhir.r4.model.Count)
        return convertCount((org.hl7.fhir.r4.model.Count) src);
    if (src instanceof org.hl7.fhir.r4.model.Distance)
        return convertDistance((org.hl7.fhir.r4.model.Distance) src);
    if (src instanceof org.hl7.fhir.r4.model.Duration)
        return convertDuration((org.hl7.fhir.r4.model.Duration) src);
    if (src instanceof org.hl7.fhir.r4.model.Identifier)
        return convertIdentifier((org.hl7.fhir.r4.model.Identifier) src);
    if (src instanceof org.hl7.fhir.r4.model.Money)
        return convertMoney((org.hl7.fhir.r4.model.Money) src);
    if (src instanceof org.hl7.fhir.r4.model.Period)
        return convertPeriod((org.hl7.fhir.r4.model.Period) src);
    if (src instanceof org.hl7.fhir.r4.model.Quantity)
        return convertQuantity((org.hl7.fhir.r4.model.Quantity) src);
    if (src instanceof org.hl7.fhir.r4.model.Range)
        return convertRange((org.hl7.fhir.r4.model.Range) src);
    if (src instanceof org.hl7.fhir.r4.model.Ratio)
        return convertRatio((org.hl7.fhir.r4.model.Ratio) src);
    if (src instanceof org.hl7.fhir.r4.model.Reference)
        return convertReference((org.hl7.fhir.r4.model.Reference) src);
    if (src instanceof org.hl7.fhir.r4.model.SampledData)
        return convertSampledData((org.hl7.fhir.r4.model.SampledData) src);
    if (src instanceof org.hl7.fhir.r4.model.Signature)
        return convertSignature((org.hl7.fhir.r4.model.Signature) src);
    if (src instanceof org.hl7.fhir.r4.model.Address)
        return convertAddress((org.hl7.fhir.r4.model.Address) src);
    if (src instanceof org.hl7.fhir.r4.model.ContactDetail)
        return convertContactDetail((org.hl7.fhir.r4.model.ContactDetail) src);
    if (src instanceof org.hl7.fhir.r4.model.ContactPoint)
        return convertContactPoint((org.hl7.fhir.r4.model.ContactPoint) src);
    if (src instanceof org.hl7.fhir.r4.model.Contributor)
        return convertContributor((org.hl7.fhir.r4.model.Contributor) src);
    if (src instanceof org.hl7.fhir.r4.model.Dosage)
        return convertDosage((org.hl7.fhir.r4.model.Dosage) src);
    if (src instanceof org.hl7.fhir.r4.model.HumanName)
        return convertHumanName((org.hl7.fhir.r4.model.HumanName) src);
    if (src instanceof org.hl7.fhir.r4.model.Meta)
        return convertMeta((org.hl7.fhir.r4.model.Meta) src);
    if (src instanceof org.hl7.fhir.r4.model.ParameterDefinition)
        return convertParameterDefinition((org.hl7.fhir.r4.model.ParameterDefinition) src);
    if (src instanceof org.hl7.fhir.r4.model.RelatedArtifact)
        return convertRelatedArtifact((org.hl7.fhir.r4.model.RelatedArtifact) src);
    if (src instanceof org.hl7.fhir.r4.model.Timing)
        return convertTiming((org.hl7.fhir.r4.model.Timing) src);
    if (src instanceof org.hl7.fhir.r4.model.UsageContext)
        return convertUsageContext((org.hl7.fhir.r4.model.UsageContext) src);
    if (src instanceof org.hl7.fhir.r4.model.SimpleQuantity)
        return convertSimpleQuantity((org.hl7.fhir.r4.model.SimpleQuantity) src);
    throw new Error("String_Node_Str" + src.fhirType());
}

Output:
         return convertUsageContext((org.hl7.fhir.r4.model.UsageContext) src);
-    if (src instanceof org.hl7.fhir.r4.model.SimpleQuantity)
-        return convertSimpleQuantity((org.hl7.fhir.r4.model.SimpleQuantity) src);
+    if (src instanceof org.hl7.fhir.r4.model.ElementDefinition)
+        return convertElementDefinition((org.hl7.fhir.r4.model.ElementDefinition) src);
+    if (src instanceof org.hl7.fhir.r4.model.DataRequirement)
+        return convertDataRequirement((org.hl7.fhir.r4.model.DataRequirement) src);
     throw new Error("String_Node_Str" + src.fhirType());


Input:
public String getImageMap() {
    Map triggerMap = getTriggers();
    if (triggerMap == null || triggerMap.size() == 0) {
        return null;
    }
    StringBuffer sb = new StringBuffer();
    List al = (List) triggerMap.get(TriggerCondition.ONFOCUS_LITERAL);
    if (al != null) {
        for (int i = al.size() - 1; i >= 0; i--) {
            ShapedAction sa = (ShapedAction) al.get(i);
            Action ac = sa.getAction();
            String coords = shape2polyCoords(sa.getShape());
            if (coords != null) {
                if (checkSupportedAction(ac)) {
                    switch(ac.getType().getValue()) {
                        case ActionType.URL_REDIRECT:
                            URLValue uv = (URLValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append("String_Node_Str");
                            sb.append(eval(uv.getBaseUrl()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                        case ActionType.SHOW_TOOLTIP:
                            break;
                        case ActionType.INVOKE_SCRIPT:
                            ScriptValue sv = (ScriptValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append(eval(sv.getScript()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                    }
                } else {
                }
            }
        }
    }
    al = (List) triggerMap.get(TriggerCondition.ONBLUR_LITERAL);
    if (al != null) {
        for (int i = al.size() - 1; i >= 0; i--) {
            ShapedAction sa = (ShapedAction) al.get(i);
            Action ac = sa.getAction();
            String coords = shape2polyCoords(sa.getShape());
            if (coords != null) {
                if (checkSupportedAction(ac)) {
                    switch(ac.getType().getValue()) {
                        case ActionType.URL_REDIRECT:
                            URLValue uv = (URLValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append("String_Node_Str");
                            sb.append(eval(uv.getBaseUrl()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                        case ActionType.SHOW_TOOLTIP:
                            break;
                        case ActionType.INVOKE_SCRIPT:
                            ScriptValue sv = (ScriptValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append(eval(sv.getScript()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                    }
                } else {
                }
            }
        }
    }
    al = (List) triggerMap.get(TriggerCondition.ONCLICK_LITERAL);
    if (al != null) {
        for (int i = al.size() - 1; i >= 0; i--) {
            ShapedAction sa = (ShapedAction) al.get(i);
            Action ac = sa.getAction();
            String coords = shape2polyCoords(sa.getShape());
            if (coords != null) {
                if (checkSupportedAction(ac)) {
                    switch(ac.getType().getValue()) {
                        case ActionType.URL_REDIRECT:
                            URLValue uv = (URLValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append(eval(uv.getBaseUrl()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                        case ActionType.SHOW_TOOLTIP:
                            break;
                        case ActionType.INVOKE_SCRIPT:
                            ScriptValue sv = (ScriptValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append(eval(sv.getScript()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                    }
                } else {
                }
            }
        }
    }
    al = (List) triggerMap.get(TriggerCondition.ONMOUSEOVER_LITERAL);
    if (al != null) {
        for (int i = al.size() - 1; i >= 0; i--) {
            ShapedAction sa = (ShapedAction) al.get(i);
            Action ac = sa.getAction();
            String coords = shape2polyCoords(sa.getShape());
            if (coords != null) {
                if (checkSupportedAction(ac)) {
                    switch(ac.getType().getValue()) {
                        case ActionType.URL_REDIRECT:
                            break;
                        case ActionType.SHOW_TOOLTIP:
                            TooltipValue tv = (TooltipValue) ac.getValue();
                            sb.append("String_Node_Str");
                            sb.append(eval(tv.getText()));
                            sb.append("String_Node_Str");
                            sb.append(coords).append("String_Node_Str");
                            break;
                        case ActionType.INVOKE_SCRIPT:
                            break;
                    }
                } else {
                }
            }
        }
    }
    return sb.toString();
}

Output:
                             URLValue uv = (URLValue) ac.getValue();
-                            sb.append("String_Node_Str");
-                            sb.append("String_Node_Str");
-                            sb.append(eval(uv.getBaseUrl()));
-                            sb.append("String_Node_Str");
-                            sb.append(coords).append("String_Node_Str");
+                            tag.addAttribute(HTMLAttribute.HREF, NO_OP_JAVASCRIPT);
+                            tag.addAttribute(HTMLAttribute.ONFOCUS, getJsURLRedirect(uv));
+                            tag.addAttribute(HTMLAttribute.SHAPE, POLY_SHAPE);
+                            tag.addAttribute(HTMLAttribute.COORDS, coords);
+                            sb.append(tag.toString());
                             break;


Input:
public int compare(DoublePair o1, DoublePair o2) {
    int cmp = Double.compare(o1.v1, o2.v1);
    if (cmp == 0) {
        cmp = Double.compare(o2.v2, o2.v2);
    }
    return cmp;
}

Output:
     if (cmp == 0) {
-        cmp = Double.compare(o2.v2, o2.v2);
+        cmp = Double.compare(o1.v2, o2.v2);
     }


Input:
public final void setProperty(String sProperty, Object oValue) {
    super.setProperty(sProperty, oValue);
    if (sProperty.equals(IDeviceRenderer.EXPECTED_BOUNDS)) {
        final Bounds bo = (Bounds) oValue;
        try {
            dom = createSvgDocument(bo.getWidth(), bo.getHeight());
            svggc = new SVGGraphics2D(dom);
            hotspotLayer = createHotspotLayer(dom);
            super.setProperty(IDeviceRenderer.GRAPHICS_CONTEXT, svggc);
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else if (sProperty.equals(IDeviceRenderer.FILE_IDENTIFIER)) {
        oOutputIdentifier = oValue;
    }
}

Output:
     super.setProperty(sProperty, oValue);
-    if (sProperty.equals(IDeviceRenderer.EXPECTED_BOUNDS)) {
+    if (sProperty.equals(IDeviceRenderer.UPDATE_NOTIFIER)) {
+        _iun = (IUpdateNotifier) oValue;
+    } else if (sProperty.equals(IDeviceRenderer.EXPECTED_BOUNDS)) {
         final Bounds bo = (Bounds) oValue;


Input:
public String toString() {
    return "String_Node_Str" + "String_Node_Str" + accountId + '\'' + "String_Node_Str" + description + '\'' + "String_Node_Str" + logicalResourceId + '\'' + "String_Node_Str" + metadataJson + '\'' + "String_Node_Str" + physicalResourceId + '\'' + "String_Node_Str" + internalPhysicalResourceUuid + '\'' + "String_Node_Str" + resourceStatus + "String_Node_Str" + resourceStatusReason + '\'' + "String_Node_Str" + resourceType + '\'' + "String_Node_Str" + ready + "String_Node_Str" + propertiesJson + '\'' + "String_Node_Str" + updatePolicyJson + '\'' + "String_Node_Str" + deletionPolicy + '\'' + "String_Node_Str" + allowedByCondition + "String_Node_Str" + referenceValueJson + '\'' + "String_Node_Str" + resourceAttributesJson + '\'' + "String_Node_Str" + stackId + '\'' + "String_Node_Str" + stackName + '\'' + "String_Node_Str" + recordDeleted + '}';
}

Output:
 public String toString() {
-    return "String_Node_Str" + "String_Node_Str" + accountId + '\'' + "String_Node_Str" + description + '\'' + "String_Node_Str" + logicalResourceId + '\'' + "String_Node_Str" + metadataJson + '\'' + "String_Node_Str" + physicalResourceId + '\'' + "String_Node_Str" + internalPhysicalResourceUuid + '\'' + "String_Node_Str" + resourceStatus + "String_Node_Str" + resourceStatusReason + '\'' + "String_Node_Str" + resourceType + '\'' + "String_Node_Str" + ready + "String_Node_Str" + propertiesJson + '\'' + "String_Node_Str" + updatePolicyJson + '\'' + "String_Node_Str" + deletionPolicy + '\'' + "String_Node_Str" + allowedByCondition + "String_Node_Str" + referenceValueJson + '\'' + "String_Node_Str" + resourceAttributesJson + '\'' + "String_Node_Str" + stackId + '\'' + "String_Node_Str" + stackName + '\'' + "String_Node_Str" + recordDeleted + '}';
+    return "String_Node_Str" + "String_Node_Str" + accountId + '\'' + "String_Node_Str" + description + '\'' + "String_Node_Str" + logicalResourceId + '\'' + "String_Node_Str" + metadataJson + '\'' + "String_Node_Str" + physicalResourceId + '\'' + "String_Node_Str" + resourceStatus + "String_Node_Str" + resourceStatusReason + '\'' + "String_Node_Str" + resourceType + '\'' + "String_Node_Str" + ready + "String_Node_Str" + createdEnoughToDelete + "String_Node_Str" + propertiesJson + '\'' + "String_Node_Str" + updatePolicyJson + '\'' + "String_Node_Str" + deletionPolicy + '\'' + "String_Node_Str" + allowedByCondition + "String_Node_Str" + referenceValueJson + '\'' + "String_Node_Str" + resourceAttributesJson + '\'' + "String_Node_Str" + stackId + '\'' + "String_Node_Str" + stackName + '\'' + "String_Node_Str" + fromUpdateReplacement + '\'' + "String_Node_Str" + recordDeleted + '}';
 }


Input:
private boolean hasNoTreatmentAdvice(Patient patient) {
    return allTreatmentAdvices.findByPatientId(patient.getId()) != null;
}

Output:
 private boolean hasNoTreatmentAdvice(Patient patient) {
-    return allTreatmentAdvices.findByPatientId(patient.getId()) != null;
+    return allTreatmentAdvices.findByPatientId(patient.getId()) == null;
 }


Input:
protected void archive(String archivePath) {
    String path = getResourceRuntime().getAgentOverrides().get(LocalFile.LOCALFILE_PATH);
    File destDir = new File(path, archivePath);
    for (String srcFile : filesRead) {
        try {
            log(LogLevel.INFO, "String_Node_Str", srcFile, destDir.getAbsolutePath());
            FileUtils.moveFileToDirectory(new File(path, srcFile), destDir, true);
        } catch (IOException e) {
            throw new IoException(e);
        }
    }
}

Output:
 protected void archive(String archivePath) {
-    String path = getResourceRuntime().getAgentOverrides().get(LocalFile.LOCALFILE_PATH);
+    String path = getResourceRuntime().getResourceRuntimeSettings().get(LocalFile.LOCALFILE_PATH);
     File destDir = new File(path, archivePath);


Input:
protected void processIndirection(ObjectReferenceMapping mapping) {
    boolean usesIndirection = usesIndirection();
    if (usesIndirection && (!getProject().isWeavingEnabled()) && (!ClassConstants.PersistenceWeavedLazy_Class.isAssignableFrom(getJavaClass(getDescriptor().getJavaClass())))) {
        usesIndirection = false;
    }
    if (usesIndirection && usesPropertyAccess()) {
        mapping.setIndirectionPolicy(new WeavedObjectBasicIndirectionPolicy(getGetMethodName(), getSetMethodName(), true));
    } else if (usesIndirection && usesFieldAccess()) {
        mapping.setIndirectionPolicy(new WeavedObjectBasicIndirectionPolicy(Helper.getWeavedGetMethodName(mapping.getAttributeName()), Helper.getWeavedSetMethodName(mapping.getAttributeName()), false));
    } else {
        mapping.setUsesIndirection(usesIndirection);
    }
}

Output:
     boolean usesIndirection = usesIndirection();
-    if (usesIndirection && (!getProject().isWeavingEnabled()) && (!ClassConstants.PersistenceWeavedLazy_Class.isAssignableFrom(getJavaClass(getDescriptor().getJavaClass())))) {
+    if (usesIndirection && (!getProject().isWeavingEnabled()) && (!getDescriptor().getJavaClass().extendsInterface(ClassConstants.PersistenceWeavedLazy_Class))) {
         usesIndirection = false;


Input:
public static void addUserToGroupById(User requestUser, String userId, String groupName) throws EucalyptusServiceException {
    try {
        User user = Accounts.lookupUserById(userId);
        Account account = user.getAccount();
        Group group = account.lookupGroupByName(groupName);
        Privileged.removeUserFromGroup(requestUser, account, user, group);
    } catch (Exception e) {
        LOG.error("String_Node_Str" + userId + "String_Node_Str" + groupName, e);
        LOG.debug(e, e);
        throw new EucalyptusServiceException("String_Node_Str" + userId + "String_Node_Str" + e.getMessage() + "String_Node_Str");
    }
}

Output:
         Group group = account.lookupGroupByName(groupName);
-        Privileged.removeUserFromGroup(requestUser, account, user, group);
+        Privileged.addUserToGroup(requestUser, account, user, group);
     } catch (Exception e) {


Input:
public void processSessionSetup(SMBSrvSession sess, SMBSrvPacket reqPkt, SMBSrvPacket respPkt) throws SMBSrvException {
    if (reqPkt.checkPacketIsValid(13, 0) == false) {
        throw new SMBSrvException(SMBStatus.NTInvalidParameter, SMBStatus.SRVNonSpecificError, SMBStatus.ErrSrv);
    }
    int maxBufSize = reqPkt.getParameter(2);
    int maxMpx = reqPkt.getParameter(3);
    int vcNum = reqPkt.getParameter(4);
    int ascPwdLen = reqPkt.getParameter(7);
    int uniPwdLen = reqPkt.getParameter(8);
    int capabs = reqPkt.getParameterLong(11);
    byte[] buf = reqPkt.getBuffer();
    boolean isUni = reqPkt.isUnicode();
    byte[] ascPwd = reqPkt.unpackBytes(ascPwdLen);
    byte[] uniPwd = reqPkt.unpackBytes(uniPwdLen);
    String user = reqPkt.unpackString(isUni);
    if (user == null) {
        throw new SMBSrvException(SMBStatus.NTInvalidParameter, SMBStatus.SRVNonSpecificError, SMBStatus.ErrSrv);
    }
    String domain = "String_Node_Str";
    if (reqPkt.hasMoreData()) {
        domain = reqPkt.unpackString(isUni);
        if (domain == null) {
            throw new SMBSrvException(SMBStatus.NTInvalidParameter, SMBStatus.SRVNonSpecificError, SMBStatus.ErrSrv);
        }
    }
    String clientOS = "String_Node_Str";
    if (reqPkt.hasMoreData()) {
        clientOS = reqPkt.unpackString(isUni);
        if (clientOS == null) {
            throw new SMBSrvException(SMBStatus.NTInvalidParameter, SMBStatus.SRVNonSpecificError, SMBStatus.ErrSrv);
        }
    }
    if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE)) {
        logger.debug("String_Node_Str" + user + "String_Node_Str" + (uniPwd != null ? HexDump.hexString(uniPwd) : "String_Node_Str") + "String_Node_Str" + (ascPwd != null ? HexDump.hexString(ascPwd) : "String_Node_Str") + "String_Node_Str" + domain + "String_Node_Str" + clientOS + "String_Node_Str" + vcNum + "String_Node_Str" + maxBufSize + "String_Node_Str" + maxMpx + "String_Node_Str" + sess.getAuthenticationContext());
        logger.debug("String_Node_Str" + reqPkt.getMultiplexId() + "String_Node_Str" + reqPkt.getUserId() + "String_Node_Str" + reqPkt.getProcessId());
    }
    sess.setClientMaximumBufferSize(maxBufSize != 0 ? maxBufSize : SMBSrvSession.DefaultBufferSize);
    sess.setClientMaximumMultiplex(maxMpx);
    sess.setClientCapabilities(capabs);
    ClientInfo client = new ClientInfo(user, uniPwd);
    client.setANSIPassword(ascPwd);
    client.setDomain(domain);
    client.setOperatingSystem(clientOS);
    if (sess.hasRemoteAddress())
        client.setClientAddress(sess.getRemoteAddress().getHostAddress());
    if (user.length() == 0 && domain.length() == 0 && uniPwdLen == 0 && ascPwdLen == 1)
        client.setLogonType(ClientInfo.LogonNull);
    int sts = authenticateUser(client, sess, CifsAuthenticator.NTLM1);
    if (sts > 0 && (sts & CifsAuthenticator.AUTH_GUEST) != 0) {
        client.setGuest(true);
        if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE))
            logger.debug("String_Node_Str" + user + "String_Node_Str");
    } else if (sts != CifsAuthenticator.AUTH_ALLOW) {
        if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE))
            logger.debug("String_Node_Str" + user + "String_Node_Str");
        throw new SMBSrvException(SMBStatus.NTLogonFailure, SMBStatus.DOSAccessDenied, SMBStatus.ErrDos);
    } else if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE)) {
        if (client.isNullSession() == false)
            client.setAuthenticationToken(m_authComponent.getCurrentAuthentication());
        else
            client.setAuthenticationToken(null);
        logger.debug("String_Node_Str" + user + "String_Node_Str" + (client != null ? "String_Node_Str" + client.getLogonTypeString() + "String_Node_Str" : "String_Node_Str"));
    }
    VirtualCircuit vc = new VirtualCircuit(vcNum, client);
    int uid = sess.addVirtualCircuit(vc);
    if (uid == VirtualCircuit.InvalidUID) {
        if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE))
            logger.debug("String_Node_Str" + vc);
        throw new SMBSrvException(SMBStatus.NTLogonFailure, SMBStatus.DOSAccessDenied, SMBStatus.ErrDos);
    } else if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE)) {
        logger.debug("String_Node_Str" + uid + "String_Node_Str" + vc);
    }
    sess.setLoggedOn(true);
    respPkt.setParameterCount(3);
    respPkt.setParameter(0, 0);
    respPkt.setParameter(1, 0);
    respPkt.setParameter(2, client.isGuest() ? 1 : 0);
    respPkt.setByteCount(0);
    respPkt.setTreeId(0);
    respPkt.setUserId(uid);
    int flags = respPkt.getFlags();
    flags &= ~SMBSrvPacket.FLG_CASELESS;
    respPkt.setFlags(flags);
    int flags2 = SMBSrvPacket.FLG2_LONGFILENAMES;
    if (isUni)
        flags2 += SMBSrvPacket.FLG2_UNICODE;
    respPkt.setFlags2(flags2);
    int pos = respPkt.getByteOffset();
    buf = respPkt.getBuffer();
    if (isUni)
        pos = DataPacker.wordAlign(pos);
    pos = DataPacker.putString("String_Node_Str", buf, pos, true, isUni);
    pos = DataPacker.putString("String_Node_Str" + sess.getServer().isVersion(), buf, pos, true, isUni);
    pos = DataPacker.putString(sess.getServer().getConfiguration().getDomainName(), buf, pos, true, isUni);
    respPkt.setByteCount(pos - respPkt.getByteOffset());
}

Output:
         throw new SMBSrvException(SMBStatus.NTLogonFailure, SMBStatus.DOSAccessDenied, SMBStatus.ErrDos);
-    } else if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_NEGOTIATE)) {
+    } else {
         if (client.isNullSession() == false)


Input:
void build() {
    if (built)
        return;
    built = true;
    CClassInfo bean = (CClassInfo) this.bean;
    for (String reservedClassName : reservedClassNames) {
        if (bean.getName().equals(reservedClassName)) {
            getErrorReporter().error(sc.getLocator(), Messages.ERR_RESERVED_CLASS_NAME, reservedClassName);
            break;
        }
    }
    if (needValueConstructor(sc)) {
        bean.addConstructor("String_Node_Str");
    }
    if (sc instanceof XSElementDecl) {
        XSElementDecl e = (XSElementDecl) sc;
        bean.isRootElement = e.isGlobal();
    }
    if (bean.javadoc == null)
        addSchemaFragmentJavadoc(bean, sc);
    if (builder.getGlobalBinding().getFlattenClasses() == LocalScoping.NESTED)
        pushClassScope(bean);
    else
        pushClassScope(bean.parent());
    XSComponent oldRoot = currentRoot;
    CClassInfo oldBean = currentBean;
    currentRoot = sc;
    currentBean = bean;
    sc.visit(Ring.get(BindRed.class));
    currentBean = oldBean;
    currentRoot = oldRoot;
    popClassScope();
    BIProperty prop = builder.getBindInfo(sc).get(BIProperty.class);
    if (prop != null)
        prop.markAsAcknowledged();
}

Output:
 void build() {
-    if (built)
+    if (!(this.bean instanceof CClassInfo))
         return;


Input:
private void setParallelization(INode node) {
    if (node.getOutgoingConnections().size() > 0) {
        for (IConnection con : node.getOutgoingConnections()) {
            EConnectionType lineStyle = con.getLineStyle();
            if (lineStyle.hasConnectionCategory(IConnectionCategory.MAIN) || lineStyle.hasConnectionCategory(IConnectionCategory.MERGE)) {
                boolean isEndRow = con.getTarget().getOutgoingConnections().size() == 0;
                boolean isStartRow = node.isStart();
                if (ParallelExecutionUtils.isPartitionKeysExist(con)) {
                    ParallelExecutionUtils.reSetParKeyValuesForCon(con);
                }
                if (!isEndRow && isComponentCanParlization(con, (Node) con.getTarget())) {
                    if (!isStartRow && isComponentNeedRepartion(con, (Node) con.getTarget())) {
                        con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
                        con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
                        con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
                        con.setPropertyValue(EParameterName.REPARTITIONER.getName(), Boolean.TRUE);
                        ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) con.getTarget());
                        setParallelization(con.getTarget());
                    } else {
                        if (ParallelExecutionUtils.existPreviousPar((Node) con.getSource()) || ParallelExecutionUtils.existPreviousNone((Node) con.getSource()) || ParallelExecutionUtils.existPreviousRepar((Node) con.getSource())) {
                            con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
                            con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
                            con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
                            con.setPropertyValue(EParameterName.NONE.getName(), Boolean.TRUE);
                            setParallelization(con.getTarget());
                        } else {
                            INode firstPartionerNode = null;
                            IElementParameter deparElem = con.getElementParameter(EParameterName.DEPARTITIONER.getName());
                            deparElem.setValue(Boolean.FALSE);
                            con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
                            con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
                            con.setPropertyValue(EParameterName.PARTITIONER.getName(), Boolean.TRUE);
                            if (isStartRow) {
                                firstPartionerNode = ParallelExecutionUtils.getFirstPartionerTargetNode(con);
                            }
                            if (firstPartionerNode != null) {
                                ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) firstPartionerNode);
                            } else {
                                ParallelExecutionUtils.setHashKeysForCon(con);
                            }
                            if (con.getTarget() != null) {
                                setParallelization(con.getTarget());
                            }
                        }
                    }
                } else {
                    if (!con.getSource().isStart()) {
                        if (!ParallelExecutionUtils.existPreviousDepar((Node) con.getSource())) {
                            setDeparallelization(con.getTarget());
                        }
                    }
                }
            } else {
                node = con.getTarget();
                setParallelization(node);
            }
        }
    } else {
        if (!node.isStart()) {
            setDeparallelization(node);
        }
    }
}

Output:
 private void setParallelization(INode node) {
-    if (node.getOutgoingConnections().size() > 0) {
-        for (IConnection con : node.getOutgoingConnections()) {
-            EConnectionType lineStyle = con.getLineStyle();
-            if (lineStyle.hasConnectionCategory(IConnectionCategory.MAIN) || lineStyle.hasConnectionCategory(IConnectionCategory.MERGE)) {
-                boolean isEndRow = con.getTarget().getOutgoingConnections().size() == 0;
-                boolean isStartRow = node.isStart();
-                if (ParallelExecutionUtils.isPartitionKeysExist(con)) {
-                    ParallelExecutionUtils.reSetParKeyValuesForCon(con);
-                }
-                if (!isEndRow && isComponentCanParlization(con, (Node) con.getTarget())) {
-                    if (!isStartRow && isComponentNeedRepartion(con, (Node) con.getTarget())) {
-                        con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
-                        con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
-                        con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
-                        con.setPropertyValue(EParameterName.REPARTITIONER.getName(), Boolean.TRUE);
-                        ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) con.getTarget());
-                        setParallelization(con.getTarget());
-                    } else {
-                        if (ParallelExecutionUtils.existPreviousPar((Node) con.getSource()) || ParallelExecutionUtils.existPreviousNone((Node) con.getSource()) || ParallelExecutionUtils.existPreviousRepar((Node) con.getSource())) {
-                            con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
-                            con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
-                            con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
-                            con.setPropertyValue(EParameterName.NONE.getName(), Boolean.TRUE);
-                            setParallelization(con.getTarget());
-                        } else {
-                            INode firstPartionerNode = null;
-                            IElementParameter deparElem = con.getElementParameter(EParameterName.DEPARTITIONER.getName());
-                            deparElem.setValue(Boolean.FALSE);
-                            con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
-                            con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
-                            con.setPropertyValue(EParameterName.PARTITIONER.getName(), Boolean.TRUE);
-                            if (isStartRow) {
-                                firstPartionerNode = ParallelExecutionUtils.getFirstPartionerTargetNode(con);
-                            }
-                            if (firstPartionerNode != null) {
-                                ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) firstPartionerNode);
+    if (node.isActivate()) {
+        if (node.getOutgoingConnections().size() > 0) {
+            for (IConnection con : node.getOutgoingConnections()) {
+                EConnectionType lineStyle = con.getLineStyle();
+                if (lineStyle.hasConnectionCategory(IConnectionCategory.MAIN) || lineStyle.hasConnectionCategory(IConnectionCategory.MERGE)) {
+                    if (con.isActivate()) {
+                        boolean isEndRow = con.getTarget().getOutgoingConnections().size() == 0;
+                        boolean isStartRow = node.isStart();
+                        if (ParallelExecutionUtils.isPartitionKeysExist(con)) {
+                            ParallelExecutionUtils.reSetParKeyValuesForCon(con);
+                        }
+                        if (!isEndRow && isComponentCanParlization(con, (Node) con.getTarget())) {
+                            if (!isStartRow && isComponentNeedRepartion(con, (Node) con.getTarget())) {
+                                con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
+                                con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
+                                con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
+                                con.setPropertyValue(EParameterName.REPARTITIONER.getName(), Boolean.TRUE);
+                                ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) con.getTarget());
+                                setParallelization(con.getTarget());
                             } else {


Input:
private int getAction(CompositeStatementObject parentComposite, int i, CompositeStatementObject childComposite) {
    int action = PUSH_NEW_LIST;
    List<AbstractStatement> statements = new ArrayList<AbstractStatement>(parentComposite.getStatements());
    CompositeStatementObject parent = (CompositeStatementObject) statements.get(0).getParent();
    boolean isBlockWithoutCompositeParent = isBlockWithoutCompositeParent(parent);
    if (parent.getStatement() instanceof Block)
        parent = (CompositeStatementObject) parent.getParent();
    int position = i;
    while (parent != null && parent instanceof TryStatementObject) {
        CompositeStatementObject tryStatement = parent;
        CompositeStatementObject tryStatementParent = (CompositeStatementObject) tryStatement.getParent();
        List<AbstractStatement> tryParentStatements = new ArrayList<AbstractStatement>(tryStatementParent.getStatements());
        if (tryStatementParent.getStatement() instanceof Block)
            tryStatementParent = (CompositeStatementObject) tryStatementParent.getParent();
        int positionOfTryStatementInParent = 0;
        int j = 0;
        for (AbstractStatement statement : tryParentStatements) {
            if (statement.equals(tryStatement)) {
                positionOfTryStatementInParent = j;
                break;
            }
            j++;
        }
        if (((TryStatementObject) tryStatement).hasResources()) {
            tryParentStatements.addAll(positionOfTryStatementInParent + 1, statements);
        } else {
            tryParentStatements.remove(tryStatement);
            tryParentStatements.addAll(positionOfTryStatementInParent, statements);
        }
        statements = tryParentStatements;
        parent = tryStatementParent;
        if (((TryStatementObject) tryStatement).hasResources())
            position = positionOfTryStatementInParent + position + 1;
        else
            position = positionOfTryStatementInParent + position;
    }
    if (parent != null && parent.getStatement() instanceof SwitchStatement && parentComposite.getStatement() instanceof Block) {
        List<AbstractStatement> switchStatements = new ArrayList<AbstractStatement>(parent.getStatements());
        int positionOfBlockInParentSwitch = 0;
        int j = 0;
        for (AbstractStatement statement : switchStatements) {
            if (statement.equals(parentComposite)) {
                positionOfBlockInParentSwitch = j;
                break;
            }
            j++;
        }
        switchStatements.remove(parentComposite);
        switchStatements.addAll(positionOfBlockInParentSwitch, statements);
        statements = switchStatements;
        position = positionOfBlockInParentSwitch + position;
    }
    if (parent != null && isBlockWithoutCompositeParent) {
        List<AbstractStatement> blockStatements = new ArrayList<AbstractStatement>(parent.getStatements());
        int positionOfBlockInParent = 0;
        int j = 0;
        for (AbstractStatement statement : blockStatements) {
            if (statement.equals(parentComposite)) {
                positionOfBlockInParent = j;
                break;
            }
            j++;
        }
        blockStatements.remove(parentComposite);
        blockStatements.addAll(positionOfBlockInParent, statements);
        statements = blockStatements;
        position = positionOfBlockInParent + position;
    }
    if (statements.size() == 1) {
        action = JOIN_TOP_LIST;
        if (parent != null) {
            if (isLoop(parent))
                action = PUSH_NEW_LIST;
            else if (parent.getStatement() instanceof DoStatement)
                action = PLACE_NEW_LIST_SECOND_FROM_TOP;
        }
    } else if (statements.size() > 1) {
        AbstractStatement previousStatement = null;
        if (position >= 1)
            previousStatement = statements.get(position - 1);
        int j = 0;
        while (previousStatement != null && previousStatement instanceof TryStatementObject && !((TryStatementObject) previousStatement).hasResources()) {
            CompositeStatementObject tryStatement = (CompositeStatementObject) previousStatement;
            AbstractStatement firstStatement = tryStatement.getStatements().get(0);
            if (firstStatement instanceof CompositeStatementObject) {
                CompositeStatementObject tryBlock = (CompositeStatementObject) firstStatement;
                List<AbstractStatement> tryBlockStatements = tryBlock.getStatements();
                if (tryBlockStatements.size() > 0) {
                    previousStatement = tryBlockStatements.get(tryBlockStatements.size() - 1);
                } else {
                    if (position >= 2 + j)
                        previousStatement = statements.get(position - 2 - j);
                    else
                        previousStatement = null;
                }
            }
            j++;
        }
        while (previousStatement != null && isBlockWithoutCompositeParent(previousStatement)) {
            CompositeStatementObject block = (CompositeStatementObject) previousStatement;
            List<AbstractStatement> blockStatements = block.getStatements();
            if (blockStatements.size() > 0) {
                previousStatement = blockStatements.get(blockStatements.size() - 1);
            }
        }
        if (statements.get(statements.size() - 1).equals(childComposite)) {
            if (previousStatement != null && previousStatement.getStatement() instanceof IfStatement) {
                action = JOIN_SECOND_FROM_TOP_LIST;
                if (parent != null && (isLoop(parent) || parent.getStatement() instanceof DoStatement))
                    action = PLACE_NEW_LIST_SECOND_FROM_TOP;
            } else {
                action = JOIN_TOP_LIST;
                if (parent != null && (isLoop(parent) || parent.getStatement() instanceof DoStatement))
                    action = PUSH_NEW_LIST;
            }
        } else {
            if (previousStatement != null && previousStatement.getStatement() instanceof IfStatement)
                action = PLACE_NEW_LIST_SECOND_FROM_TOP;
            else {
                action = PUSH_NEW_LIST;
            }
        }
    }
    return action;
}

Output:
         if (parent != null) {
-            if (isLoop(parent))
+            if (isLoop(parent) || parent.getStatement() instanceof DoStatement)
                 action = PUSH_NEW_LIST;


Input:
private void addListener() {
    nameField.textProperty().addListener(c -> {
        String newName = nameField.getText().trim();
        if (nameField.getText().length() > BOARD_MAX_NAME_LENGTH) {
            nameField.setText(previousText);
            errorText.setText(ERROR_LONG_NAME);
            submitButton.setDisable(false);
        } else if (isBoardNameInvalid(newName)) {
            errorText.setText(ERROR_INVALID_NAME);
            submitButton.setDisable(true);
        } else if (isBoardNameEmpty(newName)) {
            errorText.setText(ERROR_EMPTY_NAME);
            submitButton.setDisable(true);
        } else if (isBoardNameDuplicate(newName)) {
            errorText.setText(WARNING_DUPLICATE_NAME);
            submitButton.setDisable(false);
        } else {
            errorText.setText("String_Node_Str");
            submitButton.setDisable(false);
        }
        previousText = nameField.getText();
    });
}

Output:
             nameField.setText(previousText);
-            errorText.setText(ERROR_LONG_NAME);
+            errorText.setText(String.format(ERROR_LONG_NAME, BOARD_MAX_NAME_LENGTH));
             submitButton.setDisable(false);


Input:
private void initCommandBindings(Component comp, String propName) {
    final ComponentCtrl compCtrl = (ComponentCtrl) comp;
    final Annotation ann = compCtrl.getAnnotation(propName, BIND_ANNO);
    if (ann != null) {
        final Map<?, ?> attrs = ann.getAttributes();
        Map<String, Object> args = null;
        final List<String> cmdExprs = new ArrayList<String>();
        for (final Iterator<?> it = attrs.entrySet().iterator(); it.hasNext(); ) {
            final Map.Entry entry = (Map.Entry) it.next();
            final String tag = (String) entry.getKey();
            final Object tagExpr = entry.getValue();
            if ("String_Node_Str".equals(tag)) {
                if (tagExpr instanceof String[]) {
                    throw new UiException("String_Node_Str");
                }
                cmdExprs.add((String) tagExpr);
            } else {
                if (args == null) {
                    args = new HashMap<String, Object>();
                }
                args.put(tag, tagExpr);
            }
        }
        args = args == null ? null : parsedArgs(args);
        for (String cmd : cmdExprs) {
            _binder.addCommandBinding(comp, propName, cmd, args);
        }
    }
}

Output:
     if (ann != null) {
-        final Map<?, ?> attrs = ann.getAttributes();
+        final Map<String, Object> attrs = ann.getAttributes();
         Map<String, Object> args = null;


Input:
public AmbariRoleAllocationComplete allocateRoles(Long stackId) {
    AmbariRoleAllocationComplete allocationComplete = null;
    Stack stack = stackRepository.findById(stackId);
    MDCBuilder.buildMdcContext(stack);
    Set<InstanceMetaData> allInstanceMetaData = stack.getAllInstanceMetaData();
    PollingResult pollingResult = waitForConsulAgents(stack, allInstanceMetaData, Collections.<InstanceMetaData>emptySet());
    if (isSuccess(pollingResult)) {
        updateWithConsulData(allInstanceMetaData);
        instanceMetaDataRepository.save(allInstanceMetaData);
        allocationComplete = new AmbariRoleAllocationComplete(stack, stack.getAmbariIp());
    }
    return allocationComplete;
}

Output:
     PollingResult pollingResult = waitForConsulAgents(stack, allInstanceMetaData, Collections.<InstanceMetaData>emptySet());
-    if (isSuccess(pollingResult)) {
-        updateWithConsulData(allInstanceMetaData);
-        instanceMetaDataRepository.save(allInstanceMetaData);
-        allocationComplete = new AmbariRoleAllocationComplete(stack, stack.getAmbariIp());
+    if (!isSuccess(pollingResult)) {
+        throw new WrongMetadataException("String_Node_Str");
     }


Input:
public static final void setSaveDirectory(File saveDir) throws IOException {
    if (saveDir == null)
        throw new NullPointerException();
    if (!saveDir.isDirectory()) {
        if (!saveDir.mkdirs())
            throw new IOException();
    }
    String parentDir = saveDir.getParent();
    File incDir = new File(parentDir, "String_Node_Str");
    if (!incDir.isDirectory()) {
        if (!incDir.mkdirs())
            throw new IOException();
    }
    if (!saveDir.canRead() || !saveDir.canWrite() || !incDir.canRead() || !incDir.canWrite()) {
        throw new IOException();
    }
    try {
        saveDir = FileUtils.getCanonicalFile(saveDir);
    } catch (IOException ignored) {
    }
    try {
        incDir = FileUtils.getCanonicalFile(incDir);
    } catch (IOException ignored) {
    }
    File snapFile = new File(incDir, "String_Node_Str");
    try {
        snapFile = FileUtils.getCanonicalFile(snapFile);
    } catch (IOException ignored) {
    }
    File snapBackup = new File(incDir, "String_Node_Str");
    try {
        snapBackup = FileUtils.getCanonicalFile(snapBackup);
    } catch (IOException ignored) {
    }
    DIRECTORY_FOR_SAVING_FILES.setValue(saveDir);
    INCOMPLETE_DIRECTORY.setValue(incDir);
    DOWNLOAD_SNAPSHOT_FILE.setValue(snapFile);
    DOWNLOAD_SNAPSHOT_BACKUP_FILE.setValue(snapBackup);
}

Output:
         if (!saveDir.mkdirs())
-            throw new IOException();
+            throw new IOException("String_Node_Str");
     }


Input:
public void testEmbedded() {
    AdvancedDatastore ads = ((AdvancedDatastore) ds);
    ads.save("String_Node_Str", new B(new BB("String_Node_Str")));
    assertEquals(1, db.getCollection("String_Node_Str").getIndexInfo().size());
    ads.ensureIndexes("String_Node_Str", B.class);
    assertEquals(2, db.getCollection("String_Node_Str").getIndexInfo().size());
}

Output:
 public void testEmbedded() {
-    AdvancedDatastore ads = ((AdvancedDatastore) ds);
+    AdvancedDatastore ads = getAds();
+    DB db = getDb();
     ads.save("String_Node_Str", new B(new BB("String_Node_Str")));


Input:
private void handleBindingReinstall(OperationContext context, String bindingName, ModelNode bindingModel) throws OperationFailedException {
    context.removeService(SOCKET_BINDING.append(bindingName));
    try {
        BindingAddHandler.installBindingService(context, bindingModel, bindingName);
    } catch (UnknownHostException e) {
        throw new OperationFailedException(new ModelNode().set(e.toString()));
    }
}

Output:
     try {
-        BindingAddHandler.installBindingService(context, bindingModel, bindingName);
+        BindingAddHandler.installBindingService(context, bindingModel, bindingName, null);
     } catch (UnknownHostException e) {


Input:
public Record newRecord() {
    return null;
}

Output:
 public Record newRecord() {
-    return null;
+    return new TableRecord();
 }


Input:
public void uncaughtException(Thread t, Throwable e) {
    Log.error("String_Node_Str", e);
}

Output:
 public void uncaughtException(Thread t, Throwable e) {
-    Log.error("String_Node_Str", e);
+    if (!(e instanceof ThreadDeath))
+        Log.error("String_Node_Str", e);
 }


Input:
private void updateButtons() {
    boolean complete = uriEditor.getText() != null && uriEditor.getText().trim().length() > 0;
    URL url = null;
    try {
        url = new URL(uriEditor.getText().trim());
        if (selectedType == EMBEDDED_TYPE) {
            File file = new File(url.getPath());
            complete = file.exists() && file.isAbsolute();
        }
    } catch (Exception e) {
        complete = false;
    }
    previewButton.setEnabled(complete);
    getButton(IDialogConstants.OK_ID).setEnabled(complete);
    browseButton.setVisible(embedded.getSelection());
}

Output:
     try {
-        url = new URL(uriEditor.getText().trim());
+        url = new URL(removeQuote(uriEditor.getText().trim()));
         if (selectedType == EMBEDDED_TYPE) {


Input:
protected QName getSingleValueToWriteForUnion(XMLUnionField xmlField, Object value, AbstractSession session) {
    ArrayList schemaTypes = xmlField.getSchemaTypes();
    QName schemaType = null;
    QName nextQName;
    Class javaClass;
    for (int i = 0; i < schemaTypes.size(); i++) {
        nextQName = (QName) (xmlField).getSchemaTypes().get(i);
        try {
            if (nextQName != null) {
                javaClass = xmlField.getJavaClass(nextQName);
                value = ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, javaClass, nextQName);
                schemaType = nextQName;
                break;
            }
        } catch (ConversionException ce) {
            if (i == (schemaTypes.size() - 1)) {
                schemaType = nextQName;
            }
        }
    }
    return schemaType;
}

Output:
     QName schemaType = null;
-    QName nextQName;
-    Class javaClass;
-    for (int i = 0; i < schemaTypes.size(); i++) {
-        nextQName = (QName) (xmlField).getSchemaTypes().get(i);
+    for (int i = 0, schemaTypesSize = schemaTypes.size(); i < schemaTypesSize; i++) {
+        QName nextQName = (QName) (xmlField).getSchemaTypes().get(i);
         try {


Input:
public Matrix getCovariance() {
    return this.distribution.getCovariance();
}

Output:
 public Matrix getCovariance() {
-    return this.distribution.getCovariance();
+    return this.motionDistribution.getCovariance();
 }


Input:
public String getIconFileName() {
    if (publisher.isPublishHtmlReport()) {
        FilePath r = getWorkspaceReportDir();
        if (exists(r, "String_Node_Str")) {
            return ICON;
        }
    }
    File reportDir = getLastBuildReportDir();
    if (exists(new FilePath(reportDir), "String_Node_Str")) {
        return ICON;
    }
    return null;
}

Output:
     File reportDir = getLastBuildReportDir();
-    if (exists(new FilePath(reportDir), "String_Node_Str")) {
+    if (reportDir != null && exists(new FilePath(reportDir), "String_Node_Str")) {
         return ICON;


Input:
private void createMatchAlternative(List<OptimizerNode> target, OptimizerNode subPlan1, OptimizerNode subPlan2, ShipStrategy ss1, ShipStrategy ss2, LocalStrategy ls, Order order, boolean grouped, LocalProperties outLpp, CostEstimator estimator) {
    if (ls != LocalStrategy.SELF_NESTEDLOOP && ls != LocalStrategy.SORT_SELF_NESTEDLOOP) {
        GlobalProperties gp1 = PactConnection.getGlobalPropertiesAfterConnection(subPlan1, this, ss1);
        GlobalProperties gp2 = PactConnection.getGlobalPropertiesAfterConnection(subPlan2, this, ss2);
        int[] scrambledKeyOrder1 = null;
        int[] scrambledKeyOrder2 = null;
        if (ss1 == ShipStrategy.FORWARD && ss2 == ShipStrategy.PARTITION_HASH) {
            scrambledKeyOrder1 = getScrambledKeyOrder(this.keySet1, gp1.getPartitionedFields());
            if (scrambledKeyOrder1 != null) {
                FieldList scrambledKeys2 = new FieldList();
                for (int i = 0; i < scrambledKeyOrder1.length; i++) {
                    scrambledKeys2.add(this.keySet2.get(scrambledKeyOrder1[i]));
                }
                gp2.setPartitioning(gp2.getPartitioning(), scrambledKeys2);
            }
        }
        if (ss2 == ShipStrategy.FORWARD && ss1 == ShipStrategy.PARTITION_HASH) {
            scrambledKeyOrder2 = getScrambledKeyOrder(this.keySet2, gp2.getPartitionedFields());
            if (scrambledKeyOrder2 != null) {
                FieldList scrambledKeys1 = new FieldList();
                for (int i = 0; i < scrambledKeyOrder2.length; i++) {
                    scrambledKeys1.add(this.keySet1.get(scrambledKeyOrder2[i]));
                }
                gp1.setPartitioning(gp1.getPartitioning(), scrambledKeys1);
            }
        }
        LocalProperties outLp = outLpp;
        GlobalProperties outGp = new GlobalProperties();
        outGp.setPartitioning(gp1.getPartitioning(), gp1.getPartitionedFields());
        outGp.setOrdering(gp1.getOrdering());
        if (outLpp == null) {
            outLp = new LocalProperties();
            if (order != Order.NONE) {
                Ordering ordering = new Ordering();
                for (int keyColumn : this.keySet1) {
                    ordering.appendOrdering(keyColumn, null, order);
                }
                outLp.setOrdering(ordering);
            } else {
                outLp.setOrdering(null);
            }
            outLp.setGrouped(grouped, new FieldSet(this.keySet1));
        }
        MatchNode n = new MatchNode(this, subPlan1, subPlan2, this.input1, this.input2, outGp, outLp);
        n.input1.setShipStrategy(ss1);
        n.input1.setScramblePartitionedFields(scrambledKeyOrder2);
        n.input2.setShipStrategy(ss2);
        n.input2.setScramblePartitionedFields(scrambledKeyOrder1);
        n.setLocalStrategy(ls);
        n.getGlobalProperties().filterByNodesConstantSet(this, 0);
        n.getLocalProperties().filterByNodesConstantSet(this, 0);
        estimator.costOperator(n);
        target.add(n);
        outGp = new GlobalProperties();
        outGp.setPartitioning(gp2.getPartitioning(), gp2.getPartitionedFields());
        outGp.setOrdering(gp2.getOrdering());
        if (outLpp == null) {
            outLp = new LocalProperties();
            if (order != Order.NONE) {
                Ordering ordering = new Ordering();
                for (int keyColumn : this.keySet2) {
                    ordering.appendOrdering(keyColumn, null, order);
                }
                outLp.setOrdering(ordering);
            } else {
                outLp.setOrdering(null);
            }
            outLp.setGrouped(grouped, new FieldSet(this.keySet2));
        }
        n = new MatchNode(this, subPlan1, subPlan2, input1, input2, outGp, outLp);
        n.input1.setShipStrategy(ss1);
        n.input1.setScramblePartitionedFields(scrambledKeyOrder2);
        n.input2.setShipStrategy(ss2);
        n.input2.setScramblePartitionedFields(scrambledKeyOrder1);
        n.setLocalStrategy(ls);
        n.getGlobalProperties().filterByNodesConstantSet(this, 1);
        n.getLocalProperties().filterByNodesConstantSet(this, 1);
        estimator.costOperator(n);
        target.add(n);
    } else {
        GlobalProperties gp1 = PactConnection.getGlobalPropertiesAfterConnection(subPlan1, this, ss1);
        GlobalProperties outGp = new GlobalProperties();
        outGp.setPartitioning(gp1.getPartitioning(), gp1.getPartitionedFields());
        outGp.setOrdering(gp1.getOrdering());
        LocalProperties outLp = null;
        if (outLpp == null) {
            outLp = new LocalProperties();
            if (order != Order.NONE) {
                Ordering ordering = new Ordering();
                for (int keyColumn : this.keySet1) {
                    ordering.appendOrdering(keyColumn, null, order);
                }
                outLp.setOrdering(ordering);
            } else {
                outLp.setOrdering(null);
            }
            outLp.setGrouped(grouped, new FieldSet(this.keySet1));
        }
        MatchNode n = new MatchNode(this, subPlan1, null, this.input1, null, outGp, outLp);
        n.input1.setShipStrategy(ss1);
        n.setLocalStrategy(ls);
        n.getGlobalProperties().filterByNodesConstantSet(this, 0);
        n.getLocalProperties().filterByNodesConstantSet(this, 0);
        estimator.costOperator(n);
        target.add(n);
    }
}

Output:
     if (ls != LocalStrategy.SELF_NESTEDLOOP && ls != LocalStrategy.SORT_SELF_NESTEDLOOP) {
-        GlobalProperties gp1 = PactConnection.getGlobalPropertiesAfterConnection(subPlan1, this, ss1);
-        GlobalProperties gp2 = PactConnection.getGlobalPropertiesAfterConnection(subPlan2, this, ss2);
+        GlobalProperties gp1 = PactConnection.getGlobalPropertiesAfterConnection(subPlan1, this, 0, ss1);
+        GlobalProperties gp2 = PactConnection.getGlobalPropertiesAfterConnection(subPlan2, this, 1, ss2);
         int[] scrambledKeyOrder1 = null;


Input:
private void renderCoordinateSystem(GL gl, final int iNumberAxis) {
    textRenderer.setColor(0, 0, 0, 1);
    gl.glColor4fv(ParCoordsRenderStyle.X_AXIS_COLOR, 0);
    gl.glLineWidth(ParCoordsRenderStyle.X_AXIS_LINE_WIDTH);
    gl.glPushName(pickingManager.getPickingID(iUniqueId, EPickingType.X_AXIS_SELECTION, 1));
    gl.glBegin(GL.GL_LINES);
    gl.glVertex3f(-0.1f, 0.0f, 0.0f);
    gl.glVertex3f(((iNumberAxis - 1) * fAxisSpacing) + 0.1f, 0.0f, 0.0f);
    gl.glEnd();
    gl.glPopName();
    Set<Integer> selectedSet = verticalSelectionManager.getElements(EViewInternalSelectionType.SELECTION);
    Set<Integer> mouseOverSet = verticalSelectionManager.getElements(EViewInternalSelectionType.MOUSE_OVER);
    ArrayList<Integer> alAxisSelection;
    if (bRenderStorageHorizontally)
        alAxisSelection = alContentSelection;
    else
        alAxisSelection = alStorageSelection;
    int iCount = 0;
    while (iCount < iNumberAxis) {
        if (selectedSet.contains(alAxisSelection.get(iCount))) {
            gl.glColor4fv(ParCoordsRenderStyle.Y_AXIS_SELECTED_COLOR, 0);
            gl.glLineWidth(ParCoordsRenderStyle.Y_AXIS_SELECTED_LINE_WIDTH);
        } else if (mouseOverSet.contains(alAxisSelection.get(iCount))) {
            gl.glColor4fv(ParCoordsRenderStyle.Y_AXIS_MOUSE_OVER_COLOR, 0);
            gl.glLineWidth(ParCoordsRenderStyle.Y_AXIS_MOUSE_OVER_LINE_WIDTH);
        } else {
            gl.glColor4fv(ParCoordsRenderStyle.Y_AXIS_COLOR, 0);
            gl.glLineWidth(ParCoordsRenderStyle.Y_AXIS_LINE_WIDTH);
        }
        gl.glPushName(pickingManager.getPickingID(iUniqueId, EPickingType.Y_AXIS_SELECTION, alAxisSelection.get(iCount)));
        gl.glBegin(GL.GL_LINES);
        gl.glVertex3f(iCount * fAxisSpacing, ParCoordsRenderStyle.Y_AXIS_LOW, ParCoordsRenderStyle.AXIS_Z);
        gl.glVertex3f(iCount * fAxisSpacing, renderStyle.getAxisHeight(), ParCoordsRenderStyle.AXIS_Z);
        gl.glVertex3f(iCount * fAxisSpacing - ParCoordsRenderStyle.AXIS_MARKER_WIDTH, renderStyle.getAxisHeight(), ParCoordsRenderStyle.AXIS_Z);
        gl.glVertex3f(iCount * fAxisSpacing + ParCoordsRenderStyle.AXIS_MARKER_WIDTH, renderStyle.getAxisHeight(), ParCoordsRenderStyle.AXIS_Z);
        gl.glEnd();
        String sAxisLabel = null;
        switch(eAxisDataType) {
            case EXPERIMENT:
                sAxisLabel = "String_Node_Str" + iCount;
                break;
            case GENE:
                sAxisLabel = getRefSeqFromStorageIndex(alContentSelection.get(iCount));
                break;
            default:
                sAxisLabel = "String_Node_Str";
        }
        gl.glPushAttrib(GL.GL_CURRENT_BIT | GL.GL_LINE_BIT);
        gl.glTranslatef(iCount * fAxisSpacing, renderStyle.getAxisHeight() + renderStyle.getAxisCaptionSpacing(), 0);
        gl.glRotatef(25, 0, 0, 1);
        textRenderer.begin3DRendering();
        textRenderer.draw3D(sAxisLabel, 0, 0, 0, renderStyle.getSmallFontScalingFactor());
        textRenderer.end3DRendering();
        gl.glRotatef(-25, 0, 0, 1);
        gl.glTranslatef(-iCount * fAxisSpacing, -(renderStyle.getAxisHeight() + renderStyle.getAxisCaptionSpacing()), 0);
        textRenderer.begin3DRendering();
        textRenderer.draw3D(String.valueOf(1), iCount * fAxisSpacing + 2 * ParCoordsRenderStyle.AXIS_MARKER_WIDTH, renderStyle.getAxisHeight(), 0, renderStyle.getSmallFontScalingFactor());
        textRenderer.end3DRendering();
        gl.glPopAttrib();
        gl.glPopName();
        int iNumberOfButtons = 0;
        if (iCount != 0 || iCount != iNumberAxis - 1)
            iNumberOfButtons = 4;
        else
            iNumberOfButtons = 3;
        float fXButtonOrigin = 0;
        float fYButtonOrigin = 0;
        int iPickingID = -1;
        fXButtonOrigin = iCount * fAxisSpacing - (iNumberOfButtons * renderStyle.getButtonWidht() + (iNumberOfButtons - 1) * renderStyle.getButtonSpacing()) / 2;
        fYButtonOrigin = -renderStyle.getAxisButtonYOffset();
        if (iCount != 0) {
            iPickingID = pickingManager.getPickingID(iUniqueId, EPickingType.MOVE_AXIS_LEFT, iCount);
            renderButton(gl, fXButtonOrigin, fYButtonOrigin, iPickingID, EIconTextures.ARROW_LEFT);
        }
        fXButtonOrigin = fXButtonOrigin + renderStyle.getButtonWidht() + renderStyle.getButtonSpacing();
        iPickingID = pickingManager.getPickingID(iUniqueId, EPickingType.REMOVE_AXIS, iCount);
        renderButton(gl, fXButtonOrigin, fYButtonOrigin, iPickingID, EIconTextures.REMOVE);
        fXButtonOrigin = fXButtonOrigin + renderStyle.getButtonWidht() + renderStyle.getButtonSpacing();
        iPickingID = pickingManager.getPickingID(iUniqueId, EPickingType.DUPLICATE_AXIS, iCount);
        renderButton(gl, fXButtonOrigin, fYButtonOrigin, iPickingID, EIconTextures.DUPLICATE);
        if (iCount != iNumberAxis - 1) {
            fXButtonOrigin = fXButtonOrigin + renderStyle.getButtonWidht() + renderStyle.getButtonSpacing();
            iPickingID = pickingManager.getPickingID(iUniqueId, EPickingType.MOVE_AXIS_RIGHT, iCount);
            renderButton(gl, fXButtonOrigin, fYButtonOrigin, iPickingID, EIconTextures.ARROW_RIGHT);
        }
        iCount++;
    }
}

Output:
             case EXPERIMENT:
-                sAxisLabel = "String_Node_Str" + iCount;
+                sAxisLabel = "String_Node_Str" + alAxisSelection.get(iCount);
                 break;


Input:
protected boolean filterRepositoryNode(RepositoryNode node) {
    if (node == null) {
        return false;
    }
    if (node.isBin()) {
        return false;
    }
    if (node.getObject() != null) {
        ERepositoryStatus status = FACTORY.getStatus(node.getObject());
        if (status == ERepositoryStatus.LOCK_BY_OTHER || (status == ERepositoryStatus.LOCK_BY_USER && RepositoryManager.isOpenedItemInEditor(node.getObject()))) {
            return false;
        }
    }
    ERepositoryObjectType type = node.getObjectType();
    if (type == null) {
        if (node.getProperties(EProperties.LABEL) instanceof ERepositoryObjectType) {
            type = (ERepositoryObjectType) node.getProperties(EProperties.LABEL);
        }
        if (type == null) {
            return false;
        }
    }
    if (type == ERepositoryObjectType.PROCESS || type == ERepositoryObjectType.PROCESS_MR || type == ERepositoryObjectType.PROCESS_ROUTE || type == ERepositoryObjectType.PROCESS_SPARK || type == ERepositoryObjectType.PROCESS_SPARKSTREAMING || type == ERepositoryObjectType.PROCESS_STORM) {
        return true;
    }
    return false;
}

Output:
     }
-    if (type == ERepositoryObjectType.PROCESS || type == ERepositoryObjectType.PROCESS_MR || type == ERepositoryObjectType.PROCESS_ROUTE || type == ERepositoryObjectType.PROCESS_SPARK || type == ERepositoryObjectType.PROCESS_SPARKSTREAMING || type == ERepositoryObjectType.PROCESS_STORM) {
+    if (type == ERepositoryObjectType.FOLDER) {
+        if (node.getObject() instanceof Folder) {
+            type = ((Folder) node.getObject()).getContentType();
+        }
+    }
+    if (type == ERepositoryObjectType.PROCESS || type == ERepositoryObjectType.PROCESS_MR || type == ERepositoryObjectType.valueOf(NODENAME_ROUTE_DESIGNS) || type == ERepositoryObjectType.PROCESS_ROUTE || type == ERepositoryObjectType.PROCESS_SPARK || type == ERepositoryObjectType.PROCESS_SPARKSTREAMING || type == ERepositoryObjectType.PROCESS_STORM) {
         return true;