Input:
public void scrollTo(int x, int y) {
    y = Math.min(mMaxScrollY, y);
    y = Math.max(0, y);
    if (mListener != null && mCurrentSpec != null) {
        int index = Math.min(mAllImages.getCount(), Math.max(0, computeSelectedIndex(x, y)));
        mListener.onScroll(index);
    }
    super.scrollTo(x, y);
}

Output:
 public void scrollTo(int x, int y) {
-    y = Math.min(mMaxScrollY, y);
-    y = Math.max(0, y);
+    y = Math.max(0, Math.min(mMaxScrollY, y));
     if (mListener != null && mCurrentSpec != null) {


Input:
public void send(int channelindex, Token token, double delay) throws IllegalActionException {
    _delay = delay;
    _useDelay = true;
    send(channelindex, token);
}

Output:
     _useDelay = true;
-    send(channelindex, token);
+    send(channelIndex, token);
 }


Input:
public void testAutomatedBidding() {
    GBController mainController = makeController();
    Auctioneer auction = mainController.getBiddingController().getAuction();
    System.out.println("String_Node_Str");
    mainController.getBiddingController().getCardHolder().printHands();
    System.out.println("String_Node_Str" + auction.getCalls());
    int initialBids = auction.getCalls().size();
    mainController.getBiddingController().placeBid(4, "String_Node_Str");
    System.out.println("String_Node_Str" + auction.getCalls());
    assertEquals("String_Node_Str", initialBids + 4, auction.getCalls().size());
}

Output:
     System.out.println("String_Node_Str");
-    mainController.getBiddingController().getCardHolder().printHands();
+    mainController.getBiddingController().getCardHolder().printHandsDebug();
     System.out.println("String_Node_Str" + auction.getCalls());


Input:
public int getDataSetSize() {
    return knownDataSeries.size();
}

Output:
 public int getDataSetSize() {
-    return knownDataSeries.size();
+    return plotDataManager.size();
 }


Input:
final boolean appendValue(final Object value) {
    if (value.getClass().isArray()) {
        appendSeparator();
        buffer.appendCodePoint(symbols.getOpenSequence());
        final int length = Array.getLength(value);
        for (int i = 0; i < length; i++) {
            appendAny(Array.get(value, i));
        }
        buffer.appendCodePoint(symbols.getCloseSequence());
    } else if (value instanceof Number) {
        final Number number = (Number) value;
        if (Numbers.isInteger(number.getClass())) {
            append(number.longValue());
        } else {
            append(number.doubleValue());
        }
    } else if (value instanceof CodeList<?>)
        append((CodeList<?>) value);
    else if (value instanceof Date)
        append((Date) value);
    else if (value instanceof Boolean)
        append((Boolean) value);
    else if (value instanceof CharSequence) {
        append((value instanceof InternationalString) ? ((InternationalString) value).toString(locale) : value.toString(), null);
    } else {
        return false;
    }
    return true;
}

Output:
         }
-    } else if (value instanceof CodeList<?>)
-        append((CodeList<?>) value);
+    } else if (value instanceof Enumerated)
+        append((Enumerated) value);
     else if (value instanceof Date)


Input:
protected ItemStack distributeItemToPipes(ItemStack itemToDistribute) {
    if (itemToDistribute == null) {
        return null;
    }
    ForgeDirection[] dirsToCheck = { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.EAST, ForgeDirection.WEST };
    for (ForgeDirection dir : dirsToCheck) {
        TileEntity te = this.worldObj.getBlockTileEntity(xCoord + dir.offsetX, yCoord + dir.offsetY, zCoord + dir.offsetZ);
        if (te != null && te instanceof IPipeEntry) {
            IPipeEntry pipe = (IPipeEntry) te;
            if (pipe.acceptItems()) {
                pipe.entityEntering(itemToDistribute.copy(), dir.getOpposite());
                return null;
            }
        }
    }
    return itemToDistribute;
}

Output:
             if (pipe.acceptItems()) {
-                pipe.entityEntering(itemToDistribute.copy(), dir.getOpposite());
+                pipe.entityEntering(itemToDistribute.copy(), dir);
                 return null;


Input:
public void afterInvocation(IInvokedMethod method, ITestResult testResult) {
    if (ListenerManager.executeCurrentMethod(this) == false) {
        logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
        return;
    }
}

Output:
 public void afterInvocation(IInvokedMethod method, ITestResult testResult) {
-    if (ListenerManager.executeCurrentMethod(this) == false) {
-        logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
-        return;
+    try {
+        if (ListenerManager.executeCurrentMethod(this) == false) {
+            logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
+            return;
+        }
+    } catch (Exception e) {
+        logger.log(Level.WARNING, "String_Node_Str" + e.getMessage(), e);
     }


Input:
public void accumulate(int missed, int covered) {
    this.missed += missed;
    this.covered += covered;
    initialized = true;
}

Output:
 public void accumulate(int missed, int covered) {
-    this.missed += missed;
-    this.covered += covered;
+    this.missed = missed;
+    this.covered = covered;
     initialized = true;


Input:
public static final BufferedReader createBufferedReader(final InputStream is, final Charset charset) {
    if (is == null)
        throw new NullPointerException("String_Node_Str");
    if (charset != null)
        return new BufferedReader(new InputStreamReader(is, charset));
    return new BufferedReader(new InputStreamReader(is, charset != null ? charset : Charset.forName(CHARSET)));
}

Output:
         return new BufferedReader(new InputStreamReader(is, charset));
-    return new BufferedReader(new InputStreamReader(is, charset != null ? charset : Charset.forName(CHARSET)));
+    return new BufferedReader(new InputStreamReader(is, Charset.forName(CHARSET)));
 }


Input:
public final void readHeader() throws IOException {
    if (!isHeaderLoaded()) {
        final IntSet targetNumbers = new IntArraySet();
        int readerIndex = 0;
        ObjectList<String> alignerNames = new ObjectArrayList<String>();
        ObjectList<String> alignerVersions = new ObjectArrayList<String>();
        numberOfQueries = 0;
        smallestQueryIndex = Integer.MAX_VALUE;
        largestQueryIndex = adjustQueryIndices ? Integer.MIN_VALUE : 0;
        readOriginPermutations = new int[readers.length][];
        for (final AlignmentReader reader : readers) {
            reader.readHeader();
            String alignerName = reader.getAlignerName();
            String alignerVersion = reader.getAlignerVersion();
            if (!(alignerNames.contains(alignerName) && alignerVersions.contains(alignerVersion))) {
                alignerNames.add(alignerName);
                alignerVersions.add(alignerVersion);
            }
            smallestQueryIndex = Math.min(reader.getSmallestSplitQueryIndex(), smallestQueryIndex);
            largestQueryIndex = adjustQueryIndices ? Math.max(largestQueryIndex, 0) + 1 + reader.getLargestSplitQueryIndex() : Math.max(reader.getLargestSplitQueryIndex(), largestQueryIndex);
            targetNumbers.add(reader.getNumberOfTargets());
            final int numQueriesForReader = reader.getNumberOfQueries();
            numQueriesPerReader[readerIndex] = numQueriesForReader;
            numberOfQueries += numQueriesForReader;
            numberOfAlignedReads += reader.getNumberOfAlignedReads();
            mergeReadOrigins(readerIndex, reader.getReadOriginInfo().getPbList());
            readerIndex++;
        }
        alignerName = alignerNames.toString();
        alignerVersion = alignerVersions.toString();
        if (targetNumbers.size() != 1) {
            throw new IllegalArgumentException("String_Node_Str" + targetNumbers.toString());
        } else {
            this.numberOfTargets = targetNumbers.iterator().nextInt();
        }
        targetIdentifiers = new IndexedIdentifier();
        boolean error = false;
        for (final AlignmentReader reader : readers) {
            IndexedIdentifier targetIds = reader.getTargetIdentifiers();
            for (MutableString key : targetIds.keySet()) {
                if (!targetIdentifiers.containsKey(key)) {
                    targetIdentifiers.put(key, targetIds.getInt(key));
                } else {
                    final int globalValue = targetIdentifiers.getInt(key);
                    final int localValue = targetIds.getInt(key);
                    if (globalValue != localValue) {
                        error = true;
                        LOG.error(String.format("String_Node_Str", key, globalValue, localValue, reader.basename()));
                    }
                }
            }
        }
        if (error) {
            throw new RuntimeException("String_Node_Str");
        }
        targetLengths = new int[targetIdentifiers.size()];
        for (int targetIndex = 0; targetIndex < targetIdentifiers.size(); targetIndex++) {
            int maxLength = -1;
            for (final AlignmentReader reader : readers) {
                final int[] readerLengths = reader.getTargetLength();
                if (readerLengths != null && readerLengths.length > targetIndex) {
                    maxLength = Math.max(readerLengths[targetIndex], maxLength);
                    targetLengths[targetIndex] = maxLength;
                }
            }
        }
        for (int i = 0; i < queryIndexOffset.length; i++) {
            queryIndexOffset[i] = adjustQueryIndices ? i == 0 ? 0 : readers[i - 1].getLargestSplitQueryIndex() + 1 : 0;
        }
    }
    setHeaderLoaded(true);
}

Output:
             numberOfAlignedReads += reader.getNumberOfAlignedReads();
-            mergeReadOrigins(readerIndex, reader.getReadOriginInfo().getPbList());
+            mergeReadOrigins(readerIndex, reader.getReadOriginInfo().getPbList(), readers.length);
             readerIndex++;


Input:
public void removeDBRef(File filePath) {
    DB db = dbMap.get(filePath);
    if (db == null) {
        return;
    }
    Integer refConut = dbRefCountMap.get(db);
    if (refConut == null) {
        return;
    }
    refConut--;
    if (refConut > 0) {
        dbRefCountMap.put(db, refConut);
    } else {
        dbRefCountMap.remove(db);
        dbMap.remove(filePath);
        closeDB(db);
    }
}

Output:
         dbRefCountMap.remove(db);
-        dbMap.remove(filePath);
-        closeDB(db);
+        closeDB(db, filePath);
     }


Input:
public final Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
    try {
        Class<?> domainClass = getDomainClass(genericType);
        JAXBContext jaxbContext = getJAXBContext(domainClass, annotations, mediaType, httpHeaders);
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, MediaType.APPLICATION_JSON);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_ATTRIBUTE_PREFIX, attributePrefix);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, includeRoot);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_PREFIX_MAPPER, namespacePrefixMapper);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_SEPARATOR, namespaceSeperator);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_VALUE_WRAPPER, valueWrapper);
        preReadFrom(type, genericType, annotations, mediaType, httpHeaders, unmarshaller);
        StreamSource jsonSource;
        Map<String, String> mediaTypeParameters = mediaType.getParameters();
        if (mediaTypeParameters.containsKey(CHARSET)) {
            String charSet = mediaTypeParameters.get(CHARSET);
            Reader entityReader = new InputStreamReader(entityStream, charSet);
            jsonSource = new StreamSource(entityReader);
        } else {
            jsonSource = new StreamSource(entityStream);
        }
        return unmarshaller.unmarshal(jsonSource, domainClass).getValue();
    } catch (JAXBException jaxbException) {
        throw new WebApplicationException(jaxbException);
    }
}

Output:
         }
-        return unmarshaller.unmarshal(jsonSource, domainClass).getValue();
+        JAXBElement<?> jaxbElement = unmarshaller.unmarshal(jsonSource, domainClass);
+        if (type.isAssignableFrom(JAXBElement.class)) {
+            return jaxbElement;
+        } else {
+            return jaxbElement.getValue();
+        }
     } catch (JAXBException jaxbException) {


Input:
public void defineDataSet(IBaseDataSetDesign dataSet) throws DataException {
    logger.entering(DataEngineImpl.class.getName(), "String_Node_Str", dataSet == null ? null : dataSet.getName());
    if (dataSet == null) {
        NullPointerException e = new NullPointerException("String_Node_Str");
        logger.logp(Level.WARNING, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str", e);
        throw e;
    }
    if (dataSources == null) {
        IllegalStateException e = new IllegalStateException("String_Node_Str");
        logger.logp(Level.WARNING, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str", e);
        throw e;
    }
    String name = dataSet.getName();
    if (name == null || name.length() == 0) {
        IllegalArgumentException e = new IllegalArgumentException("String_Node_Str");
        logger.logp(Level.WARNING, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str", e);
        throw e;
    }
    if (logger.isLoggable(Level.FINE))
        logger.logp(Level.FINE, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str" + LogUtil.toString(dataSet));
    if (!(dataSet instanceof IJointDataSetDesign)) {
        String dataSourceName = dataSet.getDataSourceName();
        DataSourceRuntime dsource = this.getDataSourceRuntime(dataSourceName);
        if (dsource == null) {
            DataException e = new DataException(ResourceConstants.UNDEFINED_DATA_SOURCE, dataSourceName);
            logger.logp(Level.WARNING, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str" + dataSourceName + "String_Node_Str", e);
            throw e;
        }
        Class dSourceClass;
        if (dataSet instanceof IOdaDataSetDesign)
            dSourceClass = IOdaDataSourceDesign.class;
        else if (dataSet instanceof IScriptDataSetDesign)
            dSourceClass = IScriptDataSourceDesign.class;
        else {
            DataException e = new DataException(ResourceConstants.UNSUPPORTED_DATASET_TYPE);
            logger.logp(Level.WARNING, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str" + dataSet.getName(), e);
            throw e;
        }
        if (!dSourceClass.isInstance(dsource.getDesign())) {
            DataException e = new DataException(ResourceConstants.UNSUPPORTED_DATASOURCE_TYPE, dsource.getName());
            logger.logp(Level.WARNING, DataEngineImpl.class.getName(), "String_Node_Str", "String_Node_Str" + dsource.getName(), e);
            throw e;
        }
    }
    dataSetDesigns.put(name, dataSet);
    logger.exiting(DataEngineImpl.class.getName(), "String_Node_Str");
}

Output:
 public void defineDataSet(IBaseDataSetDesign dataSet) throws DataException {
-    logger.entering(DataEngineImpl.class.getName(), "String_Node_Str", dataSet == null ? null : dataSet.getName());
+    logger.entering(DataEngineImpl.class.getName(), "String_Node_Str", dataSet == null ? "String_Node_Str" : dataSet.getName());
     if (dataSet == null) {


Input:
private void rename0(CharSequence tableName, CharSequence to) {
    final FilesFacade ff = configuration.getFilesFacade();
    final CharSequence root = configuration.getRoot();
    try (Path oldName = new Path()) {
        try (Path newName = new Path()) {
            if (TableUtils.exists(ff, oldName, root, tableName) != TableUtils.TABLE_EXISTS) {
                LOG.error().$('\'').utf8(tableName).$("String_Node_Str").$();
                throw CairoException.instance(0).put("String_Node_Str").put(tableName).put("String_Node_Str");
            }
            if (Os.type == Os.WINDOWS) {
                oldName.of("String_Node_Str").concat(root).concat(tableName).$();
                newName.of("String_Node_Str").concat(root).concat(to).$();
            } else {
                oldName.of(root).concat(tableName).$();
                newName.of(root).concat(to).$();
            }
            if (ff.exists(newName)) {
                LOG.error().$("String_Node_Str").$(tableName).$("String_Node_Str").$(newName).$("String_Node_Str").$();
                throw CairoException.instance(0).put("String_Node_Str");
            }
            if (!getConfiguration().getFilesFacade().rename(oldName, newName)) {
                int error = ff.errno();
                LOG.error().$("String_Node_Str").$(oldName).$("String_Node_Str").$(newName).$("String_Node_Str").$(error).$(']').$();
                throw CairoException.instance(error).put("String_Node_Str");
            }
        }
    }
}

Output:
     final CharSequence root = configuration.getRoot();
-    try (Path oldName = new Path()) {
-        try (Path newName = new Path()) {
-            if (TableUtils.exists(ff, oldName, root, tableName) != TableUtils.TABLE_EXISTS) {
-                LOG.error().$('\'').utf8(tableName).$("String_Node_Str").$();
-                throw CairoException.instance(0).put("String_Node_Str").put(tableName).put("String_Node_Str");
-            }
-            if (Os.type == Os.WINDOWS) {
-                oldName.of("String_Node_Str").concat(root).concat(tableName).$();
-                newName.of("String_Node_Str").concat(root).concat(to).$();
-            } else {
-                oldName.of(root).concat(tableName).$();
-                newName.of(root).concat(to).$();
-            }
-            if (ff.exists(newName)) {
-                LOG.error().$("String_Node_Str").$(tableName).$("String_Node_Str").$(newName).$("String_Node_Str").$();
-                throw CairoException.instance(0).put("String_Node_Str");
-            }
-            if (!getConfiguration().getFilesFacade().rename(oldName, newName)) {
-                int error = ff.errno();
-                LOG.error().$("String_Node_Str").$(oldName).$("String_Node_Str").$(newName).$("String_Node_Str").$(error).$(']').$();
-                throw CairoException.instance(error).put("String_Node_Str");
-            }
-        }
+    if (TableUtils.exists(ff, path, root, tableName) != TableUtils.TABLE_EXISTS) {
+        LOG.error().$('\'').utf8(tableName).$("String_Node_Str").$();
+        throw CairoException.instance(0).put("String_Node_Str").put(tableName).put("String_Node_Str");
+    }
+    if (Os.type == Os.WINDOWS) {
+        path.of("String_Node_Str").concat(root).concat(tableName).$();
+        other.of("String_Node_Str").concat(root).concat(to).$();
+    } else {
+        path.of(root).concat(tableName).$();
+        other.of(root).concat(to).$();
+    }
+    if (ff.exists(other)) {
+        LOG.error().$("String_Node_Str").$(tableName).$("String_Node_Str").$(other).$("String_Node_Str").$();
+        throw CairoException.instance(0).put("String_Node_Str");
+    }
+    if (!ff.rename(path, other)) {
+        int error = ff.errno();
+        LOG.error().$("String_Node_Str").$(path).$("String_Node_Str").$(other).$("String_Node_Str").$(error).$(']').$();
+        throw CairoException.instance(error).put("String_Node_Str");
     }


Input:
public void run() {
    DataObject dobj = null;
    try {
        final ClassPath classPath = ClassPathSupport.createClassPath(GlobalPathRegistry.getDefault().getSourceRoots().toArray(new FileObject[0]));
        dobj = findDataObject(classPath.findResource(resource));
    } finally {
        final DataObject dataObject = dobj;
        Mutex.EVENT.readAccess(new Runnable() {
            public void run() {
                try {
                    if (dataObject == null) {
                        StatusDisplayer.getDefault().setStatusText(NbBundle.getMessage(StackLineAnalyser.class, "String_Node_Str", new Object[] { resource }));
                        return;
                    }
                    try {
                        EditorCookie editorCookie = (EditorCookie) dataObject.getCookie(EditorCookie.class);
                        LineCookie lineCookie = (LineCookie) dataObject.getCookie(LineCookie.class);
                        if (editorCookie != null && lineCookie != null && lineNumber != -1) {
                            StyledDocument doc = editorCookie.openDocument();
                            if (doc != null) {
                                if (lineNumber != -1) {
                                    try {
                                        Line l = lineCookie.getLineSet().getCurrent(lineNumber - 1);
                                        if (l != null) {
                                            l.show(Line.SHOW_GOTO);
                                            return;
                                        }
                                    } catch (IndexOutOfBoundsException oob) {
                                        StatusDisplayer.getDefault().setStatusText(NbBundle.getMessage(StackLineAnalyser.class, "String_Node_Str", new Object[] { lineNumber }));
                                    }
                                }
                            }
                        }
                        OpenCookie openCookie = (OpenCookie) dataObject.getCookie(OpenCookie.class);
                        if (openCookie != null) {
                            openCookie.open();
                            return;
                        }
                    } catch (IOException e) {
                        Exceptions.printStackTrace(e);
                    }
                } finally {
                    handle.finish();
                }
            }
        });
    }
}

Output:
         final ClassPath classPath = ClassPathSupport.createClassPath(GlobalPathRegistry.getDefault().getSourceRoots().toArray(new FileObject[0]));
-        dobj = findDataObject(classPath.findResource(resource));
+        for (String resource : resources) {
+            dobj = findDataObject(classPath.findResource(resource));
+            if (dobj != null)
+                break;
+        }
     } finally {


Input:
private void scheduleCronJob(String cronString, String elementId) {
    try {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        scheduler = schedulerFactory.getScheduler();
        jobName = "String_Node_Str" + elementId;
        JobKey jobKey = new JobKey(jobName, jobGroup);
        if (scheduler.checkExists(jobKey)) {
            scheduler.deleteJob(jobKey);
        }
        scheduler.start();
        JobDataMap dataMap = new JobDataMap();
        dataMap.put("String_Node_Str", this);
        JobDetail job = org.quartz.JobBuilder.newJob(CronEventTrigger.class).withIdentity(jobName, jobGroup).usingJobData(dataMap).build();
        Trigger trigger = org.quartz.TriggerBuilder.newTrigger().withIdentity("String_Node_Str" + elementId, jobGroup).withSchedule(CronScheduleBuilder.cronSchedule(cronString)).build();
        scheduler.scheduleJob(job, trigger);
    } catch (SchedulerException e) {
        log.error("String_Node_Str" + triggerDefinition.getId() + "String_Node_Str" + e.getMessage(), e);
    }
}

Output:
     } catch (SchedulerException e) {
-        log.error("String_Node_Str" + triggerDefinition.getId() + "String_Node_Str" + e.getMessage(), e);
+        LOG.error("String_Node_Str" + triggerDefinition.getId() + "String_Node_Str" + e.getMessage(), e);
     }


Input:
public static boolean isBender(String player, Element element) {
    BendingPlayer bPlayer = getBendingPlayer(player);
    if (bPlayer == null)
        return false;
    if (bPlayer.hasElement(element))
        return true;
    return false;
}

Output:
     BendingPlayer bPlayer = getBendingPlayer(player);
-    if (bPlayer == null)
-        return false;
-    if (bPlayer.hasElement(element))
-        return true;
-    return false;
+    return bPlayer != null && bPlayer.hasElement(element);
 }


Input:
Capability open(char mode) {
    if (mode == 't')
        issuedEpoch++;
    return new Capability(FILE_ID, 0, 60, System.currentTimeMillis(), "String_Node_Str", (int) issuedEpoch, false, COW ? SnapConfig.SNAP_CONFIG_ACCESS_CURRENT : SnapConfig.SNAP_CONFIG_SNAPS_DISABLED, 0, capSecret);
}

Output:
         issuedEpoch++;
-    return new Capability(FILE_ID, 0, 60, System.currentTimeMillis(), "String_Node_Str", (int) issuedEpoch, false, COW ? SnapConfig.SNAP_CONFIG_ACCESS_CURRENT : SnapConfig.SNAP_CONFIG_SNAPS_DISABLED, 0, capSecret);
+    return new Capability(FILE_ID, SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber() | SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_TRUNC.getNumber(), 60, System.currentTimeMillis(), "String_Node_Str", (int) issuedEpoch, false, COW ? SnapConfig.SNAP_CONFIG_ACCESS_CURRENT : SnapConfig.SNAP_CONFIG_SNAPS_DISABLED, 0, capSecret);
 }


Input:
public Note convert(final SimpleNoteInfo noteInfo, final Sound sound) throws SoundTransformException {
    final Channel channel1 = sound.getChannels()[0];
    final Map<String, Object> noteInfoValues = new HashMap<String, Object>();
    final ComputeMagnitudeSoundTransform soundTransform = new ComputeMagnitudeSoundTransform(DefaultSoundToNoteService.ACCURATE_STEP);
    final double[] magnitudeArray = soundTransform.transform(channel1);
    noteInfoValues.put(SimpleNoteInfo.ATTACK_KEY, noteInfo.hasAttack() ? noteInfo.getAttack() : 0);
    noteInfoValues.put(SimpleNoteInfo.DECAY_KEY, noteInfo.hasDecay() ? noteInfo.getDecay() : this.adsrHelper.findDecay(magnitudeArray, ((Integer) noteInfoValues.get(SimpleNoteInfo.ATTACK_KEY)).intValue()) * DefaultSoundToNoteService.ACCURATE_STEP);
    noteInfoValues.put(SimpleNoteInfo.SUSTAIN_KEY, noteInfo.hasSustain() ? noteInfo.getSustain() : this.adsrHelper.findSustain(magnitudeArray, ((Integer) noteInfoValues.get(SimpleNoteInfo.DECAY_KEY)).intValue()) * DefaultSoundToNoteService.ACCURATE_STEP);
    noteInfoValues.put(SimpleNoteInfo.RELEASE_KEY, noteInfo.hasRelease() ? noteInfo.getRelease() : this.adsrHelper.findRelease(magnitudeArray) * DefaultSoundToNoteService.ACCURATE_STEP);
    noteInfoValues.put(SimpleNoteInfo.FREQUENCY_KEY, noteInfo.hasFrequency() ? noteInfo.getFrequency() : this.frequencyHelper.findFrequency(sound));
    noteInfoValues.put(SimpleNoteInfo.NAME_KEY, noteInfo.getName());
    return new SimpleNote(new SimpleNoteInfo(noteInfoValues), sound.getChannels());
}

Output:
     noteInfoValues.put(SimpleNoteInfo.DECAY_KEY, noteInfo.hasDecay() ? noteInfo.getDecay() : this.adsrHelper.findDecay(magnitudeArray, ((Integer) noteInfoValues.get(SimpleNoteInfo.ATTACK_KEY)).intValue()) * DefaultSoundToNoteService.ACCURATE_STEP);
-    noteInfoValues.put(SimpleNoteInfo.SUSTAIN_KEY, noteInfo.hasSustain() ? noteInfo.getSustain() : this.adsrHelper.findSustain(magnitudeArray, ((Integer) noteInfoValues.get(SimpleNoteInfo.DECAY_KEY)).intValue()) * DefaultSoundToNoteService.ACCURATE_STEP);
+    noteInfoValues.put(SimpleNoteInfo.SUSTAIN_KEY, noteInfo.hasSustain() ? noteInfo.getSustain() : this.adsrHelper.findSustain(magnitudeArray, ((Integer) noteInfoValues.get(SimpleNoteInfo.DECAY_KEY)).intValue() / DefaultSoundToNoteService.ACCURATE_STEP) * DefaultSoundToNoteService.ACCURATE_STEP);
     noteInfoValues.put(SimpleNoteInfo.RELEASE_KEY, noteInfo.hasRelease() ? noteInfo.getRelease() : this.adsrHelper.findRelease(magnitudeArray) * DefaultSoundToNoteService.ACCURATE_STEP);


Input:
public int compare(IRow o1, IRow o2) {
    applyPrimitive(o1);
    applyPrimitive(o2);
    CacheRow r1 = getCacheRow(o1);
    CacheRow r2 = getCacheRow(o2);
    if (codeOrder.equalsIgnoreCase(DEFAULT_ORDER_CODE)) {
        return Float.compare(r1.value, r2.value);
    } else
        return runOrderScript(r1, r2);
}

Output:
     if (codeOrder.equalsIgnoreCase(DEFAULT_ORDER_CODE)) {
-        return Float.compare(r1.value, r2.value);
+        return -Float.compare(r1.value, r2.value);
     } else


Input:
private static RecursiveFilesystemTraversalValue resultForDirectory(TraversalRequest traversal, FileInfo rootInfo, Collection<RecursiveFilesystemTraversalValue> subdirTraversals) {
    NestedSetBuilder<ResolvedFile> paths = NestedSetBuilder.stableOrder();
    for (RecursiveFilesystemTraversalValue child : subdirTraversals) {
        paths.addTransitive(child.getTransitiveFiles());
    }
    ResolvedFile root;
    if (rootInfo.type.isSymlink()) {
        NestedSet<ResolvedFile> children = paths.build();
        root = ResolvedFileFactory.symlinkToDirectory(rootInfo.realPath, traversal.path, rootInfo.unresolvedSymlinkTarget, hashDirectorySymlink(children, rootInfo.metadata.hashCode()));
        paths = NestedSetBuilder.<ResolvedFile>stableOrder().addTransitive(children).add(root);
    } else {
        root = ResolvedFileFactory.directory(rootInfo.realPath);
    }
    return RecursiveFilesystemTraversalValue.of(root, paths.build());
}

Output:
         NestedSet<ResolvedFile> children = paths.build();
-        root = ResolvedFileFactory.symlinkToDirectory(rootInfo.realPath, traversal.path, rootInfo.unresolvedSymlinkTarget, hashDirectorySymlink(children, rootInfo.metadata.hashCode()));
+        root = ResolvedFileFactory.symlinkToDirectory(rootInfo.realPath, traversal.root.asRootedPath(), rootInfo.unresolvedSymlinkTarget, hashDirectorySymlink(children, rootInfo.metadata.hashCode()));
         paths = NestedSetBuilder.<ResolvedFile>stableOrder().addTransitive(children).add(root);


Input:
public static DateTimeFormat getFormat(String pattern) {
    return new DateTimeFormat(pattern, defaultDateTimeConstants);
}

Output:
 public static DateTimeFormat getFormat(String pattern) {
-    return new DateTimeFormat(pattern, defaultDateTimeConstants);
+    return new DateTimeFormat(pattern, getDefaultDateTimeConstants());
 }


Input:
public void dispatch(DispatchResult result, DispatchNode node, DispatchTask task) {
    if (!dispatchService.reserveTask(task)) {
        return;
    }
    DispatchProc proc = null;
    try {
        proc = dispatchService.allocateProc(node, task);
        if (dispatchService.startTask(node.getName(), task)) {
            RunTaskCommand command = dispatchService.getRuntaskCommand(task);
            if (!result.isTest) {
                RndClient client = new RndClient(node.getName());
                client.runProcess(command);
            }
            result.dispatched(proc, task);
        } else {
            cleanup(result, proc, task, "String_Node_Str");
        }
    } catch (Exception e) {
        logger.warn("String_Node_Str" + node.getName() + "String_Node_Str" + e, e);
        cleanup(result, proc, task, e.getMessage());
    }
}

Output:
         } else {
-            cleanup(result, proc, task, "String_Node_Str");
+            dispatchFailed(result, proc, null, "String_Node_Str");
         }


Input:
public void setup() throws Exception {
    super.setup();
    ModuleManager moduleManager = ModuleManagerFactory.create();
    context.put(ModuleManager.class, moduleManager);
    EngineTime mockTime = mock(EngineTime.class);
    networkSystem = new NetworkSystemImpl(mockTime, context);
    networkSystem.setContext(context);
    context.put(NetworkSystem.class, networkSystem);
    EntitySystemSetupUtil.addReflectionBasedLibraries(context);
    EntitySystemSetupUtil.addEntityManagementRelatedClasses(context);
    entityManager = (PojoEntityManager) context.get(EntityManager.class);
    context.put(ComponentSystemManager.class, new ComponentSystemManager(context));
    entityManager.clear();
    client = mock(NetClient.class);
    NetworkComponent clientNetComp = new NetworkComponent();
    clientNetComp.replicateMode = NetworkComponent.ReplicateMode.OWNER;
    clientEntity = entityManager.create(clientNetComp);
    when(client.getEntity()).thenReturn(clientEntity);
    when(client.getId()).thenReturn("String_Node_Str");
    networkSystem.mockHost();
    networkSystem.connectToEntitySystem(entityManager, context.get(EventLibrary.class), mock(BlockEntityRegistry.class));
    networkSystem.registerNetworkEntity(clientEntity);
    context.put(ServerConnectListManager.class, new ServerConnectListManager());
}

Output:
     networkSystem.registerNetworkEntity(clientEntity);
-    context.put(ServerConnectListManager.class, new ServerConnectListManager());
+    context.put(ServerConnectListManager.class, new ServerConnectListManager(context));
 }


Input:
protected boolean isLastVersion(RepositoryNode repositoryObject) {
    if (repositoryObject.getObject() instanceof RepositoryViewObject) {
        return true;
    }
    try {
        if (repositoryObject.getObject() != null) {
            Property property = repositoryObject.getObject().getProperty();
            Item item = repositoryObject.getObject().getProperty().getItem();
            if (item instanceof ConnectionItem) {
                return true;
            }
            List<IRepositoryViewObject> allVersion = null;
            ItemState state = property.getItem().getState();
            boolean pathExist = false;
            if (state != null) {
                String path = state.getPath();
                if (path != null) {
                    File f = new File(path);
                    if (f.exists()) {
                        pathExist = true;
                    }
                }
            }
            if (pathExist) {
                allVersion = CoreRuntimePlugin.getInstance().getProxyRepositoryFactory().getAllVersion(property.getId(), state.getPath(), repositoryObject.getObject().getRepositoryObjectType());
            } else {
                allVersion = CoreRuntimePlugin.getInstance().getProxyRepositoryFactory().getAllVersion(property.getId());
            }
            if (allVersion == null || allVersion.isEmpty()) {
                return false;
            }
            String lastVersion = VersionUtils.DEFAULT_VERSION;
            for (IRepositoryViewObject object : allVersion) {
                if (VersionUtils.compareTo(object.getVersion(), lastVersion) > 0) {
                    lastVersion = object.getVersion();
                }
            }
            if (VersionUtils.compareTo(property.getVersion(), lastVersion) == 0) {
                return true;
            }
        }
    } catch (PersistenceException e) {
    }
    return false;
}

Output:
             if (item instanceof ConnectionItem) {
-                return true;
+                if (GlobalServiceRegister.getDefault().isServiceRegistered(IESBService.class)) {
+                    IESBService service = (IESBService) GlobalServiceRegister.getDefault().getService(IESBService.class);
+                    if (service != null) {
+                        boolean flag = service.isServiceItem(item.eClass().getClassifierID());
+                        if (!flag) {
+                            return true;
+                        }
+                    }
+                }
             }


Input:
public static void main(String[] args) throws IOException, ClassNotFoundException {
    String usage = "String_Node_Str";
    String dictionaryFile = "String_Node_Str";
    if (args.length > 2) {
        System.err.println(usage);
        return;
    }
    String target = null;
    if (args.length >= 1) {
        if (args[0].equals("String_Node_Str")) {
            _useCompression = true;
            if (args.length == 2) {
                target = args[1];
            }
        } else {
            target = args[0];
        }
    }
    if (_useCompression) {
        dictionaryFile = "String_Node_Str";
    }
    PtIndexer ptIndexer = new PtIndexer();
    if (target == null) {
        BufferedReader stdin = null;
        BufferedReader fileInput = null;
        int numberOfFiles = 0;
        int numberOfLines = 0;
        try {
            stdin = new BufferedReader(new InputStreamReader(System.in));
            String fileName = null;
            String line = null;
            while ((fileName = stdin.readLine()) != null) {
                numberOfFiles++;
                try {
                    fileInput = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
                    fileName = fileName.substring(0, fileName.lastIndexOf("String_Node_Str"));
                    String className = fileName.replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str");
                    while ((line = fileInput.readLine()) != null) {
                        numberOfLines++;
                        ptIndexer.append(className, line);
                    }
                } finally {
                    if (fileInput != null) {
                        fileInput.close();
                    }
                }
            }
            System.out.println("String_Node_Str" + numberOfFiles + "String_Node_Str" + numberOfLines + "String_Node_Str");
        } finally {
            try {
                if (stdin != null) {
                    stdin.close();
                }
            } finally {
                if (fileInput != null) {
                    fileInput.close();
                }
            }
        }
        System.out.println(ptIndexer.statistics());
        ptIndexer.write(dictionaryFile);
    } else {
        ptIndexer.read(dictionaryFile);
        System.out.println(ptIndexer.search(target));
    }
}

Output:
         try {
-            stdin = new BufferedReader(new InputStreamReader(System.in));
+            stdin = new BufferedReader(new InputStreamReader(System.in, java.nio.charset.Charset.defaultCharset()));
             String fileName = null;


Input:
public void forward(Object result) {
    if (LOG.isLoggable(Level.FINEST)) {
        LOG.finest("String_Node_Str" + this + "String_Node_Str" + result);
    }
    _result.set(result);
}

Output:
     }
-    _result.set(result);
+    RESULT.set(result);
 }


Input:
private void registerServiceTestV1() {
    User user = new User();
    user.setUsername("String_Node_Str");
    user.setPass("String_Node_Str");
    LSMTripleStore lsmStore = new LSMTripleStore();
    lsmStore.setUser(user);
    LSMSchema myOnt = new LSMSchema(OntModelSpec.OWL_DL_MEM);
    LSMSchema myOntInstance = new LSMSchema();
    org.openiot.scheduler.core.utils.lsmpa.entities.User schedulerUser = new org.openiot.scheduler.core.utils.lsmpa.entities.User(myOnt, myOntInstance, "String_Node_Str", lsmStore);
    schedulerUser.setId(osdSpec.getUserID());
    schedulerUser.createClassIdv();
    for (OAMO oamo : osdSpec.getOAMO()) {
        logger.debug("String_Node_Str", oamo.getDescription(), oamo.getId());
        logger.debug("String_Node_Str", oamo.getName());
        Service srvc = null;
        for (OSMO osmo : oamo.getOSMO()) {
            logger.debug("String_Node_Str", osmo.getId());
            logger.debug("String_Node_Str", osmo.getName());
            logger.debug("String_Node_Str", osmo.getDescription());
            logger.debug("String_Node_Str", osmo.getQueryRequest().getQuery());
            srvc = new Service(myOnt, myOntInstance, "String_Node_Str", lsmStore);
            srvc.setName(osmo.getName());
            srvc.setDescription(osmo.getDescription());
            srvc.setQueryString(osmo.getQueryRequest().getQuery());
            srvc.setUser(schedulerUser);
            srvc.setId(osmo.getId());
            srvc.createClassIdv();
            srvc.createPserviceName();
            srvc.createPserviceDescription();
            srvc.createPqString();
            srvc.createPUser();
            schedulerUser.addService(srvc);
            schedulerUser.createPuserOf();
            WidgetPresentation widgetPre = null;
            for (Widget widget : osmo.getRequestPresentation().getWidget()) {
                widgetPre = new WidgetPresentation(myOnt, myOntInstance, "String_Node_Str", lsmStore);
                widgetPre.setService(srvc);
                widgetPre.createClassIdv();
                widgetPre.createPwidgetPresOf();
                srvc.addWidgetPresentation(widgetPre);
                srvc.createPwidgetPres();
                logger.debug("String_Node_Str", widget.getWidgetID());
                WidgetAvailable wAvail = new WidgetAvailable(myOnt, myOntInstance, "String_Node_Str", lsmStore);
                wAvail.setId(widget.getWidgetID());
                wAvail.setWidgetPre(widgetPre);
                wAvail.createClassIdv();
                wAvail.createPWidgetOf();
                widgetPre.setWidgetAvailable(wAvail);
                widgetPre.createPwidget();
                WidgetAttributes wAttr = null;
                for (PresentationAttr pAttr : widget.getPresentationAttr()) {
                    logger.debug("String_Node_Str", pAttr.getName(), pAttr.getValue());
                    wAttr = new WidgetAttributes(myOnt, myOntInstance, "String_Node_Str", lsmStore);
                    wAttr.setDescription(pAttr.getName());
                    wAttr.setName(pAttr.getValue());
                    wAttr.setWidgetPre(widgetPre);
                    wAttr.createClassIdv();
                    wAttr.createPdesc();
                    wAttr.createPname();
                    wAttr.createPWidgetAttrOf();
                    widgetPre.addWidgetAttr(wAttr);
                    widgetPre.createPwidgetAttr();
                }
            }
        }
    }
    logger.debug(myOntInstance.exportToTriples("String_Node_Str"));
    boolean ok = lsmStore.pushRDF("String_Node_Str", myOntInstance.exportToTriples("String_Node_Str"));
    if (ok) {
        replyMessage = "String_Node_Str";
    } else {
        replyMessage = "String_Node_Str";
    }
}

Output:
             logger.debug("String_Node_Str", osmo.getDescription());
-            logger.debug("String_Node_Str", osmo.getQueryRequest().getQuery());
+            for (QueryRequest qr : osmo.getQueryRequest()) {
+                logger.debug("String_Node_Str", qr.getQuery());
+            }
             srvc = new Service(myOnt, myOntInstance, "String_Node_Str", lsmStore);


Input:
protected void generateContent(ExtendedItemDesign item, IForeignContent content) {
    ExtendedItemHandle handle = (ExtendedItemHandle) item.getHandle();
    String name = item.getName();
    byte[] generationStatus = null;
    if (itemGeneration != null) {
        IBaseQueryDefinition[] queries = (IBaseQueryDefinition[]) ((ExtendedItemDesign) item).getQueries();
        ReportItemGenerationInfo info = new ReportItemGenerationInfo();
        info.setModelObject(handle);
        info.setApplicationClassLoader(context.getApplicationClassLoader());
        info.setReportContext(context.getReportContext());
        info.setReportQueries(queries);
        info.setExtendedItemContent(content);
        itemGeneration.init(info);
        try {
            IBaseResultSet[] resultSets = rsets;
            if (resultSets == null) {
                IBaseResultSet prset = getParentResultSet();
                if (prset != null) {
                    int rsetType = prset.getType();
                    if (rsetType == IBaseResultSet.QUERY_RESULTSET) {
                        resultSets = new IBaseResultSet[1];
                        resultSets[0] = new SingleQueryResultSet((IQueryResultSet) prset);
                    } else if (rsetType == IBaseResultSet.CUBE_RESULTSET) {
                        resultSets = new IBaseResultSet[1];
                        resultSets[0] = new SingleCubeResultSet((ICubeResultSet) prset);
                    }
                }
            }
            itemGeneration.onRowSets(resultSets);
            if (itemGeneration.needSerialization()) {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                itemGeneration.serialize(out);
                generationStatus = out.toByteArray();
            }
            itemGeneration.finish();
        } catch (BirtException ex) {
            logger.log(Level.SEVERE, ex.getMessage(), ex);
            context.addException(new EngineException(MessageConstants.EXTENDED_ITEM_GENERATION_ERROR, handle.getExtensionName() + (name != null ? "String_Node_Str" + name : "String_Node_Str"), ex));
        }
    } else {
    }
    content.setRawType(IForeignContent.EXTERNAL_TYPE);
    content.setRawValue(generationStatus);
}

Output:
     if (itemGeneration != null) {
-        IBaseQueryDefinition[] queries = (IBaseQueryDefinition[]) ((ExtendedItemDesign) item).getQueries();
+        IDataQueryDefinition[] queries = ((ExtendedItemDesign) item).getQueries();
         ReportItemGenerationInfo info = new ReportItemGenerationInfo();


Input:
public void convertClassNamesToClasses() {
    try {
        if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
            try {
                m_enumClass = (Class) AccessController.doPrivileged(new PrivilegedClassForName(m_enumClassName));
            } catch (PrivilegedActionException exception) {
                throw ValidationException.classNotFoundWhileConvertingClassNames(m_enumClassName, exception.getException());
            }
        } else {
            m_enumClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(m_enumClassName);
        }
    } catch (ClassNotFoundException exception) {
        throw ValidationException.classNotFoundWhileConvertingClassNames(m_enumClassName, exception);
    }
}

Output:
             try {
-                m_enumClass = (Class) AccessController.doPrivileged(new PrivilegedClassForName(m_enumClassName));
+                m_enumClass = (Class) AccessController.doPrivileged(new PrivilegedClassForName(m_enumClassName, true, classLoader));
             } catch (PrivilegedActionException exception) {


Input:
public long stepInstructions(int count) throws EmulationException {
    if (isRunning()) {
        throw new IllegalStateException("String_Node_Str");
    }
    setRunning(true);
    while (count-- > 0 && isRunning()) {
        if (debug) {
            if (servicedInterrupt >= 0) {
                disAsm.disassemble(reg[PC], memory, reg, servicedInterrupt);
            } else {
                disAsm.disassemble(reg[PC], memory, reg);
            }
        }
        boolean emuOP = emulateOP(-1);
        if (emuOP) {
            if (execCounter != null) {
                execCounter[reg[PC]]++;
            }
            if (trace != null) {
                trace[tracePos++] = reg[PC];
                if (tracePos > trace.length)
                    tracePos = 0;
            }
        }
    }
    setRunning(false);
    return cycles;
}

Output:
     while (count-- > 0 && isRunning()) {
-        if (debug) {
-            if (servicedInterrupt >= 0) {
-                disAsm.disassemble(reg[PC], memory, reg, servicedInterrupt);
-            } else {
-                disAsm.disassemble(reg[PC], memory, reg);
-            }
-        }
-        boolean emuOP = emulateOP(-1);
-        if (emuOP) {
+        int pc = emulateOP(-1);
+        if (pc >= 0) {
             if (execCounter != null) {


Input:
public void protoContactRemoved(ProtoContactEvent evt) {
    if (evt.getOldParent().equals(metaContact)) {
        Iterator chatTransportsIter = chatTransports.iterator();
        MetaContactChatTransport chatTransport = null;
        while (chatTransportsIter.hasNext()) {
            chatTransport = (MetaContactChatTransport) chatTransportsIter.next();
            if (chatTransport.getContact().equals(evt.getProtoContact())) {
                sessionRenderer.removeChatTransport(chatTransport);
                break;
            }
        }
    }
}

Output:
     if (evt.getOldParent().equals(metaContact)) {
-        Iterator chatTransportsIter = chatTransports.iterator();
-        MetaContactChatTransport chatTransport = null;
-        while (chatTransportsIter.hasNext()) {
-            chatTransport = (MetaContactChatTransport) chatTransportsIter.next();
-            if (chatTransport.getContact().equals(evt.getProtoContact())) {
+        Contact protoContact = evt.getProtoContact();
+        for (ChatTransport chatTransport : chatTransports) {
+            if (((MetaContactChatTransport) chatTransport).getContact().equals(protoContact)) {
                 sessionRenderer.removeChatTransport(chatTransport);


Input:
public void setDefaultSelector(Drawable d) {
    mDefaultBackground = d;
    if (!mStacked)
        setStacked(true, true);
}

Output:
     if (!mStacked)
-        setStacked(true, true);
+        setStacked(false, true);
 }


Input:
private List getSelectValueList() {
    if (needRefreshList == false) {
        return selValueList;
    }
    CubeHandle cube = null;
    if (designHandle instanceof ExtendedItemHandle) {
        cube = ((ExtendedItemHandle) designHandle).getCube();
    }
    if (cube == null || (!(cube instanceof TabularCubeHandle)) || expression.getText().length() == 0) {
        return new ArrayList();
    }
    Iterator iter = null;
    IBaseCubeQueryDefinition cubeQueryDefn = null;
    DataRequestSession session = null;
    try {
        session = DataRequestSession.newSession(new DataSessionContext(DataSessionContext.MODE_DIRECT_PRESENTATION));
        IReportItem item = ((ExtendedItemHandle) designHandle).getReportItem();
        Chart cm = (Chart) ((ChartReportItemImpl) item).getProperty(ChartReportItemUtil.PROPERTY_CHART);
        cubeQueryDefn = new ChartCubeQueryHelper((ExtendedItemHandle) designHandle, cm).createCubeQuery(null);
        iter = session.getCubeQueryUtil().getMemberValueIterator((TabularCubeHandle) cube, getExpression(expression.getText()), (ICubeQueryDefinition) cubeQueryDefn);
    } catch (Exception e) {
        logger.log(Level.SEVERE, e.getMessage(), e);
    }
    selValueList = new ArrayList();
    while (iter != null && iter.hasNext()) {
        Object obj = iter.next();
        if (obj != null) {
            if (selValueList.indexOf(obj) < 0) {
                selValueList.add(obj);
            }
        }
    }
    needRefreshList = false;
    return selValueList;
}

Output:
         IReportItem item = ((ExtendedItemHandle) designHandle).getReportItem();
-        Chart cm = (Chart) ((ChartReportItemImpl) item).getProperty(ChartReportItemUtil.PROPERTY_CHART);
+        Chart cm = context.getModel();
         cubeQueryDefn = new ChartCubeQueryHelper((ExtendedItemHandle) designHandle, cm).createCubeQuery(null);


Input:
public static List<Map<String, CtVariable>> findAllVarMappingCombination(Map<VarAccessWrapper, List<CtVariable>> mappedVars, boolean random) {
    if (mappedVars.isEmpty()) {
        return new ArrayList<Map<String, CtVariable>>();
    }
    List<VarAccessWrapper> varsNamesToCombine = new ArrayList<>(mappedVars.keySet());
    List<Map<String, CtVariable>> allCombinations = new ArrayList<>();
    allCombinations.add(new TreeMap<>());
    int maxNumberCombinations = ConfigurationProperties.getPropertyInt("String_Node_Str");
    int numberTotalComb = 1;
    int max = -1;
    for (VarAccessWrapper currentVar : varsNamesToCombine) {
        List<CtVariable> mapped = mappedVars.get(currentVar);
        int numberCompVar = mapped.size();
        if (numberCompVar > max)
            max = numberCompVar;
        logger.debug(String.format("String_Node_Str", currentVar.getVar().getVariable().getSimpleName(), numberCompVar));
        numberTotalComb *= numberCompVar;
    }
    logger.debug("String_Node_Str" + numberTotalComb);
    double maxPerVar = Math.pow(numberTotalComb, 1.0 / varsNamesToCombine.size());
    double maxPerVarLimit = Math.pow(maxNumberCombinations, 1.0 / varsNamesToCombine.size());
    logger.debug(String.format("String_Node_Str", maxPerVar, maxPerVarLimit));
    for (VarAccessWrapper currentVar : varsNamesToCombine) {
        List<Map<String, CtVariable>> generationCombinations = new ArrayList<>();
        List<CtVariable> mapped = mappedVars.get(currentVar);
        List<CtVariable> sortedVariables = new ArrayList<>(mapped);
        if (random) {
            Collections.shuffle(sortedVariables, RandomManager.getRandom());
        }
        int varsAnalyzed = 0;
        for (CtVariable varFromMap : sortedVariables) {
            for (Map<String, CtVariable> previousCombination : allCombinations) {
                Map<String, CtVariable> newCombination = new TreeMap<>(previousCombination);
                newCombination.put(currentVar.getVar().getVariable().getSimpleName(), varFromMap);
                generationCombinations.add(newCombination);
            }
            varsAnalyzed++;
            if (varsAnalyzed >= ((int) maxPerVarLimit)) {
                break;
            }
        }
        allCombinations = generationCombinations;
    }
    allCombinations = allCombinations.stream().filter(e -> !e.isEmpty()).collect(Collectors.toList());
    logger.debug("String_Node_Str" + allCombinations.size());
    return allCombinations;
}

Output:
     int maxNumberCombinations = ConfigurationProperties.getPropertyInt("String_Node_Str");
-    int numberTotalComb = 1;
+    long numberTotalComb = 1;
     int max = -1;


Input:
public synchronized void unregister() {
    if (!started) {
        return;
    }
    MBeanServer mbs = mBeanServer();
    Set<ObjectName> entries;
    try {
        entries = mbs.queryNames(ObjectNameSpec.getClusterNameFilter(this.name), null);
        for (ObjectName name : entries) {
            if (mbs.isRegistered(name)) {
                mbs.unregisterMBean(name);
            }
        }
    } catch (Exception e) {
        logger.log(Level.FINEST, "String_Node_Str", e);
    }
    counter.decrementAndGet();
}

Output:
         }
-    } catch (Exception e) {
-        logger.log(Level.FINEST, "String_Node_Str", e);
+        counter.decrementAndGet();
     }


Input:
public KeePassFile parse(InputStream inputStream, ProtectedStringCrypto protectedStringCrypto) {
    KeePassFile keePassFile = JAXB.unmarshal(inputStream, KeePassFile.class);
    keePassFile.init();
    List<Entry> entries = keePassFile.getEntries();
    for (Entry entry : entries) {
        if (entry.isPasswordProtected()) {
            String decrypted = protectedStringCrypto.decrypt(entry.getPassword());
            entry.setPassword(decrypted);
        }
    }
    return keePassFile;
}

Output:
     for (Entry entry : entries) {
-        if (entry.isPasswordProtected()) {
-            String decrypted = protectedStringCrypto.decrypt(entry.getPassword());
-            entry.setPassword(decrypted);
+        decryptAndSetPassword(entry, protectedStringCrypto);
+        History history = entry.getHistory();
+        for (Entry historicEntry : history.getHistoricEntries()) {
+            decryptAndSetPassword(historicEntry, protectedStringCrypto);
         }


Input:
public long process(SSIMediator ssiMediator, String commandName, String[] paramNames, String[] paramValues, PrintWriter writer) {
    String encoding = DEFAULT_ENCODING;
    String originalValue = null;
    String errorMessage = ssiMediator.getConfigErrMsg();
    for (int i = 0; i < paramNames.length; i++) {
        String paramName = paramNames[i];
        String paramValue = paramValues[i];
        if (paramName.equalsIgnoreCase("String_Node_Str")) {
            originalValue = paramValue;
        } else if (paramName.equalsIgnoreCase("String_Node_Str")) {
            if (isValidEncoding(paramValue)) {
                encoding = paramValue;
            } else {
                ssiMediator.log("String_Node_Str" + paramValue);
                writer.write(errorMessage);
            }
        } else {
            ssiMediator.log("String_Node_Str" + paramName);
            writer.write(errorMessage);
        }
    }
    String variableValue = ssiMediator.getVariableValue(originalValue, encoding);
    if (variableValue == null) {
        variableValue = MISSING_VARIABLE_VALUE;
    }
    writer.write(variableValue);
    return System.currentTimeMillis();
}

Output:
     String originalValue = null;
-    String errorMessage = ssiMediator.getConfigErrMsg();
+    String errorMessage = null;
     for (int i = 0; i < paramNames.length; i++) {


Input:
public void run() throws Exception {
    AdapterManager adapterManager = new AdapterManager();
    adapterManager.setAnnotators(AnnotatorsConfig.annotators());
    adapterManager.setDatasets(DatasetsConfig.datasets());
    AnnotatorConfiguration annotatorConfig = adapterManager.getAnnotatorConfig(ANNOTATOR_NAME, EXPERIMENT_TYPE);
    Assert.assertNotNull(annotatorConfig);
    DatasetConfiguration datasetConfig = adapterManager.getDatasetConfig(DATASET_NAME, EXPERIMENT_TYPE);
    Assert.assertNotNull(datasetConfig);
    DefeatableOverseer overseer = RootConfig.createOverseer();
    overseer.addObserver(this);
    ExperimentTaskConfiguration[] taskConfigs = new ExperimentTaskConfiguration[] { new ExperimentTaskConfiguration(annotatorConfig, datasetConfig, EXPERIMENT_TYPE, MATCHING) };
    Experimenter experimenter = new Experimenter(overseer, new SimpleLoggingDAO4Debugging(), RootConfig.createSameAsRetriever(), new EvaluatorFactory(), taskConfigs, "String_Node_Str");
    experimenter.run();
    mutex.acquire();
    overseer.shutdown();
}

Output:
     ExperimentTaskConfiguration[] taskConfigs = new ExperimentTaskConfiguration[] { new ExperimentTaskConfiguration(annotatorConfig, datasetConfig, EXPERIMENT_TYPE, MATCHING) };
-    Experimenter experimenter = new Experimenter(overseer, new SimpleLoggingDAO4Debugging(), RootConfig.createSameAsRetriever(), new EvaluatorFactory(), taskConfigs, "String_Node_Str");
+    SameAsRetriever retriever = RootConfig.createSameAsRetriever();
+    Experimenter experimenter = new Experimenter(overseer, new SimpleLoggingDAO4Debugging(), retriever, new EvaluatorFactory(), taskConfigs, "String_Node_Str");
     experimenter.run();


Input:
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    if (isShowTitle() && mTitlePaint != null && mCurTitleProperty != null && mCurTitleProperty.mAlpha != 0) {
        CharSequence buf = getHint();
        if (buf != null) {
            mTitlePaint.setTextSize(mCurTitleProperty.mTextSize);
            int color = getCurrentHintTextColor();
            int alpha = Ui.modulateAlpha(Color.alpha(color), mCurTitleProperty.mAlpha);
            if (color != 0 && alpha != 0) {
                mTitlePaint.setColor(color);
                mTitlePaint.setAlpha(alpha);
                canvas.drawText(buf, 0, buf.length(), mCurTitleProperty.mLeft, mCurTitleProperty.mTop + mCurTitleProperty.mTextSize, mTitlePaint);
            }
        }
    }
}

Output:
                 mTitlePaint.setAlpha(alpha);
-                canvas.drawText(buf, 0, buf.length(), mCurTitleProperty.mLeft, mCurTitleProperty.mTop + mCurTitleProperty.mTextSize, mTitlePaint);
+                final int scrollX = getScrollX();
+                final int scrollY = getScrollY();
+                if ((scrollX | scrollY) == 0) {
+                    canvas.drawText(buf, 0, buf.length(), mCurTitleProperty.mLeft, mCurTitleProperty.mTop + mCurTitleProperty.mTextSize, mTitlePaint);
+                } else {
+                    canvas.translate(scrollX, scrollY);
+                    canvas.drawText(buf, 0, buf.length(), mCurTitleProperty.mLeft, mCurTitleProperty.mTop + mCurTitleProperty.mTextSize, mTitlePaint);
+                    canvas.translate(-scrollX, -scrollY);
+                }
             }


Input:
protected String exec(AppCommandParser parser, Session session, Output out) throws Exception {
    HighlyAvailableGraphDatabase db = (HighlyAvailableGraphDatabase) getServer().getDb();
    MasterServer master = db.getMasterServerIfMaster();
    out.println("String_Node_Str" + (master != null ? "String_Node_Str" : "String_Node_Str"));
    if (master != null) {
        out.println("String_Node_Str");
        for (Pair<Integer, Collection<Integer>> entry : master.getConnectedClients()) {
            out.println("String_Node_Str" + entry.first());
            if (!entry.other().isEmpty()) {
                out.println("String_Node_Str" + entry.other());
            }
        }
    }
    return null;
}

Output:
             out.println("String_Node_Str" + entry.first());
-            if (!entry.other().isEmpty()) {
+            if (entry.other() != null && !entry.other().isEmpty()) {
                 out.println("String_Node_Str" + entry.other());


Input:
private void activateSubscription(IPrimitiveType<?> theStatus, String theActiveStatus, final IBaseResource theSubscription, String theRequestedStatus) {
    theStatus.setValueAsString(theActiveStatus);
    ourLog.info("String_Node_Str", theSubscription.getIdElement().toUnqualified().getValue(), theRequestedStatus, theActiveStatus);
    try {
        mySubscriptionDao.update(theSubscription);
    } catch (final UnprocessableEntityException e) {
        ourLog.info("String_Node_Str", theSubscription.getIdElement());
        IBaseResource subscription = mySubscriptionDao.read(theSubscription.getIdElement());
        SubscriptionUtil.setStatus(myCtx, subscription, "String_Node_Str");
        SubscriptionUtil.setReason(myCtx, subscription, e.getMessage());
        mySubscriptionDao.update(subscription);
    }
}

Output:
     try {
-        mySubscriptionDao.update(theSubscription);
+        SubscriptionUtil.setStatus(myCtx, subscription, theActiveStatus);
+        mySubscriptionDao.update(subscription);
+        mySubscriptionInterceptor.registerSubscription(subscription.getIdElement(), subscription);
     } catch (final UnprocessableEntityException e) {


Input:
protected Data createRowData(ResultSetMetaData meta, ResultSet rs, String flags) throws AdapterException {
    boolean flagColumnNames = hasFlag(flags, "String_Node_Str", true);
    boolean flagNativeTypes = hasFlag(flags, "String_Node_Str", true);
    boolean flagSingleRow = hasFlag(flags, "String_Node_Str", false);
    int colCount;
    Data rows = new Data(10);
    Data obj;
    Object value;
    try {
        colCount = meta.getColumnCount();
        while (rs.next()) {
            obj = flagColumnNames ? new Data() : new Data(colCount);
            for (int i = 0; i < colCount; i++) {
                value = createValue(meta, rs, i + 1, flagNativeTypes);
                if (flagColumnNames) {
                    obj.add(meta.getColumnName(i + 1).toLowerCase(), value);
                } else {
                    obj.add(value);
                }
            }
            rows.add(obj);
        }
    } catch (SQLException e) {
        throw new AdapterException("String_Node_Str" + e.getMessage());
    }
    if (flagSingleRow) {
        if (rows.arraySize() < 1) {
            return null;
        } else if (rows.arraySize() == 1) {
            return rows.getData(0);
        } else {
            throw new AdapterException("String_Node_Str" + "String_Node_Str" + rows.arraySize());
        }
    }
    return rows;
}

Output:
                 if (flagColumnNames) {
-                    obj.add(meta.getColumnName(i + 1).toLowerCase(), value);
+                    obj.add(meta.getColumnLabel(i + 1).toLowerCase(), value);
                 } else {


Input:
public void guideDialogForLEXA(String path) {
    final MaterialDialog.Builder x = new MaterialDialog.Builder(mainActivity);
    x.theme(mainActivity.getAppTheme().getMaterialDialogTheme());
    x.title(R.string.needsaccess);
    LayoutInflater layoutInflater = (LayoutInflater) mainActivity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    View view = layoutInflater.inflate(R.layout.lexadrawer, null);
    x.customView(view, true);
    TextView textView = view.findViewById(R.id.description);
    textView.setText(mainActivity.getString(R.string.needsaccesssummary) + path + mainActivity.getString(R.string.needsaccesssummary1));
    ((ImageView) view.findViewById(R.id.icon)).setImageResource(R.drawable.sd_operate_step);
    x.positiveText(R.string.open);
    x.negativeText(R.string.cancel);
    x.positiveColor(accentColor);
    x.negativeColor(accentColor);
    x.callback(new MaterialDialog.ButtonCallback() {
        public void onPositive(MaterialDialog materialDialog) {
            triggerStorageAccessFramework();
        }
        public void onNegative(MaterialDialog materialDialog) {
            Toast.makeText(mainActivity, R.string.error, Toast.LENGTH_SHORT).show();
        }
    });
    final MaterialDialog y = x.build();
    y.show();
}

Output:
     ((ImageView) view.findViewById(R.id.icon)).setImageResource(R.drawable.sd_operate_step);
-    x.positiveText(R.string.open);
-    x.negativeText(R.string.cancel);
-    x.positiveColor(accentColor);
-    x.negativeColor(accentColor);
-    x.callback(new MaterialDialog.ButtonCallback() {
-        public void onPositive(MaterialDialog materialDialog) {
-            triggerStorageAccessFramework();
-        }
-        public void onNegative(MaterialDialog materialDialog) {
-            Toast.makeText(mainActivity, R.string.error, Toast.LENGTH_SHORT).show();
-        }
-    });
+    x.positiveText(R.string.open).negativeText(R.string.cancel).positiveColor(accentColor).negativeColor(accentColor).onPositive((dialog, which) -> triggerStorageAccessFramework()).onNegative((dialog, which) -> Toast.makeText(mainActivity, R.string.error, Toast.LENGTH_SHORT).show());
     final MaterialDialog y = x.build();


Input:
public static String runCommandWaitAndReturn(String command) throws IOException {
    String ret = "String_Node_Str";
    Runtime rt = Runtime.getRuntime();
    Process pr = rt.exec(command, null, new File(command.split("String_Node_Str")[0]).getParentFile());
    BufferedReader br = new BufferedReader(new InputStreamReader(pr.getInputStream()));
    String line;
    while ((line = br.readLine()) != null) {
        ret += line;
    }
    return ret;
}

Output:
     String ret = "String_Node_Str";
-    Runtime rt = Runtime.getRuntime();
-    Process pr = rt.exec(command, null, new File(command.split("String_Node_Str")[0]).getParentFile());
-    BufferedReader br = new BufferedReader(new InputStreamReader(pr.getInputStream()));
-    String line;
-    while ((line = br.readLine()) != null) {
-        ret += line;
+    try {
+        Runtime rt = Runtime.getRuntime();
+        Process pr = rt.exec(command, null, new File(command.split("String_Node_Str")[0]).getParentFile());
+        BufferedReader br = new BufferedReader(new InputStreamReader(pr.getInputStream()));
+        String line;
+        while ((line = br.readLine()) != null) {
+            ret += line;
+        }
+    } catch (Exception e) {
+        logger.severe("String_Node_Str" + e.getMessage());
+        return null;
     }


Input:
private ArrayInfo buildInfo(Logger logger, Function f) {
    HierarchicalSet<Var> candidates = new HierarchicalSet<Var>();
    ArrayInfo info = new ArrayInfo();
    buildAliasInfoRec(logger, f, f.mainBlock(), info, new AliasTracker());
    buildInfoRec(logger, f, f.mainBlock(), info, candidates);
    return info;
}

Output:
     buildAliasInfoRec(logger, f, f.mainBlock(), info, new AliasTracker());
-    buildInfoRec(logger, f, f.mainBlock(), info, candidates);
+    buildInfoRec(logger, funcMap, f, f.mainBlock(), info, candidates);
     return info;


Input:
public static void registerAvailable(Object provider, Console console, Context context) {
    Predicate<? super Method> predicate = Predicates.<Method>and(ReflectionUtils.withModifier(Modifier.PUBLIC), ReflectionUtils.withAnnotation(Command.class));
    Set<Method> commandMethods = ReflectionUtils.getAllMethods(provider.getClass(), predicate);
    for (Method method : commandMethods) {
        final Class[] paramTypes = method.getParameterTypes();
        final Annotation[][] paramAnnotations = method.getParameterAnnotations();
        for (int i = 0; i < paramAnnotations.length; i++) {
            if (paramTypes[i].getTypeName().equals(ENTITY_REF_NAME)) {
                if (paramAnnotations[i].length == 0) {
                    logger.info("String_Node_Str", method.getName());
                } else {
                    for (Annotation annotation : paramAnnotations[i]) {
                        if (annotation instanceof Sender) {
                        } else {
                            logger.info("String_Node_Str", method.getName());
                        }
                    }
                }
            }
        }
        logger.debug("String_Node_Str", method.getName(), method.getDeclaringClass().getCanonicalName());
        try {
            SpecificAccessibleObject<Method> specificMethod = new SpecificAccessibleObject<>(method, provider);
            MethodCommand command = referringTo(specificMethod, context);
            console.registerCommand(command);
            logger.debug("String_Node_Str", method.getName(), method.getDeclaringClass().getCanonicalName());
        } catch (RuntimeException t) {
            logger.error("String_Node_Str", method.getName(), method.getDeclaringClass().getCanonicalName(), t);
        }
    }
}

Output:
                 if (paramAnnotations[i].length == 0) {
-                    logger.info("String_Node_Str", method.getName());
+                    logger.error("String_Node_Str", method.getName(), provider.getClass().getSimpleName());
                 } else {


Input:
public ResponseEntity<?> query(ServletServerHttpRequest request, PagingAndSorting pageSort, UriComponentsBuilder uriBuilder, String repository, String query) throws InvocationTargetException, IllegalAccessException, IOException {
    URI baseUri = uriBuilder.build().toUri();
    RepositoryMetadata repoMeta = repositoryMetadataFor(repository);
    Repository repo = repoMeta.repository();
    RepositoryQueryMethod queryMethod = repoMeta.queryMethod(query);
    if (null == queryMethod) {
        return notFoundResponse(request);
    }
    Class<?>[] paramTypes = queryMethod.paramTypes();
    String[] paramNames = queryMethod.paramNames();
    Object[] paramVals = new Object[paramTypes.length];
    for (int i = 0; i < paramVals.length; i++) {
        if (Pageable.class.isAssignableFrom(paramTypes[i])) {
            paramVals[i] = pageSort;
            continue;
        } else if (Sort.class.isAssignableFrom(paramTypes[i])) {
            paramVals[i] = (null != pageSort ? pageSort.getSort() : null);
            continue;
        }
        String queryVal;
        if (null == (queryVal = request.getServletRequest().getParameter(paramNames[i]))) {
            continue;
        }
        RepositoryMetadata paramRepoMeta;
        if (String.class.isAssignableFrom(paramTypes[i])) {
            paramVals[i] = queryVal;
        } else if (null != (paramRepoMeta = repositoryMetadataFor(paramTypes[i]))) {
            Serializable id = stringToSerializable(queryVal, (Class<Serializable>) paramRepoMeta.entityMetadata().idAttribute().type());
            Object o = paramRepoMeta.repository().findOne(id);
            if (null == o) {
                return notFoundResponse(request);
            }
            paramVals[i] = o;
        } else if (conversionService.canConvert(String.class, paramTypes[i])) {
            paramVals[i] = conversionService.convert(queryVal, paramTypes[i]);
        } else {
            try {
                paramVals[i] = objectMapper.readValue(queryVal, paramTypes[i]);
            } catch (IOException e) {
                throw new IllegalArgumentException(e);
            }
        }
    }
    RepositoryMethodResponse response = new RepositoryMethodResponse();
    Object result;
    if (null == (result = queryMethod.method().invoke(repo, paramVals))) {
        return negotiateResponse(request, HttpStatus.OK, new HttpHeaders(), response);
    }
    Iterator entities = Collections.emptyList().iterator();
    if (result instanceof Collection) {
        entities = ((Collection) result).iterator();
        response.setTotalCount(((Collection) result).size());
    } else if (result instanceof Page) {
        Page page = (Page) result;
        if (page.hasContent()) {
            entities = page.iterator();
        }
        response.setTotalCount(page.getTotalElements());
        response.setTotalPages(page.getTotalPages());
        response.setCurrentPage(page.getNumber() + 1);
        UriComponentsBuilder selfUri = UriComponentsBuilder.fromUri(baseUri).pathSegment(repository, "String_Node_Str", query);
        for (String name : request.getServletRequest().getParameterMap().keySet()) {
            if (notPagingParam(name)) {
                selfUri.queryParam(name, request.getServletRequest().getParameter(name));
            }
        }
        URI nextPrevBase = selfUri.build().toUri();
        maybeAddPrevNextLink(nextPrevBase, repoMeta, pageSort, page, !page.isFirstPage() && page.hasPreviousPage(), page.getNumber(), "String_Node_Str", response.getLinks());
        maybeAddPrevNextLink(nextPrevBase, repoMeta, pageSort, page, !page.isLastPage() && page.hasNextPage(), page.getNumber() + 2, "String_Node_Str", response.getLinks());
    } else {
        entities = Collections.singletonList(result).iterator();
    }
    while (entities.hasNext()) {
        Object obj = entities.next();
        RepositoryMetadata elemRepoMeta;
        if (null == (elemRepoMeta = repositoryMetadataFor(obj.getClass()))) {
            response.addResult(obj);
            continue;
        }
        String id = elemRepoMeta.entityMetadata().idAttribute().get(obj).toString();
        if (shouldReturnLinks(request.getServletRequest().getHeader("String_Node_Str"))) {
            String rel = elemRepoMeta.rel() + "String_Node_Str" + elemRepoMeta.entityMetadata().type().getSimpleName();
            URI path = buildUri(baseUri, repository, id);
            response.addLink(new SimpleLink(rel, path));
        } else {
            Map<String, Object> entityDto = extractPropertiesLinkAware(repoMeta.rel(), obj, repoMeta.entityMetadata(), buildUri(baseUri, repository, id));
            addSelfLink(baseUri, entityDto, repository, id);
            response.addResult(entityDto);
        }
    }
    return negotiateResponse(request, HttpStatus.OK, new HttpHeaders(), response);
}

Output:
             paramVals[i] = queryVal;
-        } else if (null != (paramRepoMeta = repositoryMetadataFor(paramTypes[i]))) {
+        } else if (hasRepositoryMetadataFor(paramTypes[i])) {
+            RepositoryMetadata paramRepoMeta = repositoryMetadataFor(paramTypes[i]);
             Serializable id = stringToSerializable(queryVal, (Class<Serializable>) paramRepoMeta.entityMetadata().idAttribute().type());


Input:
public void run() {
    pref.setIcon(new BitmapDrawable(getResources(), bmp.get()));
}

Output:
 public void run() {
-    pref.setIcon(new BitmapDrawable(getResources(), bmp.get()));
+    if (bmp.isPresent()) {
+        pref.setIcon(new BitmapDrawable(getResources(), bmp.get()));
+    }
 }


Input:
private void createKeys(Document document, Element root) {
    Element nodeLabelKeyE = document.createElement("String_Node_Str");
    nodeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    nodeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    nodeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    nodeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    root.appendChild(nodeLabelKeyE);
    Element edgeLabelKeyE = document.createElement("String_Node_Str");
    edgeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    edgeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    edgeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    edgeLabelKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    root.appendChild(edgeLabelKeyE);
    Element weightKeyE = document.createElement("String_Node_Str");
    weightKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    weightKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    weightKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    weightKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    root.appendChild(weightKeyE);
    Element edgeIdKeyE = document.createElement("String_Node_Str");
    edgeIdKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    edgeIdKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    edgeIdKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    edgeIdKeyE.setAttribute("String_Node_Str", "String_Node_Str");
    root.appendChild(edgeIdKeyE);
    if (exportColors) {
        Element colorKeyE = document.createElement("String_Node_Str");
        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        root.appendChild(colorKeyE);
    }
    if (exportPosition) {
        Element positionKeyE = document.createElement("String_Node_Str");
        positionKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        positionKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        positionKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        positionKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        root.appendChild(positionKeyE);
        Element positionKey2E = document.createElement("String_Node_Str");
        positionKey2E.setAttribute("String_Node_Str", "String_Node_Str");
        positionKey2E.setAttribute("String_Node_Str", "String_Node_Str");
        positionKey2E.setAttribute("String_Node_Str", "String_Node_Str");
        positionKey2E.setAttribute("String_Node_Str", "String_Node_Str");
        root.appendChild(positionKey2E);
        if (minZ != 0f || maxZ != 0f) {
            Element positionKey3E = document.createElement("String_Node_Str");
            positionKey3E.setAttribute("String_Node_Str", "String_Node_Str");
            positionKey3E.setAttribute("String_Node_Str", "String_Node_Str");
            positionKey3E.setAttribute("String_Node_Str", "String_Node_Str");
            positionKey3E.setAttribute("String_Node_Str", "String_Node_Str");
            root.appendChild(positionKey3E);
        }
    }
    if (exportSize) {
        Element sizeKeyE = document.createElement("String_Node_Str");
        sizeKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        sizeKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        sizeKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        sizeKeyE.setAttribute("String_Node_Str", "String_Node_Str");
        root.appendChild(sizeKeyE);
    }
    if (attributeModel != null && exportAttributes) {
        for (AttributeColumn column : attributeModel.getNodeTable().getColumns()) {
            if (!column.getOrigin().equals(AttributeOrigin.PROPERTY)) {
                Element attributeE = createAttribute(document, column);
                attributeE.setAttribute("String_Node_Str", "String_Node_Str");
                root.appendChild(attributeE);
            }
        }
        for (AttributeColumn column : attributeModel.getEdgeTable().getColumns()) {
            if (!column.getOrigin().equals(AttributeOrigin.PROPERTY)) {
                Element attributeE = createAttribute(document, column);
                attributeE.setAttribute("String_Node_Str", "String_Node_Str");
                root.appendChild(attributeE);
            }
        }
    }
}

Output:
     if (exportColors) {
-        Element colorKeyE = document.createElement("String_Node_Str");
-        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
-        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
-        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
-        colorKeyE.setAttribute("String_Node_Str", "String_Node_Str");
-        root.appendChild(colorKeyE);
+        Element colorRKeyE = document.createElement("String_Node_Str");
+        colorRKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorRKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorRKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorRKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        root.appendChild(colorRKeyE);
+        Element colorGKeyE = document.createElement("String_Node_Str");
+        colorGKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorGKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorGKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorGKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        root.appendChild(colorGKeyE);
+        Element colorBKeyE = document.createElement("String_Node_Str");
+        colorBKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorBKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorBKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        colorBKeyE.setAttribute("String_Node_Str", "String_Node_Str");
+        root.appendChild(colorBKeyE);
     }


Input:
protected void setInformationFields(Transaction transaction, String productId) {
    Information information = purchaseManager.getInformation(productId);
    Integer priceInCents = information.getPriceInCents();
    transaction.setPurchaseCost(priceInCents == null ? null : priceInCents);
    transaction.setPurchaseCostCurrency(information.getPriceCurrencyCode());
}

Output:
     Integer priceInCents = information.getPriceInCents();
-    transaction.setPurchaseCost(priceInCents == null ? null : priceInCents);
+    transaction.setPurchaseCost(priceInCents == null ? 0 : priceInCents);
     transaction.setPurchaseCostCurrency(information.getPriceCurrencyCode());


Input:
public void render(GL gl) {
    float yPosition = y;
    float xPosition = 0;
    float fieldHeight = 0;
    gl.glColor3f(0.6f, 0.6f, 0.6f);
    gl.glLineWidth(2);
    if (!heatMap.isCaptionsImpossible()) {
        ContentVirtualArray contentVA = heatMap.getContentVA();
        for (Integer iContentIndex : contentVA) {
            if (heatMap.getContentSelectionManager().checkStatus(SelectionType.SELECTION, iContentIndex) || heatMap.getContentSelectionManager().checkStatus(SelectionType.MOUSE_OVER, iContentIndex)) {
                fieldHeight = selectedFieldHeight;
            } else if (heatMap.isHideElements() && heatMap.getContentSelectionManager().checkStatus(GLHeatMap.SELECTION_HIDDEN, iContentIndex)) {
                continue;
            } else {
                fieldHeight = normalFieldHeight;
            }
            gl.glBegin(GL.GL_LINE_STRIP);
            gl.glVertex3f(xPosition, yPosition, 0);
            gl.glVertex3f(xPosition + x, yPosition, 0);
            gl.glEnd();
            yPosition -= fieldHeight;
        }
    }
    gl.glBegin(GL.GL_LINE_STRIP);
    gl.glVertex3f(0, 0, 0);
    gl.glVertex3f(x, 0, 0);
    gl.glVertex3f(x, y, 0);
    gl.glVertex3f(0, y, 0);
    gl.glEnd();
}

Output:
         for (Integer iContentIndex : contentVA) {
-            if (heatMap.getContentSelectionManager().checkStatus(SelectionType.SELECTION, iContentIndex) || heatMap.getContentSelectionManager().checkStatus(SelectionType.MOUSE_OVER, iContentIndex)) {
-                fieldHeight = selectedFieldHeight;
-            } else if (heatMap.isHideElements() && heatMap.getContentSelectionManager().checkStatus(GLHeatMap.SELECTION_HIDDEN, iContentIndex)) {
+            if (heatMap.isHideElements() && heatMap.getContentSelectionManager().checkStatus(GLHeatMap.SELECTION_HIDDEN, iContentIndex)) {
                 continue;


Input:
public synchronized void dispose() {
    if (channel != null) {
        channel.dispose();
        channel = null;
    }
}

Output:
     if (channel != null) {
-        channel.dispose();
+        adapter.removeChannel(channel.getID());
         channel = null;


Input:
public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always) {
    if (!mVibrator.hasVibrator()) {
        return false;
    }
    final boolean hapticsDisabled = Settings.System.getIntForUser(mContext.getContentResolver(), Settings.System.HAPTIC_FEEDBACK_ENABLED, 0, UserHandle.USER_CURRENT) == 0;
    if (!always && (hapticsDisabled || mKeyguardDelegate.isShowingAndNotHidden())) {
        return false;
    }
    long[] pattern = null;
    switch(effectId) {
        case HapticFeedbackConstants.LONG_PRESS:
            pattern = mLongPressVibePattern;
            break;
        case HapticFeedbackConstants.VIRTUAL_KEY:
            pattern = mVirtualKeyVibePattern;
            break;
        case HapticFeedbackConstants.KEYBOARD_TAP:
            pattern = mKeyboardTapVibePattern;
            break;
        case HapticFeedbackConstants.SAFE_MODE_DISABLED:
            pattern = mSafeModeDisabledVibePattern;
            break;
        case HapticFeedbackConstants.SAFE_MODE_ENABLED:
            pattern = mSafeModeEnabledVibePattern;
            break;
        default:
            return false;
    }
    int owningUid;
    String owningPackage;
    if (win != null) {
        owningUid = win.getOwningUid();
        owningPackage = win.getOwningPackage();
    } else {
        owningUid = android.os.Process.myUid();
        owningPackage = mContext.getBasePackageName();
    }
    if (pattern.length == 1) {
        mVibrator.vibrate(owningUid, owningPackage, pattern[0]);
    } else {
        mVibrator.vibrate(owningUid, owningPackage, pattern, -1);
    }
    return true;
}

Output:
         owningUid = android.os.Process.myUid();
-        owningPackage = mContext.getBasePackageName();
+        owningPackage = mContext.getOpPackageName();
     }


Input:
public String getNamedExpression(String name) {
    Object prop = getUserProperty(name);
    if (prop == null || (prop instanceof String))
        return null;
    return (String) prop;
}

Output:
 public String getNamedExpression(String name) {
-    Object prop = getUserProperty(name);
-    if (prop == null || (prop instanceof String))
+    UserPropertyDefnHandle propDefn = handle.getUserPropertyDefnHandle(name);
+    if (propDefn == null || propDefn.getDefn() == null || propDefn.getDefn().getDefault() == null || propDefn.getType() != IPropertyType.EXPRESSION_TYPE)
         return null;


Input:
public void visitCollectionField(Field f, Object obj) {
    try {
        JsonObject jsonObject = json.getAsJsonObject();
        String fName = f.getName();
        if (jsonObject.has(fName)) {
            Collection collection = (Collection) objectConstructor.construct(f.getType());
            f.set(obj, collection);
            Type childType = new TypeInfo(f.getGenericType()).getGenericClass();
            JsonArray jsonArray = jsonObject.get(fName).getAsJsonArray();
            for (JsonElement jsonChild : jsonArray) {
                Object child = visitChild(childType, jsonChild);
                if (childType == Object.class && !ObjectNavigator.isPrimitive(child)) {
                    throw new JsonParseException(fName + "String_Node_Str");
                }
                collection.add(child);
            }
        } else {
            f.set(obj, null);
        }
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

Output:
                 Object child = visitChild(childType, jsonChild);
-                if (childType == Object.class && !ObjectNavigator.isPrimitive(child)) {
+                if (childType == Object.class && !ObjectNavigator.isPrimitiveOrString(child)) {
                     throw new JsonParseException(fName + "String_Node_Str");


Input:
protected <T> T serialClone(T o) {
    try {
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(serialBytes(o)));
        T clone = (T) ois.readObject();
        if (o == clone)
            assertImmutable(o);
        assertSame(o.getClass(), clone.getClass());
        return clone;
    } catch (Throwable fail) {
        threadUnexpectedException(fail);
        return null;
    }
}

Output:
         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(serialBytes(o)));
-        T clone = (T) ois.readObject();
-        if (o == clone)
-            assertImmutable(o);
-        assertSame(o.getClass(), clone.getClass());
-        return clone;
+        clone = (T) ois.readObject();
     } catch (Throwable fail) {


Input:
public void onNavigationDrawerItemSelected(int position) {
    switch(position) {
        case 0:
            getSupportFragmentManager().beginTransaction().replace(R.id.container, new MainFragment()).commit();
            break;
        case 1:
            if (PlayerController.isLoggedIn(this)) {
                getSupportFragmentManager().beginTransaction().replace(R.id.container, ProfileFragment.newInstance(PlayerController.getName())).commit();
            } else {
                showInputDialog(ShotsFragment.MY_SHOTS);
            }
            break;
        case 2:
            if (PlayerController.isLoggedIn(this)) {
                getSupportFragmentManager().beginTransaction().replace(R.id.container, ShotsFragment.newInstance(ShotsFragment.MY_SHOTS)).commit();
            } else {
                showInputDialog(ShotsFragment.MY_SHOTS);
            }
            break;
        case 3:
            if (PlayerController.isLoggedIn(this)) {
                getSupportFragmentManager().beginTransaction().replace(R.id.container, ShotsFragment.newInstance(ShotsFragment.FOLLOWING)).commit();
            } else {
                showInputDialog(ShotsFragment.FOLLOWING);
            }
            break;
        case 4:
            if (PlayerController.isLoggedIn(this)) {
                getSupportFragmentManager().beginTransaction().replace(R.id.container, ShotsFragment.newInstance(ShotsFragment.LIKES)).commit();
            } else {
                showInputDialog(ShotsFragment.LIKES);
            }
            break;
        case 5:
            break;
        case 6:
            break;
    }
}

Output:
             } else {
-                showInputDialog(ShotsFragment.MY_SHOTS);
+                showInputDialog(-1);
             }


Input:
public void testInjection() throws IOException {
    Injector injector = Guice.createInjector(new DataFabricModules().getSingleNodeModules());
    QueueClientFactory factory = injector.getInstance(QueueClientFactory.class);
    Queue2Producer producer = factory.createProducer(QueueName.fromStream("String_Node_Str", "String_Node_Str"));
    Assert.assertTrue(producer instanceof LevelDBQueue2Producer);
    producer = factory.createProducer(QueueName.fromFlowlet("String_Node_Str", "String_Node_Str", "String_Node_Str"));
    Assert.assertTrue(producer instanceof InMemoryQueue2Producer);
}

Output:
 public void testInjection() throws IOException {
-    Injector injector = Guice.createInjector(new DataFabricModules().getSingleNodeModules());
+    Injector injector = Guice.createInjector(new DataFabricModules().getSingleNodeModules(conf));
     QueueClientFactory factory = injector.getInstance(QueueClientFactory.class);


Input:
protected IProject[] build(final int kind, final Map<String, String> args, final IProgressMonitor monitor) throws CoreException {
    final IProject project = getProject();
    log.debug("String_Node_Str", project.getName());
    final long start = System.currentTimeMillis();
    markerManager.deleteMarkers(project, kind == FULL_BUILD, IMavenConstants.MARKER_BUILD_ID);
    if (!project.hasNature(IMavenConstants.NATURE_ID)) {
        return null;
    }
    final IFile pomResource = project.getFile(IMavenConstants.POM_FILE_NAME);
    if (pomResource == null) {
        log.error("String_Node_Str", project.getName());
        return null;
    }
    return maven.execute(new ICallable<IProject[]>() {
        public IProject[] call(IMavenExecutionContext context, IProgressMonitor monitor) throws CoreException {
            final IMavenProjectFacade projectFacade = getProjectFacade(pomResource, project, monitor);
            if (projectFacade == null) {
                return null;
            }
            return projectManager.execute(projectFacade, new ICallable<IProject[]>() {
                public IProject[] call(IMavenExecutionContext context, IProgressMonitor monitor) throws CoreException {
                    try {
                        projectFacade.getMavenProject(monitor);
                    } catch (CoreException ce) {
                        addErrorMarker(project, ce);
                        monitor.done();
                        return null;
                    }
                    ILifecycleMapping lifecycleMapping = configurationManager.getLifecycleMapping(projectFacade);
                    if (lifecycleMapping == null) {
                        return null;
                    }
                    Map<MojoExecutionKey, List<AbstractBuildParticipant>> buildParticipantsByMojoExecutionKey = lifecycleMapping.getBuildParticipants(projectFacade, monitor);
                    Set<IProject> dependencies = builder.build(context.getSession(), projectFacade, kind, args, buildParticipantsByMojoExecutionKey, monitor);
                    log.debug("String_Node_Str", project.getName(), System.currentTimeMillis() - start);
                    if (dependencies.isEmpty()) {
                        return null;
                    }
                    return dependencies.toArray(new IProject[dependencies.size()]);
                }
            }, monitor);
        }
    }, monitor);
}

Output:
 protected IProject[] build(final int kind, final Map<String, String> args, final IProgressMonitor monitor) throws CoreException {
-    final IProject project = getProject();
-    log.debug("String_Node_Str", project.getName());
+    log.debug("String_Node_Str", getProject().getName());
     final long start = System.currentTimeMillis();


Input:
public void postIteration(final MasterContext<NNParams, NNParams> context) {
    if (this.isDry) {
        return;
    }
    double currentError = ((modelConfig.getTrain().getValidSetRate() < EPSILON) ? context.getMasterResult().getTrainError() : context.getMasterResult().getTestError());
    if (currentError < this.minTestError) {
        this.minTestError = currentError;
        this.optimizedWeights = context.getMasterResult().getWeights();
    }
    final int tmpModelFactor = DTrainUtils.tmpModelFactor(context.getTotalIteration());
    if (context.getCurrentIteration() % tmpModelFactor == 0) {
        Thread tmpNNThread = new Thread(new Runnable() {
            public void run() {
                saveTmpNNToHDFS(context.getCurrentIteration(), context.getMasterResult().getWeights());
                Path out = new Path(context.getProps().getProperty(CommonConstants.GUAGUA_OUTPUT));
                if (!context.getMasterResult().isHalt() && context.getCurrentIteration() != context.getTotalIteration()) {
                    writeModelWeightsToFileSystem(optimizedWeights, out);
                }
            }
        }, "String_Node_Str");
        tmpNNThread.setDaemon(true);
        tmpNNThread.start();
    }
    updateProgressLog(context);
}

Output:
     final int tmpModelFactor = DTrainUtils.tmpModelFactor(context.getTotalIteration());
-    if (context.getCurrentIteration() % tmpModelFactor == 0) {
+    final int currentIteration = context.getCurrentIteration();
+    final double[] weights = context.getMasterResult().getWeights();
+    final int totalIteration = context.getTotalIteration();
+    final boolean isHalt = context.getMasterResult().isHalt();
+    if (currentIteration > 1 && (currentIteration - 1) % tmpModelFactor == 0) {
         Thread tmpNNThread = new Thread(new Runnable() {


Input:
private void generateDescriptorsForTables(RelationalProjectNode projectNode, Collection tables, boolean generateEjbs) {
    if (!checkForProjectSave(projectNode))
        return;
    DescriptorGenerationDialog descriptorDialog = new DescriptorGenerationDialog((MWRelationalProject) projectNode.getProject(), generateEjbs, context);
    descriptorDialog.show();
    if (descriptorDialog.wasCanceled()) {
        return;
    }
    Vector possibleRelationships = new Vector();
    Collection relationshipsToCreate = new Vector();
    boolean generateBidirectionalRelationships = false;
    if (!possibleRelationships.isEmpty()) {
        RelationshipGenerationDialog relationshipDialog = new RelationshipGenerationDialog(possibleRelationships, context);
        relationshipDialog.setGenerateBidirectionalRelationships(generateEjbs);
        relationshipDialog.show();
        if (relationshipDialog.wasCanceled()) {
            return;
        }
        relationshipsToCreate = relationshipDialog.getRelationshipsToCreate();
        generateBidirectionalRelationships = relationshipDialog.getGenerateBidirectionalRelationships();
    }
    MWDescriptorGenerator generator = new MWDescriptorGenerator();
    generator.setProject((MWRelationalProject) projectNode.getProject());
    generator.setTables(tables);
    generator.setGenerateEjbs(generateEjbs);
    generator.setPackageName(descriptorDialog.getPackageName());
    generator.setGenerateMethodAccessors(descriptorDialog.getGenerateAccessors());
    generator.setGenerateBidirectionalRelationships(generateBidirectionalRelationships);
    generator.setRelationshipsToCreate(relationshipsToCreate);
    generator.generateClassesAndDescriptors();
    String successDialogString = null;
    if (generateEjbs) {
        successDialogString = "String_Node_Str";
    } else {
        successDialogString = "String_Node_Str";
    }
    JOptionPane.showMessageDialog(context.getCurrentWindow(), resourceRepository().getString(successDialogString + "String_Node_Str"), resourceRepository().getString(successDialogString + "String_Node_Str"), JOptionPane.INFORMATION_MESSAGE);
}

Output:
         return;
-    DescriptorGenerationDialog descriptorDialog = new DescriptorGenerationDialog((MWRelationalProject) projectNode.getProject(), generateEjbs, context);
+    DescriptorGenerationDialog descriptorDialog = new DescriptorGenerationDialog((MWRelationalProject) projectNode.getProject(), context);
     descriptorDialog.show();


Input:
private void runPrivoxyShellCmd() throws Exception {
    logNotice("String_Node_Str");
    int privoxyProcId = TorServiceUtils.findProcessId(privoxyPath);
    StringBuilder log = null;
    int attempts = 0;
    if (privoxyProcId == -1) {
        log = new StringBuilder();
        String privoxyConfigPath = appBinHome + PRIVOXYCONFIG_ASSET_KEY;
        String[] cmds = { privoxyPath + "String_Node_Str" + privoxyConfigPath + "String_Node_Str" };
        logNotice(cmds[0]);
        boolean runAsRoot = false;
        boolean waitFor = false;
        TorServiceUtils.doShellCommand(cmds, log, runAsRoot, waitFor);
        Thread.sleep(1000);
        while ((privoxyProcId = TorServiceUtils.findProcessId(privoxyPath)) == -1 && attempts < MAX_START_TRIES) {
            logNotice("String_Node_Str" + log);
            Thread.sleep(3000);
            attempts++;
        }
        logNotice(log.toString());
    }
    sendCallbackLogMessage("String_Node_Str" + PORT_HTTP);
    logNotice("String_Node_Str" + privoxyProcId);
}

Output:
         log = new StringBuilder();
-        String privoxyConfigPath = appBinHome + PRIVOXYCONFIG_ASSET_KEY;
+        String privoxyConfigPath = new File(appBinHome, PRIVOXYCONFIG_ASSET_KEY).getAbsolutePath();
         String[] cmds = { privoxyPath + "String_Node_Str" + privoxyConfigPath + "String_Node_Str" };