Input:
private Chart getConvertedChart(Chart currentChart, String sNewSubType, Orientation newOrientation, String sNewDimension) {
    Chart helperModel = (Chart) EcoreUtil.copy(currentChart);
    ChartDimension oldDimension = currentChart.getDimension();
    ChartCacheManager.getInstance().cacheSeries(ChartUIUtil.getAllOrthogonalSeriesDefinitions(helperModel));
    if ((currentChart instanceof ChartWithAxes)) {
        if (currentChart.getType().equals(TYPE_LITERAL)) {
            if (!currentChart.getSubType().equals(sNewSubType)) {
                currentChart.setSubType(sNewSubType);
                EList axes = ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes();
                for (int i = 0; i < axes.size(); i++) {
                    if (sNewSubType.equalsIgnoreCase(PERCENTSTACKED_SUBTYPE_LITERAL)) {
                        if (!ChartPreviewPainter.isLivePreviewActive() && !isNumbericAxis((Axis) axes.get(i))) {
                            ((Axis) axes.get(i)).setType(AxisType.LINEAR_LITERAL);
                        }
                        ((Axis) axes.get(i)).setPercent(true);
                    } else {
                        ((Axis) axes.get(i)).setPercent(false);
                    }
                    EList seriesdefinitions = ((Axis) axes.get(i)).getSeriesDefinitions();
                    for (int j = 0; j < seriesdefinitions.size(); j++) {
                        Series series = ((SeriesDefinition) seriesdefinitions.get(j)).getDesignTimeSeries();
                        if ((sNewSubType.equalsIgnoreCase(STACKED_SUBTYPE_LITERAL) || sNewSubType.equalsIgnoreCase(PERCENTSTACKED_SUBTYPE_LITERAL))) {
                            if (!ChartPreviewPainter.isLivePreviewActive() && !isNumbericAxis((Axis) axes.get(i))) {
                                ((Axis) axes.get(i)).setType(AxisType.LINEAR_LITERAL);
                            }
                            series.setStacked(true);
                        } else {
                            series.setStacked(false);
                        }
                    }
                }
            }
        } else if (currentChart.getType().equals(BarChart.TYPE_LITERAL) || currentChart.getType().equals(TubeChart.TYPE_LITERAL) || currentChart.getType().equals(ConeChart.TYPE_LITERAL) || currentChart.getType().equals(PyramidChart.TYPE_LITERAL) || currentChart.getType().equals(AreaChart.TYPE_LITERAL) || currentChart.getType().equals(StockChart.TYPE_LITERAL) || currentChart.getType().equals(ScatterChart.TYPE_LITERAL) || currentChart.getType().equals(BubbleChart.TYPE_LITERAL) || currentChart.getType().equals(DifferenceChart.TYPE_LITERAL) || currentChart.getType().equals(GanttChart.TYPE_LITERAL)) {
            currentChart.setType(TYPE_LITERAL);
            currentChart.setSubType(sNewSubType);
            currentChart.getTitle().getLabel().getCaption().setValue(CHART_TITLE);
            ArrayList axisTypes = new ArrayList();
            EList axes = ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes();
            for (int i = 0, seriesIndex = 0; i < axes.size(); i++) {
                if (sNewSubType.equalsIgnoreCase(PERCENTSTACKED_SUBTYPE_LITERAL)) {
                    if (!ChartPreviewPainter.isLivePreviewActive() && !isNumbericAxis((Axis) axes.get(i))) {
                        ((Axis) axes.get(i)).setType(AxisType.LINEAR_LITERAL);
                    }
                    ((Axis) axes.get(i)).setPercent(true);
                } else {
                    ((Axis) axes.get(i)).setPercent(false);
                }
                EList seriesdefinitions = ((Axis) axes.get(i)).getSeriesDefinitions();
                for (int j = 0; j < seriesdefinitions.size(); j++) {
                    Series series = ((SeriesDefinition) seriesdefinitions.get(j)).getDesignTimeSeries();
                    series = getConvertedSeries(series, seriesIndex++);
                    ((LineSeries) series).setPaletteLineColor(true);
                    if ((sNewSubType.equalsIgnoreCase(STACKED_SUBTYPE_LITERAL) || sNewSubType.equalsIgnoreCase(PERCENTSTACKED_SUBTYPE_LITERAL))) {
                        if (!ChartPreviewPainter.isLivePreviewActive() && !isNumbericAxis((Axis) axes.get(i))) {
                            ((Axis) axes.get(i)).setType(AxisType.LINEAR_LITERAL);
                        }
                        series.setStacked(true);
                    } else {
                        series.setStacked(false);
                    }
                    ((SeriesDefinition) seriesdefinitions.get(j)).getSeries().clear();
                    ((SeriesDefinition) seriesdefinitions.get(j)).getSeries().add(series);
                    axisTypes.add(((Axis) axes.get(i)).getType());
                }
            }
            currentChart.setSampleData(getConvertedSampleData(currentChart.getSampleData(), ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getType(), axisTypes));
        } else {
            return null;
        }
    } else {
        currentChart = ChartWithAxesImpl.create();
        currentChart.setType(TYPE_LITERAL);
        currentChart.setSubType(sNewSubType);
        ((ChartWithAxes) currentChart).setOrientation(newOrientation);
        currentChart.setDimension(ChartUIUtil.getDimensionType(sNewDimension));
        ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).setOrientation(Orientation.HORIZONTAL_LITERAL);
        ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).setType(AxisType.TEXT_LITERAL);
        ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).setCategoryAxis(true);
        ((Axis) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes().get(0)).setOrientation(Orientation.VERTICAL_LITERAL);
        ((Axis) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes().get(0)).setType(AxisType.LINEAR_LITERAL);
        currentChart.setBlock(helperModel.getBlock());
        currentChart.setDescription(helperModel.getDescription());
        currentChart.setGridColumnCount(helperModel.getGridColumnCount());
        currentChart.setSampleData(helperModel.getSampleData());
        currentChart.setScript(helperModel.getScript());
        currentChart.setSeriesThickness(helperModel.getSeriesThickness());
        currentChart.setUnits(helperModel.getUnits());
        if (helperModel.getInteractivity() != null) {
            currentChart.getInteractivity().setEnable(helperModel.getInteractivity().isEnable());
            currentChart.getInteractivity().setLegendBehavior(helperModel.getInteractivity().getLegendBehavior());
        }
        if (helperModel.getType().equals(PieChart.TYPE_LITERAL) || helperModel.getType().equals(MeterChart.TYPE_LITERAL)) {
            ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getSeriesDefinitions().clear();
            ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getSeriesDefinitions().add(((ChartWithoutAxes) helperModel).getSeriesDefinitions().get(0));
            ((Axis) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes().get(0)).getSeriesDefinitions().clear();
            ((Axis) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes().get(0)).getSeriesDefinitions().addAll(((SeriesDefinition) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getSeriesDefinitions().get(0)).getSeriesDefinitions());
            Series series = ((SeriesDefinition) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getSeriesDefinitions().get(0)).getDesignTimeSeries();
            ((SeriesDefinition) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getSeriesDefinitions().get(0)).getSeries().clear();
            ((SeriesDefinition) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getSeriesDefinitions().get(0)).getSeries().add(series);
            EList seriesdefinitions = ((Axis) ((Axis) ((ChartWithAxes) currentChart).getAxes().get(0)).getAssociatedAxes().get(0)).getSeriesDefinitions();
            for (int j = 0; j < seriesdefinitions.size(); j++) {
                series = ((SeriesDefinition) seriesdefinitions.get(j)).getDesignTimeSeries();
                series = getConvertedSeries(series, j);
                series.getLabel().setVisible(false);
                ((LineSeries) series).setPaletteLineColor(true);
                if ((sNewSubType.equalsIgnoreCase(STACKED_SUBTYPE_LITERAL) || sNewSubType.equalsIgnoreCase(PERCENTSTACKED_SUBTYPE_LITERAL))) {
                    series.setStacked(true);
                } else {
                    series.setStacked(false);
                }
                ((SeriesDefinition) seriesdefinitions.get(j)).getSeries().clear();
                ((SeriesDefinition) seriesdefinitions.get(j)).getSeries().add(series);
            }
        } else {
            return null;
        }
        currentChart.getLegend().setItemType(LegendItemType.SERIES_LITERAL);
        currentChart.getTitle().getLabel().getCaption().setValue(CHART_TITLE);
    }
    if (currentChart instanceof ChartWithAxes && !((ChartWithAxes) currentChart).getOrientation().equals(newOrientation)) {
        ((ChartWithAxes) currentChart).setOrientation(newOrientation);
    }
    if (!currentChart.getDimension().equals(ChartUIUtil.getDimensionType(sNewDimension))) {
        currentChart.setDimension(ChartUIUtil.getDimensionType(sNewDimension));
    }
    if (sNewDimension.equals(THREE_DIMENSION_TYPE) && ChartUIUtil.getDimensionType(sNewDimension) != oldDimension) {
        ((ChartWithAxes) currentChart).setRotation(Rotation3DImpl.create(new Angle3D[] { Angle3DImpl.create(-20, 45, 0) }));
        ((ChartWithAxes) currentChart).getPrimaryBaseAxes()[0].getAncillaryAxes().clear();
        Axis zAxisAncillary = AxisImpl.create(Axis.ANCILLARY_BASE);
        zAxisAncillary.setTitlePosition(Position.BELOW_LITERAL);
        zAxisAncillary.getTitle().getCaption().setValue(Messages.getString("String_Node_Str"));
        zAxisAncillary.getTitle().setVisible(true);
        zAxisAncillary.setPrimaryAxis(true);
        zAxisAncillary.setLabelPosition(Position.BELOW_LITERAL);
        zAxisAncillary.setOrientation(Orientation.HORIZONTAL_LITERAL);
        zAxisAncillary.getOrigin().setType(IntersectionType.MIN_LITERAL);
        zAxisAncillary.getOrigin().setValue(NumberDataElementImpl.create(0));
        zAxisAncillary.getTitle().setVisible(false);
        zAxisAncillary.setType(AxisType.TEXT_LITERAL);
        ((ChartWithAxes) currentChart).getPrimaryBaseAxes()[0].getAncillaryAxes().add(zAxisAncillary);
        SeriesDefinition sdZ = SeriesDefinitionImpl.create();
        sdZ.getSeriesPalette().shift(0);
        sdZ.getSeries().add(SeriesImpl.create());
        zAxisAncillary.getSeriesDefinitions().add(sdZ);
        if (currentChart.getSampleData().getAncillarySampleData().isEmpty()) {
            BaseSampleData sdAncillary = DataFactory.eINSTANCE.createBaseSampleData();
            sdAncillary.setDataSetRepresentation("String_Node_Str");
            currentChart.getSampleData().getAncillarySampleData().add(sdAncillary);
        }
        EList seriesdefinitions = ChartUIUtil.getOrthogonalSeriesDefinitions(currentChart, 0);
        for (int j = 0; j < seriesdefinitions.size(); j++) {
            Series series = ((SeriesDefinition) seriesdefinitions.get(j)).getDesignTimeSeries();
            series.setStacked(false);
        }
    }
    ChartUIUtil.restoreLabelPositionFromCache(currentChart);
    return currentChart;
}

Output:
             for (int i = 0, seriesIndex = 0; i < axes.size(); i++) {
-                if (sNewSubType.equalsIgnoreCase(PERCENTSTACKED_SUBTYPE_LITERAL)) {
-                    if (!ChartPreviewPainter.isLivePreviewActive() && !isNumbericAxis((Axis) axes.get(i))) {
-                        ((Axis) axes.get(i)).setType(AxisType.LINEAR_LITERAL);
-                    }
-                    ((Axis) axes.get(i)).setPercent(true);
-                } else {
-                    ((Axis) axes.get(i)).setPercent(false);
+                if (!ChartPreviewPainter.isLivePreviewActive() && !isNumbericAxis((Axis) axes.get(i))) {
+                    ((Axis) axes.get(i)).setType(AxisType.LINEAR_LITERAL);
                 }


Input:
public List<Axiom> getCurrentlyBestAxioms(int nrOfAxioms) {
    List<Axiom> bestAxioms = new ArrayList<Axiom>();
    Iterator<EvaluatedAxiom> it = currentlyBestAxioms.iterator();
    while (bestAxioms.size() < nrOfAxioms && it.hasNext()) {
        bestAxioms.add(it.next().getAxiom());
    }
    return bestAxioms;
}

Output:
     List<Axiom> bestAxioms = new ArrayList<Axiom>();
-    Iterator<EvaluatedAxiom> it = currentlyBestAxioms.iterator();
-    while (bestAxioms.size() < nrOfAxioms && it.hasNext()) {
-        bestAxioms.add(it.next().getAxiom());
+    for (EvaluatedAxiom evAx : getCurrentlyBestEvaluatedAxioms(nrOfAxioms)) {
+        bestAxioms.add(evAx.getAxiom());
     }


Input:
private Class generateWrapperClassAndDescriptor(TypeInfo type, QName next, ElementDeclaration nextElement, String nextClassName, String attributeTypeName) {
    String namespaceUri = null;
    if (next != null) {
        namespaceUri = next.getNamespaceURI();
        if (namespaceUri == null || namespaceUri.equals("String_Node_Str")) {
            namespaceUri = "String_Node_Str";
        }
    }
    Class generatedClass = this.generateWrapperClass(WRAPPER_CLASS + wrapperCounter++, attributeTypeName, nextElement.isList(), next);
    this.qNamesToGeneratedClasses.put(next, generatedClass);
    try {
        Class declaredClass = PrivilegedAccessHelper.getClassForName(nextClassName, false, helper.getClassLoader());
        this.qNamesToDeclaredClasses.put(next, declaredClass);
    } catch (Exception e) {
    }
    XMLDescriptor desc = new XMLDescriptor();
    desc.setJavaClass(generatedClass);
    if (nextElement.isList()) {
        XMLCompositeDirectCollectionMapping mapping = new XMLCompositeDirectCollectionMapping();
        mapping.setAttributeName("String_Node_Str");
        mapping.setXPath("String_Node_Str");
        mapping.setUsesSingleNode(true);
        mapping.setReuseContainer(true);
        if (type != null && type.isEnumerationType()) {
            mapping.setValueConverter(buildJAXBEnumTypeConverter(mapping, (EnumTypeInfo) type));
        } else {
            try {
                Class fieldElementClass = PrivilegedAccessHelper.getClassForName(nextClassName, false, helper.getClassLoader());
                mapping.setFieldElementClass(fieldElementClass);
            } catch (ClassNotFoundException e) {
            }
        }
        if (nextClassName.equals("String_Node_Str") || nextClassName.equals("String_Node_Str")) {
            ((XMLField) mapping.getField()).setSchemaType(XMLConstants.BASE_64_BINARY_QNAME);
        } else if (nextClassName.equals("String_Node_Str")) {
            ((XMLField) mapping.getField()).setSchemaType(XMLConstants.QNAME_QNAME);
        }
        desc.addMapping(mapping);
    } else {
        if (nextElement.getJavaTypeName().equals(OBJECT_CLASS_NAME)) {
            XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
            mapping.setAttributeName("String_Node_Str");
            mapping.setSetMethodName("String_Node_Str");
            mapping.setGetMethodName("String_Node_Str");
            mapping.getNullPolicy().setNullRepresentedByXsiNil(true);
            mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
            mapping.setXPath("String_Node_Str");
            ((XMLField) mapping.getField()).setIsTypedTextField(true);
            ((XMLField) mapping.getField()).setSchemaType(XMLConstants.ANY_TYPE_QNAME);
            desc.addMapping(mapping);
        } else if (areEquals(nextElement.getJavaType(), ClassConstants.ABYTE) || areEquals(nextElement.getJavaType(), ClassConstants.APBYTE) || areEquals(nextElement.getJavaType(), "String_Node_Str")) {
            XMLBinaryDataMapping mapping = new XMLBinaryDataMapping();
            mapping.setAttributeName("String_Node_Str");
            mapping.setXPath("String_Node_Str");
            ((XMLField) mapping.getField()).setSchemaType(XMLConstants.BASE_64_BINARY_QNAME);
            mapping.setSetMethodName("String_Node_Str");
            mapping.setGetMethodName("String_Node_Str");
            Class attributeClassification = org.eclipse.persistence.internal.helper.Helper.getClassFromClasseName(attributeTypeName, getClass().getClassLoader());
            mapping.setAttributeClassification(attributeClassification);
            mapping.setShouldInlineBinaryData(false);
            if (nextElement.getTypeMappingInfo() != null) {
                mapping.setSwaRef(nextElement.isXmlAttachmentRef());
                mapping.setMimeType(nextElement.getXmlMimeType());
            }
            desc.addMapping(mapping);
        } else {
            XMLDirectMapping mapping = new XMLDirectMapping();
            mapping.setAttributeName("String_Node_Str");
            mapping.setXPath("String_Node_Str");
            mapping.setSetMethodName("String_Node_Str");
            mapping.setGetMethodName("String_Node_Str");
            if (nextElement.getDefaultValue() != null) {
                mapping.setNullValue(nextElement.getDefaultValue());
            }
            if (helper.isBuiltInJavaType(nextElement.getJavaType())) {
                Class attributeClassification = org.eclipse.persistence.internal.helper.Helper.getClassFromClasseName(attributeTypeName, getClass().getClassLoader());
                mapping.setAttributeClassification(attributeClassification);
            }
            IsSetNullPolicy nullPolicy = new IsSetNullPolicy("String_Node_Str", false, true, XMLNullRepresentationType.ABSENT_NODE);
            mapping.setNullPolicy(nullPolicy);
            if (type != null && type.isEnumerationType()) {
                mapping.setConverter(buildJAXBEnumTypeConverter(mapping, (EnumTypeInfo) type));
            }
            if (nextClassName.equals("String_Node_Str") || nextClassName.equals("String_Node_Str")) {
                ((XMLField) mapping.getField()).setSchemaType(XMLConstants.BASE_64_BINARY_QNAME);
            } else if (nextClassName.equals("String_Node_Str")) {
                ((XMLField) mapping.getField()).setSchemaType(XMLConstants.QNAME_QNAME);
            }
            if (nextElement.getJavaTypeAdapterClass() != null) {
                mapping.setConverter(new XMLJavaTypeConverter(nextElement.getJavaTypeAdapterClass()));
            }
            desc.addMapping(mapping);
        }
    }
    if (next != null) {
        NamespaceInfo info = getNamespaceInfoForURI(namespaceUri);
        if (info != null) {
            NamespaceResolver resolver = info.getNamespaceResolverForDescriptor();
            String prefix = resolver.resolveNamespaceURI(namespaceUri);
            desc.setNamespaceResolver(resolver);
            desc.setDefaultRootElement("String_Node_Str");
            desc.addRootElement(getQualifiedString(prefix, next.getLocalPart()));
        } else {
            if (namespaceUri.equals("String_Node_Str")) {
                desc.setDefaultRootElement(next.getLocalPart());
            } else {
                NamespaceResolver resolver = new NamespaceResolver();
                String prefix = getPrefixForNamespace(namespaceUri, resolver, null);
                desc.setNamespaceResolver(resolver);
                desc.setDefaultRootElement("String_Node_Str");
                desc.addRootElement(getQualifiedString(prefix, next.getLocalPart()));
            }
        }
    }
    project.addDescriptor(desc);
    return generatedClass;
}

Output:
             if (helper.isBuiltInJavaType(nextElement.getJavaType())) {
-                Class attributeClassification = org.eclipse.persistence.internal.helper.Helper.getClassFromClasseName(attributeTypeName, getClass().getClassLoader());
+                Class attributeClassification = null;
+                if (nextElement.getJavaType().isPrimitive()) {
+                    attributeClassification = XMLConversionManager.getDefaultManager().convertClassNameToClass(attributeTypeName);
+                } else {
+                    attributeClassification = org.eclipse.persistence.internal.helper.Helper.getClassFromClasseName(attributeTypeName, getClass().getClassLoader());
+                }
                 mapping.setAttributeClassification(attributeClassification);


Input:
private void constructStatisticsTablesForTeams(ViewType viewType, Map<String, FeedbackQuestionAttributes> questions, LinkedHashMap<String, Map<FeedbackQuestionAttributes, List<FeedbackResponseAttributes>>> responsesGroupedByTeam, InstructorFeedbackResultsSectionPanel panel, Collection<String> teamsInSection) {
    Map<String, List<InstructorResultsQuestionTable>> teamToStatisticsTables = new HashMap<String, List<InstructorResultsQuestionTable>>();
    for (String team : teamsInSection) {
        if (!responsesGroupedByTeam.containsKey(team)) {
            continue;
        }
        List<InstructorResultsQuestionTable> statisticsTablesForTeam = new ArrayList<InstructorResultsQuestionTable>();
        for (FeedbackQuestionAttributes question : questions.values()) {
            if (!responsesGroupedByTeam.get(team).containsKey(question)) {
                continue;
            }
            List<FeedbackResponseAttributes> responsesGivenTeamAndQuestion = responsesGroupedByTeam.get(team).get(question);
            InstructorResultsQuestionTable statsTable = buildQuestionTable(question, responsesGivenTeamAndQuestion, viewType, "String_Node_Str", false);
            statsTable.setShowResponseRows(false);
            statsTable.setCollapsible(false);
            if (!statsTable.getQuestionStatisticsHtml().isEmpty()) {
                statisticsTablesForTeam.add(statsTable);
            }
        }
        InstructorResultsQuestionTable.sortByQuestionNumber(statisticsTablesForTeam);
        teamToStatisticsTables.put(team, statisticsTablesForTeam);
    }
    panel.setTeamStatisticsTable(teamToStatisticsTables);
}

Output:
             statsTable.setCollapsible(false);
-            if (!statsTable.getQuestionStatisticsHtml().isEmpty()) {
+            if (!statsTable.getQuestionStatisticsTable().isEmpty()) {
                 statisticsTablesForTeam.add(statsTable);


Input:
public boolean onItemUse(ItemStack stack, EntityPlayer par2EntityPlayer, World world, int x, int y, int z, int side, float par8, float par9, float par10) {
    TileEntity tile = world.getTileEntity(x, y, z);
    NBTTagCompound cpt = NBTUtils.getItemData(stack);
    if (tile instanceof IPathProvider) {
        cpt.setByte("String_Node_Str", (byte) 2);
        NBTTagList pathNBT = new NBTTagList();
        for (BlockPos index : ((IPathProvider) tile).getPath()) {
            NBTTagCompound nbt = new NBTTagCompound();
            index.writeTo(nbt);
            pathNBT.appendTag(nbt);
        }
        cpt.setTag("String_Node_Str", pathNBT);
    } else if (tile instanceof IAreaProvider) {
        cpt.setByte("String_Node_Str", (byte) 1);
        IAreaProvider areaTile = (IAreaProvider) tile;
        cpt.setInteger("String_Node_Str", areaTile.xMin());
        cpt.setInteger("String_Node_Str", areaTile.yMin());
        cpt.setInteger("String_Node_Str", areaTile.zMin());
        cpt.setInteger("String_Node_Str", areaTile.xMax());
        cpt.setInteger("String_Node_Str", areaTile.yMax());
        cpt.setInteger("String_Node_Str", areaTile.zMax());
    } else {
        cpt.setByte("String_Node_Str", (byte) 0);
        cpt.setByte("String_Node_Str", (byte) side);
        cpt.setInteger("String_Node_Str", x);
        cpt.setInteger("String_Node_Str", y);
        cpt.setInteger("String_Node_Str", z);
    }
    return true;
}

Output:
         for (BlockPos index : ((IPathProvider) tile).getPath()) {
-            NBTTagCompound nbt = new NBTTagCompound();
-            index.writeTo(nbt);
-            pathNBT.appendTag(nbt);
+            pathNBT.appendTag(NBTUtils.writeBlockPos(index));
         }


Input:
public boolean equals(final Object obj) {
    if (obj == this) {
        return true;
    }
    if (obj instanceof DenseFeature) {
        final DenseFeature that = (DenseFeature) obj;
        return type.equals(that.type) && Arrays.equals(properties, that.properties);
    }
    return false;
}

Output:
         final DenseFeature that = (DenseFeature) obj;
-        return type.equals(that.type) && Arrays.equals(properties, that.properties);
+        if (type.equals(that.type)) {
+            final boolean asProperties = (properties instanceof Property[]);
+            if (asProperties != (that.properties instanceof Property[])) {
+                if (asProperties) {
+                    that.wrapValuesInProperties();
+                } else {
+                    wrapValuesInProperties();
+                }
+            }
+            return Arrays.equals(properties, that.properties);
+        }
     }


Input:
public static IllegalArgumentException newIllegalArgumentException(String message, Object... arguments) {
    return initCause(new IllegalArgumentException(MessageFormat.format(message, arguments) + "String_Node_Str" + getVersion()), arguments);
}

Output:
 public static IllegalArgumentException newIllegalArgumentException(String message, Object... arguments) {
-    return initCause(new IllegalArgumentException(MessageFormat.format(message, arguments) + "String_Node_Str" + getVersion()), arguments);
+    return initCause(new IllegalArgumentException(formatMessage(0, message, arguments)), arguments);
 }


Input:
public boolean clear(Object value) throws FieldTypeMismatchException {
    values.clear();
    return true;
}

Output:
 public boolean clear(Object value) throws FieldTypeMismatchException {
-    values.clear();
-    return true;
+    boolean isSuccess = false;
+    if (values != null) {
+        values.clear();
+        isSuccess = true;
+    }
+    return isSuccess;
 }


Input:
public boolean performOk() {
    if (!modelChanged) {
        disposeAll();
        return super.performOk();
    }
    if (isValid()) {
        refreshPositions();
        disposeAll();
        return super.performOk();
    } else
        return false;
}

Output:
         return super.performOk();
-    } else
+    } else {
+        disposeAll();
         return false;


Input:
public byte[] setDate(Object... args) {
    int day = (Integer) args[0];
    int month = (Integer) args[1];
    int year = (Integer) args[2];
    byte[] completedMessage = new byte[] { gfxDriver, 0x07, IKESystem, OBCRequestSet, 0x02, (byte) day, (byte) month, (byte) year, 0x00 };
    completedMessage[7] = genMessageCRC(completedMessage);
    return completedMessage;
}

Output:
     byte[] completedMessage = new byte[] { gfxDriver, 0x07, IKESystem, OBCRequestSet, 0x02, (byte) day, (byte) month, (byte) year, 0x00 };
-    completedMessage[7] = genMessageCRC(completedMessage);
+    completedMessage[completedMessage.length - 1] = genMessageCRC(completedMessage);
     return completedMessage;


Input:
public UserVm recoverVirtualMachine(RecoverVMCmd cmd) throws ResourceAllocationException, CloudRuntimeException {
    Long vmId = cmd.getId();
    Account accountHandle = UserContext.current().getCaller();
    if (accountHandle != null && accountHandle.getRemoved() != null) {
        throw new ServerApiException(BaseCmd.ACCOUNT_ERROR, "String_Node_Str" + accountHandle.getId() + "String_Node_Str");
    }
    UserVmVO vm = _vmDao.findById(vmId.longValue());
    if (vm == null) {
        throw new ServerApiException(BaseCmd.PARAM_ERROR, "String_Node_Str" + vmId);
    }
    if ((accountHandle != null) && !_domainDao.isChildDomain(accountHandle.getDomainId(), vm.getDomainId())) {
        throw new ServerApiException(BaseCmd.PARAM_ERROR, "String_Node_Str" + vmId + "String_Node_Str");
    }
    if (vm.getRemoved() != null) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str" + vmId);
        }
        throw new InvalidParameterValueException("String_Node_Str" + vmId);
    }
    if (vm.getState() != State.Destroyed) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str" + vmId);
        }
        throw new InvalidParameterValueException("String_Node_Str" + vmId + "String_Node_Str");
    }
    if (s_logger.isDebugEnabled()) {
        s_logger.debug("String_Node_Str" + vmId);
    }
    Transaction txn = Transaction.currentTxn();
    AccountVO account = null;
    txn.start();
    account = _accountDao.lockRow(vm.getAccountId(), true);
    if (account.getRemoved() != null) {
        throw new CloudRuntimeException("String_Node_Str");
    }
    if (_accountMgr.resourceLimitExceeded(account, ResourceType.user_vm)) {
        ResourceAllocationException rae = new ResourceAllocationException("String_Node_Str" + account.getAccountName() + "String_Node_Str");
        rae.setResourceType("String_Node_Str");
        txn.commit();
        throw rae;
    }
    _haMgr.cancelDestroy(vm, vm.getHostId());
    _accountMgr.incrementResourceCount(account.getId(), ResourceType.user_vm);
    if (!_itMgr.stateTransitTo(vm, VirtualMachine.Event.RecoveryRequested, null)) {
        s_logger.debug("String_Node_Str" + vmId);
        throw new InvalidParameterValueException("String_Node_Str" + vmId);
    }
    List<VolumeVO> volumes = _volsDao.findByInstanceIdDestroyed(vmId);
    for (VolumeVO volume : volumes) {
        Long templateId = volume.getTemplateId();
        Long diskOfferingId = volume.getDiskOfferingId();
        Long offeringId = null;
        if (diskOfferingId != null) {
            DiskOfferingVO offering = _diskOfferingDao.findById(diskOfferingId);
            if (offering != null && (offering.getType() == DiskOfferingVO.Type.Disk)) {
                offeringId = offering.getId();
            }
        }
        UsageEventVO usageEvent = new UsageEventVO(EventTypes.EVENT_VOLUME_CREATE, volume.getAccountId(), volume.getDataCenterId(), volume.getId(), volume.getName(), offeringId, templateId, volume.getSize());
        _usageEventDao.persist(usageEvent);
    }
    _accountMgr.incrementResourceCount(account.getId(), ResourceType.volume, new Long(volumes.size()));
    UsageEventVO usageEvent = new UsageEventVO(EventTypes.EVENT_VM_CREATE, vm.getAccountId(), vm.getDataCenterId(), vm.getId(), vm.getName(), vm.getServiceOfferingId(), vm.getTemplateId(), null);
    _usageEventDao.persist(usageEvent);
    txn.commit();
    return _vmDao.findById(vmId);
}

Output:
     }
-    List<VolumeVO> volumes = _volsDao.findByInstanceIdDestroyed(vmId);
+    List<VolumeVO> volumes = _volsDao.findByInstance(vmId);
     for (VolumeVO volume : volumes) {


Input:
private void changeBalance(Player player, HumanNPC npc, String[] args) throws NumberFormatException {
    try {
        double amount = Double.parseDouble(args[2]);
        if (args[1].equals("String_Node_Str")) {
            if (EconomyHandler.canBuy(new Payment(amount, true), player)) {
                EconomyHandler.pay(new Payment(-amount, true), npc, -1);
                EconomyHandler.pay(new Payment(amount, true), player, -1);
                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(player.getName()), ChatColor.GREEN) + "String_Node_Str");
            } else {
                player.sendMessage(ChatColor.RED + "String_Node_Str" + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount - IconomyInterface.getBalance(player.getName())), ChatColor.RED) + "String_Node_Str");
            }
        } else if (args[1].equals("String_Node_Str")) {
            if (EconomyHandler.canBuy(new Payment(amount, true), npc)) {
                EconomyHandler.pay(new Payment(amount, true), npc, -1);
                EconomyHandler.pay(new Payment(-amount, true), player, -1);
                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getBalance(player.getName())) + "String_Node_Str");
            } else {
                player.sendMessage(ChatColor.RED + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount - npc.getBalance()), ChatColor.RED) + "String_Node_Str");
            }
        } else
            player.sendMessage(ChatColor.RED + "String_Node_Str" + StringUtils.yellowify(args[1], ChatColor.RED) + "String_Node_Str");
    } catch (NumberFormatException e) {
        player.sendMessage(ChatColor.RED + "String_Node_Str");
    }
}

Output:
     try {
-        double amount = Double.parseDouble(args[2]);
-        if (args[1].equals("String_Node_Str")) {
-            if (EconomyHandler.canBuy(new Payment(amount, true), player)) {
-                EconomyHandler.pay(new Payment(-amount, true), npc, -1);
-                EconomyHandler.pay(new Payment(amount, true), player, -1);
-                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(player.getName()), ChatColor.GREEN) + "String_Node_Str");
-            } else {
-                player.sendMessage(ChatColor.RED + "String_Node_Str" + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount - IconomyInterface.getBalance(player.getName())), ChatColor.RED) + "String_Node_Str");
-            }
-        } else if (args[1].equals("String_Node_Str")) {
-            if (EconomyHandler.canBuy(new Payment(amount, true), npc)) {
-                EconomyHandler.pay(new Payment(amount, true), npc, -1);
-                EconomyHandler.pay(new Payment(-amount, true), player, -1);
-                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getBalance(player.getName())) + "String_Node_Str");
-            } else {
-                player.sendMessage(ChatColor.RED + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount - npc.getBalance()), ChatColor.RED) + "String_Node_Str");
-            }
-        } else
-            player.sendMessage(ChatColor.RED + "String_Node_Str" + StringUtils.yellowify(args[1], ChatColor.RED) + "String_Node_Str");
+        amount = Double.parseDouble(args[2]);
     } catch (NumberFormatException e) {


Input:
public static void decorateCategoryPlot(JFreeChart chart) {
    CategoryPlot plot = chart.getCategoryPlot();
    CategoryItemRenderer render = plot.getRenderer();
    CategoryAxis domainAxis = plot.getDomainAxis();
    domainAxis.setCategoryMargin(0.01);
    ValueAxis valueAxis = plot.getRangeAxis();
    Font font = new Font("String_Node_Str", Font.BOLD, BASE_ITEM_LABEL_SIZE);
    render.setBaseItemLabelFont(font);
    font = new Font("String_Node_Str", Font.BOLD, BASE_LABEL_SIZE);
    domainAxis.setLabelFont(font);
    font = new Font("String_Node_Str", Font.BOLD, BASE_LABEL_SIZE);
    valueAxis.setLabelFont(font);
    font = new Font("String_Node_Str", Font.PLAIN, BASE_TICK_LABEL_SIZE);
    domainAxis.setTickLabelFont(font);
    valueAxis.setTickLabelFont(font);
    font = new Font("String_Node_Str", Font.PLAIN, BASE_LEGEND_LABEL_SIZE);
    LegendTitle legend = chart.getLegend();
    if (legend != null) {
        legend.setItemFont(font);
    }
    font = new Font("String_Node_Str", Font.BOLD, BASE_TITLE_LABEL_SIZE);
    TextTitle title = chart.getTitle();
    if (title != null) {
        title.setFont(font);
    }
    font = null;
    if (render instanceof BarRenderer) {
        int rowCount = chart.getCategoryPlot().getDataset().getRowCount();
        domainAxis.setTickLabelFont(new Font("String_Node_Str", Font.PLAIN, 10));
        domainAxis.setUpperMargin(0.1);
        domainAxis.setMaximumCategoryLabelLines(10);
        ((BarRenderer) render).setItemMargin(-0.40 * rowCount);
    }
}

Output:
         int rowCount = chart.getCategoryPlot().getDataset().getRowCount();
-        domainAxis.setTickLabelFont(new Font("String_Node_Str", Font.PLAIN, 10));
+        if (!isContainsChineseColumn(chart))
+            domainAxis.setTickLabelFont(new Font("String_Node_Str", Font.PLAIN, 10));
         domainAxis.setUpperMargin(0.1);


Input:
protected Void execute(PauseContainerCmd command) {
    WebTarget webResource = getBaseResource().path("String_Node_Str").resolveTemplate("String_Node_Str", command.getContainerId());
    LOGGER.trace("String_Node_Str", webResource);
    webResource.request().accept(MediaType.APPLICATION_JSON).post(null);
    return null;
}

Output:
     LOGGER.trace("String_Node_Str", webResource);
-    webResource.request().accept(MediaType.APPLICATION_JSON).post(null);
+    webResource.request().accept(MediaType.APPLICATION_JSON).post(null).close();
     return null;


Input:
public static int countItems(Map<Integer, ?> items) {
    int totalLeft = 0;
    for (int left : items.keySet()) {
        totalLeft += left;
    }
    return totalLeft;
}

Output:
     int totalLeft = 0;
-    for (int left : items.keySet()) {
-        totalLeft += left;
+    for (ItemStack left : items.values()) {
+        totalLeft += left.getAmount();
     }


Input:
public final void push_structured_event(StructuredEvent structuredEvent) throws Disconnected {
    try {
        push_structured_event_called(structuredEvent);
    } catch (Throwable thr) {
    }
    if (isDisconnected()) {
        throw new Disconnected();
    }
    final EventDescription eDescrip = EventDescriptionHelper.extract(structuredEvent.remainder_of_body);
    Object convertedAny = anyAide.complexAnyToObject(structuredEvent.filterable_data[0].value);
    if (convertedAny == null) {
        LOG_NC_EventReceive_FAIL.log(logger, channelName, getNotificationFactoryName(), structuredEvent.header.fixed_header.event_type.type_name, "String_Node_Str");
    } else if (!eventType.isInstance(convertedAny)) {
        if (genericReceiver == null) {
            logNoEventReceiver(convertedAny.getClass().getName());
        }
    } else {
        T struct = (T) convertedAny;
        if (isTraceEventsEnabled()) {
            LOG_NC_EventReceive_OK.log(logger, channelName, getNotificationFactoryName(), structuredEvent.header.fixed_header.event_type.type_name);
        }
        processEventAsync(struct, eDescrip);
    }
}

Output:
         LOG_NC_EventReceive_FAIL.log(logger, channelName, getNotificationFactoryName(), structuredEvent.header.fixed_header.event_type.type_name, "String_Node_Str");
-    } else if (!eventType.isInstance(convertedAny)) {
-        if (genericReceiver == null) {
+    } else {
+        if (!eventType.isInstance(convertedAny) && !hasGenericReceiver()) {
             logNoEventReceiver(convertedAny.getClass().getName());


Input:
private void initOptions() {
    ConfigurableOption bidiProcessing = new ConfigurableOption(IPDFRenderOption.PDF_BIDI_PROCESSING);
    bidiProcessing.setDisplayName(Messages.getString("String_Node_Str"));
    bidiProcessing.setDataType(IConfigurableOption.DataType.BOOLEAN);
    bidiProcessing.setDisplayType(IConfigurableOption.DispayType.CHECKBOX);
    bidiProcessing.setDefaultValue(Boolean.FALSE);
    bidiProcessing.setToolTip(null);
    bidiProcessing.setDescription(Messages.getString("String_Node_Str"));
    ConfigurableOption textWrapping = new ConfigurableOption(IPDFRenderOption.PDF_TEXT_WRAPPING);
    textWrapping.setDisplayName(Messages.getString("String_Node_Str"));
    textWrapping.setDataType(IConfigurableOption.DataType.BOOLEAN);
    textWrapping.setDisplayType(IConfigurableOption.DispayType.CHECKBOX);
    textWrapping.setDefaultValue(Boolean.TRUE);
    textWrapping.setToolTip(null);
    textWrapping.setDescription(Messages.getString("String_Node_Str"));
    ConfigurableOption fontSubstitution = new ConfigurableOption(IPDFRenderOption.PDF_FONT_SUBSTITUTION);
    fontSubstitution.setDisplayName(Messages.getString("String_Node_Str"));
    fontSubstitution.setDataType(IConfigurableOption.DataType.BOOLEAN);
    fontSubstitution.setDisplayType(IConfigurableOption.DispayType.CHECKBOX);
    fontSubstitution.setDefaultValue(Boolean.TRUE);
    fontSubstitution.setToolTip(null);
    fontSubstitution.setDescription(Messages.getString("String_Node_Str"));
    ConfigurableOption pageOverFlow = new ConfigurableOption(IPDFRenderOption.PAGE_OVERFLOW);
    pageOverFlow.setDisplayName(Messages.getString("String_Node_Str"));
    pageOverFlow.setDataType(IConfigurableOption.DataType.INTEGER);
    pageOverFlow.setDisplayType(IConfigurableOption.DispayType.COMBO);
    pageOverFlow.setChoices(new OptionValue[] { new OptionValue(IPDFRenderOption.CLIP_CONTENT, Messages.getString("String_Node_Str")), new OptionValue(IPDFRenderOption.FIT_TO_PAGE_SIZE, Messages.getString("String_Node_Str")), new OptionValue(IPDFRenderOption.OUTPUT_TO_MULTIPLE_PAGES, Messages.getString("String_Node_Str")), new OptionValue(IPDFRenderOption.ENLARGE_PAGE_SIZE, Messages.getString("String_Node_Str")) });
    pageOverFlow.setDefaultValue(IPDFRenderOption.CLIP_CONTENT);
    pageOverFlow.setToolTip(null);
    pageOverFlow.setDescription(Messages.getString("String_Node_Str"));
    options = new IConfigurableOption[] { bidiProcessing, textWrapping, fontSubstitution, pageOverFlow };
}

Output:
     bidiProcessing.setDataType(IConfigurableOption.DataType.BOOLEAN);
-    bidiProcessing.setDisplayType(IConfigurableOption.DispayType.CHECKBOX);
+    bidiProcessing.setDisplayType(IConfigurableOption.DisplayType.CHECKBOX);
     bidiProcessing.setDefaultValue(Boolean.FALSE);


Input:
protected SSAContextInterpreter makeContextInterpreter(SSAContextInterpreter appContextInterpreter, ReflectionSpecification reflect) {
    SSAContextInterpreter defI = new DefaultSSAInterpreter(getOptions(), getAnalysisCache());
    defI = new DelegatingSSAContextInterpreter(ReflectionContextInterpreter.createReflectionContextInterpreter(cha, getOptions(), getAnalysisCache(), reflect), defI);
    SSAContextInterpreter contextInterpreter = new DelegatingSSAContextInterpreter(appContextInterpreter, defI);
    return contextInterpreter;
}

Output:
     defI = new DelegatingSSAContextInterpreter(ReflectionContextInterpreter.createReflectionContextInterpreter(cha, getOptions(), getAnalysisCache(), reflect), defI);
-    SSAContextInterpreter contextInterpreter = new DelegatingSSAContextInterpreter(appContextInterpreter, defI);
+    SSAContextInterpreter contextInterpreter = appContextInterpreter == null ? defI : new DelegatingSSAContextInterpreter(appContextInterpreter, defI);
     return contextInterpreter;


Input:
private static void runEquivalent(ArrayList<SAFA<CharPred, Character>> safaLHS, ArrayList<SAFA<CharPred, Character>> safaRHS, ArrayList<SFA<CharPred, Character>> sfaLHS, ArrayList<SFA<CharPred, Character>> sfaRHS, long timeOut) {
    try {
        Timers.setTimeout(Long.MAX_VALUE);
        SAFA<CharPred, Character> tempLeft = IntersectedSAFA(safaLHS, timeOut);
        long fullTimeSAFALeft = Timers.getFull();
        long solverTimeSAFALeft = Timers.getSolver();
        long subTimeSAFALeft = Timers.getSubsumption();
        Timers.setTimeout(Long.MAX_VALUE);
        SAFA<CharPred, Character> tempRight = IntersectedSAFA(safaRHS, timeOut - fullTimeSAFALeft);
        long fullTimeSAFARight = Timers.getFull();
        long solverTimeSAFARight = Timers.getSolver();
        long subTimeSAFARight = Timers.getSubsumption();
        if (fullTimeSAFALeft + fullTimeSAFARight >= timeOut) {
            fullTimeSAFA = timeOut;
            solverTimeSAFA = timeOut;
            subTimeSAFA = timeOut;
        } else {
            Timers.setTimeout(Long.MAX_VALUE);
            SAFA.isEquivalent(tempLeft, tempRight, solver, SAFA.getBooleanExpressionFactory(), timeOut - fullTimeSAFALeft - fullTimeSAFARight);
            fullTimeSAFA = Timers.getFull() + fullTimeSAFALeft + fullTimeSAFARight;
            solverTimeSAFA = Timers.getSolver() + solverTimeSAFALeft + solverTimeSAFARight;
            subTimeSAFA = Timers.getSubsumption() + subTimeSAFALeft + subTimeSAFARight;
        }
    } catch (Exception e) {
        fullTimeSAFA = timeOut;
        solverTimeSAFA = timeOut;
        subTimeSAFA = timeOut;
    }
    try {
        long startDate = System.currentTimeMillis();
        SFA<CharPred, Character> tempLeftSFA = IntersectedSFA(sfaLHS, timeOut);
        long endDate = System.currentTimeMillis();
        long totalTimeLeft = endDate - startDate;
        startDate = System.currentTimeMillis();
        SFA<CharPred, Character> tempRightSFA = IntersectedSFA(sfaRHS, timeOut - totalTimeLeft);
        endDate = System.currentTimeMillis();
        long totalTimeRight = endDate - startDate;
        long startDateEquiv = System.currentTimeMillis();
        SFA.areHopcroftKarpEquivalent(tempLeftSFA, tempRightSFA, solver);
        long endDateEquiv = System.currentTimeMillis();
        totalTimeSFA = endDateEquiv - startDateEquiv + totalTimeLeft + totalTimeRight;
    } catch (Exception e) {
        totalTimeSFA = timeOut;
    }
}

Output:
     try {
-        Timers.setTimeout(Long.MAX_VALUE);
+        long start = System.currentTimeMillis();
         SAFA<CharPred, Character> tempLeft = IntersectedSAFA(safaLHS, timeOut);


Input:
public Object clone() {
    ChainImpl n = new ChainImpl();
    n.setChainID(getChainID());
    n.setSwissprotId(getSwissprotId());
    n.setHeader(this.getHeader());
    n.setInternalChainID(internalChainID);
    for (int i = 0; i < groups.size(); i++) {
        Group g = (Group) groups.get(i);
        n.addGroup((Group) g.clone());
    }
    if (seqResGroups.size() > 0) {
        List<Group> tmpSeqRes = new ArrayList<Group>();
        for (int i = 0; i < seqResGroups.size(); i++) {
            Group g = (Group) seqResGroups.get(i);
            tmpSeqRes.add(g);
        }
        Chain tmp = new ChainImpl();
        tmp.setAtomGroups(tmpSeqRes);
        SeqRes2AtomAligner seqresaligner = new SeqRes2AtomAligner();
        try {
            seqresaligner.mapSeqresRecords(n, tmp);
        } catch (StructureException e) {
            logger.error("String_Node_Str", e);
        }
    }
    return n;
}

Output:
     n.setSwissprotId(getSwissprotId());
-    n.setHeader(this.getHeader());
+    n.setCompound(this.getCompound());
     n.setInternalChainID(internalChainID);


Input:
public void onCreate(Bundle savedInstanceState) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        getWindow().setStatusBarColor(getResources().getColor(R.color.status_bar_tint));
    }
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mViewPager = (WPMainViewPager) findViewById(R.id.viewpager_main);
    mTabAdapter = new WPMainTabAdapter(getFragmentManager());
    mViewPager.setAdapter(mTabAdapter);
    mTabs = (SlidingTabLayout) findViewById(R.id.sliding_tabs);
    mTabs.setSelectedIndicatorColors(getResources().getColor(R.color.tab_indicator));
    mTabs.setDistributeEvenly(true);
    Integer[] icons = { R.drawable.main_tab_sites, R.drawable.main_tab_reader, R.drawable.main_tab_me, R.drawable.main_tab_notifications };
    mTabs.setCustomTabView(R.layout.tab_icon, R.id.tab_icon, R.id.tab_badge, icons);
    mTabs.setViewPager(mViewPager);
    mTabs.setOnPageChangeListener(this);
    if (savedInstanceState == null) {
        if (showSignInIfRequired()) {
            int position = AppPrefs.getMainTabIndex();
            if (mTabAdapter.isValidPosition(position) && position != mViewPager.getCurrentItem()) {
                mViewPager.setCurrentItem(position);
            }
        }
    }
}

Output:
 public void onCreate(Bundle savedInstanceState) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        getWindow().setStatusBarColor(getResources().getColor(R.color.status_bar_tint));
-    }
+    setStatusBarColor();
     super.onCreate(savedInstanceState);


Input:
public TmfContext seekLocation(ITmfLocation<?> location) {
    CustomTxtTraceContext context = new CustomTxtTraceContext(new TmfLocation<Long>((Long) null), ITmfContext.INITIAL_RANK);
    if (!new File(getPath()).isFile()) {
        return context;
    }
    try {
        RandomAccessFile raFile = new RandomAccessFile(getPath(), "String_Node_Str");
        if (location != null && location.getLocation() instanceof Long) {
            raFile.seek((Long) location.getLocation());
        }
        String line;
        long rawPos = raFile.getFilePointer();
        while ((line = raFile.readLine()) != null) {
            for (InputLine input : getFirstLines()) {
                Matcher matcher = input.getPattern().matcher(line);
                if (matcher.find()) {
                    context.setLocation(new TmfLocation<Long>(rawPos));
                    context.raFile = raFile;
                    context.firstLineMatcher = matcher;
                    context.nextLineLocation = raFile.getFilePointer();
                    context.inputLine = input;
                    return context;
                }
            }
            rawPos = raFile.getFilePointer();
        }
        return context;
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        return context;
    } catch (IOException e) {
        e.printStackTrace();
        return context;
    }
}

Output:
 public TmfContext seekLocation(ITmfLocation<?> location) {
-    CustomTxtTraceContext context = new CustomTxtTraceContext(new TmfLocation<Long>((Long) null), ITmfContext.INITIAL_RANK);
-    if (!new File(getPath()).isFile()) {
+    CustomTxtTraceContext context = new CustomTxtTraceContext(NULL_LOCATION, ITmfContext.INITIAL_RANK);
+    if (NULL_LOCATION.equals(location) || !new File(getPath()).isFile()) {
         return context;


Input:
public void setHoleColorTransparent(boolean enable) {
    if (enable) {
        ((PieChartRenderer) mRenderer).getPaintHole().setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
    } else {
        ((PieChartRenderer) mRenderer).getPaintHole().setXfermode(null);
    }
}

Output:
     if (enable) {
-        ((PieChartRenderer) mRenderer).getPaintHole().setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
+        ((PieChartRenderer) mRenderer).getPaintHole().setColor(0xFFFFFFFF);
+        ((PieChartRenderer) mRenderer).getPaintHole().setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
     } else {


Input:
private static String readChars(ObjectInputStream in, int l) throws IOException {
    char[] r = new char[l];
    for (int i = 0; i < l; ++l) r[i] = in.readChar();
    return new String(r);
}

Output:
     char[] r = new char[l];
-    for (int i = 0; i < l; ++l) r[i] = in.readChar();
+    for (int i = 0; i < l; ++i) r[i] = in.readChar();
     return new String(r);


Input:
protected void drawBorders(CellArea container) {
    BoxStyle style = container.getBoxStyle();
    if (style == null)
        return;
    BorderInfo baseborderinfo = style.getLeftBorder();
    writeSingleBorder(LEFTBORDERLINE, baseborderinfo);
    BorderInfo currentborderinfo = style.getRightBorder();
    if (currentborderinfo != null) {
        writeSingleBorder(RIGHTBORDERLINE, currentborderinfo);
        baseborderinfo = currentborderinfo;
    } else {
        CellArea nextcell = ((RowArea) container.getParent()).getCell(currentCol + colspan);
        if (nextcell != null) {
            writeSingleBorder(RIGHTBORDERLINE, nextcell.getBoxStyle().getLeftBorder());
        }
    }
    writeSingleBorder(TOPBORDERLINE, style.getTopBorder());
    baseborderinfo = currentborderinfo;
    currentborderinfo = style.getBottomBorder();
    if (currentborderinfo != null) {
        writeSingleBorder(BOTTOMBORDERLINE, style.getBottomBorder());
    } else {
        IArea nextcontainer = container.getParent().getParent().getChild(currentRow + 1);
        RowArea ra = null;
        while (nextcontainer instanceof TableGroupArea) {
            nextcontainer = ((TableGroupArea) nextcontainer).getFirstChild();
        }
        ra = (RowArea) nextcontainer;
        CellArea belowCell = null;
        if (ra != null) {
            belowCell = ra.getCell(currentCol);
            if (belowCell != null) {
                writeSingleBorder(BOTTOMBORDERLINE, belowCell.getBoxStyle().getTopBorder());
            }
        }
    }
}

Output:
         return;
-    BorderInfo baseborderinfo = style.getLeftBorder();
-    writeSingleBorder(LEFTBORDERLINE, baseborderinfo);
-    BorderInfo currentborderinfo = style.getRightBorder();
+    BorderInfo currentborderinfo = style.getLeftBorder();
+    writeSingleBorder(LEFTBORDERLINE, currentborderinfo);
+    currentborderinfo = style.getRightBorder();
     if (currentborderinfo != null) {


Input:
protected void upgrade(String dbVersion, String currentVersion) {
    s_logger.info("String_Node_Str" + dbVersion + "String_Node_Str" + currentVersion);
    String trimmedDbVersion = Version.trimToPatch(dbVersion);
    String trimmedCurrentVersion = Version.trimToPatch(currentVersion);
    DbUpgrade[] upgrades = _upgradeMap.get(trimmedDbVersion);
    if (upgrades == null) {
        s_logger.error("String_Node_Str" + dbVersion + "String_Node_Str" + currentVersion);
        throw new CloudRuntimeException("String_Node_Str" + dbVersion + "String_Node_Str" + currentVersion);
    }
    if (Version.compare(trimmedCurrentVersion, upgrades[upgrades.length - 1].getUpgradedVersion()) != 0) {
        s_logger.error("String_Node_Str" + upgrades[upgrades.length - 1].getUpgradedVersion() + "String_Node_Str" + currentVersion);
        throw new CloudRuntimeException("String_Node_Str" + upgrades[upgrades.length - 1].getUpgradedVersion() + "String_Node_Str" + currentVersion);
    }
    boolean supportsRollingUpgrade = true;
    for (DbUpgrade upgrade : upgrades) {
        if (!upgrade.supportsRollingUpgrade()) {
            supportsRollingUpgrade = false;
            break;
        }
    }
    if (!supportsRollingUpgrade && ClusterManagerImpl.arePeersRunning(null)) {
        s_logger.error("String_Node_Str");
        throw new CloudRuntimeException("String_Node_Str");
    }
    for (DbUpgrade upgrade : upgrades) {
        s_logger.info("String_Node_Str" + upgrade.getClass().getSimpleName() + "String_Node_Str" + upgrade.getUpgradableVersionRange()[0] + "String_Node_Str" + upgrade.getUpgradableVersionRange()[1] + "String_Node_Str" + upgrade.getUpgradedVersion());
        Transaction txn = Transaction.open("String_Node_Str");
        txn.start();
        try {
            Connection conn;
            try {
                conn = txn.getConnection();
            } catch (SQLException e) {
                s_logger.error("String_Node_Str", e);
                throw new CloudRuntimeException("String_Node_Str", e);
            }
            File[] scripts = upgrade.getPrepareScripts();
            if (scripts != null) {
                for (File script : scripts) {
                    runScript(script);
                }
            }
            upgrade.performDataMigration(conn);
            boolean upgradeVersion = true;
            if (upgrade.getUpgradedVersion().equals("String_Node_Str")) {
                upgradeVersion = false;
            } else if (upgrade.getUpgradedVersion().equals("String_Node_Str")) {
                try {
                    PreparedStatement pstmt = conn.prepareStatement("String_Node_Str");
                    ResultSet rs = pstmt.executeQuery();
                    if (rs.next()) {
                        upgradeVersion = false;
                    }
                } catch (SQLException e) {
                    throw new CloudRuntimeException("String_Node_Str", e);
                }
            }
            if (upgradeVersion) {
                VersionVO version = new VersionVO(upgrade.getUpgradedVersion());
                _dao.persist(version);
            }
            txn.commit();
        } finally {
            txn.close();
        }
    }
    if (!ClusterManagerImpl.arePeersRunning(trimmedCurrentVersion)) {
        s_logger.info("String_Node_Str");
        for (DbUpgrade upgrade : upgrades) {
            s_logger.info("String_Node_Str" + upgrade.getClass().getSimpleName() + "String_Node_Str" + upgrade.getUpgradableVersionRange()[0] + "String_Node_Str" + upgrade.getUpgradableVersionRange()[1] + "String_Node_Str" + upgrade.getUpgradedVersion());
            VersionVO version = _dao.findByVersion(upgrade.getUpgradedVersion(), Step.Upgrade);
            if (version != null) {
                Transaction txn = Transaction.open("String_Node_Str");
                txn.start();
                try {
                    File[] scripts = upgrade.getCleanupScripts();
                    if (scripts != null) {
                        for (File script : scripts) {
                            runScript(script);
                        }
                    }
                    version.setStep(Step.Complete);
                    version.setUpdated(new Date());
                    _dao.update(version.getId(), version);
                    txn.commit();
                } finally {
                    txn.close();
                }
            }
        }
    }
}

Output:
         for (DbUpgrade upgrade : upgrades) {
-            s_logger.info("String_Node_Str" + upgrade.getClass().getSimpleName() + "String_Node_Str" + upgrade.getUpgradableVersionRange()[0] + "String_Node_Str" + upgrade.getUpgradableVersionRange()[1] + "String_Node_Str" + upgrade.getUpgradedVersion());
-            VersionVO version = _dao.findByVersion(upgrade.getUpgradedVersion(), Step.Upgrade);
-            if (version != null) {
-                Transaction txn = Transaction.open("String_Node_Str");
-                txn.start();
-                try {
-                    File[] scripts = upgrade.getCleanupScripts();
-                    if (scripts != null) {
-                        for (File script : scripts) {
-                            runScript(script);
+            String upgradedVerson = upgrade.getUpgradedVersion();
+            List<DbUpgrade> upgradeList = upgradedVersions.get(upgradedVerson);
+            if (upgradeList == null) {
+                upgradeList = new ArrayList<DbUpgrade>();
+            }
+            upgradeList.add(upgrade);
+            upgradedVersions.put(upgradedVerson, upgradeList);
+        }
+        for (String upgradedVersion : upgradedVersions.keySet()) {
+            List<DbUpgrade> versionUpgrades = upgradedVersions.get(upgradedVersion);
+            VersionVO version = _dao.findByVersion(upgradedVersion, Step.Upgrade);
+            s_logger.debug("String_Node_Str" + upgradedVersion + "String_Node_Str");
+            Transaction txn = Transaction.open("String_Node_Str");
+            try {
+                if (version != null) {
+                    for (DbUpgrade upgrade : versionUpgrades) {
+                        s_logger.info("String_Node_Str" + upgrade.getClass().getSimpleName() + "String_Node_Str" + upgrade.getUpgradableVersionRange()[0] + "String_Node_Str" + upgrade.getUpgradableVersionRange()[1] + "String_Node_Str" + upgrade.getUpgradedVersion());
+                        txn.start();
+                        File[] scripts = upgrade.getCleanupScripts();
+                        if (scripts != null) {
+                            for (File script : scripts) {
+                                runScript(script);
+                                s_logger.debug("String_Node_Str" + script.getAbsolutePath() + "String_Node_Str");
+                            }
                         }


Input:
private void processFlowMod(OFMessage msg, FloodlightContext cntx) {
    List<OFFlowMod> flows = this.mySlicer.allowedFlows((OFFlowMod) msg);
    if (flows.size() == 0) {
        log.info("String_Node_Str");
        this.sendError((OFMessage) msg);
        return;
    } else {
        log.info("String_Node_Str");
    }
    List<OFMessage> messages = new ArrayList<OFMessage>();
    Iterator<OFFlowMod> it = flows.iterator();
    while (it.hasNext()) {
        OFFlowMod flow = it.next();
        messages.add((OFMessage) msg);
        switch(flow.getCommand()) {
            case OFFlowMod.OFPFC_ADD:
                if (this.mySlicer.isGreaterThanMaxFlows(this.flowCount + 1)) {
                    log.warn("String_Node_Str" + this.mySwitch.getStringId() + "String_Node_Str" + this.mySlicer.getSliceName() + "String_Node_Str");
                    this.sendError((OFMessage) msg);
                    return;
                }
                this.updateFlowCount(1);
                break;
            case OFFlowMod.OFPFF_CHECK_OVERLAP:
                if (this.mySlicer.isGreaterThanMaxFlows(this.flowCount + 1)) {
                    log.warn("String_Node_Str" + this.mySwitch.getStringId() + "String_Node_Str" + this.mySlicer.getSliceName() + "String_Node_Str");
                    this.sendError((OFMessage) msg);
                    return;
                }
                this.updateFlowCount(1);
                break;
            case OFFlowMod.OFPFC_DELETE:
                this.updateFlowCount(-1);
                break;
            case OFFlowMod.OFPFC_DELETE_STRICT:
                this.updateFlowCount(-1);
                break;
            case OFFlowMod.OFPFC_MODIFY:
                break;
        }
    }
    mapXids(messages);
    try {
        mySwitch.write(messages, cntx);
    } catch (IOException e) {
        e.printStackTrace();
    }
    mySwitch.flush();
}

Output:
     if (flows.size() == 0) {
-        log.info("String_Node_Str");
+        log.error("String_Node_Str" + this.mySlicer.getSliceName() + "String_Node_Str" + this.mySwitch.getStringId() + "String_Node_Str" + ((OFFlowMod) msg).toString());
         this.sendError((OFMessage) msg);


Input:
public void readValues(DataRead dr) throws BasicException {
    m_sTicket = dr.getString(1);
    m_iLine = dr.getInt(2).intValue();
    productid = dr.getString(3);
    multiply = dr.getDouble(4);
    price = dr.getDouble(5);
    tax = new TaxInfo(dr.getString(6), dr.getString(7), dr.getString(8), dr.getString(9), dr.getString(10), dr.getDouble(11), dr.getBoolean(12), dr.getInt(13));
    attributes = new Properties();
    try {
        byte[] img = dr.getBytes(14);
        if (img != null) {
            attributes.loadFromXML(new ByteArrayInputStream(img));
        }
    } catch (IOException e) {
    }
}

Output:
     productid = dr.getString(3);
-    multiply = dr.getDouble(4);
-    price = dr.getDouble(5);
-    tax = new TaxInfo(dr.getString(6), dr.getString(7), dr.getString(8), dr.getString(9), dr.getString(10), dr.getDouble(11), dr.getBoolean(12), dr.getInt(13));
+    attsetinstid = dr.getString(4);
+    multiply = dr.getDouble(5);
+    price = dr.getDouble(6);
+    tax = new TaxInfo(dr.getString(7), dr.getString(8), dr.getString(9), dr.getString(10), dr.getString(11), dr.getDouble(12), dr.getBoolean(13), dr.getInt(14));
     attributes = new Properties();


Input:
public static List<IMigrationTask> findWorkspaceTaskByType(MigrationTaskType type, ProductVersion specifiedVersion) {
    List<IMigrationTask> wTasks = findTasksByCategory(MigrationTaskCategory.WORKSPACE);
    List<IMigrationTask> validTasks = new ArrayList<IMigrationTask>();
    for (IMigrationTask task : wTasks) {
        IWorkspaceMigrationTask wTask = (IWorkspaceMigrationTask) task;
        if (wTask.getMigrationTaskType() == type) {
            validTasks.add(task);
        }
    }
    if (specifiedVersion != null) {
        ProductVersion currentVersion = CorePlugin.getDefault().getProductVersion();
        return findValidTasks(specifiedVersion, currentVersion, validTasks);
    }
    return validTasks;
}

Output:
     for (IMigrationTask task : wTasks) {
-        IWorkspaceMigrationTask wTask = (IWorkspaceMigrationTask) task;
-        if (wTask.getMigrationTaskType() == type) {
+        if (task.getMigrationTaskType() == type) {
             validTasks.add(task);


Input:
protected void replayCheckpointsFromPreviousStage(final ExecutionGraph executionGraph) {
    final int currentStageIndex = executionGraph.getIndexOfCurrentExecutionStage();
    final ExecutionStage previousStage = executionGraph.getStage(currentStageIndex - 1);
    for (int i = 0; i < previousStage.getNumberOfOutputExecutionVertices(); ++i) {
        final ExecutionVertex vertex = previousStage.getOutputExecutionVertex(i);
        vertex.updateExecutionState(ExecutionState.ASSIGNED);
    }
    deployAssignedInputVertices(executionGraph);
}

Output:
     }
-    deployAssignedInputVertices(executionGraph);
+    deployAssignedVertices(verticesToBeReplayed);
 }


Input:
public static void sendChangeStatusBarIntent(final Activity activity) {
    boolean isSysApp = (Boolean) XposedHelpers.getAdditionalInstanceField(activity, "String_Node_Str");
    if (isSysApp) {
        Utils.log("String_Node_Str");
        return;
    }
    WindowType type = Utils.getWindowType(activity);
    switch(type) {
        case Normal:
            boolean needGetColorFromBackground = (Boolean) XposedHelpers.getAdditionalInstanceField(activity, "String_Node_Str");
            if (!needGetColorFromBackground)
                return;
            int delay = Constant.DELAY_GET_CACHEDRAWABLE;
            String activityName = activity.getLocalClassName();
            if (activityName.equals("String_Node_Str")) {
                delay = 800;
            } else if (activityName.equals("String_Node_Str") && activity.getPackageName().equals("String_Node_Str")) {
                delay = 300;
            }
            Handler handler = new Handler();
            handler.postDelayed(new Runnable() {
                public void run() {
                    Bitmap bitmap = Utils.getBitMapFromActivityBackground(activity);
                    int color = Color.BLACK;
                    boolean isdark = false;
                    boolean darkHandled = false;
                    if (bitmap != null) {
                        BitMapColor bitmapColor = Utils.getBitmapColor(bitmap);
                        if (bitmapColor.mType == Type.FLAT) {
                            Utils.log("String_Node_Str");
                            color = bitmapColor.Color;
                            XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", color);
                            isdark = Utils.getDarkMode(color);
                            XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", isdark);
                            darkHandled = true;
                        } else if (bitmapColor.mType == Type.GRADUAL) {
                            Utils.log("String_Node_Str");
                            color = bitmapColor.Color;
                            XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", color);
                            isdark = Utils.getDarkMode(color);
                            XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", isdark);
                            darkHandled = true;
                            if (!(Boolean) XposedHelpers.getAdditionalInstanceField(activity, "String_Node_Str")) {
                                Utils.resetPadding(activity, Constant.OFFEST_FOR_GRADUAL_ACTIVITY);
                                XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", true);
                            }
                        } else if (bitmapColor.mType == Type.PICTURE) {
                            Utils.log("String_Node_Str");
                            if (Settings.System.getInt(activity.getContentResolver(), SettingsActivity.KEY_PREF_FORCE_TINT, 0) == 1) {
                                color = bitmapColor.Color;
                                XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", color);
                                isdark = Utils.getDarkMode(color);
                                XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", isdark);
                                darkHandled = true;
                            }
                        }
                    }
                    Intent intent = new Intent(Constant.INTENT_CHANGE_STATUSBAR_COLOR);
                    intent.putExtra(Constant.STATUSBAR_BACKGROUND_COLOR, color);
                    intent.putExtra(Constant.IS_DARKMODE, isdark);
                    intent.putExtra(Constant.DARKMODE_HANDLE, darkHandled);
                    activity.sendBroadcast(intent);
                    XposedHelpers.setAdditionalInstanceField(activity, "String_Node_Str", false);
                }
            }, delay);
            break;
        case Translucent:
            boolean needGetDarkModeFromBackground = (Boolean) XposedHelpers.getAdditionalInstanceField(activity, "String_Node_Str");
            if (needGetDarkModeFromBackground) {
                Bitmap bitmap = Utils.getBitMapFromActivityBackground(activity);
                if (bitmap != null) {
                    BitMapColor bitmapColor = Utils.getBitmapColor(bitmap);
                    int color = bitmapColor.Color;
                    boolean darkMode = Utils.getDarkMode(color);
                    Intent intent = new Intent(Constant.INTENT_CHANGE_STATUSBAR_COLOR);
                    intent.putExtra(Constant.STATUSBAR_BACKGROUND_COLOR, Color.TRANSPARENT);
                    intent.putExtra(Constant.IS_DARKMODE, darkMode);
                    intent.putExtra(Constant.DARKMODE_HANDLE, true);
                    activity.sendBroadcast(intent);
                }
            }
            break;
        default:
            break;
    }
}

Output:
         case Translucent:
-            boolean needGetDarkModeFromBackground = (Boolean) XposedHelpers.getAdditionalInstanceField(activity, "String_Node_Str");
-            if (needGetDarkModeFromBackground) {
+            if (this.mDarkModeTranslucent == null) {
                 Bitmap bitmap = Utils.getBitMapFromActivityBackground(activity);


Input:
public void writeColumns(HTable htable, String columnFamily, String rowKey, List<Column> columns, EnhancedEntity e) throws IOException {
    Put p = new Put(Bytes.toBytes(rowKey));
    for (Column col : columns) {
        String qualifier = col.getName();
        try {
            PropertyAccessorHelper.getObject(e.getEntity(), col.getField());
            p.add(Bytes.toBytes(columnFamily), Bytes.toBytes(qualifier), PropertyAccessorHelper.get(e.getEntity(), col.getField()));
        } catch (PropertyAccessException e1) {
            throw new IOException(e1.getMessage());
        }
    }
    htable.put(p);
}

Output:
     Put p = new Put(Bytes.toBytes(rowKey));
-    for (Column col : columns) {
-        String qualifier = col.getName();
+    Object columnFamilyObj = null;
+    try {
+        columnFamilyObj = PropertyAccessorHelper.getObject(e.getEntity(), columnFamily);
+    } catch (PropertyAccessException e2) {
+        log.error("String_Node_Str" + columnFamily + "String_Node_Str");
+        return;
+    }
+    for (Column column : columns) {
+        String columnName = column.getName();
         try {


Input:
private synchronized void selectTagSet(final TagSet tagSet) {
    if (null == tagSet || !tagModel.getTagSetStructure().getTagSets().contains(tagSet))
        return;
    inputMap.clear();
    actionMap.clear();
    final KeyStroke abortKey = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
    final Action abortAction = new AbstractAction("String_Node_Str") {
        public void actionPerformed(final ActionEvent e) {
            abort();
        }
        private static final long serialVersionUID = 1L;
    };
    inputMap.put(abortKey, "String_Node_Str");
    actionMap.put("String_Node_Str", abortAction);
    final KeyStroke removeKey = KeyStroke.getKeyStroke(KeyEvent.VK_0, 0);
    final Action removeAction = new AbstractAction("String_Node_Str") {
        public void actionPerformed(final ActionEvent e) {
            removeLabels();
        }
        private static final long serialVersionUID = 1L;
    };
    inputMap.put(removeKey, "String_Node_Str");
    actionMap.put("String_Node_Str", removeAction);
    final KeyStroke clearAllKey = KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, KeyEvent.SHIFT_DOWN_MASK);
    final Action clearAllAction = new AbstractAction("String_Node_Str") {
        public void actionPerformed(final ActionEvent e) {
            clearAllLabels();
        }
        private static final long serialVersionUID = 1L;
    };
    inputMap.put(clearAllKey, "String_Node_Str");
    actionMap.put("String_Node_Str", clearAllAction);
    int i = 1;
    for (final Tag tag : tagSet.getTags()) {
        final String actionName = "String_Node_Str" + i;
        final KeyStroke takKeyStroke = KeyStroke.getKeyStroke((char) ('0' + i));
        final AbstractAction action = new AbstractAction(actionName) {
            public void actionPerformed(final ActionEvent e) {
                selectTag(tag);
            }
            private static final long serialVersionUID = 1L;
        };
        inputMap.put(takKeyStroke, actionName);
        actionMap.put(actionName, action);
        i++;
    }
    bindings.addInputMap("String_Node_Str", inputMap);
    bindings.addActionMap("String_Node_Str", actionMap);
    this.tagSet = tagSet;
    mode = Mode.PICK_TAG;
    panel.repaint();
}

Output:
     }
-    bindings.addInputMap("String_Node_Str", inputMap);
-    bindings.addActionMap("String_Node_Str", actionMap);
+    bindings.addInputMap(PICK_TAGS_MAP, inputMap);
+    bindings.addActionMap(PICK_TAGS_MAP, actionMap);
     this.tagSet = tagSet;


Input:
public Bundle perform(Bundle extras) throws Exception {
    String socialProvider = (String) extras.getSerializable(QBServiceConsts.EXTRA_SOCIAL_PROVIDER);
    String accessToken = (String) extras.getSerializable(QBServiceConsts.EXTRA_ACCESS_TOKEN);
    String accessTokenSecret = (String) extras.getSerializable(QBServiceConsts.EXTRA_ACCESS_TOKEN_SECRET);
    QBUser user = authHelper.login(socialProvider, accessToken, accessTokenSecret);
    if (user.getCustomData() == null) {
        CoreSharedHelper.getInstance().saveUsersImportInitialized(false);
        extras.putSerializable(QBServiceConsts.AUTH_ACTION_TYPE, QBServiceConsts.AUTH_TYPE_REGISTRATION);
        extras.putSerializable(QBServiceConsts.EXTRA_USER, getUserWithAvatar(user));
    } else {
        CoreSharedHelper.getInstance().saveUsersImportInitialized(true);
        extras.putSerializable(QBServiceConsts.AUTH_ACTION_TYPE, QBServiceConsts.AUTH_TYPE_LOGIN);
        extras.putSerializable(QBServiceConsts.EXTRA_USER, user);
    }
    return extras;
}

Output:
     QBUser user = authHelper.login(socialProvider, accessToken, accessTokenSecret);
-    if (user.getCustomData() == null) {
+    UserCustomData userCustomData = Utils.customDataToObject(user.getCustomData());
+    if (TextUtils.isEmpty(userCustomData.getAvatar_url())) {
         CoreSharedHelper.getInstance().saveUsersImportInitialized(false);


Input:
public void cdata(String value) {
    CDATASection cdata = document.createCDATASection(value);
    getNode().appendChild(cdata);
}

Output:
     CDATASection cdata = document.createCDATASection(value);
-    getNode().appendChild(cdata);
+    node.appendChild(cdata);
 }


Input:
private boolean removeNetwork(CallbackContext callbackContext, JSONArray data) {
    if (!validateData(data)) {
        return false;
    }
    String ssidToDisconnect = data.get(0);
    int networkIdToRemove = ssidToNetworkId(ssidToDisconnect);
    if (networkIdToRemove > 0) {
        wifiManager.removeNetwork(networkIdToRemove);
        wifiManager.saveConfiguration();
        callbackContext.success("String_Node_Str");
        return true;
    } else {
        callbackContext.error("String_Node_Str");
        return false;
    }
}

Output:
     }
-    String ssidToDisconnect = data.get(0);
+    String ssidToDisconnect = data.getString(0);
     int networkIdToRemove = ssidToNetworkId(ssidToDisconnect);


Input:
public int run(List<XValue> args) throws Exception {
    Options opts = new Options("String_Node_Str", SerializeOpts.getOptionDefs());
    opts.parse(args);
    args = opts.getRemainingArgs();
    mSerial = this.getSerializeOpts(opts);
    XValue vlines = getEnv().getVarValue("String_Node_Str");
    if (vlines != null)
        mLines = (int) vlines.toLong();
    mLines = opts.getOptInt("String_Node_Str", mLines);
    OutputStream stdout = getStdout().asOutputStream();
    if (args.size() > 0) {
        for (XValue arg : args) {
            File inf = getFile(arg);
            if (!inf.exists()) {
                this.printErr("String_Node_Str" + arg.toString());
                continue;
            }
            if (!inf.canRead()) {
                this.printErr("String_Node_Str" + arg.toString());
                continue;
            }
            InputStream in = new FileInputStream(inf);
            boolean bQuit = page(in, stdout);
            in.close();
            if (bQuit)
                break;
        }
    } else
        page(getStdin().asInputStream(getSerializeOpts()), stdout);
    return 0;
}

Output:
     mLines = opts.getOptInt("String_Node_Str", mLines);
-    OutputStream stdout = getStdout().asOutputStream();
+    OutputStream stdout = getStdout().asOutputStream(mSerial);
     if (args.size() > 0) {


Input:
private void writeRequiredJarFiles(final Kryo kryo, final Output out, final AbstractJobVertex[] jobVertices) throws IOException {
    final FileSystem fs = FileSystem.getLocalFileSystem();
    for (int i = 0; i < this.userJars.size(); i++) {
        if (!fs.exists(this.userJars.get(i))) {
            throw new IOException("String_Node_Str" + this.userJars.get(i));
        }
    }
    out.writeInt(this.userJars.size());
    for (int i = 0; i < this.userJars.size(); i++) {
        final Path jar = this.userJars.get(i);
        kryo.writeObject(out, jar);
        final FileStatus file = fs.getFileStatus(jar);
        out.writeLong(file.getLen());
        final FSDataInputStream inStream = fs.open(this.userJars.get(i));
        final byte[] buf = new byte[BUFFERSIZE];
        int read = inStream.read(buf, 0, buf.length);
        while (read > 0) {
            out.write(buf, 0, read);
            read = inStream.read(buf, 0, buf.length);
        }
    }
}

Output:
         final Path jar = this.userJars.get(i);
-        kryo.writeObject(out, jar);
+        jar.write(kryo, out);
         final FileStatus file = fs.getFileStatus(jar);


Input:
private void queueWork() {
    GlobalCoordinate gc = new GlobalCoordinate(getPos(), getWorld().provider.getDimension());
    if (endergenicsAdded.contains(gc)) {
        return;
    }
    EndergenicTileEntity endergenicWithInjector = findEndergenicWithInjector();
    if (endergenicWithInjector != null) {
        EndergenicTileEntity loop = endergenicWithInjector;
        while (loop != null) {
            addToQueue(loop, new GlobalCoordinate(loop.getPos(), getWorld().provider.getDimension()));
            loop = loop.getDestinationTE();
            if (loop == endergenicWithInjector) {
                loop = null;
            }
        }
    }
    addToQueue(this, gc);
}

Output:
     }
-    EndergenicTileEntity endergenicWithInjector = findEndergenicWithInjector();
+    EndergenicTileEntity endergenicWithInjector = findEndergenicWithInjector(getPos());
     if (endergenicWithInjector != null) {


Input:
public void setup(org.dspace.content.Bitstream bitstream, ServletContext servletContext, String expand, Context context) throws SQLException {
    List<String> expandFields = new ArrayList<String>();
    if (expand != null) {
        expandFields = Arrays.asList(expand.split("String_Node_Str"));
    }
    if (bitstream.getBundles() != null & bitstream.getBundles().size() >= 0) {
        if (bitstreamService.getParentObject(context, bitstream).getType() == Constants.ITEM) {
            bundleName = bitstream.getBundles().get(0).getName();
        }
    }
    description = bitstream.getDescription();
    format = bitstreamService.getFormatDescription(context, bitstream);
    sizeBytes = bitstream.getSize();
    String path = new DSpace().getRequestService().getCurrentRequest().getHttpServletRequest().getContextPath();
    retrieveLink = path + "String_Node_Str" + bitstream.getID() + "String_Node_Str";
    mimeType = bitstreamService.getFormat(context, bitstream).getMIMEType();
    sequenceId = bitstream.getSequenceID();
    CheckSum checkSum = new CheckSum();
    checkSum.setCheckSumAlgorith(bitstream.getChecksumAlgorithm());
    checkSum.setValue(bitstream.getChecksum());
    this.setCheckSum(checkSum);
    if (expandFields.contains("String_Node_Str") || expandFields.contains("String_Node_Str")) {
        parentObject = new DSpaceObject(bitstreamService.getParentObject(context, bitstream), servletContext);
    } else {
        this.addExpand("String_Node_Str");
    }
    if (expandFields.contains("String_Node_Str") || expandFields.contains("String_Node_Str")) {
        List<ResourcePolicy> tempPolicies = new ArrayList<ResourcePolicy>();
        List<Bundle> bundles = bitstream.getBundles();
        for (Bundle bundle : bundles) {
            List<org.dspace.authorize.ResourcePolicy> bitstreamsPolicies = bundleService.getBitstreamPolicies(context, bundle);
            for (org.dspace.authorize.ResourcePolicy policy : bitstreamsPolicies) {
                if (policy.getdSpaceObject().equals(bitstream)) {
                    tempPolicies.add(new ResourcePolicy(policy));
                }
            }
        }
        policies = tempPolicies.toArray(new ResourcePolicy[0]);
    } else {
        this.addExpand("String_Node_Str");
    }
    if (!expandFields.contains("String_Node_Str")) {
        this.addExpand("String_Node_Str");
    }
}

Output:
     }
-    if (bitstream.getBundles() != null & bitstream.getBundles().size() >= 0) {
+    if (bitstream.getBundles() != null && !bitstream.getBundles().isEmpty()) {
         if (bitstreamService.getParentObject(context, bitstream).getType() == Constants.ITEM) {


Input:
private void initPeerScan(Connection conn) {
    Date cutTime = DateUtil.currentGMTTime();
    List<ManagementServerHostVO> inactiveList = _mshostDao.getInactiveList(conn, new Date(cutTime.getTime() - heartbeatThreshold));
    if (inactiveList.size() > 0) {
        this.queueNotification(new ClusterManagerMessage(ClusterManagerMessage.MessageType.nodeRemoved, inactiveList));
    }
}

Output:
     Date cutTime = DateUtil.currentGMTTime();
-    List<ManagementServerHostVO> inactiveList = _mshostDao.getInactiveList(conn, new Date(cutTime.getTime() - heartbeatThreshold));
+    List<ManagementServerHostVO> inactiveList = _mshostDao.getInactiveList(new Date(cutTime.getTime() - heartbeatThreshold));
     if (inactiveList.size() > 0) {


Input:
public String getDirection() {
    return null;
}

Output:
 public String getDirection() {
-    return null;
+    return getCssText(STYLE_DIRECTION);
 }


Input:
private void prepareModelFromOutput(List<XMLFileNode> root, List<XMLFileNode> loop, List<XMLFileNode> group) {
    TreeNode rootNode = null;
    TreeNode lastTreeNode = parentNode;
    TreeNode temp = null;
    TreeNode mainNode = null;
    String mainPath = null;
    String lastXmlPath = null;
    for (int i = 0; i < root.size(); i++) {
        XMLFileNode node = (XMLFileNode) root.get(i);
        String newPath = node.getXMLPath();
        String type = node.getType();
        if (node.getAttribute().equals("String_Node_Str")) {
            temp = createModel();
            temp.setName(newPath);
            temp.setDefaultValue(node.getDefaultValue());
            temp.setNodeType(NodeType.ATTRIBUT);
            temp.setXpath(XmlMapUtil.getXPath(lastTreeNode.getXpath(), temp.getName(), temp.getNodeType()));
            lastTreeNode.getChildren().add(temp);
        } else if (node.getAttribute().equals("String_Node_Str")) {
            temp = createModel();
            temp.setName(newPath);
            temp.setDefaultValue(node.getDefaultValue());
            temp.setNodeType(NodeType.NAME_SPACE);
            temp.setXpath(XmlMapUtil.getXPath(lastTreeNode.getXpath(), temp.getName(), temp.getNodeType()));
            lastTreeNode.getChildren().add(temp);
        } else {
            temp = this.addElement(lastTreeNode, lastXmlPath, node);
            if (rootNode == null) {
                rootNode = temp;
            }
            if (node.getAttribute().equals("String_Node_Str")) {
                temp.setMain(true);
                mainNode = temp;
                mainPath = newPath;
            }
            lastTreeNode = temp;
            lastXmlPath = newPath;
        }
        temp.setType(type);
    }
    lastTreeNode = mainNode;
    lastXmlPath = mainPath;
    List<TreeNode> groupElements = new ArrayList<TreeNode>();
    boolean isFirst = true;
    for (int i = 0; i < group.size(); i++) {
        XMLFileNode node = (XMLFileNode) group.get(i);
        String newPath = node.getXMLPath();
        String type = node.getType();
        if (node.getAttribute().equals("String_Node_Str")) {
            temp = createModel();
            temp.setName(newPath);
            temp.setDefaultValue(node.getDefaultValue());
            temp.setNodeType(NodeType.ATTRIBUT);
            temp.setXpath(XmlMapUtil.getXPath(lastTreeNode.getXpath(), temp.getName(), temp.getNodeType()));
            lastTreeNode.getChildren().add(temp);
        } else if (node.getAttribute().equals("String_Node_Str")) {
            temp = createModel();
            temp.setName(newPath);
            temp.setDefaultValue(node.getDefaultValue());
            temp.setNodeType(NodeType.NAME_SPACE);
            temp.setXpath(XmlMapUtil.getXPath(lastTreeNode.getXpath(), temp.getName(), temp.getNodeType()));
            lastTreeNode.getChildren().add(temp);
        } else {
            temp = this.addElement(lastTreeNode, lastXmlPath, node);
            if (node.getAttribute().equals("String_Node_Str")) {
                temp.setMain(true);
                mainNode = temp;
                mainPath = newPath;
            }
            if (isFirst) {
                temp.setGroup(true);
                isFirst = false;
            }
            lastTreeNode = temp;
            lastXmlPath = newPath;
            groupElements.add(temp);
        }
        temp.setType(type);
    }
    lastTreeNode = mainNode;
    lastXmlPath = mainPath;
    isFirst = true;
    TreeNode loopElement = null;
    for (int i = 0; i < loop.size(); i++) {
        XMLFileNode node = (XMLFileNode) loop.get(i);
        String newPath = node.getXMLPath();
        String type = node.getType();
        if (node.getAttribute().equals("String_Node_Str")) {
            temp = createModel();
            temp.setName(newPath);
            temp.setDefaultValue(node.getDefaultValue());
            temp.setNodeType(NodeType.ATTRIBUT);
            temp.setXpath(XmlMapUtil.getXPath(lastTreeNode.getXpath(), temp.getName(), temp.getNodeType()));
            lastTreeNode.getChildren().add(temp);
        } else if (node.getAttribute().equals("String_Node_Str")) {
            temp = createModel();
            temp.setName(newPath);
            temp.setDefaultValue(node.getDefaultValue());
            temp.setNodeType(NodeType.NAME_SPACE);
            temp.setXpath(XmlMapUtil.getXPath(lastTreeNode.getXpath(), temp.getName(), temp.getNodeType()));
            lastTreeNode.getChildren().add(temp);
        } else {
            temp = this.addElement(lastTreeNode, lastXmlPath, node);
            if (node.getAttribute().equals("String_Node_Str")) {
                temp.setMain(true);
                mainNode = temp;
                mainPath = newPath;
            }
            if (isFirst) {
                temp.setLoop(true);
                loopElement = temp;
                isFirst = false;
            }
            lastTreeNode = temp;
            lastXmlPath = newPath;
        }
        temp.setType(type);
    }
    if (loopElement != null && !groupElements.isEmpty()) {
        fillGroup(loopElement, groupElements);
    }
    if (rootNode != null) {
        parentNode.getChildren().add(rootNode);
    }
}

Output:
     TreeNode temp = null;
-    TreeNode mainNode = null;
+    TreeNode mainNode = parentNode;
     String mainPath = null;


Input:
private void setUpSharesContent() {
    serverClient.getShares();
}

Output:
 private void setUpSharesContent() {
-    serverClient.getShares();
+    if (serverClient.isConnected()) {
+        serverClient.getShares();
+    } else {
+        showSharesError();
+    }
 }


Input:
public ConstraintMoney[] divideAndRemainder(double divisor) {
    return new ConstraintMoney(amount.divideAndRemainder(divisor), predicate);
}

Output:
 public ConstraintMoney[] divideAndRemainder(double divisor) {
-    return new ConstraintMoney(amount.divideAndRemainder(divisor), predicate);
+    MonetaryAmount<?>[] result = this.amount.divideAndRemainder(divisor);
+    return new ConstraintMoney[] { new ConstraintMoney(result[0], predicate), new ConstraintMoney(result[1], predicate) };
 }


Input:
public int getPropertyCount(ObjectProperty property) {
    String query = String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str", property.getName());
    ResultSet rs = executeSelectQuery(query);
    int cnt = rs.next().get(rs.getResultVars().get(0)).asLiteral().getInt();
    return cnt;
}

Output:
 public int getPropertyCount(ObjectProperty property) {
-    String query = String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str", property.getName());
+    String query = String.format("String_Node_Str", property.getName());
     ResultSet rs = executeSelectQuery(query);


Input:
private static Endpoint checkForDataset(Endpoint ep, String datasetId, CloseableHttpClient httpClient) {
    log.debug("String_Node_Str", datasetId, ep);
    HttpGet getRequest = null;
    try {
        getRequest = new HttpGet("String_Node_Str" + datasetId);
        CloseableHttpResponse response = httpClient.execute(getRequest);
        if (response.getStatusLine().getStatusCode() != 200) {
            throw new RuntimeException("String_Node_Str" + response.getStatusLine().getStatusCode());
        }
        String respString = EntityUtils.toString(response.getEntity());
        response.close();
        JsonFactory factory = new JsonFactory();
        ObjectMapper mapper = new ObjectMapper(factory);
        JsonNode rootNode = mapper.readTree(respString);
        String ckan_url = rootNode.findPath("String_Node_Str").getTextValue();
        String title = rootNode.findPath("String_Node_Str").getTextValue().trim();
        Dataset d = new Dataset();
        d.setLabel(title);
        d.setUri(ckan_url);
        List<Dataset> l = ep.getDatasets();
        l.add(d);
        ep.setDatasets(l);
        return ep;
    } catch (Exception e) {
        log.warn("String_Node_Str", e);
    }
    return ep;
}

Output:
         String ckan_url = rootNode.findPath("String_Node_Str").getTextValue();
-        String title = rootNode.findPath("String_Node_Str").getTextValue().trim();
+        List<JsonNode> titles = rootNode.findValues("String_Node_Str");
+        String title = null;
+        for (JsonNode s : titles) {
+            if (!s.toString().contains("String_Node_Str"))
+                title = s.asText();
+        }
         Dataset d = new Dataset();


Input:
public float getAxisHeight() {
    return viewFrustum.getHeight() - 2 * XYAXISDISTANCE;
}

Output:
 public float getAxisHeight() {
-    return viewFrustum.getHeight() - 2 * XYAXISDISTANCE;
+    return getRenderHeight() - 2 * XYAXISDISTANCE;
 }


Input:
private void writeUndeclaredExt(RuntimeResourceDefinition theResDef, IResource theResource, JsonGenerator theEventWriter, ExtensionDt ext) throws IOException {
    theEventWriter.writeStartObject();
    theEventWriter.write("String_Node_Str", ext.getUrl().getValue());
    IElement value = ext.getValue();
    if (value == null && ext.getAllUndeclaredExtensions().isEmpty()) {
        theEventWriter.writeNull();
    } else if (value == null) {
        theEventWriter.writeStartArray("String_Node_Str");
        for (ExtensionDt next : ext.getUndeclaredExtensions()) {
            writeUndeclaredExt(theResDef, theResource, theEventWriter, next);
        }
        theEventWriter.writeEnd();
    } else {
        RuntimeChildUndeclaredExtensionDefinition extDef = myContext.getRuntimeChildUndeclaredExtensionDefinition();
        String childName = extDef.getChildNameByDatatype(value.getClass());
        if (childName == null) {
            throw new ConfigurationException("String_Node_Str" + value.getClass().getCanonicalName());
        }
        BaseRuntimeElementDefinition<?> childDef = extDef.getChildElementDefinitionByDatatype(value.getClass());
        encodeChildElementToStreamWriter(theResDef, theResource, theEventWriter, value, childDef, childName);
    }
    theEventWriter.writeEnd();
}

Output:
     if (value == null && ext.getAllUndeclaredExtensions().isEmpty()) {
-        theEventWriter.writeNull();
+        ourLog.debug("String_Node_Str", ext.getUrl().getValue());
     } else if (value == null) {


Input:
private void assertFailure(Injector injector, Class clazz) {
    try {
        injector.getBinding(clazz);
        fail("String_Node_Str" + clazz);
    } catch (ConfigurationException expected) {
        List<Object> sources = Iterables.getOnlyElement(expected.getErrorMessages()).getSources();
        assertEquals(Key.get(clazz).toString(), sources.get(0).toString());
        Asserts.assertContains(sources.get(sources.size() - 1).toString(), Key.get(InvalidInterface.class).toString());
    }
}

Output:
     } catch (ConfigurationException expected) {
-        List<Object> sources = Iterables.getOnlyElement(expected.getErrorMessages()).getSources();
+        Message msg = Iterables.getOnlyElement(expected.getErrorMessages());
+        assertEquals("String_Node_Str" + InvalidInterface.class.getName() + "String_Node_Str", msg.getMessage());
+        List<Object> sources = msg.getSources();
         assertEquals(Key.get(clazz).toString(), sources.get(0).toString());


Input:
public static String urlEncode(String str) {
    if (StringUtils.isBlank(str)) {
        return str;
    }
    String result = str;
    try {
        String decodedURL = URLDecoder.decode(str, "String_Node_Str");
        URL url = new URL(decodedURL);
        URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef());
        result = uri.toASCIIString();
    } catch (Exception e) {
        logger.error(e.getMessage());
    }
    return result;
}

Output:
     try {
-        String decodedURL = URLDecoder.decode(str, "String_Node_Str");
-        URL url = new URL(decodedURL);
-        URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef());
+        String decodedURL = URLDecoder.decode(str, CHAR_SET_UTF8);
+        URI uri = new URI(decodedURL);
         result = uri.toASCIIString();


Input:
public void openPhone() {
    if (!Main.game.isStarted() || !Main.game.isInNewWorld()) {
        return;
    }
    if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.PHONE)
        Main.game.restoreSavedContent();
    else if (!Main.game.getCurrentDialogueNode().isOptionsDisabled()) {
        if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.NORMAL || Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.SLAVERY_MANAGEMENT)
            Main.game.saveDialogueNode();
        Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", PhoneDialogue.MENU));
    }
}

Output:
     }
-    if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.PHONE)
+    if (Main.game.getCurrentDialogueNode().getDialogueNodeType() == DialogueNodeType.PHONE)
         Main.game.restoreSavedContent();


Input:
public void stop(BundleContext context) throws Exception {
    plugin = null;
    super.stop(context);
    IPath location = Platform.getStateLocation(context.getBundle());
    File store = location.append(STORE_NAME).toFile();
    if (store != null) {
        try {
            ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream(store));
            stream.writeObject(this.store);
        } catch (IOException e) {
            getLog().log(new Status(IStatus.ERROR, PLUGIN_ID, "String_Node_Str", e));
        }
    }
    this.store.dispose();
}

Output:
         try {
-            ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream(store));
+            stream = new ObjectOutputStream(new FileOutputStream(store));
             stream.writeObject(this.store);


Input:
public static JExpression createDefaultConstructorInstantiation(SourceInfo info, JClassType type) {
    JConstructor noArgCtor = (JConstructor) FluentIterable.from(type.getMethods()).firstMatch(new Predicate<JMethod>() {
        public boolean apply(JMethod method) {
            return method instanceof JConstructor && method.getOriginalParamTypes().size() == 0;
        }
    }).get();
    if (noArgCtor == null) {
        return null;
    }
    return new JNewInstance(info, noArgCtor);
}

Output:
         }
-    }).get();
+    }).orNull();
     if (noArgCtor == null) {


Input:
private final void appearAt(IBuildingsGrid grid, ShortPoint2D pos) {
    this.state = STATE_CONSTRUCTED;
    positionAt(grid, pos);
    if (this.pos != null) {
        grid.setBlocked(getBuildingArea(), true);
        finishConstruction();
    }
    appearedEvent();
}

Output:
     this.state = STATE_CONSTRUCTED;
-    positionAt(grid, pos);
-    if (this.pos != null) {
+    boolean itWorked = positionAt(grid, pos);
+    if (itWorked) {
         grid.setBlocked(getBuildingArea(), true);


Input:
public void run() {
    long beforeTime = System.nanoTime();
    long overSleepTime = 0L;
    int noDelays = 0;
    final int NO_DELAYS_PER_YIELD = 15;
    if (sketch == null)
        return;
    sketch.start();
    while ((Thread.currentThread() == thread) && (sketch != null && !sketch.finished)) {
        checkPause();
        callDraw();
        long afterTime = System.nanoTime();
        long timeDiff = afterTime - beforeTime;
        long sleepTime = (frameRatePeriod - timeDiff) - overSleepTime;
        if (sleepTime > 0) {
            try {
                Thread.sleep(sleepTime / 1000000L, (int) (sleepTime % 1000000L));
                noDelays = 0;
            } catch (InterruptedException ex) {
            }
            overSleepTime = (System.nanoTime() - afterTime) - sleepTime;
        } else {
            overSleepTime = 0L;
            noDelays++;
            if (noDelays > NO_DELAYS_PER_YIELD) {
                Thread.yield();
                noDelays = 0;
            }
        }
        beforeTime = System.nanoTime();
    }
    if (killProcAfterStop)
        finish();
}

Output:
     }
-    if (killProcAfterStop)
-        finish();
+    finish();
 }