Input:
public final void parameters(final String[] args, final SnipeData v) {
    if (args[1].equalsIgnoreCase("String_Node_Str")) {
        v.sendMessage(ChatColor.GOLD + "String_Node_Str");
        String _availableBiomes = "String_Node_Str";
        for (final org.bukkit.block.Biome _biome : org.bukkit.block.Biome.values()) {
            if (_availableBiomes.isEmpty()) {
                _availableBiomes = ChatColor.DARK_GREEN + _biome.name();
                continue;
            }
            _availableBiomes += ChatColor.RED + "String_Node_Str" + ChatColor.DARK_GREEN + _biome.name();
        }
        v.sendMessage(ChatColor.DARK_BLUE + "String_Node_Str" + _availableBiomes);
    } else {
        String biomeName = args[1];
        for (int i = 1; i < args.length; i++) {
            biomeName += "String_Node_Str" + args[i];
        }
        for (final org.bukkit.block.Biome _bio : org.bukkit.block.Biome.values()) {
            if (_bio.name().equalsIgnoreCase(biomeName)) {
                this.selectedBiome = _bio;
                break;
            }
        }
        v.sendMessage(ChatColor.GOLD + "String_Node_Str" + ChatColor.DARK_GREEN + this.selectedBiome.name());
    }
}

Output:
         String biomeName = args[1];
-        for (int i = 1; i < args.length; i++) {
+        for (int i = 2; i < args.length; i++) {
             biomeName += "String_Node_Str" + args[i];


Input:
void addProbes(boolean globalAccessLoggingEnabled) {
    List<String> listenerList = StringUtils.parseStringList(vsBean.getNetworkListeners(), "String_Node_Str");
    String[] listeners = (listenerList != null) ? listenerList.toArray(new String[listenerList.size()]) : new String[0];
    List<NetworkListener> networkListeners = new ArrayList<NetworkListener>();
    for (String listener : listeners) {
        for (NetworkListener networkListener : serverConfig.getNetworkConfig().getNetworkListeners().getNetworkListener()) {
            if (networkListener.getName().equals(listener)) {
                networkListeners.add(networkListener);
            }
        }
    }
    for (final NetworkListener listener : networkListeners) {
        try {
            final GrizzlyProxy proxy = (GrizzlyProxy) grizzlyService.lookupNetworkProxy(listener);
            if (proxy != null) {
                GenericGrizzlyListener grizzlyListener = (GenericGrizzlyListener) proxy.getUnderlyingListener();
                List<HttpCodecFilter> codecFilters = grizzlyListener.getFilters(HttpCodecFilter.class);
                if (codecFilters == null || codecFilters.isEmpty()) {
                    if (grizzlyListener.isAjpEnabled()) {
                        continue;
                    }
                    _logger.log(Level.SEVERE, LogFacade.CODE_FILTERS_NULL, new Object[] { listener.getName(), codecFilters });
                } else {
                    for (HttpCodecFilter codecFilter : codecFilters) {
                        if (codecFilter.getMonitoringConfig().getProbes().length == 0) {
                            httpProbe = new HttpProbeImpl(listener, isAccessLoggingEnabled(globalAccessLoggingEnabled));
                            codecFilter.getMonitoringConfig().addProbes(httpProbe);
                        }
                    }
                }
                grizzlyListener.getTransport().getConnectionMonitoringConfig().addProbes(new ConnectionProbe.Adapter() {
                    RequestProbeProvider requestProbeProvider = webContainer.getRequestProbeProvider();
                    public void onReadEvent(Connection connection, Buffer data, int size) {
                        if (requestProbeProvider != null) {
                            requestProbeProvider.dataReceivedEvent(size);
                        }
                    }
                    public void onWriteEvent(Connection connection, Buffer data, long size) {
                        if (requestProbeProvider != null) {
                            requestProbeProvider.dataSentEvent(size);
                        }
                    }
                });
            } else {
                if (Boolean.parseBoolean(listener.getEnabled())) {
                    _logger.log(Level.SEVERE, LogFacade.PROXY_NULL, new Object[] { listener.getName() });
                }
            }
        } catch (Exception ex) {
            _logger.log(Level.SEVERE, LogFacade.ADD_HTTP_PROBES_ERROR, ex);
        }
    }
}

Output:
 void addProbes(boolean globalAccessLoggingEnabled) {
-    List<String> listenerList = StringUtils.parseStringList(vsBean.getNetworkListeners(), "String_Node_Str");
-    String[] listeners = (listenerList != null) ? listenerList.toArray(new String[listenerList.size()]) : new String[0];
-    List<NetworkListener> networkListeners = new ArrayList<NetworkListener>();
-    for (String listener : listeners) {
-        for (NetworkListener networkListener : serverConfig.getNetworkConfig().getNetworkListeners().getNetworkListener()) {
-            if (networkListener.getName().equals(listener)) {
-                networkListeners.add(networkListener);
-            }
-        }
-    }
-    for (final NetworkListener listener : networkListeners) {
+    for (final NetworkListener listener : getGrizzlyNetworkListeners()) {
         try {


Input:
public void execute() {
    propagateInput();
    if (!oldMetaDataList.isEmpty() && !newMetaDataList.isEmpty() && !oldMetaDataList.get(0).sameMetadataAs(newMetaDataList.get(0))) {
        node.setPropertyValue(EParameterName.SCHEMA_TYPE.getName(), EmfComponent.BUILTIN);
    }
    metadataOutputChanges.clear();
    List<IConnection> initTraceList = new ArrayList<IConnection>();
    for (IConnection connection : node.getOutgoingConnections()) {
        if (connection.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA)) {
            IODataComponent dataComponent = inAndOut.getDataComponent(connection);
            if (!connection.getMetadataTable().sameMetadataAs(dataComponent.getTable())) {
                IMetadataTable table = connection.getMetadataTable();
                if (table == null || table.getListColumns().isEmpty()) {
                    initTraceList.add(connection);
                }
                INode connTar = connection.getTarget();
                boolean openDialog = false;
                Map<String, Boolean> jobletMap = new HashMap<String, Boolean>();
                if (isForTemlate()) {
                    openDialog = true;
                } else {
                    openDialog = getPropagate(connection, jobletMap);
                }
                if (openDialog) {
                    IElementParameter schemaParam = null;
                    if (connection != null) {
                        IMetadataTable connTable = connection.getMetadataTable();
                        IMetadataTable dataTable = dataComponent.getTable();
                        for (IElementParameter param : ((Node) connection.getTarget()).getElementParameters()) {
                            if (param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE) && param.getContext().equals(connection.getTarget().getConnectorFromName(connection.getConnectorName()).getBaseSchema())) {
                                schemaParam = param;
                                break;
                            }
                        }
                        if (schemaParam != null) {
                            ChangeMetadataCommand cmd = new ChangeMetadataCommand(connection.getTarget(), schemaParam, connTable, dataTable);
                            cmd.execute(true);
                            metadataOutputChanges.add(cmd);
                        }
                        for (IElementParameter param : ((Node) connection.getSource()).getElementParameters()) {
                            if (param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE) && param.getContext().equals(connection.getSource().getConnectorFromName(connection.getConnectorName()).getBaseSchema())) {
                                schemaParam = param;
                                break;
                            }
                        }
                        if (schemaParam != null) {
                            ChangeMetadataCommand cmd = new ChangeMetadataCommand(connection.getSource(), schemaParam, connTable, dataTable);
                            cmd.execute(true);
                            metadataOutputChanges.add(cmd);
                        }
                        if (((Node) connTar).isJoblet()) {
                            IElementParameter param = connTar.getElementParameter(connection.getTarget().getUniqueName());
                            if (param != null) {
                                IMetadataTable originaleOutputTable = connTar.getMetadataFromConnector(param.getContext());
                                if (originaleOutputTable != null) {
                                    MetadataToolHelper.copyTable(dataTable, originaleOutputTable);
                                }
                            }
                        } else if (((Node) connTar).getJobletNode() != null) {
                            IElementParameter param = ((Node) connTar).getJobletNode().getElementParameter(connection.getTarget().getUniqueName());
                            if (param != null) {
                                IMetadataTable originaleOutputTable = ((Node) connTar).getJobletNode().getMetadataFromConnector(param.getContext());
                                if (originaleOutputTable != null) {
                                    MetadataToolHelper.copyTable(dataTable, originaleOutputTable);
                                }
                            }
                        }
                    }
                    if (((Node) connTar).isJoblet()) {
                        changeCollapsedState(true, jobletMap, connTar);
                    }
                } else {
                    final Node target = (Node) connection.getTarget();
                    if (target != null && target.getExternalNode() != null) {
                        if (GlobalServiceRegister.getDefault().isServiceRegistered(IXmlMapService.class)) {
                            final IXmlMapService service = (IXmlMapService) GlobalServiceRegister.getDefault().getService(IXmlMapService.class);
                            if (service.isXmlMapComponent(target.getExternalNode())) {
                                IODataComponent output = new IODataComponent(connection, dataComponent.getTable());
                                target.metadataInputChanged(output, connection.getUniqueName());
                            }
                        }
                    }
                }
            }
            if (connection instanceof Connection) {
                ((Connection) connection).updateName();
            }
        }
    }
    node.setExternalData(newExternalData);
    List<IMetadataTable> cloneNewMetadata = new ArrayList<IMetadataTable>();
    if (newMetaDataList != null) {
        for (IMetadataTable t : newMetaDataList) {
            cloneNewMetadata.add(t.clone(true));
        }
    }
    node.setMetadataList(cloneNewMetadata);
    for (IConnection conn : initTraceList) {
        if (conn instanceof Connection) {
            ((Connection) conn).initTraceParamters();
        }
    }
    for (Connection connection : connectionsToDelete.keySet()) {
        connection.disconnect();
        INode prevNode = connection.getSource();
        INodeConnector nodeConnectorSource, nodeConnectorTarget;
        nodeConnectorSource = prevNode.getConnectorFromType(connection.getLineStyle());
        nodeConnectorSource.setCurLinkNbOutput(nodeConnectorSource.getCurLinkNbOutput() - 1);
        INode nextNode = connection.getTarget();
        nodeConnectorTarget = nextNode.getConnectorFromType(connection.getLineStyle());
        nodeConnectorTarget.setCurLinkNbInput(nodeConnectorTarget.getCurLinkNbInput() - 1);
        inAndOut.getOuputs().remove(connectionsToDelete.get(connection));
    }
    ((Process) node.getProcess()).checkProcess();
    if (!isMetaLanguage) {
        refreshCodeView();
        ComponentSettings.switchToCurComponentSettingsView();
    }
}

Output:
             IODataComponent dataComponent = inAndOut.getDataComponent(connection);
-            if (!connection.getMetadataTable().sameMetadataAs(dataComponent.getTable())) {
+            if (hasChanged || !connection.getMetadataTable().sameMetadataAs(dataComponent.getTable())) {
                 IMetadataTable table = connection.getMetadataTable();


Input:
public void testMultipleRecords() {
    final Properties destinationProperties = new Properties();
    destinationProperties.setProperty("String_Node_Str", csvFile.getAbsolutePath());
    prepareFile(csvFile);
    try {
        final CsvDestination destination = (CsvDestination) ObjectFactory.summonInstance(CsvDestination.class.getName(), destinationProperties);
        final Measurement measurement = new Measurement(42, 123456000, ITERATION - 1);
        measurement.set(new Quantity<Double>(1111.11, "String_Node_Str"));
        measurement.set("String_Node_Str", new Quantity<Double>(222.22, "String_Node_Str"));
        final Measurement measurement2 = new Measurement(43, 123457000, ITERATION);
        measurement2.set(new Quantity<Double>(2222.22, "String_Node_Str"));
        measurement2.set("String_Node_Str", new Quantity<Double>(333.33, "String_Node_Str"));
        destination.open();
        destination.report(measurement);
        Thread.sleep(100);
        destination.report(measurement2);
        destination.close();
        assertCSVFileContent(csvFile, "String_Node_Str" + Measurement.DEFAULT_RESULT + "String_Node_Str" + ITERATION + "String_Node_Str" + (ITERATION + 1) + "String_Node_Str");
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException | InvocationTargetException | ReportingException | InterruptedException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
}

Output:
         final Measurement measurement = new Measurement(42, 123456000, ITERATION - 1);
-        measurement.set(new Quantity<Double>(1111.11, "String_Node_Str"));
-        measurement.set("String_Node_Str", new Quantity<Double>(222.22, "String_Node_Str"));
+        measurement.set(new Quantity<>(1111.11, "String_Node_Str"));
+        measurement.set("String_Node_Str", new Quantity<>(222.22, "String_Node_Str"));
         final Measurement measurement2 = new Measurement(43, 123457000, ITERATION);


Input:
public JsonElement serialize(WrappedStack wrappedStack, Type type, JsonSerializationContext context) {
    JsonObject jsonWrappedStack = new JsonObject();
    Gson gsonWrappedStack = new Gson();
    jsonWrappedStack.addProperty("String_Node_Str", wrappedStack.className);
    jsonWrappedStack.addProperty("String_Node_Str", wrappedStack.stackSize);
    if (wrappedStack.wrappedStack instanceof ItemStack) {
        Gson gsonItemStackSerializer = (new GsonBuilder()).registerTypeAdapter(ItemStack.class, new GsonItemStackSerialization()).create();
        jsonWrappedStack.add("String_Node_Str", gsonItemStackSerializer.toJsonTree(wrappedStack.wrappedStack, ItemStack.class));
    } else if (wrappedStack.wrappedStack instanceof OreStack) {
        jsonWrappedStack.add("String_Node_Str", gsonWrappedStack.toJsonTree(wrappedStack.wrappedStack, OreStack.class));
    } else if (wrappedStack.wrappedStack instanceof EnergyStack) {
        jsonWrappedStack.add("String_Node_Str", gsonWrappedStack.toJsonTree(wrappedStack.wrappedStack, EnergyStack.class));
    } else if (wrappedStack.wrappedStack instanceof FluidStack) {
        jsonWrappedStack.add("String_Node_Str", gsonWrappedStack.toJsonTree(wrappedStack.wrappedStack, FluidStack.class));
    }
    return jsonWrappedStack;
}

Output:
     if (wrappedStack.wrappedStack instanceof ItemStack) {
-        Gson gsonItemStackSerializer = (new GsonBuilder()).registerTypeAdapter(ItemStack.class, new GsonItemStackSerialization()).create();
-        jsonWrappedStack.add("String_Node_Str", gsonItemStackSerializer.toJsonTree(wrappedStack.wrappedStack, ItemStack.class));
+        jsonWrappedStack.add("String_Node_Str", gsonWrappedStack.toJsonTree(wrappedStack.wrappedStack, ItemStack.class));
     } else if (wrappedStack.wrappedStack instanceof OreStack) {


Input:
public static List<SootField> getAllFields(SootClass sc) {
    List<SootField> allFields = new ArrayList<SootField>();
    Iterator fieldsIt = sc.getFields().iterator();
    while (fieldsIt.hasNext()) {
        SootField field = (SootField) fieldsIt.next();
        allFields.add(field);
    }
    SootClass superclass = sc;
    if (superclass.hasSuperclass())
        superclass = superclass.getSuperclass();
    while (superclass.hasSuperclass()) {
        Iterator scFieldsIt = superclass.getFields().iterator();
        while (scFieldsIt.hasNext()) {
            SootField scField = (SootField) scFieldsIt.next();
            allFields.add(scField);
        }
        superclass = superclass.getSuperclass();
    }
    return allFields;
}

Output:
     List<SootField> allFields = new ArrayList<SootField>();
-    Iterator fieldsIt = sc.getFields().iterator();
-    while (fieldsIt.hasNext()) {
-        SootField field = (SootField) fieldsIt.next();
+    for (SootField field : sc.getFields()) {
         allFields.add(field);


Input:
private BufferedImage decodeStrippedTiff(IFD ifd) throws Exception {
    TiffField<?> field = ifd.getField(TiffTag.COMPRESSION.getValue());
    short[] data = (short[]) field.getData();
    TiffFieldEnum.Compression compression = TiffFieldEnum.Compression.fromValue(data[0] & 0xffff);
    System.out.println("String_Node_Str" + compression.getDescription());
    TiffField<?> f_stripOffsets = ifd.getField(TiffTag.STRIP_OFFSETS.getValue());
    TiffField<?> f_stripByteCounts = ifd.getField(TiffTag.STRIP_BYTE_COUNTS.getValue());
    int[] stripOffsets = f_stripOffsets.getDataAsLong();
    int[] stripByteCounts = f_stripByteCounts.getDataAsLong();
    int imageWidth = ifd.getField(TiffTag.IMAGE_WIDTH.getValue()).getDataAsLong()[0];
    int imageHeight = ifd.getField(TiffTag.IMAGE_LENGTH.getValue()).getDataAsLong()[0];
    System.out.println("String_Node_Str" + imageWidth);
    System.out.println("String_Node_Str" + imageHeight);
    TiffField<?> f_rowsPerStrip = ifd.getField(TiffTag.ROWS_PER_STRIP.getValue());
    int rowsPerStrip = imageHeight;
    if (f_rowsPerStrip != null)
        rowsPerStrip = f_rowsPerStrip.getDataAsLong()[0];
    System.out.println("String_Node_Str" + rowsPerStrip);
    TiffField<?> f_photoMetric = ifd.getField(TiffTag.PHOTOMETRIC_INTERPRETATION.getValue());
    int photoMetric = f_photoMetric.getDataAsLong()[0];
    TiffFieldEnum.PhotoMetric e_photoMetric = TiffFieldEnum.PhotoMetric.fromValue(photoMetric);
    System.out.println("String_Node_Str" + e_photoMetric);
    TiffField<?> f_bitsPerSample = ifd.getField(TiffTag.BITS_PER_SAMPLE.getValue());
    int bitsPerSample = f_bitsPerSample.getDataAsLong()[0];
    System.out.println("String_Node_Str" + bitsPerSample);
    TiffField<?> f_samplesPerPixel = ifd.getField(TiffTag.SAMPLES_PER_PIXEL.getValue());
    int samplesPerPixel = f_samplesPerPixel.getDataAsLong()[0];
    System.out.println("String_Node_Str" + samplesPerPixel);
    TiffField<?> f_predictor = ifd.getField(TiffTag.PREDICTOR.getValue());
    int predictor = 0;
    if (f_predictor != null) {
        predictor = f_predictor.getDataAsLong()[0];
        System.out.println("String_Node_Str" + predictor);
    }
    TiffField<?> f_planaryConfiguration = ifd.getField(TiffTag.PLANAR_CONFIGURATTION.getValue());
    int planaryConfiguration = 1;
    if (f_planaryConfiguration != null)
        planaryConfiguration = f_planaryConfiguration.getDataAsLong()[0];
    TiffFieldEnum.PlanarConfiguration e_planaryConfiguration = TiffFieldEnum.PlanarConfiguration.fromValue(planaryConfiguration);
    System.out.println("String_Node_Str" + e_planaryConfiguration);
    boolean transparent = false;
    boolean isAssociatedAlpha = false;
    int numOfBands = samplesPerPixel;
    int trans = Transparency.OPAQUE;
    TiffField<?> f_extraSamples = ifd.getField(TiffTag.EXTRA_SAMPLES.getValue());
    if (f_extraSamples != null)
        isAssociatedAlpha = (f_extraSamples.getDataAsLong()[0] == 1) ? true : false;
    int offset = 0;
    ImageDecoder decoder = null;
    byte[] pixels = null;
    int[] stripBytes = TIFFTweaker.getUncompressedStripByteCounts(ifd, stripOffsets.length);
    int[] count = new int[samplesPerPixel];
    if (planaryConfiguration == 2) {
        int inc = stripBytes.length / samplesPerPixel;
        int startOff = 0;
        int endOff = inc;
        for (int k = 0; k < samplesPerPixel; k++) {
            for (int j = startOff; j < endOff; j++) count[k] += stripBytes[j];
            startOff += inc;
            endOff += inc;
        }
    }
    switch(e_photoMetric) {
        case PALETTE_COLOR:
            short[] colorMap = (short[]) ifd.getField(TiffTag.COLORMAP.getValue()).getData();
            rgbColorPalette = new int[colorMap.length / 3];
            int numOfColors = (1 << bitsPerSample);
            int numOfColors2 = (numOfColors << 1);
            for (int i = 0, index = 0; i < colorMap.length / 3; i++) {
                rgbColorPalette[index++] = 0xff000000 | ((colorMap[i] & 0xff00) << 8) | ((colorMap[i + numOfColors] & 0xff00)) | ((colorMap[i + numOfColors2] & 0xff00) >> 8);
            }
            int bytesPerScanLine = (imageWidth * bitsPerSample + 7) / 8;
            pixels = new byte[bytesPerScanLine * imageHeight];
            switch(compression) {
                case NONE:
                    for (int i = 0; i < stripByteCounts.length; i++) {
                        int bytes2Read = stripBytes[i];
                        randIS.seek(stripOffsets[i]);
                        randIS.readFully(pixels, offset, bytes2Read);
                        offset += bytes2Read;
                    }
                    break;
                case LZW:
                    decoder = new LZWTreeDecoder(8, true);
                    break;
                case DEFLATE:
                case DEFLATE_ADOBE:
                    decoder = new DeflateDecoder();
                    break;
                default:
            }
            if (decoder != null) {
                for (int i = 0; i < stripByteCounts.length; i++) {
                    byte[] temp = new byte[stripByteCounts[i]];
                    randIS.seek(stripOffsets[i]);
                    randIS.readFully(temp);
                    decoder.setInput(temp);
                    int numOfBytes = decoder.decode(pixels, offset, stripBytes[i]);
                    offset += numOfBytes;
                }
            }
            DataBuffer db = new DataBufferByte(pixels, pixels.length);
            WritableRaster raster = null;
            if (bitsPerSample != 8) {
                raster = Raster.createPackedRaster(db, imageWidth, imageHeight, bitsPerSample, null);
            } else {
                int[] off = { 0 };
                raster = Raster.createInterleavedRaster(db, imageWidth, imageHeight, imageWidth, 1, off, null);
            }
            ColorModel cm = new IndexColorModel(bitsPerSample, rgbColorPalette.length, rgbColorPalette, 0, false, -1, DataBuffer.TYPE_BYTE);
            return new BufferedImage(cm, raster, false, null);
        case SEPARATED:
            bytesPerScanLine = samplesPerPixel * ((imageWidth * bitsPerSample + 7) / 8);
            if (planaryConfiguration == 2)
                bytesPerScanLine = (imageWidth * bitsPerSample + 7) / 8;
            pixels = new byte[imageHeight * bytesPerScanLine];
            switch(compression) {
                case NONE:
                    bytesPerScanLine = imageWidth * samplesPerPixel * bitsPerSample / 8;
                    pixels = new byte[imageWidth * bytesPerScanLine];
                    for (int i = 0; i < stripByteCounts.length; i++) {
                        int bytes2Read = stripBytes[i];
                        randIS.seek(stripOffsets[i]);
                        randIS.readFully(pixels, offset, bytes2Read);
                        offset += bytes2Read;
                    }
                    break;
                case LZW:
                    decoder = new LZWTreeDecoder(8, true);
                    break;
                case DEFLATE:
                case DEFLATE_ADOBE:
                    decoder = new DeflateDecoder();
                    break;
                default:
                    break;
            }
            if (decoder != null) {
                for (int i = 0; i < stripByteCounts.length; i++) {
                    int bytes2Read = stripBytes[i];
                    byte[] temp = new byte[stripByteCounts[i]];
                    randIS.seek(stripOffsets[i]);
                    randIS.readFully(temp);
                    decoder.setInput(temp);
                    int numOfBytes = decoder.decode(pixels, offset, bytes2Read);
                    offset += numOfBytes;
                }
            }
            if (predictor == 2 && planaryConfiguration == 1)
                pixels = applyDePredictor(samplesPerPixel, pixels, imageWidth, imageHeight);
            db = new DataBufferByte(pixels, pixels.length);
            TiffField<?> f_colorProfile = ifd.getField(TiffTag.ICC_PROFILE.getValue());
            ICC_Profile profile = null;
            if (f_colorProfile != null)
                profile = ICC_Profile.getInstance((byte[]) f_colorProfile.getData());
            ColorSpace colorSpace = CMYKColorSpace.getInstance();
            if (profile != null)
                colorSpace = new ICC_ColorSpace(profile);
            int[] bandoff = { 0, 1, 2, 3 };
            int[] nBits = { 8, 8, 8, 8 };
            if (samplesPerPixel >= 5) {
                bandoff = new int[] { 0, 1, 2, 3, 4 };
                nBits = new int[] { 8, 8, 8, 8, 8 };
                trans = Transparency.TRANSLUCENT;
                transparent = true;
            }
            if (bitsPerSample == 16) {
                short[] spixels = ArrayUtils.byteArrayToShortArray(pixels, true);
                db = new DataBufferUShort(spixels, spixels.length);
                int[] off = { 0, 1, 2, 3 };
                nBits = new int[] { 16, 16, 16, 16 };
                trans = Transparency.OPAQUE;
                numOfBands = samplesPerPixel;
                if (samplesPerPixel >= 5) {
                    off = new int[] { 0, 1, 2, 3, 4 };
                    nBits = new int[] { 16, 16, 16, 16, 16 };
                    trans = Transparency.TRANSLUCENT;
                }
                raster = Raster.createInterleavedRaster(db, imageWidth, imageHeight, imageWidth * numOfBands, numOfBands, off, null);
                cm = new ComponentColorModel(CMYKColorSpace.getInstance(), nBits, transparent, isAssociatedAlpha, trans, DataBuffer.TYPE_USHORT);
            } else {
                cm = new ComponentColorModel(colorSpace, nBits, transparent, false, trans, DataBuffer.TYPE_BYTE);
                if (planaryConfiguration == 2) {
                    bandoff = new int[] { 0, count[0], count[0] + count[1], count[0] + count[1] + count[2] };
                    int[] bandIndices = new int[] { 0, 0, 0, 0 };
                    if (samplesPerPixel >= 5) {
                        bandoff = new int[] { 0, count[0], count[0] + count[1], count[0] + count[1] + count[2], count[0] + count[1] + count[2] + count[3] };
                        bandIndices = new int[] { 0, 0, 0, 0, 0 };
                    }
                    raster = Raster.createBandedRaster(db, imageWidth, imageHeight, bytesPerScanLine, bandIndices, bandoff, null);
                    if (profile != null) {
                        raster = IMGUtils.CMYK2RGB(raster, cm);
                        cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), nBits, transparent, isAssociatedAlpha, trans, DataBuffer.TYPE_BYTE);
                    }
                } else {
                    raster = Raster.createInterleavedRaster(db, imageWidth, imageHeight, imageWidth * numOfBands, numOfBands, bandoff, null);
                    if (profile != null) {
                        raster = IMGUtils.CMYK2RGB(raster, cm);
                        cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), nBits, transparent, isAssociatedAlpha, trans, DataBuffer.TYPE_BYTE);
                    }
                }
            }
            return new BufferedImage(cm, raster, false, null);
        case YCbCr:
            int[] samplingFactor = { 2, 2 };
            TiffField<?> f_YCbCrSubSampling = ifd.getField(TiffTag.YCbCr_SUB_SAMPLING.getValue());
            if (f_YCbCrSubSampling != null)
                samplingFactor = f_YCbCrSubSampling.getDataAsLong();
            float referenceBlackY = 0.0f;
            float referenceWhiteY = 255.0f;
            float referenceBlackCb = 128.0f;
            float referenceWhiteCb = 255.0f;
            float referenceBlackCr = 128.0f;
            float referenceWhiteCr = 255.0f;
            float codingRangeY = 255.0f;
            float codingRangeCbCr = 127.0f;
            TiffField<?> f_referenceBlackWhite = ifd.getField(TiffTag.REFERENCE_BLACK_WHITE.getValue());
            if (f_referenceBlackWhite != null) {
                int[] referenceBlackWhite = f_referenceBlackWhite.getDataAsLong();
                referenceBlackY = 1.0f * referenceBlackWhite[0] / referenceBlackWhite[1];
                referenceWhiteY = 1.0f * referenceBlackWhite[2] / referenceBlackWhite[3];
                referenceBlackCb = 1.0f * referenceBlackWhite[4] / referenceBlackWhite[5];
                referenceWhiteCb = 1.0f * referenceBlackWhite[6] / referenceBlackWhite[7];
                referenceBlackCr = 1.0f * referenceBlackWhite[8] / referenceBlackWhite[9];
                referenceWhiteCr = 1.0f * referenceBlackWhite[10] / referenceBlackWhite[11];
            }
            float lumaRed = 0.299f;
            float lumaGreen = 0.587f;
            float lumaBlue = 0.114f;
            TiffField<?> f_YCbCrCoefficients = ifd.getField(TiffTag.YCbCr_COEFFICIENTS.getValue());
            if (f_YCbCrCoefficients != null) {
                int[] lumas = f_YCbCrCoefficients.getDataAsLong();
                lumaRed = 1.0f * lumas[0] / lumas[1];
                lumaGreen = 1.0f * lumas[2] / lumas[3];
                lumaBlue = 1.0f * lumas[4] / lumas[5];
            }
            int bytesPerUnitY = samplingFactor[0] * samplingFactor[1];
            int bytesPerUnitCb = 1;
            int bytesPerUnitCr = 1;
            int bytesPerDataUnit = bytesPerUnitY + bytesPerUnitCb + bytesPerUnitCr;
            int dataUnitsPerWidth = imageWidth / samplingFactor[0];
            int offsetX = 0;
            int offsetY = 0;
            int bytesY = imageWidth * imageHeight;
            pixels = new byte[bytesY * 3 + rowsPerStrip * imageWidth * samplesPerPixel];
            switch(compression) {
                case NONE:
                    if (planaryConfiguration == 1) {
                        byte[] temp = null;
                        for (int i = 0; i < stripByteCounts.length; i++) {
                            randIS.seek(stripOffsets[i]);
                            int len = stripByteCounts[i];
                            temp = new byte[len];
                            randIS.readFully(temp);
                            offset = 0;
                            offsetX = 0;
                            int numOfDataUnit = len / bytesPerDataUnit;
                            for (int j = 1; j <= numOfDataUnit; j++) {
                                int offsetCb = offset + bytesPerUnitY;
                                int Cb = temp[offsetCb] & 0xff;
                                int Cr = temp[offsetCb + 1] & 0xff;
                                for (int k = 0; k < samplingFactor[1]; k++) {
                                    for (int l = 0; l < samplingFactor[0]; l++, offsetX++) {
                                        int Y = temp[offset++] & 0xff;
                                        float fY = (Y - referenceBlackY) * codingRangeY / (referenceWhiteY - referenceBlackY);
                                        float fCb = (Cb - referenceBlackCb) * codingRangeCbCr / (referenceWhiteCb - referenceBlackCb);
                                        float fCr = (Cr - referenceBlackCr) * codingRangeCbCr / (referenceWhiteCr - referenceBlackCr);
                                        float R = (fCr * (2 - 2 * lumaRed) + fY);
                                        float B = (fCb * (2 - 2 * lumaBlue) + fY);
                                        float G = ((fY - lumaBlue * B - lumaRed * R) / lumaGreen);
                                        if (R < 0)
                                            R = 0;
                                        if (R > 255)
                                            R = 255;
                                        if (G < 0)
                                            G = 0;
                                        if (G > 255)
                                            G = 255;
                                        if (B < 0)
                                            B = 0;
                                        if (B > 255)
                                            B = 255;
                                        int yPos = offsetX + offsetY * imageWidth;
                                        int redPos = 3 * yPos;
                                        pixels[redPos] = (byte) R;
                                        pixels[redPos + 1] = (byte) G;
                                        pixels[redPos + 2] = (byte) B;
                                    }
                                    offsetX -= samplingFactor[0];
                                    offsetY += 1;
                                }
                                offsetY -= samplingFactor[1];
                                offset += 2;
                                offsetX += samplingFactor[0];
                                if (j % dataUnitsPerWidth == 0) {
                                    offsetY += samplingFactor[1];
                                    offsetX = 0;
                                }
                            }
                        }
                    } else {
                    }
                    break;
                case LZW:
                    if (planaryConfiguration == 1) {
                        byte[] temp = null;
                        byte[] temp2 = null;
                        for (int i = 0; i < stripByteCounts.length; i++) {
                            randIS.seek(stripOffsets[i]);
                            int len = stripByteCounts[i];
                            temp = new byte[len];
                            randIS.readFully(temp);
                            temp2 = new byte[stripBytes[i]];
                            decoder = new LZWTreeDecoder(8, true);
                            decoder.setInput(temp);
                            int numOfBytes = decoder.decode(temp2, 0, temp2.length);
                            offset = 0;
                            offsetX = 0;
                            int numOfDataUnit = numOfBytes / bytesPerDataUnit;
                            for (int j = 1; j <= numOfDataUnit; j++) {
                                int offsetCb = offset + bytesPerUnitY;
                                int Cb = temp2[offsetCb] & 0xff;
                                int Cr = temp2[offsetCb + 1] & 0xff;
                                for (int k = 0; k < samplingFactor[1]; k++) {
                                    for (int l = 0; l < samplingFactor[0]; l++, offsetX++) {
                                        int Y = temp2[offset++] & 0xff;
                                        float fY = (Y - referenceBlackY) * codingRangeY / (referenceWhiteY - referenceBlackY);
                                        float fCb = (Cb - referenceBlackCb) * codingRangeCbCr / (referenceWhiteCb - referenceBlackCb);
                                        float fCr = (Cr - referenceBlackCr) * codingRangeCbCr / (referenceWhiteCr - referenceBlackCr);
                                        float R = (fCr * (2 - 2 * lumaRed) + fY);
                                        float B = (fCb * (2 - 2 * lumaBlue) + fY);
                                        float G = ((fY - lumaBlue * B - lumaRed * R) / lumaGreen);
                                        if (R < 0)
                                            R = 0;
                                        if (R > 255)
                                            R = 255;
                                        if (G < 0)
                                            G = 0;
                                        if (G > 255)
                                            G = 255;
                                        if (B < 0)
                                            B = 0;
                                        if (B > 255)
                                            B = 255;
                                        int yPos = offsetX + offsetY * imageWidth;
                                        int redPos = 3 * yPos;
                                        pixels[redPos] = (byte) R;
                                        pixels[redPos + 1] = (byte) G;
                                        pixels[redPos + 2] = (byte) B;
                                    }
                                    offsetX -= samplingFactor[0];
                                    offsetY += 1;
                                }
                                offsetY -= samplingFactor[1];
                                offset += 2;
                                offsetX += samplingFactor[0];
                                if (j % dataUnitsPerWidth == 0) {
                                    offsetY += samplingFactor[1];
                                    offsetX = 0;
                                }
                            }
                        }
                    } else {
                    }
                    break;
                default:
            }
            db = new DataBufferByte(pixels, pixels.length);
            bandoff = new int[] { 0, 1, 2 };
            transparent = false;
            numOfBands = samplesPerPixel;
            trans = Transparency.OPAQUE;
            nBits = new int[] { 8, 8, 8 };
            raster = Raster.createInterleavedRaster(db, imageWidth, imageHeight, imageWidth * numOfBands, numOfBands, bandoff, null);
            cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), nBits, transparent, isAssociatedAlpha, trans, DataBuffer.TYPE_BYTE);
            return new BufferedImage(cm, raster, false, null);
        case RGB:
            bytesPerScanLine = samplesPerPixel * ((imageWidth * bitsPerSample + 7) / 8);
            int totalBytes2Read = imageHeight * bytesPerScanLine;
            if (planaryConfiguration == 2)
                bytesPerScanLine = (imageWidth * bitsPerSample + 7) / 8;
            pixels = new byte[totalBytes2Read];
            switch(compression) {
                case NONE:
                    for (int i = 0; i < stripByteCounts.length; i++) {
                        int bytes2Read = stripBytes[i];
                        randIS.seek(stripOffsets[i]);
                        randIS.readFully(pixels, offset, bytes2Read);
                        offset += bytes2Read;
                    }
                    break;
                case PACKBITS:
                    for (int i = 0; i < stripByteCounts.length; i++) {
                        int bytes2Read = stripBytes[i];
                        byte[] temp = new byte[stripByteCounts[i]];
                        randIS.seek(stripOffsets[i]);
                        randIS.readFully(temp);
                        byte[] temp2 = new byte[bytes2Read];
                        Packbits.unpackbits(temp, temp2);
                        System.arraycopy(temp2, 0, pixels, offset, bytes2Read);
                        offset += bytes2Read;
                    }
                    break;
                case LZW:
                    decoder = new LZWTreeDecoder(8, true);
                    break;
                case DEFLATE:
                case DEFLATE_ADOBE:
                    decoder = new DeflateDecoder();
                    break;
                default:
            }
            if (decoder != null) {
                pixels = new byte[stripOffsets.length * stripBytes[0]];
                for (int i = 0; i < stripByteCounts.length; i++) {
                    byte[] temp = new byte[stripByteCounts[i]];
                    randIS.seek(stripOffsets[i]);
                    randIS.readFully(temp);
                    decoder.setInput(temp);
                    int numOfBytes = decoder.decode(pixels, offset, stripBytes[i]);
                    offset += numOfBytes;
                }
            }
            if (predictor == 2) {
                if (planaryConfiguration == 1)
                    pixels = applyDePredictor(samplesPerPixel, pixels, imageWidth, imageHeight);
                else {
                    int dataOffset = 0;
                    for (int k = 0; k < samplesPerPixel; k++) {
                        applyDePredictor2(pixels, dataOffset, imageWidth, imageHeight);
                        dataOffset += count[k];
                    }
                }
            }
            bandoff = new int[] { 0, 1, 2 };
            transparent = false;
            numOfBands = samplesPerPixel;
            trans = Transparency.OPAQUE;
            if (bitsPerSample == 16) {
                short[] spixels = ArrayUtils.byteArrayToShortArray(pixels, endian == IOUtils.BIG_ENDIAN);
                db = new DataBufferUShort(spixels, spixels.length);
                nBits = new int[] { 16, 16, 16 };
                if (samplesPerPixel == 4) {
                    bandoff = new int[] { 0, 1, 2, 3 };
                    nBits = new int[] { 16, 16, 16, 16 };
                    trans = Transparency.TRANSLUCENT;
                    transparent = true;
                }
            } else {
                db = new DataBufferByte(pixels, pixels.length);
                nBits = new int[] { 8, 8, 8 };
                if (samplesPerPixel == 4) {
                    bandoff = new int[] { 0, 1, 2, 3 };
                    nBits = new int[] { 8, 8, 8, 8 };
                    trans = Transparency.TRANSLUCENT;
                    transparent = true;
                }
            }
            if (planaryConfiguration == 2) {
                bandoff = new int[] { 0, count[0] * 8 / bitsPerSample, (count[0] + count[1]) * 8 / bitsPerSample };
                int[] bandIndices = new int[] { 0, 0, 0 };
                if (samplesPerPixel == 4) {
                    bandoff = new int[] { 0, count[0] * 8 / bitsPerSample, (count[0] + count[1]) * 8 / bitsPerSample, (count[0] + count[1] + count[2]) * 8 / bitsPerSample };
                    bandIndices = new int[] { 0, 0, 0, 0 };
                }
                raster = Raster.createBandedRaster(db, imageWidth, imageHeight, bytesPerScanLine * 8 / bitsPerSample, bandIndices, bandoff, null);
            } else
                raster = Raster.createInterleavedRaster(db, imageWidth, imageHeight, imageWidth * numOfBands, numOfBands, bandoff, null);
            if (bitsPerSample == 16)
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), nBits, transparent, isAssociatedAlpha, trans, DataBuffer.TYPE_USHORT);
            else
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), nBits, transparent, isAssociatedAlpha, trans, DataBuffer.TYPE_BYTE);
            return new BufferedImage(cm, raster, false, null);
        default:
            break;
    }
    return null;
}

Output:
             int bytesPerDataUnit = bytesPerUnitY + bytesPerUnitCb + bytesPerUnitCr;
-            int dataUnitsPerWidth = imageWidth / samplingFactor[0];
+            int dataUnitsPerWidth = expandedImageWidth / samplingFactor[0];
             int offsetX = 0;


Input:
public ElementLocator createLocator(Field field) {
    TimeOutDuration customDuration;
    if (field.isAnnotationPresent(WithTimeout.class)) {
        WithTimeout withTimeout = field.getAnnotation(WithTimeout.class);
        customDuration = new TimeOutDuration(withTimeout.time(), withTimeout.unit());
    } else
        customDuration = timeOutDuration;
    builder.setAnnotated(field);
    By by = builder.buildBy();
    if (by != null)
        return new AppiumElementLocator(searchContext, by, builder.isLookupCached(), customDuration, originalWebDriver);
    return null;
}

Output:
     TimeOutDuration customDuration;
-    if (field.isAnnotationPresent(WithTimeout.class)) {
-        WithTimeout withTimeout = field.getAnnotation(WithTimeout.class);
+    if (annotatedElement.isAnnotationPresent(WithTimeout.class)) {
+        WithTimeout withTimeout = annotatedElement.getAnnotation(WithTimeout.class);
         customDuration = new TimeOutDuration(withTimeout.time(), withTimeout.unit());


Input:
public void setProperty(String key, String value) {
    if (key == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    Map map = PropertyManager.getRequestProperties(portletWindow, this.getHttpServletRequest());
    if (map == null) {
        map = new HashMap();
    }
    String[] properties = new String[] { value };
    map.put(key, properties);
    PropertyManager.setResponseProperties(portletWindow, getHttpServletRequest(), _getHttpServletResponse(), map);
}

Output:
     }
-    Map map = PropertyManager.getRequestProperties(portletWindow, this.getHttpServletRequest());
-    if (map == null) {
-        map = new HashMap();
-    }
-    String[] properties = new String[] { value };
-    map.put(key, properties);
-    PropertyManager.setResponseProperties(portletWindow, getHttpServletRequest(), _getHttpServletResponse(), map);
+    Map props = getProperties();
+    String[] newValues = new String[] { value };
+    props.put(key, newValues);
+    PropertyManager.setResponseProperties(portletWindow, this.getHttpServletRequest(), _getHttpServletResponse(), props);
 }


Input:
public Object getValue(BindELContext ctx) {
    return grid.getModel().getElementAt(nr.getIndex() / items.length);
}

Output:
 public Object getValue(BindELContext ctx) {
-    return grid.getModel().getElementAt(nr.getIndex() / items.length);
+    return grid.getModel().getElementAt(BindRowRenderer.this.getRenderedIndex(grid, nr.getIndex()));
 }


Input:
private String getRawNameForSaving() {
    String tempFileName = getDisplayName();
    if (tempFileName != null && tempFileName.length() > 0) {
        return tempFileName;
    }
    tempFileName = getKeywordTopic();
    if (tempFileName != null && tempFileName.length() > 0) {
        return tempFileName;
    }
    URN urn = getSHA1Urn();
    if (urn != null) {
        tempFileName = urn.toString();
        return tempFileName;
    }
    String[] urls = getDefaultURLs();
    if (urls.length > 0) {
        try {
            URI uri = new URI(urls[0].toCharArray());
            tempFileName = extractFileName(uri);
            if (tempFileName != null && tempFileName.length() > 0) {
                return tempFileName;
            }
        } catch (URIException e) {
        }
    }
    try {
        File file = File.createTempFile("String_Node_Str", "String_Node_Str");
        file.deleteOnExit();
        tempFileName = file.getName();
        return tempFileName;
    } catch (IOException ie) {
    }
    tempFileName = DOWNLOAD_PREFIX;
    return tempFileName;
}

Output:
     try {
-        File file = File.createTempFile("String_Node_Str", "String_Node_Str");
+        File file = FileUtils.createTempFile("String_Node_Str", "String_Node_Str");
         file.deleteOnExit();


Input:
public Set<String> getSymbols() {
    return _symbols.keySet();
}

Output:
 public Set<String> getSymbols() {
-    return _symbols.keySet();
+    if (_currentBranch || isForStatement) {
+        return _trueSymbols.keySet();
+    } else {
+        return _falseSymbols.keySet();
+    }
 }


Input:
protected void setNamespace(String namespace) {
    this.namespace = namespace;
    this.binding = BindingManager.getBinding(BindingManager.sanitizeNamespace(this.namespace));
}

Output:
     this.namespace = namespace;
-    this.binding = BindingManager.getBinding(BindingManager.sanitizeNamespace(this.namespace));
+    this.binding = BindingManager.getBinding(this.namespace);
 }


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    MageObject sourceObject = source.getSourceObject(game);
    if (controller != null && sourceObject != null) {
        Permanent permanentLeftBattlefield = (Permanent) getValue("String_Node_Str");
        if (permanentLeftBattlefield == null) {
            Logger.getLogger(ReturnFromExileForSourceEffect.class).error("String_Node_Str" + sourceObject.getName());
            return false;
        }
        ExileZone exile = game.getExile().getExileZone(CardUtil.getExileZoneId(game, source.getSourceId(), permanentLeftBattlefield.getZoneChangeCounter(game)));
        if (exile != null) {
            Card card = exile.getCards(game).iterator().next();
            if (card != null) {
                Player cardOwner = game.getPlayer(card.getOwnerId());
                if (cardOwner != null) {
                    if (cardOwner.chooseUse(Outcome.PlayForFree, "String_Node_Str" + card.getLogName() + "String_Node_Str", source, game)) {
                        cardOwner.cast(card.getSpellAbility(), game, true);
                    }
                }
            }
        }
        return true;
    }
    return false;
}

Output:
         if (exile != null) {
-            Card card = exile.getCards(game).iterator().next();
-            if (card != null) {
-                Player cardOwner = game.getPlayer(card.getOwnerId());
-                if (cardOwner != null) {
-                    if (cardOwner.chooseUse(Outcome.PlayForFree, "String_Node_Str" + card.getLogName() + "String_Node_Str", source, game)) {
-                        cardOwner.cast(card.getSpellAbility(), game, true);
+            Card card = null;
+            Set<Card> exiledCards = exile.getCards(game);
+            if (exiledCards != null && !exiledCards.isEmpty()) {
+                card = exiledCards.iterator().next();
+                if (card != null) {
+                    Player cardOwner = game.getPlayer(card.getOwnerId());
+                    if (cardOwner != null) {
+                        if (cardOwner.chooseUse(Outcome.PlayForFree, "String_Node_Str" + card.getLogName() + "String_Node_Str", source, game)) {
+                            cardOwner.cast(card.getSpellAbility(), game, true);
+                        }
                     }


Input:
public String prettyPrint(ILogicDecorator d) {
    if (clauses.size() == 1) {
        return getF1().prettyPrint(d);
    } else {
        StringBuffer result = new StringBuffer();
        result.append("String_Node_Str");
        result.append(getF1().prettyPrint(d));
        result.append("String_Node_Str");
        result.append(d.prettyPrint(getConnective()));
        result.append("String_Node_Str");
        result.append(getF2().prettyPrint(d));
        result.append("String_Node_Str");
        return result.toString();
    }
}

Output:
 public String prettyPrint(ILogicDecorator d) {
-    if (clauses.size() == 1) {
-        return getF1().prettyPrint(d);
-    } else {
-        StringBuffer result = new StringBuffer();
-        result.append("String_Node_Str");
-        result.append(getF1().prettyPrint(d));
-        result.append("String_Node_Str");
-        result.append(d.prettyPrint(getConnective()));
-        result.append("String_Node_Str");
-        result.append(getF2().prettyPrint(d));
-        result.append("String_Node_Str");
-        return result.toString();
+    if (d == null) {
+        throw new IllegalArgumentException("String_Node_Str");
     }


Input:
private static Version readVersion() {
    if (Activator.version != null)
        return Activator.version;
    Properties p = new Properties();
    try {
        p.load(GeneralManager.class.getResourceAsStream("String_Node_Str"));
    } catch (IOException e) {
        Logger.log(new Status(IStatus.ERROR, "String_Node_Str", "String_Node_Str"));
    }
    String v = p.getProperty("String_Node_Str", "String_Node_Str");
    return Version.parseVersion(v);
}

Output:
     Properties p = new Properties();
-    try {
-        p.load(GeneralManager.class.getResourceAsStream("String_Node_Str"));
+    try (InputStream in = GeneralManager.class.getResourceAsStream("String_Node_Str")) {
+        if (in != null)
+            p.load(in);
     } catch (IOException e) {


Input:
public void testSubmitNewJobs() throws DocumentException {
    prepareDefaultMockAnswers(SELECTIVE_HARVEST_CHANNEL, jobMock);
    jobDispatcher.submitNextNewJob(SELECTIVE_HARVEST_CHANNEL);
    verify(jobMock).setStatus(JobStatus.SUBMITTED);
    verify(jobMock).setSubmittedDate(any(Date.class));
    verify(jobDAO).update(jobMock);
    verify(jmsConnection).send(crawlMessageCaptor.capture());
    assertTrue(jobMock == crawlMessageCaptor.getValue().getJob());
    assertEquals(HarvesterChannels.getHarvestJobChannelId(SELECTIVE_HARVEST_CHANNEL), crawlMessageCaptor.getValue().getTo());
    assertEquals(harvest.getName(), crawlMessageCaptor.getValue().getOrigHarvestInfo().getOrigHarvestName());
}

Output:
 public void testSubmitNewJobs() throws DocumentException {
-    prepareDefaultMockAnswers(SELECTIVE_HARVEST_CHANNEL, jobMock);
+    prepareDefaultMockAnswers(SELECTIVE_HARVEST_CHANNEL, jobMock, false);
     jobDispatcher.submitNextNewJob(SELECTIVE_HARVEST_CHANNEL);


Input:
public void handle(TableColumn.CellEditEvent<Profile.PairLogoRelativeRectangle, String> t) {
    try {
        Profile.PairLogoRelativeRectangle p = ((Profile.PairLogoRelativeRectangle) t.getTableView().getItems().get(t.getTablePosition().getRow()));
        if (t.getNewValue().compareTo("String_Node_Str") != 0) {
            if (p.getLogo() == null) {
                Logo newLogo = pservice.addLogo(new Logo(t.getNewValue(), "String_Node_Str"));
                p.setLogo(newLogo);
            } else
                p.getLogo().setLabel(t.getNewValue());
            LOGGER.info("String_Node_Str" + p.getLogo().getId() + "String_Node_Str" + p.getLogo().getLabel() + "String_Node_Str" + p.getLogo().getPath());
            pservice.editLogo(p.getLogo());
        } else {
            refreshTableLogo(pservice.getAllPairLogoRelativeRectangle(selectedProfile.getId()));
        }
    } catch (ServiceException e) {
        try {
            refreshTableProfiles(pservice.getAllProfiles());
        } catch (ServiceException e1) {
            LOGGER.error("String_Node_Str", e1);
        }
    }
}

Output:
                 p.setLogo(newLogo);
-            } else
-                p.getLogo().setLabel(t.getNewValue());
+            } else {
+                if (pservice.getNumberOfUsing(p.getLogo().getId()) == 1) {
+                    txLogoName.getEntries().remove(p.getLogo().getLabel().toLowerCase() + "String_Node_Str" + p.getLogo().getId());
+                    txLogoName.getImgViews().remove(p.getLogo().getLabel().toLowerCase() + "String_Node_Str" + p.getLogo().getId());
+                    p.getLogo().setLabel(t.getNewValue());
+                    ImageView imgView = new ImageView(new Image("String_Node_Str" + p.getLogo().getPath(), 30, 30, true, true));
+                    imgView.setId((p.getLogo().getPath()));
+                    txLogoName.getEntries().add(p.getLogo().getLabel().toLowerCase() + "String_Node_Str" + p.getLogo().getId());
+                    txLogoName.getImgViews().put(p.getLogo().getLabel().toLowerCase() + "String_Node_Str" + p.getLogo().getId(), imgView);
+                } else {
+                    int index = logoList.indexOf(p);
+                    logoList.remove(p);
+                    p.getLogo().setId(Integer.MIN_VALUE);
+                    p.getLogo().setLabel(t.getNewValue());
+                    Logo newLogo = pservice.addLogo(p.getLogo());
+                    p.setLogo(newLogo);
+                    logoList.add(index, p);
+                    ImageView imgView = new ImageView(new Image("String_Node_Str" + p.getLogo().getPath(), 30, 30, true, true));
+                    imgView.setId((p.getLogo().getPath()));
+                    txLogoName.getEntries().add(p.getLogo().getLabel().toLowerCase() + "String_Node_Str" + p.getLogo().getId());
+                    txLogoName.getImgViews().put(p.getLogo().getLabel().toLowerCase() + "String_Node_Str" + p.getLogo().getId(), imgView);
+                    pservice.editPairLogoRelativeRectangle(p);
+                }
+            }
             LOGGER.info("String_Node_Str" + p.getLogo().getId() + "String_Node_Str" + p.getLogo().getLabel() + "String_Node_Str" + p.getLogo().getPath());


Input:
private Node getNextSibling(Node node) {
    Node sib = node.getNextSibling();
    if (sib != null && Node.COMMENT_NODE == sib.getNodeType()) {
        sib = getNextSibling(sib);
    }
    if (sib != null && sib.getNodeType() == Node.TEXT_NODE) {
        String value = sib.getTextContent();
        if (value != null) {
            value = value.replaceAll("String_Node_Str", "String_Node_Str");
            value = value.replaceAll("String_Node_Str", "String_Node_Str");
            value = value.replaceAll("String_Node_Str", "String_Node_Str");
            if (Utils.isEmpty(value)) {
                sib = getNextSibling(sib);
            }
        }
    }
    logger.log(Level.INFO, "String_Node_Str", sib);
    return sib;
}

Output:
     }
-    logger.log(Level.INFO, "String_Node_Str", sib);
+    logger.log(Level.FINEST, "String_Node_Str", sib);
     return sib;


Input:
public QuasiLiveService getService(File source, long serviceId) {
    if (source == null) {
        SortedMap<Long, QuasiLiveService> services = getServicesSortedMap(this.getQuasiFramework(source));
        return services.get(serviceId);
    }
    return null;
}

Output:
     if (source == null) {
-        SortedMap<Long, QuasiLiveService> services = getServicesSortedMap(this.getQuasiFramework(source));
+        SortedMap<Long, QuasiLiveService> services = getServicesSortedMap(this.getQuasiFramework());
         return services.get(serviceId);


Input:
protected final void closeConnection() throws IOException {
    socket.close();
}

Output:
 protected final void closeConnection() throws IOException {
-    socket.close();
+    if (socket != null)
+        socket.close();
 }


Input:
private NSArray<UIGestureRecognizer> createGestureRecognizers() {
    UIGestureRecognizerDelegate gestureRecognizerDelegate = new UIGestureRecognizerDelegateAdapter() {
        public boolean shouldRecognizeSimultaneously(UIGestureRecognizer gestureRecognizer, UIGestureRecognizer otherGestureRecognizer) {
            if (gestureRecognizer.getView() != firstPieceView && gestureRecognizer.getView() != secondPieceView && gestureRecognizer.getView() != thirdPieceView) {
                return false;
            }
            if (gestureRecognizer.getView() != otherGestureRecognizer.getView()) {
                return false;
            }
            if (gestureRecognizer instanceof UILongPressGestureRecognizer || otherGestureRecognizer instanceof UILongPressGestureRecognizer) {
                return false;
            }
            return true;
        }
    };
    UIRotationGestureRecognizer rotationGestureRecognizer = new UIRotationGestureRecognizer(new UIGestureRecognizer.GestureListener() {
        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            rotatePiece((UIRotationGestureRecognizer) gestureRecognizer);
        }
    });
    UIPinchGestureRecognizer pinchGestureRecognizer = new UIPinchGestureRecognizer(new UIGestureRecognizer.GestureListener() {
        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            scalePiece((UIPinchGestureRecognizer) gestureRecognizer);
        }
    });
    UIPanGestureRecognizer panGestureRecognizer = new UIPanGestureRecognizer(new UIGestureRecognizer.GestureListener() {

        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            panPiece((UIPanGestureRecognizer) gestureRecognizer);
        }
    });
    UILongPressGestureRecognizer longPressGestureRecognizer = new UILongPressGestureRecognizer(new UIGestureRecognizer.GestureListener() {
        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            showResetMenu((UILongPressGestureRecognizer) gestureRecognizer);
        }
    });
    NSArray<UIGestureRecognizer> gestureRecognizers = new NSArray<>(rotationGestureRecognizer, pinchGestureRecognizer, panGestureRecognizer, longPressGestureRecognizer);
    for (UIGestureRecognizer gestureRecognizer : gestureRecognizers) {
        gestureRecognizer.setDelegate(gestureRecognizerDelegate);
    }
    return gestureRecognizers;
}

Output:
     });
-    UIPanGestureRecognizer panGestureRecognizer = new UIPanGestureRecognizer(new UIGestureRecognizer.GestureListener() {
+    UIPanGestureRecognizer panGestureRecognizer = new UIPanGestureRecognizer(new UIGestureRecognizer.OnGestureListener() {


Input:
public void testSkylarkTypeEquivalence() throws Exception {
    Class<?> emptyTupleClass = Tuple.empty().getClass();
    Class<?> tupleClass = Tuple.of(1, "String_Node_Str", "String_Node_Str").getClass();
    Class<?> mutableListClass = new MutableList<>(Tuple.of(1, 2, 3), env).getClass();
    assertThat(SkylarkType.of(mutableListClass)).isEqualTo(SkylarkType.LIST);
    assertThat(SkylarkType.of(emptyTupleClass)).isEqualTo(SkylarkType.TUPLE);
    assertThat(SkylarkType.of(tupleClass)).isEqualTo(SkylarkType.TUPLE);
    assertThat(SkylarkType.TUPLE).isNotEqualTo(SkylarkType.LIST);
    try {
        SkylarkType.of(ClassObject.class);
        throw new Exception("String_Node_Str");
    } catch (Exception e) {
        assertThat(e).hasMessageThat().contains("String_Node_Str" + "String_Node_Str");
    }
    assertThat(SkylarkType.of(Artifact.SpecialArtifact.class)).isEqualTo(SkylarkType.of(Artifact.class));
    assertThat(SkylarkType.of(RuleConfiguredTarget.class)).isNotEqualTo(SkylarkType.of(Info.class));
}

Output:
     Class<?> tupleClass = Tuple.of(1, "String_Node_Str", "String_Node_Str").getClass();
-    Class<?> mutableListClass = new MutableList<>(Tuple.of(1, 2, 3), env).getClass();
+    Class<?> mutableListClass = MutableList.copyOf(env, Tuple.of(1, 2, 3)).getClass();
     assertThat(SkylarkType.of(mutableListClass)).isEqualTo(SkylarkType.LIST);


Input:
public void widgetSelected(SelectionEvent e) {
    Context ctx = CorePlugin.getContext();
    ctx.putProperty(Context.REPOSITORY_CONTEXT_KEY, loginComposite.getRepositoryContext());
    if (!TOSLoginComposite.this.projectListViewer.getSelection().isEmpty()) {
        String selection = TOSLoginComposite.this.projectListViewer.getList().getSelection()[0];
        if (selection != null && !selection.equals("String_Node_Str")) {
            StringBuffer temp = new StringBuffer();
            for (int i = 0; i < selection.length(); i++) {
                if ((selection.charAt(i) + "String_Node_Str").equals("String_Node_Str")) {
                    temp.append("String_Node_Str");
                } else {
                    temp.append(selection.charAt(i));
                }
            }
            Project project = (Project) projectsMap.get(temp.toString().toUpperCase());
            boolean flag = dialog.logIn(project);
            if (flag) {
                dialog.okPressed();
            }
        }
    }
}

Output:
         if (selection != null && !selection.equals("String_Node_Str")) {
-            StringBuffer temp = new StringBuffer();
-            for (int i = 0; i < selection.length(); i++) {
-                if ((selection.charAt(i) + "String_Node_Str").equals("String_Node_Str")) {
-                    temp.append("String_Node_Str");
-                } else {
-                    temp.append(selection.charAt(i));
-                }
+            if (selection.contains("String_Node_Str")) {
+                selection = selection.replace(' ', '_');
             }


Input:
public Response getDefinitionAsJson(String propertyPath, String output, String callback, String prettyPrint) {
    boolean prettyPrintEnabled = ContentApiUtils.isPrettyPrintEnabled(prettyPrint);
    if (StringUtils.equals(propertyPath, CmsConstants.ASTROBOA_MODEL_SCHEMA_FILENAME_WITH_VERSION) || StringUtils.equals(propertyPath, CmsConstants.ASTROBOA_API_SCHEMA_FILENAME_WITH_VERSION)) {
        return getDefinitionInternal(propertyPath, Output.XSD, callback, prettyPrintEnabled);
    }
    Output outputEnum = Output.XML;
    if (StringUtils.isNotBlank(output)) {
        outputEnum = Output.valueOf(output.toUpperCase());
    }
    return getDefinitionInternal(propertyPath, outputEnum, callback, prettyPrintEnabled);
}

Output:
     }
-    Output outputEnum = Output.XML;
+    Output outputEnum = Output.JSON;
     if (StringUtils.isNotBlank(output)) {


Input:
public static int getCDSLengthReverse(List<Integer> exonStarts, List<Integer> exonEnds, int cdsStart, int cdsEnd) {
    boolean inCoding = false;
    int codingLength = 0;
    if (cdsEnd < cdsStart) {
        int tmp = cdsEnd;
        cdsEnd = cdsStart;
        cdsStart = tmp;
    }
    int lengthExons = 0;
    for (int i = exonStarts.size() - 1; i >= 0; i--) {
        int end = exonStarts.get(i);
        int start = exonEnds.get(i);
        if (end < start) {
            int tmp = end;
            end = start;
            start = tmp;
        }
        lengthExons += end - start;
        if (start <= cdsEnd && end >= cdsEnd) {
            inCoding = true;
            int tmpstart = start;
            if (start < cdsStart) {
                tmpstart = cdsStart;
            }
            codingLength += (cdsEnd - tmpstart);
            boolean debug = logger.isDebugEnabled();
            if (debug) {
                StringBuffer b = new StringBuffer();
                b.append("String_Node_Str" + (cdsEnd + 1) + "String_Node_Str" + (end) + newline);
                if (tmpstart == start)
                    b.append("String_Node_Str");
                else
                    b.append("String_Node_Str");
                b.append("String_Node_Str" + tmpstart + "String_Node_Str" + cdsEnd + "String_Node_Str" + (cdsEnd - tmpstart) + "String_Node_Str" + codingLength + "String_Node_Str" + (codingLength % 3) + newline);
                if (tmpstart != start)
                    b.append("String_Node_Str" + (cdsStart - 1) + "String_Node_Str" + start + newline);
                logger.debug(b.toString());
            }
        } else if (start <= cdsStart && end >= cdsStart) {
            inCoding = false;
            codingLength += (end - cdsStart);
            logger.debug("String_Node_Str" + (cdsStart + 1) + "String_Node_Str" + end + "String_Node_Str" + (end - cdsStart) + "String_Node_Str" + (codingLength - 3) + "String_Node_Str" + (codingLength % 3));
            logger.debug("String_Node_Str" + start + "String_Node_Str" + (cdsStart));
        } else if (inCoding) {
            codingLength += (end - start);
            logger.debug("String_Node_Str" + start + "String_Node_Str" + end + "String_Node_Str" + (end - start) + "String_Node_Str" + codingLength + "String_Node_Str" + (codingLength % 3));
        } else {
            logger.debug("String_Node_Str");
        }
    }
    logger.debug("String_Node_Str" + lengthExons + "String_Node_Str" + (codingLength - 3));
    return codingLength - 3;
}

Output:
         }
-        lengthExons += end - start;
-        if (start <= cdsEnd && end >= cdsEnd) {
-            inCoding = true;
-            int tmpstart = start;
-            if (start < cdsStart) {
-                tmpstart = cdsStart;
-            }
-            codingLength += (cdsEnd - tmpstart);
-            boolean debug = logger.isDebugEnabled();
-            if (debug) {
-                StringBuffer b = new StringBuffer();
-                b.append("String_Node_Str" + (cdsEnd + 1) + "String_Node_Str" + (end) + newline);
-                if (tmpstart == start)
-                    b.append("String_Node_Str");
-                else
-                    b.append("String_Node_Str");
-                b.append("String_Node_Str" + tmpstart + "String_Node_Str" + cdsEnd + "String_Node_Str" + (cdsEnd - tmpstart) + "String_Node_Str" + codingLength + "String_Node_Str" + (codingLength % 3) + newline);
-                if (tmpstart != start)
-                    b.append("String_Node_Str" + (cdsStart - 1) + "String_Node_Str" + start + newline);
-                logger.debug(b.toString());
-            }
-        } else if (start <= cdsStart && end >= cdsStart) {
-            inCoding = false;
-            codingLength += (end - cdsStart);
-            logger.debug("String_Node_Str" + (cdsStart + 1) + "String_Node_Str" + end + "String_Node_Str" + (end - cdsStart) + "String_Node_Str" + (codingLength - 3) + "String_Node_Str" + (codingLength % 3));
-            logger.debug("String_Node_Str" + start + "String_Node_Str" + (cdsStart));
-        } else if (inCoding) {
-            codingLength += (end - start);
-            logger.debug("String_Node_Str" + start + "String_Node_Str" + end + "String_Node_Str" + (end - start) + "String_Node_Str" + codingLength + "String_Node_Str" + (codingLength % 3));
-        } else {
-            logger.debug("String_Node_Str");
-        }
+        if ((start < cdsStart && end < cdsStart) || (start > cdsEnd && end > cdsEnd))
+            continue;
+        if (start < cdsStart)
+            start = cdsStart;
+        if (end > cdsEnd)
+            end = cdsEnd;
+        codingLength += (end - start + 1);
     }


Input:
public void process(SubstitutionMapping instance) {
    if (instance == null) {
        return;
    }
    referencePostProcessor.process(new ReferencePostProcessor.TypeReference(instance.getSubstitutionType().getElementId(), NodeType.class));
    NodeType nodeType = ToscaContext.get(NodeType.class, instance.getSubstitutionType().getElementId());
    instance.setSubstitutionType(nodeType);
}

Output:
     }
-    referencePostProcessor.process(new ReferencePostProcessor.TypeReference(instance.getSubstitutionType().getElementId(), NodeType.class));
+    referencePostProcessor.process(new ReferencePostProcessor.TypeReference(instance.getSubstitutionType(), instance.getSubstitutionType().getElementId(), NodeType.class));
     NodeType nodeType = ToscaContext.get(NodeType.class, instance.getSubstitutionType().getElementId());


Input:
public static CellList getWFSRootChildren(String root) {
    try {
        URL url = getURL(WFS_PREFIX + root + "String_Node_Str");
        return CellList.decode("String_Node_Str", url.openStream());
    } catch (java.lang.Exception excp) {
        LOGGER.log(Level.INFO, "String_Node_Str" + root, excp);
        return null;
    }
}

Output:
     } catch (java.lang.Exception excp) {
-        LOGGER.log(Level.INFO, "String_Node_Str" + root, excp);
+        LOGGER.log(Level.WARNING, "String_Node_Str" + root, excp);
         return null;


Input:
protected boolean _close() {
    if (getEffigy() == null) {
        return super._close();
    }
    Effigy topEffigy = getEffigy().topEffigy();
    if (!_tableau.isMaster()) {
        List tableaux = topEffigy.entityList(Tableau.class);
        Iterator tableauxIterator = tableaux.iterator();
        while (tableauxIterator.hasNext()) {
            Tableau tableau = (Tableau) tableauxIterator.next();
            if (!(tableau instanceof DialogTableau) && (tableau != _tableau)) {
                dispose();
                return true;
            }
        }
    }
    return super._close();
}

Output:
     }
-    return super._close();
+    if (isModified()) {
+        int reply = _queryForSave();
+        if (reply == _DISCARDED || reply == _FAILED) {
+            if (!_checkForDerivedObjects()) {
+                return false;
+            }
+            dispose();
+            return true;
+        }
+        return false;
+    } else {
+        dispose();
+        return true;
+    }
 }


Input:
private boolean useMmap(long currentFileSize) {
    final long maxSize = 500 * 1024 * 1024;
    System.out.println("String_Node_Str" + OutputUtils.formatBytes(totalOnDiskSize + currentFileSize));
    return "String_Node_Str".equals(System.getProperty("String_Node_Str")) || totalOnDiskSize + currentFileSize < maxSize;
}

Output:
     final long maxSize = 500 * 1024 * 1024;
-    System.out.println("String_Node_Str" + OutputUtils.formatBytes(totalOnDiskSize + currentFileSize));
+    Logging.logMessage(Logging.LEVEL_DEBUG, this, "String_Node_Str" + OutputUtils.formatBytes(totalOnDiskSize + currentFileSize));
     return "String_Node_Str".equals(System.getProperty("String_Node_Str")) || totalOnDiskSize + currentFileSize < maxSize;


Input:
public void setProfilePic(Bitmap b) {
    this.profilePicture = Bitmap.createScaledBitmap(b, 80, 80, true);
}

Output:
 public void setProfilePic(Bitmap b) {
-    this.profilePicture = Bitmap.createScaledBitmap(b, 80, 80, true);
+    this.profilePicture = Bitmap.createScaledBitmap(b, Constants.size_Profile_Picture_Width, Constants.size_Profile_Picture_Heigth, true);
 }


Input:
public void testGetSummonerById() throws InterruptedException {
    Thread.sleep(1500);
    handler.getSummoner(SUMMONER_ID_2);
}

Output:
 public void testGetSummonerById() throws InterruptedException {
-    Thread.sleep(1500);
-    handler.getSummoner(SUMMONER_ID_2);
+    try {
+        Thread.sleep(1500);
+        handler.getSummoner(SUMMONER_ID_2);
+    } catch (RequestException ex) {
+        System.out.println("String_Node_Str");
+        ex.printStackTrace();
+    }
 }


Input:
public State decode(ByteBuffer buffer) throws LineTooLargeException, ProtocolException, AbortException {
    String line;
    while (buffer.hasRemaining() && state != State.ALL_READ) {
        switch(state) {
            case READ_INITIAL:
                if ((line = lineReader.readLine(buffer)) != null) {
                    parseInitialLine(line);
                }
                break;
            case READ_HEADER:
                readHeaders(buffer);
                break;
            case READ_CHUNK_SIZE:
                line = lineReader.readLine(buffer);
                if (line != null && !line.isEmpty()) {
                    readRemaining = getChunkSize(line);
                    if (readRemaining == 0) {
                        state = READ_CHUNK_FOOTER;
                    } else {
                        state = READ_CHUNKED_CONTENT;
                    }
                }
                break;
            case READ_FIXED_LENGTH_CONTENT:
                readBody(buffer, ALL_READ);
                break;
            case READ_CHUNKED_CONTENT:
                readBody(buffer, READ_CHUNK_DELIMITER);
                break;
            case READ_CHUNK_FOOTER:
                readEmptyLine(buffer);
                state = ALL_READ;
                break;
            case READ_CHUNK_DELIMITER:
                readEmptyLine(buffer);
                state = READ_CHUNK_SIZE;
                break;
            case READ_VARIABLE_LENGTH_CONTENT:
                readBody(buffer, null);
                break;
        }
    }
    return state;
}

Output:
             case READ_CHUNK_FOOTER:
-                readEmptyLine(buffer);
-                state = ALL_READ;
+                readEmptyLine(buffer, ALL_READ);
                 break;


Input:
private void unsetInternal(Property property, boolean updateSequence) {
    if (property.isMany()) {
        getList(property).clear();
        if (property.isOpenContent()) {
            removeOpenContentProperty(property);
        } else {
            _getCurrentValueStore().unsetDeclaredProperty(((SDOProperty) property).getIndexInType());
        }
    } else {
        if (property.isOpenContent()) {
            _getCurrentValueStore().unsetOpenContentProperty(property);
            removeOpenContentProperty(property);
        } else {
            _getCurrentValueStore().unsetDeclaredProperty(((SDOProperty) property).getIndexInType());
        }
    }
    if (type.isSequenced() && (sequence != null) && updateSequence && aHelperContext.getXSDHelper().isElement(property)) {
        ((SDOSequence) sequence).removeSettingWithoutModifyingDataObject(property);
    }
}

Output:
     if (type.isSequenced() && (sequence != null) && updateSequence && aHelperContext.getXSDHelper().isElement(property)) {
-        ((SDOSequence) sequence).removeSettingWithoutModifyingDataObject(property);
+        sequence.removeSettingWithoutModifyingDataObject(property);
     }


Input:
public List<String> messageMaker(List<String[]> sms) {
    List<String> messageList = new ArrayList<String>();
    for (int i = 0; i < sms.size(); i++) {
        messageList.add(sms.get(i)[1] + "String_Node_Str" + sms.get(i)[2]);
    }
    return messageList;
}

Output:
     for (int i = 0; i < sms.size(); i++) {
-        messageList.add(sms.get(i)[1] + "String_Node_Str" + sms.get(i)[2]);
+        messageList.add(sms.get(i)[1] + "String_Node_Str" + sms.get(i)[0] + "String_Node_Str" + sms.get(i)[2]);
     }


Input:
public BigDecimal getCost() {
    Collection<Date> dates = workdays.getWorkdays(pop);
    BigDecimal total = BigDecimal.ZERO;
    for (Date date : dates) {
        try {
            CostData cost = Invoice.cost(categoriesById, projectBillRates, task.getProject().getId(), employee.getNumber(), task, SQLUtilities.convert(date), 8, dataSource);
            if (cost.getLaborCategory() == null) {
                return BigDecimal.ZERO;
            }
            total = total.add(cost.getCost());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    return total;
}

Output:
         try {
-            CostData cost = Invoice.cost(categoriesById, projectBillRates, task.getProject().getId(), employee.getNumber(), task, SQLUtilities.convert(date), 8, dataSource);
+            CostData cost = Invoice.cost(categoriesById, projectBillRates, task.getProject().getId(), employee.getNumber(), task, SQLUtilities.convert(date), duration, dataSource);
             if (cost.getLaborCategory() == null) {


Input:
public EntryObject key() {
    Expression expression = new Expression() {
        public Object getValue(Object obj) {
            MapEntry entry = (MapEntry) obj;
            return entry.getKey();
        }
    };
    qb.exp = expression;
    return this;
}

Output:
 public EntryObject key() {
-    Expression expression = new Expression() {
-        public Object getValue(Object obj) {
-            MapEntry entry = (MapEntry) obj;
-            return entry.getKey();
-        }
-    };
+    Expression expression = new EntryKeyObject();
     qb.exp = expression;


Input:
public int category(Object element) {
    if (element instanceof RepositoryNode) {
        RepositoryNode node = (RepositoryNode) element;
        if (ERepositoryObjectType.METADATA_CON_COLUMN.equals(node.getProperties(EProperties.CONTENT_TYPE))) {
            RepositoryNode parent = node.getParent().getParent();
            if (parent != null && ERepositoryObjectType.METADATA_CON_TABLE.equals(parent.getProperties(EProperties.CONTENT_TYPE)) && parent.getObject() instanceof MetadataTableRepositoryObject) {
                MetadataTableRepositoryObject tableObject = (MetadataTableRepositoryObject) parent.getObject();
                MetadataColumnRepositoryObject columnObject = (MetadataColumnRepositoryObject) ((RepositoryNode) element).getObject();
                return tableObject.getTable().getColumns().indexOf(columnObject.getTdColumn());
            }
        }
    }
    return super.category(element);
}

Output:
                 MetadataColumnRepositoryObject columnObject = (MetadataColumnRepositoryObject) ((RepositoryNode) element).getObject();
-                return tableObject.getTable().getColumns().indexOf(columnObject.getTdColumn());
+                MetadataColumn tColumn = columnObject.getTdColumn();
+                EList<MetadataColumn> columns = tableObject.getTable().getColumns();
+                for (int i = 0; i < columns.size(); i++) {
+                    MetadataColumn column = columns.get(i);
+                    if (column.getName() != null && column.getName().equals(tColumn.getName())) {
+                        return i;
+                    }
+                }
             }


Input:
public void handleDoneClicked() {
    TurboIssueCommand command;
    String message = "String_Node_Str";
    boolean success = false;
    if (mode == IssueEditMode.CREATE) {
        command = new TurboIssueAdd(model, displayedIssue);
        success = command.execute();
        if (success) {
            displayedIssue.copyValues(((TurboIssueAdd) command).getAddedIssue());
            issueEditDisplay.updateIssueId(displayedIssue.getId());
            message = "String_Node_Str";
        } else {
            message = "String_Node_Str";
        }
    } else if (mode == IssueEditMode.EDIT) {
        command = new TurboIssueEdit(model, originalIssue, displayedIssue);
        success = command.execute();
        if (success) {
            message = "String_Node_Str";
        } else {
            message = "String_Node_Str";
        }
    }
    StatusBar.displayMessage(message);
    if (success && !expandedIssueView) {
        showIssueDetailsDisplay(false);
        cleanup();
        parentPanel.get().displayTabs();
    }
}

Output:
         if (success) {
-            displayedIssue.copyValues(((TurboIssueAdd) command).getAddedIssue());
-            issueEditDisplay.updateIssueId(displayedIssue.getId());
+            updateStateAfterSuccessfulAdd(((TurboIssueAdd) command).getAddedIssue());
             message = "String_Node_Str";


Input:
public V put(long key, V value) {
    if ((key == FastByIDMap.NULL) || (key == FastByIDMap.REMOVED)) {
        throw new IllegalArgumentException();
    }
    if (value == null) {
        throw new NullPointerException();
    }
    if (numSlotsUsed * FastByIDMap.ALLOWED_LOAD_FACTOR >= keys.length) {
        if (numEntries * FastByIDMap.ALLOWED_LOAD_FACTOR >= numSlotsUsed) {
            growAndRehash();
        } else {
            rehash();
        }
    }
    int index = findForAdd(key);
    long keyIndex = keys[index];
    if (keyIndex == key) {
        V oldValue = values[index];
        values[index] = value;
        return oldValue;
    } else {
        if (countingAccesses && (numEntries >= maxSize)) {
            clearStaleEntry(index);
        }
        keys[index] = key;
        values[index] = value;
        numEntries++;
        if (keyIndex == FastByIDMap.NULL) {
            numSlotsUsed++;
        }
        return null;
    }
}

Output:
 public V put(long key, V value) {
-    if ((key == FastByIDMap.NULL) || (key == FastByIDMap.REMOVED)) {
+    if ((key == NULL) || (key == REMOVED)) {
         throw new IllegalArgumentException();


Input:
public void paint(Graphics graphics) {
    if (graphics.getAlpha() != -1) {
        graphics.setAlpha(-1);
    }
    errorFigure.setLocation(jobletContainer.getErrorLocation());
    super.paint(graphics);
}

Output:
 public void paint(Graphics graphics) {
-    if (graphics.getAlpha() != -1) {
-        graphics.setAlpha(-1);
-    }
+    graphics.setAlpha(100);
     errorFigure.setLocation(jobletContainer.getErrorLocation());


Input:
public int executeBatch() {
    String persistenceUnit = null;
    Cassandra.Client conn = null;
    Object pooledConnection = null;
    Map<Class<?>, Map<ByteBuffer, Map<String, List<Mutation>>>> batchMutationMap = new HashMap<Class<?>, Map<ByteBuffer, Map<String, List<Mutation>>>>();
    int recordsExecuted = 0;
    String batchQuery = CQLTranslator.BATCH_QUERY;
    batchQuery = StringUtils.replace(batchQuery, CQLTranslator.STATEMENT, "String_Node_Str");
    StringBuilder batchQueryBuilder = new StringBuilder(batchQuery);
    try {
        boolean isCql3Enabled = false;
        for (Node node : nodes) {
            if (node.isDirty()) {
                node.handlePreEvent();
                Object entity = node.getData();
                Object id = node.getEntityId();
                EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(node.getDataClass());
                persistenceUnit = metadata.getPersistenceUnit();
                isUpdate = node.isUpdate();
                MetamodelImpl metaModel = (MetamodelImpl) KunderaMetadata.INSTANCE.getApplicationMetadata().getMetamodel(metadata.getPersistenceUnit());
                if (isCql3Enabled(metadata)) {
                    isCql3Enabled = true;
                    List<RelationHolder> relationHolders = getRelationHolders(node);
                    String query;
                    if (node.isInState(RemovedState.class)) {
                        query = onDeleteQuery(metadata, metaModel, id);
                    } else {
                        query = createInsertQuery(metadata, entity, conn, relationHolders, getTtlValues().get(metadata.getTableName()));
                    }
                    batchQueryBuilder.append(query);
                } else {
                    if (node.isInState(RemovedState.class)) {
                        delete(entity, id);
                    } else {
                        List<RelationHolder> relationHolders = getRelationHolders(node);
                        Map<ByteBuffer, Map<String, List<Mutation>>> mutationMap = new HashMap<ByteBuffer, Map<String, List<Mutation>>>();
                        mutationMap = prepareMutation(metadata, entity, id, relationHolders, mutationMap);
                        recordsExecuted += mutationMap.size();
                        if (!batchMutationMap.containsKey(metadata.getEntityClazz())) {
                            batchMutationMap.put(metadata.getEntityClazz(), mutationMap);
                        } else {
                            batchMutationMap.get(metadata.getEntityClazz()).putAll(mutationMap);
                        }
                        indexNode(node, metadata);
                    }
                }
                node.handlePostEvent();
            }
        }
        if (!batchMutationMap.isEmpty()) {
            pooledConnection = getConection(persistenceUnit);
            conn = getConnection(pooledConnection);
            for (Class<?> entityClass : batchMutationMap.keySet()) {
                conn.batch_mutate(batchMutationMap.get(entityClass), consistencyLevel);
            }
        }
        if (!nodes.isEmpty() && isCql3Enabled) {
            batchQueryBuilder.append(CQLTranslator.APPLY_BATCH);
            executeCQLQuery(batchQueryBuilder.toString());
        }
    } catch (InvalidRequestException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } catch (TException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } catch (UnavailableException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } catch (TimedOutException e) {
        log.error("String_Node_Str" + e);
        throw new KunderaException(e);
    } catch (SchemaDisagreementException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } finally {
        clear();
        if (pooledConnection != null) {
            releaseConnection(pooledConnection);
        }
    }
    return recordsExecuted;
}

Output:
             batchQueryBuilder.append(CQLTranslator.APPLY_BATCH);
-            executeCQLQuery(batchQueryBuilder.toString());
+            executeCQLQuery(batchQueryBuilder.toString(), false);
         }


Input:
public Map<String, TopicDescription> getTopicAndDescriptions() {
    ListTopicsOptions lto = new ListTopicsOptions();
    lto.timeoutMs(10 * 1000);
    ListTopicsResult ltr = adminClient.listTopics(lto);
    try {
        DescribeTopicsOptions dto = new DescribeTopicsOptions();
        dto.timeoutMs(15 * 1000);
        DescribeTopicsResult dtr = adminClient.describeTopics(ltr.names().get(), dto);
        return dtr.all().get();
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e);
    }
    return null;
}

Output:
     } catch (Exception e) {
-        LOGGER.error("String_Node_Str", e);
+        throw e;
     }


Input:
public void changePlayerAt(ShortPoint2D position, Player player) {
    partitionsGrid.changePlayerAt(position, player.playerId);
    bordersThread.checkPosition(position);
    landmarksCorrection.addLandmarkedPosition(position);
}

Output:
     bordersThread.checkPosition(position);
-    landmarksCorrection.addLandmarkedPosition(position);
+    checkForEnclosedBlockedArea(position);
 }


Input:
public void fire() {
    final TaskLink currentTaskLink = taskLinks.takeOut();
    if (currentTaskLink == null) {
        return;
    }
    memory.setCurrentTaskLink(currentTaskLink);
    memory.setCurrentBeliefLink(null);
    if (memory.getRecorder().isActive()) {
        memory.getRecorder().append("String_Node_Str" + currentTaskLink + "String_Node_Str");
    }
    final Task task = currentTaskLink.getTargetTask();
    memory.setCurrentTask(task);
    if (currentTaskLink.getType() == TermLink.TRANSFORM) {
        memory.setCurrentBelief(null);
        RuleTables.transformTask(currentTaskLink, memory);
    } else {
        int termLinkCount = Parameters.MAX_REASONED_TERM_LINK;
        while (termLinkCount > 0) {
            final TermLink termLink = termLinks.takeOut(currentTaskLink, memory.getTime());
            if (termLink != null) {
                if (memory.getRecorder().isActive()) {
                    memory.getRecorder().append("String_Node_Str" + termLink + "String_Node_Str");
                }
                memory.setCurrentBeliefLink(termLink);
                RuleTables.reason(currentTaskLink, termLink, memory);
                termLinks.putBack(termLink);
                termLinkCount--;
            } else {
                termLinkCount = 0;
            }
        }
    }
    taskLinks.putBack(currentTaskLink);
}

Output:
     memory.setCurrentTask(task);
-    if (currentTaskLink.getType() == TermLink.TRANSFORM) {
+    if (currentTaskLink.type == TermLink.TRANSFORM) {
         memory.setCurrentBelief(null);


Input:
private static Reader manifestReaderFromFile(File file) throws IOException {
    try {
        StringWriter writer = new StringWriter();
        FileCopyUtils.copy(new InputStreamReader(new FileInputStream(file)), writer);
        return new StringReader(writer.toString());
    } catch (IOException ioe) {
        throw new IOException("String_Node_Str", ioe);
    }
}

Output:
         StringWriter writer = new StringWriter();
-        FileCopyUtils.copy(new InputStreamReader(new FileInputStream(file)), writer);
+        FileCopyUtils.copy(new InputStreamReader(new FileInputStream(file), UTF_8), writer);
         return new StringReader(writer.toString());


Input:
public Set<Template> buildTemplates(String s) {
    boolean clearAgain = true;
    String tagged;
    if (UNTAGGED_INPUT) {
        s = pp.normalize(s);
        tagged = tagger.tag(s);
        logger.trace("String_Node_Str" + tagged);
    } else {
        tagged = s;
        s = extractSentence(tagged);
    }
    String newtagged;
    if (USE_NER) {
        newtagged = pp.condenseNominals(pp.findNEs(tagged, s));
    } else
        newtagged = pp.condenseNominals(tagged);
    newtagged = pp.condense(newtagged);
    logger.trace("String_Node_Str" + newtagged);
    p.parse(newtagged, g);
    if (p.getDerivationTrees().isEmpty()) {
        p.clear(g, p.getTemps());
        clearAgain = false;
        logger.error("String_Node_Str" + s + "String_Node_Str");
    } else {
        try {
            p.buildDerivedTrees(g);
        } catch (ParseException e) {
            logger.error("String_Node_Str" + e.getMessage() + "String_Node_Str", e);
        }
    }
    Hashtable<String, String> postable = new Hashtable<String, String>();
    for (String st : newtagged.split("String_Node_Str")) {
        postable.put(st.substring(0, st.indexOf("String_Node_Str")).toLowerCase(), st.substring(st.indexOf("String_Node_Str") + 1));
        ;
    }
    Set<DRS> drses = new HashSet<DRS>();
    Set<Template> templates = new HashSet<Template>();
    for (Dude dude : p.getDudes()) {
        UDRS udrs = d2u.convert(dude);
        if (udrs != null) {
            for (DRS drs : udrs.initResolve()) {
                List<Slot> slots = new ArrayList<Slot>();
                slots.addAll(dude.getSlots());
                d2s.setSlots(slots);
                d2s.redundantEqualRenaming(drs);
                if (!containsModuloRenaming(drses, drs)) {
                    drses.add(drs);
                    try {
                        Template temp = d2s.convert(drs, slots);
                        if (temp == null) {
                            continue;
                        }
                        List<String> newwords;
                        String word;
                        String pos;
                        for (Slot slot : temp.getSlots()) {
                            if (!slot.getWords().isEmpty()) {
                                word = slot.getWords().get(0);
                                pos = postable.get(word.toLowerCase().replace("String_Node_Str", "String_Node_Str"));
                                POS wordnetpos = null;
                                if (pos != null) {
                                    if (equalsOneOf(pos, noun)) {
                                        wordnetpos = POS.NOUN;
                                    } else if (equalsOneOf(pos, adjective)) {
                                        wordnetpos = POS.ADJECTIVE;
                                    } else if (equalsOneOf(pos, verb)) {
                                        wordnetpos = POS.VERB;
                                    }
                                }
                                List<String> strings = new ArrayList<String>();
                                if (wordnetpos != null && wordnetpos.equals(POS.ADJECTIVE)) {
                                    strings = wordnet.getAttributes(word);
                                }
                                newwords = new ArrayList<String>();
                                newwords.add(word);
                                newwords.addAll(strings);
                                if (wordnetpos != null && !slot.getSlotType().equals(SlotType.RESOURCE)) {
                                    newwords.addAll(wordnet.getBestSynonyms(wordnetpos, getLemmatizedWord(word)));
                                    for (String att : getLemmatizedWords(strings)) {
                                        newwords.addAll(wordnet.getBestSynonyms(wordnetpos, att));
                                    }
                                }
                                if (newwords.isEmpty()) {
                                }
                                if (newwords.isEmpty()) {
                                    newwords.add(slot.getWords().get(0));
                                }
                                List<String> newwordslist = new ArrayList<String>();
                                newwordslist.addAll(newwords);
                                slot.setWords(newwordslist);
                            }
                        }
                        templates.add(temp);
                    } catch (java.lang.ClassCastException e) {
                        continue;
                    }
                    if (ONE_SCOPE_ONLY) {
                        break;
                    }
                }
            }
        }
    }
    if (clearAgain) {
        p.clear(g, p.getTemps());
    }
    System.gc();
    return templates;
}

Output:
                                 newwords = new ArrayList<String>();
-                                newwords.add(word);
+                                newwords.addAll(slot.getWords());
                                 newwords.addAll(strings);


Input:
protected boolean playManaHandling(ManaCost unpaid, Game game) {
    updateGameStatePriority("String_Node_Str", game);
    game.firePlayManaEvent(playerId, "String_Node_Str" + unpaid.getText());
    waitForResponse(game);
    if (!this.isInGame()) {
        return false;
    }
    if (response.getBoolean() != null) {
        return false;
    } else if (response.getUUID() != null) {
        playManaAbilities(unpaid, game);
    } else if (response.getString() != null && response.getString().equals("String_Node_Str")) {
        if (unpaid instanceof ManaCostsImpl) {
            specialManaAction(unpaid, game);
            ManaCostsImpl<ManaCost> costs = (ManaCostsImpl<ManaCost>) unpaid;
            for (ManaCost cost : costs.getUnpaid()) {
                if (cost instanceof PhyrexianManaCost) {
                    PhyrexianManaCost ph = (PhyrexianManaCost) cost;
                    if (ph.canPay(null, null, playerId, game)) {
                        ((PhyrexianManaCost) cost).pay(null, game, null, playerId, false);
                    }
                    break;
                }
            }
        }
    } else if (response.getManaType() != null) {
        if (response.getResponseManaTypePlayerId().equals(this.getId())) {
            this.getManaPool().unlockManaType(response.getManaType());
        }
    }
    return true;
}

Output:
     updateGameStatePriority("String_Node_Str", game);
-    game.firePlayManaEvent(playerId, "String_Node_Str" + unpaid.getText());
+    game.firePlayManaEvent(playerId, "String_Node_Str" + promptText);
     waitForResponse(game);