Input:
public List<InputSplit> getSplits(JobContext context) throws IOException {
    Configuration conf = context.getConfiguration();
    TiledInputFormatContext ifContext = TiledInputFormatContext.load(conf);
    final int zoom = ifContext.getZoomLevel();
    final int tilesize = ifContext.getTileSize();
    HdfsMrsImageDataProvider dp = new HdfsMrsImageDataProvider(context.getConfiguration(), input, null);
    Path inputWithZoom = new Path(dp.getResourcePath(true), "String_Node_Str" + zoom);
    org.mrgeo.hdfs.tile.FileSplit splitfile = new org.mrgeo.hdfs.tile.FileSplit();
    splitfile.readSplits(inputWithZoom);
    MrsImagePyramidMetadataReader metadataReader = dp.getMetadataReader();
    MrsImagePyramidMetadata metadata = metadataReader.read();
    List<InputSplit> actualSplits = super.getSplits(context);
    List<InputSplit> result = new ArrayList<InputSplit>(actualSplits.size());
    for (InputSplit actualSplit : actualSplits) {
        if (!(actualSplit instanceof FileSplit)) {
            throw new IOException("String_Node_Str" + actualSplit.getClass().getCanonicalName());
        }
        FileSplit fileSplit = (FileSplit) actualSplit;
        String partFile = fileSplit.getPath().getParent().getName();
        if (!partFile.startsWith("String_Node_Str")) {
            throw new IOException("String_Node_Str" + partFile);
        }
        org.mrgeo.hdfs.tile.FileSplit.FileSplitInfo splitinfo;
        try {
            splitinfo = (org.mrgeo.hdfs.tile.FileSplit.FileSplitInfo) splitfile.getSplitByName(partFile);
        } catch (Splits.SplitException e) {
            String indexStr = partFile.substring(partFile.lastIndexOf('-') + 1, partFile.length());
            int partition = Integer.valueOf(indexStr);
            splitinfo = (org.mrgeo.hdfs.tile.FileSplit.FileSplitInfo) splitfile.getSplitByPartition(partition);
        }
        long endTileId = splitinfo.getEndId();
        long startTileId = splitinfo.getStartId();
        TMSUtils.Tile startTile = TMSUtils.tileid(startTileId, zoom);
        TMSUtils.Tile endTile = TMSUtils.tileid(endTileId, zoom);
        TileBounds partFileTileBounds = new TileBounds(startTile.tx, startTile.ty, endTile.tx, endTile.ty);
        Bounds partFileBounds = TMSUtils.tileToBounds(partFileTileBounds, zoom, tilesize);
        if (ifContext.getBounds() != null) {
            Bounds requestedBounds = ifContext.getBounds().getTMSBounds();
            if (requestedBounds.intersect(partFileBounds, false)) {
                Bounds intersected = requestedBounds.intersection(partFileBounds, false);
                TMSUtils.TileBounds tb = TMSUtils.boundsToTile(intersected, zoom, tilesize);
                long s = TMSUtils.tileid(tb.w, tb.s, zoom);
                long e = TMSUtils.tileid(tb.e, tb.n, zoom);
                result.add(new TiledInputSplit(actualSplit, s, e, zoom, metadata.getTilesize()));
            }
        } else {
            result.add(new TiledInputSplit(actualSplit, startTileId, endTileId, ifContext.getZoomLevel(), metadata.getTilesize()));
        }
    }
    return result;
}

Output:
             splitinfo = (org.mrgeo.hdfs.tile.FileSplit.FileSplitInfo) splitfile.getSplitByName(partFile);
-        } catch (Splits.SplitException e) {
-            String indexStr = partFile.substring(partFile.lastIndexOf('-') + 1, partFile.length());
-            int partition = Integer.valueOf(indexStr);
-            splitinfo = (org.mrgeo.hdfs.tile.FileSplit.FileSplitInfo) splitfile.getSplitByPartition(partition);
+        } catch (Splits.SplitNotFoundException e) {
+            LOG.info("String_Node_Str" + super.getClass().getName() + "String_Node_Str" + partFile);
+            continue;
         }


Input:
public void removeToken() {
    provisionalGUIToken = null;
    setSelected(false);
    setToolTip();
}

Output:
     setSelected(false);
-    setToolTip();
+    toolTip = null;
 }


Input:
private void dumpInner(FileDescriptor fd, PrintWriter pw, String[] args) {
    final long now = SystemClock.uptimeMillis();
    boolean isCheckin = false;
    boolean isCompact = false;
    boolean isCsv = false;
    boolean currentOnly = false;
    boolean dumpDetails = false;
    boolean dumpFullDetails = false;
    boolean dumpAll = false;
    int aggregateHours = 0;
    boolean activeOnly = false;
    String reqPackage = null;
    boolean csvSepScreenStats = false;
    int[] csvScreenStats = new int[] { ProcessStats.ADJ_SCREEN_OFF, ProcessStats.ADJ_SCREEN_ON };
    boolean csvSepMemStats = false;
    int[] csvMemStats = new int[] { ProcessStats.ADJ_MEM_FACTOR_CRITICAL };
    boolean csvSepProcStats = true;
    int[] csvProcStats = ProcessStats.ALL_PROC_STATES;
    if (args != null) {
        for (int i = 0; i < args.length; i++) {
            String arg = args[i];
            if ("String_Node_Str".equals(arg)) {
                isCheckin = true;
            } else if ("String_Node_Str".equals(arg)) {
                isCompact = true;
            } else if ("String_Node_Str".equals(arg)) {
                isCsv = true;
            } else if ("String_Node_Str".equals(arg)) {
                i++;
                if (i >= args.length) {
                    pw.println("String_Node_Str");
                    dumpHelp(pw);
                    return;
                }
                boolean[] sep = new boolean[1];
                String[] error = new String[1];
                csvScreenStats = parseStateList(ProcessStats.ADJ_SCREEN_NAMES_CSV, ProcessStats.ADJ_SCREEN_MOD, args[i], sep, error);
                if (csvScreenStats == null) {
                    pw.println("String_Node_Str" + args[i] + "String_Node_Str" + error[0]);
                    dumpHelp(pw);
                    return;
                }
                csvSepScreenStats = sep[0];
            } else if ("String_Node_Str".equals(arg)) {
                i++;
                if (i >= args.length) {
                    pw.println("String_Node_Str");
                    dumpHelp(pw);
                    return;
                }
                boolean[] sep = new boolean[1];
                String[] error = new String[1];
                csvMemStats = parseStateList(ProcessStats.ADJ_MEM_NAMES_CSV, 1, args[i], sep, error);
                if (csvMemStats == null) {
                    pw.println("String_Node_Str" + args[i] + "String_Node_Str" + error[0]);
                    dumpHelp(pw);
                    return;
                }
                csvSepMemStats = sep[0];
            } else if ("String_Node_Str".equals(arg)) {
                i++;
                if (i >= args.length) {
                    pw.println("String_Node_Str");
                    dumpHelp(pw);
                    return;
                }
                boolean[] sep = new boolean[1];
                String[] error = new String[1];
                csvProcStats = parseStateList(ProcessStats.STATE_NAMES_CSV, 1, args[i], sep, error);
                if (csvProcStats == null) {
                    pw.println("String_Node_Str" + args[i] + "String_Node_Str" + error[0]);
                    dumpHelp(pw);
                    return;
                }
                csvSepProcStats = sep[0];
            } else if ("String_Node_Str".equals(arg)) {
                dumpDetails = true;
            } else if ("String_Node_Str".equals(arg)) {
                dumpFullDetails = true;
            } else if ("String_Node_Str".equals(arg)) {
                i++;
                if (i >= args.length) {
                    pw.println("String_Node_Str");
                    dumpHelp(pw);
                    return;
                }
                try {
                    aggregateHours = Integer.parseInt(args[i]);
                } catch (NumberFormatException e) {
                    pw.println("String_Node_Str" + args[i]);
                    dumpHelp(pw);
                    return;
                }
            } else if ("String_Node_Str".equals(arg)) {
                activeOnly = true;
                currentOnly = true;
            } else if ("String_Node_Str".equals(arg)) {
                currentOnly = true;
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mAm) {
                    mProcessStats.mFlags |= ProcessStats.FLAG_COMPLETE;
                    writeStateLocked(true, true);
                    pw.println("String_Node_Str");
                }
                return;
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mAm) {
                    mProcessStats.resetSafely();
                    pw.println("String_Node_Str");
                }
                return;
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mAm) {
                    mProcessStats.resetSafely();
                    ArrayList<String> files = getCommittedFiles(0, true, true);
                    if (files != null) {
                        for (int fi = 0; fi < files.size(); fi++) {
                            (new File(files.get(fi))).delete();
                        }
                    }
                    pw.println("String_Node_Str");
                }
                return;
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mAm) {
                    writeStateSyncLocked();
                    pw.println("String_Node_Str");
                }
                return;
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mAm) {
                    readLocked(mProcessStats, mFile);
                    pw.println("String_Node_Str");
                }
                return;
            } else if ("String_Node_Str".equals(arg)) {
                dumpHelp(pw);
                return;
            } else if ("String_Node_Str".equals(arg)) {
                dumpDetails = true;
                dumpAll = true;
            } else if (arg.length() > 0 && arg.charAt(0) == '-') {
                pw.println("String_Node_Str" + arg);
                dumpHelp(pw);
                return;
            } else {
                try {
                    IPackageManager pm = AppGlobals.getPackageManager();
                    if (pm.getPackageUid(arg, UserHandle.getCallingUserId()) >= 0) {
                        reqPackage = arg;
                        dumpDetails = true;
                    }
                } catch (RemoteException e) {
                }
                if (reqPackage == null) {
                    pw.println("String_Node_Str" + arg);
                    dumpHelp(pw);
                    return;
                }
            }
        }
    }
    if (isCsv) {
        pw.print("String_Node_Str");
        if (!csvSepScreenStats) {
            for (int i = 0; i < csvScreenStats.length; i++) {
                pw.print("String_Node_Str");
                ProcessStats.printScreenLabelCsv(pw, csvScreenStats[i]);
            }
        }
        if (!csvSepMemStats) {
            for (int i = 0; i < csvMemStats.length; i++) {
                pw.print("String_Node_Str");
                ProcessStats.printMemLabelCsv(pw, csvMemStats[i]);
            }
        }
        if (!csvSepProcStats) {
            for (int i = 0; i < csvProcStats.length; i++) {
                pw.print("String_Node_Str");
                pw.print(ProcessStats.STATE_NAMES_CSV[csvProcStats[i]]);
            }
        }
        pw.println();
        synchronized (mAm) {
            dumpFilteredProcessesCsvLocked(pw, null, csvSepScreenStats, csvScreenStats, csvSepMemStats, csvMemStats, csvSepProcStats, csvProcStats, now, reqPackage);
        }
        return;
    } else if (aggregateHours != 0) {
        dumpAggregatedStats(pw, aggregateHours, now, reqPackage, isCompact, dumpDetails, dumpFullDetails, dumpAll, activeOnly);
        return;
    }
    boolean sepNeeded = false;
    if (!currentOnly || isCheckin) {
        mWriteLock.lock();
        try {
            ArrayList<String> files = getCommittedFiles(0, false, !isCheckin);
            if (files != null) {
                for (int i = 0; i < files.size(); i++) {
                    if (DEBUG)
                        Slog.d(TAG, "String_Node_Str" + files.get(i));
                    try {
                        AtomicFile file = new AtomicFile(new File(files.get(i)));
                        ProcessStats processStats = new ProcessStats(false);
                        readLocked(processStats, file);
                        if (processStats.mReadError != null) {
                            if (isCheckin || isCompact)
                                pw.print("String_Node_Str");
                            pw.print("String_Node_Str");
                            pw.print(files.get(i));
                            pw.print("String_Node_Str");
                            pw.println(processStats.mReadError);
                            if (DEBUG)
                                Slog.d(TAG, "String_Node_Str" + files.get(i));
                            (new File(files.get(i))).delete();
                            continue;
                        }
                        String fileStr = file.getBaseFile().getPath();
                        boolean checkedIn = fileStr.endsWith(STATE_FILE_CHECKIN_SUFFIX);
                        if (isCheckin || isCompact) {
                            processStats.dumpCheckinLocked(pw, reqPackage);
                        } else {
                            if (sepNeeded) {
                                pw.println();
                            } else {
                                sepNeeded = true;
                            }
                            pw.print("String_Node_Str");
                            pw.print(processStats.mTimePeriodStartClockStr);
                            if (checkedIn)
                                pw.print("String_Node_Str");
                            pw.println("String_Node_Str");
                            if (dumpFullDetails) {
                                mProcessStats.dumpLocked(pw, reqPackage, now, false, false, activeOnly);
                            } else {
                                processStats.dumpSummaryLocked(pw, reqPackage, now, activeOnly);
                            }
                        }
                        if (isCheckin) {
                            file.getBaseFile().renameTo(new File(fileStr + STATE_FILE_CHECKIN_SUFFIX));
                        }
                    } catch (Throwable e) {
                        pw.print("String_Node_Str");
                        pw.println(files.get(i));
                        e.printStackTrace(pw);
                    }
                }
            }
        } finally {
            mWriteLock.unlock();
        }
    }
    if (!isCheckin) {
        if (dumpAll) {
            if (sepNeeded) {
                pw.println();
                pw.println("String_Node_Str");
            }
            dumpAggregatedStats(pw, 24, now, reqPackage, isCompact, dumpDetails, dumpFullDetails, dumpAll, activeOnly);
            pw.println();
            pw.println("String_Node_Str");
            dumpAggregatedStats(pw, 3, now, reqPackage, isCompact, dumpDetails, dumpFullDetails, dumpAll, activeOnly);
            sepNeeded = true;
        }
        synchronized (mAm) {
            if (isCompact) {
                mProcessStats.dumpCheckinLocked(pw, reqPackage);
            } else {
                if (sepNeeded) {
                    pw.println();
                    pw.println("String_Node_Str");
                }
                if (dumpDetails || dumpFullDetails) {
                    mProcessStats.dumpLocked(pw, reqPackage, now, !dumpFullDetails, dumpAll, activeOnly);
                    if (dumpAll) {
                        pw.print("String_Node_Str");
                        pw.println(mFile.getBaseFile());
                    }
                } else {
                    mProcessStats.dumpSummaryLocked(pw, reqPackage, now, activeOnly);
                }
            }
        }
    }
}

Output:
             } else {
-                try {
-                    IPackageManager pm = AppGlobals.getPackageManager();
-                    if (pm.getPackageUid(arg, UserHandle.getCallingUserId()) >= 0) {
-                        reqPackage = arg;
-                        dumpDetails = true;
-                    }
-                } catch (RemoteException e) {
-                }
-                if (reqPackage == null) {
-                    pw.println("String_Node_Str" + arg);
-                    dumpHelp(pw);
-                    return;
-                }
+                reqPackage = arg;
+                dumpDetails = true;
             }


Input:
public void run() {
    try {
        ConsoleHelper.consolePrint("String_Node_Str");
        if (mode.equals(ILaunchManager.DEBUG_MODE)) {
            if (type != RhodesAdapter.EPlatformType.eEmu) {
                if (rhodesAdapter.buildApp(project.getLocation().toOSString(), type, m_onDevice) != 0) {
                    ConsoleHelper.consolePrint("String_Node_Str");
                    setProcessFinished(true);
                    return;
                }
            } else {
                m_debugProcess = rhodesAdapter.debugApp(project.getLocation().toOSString(), type, launch, m_onDevice);
                if (m_debugProcess == null) {
                    ConsoleHelper.consolePrint("String_Node_Str");
                    setProcessFinished(true);
                    return;
                }
            }
        } else {
            if (rhodesAdapter.buildApp(project.getLocation().toOSString(), type, m_onDevice) != 0) {
                ConsoleHelper.consolePrint("String_Node_Str");
                setProcessFinished(true);
                return;
            }
        }
        ConsoleHelper.showAppConsole();
        startLogOutput(project, type);
        setProcessFinished(true);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
             } else {
-                m_debugProcess = rhodesAdapter.debugApp(project.getLocation().toOSString(), type, launch, m_onDevice);
+                m_debugProcess = rhodesAdapter.debugApp(m_projectName, project.getLocation().toOSString(), type, launch, m_onDevice);
                 if (m_debugProcess == null) {


Input:
private void readObjectArray(InputStream in) throws IOException {
    int originalObjectId = readInt(in);
    in.skip(4);
    int count = readInt(in);
    int originalElementClassId = readInt(in);
    int[] elements = new int[count];
    for (int i = 0; i < count; i++) {
        elements[i] = readInt(in);
    }
    writer.writeObjectArray(originalObjectId, originalElementClassId, elements);
}

Output:
     int originalObjectId = readInt(in);
-    in.skip(4);
+    skip(in, 4);
     int count = readInt(in);


Input:
public void setWasDerivedFrom(URI wasDerivedFrom) throws SBOLValidationException {
    if (sbolDocument != null) {
        if (!SBOLValidate.checkWasDerivedFromVersion(sbolDocument, this, wasDerivedFrom)) {
            throw new SBOLValidationException("String_Node_Str", this);
        }
        SBOLValidate.checkWasDerivedFromCycle(sbolDocument, this, wasDerivedFrom, new HashSet<URI>());
    }
    this.wasDerivedFrom = wasDerivedFrom;
}

Output:
     }
-    this.wasDerivedFrom = wasDerivedFrom;
+    clearWasDerivedFroms();
+    addWasDerivedFrom(wasDerivedFrom);
 }


Input:
public void createSortArea(Composite parent) {
    cmpSortArea = new Group(parent, SWT.NONE);
    {
        cmpSortArea.setText(Messages.getString("String_Node_Str"));
        cmpSortArea.setLayout(new GridLayout(3, false));
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = 2;
        gd.widthHint = 200;
        cmpSortArea.setLayoutData(gd);
    }
    lblSorting = new Label(cmpSortArea, SWT.NONE);
    lblSorting.setText(Messages.getString("String_Node_Str"));
    cmbSorting = new Combo(cmpSortArea, SWT.DROP_DOWN | SWT.READ_ONLY);
    GridData gdCMBSorting = new GridData(GridData.FILL_HORIZONTAL);
    cmbSorting.setLayoutData(gdCMBSorting);
    cmbSorting.addListener(SWT.Selection, this);
    new Label(cmpSortArea, SWT.NONE);
    lblSortExpr = new Label(cmpSortArea, SWT.NONE);
    lblSortExpr.setText(Messages.getString("String_Node_Str"));
    cmbSortExpr = new Combo(cmpSortArea, SWT.DROP_DOWN);
    GridData gdCMBSortExpr = new GridData(GridData.FILL_HORIZONTAL);
    cmbSortExpr.setLayoutData(gdCMBSortExpr);
    cmbSortExpr.addListener(SWT.Selection, this);
    cmbSortExpr.addFocusListener(new FocusAdapter() {
        public void focusLost(FocusEvent e) {
            updateSortKey();
        }
    });
    try {
        btnSortExprBuilder = (IExpressionButton) wizardContext.getUIServiceProvider().invoke(IUIServiceProvider.Command.EXPRESS_BUTTON_CREATE, cmpSortArea, cmbSortExpr, wizardContext.getExtendedItem(), IUIServiceProvider.COMMAND_EXPRESSION_DATA_BINDINGS, null);
        Query query = getSeriesDefinitionForProcessing().getSortKey();
        if (query != null) {
            btnSortExprBuilder.setExpression(query.getDefinition());
        }
    } catch (ChartException e) {
        WizardBase.displayException(e);
    }
    lblSortLocale = new Label(cmpSortArea, SWT.NONE);
    lblSortLocale.setText(Messages.getString("String_Node_Str"));
    cmbSortLocale = new Combo(cmpSortArea, SWT.READ_ONLY | SWT.BORDER);
    GridData gd = new GridData(GridData.FILL_HORIZONTAL);
    cmbSortLocale.setLayoutData(gd);
    cmbSortLocale.setVisibleItemCount(30);
    cmbSortLocale.addListener(SWT.Selection, this);
    new Label(cmpSortArea, SWT.NONE);
    lblSortStrength = new Label(cmpSortArea, SWT.NONE);
    lblSortStrength.setText(Messages.getString("String_Node_Str"));
    cmbSortStrength = new Combo(cmpSortArea, SWT.READ_ONLY | SWT.BORDER);
    gd = new GridData(GridData.FILL_HORIZONTAL);
    cmbSortStrength.setLayoutData(gd);
    cmbSortStrength.setVisibleItemCount(30);
    cmbSortStrength.addListener(SWT.Selection, this);
    if (isInheritColumnsGroups()) {
        disableSorting();
    }
}

Output:
         gd.horizontalSpan = 2;
-        gd.widthHint = 200;
+        gd.widthHint = 300;
         cmpSortArea.setLayoutData(gd);


Input:
public void addWarning(Iterable<String> warnings) {
    this.warnings.addAll((Collection<? extends String>) warnings);
}

Output:
 public void addWarning(Iterable<String> warnings) {
-    this.warnings.addAll((Collection<? extends String>) warnings);
+    for (String warning : warnings) addWarning(warning);
 }


Input:
public Class loadClass(String className, SDOType type) throws ClassNotFoundException {
    Class javaClass = null;
    javaClass = (Class) generatedClasses.get(className);
    if (javaClass != null) {
        return javaClass;
    }
    try {
        javaClass = delegateLoader.loadClass(className);
    } catch (ClassNotFoundException e) {
        javaClass = createGeneric(className, type);
        if (javaClass == null) {
            throw e;
        }
    } catch (NoClassDefFoundError error) {
        javaClass = createGeneric(className, type);
        if (javaClass == null) {
            throw error;
        }
    }
    return javaClass;
}

Output:
     try {
-        javaClass = delegateLoader.loadClass(className);
+        javaClass = getParent().loadClass(className);
     } catch (ClassNotFoundException e) {


Input:
public boolean equals(Object other) {
    if (!(other instanceof InputDefinition)) {
        return false;
    }
    InputDefinition that = (InputDefinition) other;
    return this.getServerUri().equals(that.getServerUri()) && this.getServerHost().equals(that.getServerHost()) && this.getCheckpointDir().equals(that.getCheckpointDir()) && this.getSessionKey().equals(that.getSessionKey()) && this.getInputs().equals(that.getInputs());
}

Output:
     InputDefinition that = (InputDefinition) other;
-    return this.getServerUri().equals(that.getServerUri()) && this.getServerHost().equals(that.getServerHost()) && this.getCheckpointDir().equals(that.getCheckpointDir()) && this.getSessionKey().equals(that.getSessionKey()) && this.getInputs().equals(that.getInputs());
+    return this.metadata.equals(that.metadata) && this.inputs.equals(that.inputs);
 }


Input:
public void setImageIcon(ImageIcon imageIcon) {
    this.image = ImageUtils.getScaledRoundedImage(imageIcon.getImage(), width - 2, height - 2);
}

Output:
 public void setImageIcon(ImageIcon imageIcon) {
-    this.image = ImageUtils.getScaledRoundedImage(imageIcon.getImage(), width - 2, height - 2);
+    image = ImageUtils.getScaledRoundedImage(imageIcon.getImage(), width - 2, height - 2);
 }


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    SimpleMonthView v;
    HashMap<String, Integer> drawingParams = null;
    if (convertView != null) {
        v = (SimpleMonthView) convertView;
        drawingParams = (HashMap<String, Integer>) v.getTag();
    } else {
        v = new SimpleMonthView(mContext);
        AbsListView.LayoutParams params = new AbsListView.LayoutParams(AbsListView.LayoutParams.MATCH_PARENT, AbsListView.LayoutParams.MATCH_PARENT);
        v.setLayoutParams(params);
        v.setClickable(true);
        v.setOnDayClickListener(this);
        if (mCalendarTextColors != null) {
            v.setTextColor(mCalendarTextColors);
        }
    }
    if (drawingParams == null) {
        drawingParams = new HashMap<String, Integer>();
    } else {
        drawingParams.clear();
    }
    final int currentMonth = position + mController.getMinMonth();
    final int month = currentMonth % 12;
    final int year = currentMonth / 12 + mController.getMinYear();
    int selectedDay = -1;
    if (isSelectedDayInMonth(year, month)) {
        selectedDay = mSelectedDay.get(Calendar.DAY_OF_MONTH);
    }
    v.reuse();
    final int enabledDayRangeStart;
    if (mController.getMinMonth() == month && mController.getMinYear() == year) {
        enabledDayRangeStart = mController.getMinDay();
    } else {
        enabledDayRangeStart = 1;
    }
    final int enabledDayRangeEnd;
    if (mController.getMaxMonth() == month && mController.getMaxYear() == year) {
        enabledDayRangeEnd = mController.getMaxDay();
    } else {
        enabledDayRangeEnd = 31;
    }
    drawingParams.put(SimpleMonthView.VIEW_PARAMS_SELECTED_DAY, selectedDay);
    drawingParams.put(SimpleMonthView.VIEW_PARAMS_YEAR, year);
    drawingParams.put(SimpleMonthView.VIEW_PARAMS_MONTH, month);
    drawingParams.put(SimpleMonthView.VIEW_PARAMS_WEEK_START, mController.getFirstDayOfWeek());
    drawingParams.put(SimpleMonthView.VIEW_PARAMS_ENABLEDDAYRANGE_START, enabledDayRangeStart);
    drawingParams.put(SimpleMonthView.VIEW_PARAMS_ENABLEDDAYRANGE_END, enabledDayRangeEnd);
    v.setMonthParams(drawingParams);
    v.invalidate();
    return v;
}

Output:
     }
-    drawingParams.put(SimpleMonthView.VIEW_PARAMS_SELECTED_DAY, selectedDay);
-    drawingParams.put(SimpleMonthView.VIEW_PARAMS_YEAR, year);
-    drawingParams.put(SimpleMonthView.VIEW_PARAMS_MONTH, month);
-    drawingParams.put(SimpleMonthView.VIEW_PARAMS_WEEK_START, mController.getFirstDayOfWeek());
-    drawingParams.put(SimpleMonthView.VIEW_PARAMS_ENABLEDDAYRANGE_START, enabledDayRangeStart);
-    drawingParams.put(SimpleMonthView.VIEW_PARAMS_ENABLEDDAYRANGE_END, enabledDayRangeEnd);
-    v.setMonthParams(drawingParams);
+    v.setMonthParams(selectedDay, month, year, mController.getFirstDayOfWeek(), enabledDayRangeStart, enabledDayRangeEnd);
     v.invalidate();


Input:
private List<EvaluatedAxiom> applyCELOE(SparqlEndpointKS ks, OWLClass nc, boolean equivalence, boolean reuseKnowledgeSource, double threshold) throws ComponentInitException {
    SPARQLReasoner sr = new SPARQLReasoner(ks);
    SortedSet<OWLIndividual> posExamples = sr.getIndividuals(nc, 20);
    if (posExamples.isEmpty()) {
        System.out.println("String_Node_Str" + nc.toString() + "String_Node_Str");
        return Collections.emptyList();
    }
    SortedSet<String> posExStr = Helper.getStringSet(posExamples);
    long startTime = System.currentTimeMillis();
    System.out.print("String_Node_Str");
    AutomaticNegativeExampleFinderSPARQL2 finder = new AutomaticNegativeExampleFinderSPARQL2(ks.getEndpoint());
    SortedSet<OWLIndividual> negExamples = finder.getNegativeExamples(nc, posExamples, 20);
    SortedSetTuple<OWLIndividual> examples = new SortedSetTuple<OWLIndividual>(posExamples, negExamples);
    long runTime = System.currentTimeMillis() - startTime;
    System.out.println("String_Node_Str" + negExamples.size() + "String_Node_Str" + runTime + "String_Node_Str");
    SparqlKnowledgeSource ks2;
    AbstractReasonerComponent rc;
    ks2 = new SparqlKnowledgeSource();
    ks2.setInstances(Datastructures.individualSetToStringSet(examples.getCompleteSet()));
    ks2.setUrl(ks.getEndpoint().getURL());
    ks2.setDefaultGraphURIs(new TreeSet<String>(ks.getEndpoint().getDefaultGraphURIs()));
    ks2.setUseLits(false);
    ks2.setUseCacheDatabase(true);
    ks2.setCacheDir(cacheDir);
    ks2.setRecursionDepth(2);
    ks2.setCloseAfterRecursion(true);
    ks2.setDissolveBlankNodes(false);
    ks2.setSaveExtractedFragment(true);
    startTime = System.currentTimeMillis();
    System.out.print("String_Node_Str");
    ks2.init();
    runTime = System.currentTimeMillis() - startTime;
    System.out.println("String_Node_Str" + runTime + "String_Node_Str");
    rc = new ClosedWorldReasoner(ks2);
    rc.init();
    ClassLearningProblem lp = new ClassLearningProblem(rc);
    lp.setClassToDescribe(nc);
    lp.setEquivalence(equivalence);
    lp.setHeuristic(HeuristicType.FMEASURE);
    lp.setUseApproximations(false);
    lp.setMaxExecutionTimeInSeconds(10);
    lp.init();
    CELOE la = new CELOE(lp, rc);
    la.setMaxExecutionTimeInSeconds(10);
    la.setNoisePercentage(25);
    la.init();
    startTime = System.currentTimeMillis();
    System.out.print("String_Node_Str" + (equivalence ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    la.start();
    runTime = System.currentTimeMillis() - startTime;
    System.out.println("String_Node_Str" + runTime + "String_Node_Str");
    List<? extends EvaluatedDescription<? extends Score>> learnedDescriptions = la.getCurrentlyBestEvaluatedDescriptions(threshold);
    List<EvaluatedAxiom> learnedAxioms = new LinkedList<EvaluatedAxiom>();
    for (EvaluatedDescription<? extends Score> learnedDescription : learnedDescriptions) {
        OWLAxiom axiom;
        if (equivalence) {
            axiom = dataFactory.getOWLEquivalentClassesAxiom(nc, learnedDescription.getDescription());
        } else {
            axiom = dataFactory.getOWLSubClassOfAxiom(nc, learnedDescription.getDescription());
        }
        Score score = lp.computeScore(learnedDescription.getDescription());
        learnedAxioms.add(new EvaluatedAxiom(axiom, new AxiomScore(score.getAccuracy())));
    }
    return learnedAxioms;
}

Output:
     lp.setEquivalence(equivalence);
-    lp.setHeuristic(HeuristicType.FMEASURE);
+    lp.setAccuracyMethod(HeuristicType.FMEASURE);
     lp.setUseApproximations(false);


Input:
private Matrix getMotionModel(double dt) {
    double[][] motionModel2D = { { 1, 0, dt * Math.cos(x.get(HEADING_GLOBAL_ROW, 0)), 0, 0 }, { 0, 1, dt * Math.sin(x.get(HEADING_GLOBAL_ROW, 0)), 0, 0 }, { 0, 0, 1, 0, 0 }, { 0, 0, 0, 1, dt, 0 }, { 0, 0, Math.tan(steeringAngle) / WHEELBASE_IN_METERS, 0, 0 } };
    return new Matrix(motionModel2D);
}

Output:
 private Matrix getMotionModel(double dt) {
-    double[][] motionModel2D = { { 1, 0, dt * Math.cos(x.get(HEADING_GLOBAL_ROW, 0)), 0, 0 }, { 0, 1, dt * Math.sin(x.get(HEADING_GLOBAL_ROW, 0)), 0, 0 }, { 0, 0, 1, 0, 0 }, { 0, 0, 0, 1, dt, 0 }, { 0, 0, Math.tan(steeringAngle) / WHEELBASE_IN_METERS, 0, 0 } };
+    double[][] motionModel2D = { { 1, 0, dt * Math.cos(x.get(HEADING_GLOBAL_ROW, 0)), 0, 0 }, { 0, 1, dt * Math.sin(x.get(HEADING_GLOBAL_ROW, 0)), 0, 0 }, { 0, 0, 1, 0, 0 }, { 0, 0, 0, 1, dt }, { 0, 0, Math.tan(steeringAngle) / WHEELBASE_IN_METERS, 0, 0 } };
     return new Matrix(motionModel2D);


Input:
public void createWorld(String id, WorldGenerator generator) {
    World world = new SimpleGeneratedWorld(id, worldLoader.getDataSource(id), generator);
    worldMap.put(id, world);
}

Output:
 public void createWorld(String id, WorldGenerator generator) {
-    World world = new SimpleGeneratedWorld(id, worldLoader.getDataSource(id), generator);
-    worldMap.put(id, world);
+    World world;
+    try {
+        world = new SimpleGeneratedWorld(id, worldLoader.getDataSource(id), generator);
+        worldMap.put(id, world);
+    } catch (IOException e) {
+        logger.error("String_Node_Str", e);
+    }
 }


Input:
protected int _generateCode(StringBuffer code) throws KernelException {
    long startTime = new Date().getTime();
    long overallStartTime = startTime;
    StringBuffer codeMainH = new StringBuffer();
    StringBuffer codeTypesH = new StringBuffer();
    StringBuffer codeTypesC = new StringBuffer();
    _reset();
    _sanitizedModelName = CodeGeneratorAdapter.generateName(_model);
    _analyzeTypeConversions();
    startTime = _printTimeAndMemory(startTime, "String_Node_Str");
    String directory = codeDirectory.stringValue();
    if (!directory.endsWith("String_Node_Str"))
        directory += "String_Node_Str";
    String directorySrc = directory + "String_Node_Str";
    String directoryIncludes = directory + "String_Node_Str";
    String directoryBuild = directory + "String_Node_Str";
    _deleteDirectory(directorySrc);
    if (!_includes.contains("String_Node_Str" + directoryIncludes))
        _includes.add("String_Node_Str" + directoryIncludes);
    if (new File(directorySrc).mkdirs() || new File(directoryIncludes).mkdirs() || new File(directoryBuild).mkdirs()) {
        directory += "String_Node_Str";
    }
    CompositeActor container = (CompositeActor) getContainer();
    String sanitizedNameContainer = CodeGeneratorAdapter.generateName(container);
    _generateAndWriteCompositeActorCode(container, "String_Node_Str");
    String sharedCode = _generateSharedCode();
    String declareSharedCode = _generateDeclareSharedCode();
    String[] typeResolutionCode = generateTypeConvertCodeCandH();
    startTime = _printTimeAndMemory(startTime, "String_Node_Str");
    code.append(generateCopyright());
    codeMainH.append(generateCopyright());
    codeTypesH.append(generateCopyright());
    codeTypesC.append(generateCopyright());
    codeMainH.append("String_Node_Str" + _sanitizedModelName.toUpperCase() + "String_Node_Str" + _eol + "String_Node_Str" + _sanitizedModelName.toUpperCase() + "String_Node_Str" + _eol);
    codeMainH.append(_eol + "String_Node_Str" + _sanitizedModelName + "String_Node_Str");
    codeMainH.append(_eol + "String_Node_Str" + sanitizedNameContainer + "String_Node_Str");
    code.append(_eol + "String_Node_Str" + _sanitizedModelName + "String_Node_Str");
    if (((BooleanToken) measureTime.getToken()).booleanValue()) {
        code.append(_eol + "String_Node_Str");
        code.append(_eol + "String_Node_Str");
    }
    codeMainH.append(_eol + _eol + "String_Node_Str");
    code.append(generateMainEntryCode());
    code.append(generateMainExitCode());
    codeMainH.append(_eol + "String_Node_Str");
    codeMainH.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str" + sanitizedNameContainer + "String_Node_Str");
    code.append(_eol + sanitizedNameContainer + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    codeMainH.append(generateInitializeProcedureName());
    code.append(generateInitializeEntryCode());
    code.append(_eol + "String_Node_Str");
    code.append(_eol + sanitizedNameContainer + "String_Node_Str" + _eol);
    code.append(generateInitializeExitCode());
    codeMainH.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str" + sanitizedNameContainer + "String_Node_Str");
    code.append(_eol + sanitizedNameContainer + "String_Node_Str");
    code.append(_eol + "String_Node_Str" + sanitizedNameContainer + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    code.append(_eol + "String_Node_Str");
    codeMainH.append(generateWrapupProcedureName());
    code.append(generateWrapupEntryCode());
    code.append(_eol + sanitizedNameContainer + "String_Node_Str");
    code.append(generateWrapupExitCode());
    codeMainH.append(_eol + "String_Node_Str");
    codeTypesH.append("String_Node_Str" + _sanitizedModelName.toUpperCase() + "String_Node_Str" + _eol + "String_Node_Str" + _sanitizedModelName.toUpperCase() + "String_Node_Str" + _eol);
    codeTypesH.append(_eol + typeResolutionCode[0]);
    typeResolutionCode[0] = null;
    codeTypesH.append(comment("String_Node_Str"));
    codeTypesC.append(typeResolutionCode[1]);
    typeResolutionCode[1] = null;
    codeTypesC.append(comment("String_Node_Str"));
    codeTypesC.append(sharedCode);
    sharedCode = null;
    codeTypesH.append(declareSharedCode);
    declareSharedCode = null;
    codeTypesH.append(comment("String_Node_Str"));
    codeTypesH.append("String_Node_Str");
    startTime = _printTimeAndMemory(startTime, "String_Node_Str");
    code = _finalPassOverCode(code);
    codeMainH = _finalPassOverCode(codeMainH);
    codeTypesH = _finalPassOverCode(codeTypesH);
    codeTypesC = _finalPassOverCode(codeTypesC);
    startTime = _printTimeAndMemory(startTime, "String_Node_Str");
    _writeCodeFileName(code, _sanitizedModelName + "String_Node_Str", true, false);
    _writeCodeFileName(codeMainH, "String_Node_Str" + _sanitizedModelName + "String_Node_Str", true, false);
    _writeCodeFileName(codeTypesH, "String_Node_Str" + _sanitizedModelName + "String_Node_Str", true, false);
    _writeCodeFileName(codeTypesC, "String_Node_Str" + _sanitizedModelName + "String_Node_Str", true, false);
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directoryIncludes, "String_Node_Str");
    _copyCFileTosrc("String_Node_Str", directorySrc, "String_Node_Str");
    code = null;
    codeMainH = null;
    codeTypesH = null;
    codeTypesC = null;
    _writeMakefile(container, directory);
    _printTimeAndMemory(startTime, "String_Node_Str");
    if (_executeCommands == null) {
        _executeCommands = new StreamExec();
    }
    _printTimeAndMemory(overallStartTime, "String_Node_Str");
    return _executeCommands();
}

Output:
         _includes.add("String_Node_Str" + directoryIncludes);
-    if (new File(directorySrc).mkdirs() || new File(directoryIncludes).mkdirs() || new File(directoryBuild).mkdirs()) {
+    if (new File(directorySrc).mkdirs() && new File(directoryIncludes).mkdirs() && new File(directoryBuild).mkdirs()) {
         directory += "String_Node_Str";


Input:
private void postWorkDirectory() {
    String workDir = getWorkDir();
    if (workDir == null || workDir.length() == 0) {
        String hostName = null;
        String engineName = null;
        String hostWorkDir = null;
        Container parentHost = getParent();
        if (parentHost != null) {
            hostName = parentHost.getName();
            if (parentHost instanceof StandardHost) {
                hostWorkDir = ((StandardHost) parentHost).getWorkDir();
            }
            Container parentEngine = parentHost.getParent();
            if (parentEngine != null) {
                engineName = parentEngine.getName();
            }
        }
        if ((hostName == null) || (hostName.length() < 1))
            hostName = "String_Node_Str";
        if ((engineName == null) || (engineName.length() < 1))
            engineName = "String_Node_Str";
        String temp = getPath();
        if (temp.startsWith("String_Node_Str"))
            temp = temp.substring(1);
        temp = temp.replace('/', '_');
        temp = temp.replace('\\', '_');
        if (temp.length() < 1)
            temp = "String_Node_Str";
        if (hostWorkDir != null) {
            workDir = hostWorkDir + File.separator + temp;
        } else {
            workDir = "String_Node_Str" + File.separator + engineName + File.separator + hostName + File.separator + temp;
        }
        setWorkDir(workDir);
    }
    File dir = new File(workDir);
    if (!dir.isAbsolute()) {
        File catalinaHome = engineBase();
        String catalinaHomePath = null;
        try {
            catalinaHomePath = catalinaHome.getCanonicalPath();
            dir = new File(catalinaHomePath, workDir);
        } catch (IOException e) {
        }
    }
    dir.mkdirs();
    getServletContext().setAttribute(ServletContext.TEMPDIR, dir);
    context.setAttributeReadOnly(ServletContext.TEMPDIR);
}

Output:
     }
-    dir.mkdirs();
+    if (!dir.exists() && !dir.mkdirs()) {
+        log.log(Level.SEVERE, sm.getString("String_Node_Str", dir.getAbsolutePath()));
+    }
     getServletContext().setAttribute(ServletContext.TEMPDIR, dir);


Input:
private void createExpressionButton(Composite composite, final Text property, String propName) {
    ExpressionButton exprButton = ExpressionButtonUtil.createExpressionButton(composite, property, new ExpressionProvider(handle), true, SWT.PUSH);
    if (PASSWORD.equals(propName)) {
        exprButton.setExpressionButtonProvider(new ExprButtonProvider(true, property));
    }
    Expression expr = handle.getPropertyBindingExpression(propName);
    property.setData(ExpressionButtonUtil.EXPR_TYPE, expr == null || expr.getType() == null ? UIUtil.getDefaultScriptType() : (String) expr.getType());
    property.setText((expr == null || expr.getStringExpression() == null) ? "String_Node_Str" : expr.getStringExpression());
    exprButton.refresh();
}

Output:
 private void createExpressionButton(Composite composite, final Text property, String propName) {
-    ExpressionButton exprButton = ExpressionButtonUtil.createExpressionButton(composite, property, new ExpressionProvider(handle), true, SWT.PUSH);
+    ExpressionButton exprButton = ExpressionButtonUtil.createExpressionButton(composite, property, new ExpressionProvider(handle), handle, true, SWT.PUSH);
     if (PASSWORD.equals(propName)) {


Input:
private <TGetSettingsResponseCollection, TSettingName> TGetSettingsResponseCollection getSettings(Class<TGetSettingsResponseCollection> cls, Class<TSettingName> cls1, List<String> identities, List<TSettingName> settings, ExchangeVersion requestedVersion, IFunctionDelegate<List<String>, List<TSettingName>, TGetSettingsResponseCollection> getSettingsMethod, IFuncDelegate<String> getDomainMethod) throws Exception {
    TGetSettingsResponseCollection response;
    if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
        throw new ServiceVersionException(String.format(Strings.AutodiscoverServiceIncompatibleWithRequestVersion, MinimumRequestVersionForAutoDiscoverSoapService));
    }
    if (this.url != null) {
        URI autodiscoverUrl = this.url;
        response = getSettingsMethod.func(identities, settings, requestedVersion, this.url);
        this.url = autodiscoverUrl;
        return response;
    } else if (!(this.domain == null || this.domain.isEmpty())) {
        URI autodiscoverUrl = this.getAutodiscoverEndpointUrl(this.domain);
        response = getSettingsMethod.func(identities, settings, requestedVersion, autodiscoverUrl);
        this.url = autodiscoverUrl;
        return response;
    } else {
        this.isExternal = true;
        URI autodiscoverUrl;
        String domainName = getDomainMethod.func();
        int scpHostCount;
        OutParam<Integer> outParam = new OutParam<Integer>();
        List<String> hosts = this.getAutodiscoverServiceHosts(domainName, outParam);
        scpHostCount = outParam.getParam();
        if (hosts.size() == 0) {
            throw new ServiceValidationException(Strings.AutodiscoverServiceRequestRequiresDomainOrUrl);
        }
        for (int currentHostIndex = 0; currentHostIndex < hosts.size(); currentHostIndex++) {
            String host = hosts.get(currentHostIndex);
            boolean isScpHost = currentHostIndex < scpHostCount;
            OutParam<URI> outParams = new OutParam<URI>();
            if (this.tryGetAutodiscoverEndpointUrl(host, outParams)) {
                autodiscoverUrl = outParams.getParam();
                response = getSettingsMethod.func(identities, settings, requestedVersion, autodiscoverUrl);
                this.url = autodiscoverUrl;
                if (isScpHost) {
                    this.isExternal = false;
                }
                return response;
            }
        }
        autodiscoverUrl = this.getRedirectUrl(domainName);
        OutParam<URI> outParamUrl = new OutParam<URI>();
        if ((autodiscoverUrl != null) && this.callRedirectionUrlValidationCallback(autodiscoverUrl.toString()) && this.tryGetAutodiscoverEndpointUrl(autodiscoverUrl.getHost(), outParamUrl)) {
            autodiscoverUrl = outParamUrl.getParam();
            response = getSettingsMethod.func(identities, settings, requestedVersion, autodiscoverUrl);
            this.url = autodiscoverUrl;
            return response;
        }
        autodiscoverUrl = this.getRedirectionUrlFromDnsSrvRecord(domainName);
        if ((autodiscoverUrl != null) && this.callRedirectionUrlValidationCallback(autodiscoverUrl.toString()) && this.tryGetAutodiscoverEndpointUrl(autodiscoverUrl.getHost(), outParamUrl)) {
            autodiscoverUrl = outParamUrl.getParam();
            response = getSettingsMethod.func(identities, settings, requestedVersion, autodiscoverUrl);
            this.url = autodiscoverUrl;
            return response;
        } else {
            throw new AutodiscoverLocalException(Strings.AutodiscoverCouldNotBeLocated);
        }
    }
}

Output:
     if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
-        throw new ServiceVersionException(String.format(Strings.AutodiscoverServiceIncompatibleWithRequestVersion, MinimumRequestVersionForAutoDiscoverSoapService));
+        throw new ServiceVersionException(String.format("String_Node_Str", MinimumRequestVersionForAutoDiscoverSoapService));
     }


Input:
public boolean shouldDisplay() {
    return this.isEnabled();
}

Output:
 public boolean shouldDisplay() {
-    return this.isEnabled();
+    return this.isSlotEnabled();
 }


Input:
public void onReceive(Context context, Intent intent) {
    Log.v("String_Node_Str", "String_Node_Str");
    if (intent.getAction() == null) {
        Bundle extras = intent.getExtras();
        if (extras != null) {
            Log.v("String_Node_Str", "String_Node_Str");
            appWidgetManager = AppWidgetManager.getInstance(context);
            widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
            Log.v("String_Node_Str", "String_Node_Str" + widgetId);
            getJsonResponse task = new getJsonResponse(context);
            task.execute();
        }
    } else {
        super.onReceive(context, intent);
    }
}

Output:
         Bundle extras = intent.getExtras();
-        if (extras != null) {
-            Log.v("String_Node_Str", "String_Node_Str");
-            appWidgetManager = AppWidgetManager.getInstance(context);
-            widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
-            Log.v("String_Node_Str", "String_Node_Str" + widgetId);
-            getJsonResponse task = new getJsonResponse(context);
-            task.execute();
-        }
+        Log.v("String_Node_Str", "String_Node_Str");
+        appWidgetManager = AppWidgetManager.getInstance(context);
+        widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        Log.v("String_Node_Str", "String_Node_Str" + widgetId);
+        Log.v("String_Node_Str", "String_Node_Str");
+        getJsonResponse task = new getJsonResponse(context);
+        task.execute();
     } else {


Input:
private void init() {
    scenarios = applicationContext.getBeansOfType(SimulatorScenario.class);
    log.info(String.format("String_Node_Str", Arrays.toString(scenarios.keySet().toArray())));
    scenarioStarters = applicationContext.getBeansOfType(ScenarioStarter.class);
    log.info(String.format("String_Node_Str", Arrays.toString(scenarioStarters.keySet().toArray())));
}

Output:
 private void init() {
-    scenarios = applicationContext.getBeansOfType(SimulatorScenario.class);
-    log.info(String.format("String_Node_Str", Arrays.toString(scenarios.keySet().toArray())));
-    scenarioStarters = applicationContext.getBeansOfType(ScenarioStarter.class);
-    log.info(String.format("String_Node_Str", Arrays.toString(scenarioStarters.keySet().toArray())));
+    scenarios = findSimulatorScenarios(applicationContext);
+    scenarioStarters = findScenarioStarters(applicationContext);
 }


Input:
public void run(IProgressMonitor monitor) throws CoreException {
    if (!isMavenProject(javaProject)) {
        return;
    }
    javaProject.getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
    GrailsClasspathContainer container = GrailsClasspathUtils.getClasspathContainer(javaProject);
    if (container != null) {
        container.invalidate();
    }
    GrailsCore.get().connect(javaProject.getProject(), PerProjectDependencyDataCache.class).refreshData();
    GrailsCore.get().connect(javaProject.getProject(), PerProjectPluginCache.class).refreshDependencyCache();
    SourceFolderJob updateSourceFolders = new SourceFolderJob(javaProject);
    updateSourceFolders.refreshSourceFolders(new NullProgressMonitor());
    javaProject.setRawClasspath(javaProject.getRawClasspath(), monitor);
}

Output:
 public void run(IProgressMonitor monitor) throws CoreException {
-    if (!isMavenProject(javaProject)) {
+    if (isMavenProject(javaProject)) {
         return;


Input:
void addAllToSuffix(final String... entries) {
    for (final String classPathEntry : entries) {
        this.addToPrefix(classPathEntry);
    }
}

Output:
     for (final String classPathEntry : entries) {
-        this.addToPrefix(classPathEntry);
+        this.addToSuffix(classPathEntry);
     }


Input:
public static JointSegmentationResult doubly_constrained_multi_segmentation(double[][] y, double alpha_0, double beta_0, int nb_r, int r, double p, boolean constrain_decreasing, double min_fold) {
    int n = y[0].length;
    ExtremeObjectTracker<Integer, Double>[] map = new ExtremeObjectTracker[n];
    ExtremeObjectTracker<Double, Double>[][] map_mle = new ExtremeObjectTracker[y.length][n];
    ExtremeObjectTracker<Double, Double>[][] nxt_mle = new ExtremeObjectTracker[y.length][n];
    double[][][] log_p = new double[y.length][][];
    double[][][] segment_mle = new double[y.length][][];
    SCMResult[] results = new SCMResult[y.length];
    for (int i = 0; i < y.length; i++) {
        results[i] = calculate_segment_probabilities(y[i], alpha_0, beta_0, nb_r);
        log_p[i] = results[i].log_p;
        segment_mle[i] = results[i].segment_mle;
    }
    double[] log_g = new double[n];
    double[] log_G = new double[n];
    log_G[0] = Double.NEGATIVE_INFINITY;
    for (int i = 0; i < n; i++) {
        map[i] = new ExtremeObjectTracker<Integer, Double>(new Util.ComparableComparator<Double>());
        for (int j = 0; j < y.length; j++) {
            map_mle[j][i] = new ExtremeObjectTracker<Double, Double>(new Util.ComparableComparator<Double>());
            nxt_mle[j][i] = new ExtremeObjectTracker<Double, Double>(new Util.ComparableComparator<Double>());
        }
        log_g[i] = log_nb(i, r, p);
        if (i > 0)
            log_G[i] = log_G[i - 1];
        log_G[i] = Util.logSum(Util.list(log_G[i], log_g[i]));
    }
    for (int t = n - 1; t > -1; t--) {
        for (int s = t; s < n - 1; s++) {
            boolean any_satisfy_constraints = false;
            double log_p_t_s = 0;
            double[] extremes = new double[y.length];
            for (int i = 0; i < y.length; i++) {
                log_p_t_s += log_p[i][t][s];
                double next_mle = nxt_mle[i][s + 1].getMaxObject();
                extremes[i] = constrain_decreasing ? Math.max(map_mle[i][s + 1].getMaxObject(), segment_mle[i][t][s]) : Math.min(map_mle[i][s + 1].getMaxObject(), segment_mle[i][t][s]);
                Boolean satisfies_decreasing = null;
                Boolean satisfies_fold = null;
                if (constrain_decreasing) {
                    double fold = next_mle / segment_mle[i][t][s];
                    satisfies_fold = fold <= min_fold;
                    satisfies_decreasing = map_mle[i][s + 1].getMaxObject() < (segment_mle[i][t][s]);
                } else {
                    double fold = segment_mle[i][t][s] / next_mle;
                    satisfies_fold = fold <= min_fold;
                    satisfies_decreasing = (segment_mle[i][t][s]) < map_mle[i][s + 1].getMaxObject();
                }
                any_satisfy_constraints |= (satisfies_fold && satisfies_decreasing);
            }
            if (!any_satisfy_constraints) {
                map[t].put(s + 1, Double.NEGATIVE_INFINITY);
                for (int i = 0; i < y.length; i++) {
                    map_mle[i][t].put(extremes[i], Double.NEGATIVE_INFINITY);
                    nxt_mle[i][t].put(segment_mle[i][t][s], Double.NEGATIVE_INFINITY);
                }
            } else {
                double p_segment_length = t == 0 ? Math.log(1 - Math.exp(log_G[s])) : log_g[s - t];
                map[t].put(s + 1, log_p_t_s + map[s + 1].getMax() + p_segment_length);
                for (int i = 0; i < y.length; i++) {
                    map_mle[i][t].put(extremes[i], log_p_t_s + map[s + 1].getMax() + p_segment_length);
                    nxt_mle[i][t].put(segment_mle[i][t][s], log_p_t_s + map[s + 1].getMax() + p_segment_length);
                }
            }
            for (int i = 0; i < y.length; i++) {
                double extreme = constrain_decreasing ? Math.max(map_mle[i][s + 1].getMaxObject(), segment_mle[i][t][s]) : Math.min(map_mle[i][s + 1].getMaxObject(), segment_mle[i][t][s]);
                if (!(any_satisfy_constraints)) {
                    map_mle[i][t].put(extreme, Double.NEGATIVE_INFINITY);
                    nxt_mle[i][t].put(segment_mle[i][t][s], Double.NEGATIVE_INFINITY);
                } else {
                    double p_segment_length = t == 0 ? Math.log(1 - Math.exp(log_G[s])) : log_g[s - t];
                    map_mle[i][t].put(extreme, log_p_t_s + map[s + 1].getMax() + p_segment_length);
                    nxt_mle[i][t].put(segment_mle[i][t][s], log_p_t_s + map[s + 1].getMax() + p_segment_length);
                }
            }
            if (!(any_satisfy_constraints)) {
                map[t].put(s + 1, Double.NEGATIVE_INFINITY);
            } else {
                double p_segment_length = t == 0 ? Math.log(1 - Math.exp(log_G[s])) : log_g[s - t];
                map[t].put(s + 1, log_p_t_s + map[s + 1].getMax() + p_segment_length);
            }
        }
        double log_p_t_s = 0;
        for (int i = 0; i < y.length; i++) {
            log_p_t_s += log_p[i][t][n - 1];
        }
        map[t].put(n, log_p_t_s + Math.log(1 - Math.exp(log_G[n - t - 1])));
        for (int i = 0; i < y.length; i++) {
            map_mle[i][t].put(segment_mle[i][t][n - 1], log_p_t_s + Math.log(1 - Math.exp(log_G[n - t - 1])));
            nxt_mle[i][t].put(segment_mle[i][t][n - 1], log_p_t_s + Math.log(1 - Math.exp(log_G[n - t - 1])));
        }
    }
    List<Integer> mapCPs = new ArrayList<Integer>();
    List<Double[]> mapMLEs = new ArrayList<Double[]>();
    List<Double> mapLs = new ArrayList<Double>();
    int first = 0;
    int last = map[0].getMaxObject();
    Double[] mle = new Double[y.length];
    for (int i = 0; i < y.length; i++) {
        mle[i] = segment_mle[i][first][last - 1];
    }
    mapMLEs.add(mle);
    while (last < n) {
        mapCPs.add(last - 1);
        first = last;
        last = map[last].getMaxObject();
        mle = new Double[y.length];
        for (int i = 0; i < y.length; i++) {
            mle[i] = segment_mle[i][first][last - 1];
        }
        mapMLEs.add(mle);
    }
    double[][] mles = new double[mapMLEs.size()][y.length];
    for (int i = 0; i < mapMLEs.size(); i++) {
        for (int j = 0; j < y.length; j++) {
            mles[i][j] = mapMLEs.get(i)[j];
        }
    }
    JointSegmentationResult segmentation = new JointSegmentationResult(ArrayUtils.toPrimitive(mapCPs.toArray(new Integer[0])), mles, ArrayUtils.toPrimitive(mapLs.toArray(new Double[0])), n);
    return segmentation;
}

Output:
             }
-            if (!any_satisfy_constraints) {
+            if (!(any_satisfy_constraints && all_positive_upstream)) {
                 map[t].put(s + 1, Double.NEGATIVE_INFINITY);


Input:
boolean close(Exception reason) {
    manager.invokeAndWait(new CTPConnectionToClose(this, reason));
    return false;
}

Output:
 boolean close(Exception reason) {
-    manager.invokeAndWait(new CTPConnectionToClose(this, reason));
+    manager.invokeLater(new CTPConnectionToClose(this, reason));
     return false;


Input:
private RelationshipExpander toExpander(Direction direction, Map<String, Object> filterMap, boolean caseInsensitiveFilters, boolean looseFilters) {
    DefaultExpander expander = new DefaultExpander();
    for (RelationshipType type : getServer().getDb().getRelationshipTypes()) {
        boolean matches = false;
        if (filterMap == null || filterMap.isEmpty()) {
            matches = true;
        } else {
            for (String filter : filterMap.keySet()) {
                if (matches(newPattern(filter, caseInsensitiveFilters), type.name(), caseInsensitiveFilters, looseFilters)) {
                    matches = true;
                    break;
                }
            }
        }
        if (matches) {
            expander = expander.add(type, direction);
        }
    }
    return expander;
}

Output:
 private RelationshipExpander toExpander(Direction direction, Map<String, Object> filterMap, boolean caseInsensitiveFilters, boolean looseFilters) {
-    DefaultExpander expander = new DefaultExpander();
+    Expander expander = TraversalFactory.emptyExpander();
     for (RelationshipType type : getServer().getDb().getRelationshipTypes()) {


Input:
private int totalSlop() {
    if (totalSlop >= 0)
        return totalSlop;
    int matchSlop = 0;
    int lastStart = -1;
    int lastEnd = -1;
    for (int i = 0; i < ordered.size(); i++) {
        SpansCell cell = (SpansCell) ordered.get(i);
        int start = cell.start();
        int end = cell.end();
        if (i > 0) {
            if (end <= lastStart)
                matchSlop += (lastStart - end);
            else if (start >= lastEnd)
                matchSlop += (start - lastEnd);
            else
                ;
        }
        lastStart = start;
        lastEnd = end;
    }
    return totalSlop = matchSlop;
}

Output:
             if (end <= lastStart)
-                matchSlop += (lastStart - end);
+                matchSlop += (lastStart - end) + 1;
             else if (start >= lastEnd)


Input:
public void setUp() throws Exception {
    createTestMetadata();
    logger.info("String_Node_Str" + this.getTestConfig());
    MetadataManager.removeInstance(this.getTestConfig());
    CubeManager.removeInstance(this.getTestConfig());
    ProjectManager.removeInstance(this.getTestConfig());
    DictionaryManager.removeInstance(this.getTestConfig());
    FileUtils.deleteDirectory(new File("String_Node_Str"));
    MergeCuboidMapper mapper = new MergeCuboidMapper();
    mapDriver = MapDriver.newMapDriver(mapper);
    cubeManager = CubeManager.getInstance(this.getTestConfig());
    cube = cubeManager.getCube("String_Node_Str");
    dictionaryManager = DictionaryManager.getInstance(getTestConfig());
    lfn = cube.getDescriptor().findColumnRef("String_Node_Str", "String_Node_Str");
    lsi = cube.getDescriptor().findColumnRef("String_Node_Str", "String_Node_Str");
    ssc = cube.getDescriptor().findColumnRef("String_Node_Str", "String_Node_Str");
    DictionaryInfo sharedDict = makeSharedDict();
    boolean isFirstSegment = true;
    for (CubeSegment segment : cube.getSegments()) {
        TableSignature signature = new TableSignature();
        signature.setSize(100);
        signature.setLastModifiedTime(System.currentTimeMillis());
        signature.setPath("String_Node_Str" + lfn.getName() + segment.getName());
        DictionaryInfo newDictInfo = new DictionaryInfo(lfn.getTable(), lfn.getColumn().getName(), lfn.getColumn().getZeroBasedIndex(), "String_Node_Str", signature, "String_Node_Str");
        List<byte[]> values = new ArrayList<byte[]>();
        values.add(new byte[] { 97, 97, 97 });
        if (isFirstSegment)
            values.add(new byte[] { 99, 99, 99 });
        else
            values.add(new byte[] { 98, 98, 98 });
        Dictionary<?> dict = DictionaryGenerator.buildDictionaryFromValueList(newDictInfo, values);
        dictionaryManager.trySaveNewDict(dict, newDictInfo);
        ((TrieDictionary) dict).dump(System.out);
        segment.putDictResPath(lfn, newDictInfo.getResourcePath());
        segment.putDictResPath(lsi, sharedDict.getResourcePath());
        segment.putDictResPath(ssc, sharedDict.getResourcePath());
        cubeManager.updateCube(cube);
        isFirstSegment = false;
    }
}

Output:
     CubeManager.removeInstance(this.getTestConfig());
-    ProjectManager.removeInstance(this.getTestConfig());
+    CubeRealizationManager.removeInstance(this.getTestConfig());
     DictionaryManager.removeInstance(this.getTestConfig());


Input:
public void resumeSelectAttackers(Game game) {
    Player player = game.getPlayer(attackerId);
    for (CombatGroup group : groups) {
        for (UUID attacker : group.getAttackers()) {
            game.fireEvent(GameEvent.getEvent(GameEvent.EventType.ATTACKER_DECLARED, group.defenderId, attacker, attackerId));
        }
    }
    game.fireEvent(GameEvent.getEvent(GameEvent.EventType.DECLARED_ATTACKERS, attackerId, attackerId));
    game.informPlayers(new StringBuilder(player.getName()).append("String_Node_Str").append(groups.size()).append("String_Node_Str").toString());
}

Output:
     game.fireEvent(GameEvent.getEvent(GameEvent.EventType.DECLARED_ATTACKERS, attackerId, attackerId));
-    game.informPlayers(new StringBuilder(player.getName()).append("String_Node_Str").append(groups.size()).append("String_Node_Str").toString());
+    game.informPlayers(new StringBuilder(player.getName()).append("String_Node_Str").append(groups.size()).append(groups.size() == 1 ? "String_Node_Str" : "String_Node_Str").toString());
 }


Input:
protected Properties createConfig() {
    assertTrue(FTPSERVER_KEYSTORE.exists());
    Properties configProps = new Properties();
    configProps.setProperty("String_Node_Str", IOListener.class.getName());
    configProps.setProperty("String_Node_Str", Integer.toString(port));
    configProps.setProperty("String_Node_Str", DefaultSsl.class.getName());
    configProps.setProperty("String_Node_Str", FTPSERVER_KEYSTORE.getAbsolutePath());
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", getAuthValue());
    configProps.setProperty("String_Node_Str", getClientAuth());
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", DefaultDataConnectionConfig.class.getName());
    configProps.setProperty("String_Node_Str", DefaultSsl.class.getName());
    configProps.setProperty("String_Node_Str", FTPSERVER_KEYSTORE.getAbsolutePath());
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", getAuthValue());
    configProps.setProperty("String_Node_Str", getClientAuth());
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    configProps.setProperty("String_Node_Str", USERS_FILE.getAbsolutePath());
    configProps.setProperty("String_Node_Str", "String_Node_Str");
    return configProps;
}

Output:
     Properties configProps = new Properties();
-    configProps.setProperty("String_Node_Str", IOListener.class.getName());
+    configProps.setProperty("String_Node_Str", MinaListener.class.getName());
     configProps.setProperty("String_Node_Str", Integer.toString(port));


Input:
private static FileInfo lookUpFileInfo(Environment env, TraversalRequest traversal) throws MissingDepException, IOException, InterruptedException {
    FileValue fileValue = (FileValue) env.getValueOrThrow(FileValue.key(traversal.path), IOException.class);
    if (env.valuesMissing()) {
        throw new MissingDepException();
    }
    if (fileValue.exists()) {
        PathFragment unresolvedLinkTarget = null;
        FileType type = null;
        if (fileValue.isSymlink()) {
            unresolvedLinkTarget = fileValue.getUnresolvedLinkTarget();
            type = fileValue.isDirectory() ? FileType.SYMLINK_TO_DIRECTORY : FileType.SYMLINK_TO_FILE;
        } else {
            type = fileValue.isDirectory() ? FileType.DIRECTORY : FileType.FILE;
        }
        return new FileInfo(type, fileValue.realFileStateValue(), fileValue.realRootedPath(), unresolvedLinkTarget);
    } else {
        return new FileInfo(fileValue.isSymlink() ? FileType.DANGLING_SYMLINK : FileType.NONEXISTENT, fileValue.realFileStateValue(), null, fileValue.isSymlink() ? fileValue.getUnresolvedLinkTarget() : null);
    }
}

Output:
 private static FileInfo lookUpFileInfo(Environment env, TraversalRequest traversal) throws MissingDepException, IOException, InterruptedException {
-    FileValue fileValue = (FileValue) env.getValueOrThrow(FileValue.key(traversal.path), IOException.class);
-    if (env.valuesMissing()) {
-        throw new MissingDepException();
-    }
-    if (fileValue.exists()) {
+    if (traversal.isGenerated) {
+        byte[] digest = null;
+        if (traversal.root.getOutputArtifact() != null) {
+            Artifact artifact = traversal.root.getOutputArtifact();
+            SkyKey artifactKey = ArtifactSkyKey.key(artifact, true);
+            SkyValue value = env.getValue(artifactKey);
+            if (env.valuesMissing()) {
+                throw new MissingDepException();
+            }
+            if (value instanceof FileArtifactValue) {
+                FileArtifactValue fsVal = (FileArtifactValue) value;
+                digest = fsVal.getDigest();
+            } else {
+                return new FileInfo(FileType.NONEXISTENT, null, null, null);
+            }
+        }
+        Path path = traversal.root.asRootedPath().asPath();
+        FileStatus noFollowStat = path.stat(Symlinks.NOFOLLOW);
+        FileStatus followStat = path.statIfFound(Symlinks.FOLLOW);
+        FileType type;
         PathFragment unresolvedLinkTarget = null;


Input:
private BeanDefinition createSelectiveDatabasePopulator(Element element) {
    List<Element> scripts = DomUtils.getChildElementsByTagName(element, "String_Node_Str");
    List<Element> exceptionElements = DomUtils.getChildElementsByTagName(element, "String_Node_Str");
    boolean ignoreFailedDrops = element.getAttribute("String_Node_Str").equals("String_Node_Str");
    boolean continueOnError = element.getAttribute("String_Node_Str").equals("String_Node_Str");
    BeanDefinitionBuilder selectivebuilder = BeanDefinitionBuilder.genericBeanDefinition(SelectiveDatabasePopulator.class);
    BeanDefinitionBuilder defaultDbPopulatorbuilder = createResourceDatabasePopulatorBuilder(scripts, ignoreFailedDrops, continueOnError);
    selectivebuilder.addPropertyValue("String_Node_Str", defaultDbPopulatorbuilder);
    for (Element exception : exceptionElements) {
        String product = exception.getAttribute("String_Node_Str");
        List<Element> exceptionScripts = DomUtils.getChildElementsByTagName(exception, "String_Node_Str");
        selectivebuilder.addPropertyValue("String_Node_Str" + product + "String_Node_Str", createResourceDatabasePopulatorBuilder(exceptionScripts, ignoreFailedDrops, continueOnError));
    }
    return selectivebuilder.getBeanDefinition();
}

Output:
     BeanDefinitionBuilder selectivebuilder = BeanDefinitionBuilder.genericBeanDefinition(SelectiveDatabasePopulator.class);
-    BeanDefinitionBuilder defaultDbPopulatorbuilder = createResourceDatabasePopulatorBuilder(scripts, ignoreFailedDrops, continueOnError);
-    selectivebuilder.addPropertyValue("String_Node_Str", defaultDbPopulatorbuilder);
+    BeanDefinition defaultDbPopulator = createResourceDatabasePopulator(scripts, ignoreFailedDrops, continueOnError);
+    selectivebuilder.addPropertyValue("String_Node_Str", defaultDbPopulator);
     for (Element exception : exceptionElements) {


Input:
private void parseJsonQuery(Query query, ObjectNode objectNode) throws QueryException {
    QueryPart queryPart = new QueryPart(packageMetaData);
    if (objectNode.has("String_Node_Str")) {
        JsonNode typeNode = objectNode.get("String_Node_Str");
        if (typeNode.isTextual()) {
            String type = typeNode.asText();
            addType(objectNode, queryPart, type);
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode typesNode = objectNode.get("String_Node_Str");
        if (typesNode instanceof ArrayNode) {
            ArrayNode types = (ArrayNode) typesNode;
            for (int i = 0; i < types.size(); i++) {
                JsonNode typeNode = types.get(i);
                if (typeNode.isTextual()) {
                    String type = typeNode.asText();
                    addType(objectNode, queryPart, type);
                } else {
                    throw new QueryException("String_Node_Str" + i + "String_Node_Str");
                }
            }
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str") && objectNode.get("String_Node_Str").asBoolean()) {
        queryPart.setIncludeAllFields(true);
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode oidNode = objectNode.get("String_Node_Str");
        if (oidNode.isNumber()) {
            queryPart.addOid(oidNode.asInt());
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode oidsNode = objectNode.get("String_Node_Str");
        if (oidsNode instanceof ArrayNode) {
            ArrayNode oids = (ArrayNode) oidsNode;
            for (int i = 0; i < oids.size(); i++) {
                JsonNode oidNode = oids.get(i);
                if (oidNode.isNumber()) {
                    queryPart.addOid(oidNode.asInt());
                } else {
                    throw new QueryException("String_Node_Str" + i + "String_Node_Str");
                }
            }
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode guidNode = objectNode.get("String_Node_Str");
        if (guidNode.isTextual()) {
            queryPart.addGuid(guidNode.asText());
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode guidsNode = objectNode.get("String_Node_Str");
        if (guidsNode instanceof ArrayNode) {
            ArrayNode guids = (ArrayNode) guidsNode;
            for (int i = 0; i < guids.size(); i++) {
                JsonNode guidNode = guids.get(i);
                if (guidNode.isTextual()) {
                    queryPart.addGuid(guidNode.asText());
                } else {
                    throw new QueryException("String_Node_Str" + i + "String_Node_Str");
                }
            }
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode propertiesNode = objectNode.get("String_Node_Str");
        if (propertiesNode instanceof ObjectNode) {
            ObjectNode properties = (ObjectNode) objectNode.get("String_Node_Str");
            Iterator<Entry<String, JsonNode>> fields = properties.fields();
            while (fields.hasNext()) {
                Entry<String, JsonNode> entry = fields.next();
                JsonNode value = entry.getValue();
                if (value.isValueNode()) {
                    queryPart.addProperty(entry.getKey(), value.asBoolean());
                } else {
                    throw new QueryException("String_Node_Str" + entry.getKey() + "String_Node_Str");
                }
            }
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode boundingBoxNode = objectNode.get("String_Node_Str");
        if (boundingBoxNode instanceof ObjectNode) {
            ObjectNode boundingBox = (ObjectNode) boundingBoxNode;
            double x = checkFloat(boundingBox, "String_Node_Str");
            double y = checkFloat(boundingBox, "String_Node_Str");
            double z = checkFloat(boundingBox, "String_Node_Str");
            double width = checkFloat(boundingBox, "String_Node_Str");
            double height = checkFloat(boundingBox, "String_Node_Str");
            double depth = checkFloat(boundingBox, "String_Node_Str");
            queryPart.setInBoundingBox(new InBoundingBox(x, y, z, width, height, depth));
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode includeNode = objectNode.get("String_Node_Str");
        processSubInclude(query, queryPart, includeNode);
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode includesNode = objectNode.get("String_Node_Str");
        if (includesNode instanceof ArrayNode) {
            ArrayNode includes = (ArrayNode) includesNode;
            for (int i = 0; i < includes.size(); i++) {
                JsonNode include = includes.get(i);
                processSubInclude(query, queryPart, include);
            }
        } else {
            throw new QueryException("String_Node_Str");
        }
    }
    if (objectNode.has("String_Node_Str")) {
        JsonNode fieldsNode = objectNode.get("String_Node_Str");
    }
    Iterator<String> fieldNames = objectNode.fieldNames();
    while (fieldNames.hasNext()) {
        String fieldName = fieldNames.next();
        if (fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str") || fieldName.equals("String_Node_Str")) {
        } else {
            throw new QueryException("String_Node_Str" + fieldName + "String_Node_Str");
        }
    }
    query.addQueryPart(queryPart);
}

Output:
         if (oidNode.isNumber()) {
-            queryPart.addOid(oidNode.asInt());
+            queryPart.addOid(oidNode.asLong());
         } else {


Input:
private void processEnvelopeWithBuffer(final TransferEnvelope transferEnvelope, final TransferEnvelopeReceiverList receiverList, final boolean freeSourceBuffer) throws IOException, InterruptedException {
    if (!freeSourceBuffer) {
        final List<ChannelID> localReceivers = receiverList.getLocalReceivers();
        if (localReceivers.size() != 1) {
            throw new IOException("String_Node_Str");
        }
        final ChannelID localReceiver = localReceivers.get(0);
        final ChannelContext cc = this.registeredChannels.get(localReceiver);
        if (cc == null) {
            throw new IOException("String_Node_Str" + localReceiver);
        }
        if (!cc.isInputChannel()) {
            throw new IOException("String_Node_Str" + localReceiver + "String_Node_Str");
        }
        cc.queueTransferEnvelope(transferEnvelope);
        return;
    }
    final Buffer srcBuffer = transferEnvelope.getBuffer();
    if (receiverList.hasLocalReceivers()) {
        final List<ChannelID> localReceivers = receiverList.getLocalReceivers();
        for (final ChannelID localReceiver : localReceivers) {
            final ChannelContext cc = this.registeredChannels.get(localReceiver);
            if (cc == null) {
                throw new IOException("String_Node_Str" + localReceiver);
            }
            if (!cc.isInputChannel()) {
                throw new IOException("String_Node_Str" + localReceiver + "String_Node_Str");
            }
            final InputChannelContext inputChannelContext = (InputChannelContext) cc;
            final Buffer destBuffer = inputChannelContext.requestEmptyBufferBlocking(srcBuffer.size());
            srcBuffer.copyToBuffer(destBuffer);
            final TransferEnvelope dup = transferEnvelope.duplicateWithoutBuffer();
            dup.setBuffer(destBuffer);
            inputChannelContext.queueTransferEnvelope(dup);
        }
    }
    if (receiverList.hasRemoteReceivers()) {
        final List<InetSocketAddress> remoteReceivers = receiverList.getRemoteReceivers();
        for (final InetSocketAddress remoteReceiver : remoteReceivers) {
            this.networkConnectionManager.queueEnvelopeForTransfer(remoteReceiver, transferEnvelope.duplicate());
        }
    }
    srcBuffer.recycleBuffer();
}

Output:
             final InputChannelContext inputChannelContext = (InputChannelContext) cc;
-            final Buffer destBuffer = inputChannelContext.requestEmptyBufferBlocking(srcBuffer.size());
+            final Buffer destBuffer = inputChannelContext.requestEmptyBufferBlocking(srcBuffer.size(), 1);
             srcBuffer.copyToBuffer(destBuffer);


Input:
private boolean sameSignature(final IMethodName recMethod, final IMethod jdtMethod) throws JavaModelException {
    if (!(bothConstructors(recMethod, jdtMethod) || sameName(recMethod, jdtMethod))) {
        return false;
    }
    final ITypeName[] recTypes = recMethod.getParameterTypes();
    final String[] jdtTypes = jdtMethod.getParameterTypes();
    if (!sameNumberOfParameters(recMethod, jdtMethod)) {
        return false;
    }
    for (int i = 0; i < recTypes.length; i++) {
        final Optional<ITypeName> jdtType = JdtUtils.resolveUnqualifiedJDTType(jdtTypes[i], jdtMethod);
        if (!jdtType.isPresent()) {
            return false;
        }
        if (!sameSimpleTypes(recTypes[i], jdtType.get()) || !sameArrayDimensions(recTypes[i], jdtType.get())) {
            return false;
        }
    }
    return true;
}

Output:
         }
-        if (!sameSimpleTypes(recTypes[i], jdtType.get()) || !sameArrayDimensions(recTypes[i], jdtType.get())) {
+        if (!sameSimpleTypes(recTypes[i], jdtType.get()) || !sameArrayDimensions(recTypes[i], jdtTypes[i])) {
             return false;


Input:
public Year scrapeYear() {
    Element releaseDateElement = document.select("String_Node_Str").first();
    if (releaseDateElement != null & releaseDateElement.text().contains("String_Node_Str"))
        releaseDateElement = document.select("String_Node_Str").first();
    if (releaseDateElement != null) {
        String releaseDateText = releaseDateElement.text().trim();
        if (releaseDateText.length() >= 4) {
            releaseDateText = releaseDateText.substring(releaseDateText.length() - 4, releaseDateText.length());
            return new Year(releaseDateText);
        }
    }
    return Year.BLANK_YEAR;
}

Output:
 public Year scrapeYear() {
-    Element releaseDateElement = document.select("String_Node_Str").first();
-    if (releaseDateElement != null & releaseDateElement.text().contains("String_Node_Str"))
-        releaseDateElement = document.select("String_Node_Str").first();
-    if (releaseDateElement != null) {
-        String releaseDateText = releaseDateElement.text().trim();
-        if (releaseDateText.length() >= 4) {
-            releaseDateText = releaseDateText.substring(releaseDateText.length() - 4, releaseDateText.length());
-            return new Year(releaseDateText);
-        }
-    }
-    return Year.BLANK_YEAR;
+    return scrapeReleaseDate().getYear();
 }


Input:
private void resetAndRefreshLocal(final String[] names) {
    resetModulesNeeded();
    Project currentProject = ProjectManager.getInstance().getCurrentProject();
    final String projectLabel = currentProject.getTechnicalLabel();
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    final IProject eclipseProject = workspace.getRoot().getProject(projectLabel);
    if (PluginChecker.isSVNProviderPluginLoaded()) {
        ISVNProviderServiceInCoreRuntime service = (ISVNProviderServiceInCoreRuntime) GlobalServiceRegister.getDefault().getService(ISVNProviderServiceInCoreRuntime.class);
        if (service != null) {
            File libFile = new File(LibrariesManagerUtils.getLibrariesPath(ECodeLanguage.JAVA));
            if (service.isSvnLibSetupOnTAC() && service.isInSvn(libFile.getAbsolutePath()) && !getRepositoryContext().isOffline()) {
                List jars = new ArrayList();
                for (String name : names) {
                    jars.add(libFile.getAbsolutePath() + File.separatorChar + name);
                }
                service.depolyNewJar(jars);
                return;
            }
        }
    }
    if (PluginChecker.isSVNProviderPluginLoaded()) {
        RepositoryWorkUnit repositoryWorkUnit = new RepositoryWorkUnit(currentProject, "String_Node_Str") {

            public void run() throws PersistenceException {
                try {
                    for (String name : names) {
                        String path = new Path(Platform.getInstanceLocation().getURL().getPath()).toFile().getPath();
                        path = path + File.separatorChar + projectLabel + File.separatorChar + ERepositoryObjectType.getFolderName(ERepositoryObjectType.LIBS) + File.separatorChar + name;
                        File libsTargetFile = new File(path);
                        File source = new File(LibrariesManagerUtils.getLibrariesPath(ECodeLanguage.JAVA) + File.separatorChar + name);
                        FilesUtils.copyFile(source, libsTargetFile);
                        synJavaLibs(source);
                    }
                    eclipseProject.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
                } catch (IOException e) {
                    CommonExceptionHandler.process(e);
                } catch (CoreException e) {
                    CommonExceptionHandler.process(e);
                }
            }
        };
        repositoryWorkUnit.setAvoidUnloadResources(true);
        if (GlobalServiceRegister.getDefault().isServiceRegistered(IRepositoryService.class)) {
            IRepositoryService service = (IRepositoryService) GlobalServiceRegister.getDefault().getService(IRepositoryService.class);
            service.getProxyRepositoryFactory().executeRepositoryWorkUnit(repositoryWorkUnit);
        }
    }
}

Output:
     if (PluginChecker.isSVNProviderPluginLoaded()) {
-        RepositoryWorkUnit repositoryWorkUnit = new RepositoryWorkUnit(currentProject, "String_Node_Str") {
+        final RepositoryWorkUnit repositoryWorkUnit = new RepositoryWorkUnit(currentProject, "String_Node_Str") {


Input:
public void startRow(IRowContent row) {
    currentRowID++;
    CellWrapper[] newRowContent = new CellWrapper[columnNumber];
    if (currentRowID > 0) {
        for (int i = 0; i < columnNumber; i++) {
            if (currentRowContent[i] != null) {
                int rowSpan = currentRowContent[i].rowSpan;
                if (rowSpan > 0 && currentRowID < rowSpan + currentRowContent[i].rowID || rowSpan < 0) {
                    newRowContent[i] = currentRowContent[i];
                } else {
                    newRowContent[i] = null;
                    removeDropAreaByIndex(i);
                }
            }
        }
    }
    lastRowContent = currentRowContent;
    lastRow = currentRow;
    currentRowContent = newRowContent;
    currentRow = new RowWrapper(row, currentRowID);
}

Output:
                     newRowContent[i] = null;
-                    removeDropAreaByIndex(i);
+                    removedDropCells.add(new Integer(i));
                 }


Input:
protected void addResponse(ContactNode node) {
    if (responses.size() == resultSize) {
        KUID furthest = lookup.invert();
        responses.remove((KUID) responses.select(furthest));
    }
    responses.put(node.getNodeID(), node);
}

Output:
         KUID furthest = lookup.invert();
-        responses.remove((KUID) responses.select(furthest));
+        responses.remove(((ContactNode) responses.select(furthest)).getNodeID());
     }


Input:
public void launch(ILaunchConfiguration config, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
    if (!PerfCore.checkPerfInPath()) {
        IStatus status = new Status(IStatus.ERROR, PerfPlugin.PLUGIN_ID, "String_Node_Str");
        throw new CoreException(status);
    }
    IPath exePath = CDebugUtils.verifyProgramPath(config);
    String[] arguments = getProgramArgumentsArray(config);
    File wd = getWorkingDirectory(config);
    if (wd == null) {
        wd = new File(System.getProperty("String_Node_Str", "String_Node_Str"));
    }
    IPath workingDir = Path.fromOSString(wd.toURI().getPath());
    PerfPlugin.getDefault().setWorkingDir(workingDir);
    if (config.getAttribute(PerfPlugin.ATTR_ShowStat, PerfPlugin.ATTR_ShowStat_default)) {
        int runCount = config.getAttribute(PerfPlugin.ATTR_StatRunCount, PerfPlugin.ATTR_StatRunCount_default);
        StringBuffer args = new StringBuffer();
        for (String arg : arguments) {
            args.append(arg);
            args.append("String_Node_Str");
        }
        String title = renderProcessLabel("String_Node_Str" + exePath.toOSString() + "String_Node_Str" + args.toString() + "String_Node_Str" + runCount + "String_Node_Str");
        StatData sd = null;
        Object[] configEvents = config.getAttribute(PerfPlugin.ATTR_SelectedEvents, PerfPlugin.ATTR_SelectedEvents_default).toArray();
        String[] statEvents = new String[0];
        if (!config.getAttribute(PerfPlugin.ATTR_DefaultEvent, PerfPlugin.ATTR_DefaultEvent_default)) {
            statEvents = configEvents == null ? statEvents : Arrays.asList(configEvents).toArray(new String[] {});
        }
        sd = new StatData(title, exePath.toOSString(), arguments, runCount, statEvents);
        sd.parse();
        PerfPlugin.getDefault().setStatData(sd);
        StatView.refreshView();
    } else {
        ArrayList<String> command = new ArrayList<String>();
        command.addAll(Arrays.asList(PerfCore.getRecordString(config)));
        command.add(exePath.toOSString());
        command.addAll(Arrays.asList(arguments));
        String[] commandArray = command.toArray(new String[] {});
        boolean usePty = config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_USE_TERMINAL, ICDTLaunchConfigurationConstants.USE_TERMINAL_DEFAULT);
        Process process;
        try {
            process = execute(commandArray, getEnvironment(config), wd, usePty);
            createNewProcess(launch, process, commandArray[0]);
            process.waitFor();
            PrintStream print = null;
            if (config.getAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, true)) {
                ConsolePlugin plugin = ConsolePlugin.getDefault();
                IConsoleManager conMan = plugin.getConsoleManager();
                IConsole[] existing = conMan.getConsoles();
                IOConsole binaryOutCons = null;
                for (IConsole x : existing) {
                    if (x.getName().contains(renderProcessLabel(commandArray[0]))) {
                        binaryOutCons = (IOConsole) x;
                    }
                }
                if ((binaryOutCons == null) && (existing.length != 0)) {
                    if (existing[existing.length - 1] instanceof IOConsole)
                        binaryOutCons = (IOConsole) existing[existing.length - 1];
                }
                OutputStream outputTo;
                if (binaryOutCons != null) {
                    outputTo = binaryOutCons.newOutputStream();
                    print = new PrintStream(outputTo);
                    for (int i = 0; i < commandArray.length; i++) {
                        print.print(commandArray[i] + "String_Node_Str");
                    }
                    print.println();
                    print.println("String_Node_Str");
                }
            }
            PerfCore.Report(config, getEnvironment(config), workingDir, monitor, null, print);
            PerfCore.RefreshView(renderProcessLabel(exePath.toOSString()));
            if (config.getAttribute(PerfPlugin.ATTR_ShowSourceDisassembly, PerfPlugin.ATTR_ShowSourceDisassembly_default)) {
                String title = renderProcessLabel(workingDir + "String_Node_Str");
                SourceDisassemblyData sdData = new SourceDisassemblyData(title, workingDir);
                sdData.parse();
                PerfPlugin.getDefault().setSourceDisassemblyData(sdData);
                SourceDisassemblyView.refreshView();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Output:
         StatData sd = null;
-        Object[] configEvents = config.getAttribute(PerfPlugin.ATTR_SelectedEvents, PerfPlugin.ATTR_SelectedEvents_default).toArray();
-        String[] statEvents = new String[0];
+        List<String> configEvents = config.getAttribute(PerfPlugin.ATTR_SelectedEvents, PerfPlugin.ATTR_SelectedEvents_default);
+        String[] statEvents = new String[] {};
         if (!config.getAttribute(PerfPlugin.ATTR_DefaultEvent, PerfPlugin.ATTR_DefaultEvent_default)) {


Input:
public void run() {
    deleteMenu();
    if (entry instanceof Menu) {
        GtkMenu item = new GtkMenu(GtkMenu.this);
        menuEntries.add(index, item);
        ((Menu) entry).bind(item, parentMenu, parentMenu.getSystemTray());
    } else if (entry instanceof Separator) {
        GtkMenuItemSeparator item = new GtkMenuItemSeparator(GtkMenu.this);
        menuEntries.add(index, item);
        entry.bind(item, parentMenu, parentMenu.getSystemTray());
    } else if (entry instanceof Checkbox) {
        GtkMenuItemCheckbox item = new GtkMenuItemCheckbox(GtkMenu.this);
        menuEntries.add(index, item);
        ((Checkbox) entry).bind(item, parentMenu, parentMenu.getSystemTray());
    } else if (entry instanceof Status) {
        GtkMenuItemStatus item = new GtkMenuItemStatus(GtkMenu.this);
        menuEntries.add(index, item);
        ((Status) entry).bind(item, parentMenu, parentMenu.getSystemTray());
    } else if (entry instanceof MenuItem) {
        GtkMenuItem item = new GtkMenuItem(GtkMenu.this);
        menuEntries.add(index, item);
        ((MenuItem) entry).bind(item, parentMenu, parentMenu.getSystemTray());
    }
    createMenu();
}

Output:
     if (entry instanceof Menu) {
-        GtkMenu item = new GtkMenu(GtkMenu.this);
+        item = new GtkMenu(GtkMenu.this);
         menuEntries.add(index, item);


Input:
private String derivedComplexType(final EdmComplexType baseType, final String definedType) throws SerializerException {
    String derived = baseType.getFullQualifiedName().getFullQualifiedNameAsString();
    if (derived.equals(definedType)) {
        return null;
    }
    return definedType;
}

Output:
 private String derivedComplexType(final EdmComplexType baseType, final String definedType) throws SerializerException {
-    String derived = baseType.getFullQualifiedName().getFullQualifiedNameAsString();
-    if (derived.equals(definedType)) {
+    String base = baseType.getFullQualifiedName().getFullQualifiedNameAsString();
+    if (base.equals(definedType)) {
         return null;


Input:
public void execute() {
    DialogManager.getManager().fadeOut((DialogContainer) getParent());
}

Output:
 public void execute() {
-    DialogManager.getManager().fadeOut((DialogContainer) getParent());
+    DialogManager.getManager(gameId).fadeOut((DialogContainer) getParent());
 }


Input:
public String toString() {
    return "String_Node_Str" + restriction + "String_Node_Str" + subject + "String_Node_Str" + object + "String_Node_Str" + componentDefinition + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + restriction + "String_Node_Str" + subject + "String_Node_Str" + object + "String_Node_Str" + componentDefinition + "String_Node_Str";
+    return "String_Node_Str" + restriction + "String_Node_Str" + subject + "String_Node_Str" + object + "String_Node_Str";
 }


Input:
public void onRecord(int tag, int timestamp, int length, HprofReader reader) throws IOException {
    reader.getInputStream().skip(length);
}

Output:
 public void onRecord(int tag, int timestamp, int length, HprofReader reader) throws IOException {
-    reader.getInputStream().skip(length);
+    skip(reader.getInputStream(), length);
 }


Input:
protected void setIntrinsicProperty(String propName, Object value) {
    if (EXTENSION_NAME_PROP.equals(propName)) {
        extensionName = (String) value;
        provider = new PeerExtensibilityProvider(this, extensionName);
    } else {
        super.setIntrinsicProperty(propName, value);
    }
}

Output:
         extensionName = (String) value;
-        provider = new PeerExtensibilityProvider(this, extensionName);
+        if (extensionName != null)
+            provider = new PeerExtensibilityProvider(this, extensionName);
+        else
+            provider = null;
     } else {