Input:
public void startRequest(MRCRequest rq) {
    try {
        Args rqArgs = (Args) rq.getRequestArgs();
        final VolumeManager vMan = master.getVolumeManager();
        final FileAccessManager faMan = master.getFileAccessManager();
        Path p = new Path(rqArgs.path);
        VolumeInfo volume = vMan.getVolumeByName(p.getComp(0));
        StorageManager sMan = vMan.getStorageManager(volume.getId());
        PathResolver res = new PathResolver(sMan, p);
        faMan.checkSearchPermission(sMan, res, rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        res.checkIfFileDoesNotExist();
        FileMetadata file = res.getFile();
        String target = sMan.getSoftlinkTarget(file.getId());
        if (target != null) {
            rqArgs.path = target;
            p = new Path(rqArgs.path);
            if (!vMan.hasVolume(p.getComp(0))) {
                finishRequest(rq, new ErrorRecord(ErrorClass.REDIRECT, target));
                return;
            }
            volume = vMan.getVolumeByName(p.getComp(0));
            sMan = vMan.getStorageManager(volume.getId());
            res = new PathResolver(sMan, p);
            file = res.getFile();
        }
        faMan.checkPrivilegedPermissions(sMan, file, rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        AtomicDBUpdate update = sMan.createAtomicDBUpdate(master, rq);
        faMan.setPosixAccessMode(sMan, file, res.getParentDirId(), rq.getDetails().userId, rq.getDetails().groupIds, rqArgs.mode, update);
        MRCOpHelper.updateFileTimes(res.getParentDirId(), file, false, true, false, sMan, update);
        rq.setData(ReusableBuffer.wrap(JSONParser.writeJSON(null).getBytes()));
        update.execute();
    } catch (UserException exc) {
        Logging.logMessage(Logging.LEVEL_TRACE, this, exc);
        finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, exc.getErrno(), exc.getMessage(), exc));
    } catch (Exception exc) {
        finishRequest(rq, new ErrorRecord(ErrorClass.INTERNAL_SERVER_ERROR, "String_Node_Str", exc));
    }
}

Output:
         faMan.setPosixAccessMode(sMan, file, res.getParentDirId(), rq.getDetails().userId, rq.getDetails().groupIds, rqArgs.mode, update);
-        MRCOpHelper.updateFileTimes(res.getParentDirId(), file, false, true, false, sMan, update);
+        MRCHelper.updateFileTimes(res.getParentDirId(), file, false, true, false, sMan, update);
         rq.setData(ReusableBuffer.wrap(JSONParser.writeJSON(null).getBytes()));


Input:
private void initNodeEditor(UserRequest ureq, CourseNode chosenNode) {
    ICourse course = CourseFactory.getCourseEditSession(ores.getResourceableId());
    tabbedNodeConfig.removeAll();
    removeAsListenerAndDispose(nodeEditCntrllr);
    String type = chosenNode.getType();
    CourseNodeConfiguration cnConfig = CourseNodeFactory.getInstance().getCourseNodeConfigurationEvenForDisabledBB(type);
    if (cnConfig.isEnabled()) {
        nodeEditCntrllr = chosenNode.createEditController(ureq, getWindowControl(), stackPanel, course, euce);
        listenTo(nodeEditCntrllr);
        nodeEditCntrllr.addTabs(tabbedNodeConfig);
    }
    boolean disabled = !cnConfig.isEnabled();
    boolean deprecated = cnConfig.isDeprecated();
    main.contextPut("String_Node_Str", disabled);
    main.contextPut("String_Node_Str", deprecated);
    alternativeLink.setVisible((disabled || deprecated) && !cnConfig.getAlternativeCourseNodes().isEmpty());
    alternativeLink.setUserObject(chosenNode);
    String nodeCssClass = null;
    if (chosenNode.getParent() == null) {
        nodeCssClass = "String_Node_Str";
    } else {
        nodeCssClass = cnConfig.getIconCSSClass();
    }
    main.contextPut("String_Node_Str", nodeCssClass);
    main.contextPut("String_Node_Str", chosenNode);
}

Output:
     String nodeCssClass = null;
-    if (chosenNode.getParent() == null) {
+    if (this.cetm.getRootNode().getIdent().equals(chosenNode.getIdent())) {
         nodeCssClass = "String_Node_Str";


Input:
private final int broadcastIntentLocked(ProcessRecord callerApp, String callerPackage, Intent intent, String resolvedType, IIntentReceiver resultTo, int resultCode, String resultData, Bundle map, String requiredPermission, boolean ordered, boolean sticky, int callingPid, int callingUid) {
    intent = new Intent(intent);
    if (DEBUG_BROADCAST)
        Log.v(TAG, (sticky ? "String_Node_Str" : "String_Node_Str") + intent + "String_Node_Str" + ordered);
    if ((resultTo != null) && !ordered) {
        Log.w(TAG, "String_Node_Str" + intent + "String_Node_Str");
    }
    final boolean uidRemoved = intent.ACTION_UID_REMOVED.equals(intent.getAction());
    if (intent.ACTION_PACKAGE_REMOVED.equals(intent.getAction()) || intent.ACTION_PACKAGE_CHANGED.equals(intent.getAction()) || uidRemoved) {
        if (checkComponentPermission(android.Manifest.permission.BROADCAST_PACKAGE_REMOVED, callingPid, callingUid, -1) == PackageManager.PERMISSION_GRANTED) {
            if (uidRemoved) {
                final Bundle intentExtras = intent.getExtras();
                final int uid = intentExtras != null ? intentExtras.getInt(Intent.EXTRA_UID) : -1;
                if (uid >= 0) {
                    BatteryStatsImpl bs = mBatteryStatsService.getActiveStatistics();
                    synchronized (bs) {
                        bs.removeUidStatsLocked(uid);
                    }
                }
            } else {
                Uri data = intent.getData();
                String ssp;
                if (data != null && (ssp = data.getSchemeSpecificPart()) != null) {
                    if (!intent.getBooleanExtra(Intent.EXTRA_DONT_KILL_APP, false)) {
                        uninstallPackageLocked(ssp, intent.getIntExtra(Intent.EXTRA_UID, -1), false);
                    }
                }
            }
        } else {
            String msg = "String_Node_Str" + intent.getAction() + "String_Node_Str" + callerPackage + "String_Node_Str" + callingPid + "String_Node_Str" + callingUid + "String_Node_Str" + "String_Node_Str" + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED;
            Log.w(TAG, msg);
            throw new SecurityException(msg);
        }
    }
    if (intent.ACTION_TIMEZONE_CHANGED.equals(intent.getAction())) {
        mHandler.sendEmptyMessage(UPDATE_TIME_ZONE);
    }
    if (sticky) {
        if (checkPermission(android.Manifest.permission.BROADCAST_STICKY, callingPid, callingUid) != PackageManager.PERMISSION_GRANTED) {
            String msg = "String_Node_Str" + callingPid + "String_Node_Str" + callingUid + "String_Node_Str" + android.Manifest.permission.BROADCAST_STICKY;
            Log.w(TAG, msg);
            throw new SecurityException(msg);
        }
        if (requiredPermission != null) {
            Log.w(TAG, "String_Node_Str" + intent + "String_Node_Str" + requiredPermission);
            return BROADCAST_STICKY_CANT_HAVE_PERMISSION;
        }
        if (intent.getComponent() != null) {
            throw new SecurityException("String_Node_Str");
        }
        ArrayList<Intent> list = mStickyBroadcasts.get(intent.getAction());
        if (list == null) {
            list = new ArrayList<Intent>();
            mStickyBroadcasts.put(intent.getAction(), list);
        }
        int N = list.size();
        int i;
        for (i = 0; i < N; i++) {
            if (intent.filterEquals(list.get(i))) {
                list.set(i, new Intent(intent));
                break;
            }
        }
        if (i >= N) {
            list.add(new Intent(intent));
        }
    }
    final ContentResolver resolver = mContext.getContentResolver();
    List receivers = null;
    List<BroadcastFilter> registeredReceivers = null;
    try {
        if (intent.getComponent() != null) {
            ActivityInfo ai = ActivityThread.getPackageManager().getReceiverInfo(intent.getComponent(), 0);
            if (ai != null) {
                receivers = new ArrayList();
                ResolveInfo ri = new ResolveInfo();
                ri.activityInfo = ai;
                receivers.add(ri);
            }
        } else {
            if ((intent.getFlags() & Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
                receivers = ActivityThread.getPackageManager().queryIntentReceivers(intent, resolvedType, PackageManager.GET_SHARED_LIBRARY_FILES);
            }
            registeredReceivers = mReceiverResolver.queryIntent(resolver, intent, resolvedType, false);
        }
    } catch (RemoteException ex) {
    }
    int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
    if (!ordered && NR > 0) {
        BroadcastRecord r = new BroadcastRecord(intent, callerApp, callerPackage, callingPid, callingUid, requiredPermission, registeredReceivers, resultTo, resultCode, resultData, map, ordered);
        if (DEBUG_BROADCAST)
            Log.v(TAG, "String_Node_Str" + r + "String_Node_Str" + mParallelBroadcasts.size());
        mParallelBroadcasts.add(r);
        scheduleBroadcastsLocked();
        registeredReceivers = null;
        NR = 0;
    }
    int ir = 0;
    if (receivers != null) {
        boolean skip = false;
        if (intent.ACTION_PACKAGE_ADDED.equals(intent.getAction())) {
            skip = true;
        } else if (intent.ACTION_PACKAGE_RESTARTED.equals(intent.getAction())) {
            skip = true;
        } else if (intent.ACTION_PACKAGE_DATA_CLEARED.equals(intent.getAction())) {
            skip = true;
        }
        String skipPackage = (skip && intent.getData() != null) ? intent.getData().getSchemeSpecificPart() : null;
        if (skipPackage != null && receivers != null) {
            int NT = receivers.size();
            for (int it = 0; it < NT; it++) {
                ResolveInfo curt = (ResolveInfo) receivers.get(it);
                if (curt.activityInfo.packageName.equals(skipPackage)) {
                    receivers.remove(it);
                    it--;
                    NT--;
                }
            }
        }
        int NT = receivers != null ? receivers.size() : 0;
        int it = 0;
        ResolveInfo curt = null;
        BroadcastFilter curr = null;
        while (it < NT && ir < NR) {
            if (curt == null) {
                curt = (ResolveInfo) receivers.get(it);
            }
            if (curr == null) {
                curr = registeredReceivers.get(ir);
            }
            if (curr.getPriority() >= curt.priority) {
                receivers.add(it, curr);
                ir++;
                curr = null;
                it++;
                NT++;
            } else {
                it++;
                curt = null;
            }
        }
    }
    while (ir < NR) {
        if (receivers == null) {
            receivers = new ArrayList();
        }
        receivers.add(registeredReceivers.get(ir));
        ir++;
    }
    if ((receivers != null && receivers.size() > 0) || resultTo != null) {
        BroadcastRecord r = new BroadcastRecord(intent, callerApp, callerPackage, callingPid, callingUid, requiredPermission, receivers, resultTo, resultCode, resultData, map, ordered);
        if (DEBUG_BROADCAST)
            Log.v(TAG, "String_Node_Str" + r + "String_Node_Str" + mOrderedBroadcasts.size());
        if (DEBUG_BROADCAST) {
            int seq = r.intent.getIntExtra("String_Node_Str", -1);
            Log.i(TAG, "String_Node_Str" + r.intent.getAction() + "String_Node_Str" + seq);
        }
        mOrderedBroadcasts.add(r);
        scheduleBroadcastsLocked();
    }
    return BROADCAST_SUCCESS;
}

Output:
         if (intent.getComponent() != null) {
-            ActivityInfo ai = ActivityThread.getPackageManager().getReceiverInfo(intent.getComponent(), 0);
+            ActivityInfo ai = ActivityThread.getPackageManager().getReceiverInfo(intent.getComponent(), STOCK_PM_FLAGS);
             if (ai != null) {


Input:
private void startArcAction(boolean enabled) {
    assertRunOnServiceThread();
    HdmiDeviceInfo info = getAvrDeviceInfo();
    if (info == null) {
        return;
    }
    if (!isConnectedToArcPort(info.getPhysicalAddress())) {
        return;
    }
    if (enabled) {
        removeAction(RequestArcTerminationAction.class);
        if (!hasAction(RequestArcInitiationAction.class)) {
            addAndStartAction(new RequestArcInitiationAction(this, info.getLogicalAddress()));
        }
    } else {
        removeAction(RequestArcInitiationAction.class);
        if (!hasAction(RequestArcTerminationAction.class)) {
            addAndStartAction(new RequestArcTerminationAction(this, info.getLogicalAddress()));
        }
    }
}

Output:
     }
-    if (!isConnectedToArcPort(info.getPhysicalAddress())) {
+    if (!canStartArcUpdateAction(info.getLogicalAddress(), enabled)) {
+        Slog.w(TAG, "String_Node_Str");
+        if (enabled && !isConnectedToArcPort(info.getPhysicalAddress())) {
+            displayOsd(OSD_MESSAGE_ARC_CONNECTED_INVALID_PORT);
+        }
         return;


Input:
private File createTmpDirectory() throws IOException {
    File tmpDirectory = null;
    int suffix = 0;
    while (tmpDirectory == null || tmpDirectory.exists()) {
        tmpDirectory = new File(SystemUtils.getJavaIoTmpDir(), "String_Node_Str" + suffix);
        suffix++;
    }
    if (!tmpDirectory.mkdir()) {
        throw new IOException(Messages.getString("String_Node_Str", tmpDirectory));
    }
    return tmpDirectory;
}

Output:
     while (tmpDirectory == null || tmpDirectory.exists()) {
-        tmpDirectory = new File(SystemUtils.getJavaIoTmpDir(), "String_Node_Str" + suffix);
+        tmpDirectory = new File(tmpFolder + File.separatorChar + "String_Node_Str" + suffix);
         suffix++;


Input:
protected final Player[] getTargets() {
    CPlayer[] cPlayers = (this.viewers.size() == 0 ? Core.getPlayerManager().getOnlinePlayers() : this.viewers).toArray(new CPlayer[this.viewers.size()]);
    Player[] players = new Player[cPlayers.length];
    for (int x = 0; x < cPlayers.length; x++) {
        Player bukkitPlayer = cPlayers[x].getBukkitPlayer();
        if (this.world != null && !bukkitPlayer.getWorld().equals(world))
            continue;
        players[x] = bukkitPlayer;
    }
    return players;
}

Output:
     Player[] players = new Player[cPlayers.length];
-    for (int x = 0; x < cPlayers.length; x++) {
+    int x = 0;
+    for (int i = 0; i < cPlayers.length; i++) {
         Player bukkitPlayer = cPlayers[x].getBukkitPlayer();


Input:
public void update() {
    updateGraphicsElementsPosition();
    Vector2f mousePos = new Vector2f(Mouse.getX(), Display.getHeight() - Mouse.getY());
    if (intersects(mousePos)) {
        if (_mouseDown) {
            _scrolled = true;
            if (_prevMousePos == -1) {
                if (_scrollType == ScrollType.vertical) {
                    _prevMousePos = mousePos.y;
                } else {
                    _prevMousePos = mousePos.x;
                }
            }
        }
    }
    if (_scrolled) {
        scrolled(_scrollType == ScrollType.vertical ? mousePos.y : mousePos.x);
    }
    if (!_mouseDown || !_scrolled || _mouseUp) {
        _scrolled = false;
        _mouseDown = false;
        _prevMousePos = -1;
        _mouseUp = false;
    }
}

Output:
 public void update() {
-    updateGraphicsElementsPosition();
+    updateThumb();
     Vector2f mousePos = new Vector2f(Mouse.getX(), Display.getHeight() - Mouse.getY());


Input:
public void onActionDown(MotionEvent event) {
    super.onActionDown(event);
    final int xGrid;
    final int x = (int) event.getX();
    final int y = (int) event.getY();
    if (mTweetFlow.elementAt(mEditorView.scaledX(x), mEditorView.scaledY(y))) {
        mTweetFlow.setTouchElementModeMarked();
        mEditorView.setState(EDITOR_STATE.TOUCH_ELEMENT);
        mEditorView.redraw();
    } else if (rasterGridHelper.getRasterOn() && rasterGridHelper.getSnapMode() == SnapMode.GRID && rasterGridHelper.isTouchOnGrid(x)) {
        mEditorView.setState(EDITOR_STATE.MOVE_GRID);
        mEditorView.redraw();
    } else {
        mEditorView.setState(EDITOR_STATE.TOUCH_VOID);
    }
    mEditorView.setLastTouch(x, y);
}

Output:
         mEditorView.redraw();
-    } else if (rasterGridHelper.getRasterOn() && rasterGridHelper.getSnapMode() == SnapMode.GRID && rasterGridHelper.isTouchOnGrid(x)) {
+    } else if (rasterGridHelper.getRasterOn() && rasterGridHelper.getSnapMode() == SnapMode.GRID && rasterGridHelper.isTouchOnGrid(mEditorView.scaledX(x))) {
         mEditorView.setState(EDITOR_STATE.MOVE_GRID);


Input:
void accept(Environment env) throws TemplateException, IOException {
    for (int i = 0; i < nestedElements.size(); i++) {
        ConditionalBlock cblock = (ConditionalBlock) nestedElements.get(i);
        Expression condition = cblock.condition;
        env.replaceElementStackTop(cblock);
        if (condition == null || condition.evalToBoolean(env)) {
            if (cblock.nestedBlock != null) {
                env.visitByHiddingParent(cblock.nestedBlock);
            }
            return;
        }
    }
}

Output:
 void accept(Environment env) throws TemplateException, IOException {
-    for (int i = 0; i < nestedElements.size(); i++) {
-        ConditionalBlock cblock = (ConditionalBlock) nestedElements.get(i);
+    int ln = getRegulatedChildCount();
+    for (int i = 0; i < ln; i++) {
+        ConditionalBlock cblock = (ConditionalBlock) getRegulatedChild(i);
         Expression condition = cblock.condition;


Input:
public Cipher decryptstream() throws Exception {
    try {
        Cipher c = Cipher.getInstance(mode);
        c.init(Cipher.DECRYPT_MODE, aesKey);
        return c;
    } catch (Exception ex) {
        throw ex;
    }
}

Output:
 public Cipher decryptstream() throws Exception {
-    try {
-        Cipher c = Cipher.getInstance(mode);
-        c.init(Cipher.DECRYPT_MODE, aesKey);
-        return c;
-    } catch (Exception ex) {
-        throw ex;
-    }
+    Cipher c = Cipher.getInstance(mode);
+    c.init(Cipher.DECRYPT_MODE, aesKey);
+    return c;
 }


Input:
private void updateModel() {
    popSize = ((GEModel) Controller.getModel()).getPopulationSize();
}

Output:
 private void updateModel() {
-    popSize = ((GEModel) Controller.getModel()).getPopulationSize();
+    model = (GEModel) Controller.getModel();
+    popSize = model.getPopulationSize();
 }


Input:
private int[] getModifierMask(ClickModifier clickModifier) {
    int[] modifier = new int[0];
    if (clickModifier.hasModifiers(ClickModifier.M1)) {
        modifier = ArrayUtils.add(modifier, KeyCode.CONTROL.impl_getCode());
    }
    if (clickModifier.hasModifiers(ClickModifier.M2)) {
        modifier = ArrayUtils.add(modifier, KeyCode.SHIFT.impl_getCode());
    }
    if (clickModifier.hasModifiers(ClickModifier.M3)) {
        modifier = ArrayUtils.add(modifier, KeyCode.ALT.impl_getCode());
    }
    if (clickModifier.hasModifiers(ClickModifier.M4)) {
        modifier = ArrayUtils.add(modifier, KeyCode.META.impl_getCode());
    }
    return modifier;
}

Output:
     if (clickModifier.hasModifiers(ClickModifier.M1)) {
-        modifier = ArrayUtils.add(modifier, KeyCode.CONTROL.impl_getCode());
+        modifier = ArrayUtils.add(modifier, KeyCodeUtil.getKeyCode(KeyCode.CONTROL));
     }


Input:
protected void updateAllFieldsOfSite1Movie(boolean forceUpdatePoster) {
    if (movieToWriteToDiskList == null || movieToWriteToDiskList.size() == 0) {
        clearAllFieldsOfSite1Movie();
    } else if (movieToWriteToDiskList != null && movieToWriteToDiskList.get(0) != null) {
        clearAllFieldsOfSite1Movie();
        if (movieToWriteToDiskList != null)
            comboBoxMovieTitleText.addItem(movieToWriteToDiskList.get(0).getTitle().getTitle());
        if (currentlySelectedMovieDMM != null)
            comboBoxMovieTitleText.addItem(currentlySelectedMovieDMM.getTitle().getTitle());
        if (currentlySelectedMovieJavLibrary != null)
            comboBoxMovieTitleText.addItem(currentlySelectedMovieJavLibrary.getTitle().getTitle());
        if (currentlySelectedMovieSquarePlus != null)
            comboBoxMovieTitleText.addItem(currentlySelectedMovieSquarePlus.getTitle().getTitle());
        if (currentlySelectedMovieActionJav != null)
            comboBoxMovieTitleText.addItem(currentlySelectedMovieActionJav.getTitle().getTitle());
        if (currentlySelectedMovieJavZoo != null)
            comboBoxMovieTitleText.addItem(currentlySelectedMovieJavZoo.getTitle().getTitle());
        if (comboBoxMovieTitleText.getItemCount() > 0)
            comboBoxMovieTitleText.setEditable(true);
        lblOriginalTitleTextSite1.setText(movieToWriteToDiskList.get(0).getOriginalTitle().getOriginalTitle());
        if (movieToWriteToDiskList.get(0).getId() != null)
            lblIDCurrentMovie.setText(movieToWriteToDiskList.get(0).getId().getId());
        if (movieToWriteToDiskList.get(0).getStudio() != null)
            txtFieldStudio.setText(movieToWriteToDiskList.get(0).getStudio().getStudio());
        if (movieToWriteToDiskList.get(0).getYear() != null)
            lblScrapedYearText.setText(movieToWriteToDiskList.get(0).getYear().getYear());
        if (movieToWriteToDiskList.get(0).getPlot() != null)
            moviePlotTextField.setText(movieToWriteToDiskList.get(0).getPlot().getPlot());
        if (movieToWriteToDiskList.get(0).getSet() != null)
            txtFieldMovieSet.setText(movieToWriteToDiskList.get(0).getSet().getSet());
        listModelGenresSite1.removeAllElements();
        for (Genre genre : movieToWriteToDiskList.get(0).getGenres()) {
            listModelGenresSite1.addElement(genre.getGenre());
        }
        listModelActorsSite1.removeAllElements();
        for (Actor actor : movieToWriteToDiskList.get(0).getActors()) {
            listModelActorsSite1.addElement(actor.getName());
        }
        boolean posterFileUpdateOccured = false;
        boolean fanartFileUpdateOccured = false;
        if (!forceUpdatePoster) {
            File potentialOtherPosterJpg = new File(Movie.getFileNameOfPoster(currentlySelectedMovieFileList.get(0), true));
            File potentialOtherFanartJpg = new File(Movie.getFileNameOfFanart(currentlySelectedMovieFileList.get(0), true));
            File standardPosterJpg = new File(Movie.getFileNameOfPoster(currentlySelectedMovieFileList.get(0), false));
            File standardFanartJpg = new File(Movie.getFileNameOfFanart(currentlySelectedMovieFileList.get(0), false));
            if (currentlySelectedPosterFileList.get(0).exists()) {
                try {
                    ImageIcon newPosterIcon;
                    BufferedImage img = ImageIO.read(currentlySelectedPosterFileList.get(0));
                    BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, posterSizeX, posterSizeY, Scalr.OP_ANTIALIAS);
                    newPosterIcon = new ImageIcon(scaledImage);
                    lblPosterIcon.setIcon(newPosterIcon);
                    posterFileUpdateOccured = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (currentlySelectedFanartFileList.get(0).exists()) {
                try {
                    ImageIcon newFanartIcon;
                    BufferedImage img = ImageIO.read(currentlySelectedFanartFileList.get(0));
                    BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, fanartSizeX, fanartSizeY, Scalr.OP_ANTIALIAS);
                    newFanartIcon = new ImageIcon(scaledImage);
                    lblFanartIcon.setIcon(newFanartIcon);
                    fanartFileUpdateOccured = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (currentlySelectedMovieFileList.get(0).isDirectory() && potentialOtherPosterJpg.exists() && !posterFileUpdateOccured) {
                try {
                    ImageIcon newPosterIcon;
                    BufferedImage img = ImageIO.read(potentialOtherPosterJpg);
                    BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, posterSizeX, posterSizeY, Scalr.OP_ANTIALIAS);
                    newPosterIcon = new ImageIcon(scaledImage);
                    lblPosterIcon.setIcon(newPosterIcon);
                    posterFileUpdateOccured = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (currentlySelectedMovieFileList.get(0).isDirectory() && potentialOtherFanartJpg.exists() && !fanartFileUpdateOccured) {
                try {
                    ImageIcon newFanartIcon;
                    BufferedImage img = ImageIO.read(potentialOtherFanartJpg);
                    BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, posterSizeX, posterSizeY, Scalr.OP_ANTIALIAS);
                    newFanartIcon = new ImageIcon(scaledImage);
                    lblFanartIcon.setIcon(newFanartIcon);
                    fanartFileUpdateOccured = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (standardPosterJpg.exists() && !posterFileUpdateOccured) {
                try {
                    lblPosterIcon.setIcon(new ImageIcon(standardPosterJpg.getCanonicalPath()));
                    posterFileUpdateOccured = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (standardFanartJpg.exists() && !fanartFileUpdateOccured) {
                try {
                    lblFanartIcon.setIcon(new ImageIcon(standardFanartJpg.getCanonicalPath()));
                    fanartFileUpdateOccured = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if (movieToWriteToDiskList.get(0).hasPoster() && !posterFileUpdateOccured) {
            try {
                posterImage = movieToWriteToDiskList.get(0).getPosters()[0].getThumbImage();
                ImageIcon newPosterIcon = new ImageIcon(posterImage);
                BufferedImage img = (BufferedImage) newPosterIcon.getImage();
                BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, posterSizeX, posterSizeY, Scalr.OP_ANTIALIAS);
                posterImage = scaledImage;
                posterFileUpdateOccured = true;
            } catch (IOException e) {
                e.printStackTrace();
                JOptionPane.showMessageDialog(null, ExceptionUtils.getStackTrace(e), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
            }
            lblPosterIcon.setIcon(new ImageIcon(posterImage));
        }
        if (movieToWriteToDiskList.get(0).hasFanart() && !fanartFileUpdateOccured) {
            System.out.println("String_Node_Str");
            try {
                fanartImage = movieToWriteToDiskList.get(0).getFanart()[0].getThumbImage();
                ImageIcon newFanartIcon = new ImageIcon(fanartImage);
                BufferedImage img = (BufferedImage) newFanartIcon.getImage();
                BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, fanartSizeX, fanartSizeY, Scalr.OP_ANTIALIAS);
                fanartImage = scaledImage;
            } catch (IOException e) {
                e.printStackTrace();
                JOptionPane.showMessageDialog(null, ExceptionUtils.getStackTrace(e), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
            }
            lblFanartIcon.setIcon(new ImageIcon(fanartImage));
        }
    }
}

Output:
                     BufferedImage img = ImageIO.read(potentialOtherFanartJpg);
-                    BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, posterSizeX, posterSizeY, Scalr.OP_ANTIALIAS);
+                    BufferedImage scaledImage = Scalr.resize(img, Method.QUALITY, fanartSizeX, fanartSizeY, Scalr.OP_ANTIALIAS);
                     newFanartIcon = new ImageIcon(scaledImage);


Input:
private void clearChildren(String worldName) {
    for (PermissionGroup group : this.getChildGroups(worldName)) {
        List<PermissionGroup> parentGroups = new LinkedList<PermissionGroup>(group.getOwnParents(worldName));
        parentGroups.remove(this);
        group.setParents(parentGroups, worldName);
    }
    for (PermissionUser user : this.getUsers(worldName)) {
        user.removeGroup(this, worldName);
    }
}

Output:
     for (PermissionGroup group : this.getChildGroups(worldName)) {
-        List<PermissionGroup> parentGroups = new LinkedList<PermissionGroup>(group.getOwnParents(worldName));
+        List<PermissionGroup> parentGroups = new LinkedList<>(group.getOwnParents(worldName));
         parentGroups.remove(this);


Input:
public boolean runCommand() {
    if (args.length < 1) {
        return false;
    }
    String name = this.getPlayerName(args[0]);
    if (this.isPlayerOnline(name)) {
        String reason = MCBouncerUtil.getReasonOrDefault(args, MCBouncerUtil.implodeWithoutFirstElement(args, "String_Node_Str"), MCBConfiguration.getDefaultKickMessage());
        this.sendMessageToMods(ChatColor.RED + name + "String_Node_Str" + reason);
        MCBouncer.log.info(this.getSenderName() + "String_Node_Str" + name + "String_Node_Str" + reason);
        this.kickPlayer(name, "String_Node_Str" + reason);
        return true;
    } else {
        this.sendMessageToSender(ChatColor.RED + "String_Node_Str");
    }
    return true;
}

Output:
     String name = this.getPlayerName(args[0]);
-    if (this.isPlayerOnline(name)) {
+    if (name != null && this.isPlayerOnline(name)) {
         String reason = MCBouncerUtil.getReasonOrDefault(args, MCBouncerUtil.implodeWithoutFirstElement(args, "String_Node_Str"), MCBConfiguration.getDefaultKickMessage());


Input:
public void setup() {
    size(800, 600, GLConstants.GLGRAPHICS);
    map = new Map(this, "String_Node_Str", 0, 0, 800, 600);
    map.setTweening(false);
    debugDisplay = new DebugDisplay(this, map.mapDisplay, 0, 0, 250, 200);
    addMouseWheelListener(new java.awt.event.MouseWheelListener() {
        public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
            mouseWheel(evt.getWheelRotation());
        }
    });
}

Output:
     size(800, 600, GLConstants.GLGRAPHICS);
-    map = new Map(this, "String_Node_Str", 0, 0, 800, 600);
+    map = new Map(this, "String_Node_Str", 50, 50, 700, 500);
     map.setTweening(false);


Input:
private void processAllComponentsBindings(Component comp) {
    final Binder selfBinder = (Binder) comp.getAttribute(BinderImpl.BINDER);
    if (selfBinder != null)
        return;
    processComponentBindings0(comp);
    for (final Iterator<Component> it = comp.getChildren().iterator(); it.hasNext(); ) {
        final Component kid = it.next();
        processAllComponentsBindings(kid);
    }
}

Output:
 private void processAllComponentsBindings(Component comp) {
-    final Binder selfBinder = (Binder) comp.getAttribute(BinderImpl.BINDER);
+    final Binder selfBinder = BinderUtil.getBinder(comp);
     if (selfBinder != null)


Input:
public List getReferableBindings(String targetLevel, ICubeQueryDefinition cubeDefn, boolean isSort) throws AdapterException {
    try {
        List bindings = cubeDefn.getBindings();
        if (bindings == null)
            return new ArrayList();
        DimLevel target = OlapExpressionUtil.getTargetDimLevel(targetLevel);
        List result = new ArrayList();
        for (int i = 0; i < bindings.size(); i++) {
            IBinding binding = (IBinding) bindings.get(i);
            Set refDimLevel = OlapExpressionCompiler.getReferencedDimLevel(binding.getExpression(), bindings, isSort);
            if (refDimLevel.size() > 1)
                continue;
            if (!refDimLevel.contains(target)) {
                List aggrOns = binding.getAggregatOns();
                if (aggrOns.size() == 0) {
                    if (isGrandTotal(binding) && isSort)
                        continue;
                    if (this.getReferencedMeasureName(binding.getExpression()) != null) {
                        if (this.isLeafLevel(cubeDefn, target) && binding.getAggrFunction() == null) {
                            result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.MEASURE_TYPE));
                            continue;
                        } else if (isGrandTotal(binding)) {
                            result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.GRAND_TOTAL_TYPE));
                            continue;
                        }
                    }
                }
                for (int j = 0; j < aggrOns.size(); j++) {
                    DimLevel dimLevel = OlapExpressionUtil.getTargetDimLevel(aggrOns.get(j).toString());
                    if (dimLevel.equals(target)) {
                        if (j == aggrOns.size() - 1) {
                            if (fromSameEdge(aggrOns, cubeDefn))
                                result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.GRAND_TOTAL_TYPE));
                            else
                                result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.SUB_TOTAL_TYPE));
                        } else {
                            DimLevel next = OlapExpressionUtil.getTargetDimLevel(aggrOns.get(j + 1).toString());
                            int candidateEdge = getAxisQualifierEdgeType(dimLevel, cubeDefn);
                            if (candidateEdge != -1) {
                                if (getAxisQualifierLevel(next, cubeDefn.getEdge(candidateEdge)) != null)
                                    result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.SUB_TOTAL_TYPE));
                            }
                        }
                        break;
                    }
                }
                continue;
            }
            result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.DIMENSION_TYPE));
        }
        return result;
    } catch (DataException e) {
        throw new AdapterException(e.getLocalizedMessage(), e);
    }
}

Output:
                 List aggrOns = binding.getAggregatOns();
-                if (aggrOns.size() == 0) {
-                    if (isGrandTotal(binding) && isSort)
+                if (isGrandTotal(binding) && isSort)
+                    continue;
+                if (this.getReferencedMeasureName(binding.getExpression()) != null) {
+                    if (this.isLeafLevel(cubeDefn, target) && this.isMeasureBinding(cubeDefn, binding)) {
+                        result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.MEASURE_TYPE));
+                        continue;
+                    } else if (isGrandTotal(binding)) {
+                        result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.GRAND_TOTAL_TYPE));
                         continue;


Input:
public UserPrefWritable[] getUserPrefs() {
    Writable[] writables = get();
    UserPrefWritable[] userPrefs = new UserPrefWritable[writables.length];
    for (int n = 0; n < writables.length; n++) {
        userPrefs[n] = (UserPrefWritable) writables[n];
    }
    return userPrefs;
}

Output:
 public UserPrefWritable[] getUserPrefs() {
-    Writable[] writables = get();
-    UserPrefWritable[] userPrefs = new UserPrefWritable[writables.length];
-    for (int n = 0; n < writables.length; n++) {
-        userPrefs[n] = (UserPrefWritable) writables[n];
-    }
-    return userPrefs;
+    return (UserPrefWritable[]) toArray();
 }


Input:
public void execute(CommandSender sender, String[] args) {
    MessagesConfig messages = Messages.getInstance();
    PluginConfig config = Settings.getConfig();
    if (args.length < 1) {
        sender.sendMessage(messages.generalNoTagGiven);
        return;
    } else if (args.length < 2) {
        sender.sendMessage(messages.adminNoValidityTimeGiven);
        return;
    }
    Guild guild = GuildUtils.byTag(args[0]);
    if (guild == null) {
        sender.sendMessage(messages.generalNoGuildFound);
        return;
    }
    if (guild.isBanned()) {
        sender.sendMessage(messages.adminGuildBanned);
        return;
    }
    long time = Parser.parseTime(args[1]);
    if (time < 1) {
        sender.sendMessage(messages.adminTimeError);
        return;
    }
    User admin = (sender instanceof Player) ? User.get(sender.getName()) : null;
    if (!SimpleEventHandler.handle(new GuildExtendValidityEvent(admin == null ? EventCause.CONSOLE : EventCause.ADMIN, admin, guild, time))) {
        return;
    }
    long validity = guild.getValidity();
    if (validity == 0) {
        validity = System.currentTimeMillis();
    }
    validity += time;
    guild.setValidity(validity);
    String date = config.dateFormat.format(new Date(validity));
    sender.sendMessage(messages.adminNewValidity.replace("String_Node_Str", guild.getName()).replace("String_Node_Str", date));
}

Output:
     }
-    Guild guild = GuildUtils.byTag(args[0]);
+    Guild guild = GuildUtils.getByTag(args[0]);
     if (guild == null) {


Input:
public void goAlgo() {
    for (int step = 0; step < stepSize; step++) {
        for (Edge edge : graphModel.getGraph().getEdges()) {
            ((FDEBLayoutData) edge.getEdgeData().getLayoutData()).newSubdivisionPoints = Arrays.copyOf(((FDEBLayoutData) edge.getEdgeData().getLayoutData()).subdivisionPoints, ((FDEBLayoutData) edge.getEdgeData().getLayoutData()).subdivisionPoints.length);
        }
        for (Edge edge : graphModel.getGraph().getEdges()) {
            if (edge.isSelfLoop()) {
                continue;
            }
            FDEBLayoutData data = edge.getEdgeData().getLayoutData();
            double k = sprintConstant / (data.length * (data.subdivisionPoints.length - 1));
            for (int i = 1; i < data.subdivisionPoints.length - 1; i++) {
                double Fsi_x = (data.subdivisionPoints[i - 1].x - data.subdivisionPoints[i].x) + (data.subdivisionPoints[i + 1].x - data.subdivisionPoints[i].x);
                double Fsi_y = (data.subdivisionPoints[i - 1].y - data.subdivisionPoints[i].y) + (data.subdivisionPoints[i + 1].y - data.subdivisionPoints[i].y);
                if (Math.abs(k) <= 1) {
                    Fsi_x *= k;
                    Fsi_y *= k;
                }
                double Fei_x = 0;
                double Fei_y = 0;
                for (Edge moveEdge : graphModel.getGraph().getEdges()) {
                    if (moveEdge.isSelfLoop()) {
                        continue;
                    }
                    FDEBLayoutData moveData = moveEdge.getEdgeData().getLayoutData();
                    double v_x = moveData.subdivisionPoints[i].x - data.subdivisionPoints[i].x;
                    double v_y = moveData.subdivisionPoints[i].y - data.subdivisionPoints[i].y;
                    if (Math.abs(v_x) > EPS || Math.abs(v_y) > EPS) {
                        double len_sq = v_x * v_x + v_y * v_y;
                        double m = (1.0 / Math.sqrt(len_sq));
                        v_x *= m;
                        v_y *= m;
                        Fei_x += v_x;
                        Fei_y += v_y;
                    }
                }
                System.err.println("String_Node_Str" + (Fei_x + Fsi_x) + "String_Node_Str" + (Fei_y + Fsi_y) + "String_Node_Str" + stepSize);
                data.newSubdivisionPoints[i] = new Point.Double(data.subdivisionPoints[i].x + stepSize * (Fei_x + Fsi_x), data.subdivisionPoints[i].y + stepSize * (Fei_y + Fsi_y));
            }
        }
        for (Edge edge : graphModel.getGraph().getEdges()) {
            ((FDEBLayoutData) edge.getEdgeData().getLayoutData()).subdivisionPoints = ((FDEBLayoutData) edge.getEdgeData().getLayoutData()).newSubdivisionPoints;
            ((FDEBLayoutData) edge.getEdgeData().getLayoutData()).newSubdivisionPoints = null;
        }
    }
    if (cycle == parameters.getNumCycles()) {
        setConverged(true);
    } else {
        prepareForTheNextStep();
    }
}

Output:
 public void goAlgo() {
-    for (int step = 0; step < stepSize; step++) {
+    long totalEdges = 0;
+    long passedEdges = 0;
+    for (int step = 0; step < iterationsPerCycle; step++) {
         for (Edge edge : graphModel.getGraph().getEdges()) {


Input:
private String defaultDummyMember() {
    if (iLdapType.startsWith(LdapConstants.IDS_LDAP_SERVER) || iLdapType.startsWith(LdapConstants.DOMINO_LDAP_SERVER)) {
        return LdapConstants.LDAP_DUMMY_MEMBER_DEFAULT;
    } else
        return null;
}

Output:
 private String defaultDummyMember() {
-    if (iLdapType.startsWith(LdapConstants.IDS_LDAP_SERVER) || iLdapType.startsWith(LdapConstants.DOMINO_LDAP_SERVER)) {
+    if (LdapConstants.IDS_LDAP_SERVER.equalsIgnoreCase(iLdapType) || LdapConstants.DOMINO_LDAP_SERVER.equalsIgnoreCase(iLdapType)) {
         return LdapConstants.LDAP_DUMMY_MEMBER_DEFAULT;


Input:
public boolean get(URIish arg0, CredentialItem... arg1) throws UnsupportedCredentialItem {
    InputDialog dlg = new InputDialog(Display.getCurrent().getActiveShell(), "String_Node_Str", "String_Node_Str", "String_Node_Str", null) {
        protected int getInputTextStyle() {
            return SWT.SINGLE | SWT.BORDER;
        }
    };
    dlg.open();
    CredentialItem.StringType pwdCred = (CredentialItem.StringType) arg1[0];
    pwdCred.setValue(dlg.getValue());
    return true;
}

Output:
         }
-    };
-    dlg.open();
-    CredentialItem.StringType pwdCred = (CredentialItem.StringType) arg1[0];
-    pwdCred.setValue(dlg.getValue());
+    });
     return true;


Input:
public static boolean equalByUri(Vertex v1, Vertex v2) {
    return uriOfVertex(v1).equals(uriOfVertex(v2));
}

Output:
 public static boolean equalByUri(Vertex v1, Vertex v2) {
-    return uriOfVertex(v1).equals(uriOfVertex(v2));
+    return shortUriOfVertex(v1).equals(shortUriOfVertex(v2));
 }


Input:
static int findSummaryIndex(StringBuffer fileBuffer, int index) {
    String fbs = fileBuffer.toString();
    String MARKER_1 = "String_Node_Str";
    String MARKER_2 = "String_Node_Str";
    int index1 = fbs.indexOf(MARKER_1, index);
    int index2 = fbs.indexOf(MARKER_2, index);
    if (index1 < index2) {
        return index1;
    } else {
        return index2;
    }
}

Output:
     int index2 = fbs.indexOf(MARKER_2, index);
-    if (index1 < index2) {
+    if (index1 < index2 && index1 != -1) {
         return index1;


Input:
public int getSPIlen() {
    return 0;
}

Output:
 public int getSPIlen() {
-    return 0;
+    return spiLen;
 }


Input:
public static void doHivePreSetup(Connection connection) {
    Connection conn = connection;
    if (conn instanceof DatabaseConnection) {
        IProject project = ProjectManager.getInstance().getResourceProject(ProjectManager.getInstance().getCurrentProject().getEmfProject());
        String fullPathTemp = project.getFolder("String_Node_Str").getLocation().append("String_Node_Str").append(connection.getId()).toPortableString();
        System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_JDO_CONNECTION_URL.getKey(), "String_Node_Str" + fullPathTemp + "String_Node_Str");
        DatabaseConnection dbConn = (DatabaseConnection) conn;
        System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_HIVE_METASTORE_LOCAL.getKey(), "String_Node_Str");
        if (conn.isContextMode()) {
            IRepositoryService repositoryService = CoreRuntimePlugin.getInstance().getRepositoryService();
            if (repositoryService != null) {
                String contextName = conn.getContextName();
                conn = repositoryService.cloneOriginalValueConnection(dbConn, contextName == null ? true : false, contextName);
            }
        }
        String thriftURL = "String_Node_Str" + dbConn.getServerName() + "String_Node_Str" + dbConn.getPort();
        System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_HIVE_METASTORE_URI.getKey(), thriftURL);
        System.setProperty("String_Node_Str", "String_Node_Str");
        System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_HIVE_METASTORE_EXECUTE_SETUGI.getKey(), "String_Node_Str");
        System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_FS_DEFAULT_NAME.getKey(), dbConn.getParameters().get(ConnParameterKeys.CONN_PARA_KEY_NAME_NODE_URL));
        System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_MAPRED_JOB_TRACKER.getKey(), dbConn.getParameters().get(ConnParameterKeys.CONN_PARA_KEY_JOB_TRACKER_URL));
    }
}

Output:
         IProject project = ProjectManager.getInstance().getResourceProject(ProjectManager.getInstance().getCurrentProject().getEmfProject());
-        String fullPathTemp = project.getFolder("String_Node_Str").getLocation().append("String_Node_Str").append(connection.getId()).toPortableString();
+        String id = connection.getId();
+        if (id == null) {
+            IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
+            id = factory.getNextId();
+        }
+        String fullPathTemp = project.getFolder("String_Node_Str").getLocation().append("String_Node_Str").append(id).toPortableString();
         System.setProperty(HiveConfKeysForTalend.HIVE_CONF_KEY_JDO_CONNECTION_URL.getKey(), "String_Node_Str" + fullPathTemp + "String_Node_Str");


Input:
private void init(Graph<T> G, Iterator<? extends T> nodes) {
    this.G = G;
    if (G.getNumberOfNodes() == 0) {
        return;
    }
    while (nodes.hasNext()) {
        T o = nodes.next();
        if (!visited.contains(o)) {
            Q.add(o);
            visited.add(o);
        }
    }
    index = 0;
    T current = Q.get(0);
    visitChildren(current);
}

Output:
     index = 0;
-    T current = Q.get(0);
-    visitChildren(current);
+    if (Q.size() > 0) {
+        T current = Q.get(0);
+        visitChildren(current);
+    }
 }


Input:
public void configureFromXML(Tag tag) throws ConfigurationException {
    TrainType defaultType = null;
    TrainType newType;
    Tag defaultsTag = tag.getChild("String_Node_Str");
    if (defaultsTag != null) {
        defaultType = new TrainType(false);
        defaultType.configureFromXML(defaultsTag);
    }
    List<Tag> typeTags = tag.getChildren("String_Node_Str");
    for (Tag typeTag : typeTags) {
        if (defaultType != null) {
            newType = (TrainType) defaultType.clone();
            if (newType == null) {
                throw new ConfigurationException("String_Node_Str" + defaultType.getName());
            }
        } else {
            newType = new TrainType(true);
        }
        lTrainTypes.add(newType);
        newType.configureFromXML(typeTag);
        mTrainTypes.put(newType.getName(), newType);
    }
    Tag rulesTag = tag.getChild("String_Node_Str");
    if (rulesTag != null) {
        gameManager.setGameParameter(GameDef.Parm.FIXED_PRICE_TRAINS_BETWEEN_PRESIDENTS, rulesTag.getChild("String_Node_Str") != null);
    }
    for (TrainTypeI type : lTrainTypes) {
        if (type.getReleasedTrainTypeNames() != null) {
            List<TrainTypeI> rtts = new ArrayList<TrainTypeI>(2);
            for (String ttName : type.getReleasedTrainTypeNames().split("String_Node_Str")) {
                rtts.add(mTrainTypes.get(ttName));
            }
            type.setReleasedTrainTypes(rtts);
        }
        if (type.getRustedTrainTypeName() != null) {
            type.setRustedTrainType(mTrainTypes.get(type.getRustedTrainTypeName()));
            mTrainTypes.get(type.getRustedTrainTypeName()).setPermanent(false);
        }
    }
    Tag removeTrainTag = tag.getChild("String_Node_Str");
    if (removeTrainTag != null) {
        removeTrain = true;
    }
}

Output:
     if (rulesTag != null) {
-        gameManager.setGameParameter(GameDef.Parm.FIXED_PRICE_TRAINS_BETWEEN_PRESIDENTS, rulesTag.getChild("String_Node_Str") != null);
+        trainPriceAtFaceValueIfDifferentPresidents = rulesTag.getChild("String_Node_Str") != null;
     }


Input:
public void testResolveItem4ValidItem() throws Exception {
    ImportBasicHandler basicHandler = new ImportBasicHandler();
    ItemRecord itemRecord = new ItemRecord(processPropPath1);
    itemRecord.setItemName(processPropPath1.lastSegment());
    Property property = mock(Property.class);
    itemRecord.setProperty(property);
    ProcessItem processItem = createTempProcessItem();
    when(property.getItem()).thenReturn(processItem);
    ResourcesManager resManager = mock(ResourcesManager.class);
    Set<IPath> pathes = new HashSet<IPath>();
    IPath projPath = new Path("String_Node_Str" + FileConstants.LOCAL_PROJECT_FILENAME);
    pathes.add(projPath);
    pathes.add(processPropPath1);
    pathes.add(processItemPath1);
    when(resManager.getPaths()).thenReturn(pathes);
    when(resManager.getStream(processItemPath1)).thenReturn(new InputStream() {
        public int read() throws IOException {
            return 1;
        }
    });
    basicHandler.resolveItem(resManager, itemRecord);
    Assert.assertTrue(itemRecord.getErrors().isEmpty());
    Assert.assertTrue(itemRecord.isValid());
    Assert.assertTrue(itemRecord.getErrors().size() == 0);
}

Output:
     ImportBasicHandler basicHandler = new ImportBasicHandler();
-    ItemRecord itemRecord = new ItemRecord(processPropPath1);
-    itemRecord.setItemName(processPropPath1.lastSegment());
+    ImportItem ImportItem = new ImportItem(processPropPath1);
+    ImportItem.setItemName(processPropPath1.lastSegment());
     Property property = mock(Property.class);


Input:
private void removePermanent(UUID permanentId, final int count) {
    for (Component c : this.getComponents()) {
        final Component comp = c;
        if (comp instanceof Permanent) {
            if (((Permanent) comp).getPermanentId().equals(permanentId)) {
                comp.setVisible(false);
                this.remove(comp);
            }
        } else if (comp instanceof MagePermanent) {
            if (((MagePermanent) comp).getOriginal().getId().equals(permanentId)) {
                Thread t = new Thread(new Runnable() {
                    public void run() {
                        Plugins.getInstance().onRemoveCard((MagePermanent) comp, count);
                        comp.setVisible(false);
                        BattlefieldPanel.this.remove(comp);
                    }
                });
                t.start();
            }
        }
    }
}

Output:
 private void removePermanent(UUID permanentId, final int count) {
-    for (Component c : this.getComponents()) {
+    for (Component c : this.jPanel.getComponents()) {
         final Component comp = c;


Input:
public void closeEditorIfOpened(Property property) {
    IWorkbenchPage activePage = CorePlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getActivePage();
    IEditorReference[] editorReferences = activePage.getEditorReferences();
    IEditorInput editorInput = null;
    for (IEditorReference reference : editorReferences) {
        try {
            editorInput = reference.getEditorInput();
            if (editorInput instanceof FileEditorInput) {
                FileEditorInput fileInput = (FileEditorInput) editorInput;
                if (property.eResource() != null) {
                    IPath propPath = new Path(property.eResource().getURI().lastSegment()).removeFileExtension();
                    IPath filePath = new Path(fileInput.getFile().getName()).removeFileExtension();
                    if (filePath.equals(propPath)) {
                        activePage.closeEditor(reference.getEditor(false), false);
                        break;
                    }
                }
            } else if (editorInput instanceof SQLEditorInput) {
                SQLEditorInput sqlEditorInput = (SQLEditorInput) editorInput;
                if (sqlEditorInput.getUser().getAlias().getName().equals(property.getLabel())) {
                    activePage.closeEditor(reference.getEditor(false), false);
                }
            } else if (editorInput instanceof ConnectionItemEditorInput) {
                ConnectionItemEditorInput connectionInput = (ConnectionItemEditorInput) editorInput;
                if (property.equals(connectionInput.getReposViewObj().getProperty())) {
                    activePage.closeEditor(reference.getEditor(false), false);
                }
            }
        } catch (PartInitException e) {
            e.printStackTrace();
        }
    }
}

Output:
                 SQLEditorInput sqlEditorInput = (SQLEditorInput) editorInput;
-                if (sqlEditorInput.getUser().getAlias().getName().equals(property.getLabel())) {
+                if (sqlEditorInput.getUser() == null) {
+                    if (sqlEditorInput.getName().equals(property.getLabel())) {
+                        activePage.closeEditor(reference.getEditor(false), false);
+                    }
+                } else if (sqlEditorInput.getUser().getAlias().getName().equals(property.getLabel())) {
                     activePage.closeEditor(reference.getEditor(false), false);


Input:
public void alignNextTo(Entity3D other) {
    Vector3 tCenter = getPosition();
    Vector3 oCenter = other.getPosition();
    Vector3 direction = Vector3.REUSABLE_STACK.pop();
    direction.set(tCenter).subtractSelf(oCenter).normalizeSelf();
    setPosition(position.addSelf(direction));
    Collision3D.Response response = new Collision3D.Response();
    Collision3D.testPolyhedronCollision(polyhedron, other.polyhedron, response);
    setPosition(position.subtractSelf(response.getMinimumTranslationVector()));
    Vector3.REUSABLE_STACK.push(direction);
}

Output:
     Collision3D.Response response = new Collision3D.Response();
-    Collision3D.testPolyhedronCollision(polyhedron, other.polyhedron, response);
-    setPosition(position.subtractSelf(response.getMinimumTranslationVector()));
-    Vector3.REUSABLE_STACK.push(direction);
+    boolean intersection;
+    do {
+        response.clear();
+        Collision3D.testPolyhedronCollision(polyhedron, other.polyhedron, response);
+        intersection = response.getOverlapDistance() != 0;
+        Vector3 mtv = response.getMinimumTranslationVector();
+        setPosition(position.subtractSelf(mtv));
+    } while (intersection);
 }


Input:
private void dumpFocusStack(PrintWriter pw) {
    pw.println("String_Node_Str");
    synchronized (mFocusStack) {
        Iterator<FocusStackEntry> stackIterator = mFocusStack.iterator();
        while (stackIterator.hasNext()) {
            FocusStackEntry fse = stackIterator.next();
            pw.println("String_Node_Str" + fse.mSourceRef + "String_Node_Str" + fse.mClientId + "String_Node_Str" + fse.mFocusChangeType);
        }
    }
}

Output:
     pw.println("String_Node_Str");
-    synchronized (mFocusStack) {
+    synchronized (mAudioFocusLock) {
         Iterator<FocusStackEntry> stackIterator = mFocusStack.iterator();


Input:
private List<UpdateResult> checkNodeSchemaFromRepositoryForEBCDIC(final Node node, boolean onlySimpleShow) {
    if (node == null) {
        return Collections.emptyList();
    }
    List<UpdateResult> schemaResults = new ArrayList<UpdateResult>();
    if (PluginChecker.isEBCDICPluginLoaded()) {
        IEBCDICProviderService service = (IEBCDICProviderService) GlobalServiceRegister.getDefault().getService(IEBCDICProviderService.class);
        if (service != null) {
            EbcdicConnectionItem repositoryItem = service.getRepositoryItem(node);
            if (repositoryItem != null) {
                IElementParameter schemasTableParam = node.getElementParameter(IEbcdicConstant.TABLE_SCHEMAS);
                if (schemasTableParam != null) {
                    List<Map<String, Object>> paramValues = (List<Map<String, Object>>) schemasTableParam.getValue();
                    for (Map<String, Object> line : paramValues) {
                        if (service.isRepositorySchemaLine(node, line)) {
                            final String schemaName = (String) line.get(IEbcdicConstant.FIELD_SCHEMA);
                            final String propertyValue = repositoryItem.getProperty().getId() + UpdatesConstants.SEGMENT_LINE + schemaName;
                            boolean builtIn = true;
                            UpdateCheckResult result = null;
                            if (repositoryItem != null) {
                                String newSourceId = getSchemaRenamedMap().get(propertyValue);
                                if (newSourceId != null && !newSourceId.equals(propertyValue)) {
                                    String[] newSourceIdAndName = UpdateManagerUtils.getSourceIdAndChildName(newSourceId);
                                    if (newSourceIdAndName != null) {
                                        IMetadataTable table = UpdateRepositoryUtils.getTableByName(repositoryItem, newSourceIdAndName[1]);
                                        if (table != null) {
                                            String source = UpdateRepositoryUtils.getRepositorySourceName(repositoryItem);
                                            final IMetadataTable copyOfrepositoryMetadata = table.clone();
                                            List<Object> parameter = new ArrayList<Object>();
                                            parameter.add(copyOfrepositoryMetadata);
                                            parameter.add(propertyValue);
                                            parameter.add(newSourceId);
                                            parameter.add(line);
                                            result = new UpdateCheckResult(node);
                                            result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.RENAME, parameter, source);
                                            builtIn = false;
                                        }
                                    }
                                } else {
                                    IMetadataTable table = UpdateRepositoryUtils.getTableByName(repositoryItem, schemaName);
                                    if (table != null) {
                                        String source = UpdateRepositoryUtils.getRepositorySourceName(repositoryItem) + UpdatesConstants.SEGMENT_LINE + table.getLabel();
                                        final IMetadataTable copyOfrepositoryMetadata = table.clone();
                                        IMetadataTable metadataTable = null;
                                        metadataTable = MetadataTool.getMetadataTableFromNode(node, schemaName);
                                        if (metadataTable != null && (onlySimpleShow || !metadataTable.sameMetadataAs(copyOfrepositoryMetadata, IMetadataColumn.OPTIONS_NONE))) {
                                            List<Object> parameter = new ArrayList<Object>();
                                            parameter.add(copyOfrepositoryMetadata);
                                            parameter.add(schemaName);
                                            result = new UpdateCheckResult(node);
                                            result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.UPDATE, parameter, source);
                                        }
                                        builtIn = false;
                                    }
                                }
                            }
                            if (builtIn) {
                                result = new UpdateCheckResult(node);
                                result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.BUIL_IN, line);
                            }
                            if (result != null) {
                                result.setJob(getProcess());
                                setConfigrationForReadOnlyJob(result);
                                schemaResults.add(result);
                            }
                        }
                    }
                }
            }
        }
    }
    return schemaResults;
}

Output:
                                         IMetadataTable metadataTable = null;
-                                        metadataTable = MetadataTool.getMetadataTableFromNode(node, schemaName);
+                                        metadataTable = MetadataToolHelper.getMetadataTableFromNodeLabel(node, schemaName);
                                         if (metadataTable != null && (onlySimpleShow || !metadataTable.sameMetadataAs(copyOfrepositoryMetadata, IMetadataColumn.OPTIONS_NONE))) {


Input:
public void setDateStringFormat(String dateStringFormat) {
    setPragma(Pragma.DATE_STRING_FORMAT, dateStringFormat);
}

Output:
 public void setDateStringFormat(String dateStringFormat) {
-    setPragma(Pragma.DATE_STRING_FORMAT, dateStringFormat);
+    this.dateStringFormat = dateStringFormat;
 }


Input:
public void execute(final ScriptEntry scriptEntry) throws CommandExecutionException {
    String direction = scriptEntry.hasObject("String_Node_Str") ? ((Element) scriptEntry.getObject("String_Node_Str")).asString() : null;
    Element typeElement = scriptEntry.getElement("String_Node_Str");
    dList text = (dList) scriptEntry.getObject("String_Node_Str");
    dLocation location = (dLocation) scriptEntry.getObject("String_Node_Str");
    dB.report(scriptEntry, getName(), typeElement.debug() + location.debug() + text.debug());
    Type type = Type.valueOf(typeElement.asString().toUpperCase());
    Block sign = location.getBlock();
    if (type != Type.AUTOMATIC || (sign.getType() != Material.WALL_SIGN && sign.getType() != Material.SIGN_POST)) {
        sign.setType(type == Type.WALL_SIGN ? Material.WALL_SIGN : Material.SIGN_POST);
    }
    BlockState signState = sign.getState();
    Utilities.setSignLines((Sign) signState, text.toArray(4));
    if (direction != null) {
        Utilities.setSignRotation(signState, direction);
    } else if (type == Type.WALL_SIGN) {
        Utilities.setSignRotation(signState);
    }
}

Output:
     if (type != Type.AUTOMATIC || (sign.getType() != Material.WALL_SIGN && sign.getType() != Material.SIGN_POST)) {
-        sign.setType(type == Type.WALL_SIGN ? Material.WALL_SIGN : Material.SIGN_POST);
+        sign.setType(type == Type.WALL_SIGN ? Material.WALL_SIGN : Material.SIGN_POST, false);
     }


Input:
public static XSDElementDeclaration findReference(String refName, XSDSchema schema) {
    EList<XSDElementDeclaration> eDecls = schema.getElementDeclarations();
    if (refName.indexOf("String_Node_Str") != -1) {
        refName = refName.substring(0, refName.indexOf("String_Node_Str"));
    }
    for (XSDElementDeclaration d : eDecls) {
        if (d.getQName().equals(refName)) {
            return d;
        }
    }
    return null;
}

Output:
 public static XSDElementDeclaration findReference(String refName, XSDSchema schema) {
-    EList<XSDElementDeclaration> eDecls = schema.getElementDeclarations();
-    if (refName.indexOf("String_Node_Str") != -1) {
-        refName = refName.substring(0, refName.indexOf("String_Node_Str"));
-    }
-    for (XSDElementDeclaration d : eDecls) {
-        if (d.getQName().equals(refName)) {
-            return d;
+    if (refName != null && schema != null) {
+        EList<XSDElementDeclaration> eDecls = schema.getElementDeclarations();
+        if (refName.indexOf("String_Node_Str") != -1) {
+            refName = refName.substring(0, refName.indexOf("String_Node_Str"));
+        }
+        for (XSDElementDeclaration d : eDecls) {
+            if (d.getQName().equals(refName)) {
+                return d;
+            }
         }


Input:
public static String splitQueryData(String oldName, String newName, String value) {
    inputString = value;
    final int length = value.length();
    LinkedHashMap<Integer, Integer> quotaStrings = new LinkedHashMap<Integer, Integer>();
    List<FunctionInfo> functions = new ArrayList<FunctionInfo>();
    int start = -1;
    int end = -2;
    char ch;
    for (int i = 0; i < length; i++) {
        ch = value.charAt(i);
        if (ch == '\"') {
            if (isEscapeSequence(value, i)) {
                continue;
            }
            if (0 <= start && end < start) {
                end = i;
                quotaStrings.put(start, end);
            } else {
                start = i;
            }
        }
    }
    {
    }
    StringBuffer strBuffer = new StringBuffer();
    String subString = null;
    int vStart = 0;
    int vEnd = 0;
    int methodMaxIndex = -1;
    vStart = 0;
    vEnd = 0;
    start = 0;
    end = 0;
    for (Entry<Integer, Integer> entry : quotaStrings.entrySet()) {
        start = entry.getKey();
        end = entry.getValue() + 1;
        vEnd = start;
        if (vStart != start) {
            subString = value.substring(vStart, vEnd);
            calcMethodArea(subString, value, vStart, functions);
        }
        vStart = end;
    }
    vStart = 0;
    vEnd = 0;
    start = 0;
    end = 0;
    for (Entry<Integer, Integer> entry : quotaStrings.entrySet()) {
        start = entry.getKey();
        end = entry.getValue() + 1;
        vEnd = start;
        if (vStart == start) {
            subString = value.substring(start, end);
            if (start < methodMaxIndex) {
                subString = subString.replaceAll(oldName, newName);
            }
        } else {
            subString = value.substring(vStart, vEnd);
            if (methodMaxIndex < start) {
                methodMaxIndex = FunctionInfo.getMaxIndexForCurrentParentFunction(start, functions);
            }
            String replacedString = doVaribleReplace(oldName, newName, value, functions, vStart, vEnd);
            strBuffer.append(replacedString);
            subString = value.substring(start, end);
            if (start < methodMaxIndex) {
                FunctionInfo function = FunctionInfo.getParentFunctionFromList(start, end, functions);
                Point funcNameArea = function.getNameArea();
                String functionName = value.substring(funcNameArea.x, funcNameArea.y);
                if (functionName.matches("String_Node_Str")) {
                    subString = subString.replaceAll(oldName, newName);
                } else {
                    if (subString.equals("String_Node_Str" + oldName + "String_Node_Str")) {
                        subString = "String_Node_Str" + newName + "String_Node_Str";
                    }
                }
            }
        }
        strBuffer.append(subString);
        vStart = end;
    }
    if (vStart < length) {
        vEnd = length;
        String replacedString = doVaribleReplace(oldName, newName, value, functions, vStart, vEnd);
        strBuffer.append(replacedString);
    }
    return strBuffer.toString();
}

Output:
         ch = value.charAt(i);
-        if (ch == '\"') {
+        if (isInCommentString == false && ch == '\"') {
             if (isEscapeSequence(value, i)) {


Input:
public void SelectTestWithAlias() {
    ClusterName targetCluster = new ClusterName("String_Node_Str");
    List<LogicalStep> logicalSteps = new ArrayList<>();
    TableName tableName = new TableName("String_Node_Str", "String_Node_Str");
    List<ColumnName> columnList = new ArrayList<>();
    ColumnName columnName = new ColumnName(tableName, "String_Node_Str");
    columnList.add(columnName);
    Project project = new Project(Operations.PROJECT, tableName, targetCluster, columnList);
    Selector selector = new ColumnSelector(new ColumnName("String_Node_Str", "String_Node_Str", "String_Node_Str"));
    Selector rightTerm = new StringSelector("String_Node_Str");
    Selector selector2 = new ColumnSelector(new ColumnName("String_Node_Str", "String_Node_Str", "String_Node_Str"));
    Selector rightTerm2 = new StringSelector("String_Node_Str");
    Relation relation2 = new Relation(selector2, Operator.EQ, rightTerm2);
    Filter filter2 = new Filter(Operations.FILTER_INDEXED_EQ, relation2);
    Relation relation = new Relation(selector, Operator.EQ, rightTerm);
    Filter filter = new Filter(Operations.FILTER_NON_INDEXED_EQ, relation);
    Map<ColumnName, String> aliasColumns = new HashMap<>();
    aliasColumns.put(new ColumnName("String_Node_Str", "String_Node_Str", "String_Node_Str"), "String_Node_Str");
    Map<String, ColumnType> typeMap = new HashMap<>();
    Map<ColumnName, ColumnType> typeMapFromColumnName = new HashMap<>();
    typeMap.put("String_Node_Str", ColumnType.VARCHAR);
    typeMapFromColumnName.put(new ColumnName("String_Node_Str", "String_Node_Str", "String_Node_Str"), ColumnType.VARCHAR);
    Select aliasSelect = new Select(Operations.SELECT_LIMIT, aliasColumns, typeMap, typeMapFromColumnName);
    filter2.setNextStep(aliasSelect);
    filter.setNextStep(filter2);
    project.setNextStep(filter);
    logicalSteps.add(project);
    LogicalWorkflow workflow = new LogicalWorkflow(logicalSteps);
    Map<String, Session> sessions = new HashMap<>();
    sessions.put("String_Node_Str", this._session);
    CassandraQueryEngine cqe = new CassandraQueryEngine(sessions, 100);
    QueryResult qr = null;
    try {
        qr = cqe.execute(workflow);
    } catch (ConnectorException e) {
        Assert.fail(e.getMessage());
    }
    String value = "String_Node_Str";
    try {
        for (Row row : qr.getResultSet()) {
            Cell cell = row.getCell("String_Node_Str");
            value = cell.getValue().toString();
        }
        assertEquals(value, "String_Node_Str", "String_Node_Str");
        assertEquals(cqe.parseQuery(), "String_Node_Str", "String_Node_Str");
    } catch (Exception ex) {
        Assert.fail("String_Node_Str");
    }
}

Output:
     Filter filter = new Filter(Operations.FILTER_NON_INDEXED_EQ, relation);
-    Map<ColumnName, String> aliasColumns = new HashMap<>();
-    aliasColumns.put(new ColumnName("String_Node_Str", "String_Node_Str", "String_Node_Str"), "String_Node_Str");
+    Map<Selector, String> aliasColumns = new HashMap<>();
+    aliasColumns.put(new ColumnSelector(new ColumnName("String_Node_Str", "String_Node_Str", "String_Node_Str")), "String_Node_Str");
     Map<String, ColumnType> typeMap = new HashMap<>();


Input:
public void testCascadeRemove() {
    BeerConsumer beerConsumer = null;
    BlueLight blueLightPersisted = null;
    BlueLight blueLightDetached = null;
    EntityManager em = createEntityManager();
    beginTransaction(em);
    beerConsumer = new BeerConsumer();
    beerConsumer.setName("String_Node_Str");
    blueLightPersisted = new BlueLight();
    beerConsumer.getBlueLightBeersToConsume().add(blueLightPersisted);
    blueLightPersisted.setBeerConsumer(beerConsumer);
    em.persist(beerConsumer);
    blueLightPersisted.setUniqueKey(blueLightPersisted.getId().toBigInteger());
    commitTransaction(em);
    assertTrue(em.contains(beerConsumer));
    assertTrue(em.contains(blueLightPersisted));
    beginTransaction(em);
    blueLightDetached = new BlueLight();
    blueLightDetached.setUniqueKey(new BigDecimal(blueLightPersisted.getUniqueKey().intValue() + 1).toBigInteger());
    beerConsumer.getBlueLightBeersToConsume().add(blueLightDetached);
    blueLightDetached.setBeerConsumer(beerConsumer);
    em.remove(beerConsumer);
    assertFalse(em.contains(blueLightDetached));
    try {
        commitTransaction(em);
    } catch (RuntimeException e) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        fail("String_Node_Str" + e.getMessage() + "String_Node_Str");
    }
    assertFalse("String_Node_Str", em.contains(beerConsumer));
    assertFalse("String_Node_Str", em.contains(blueLightPersisted));
    assertFalse("String_Node_Str", em.contains(blueLightDetached));
    closeEntityManager(em);
}

Output:
     EntityManager em = createEntityManager();
-    beginTransaction(em);
-    beerConsumer = new BeerConsumer();
-    beerConsumer.setName("String_Node_Str");
-    blueLightPersisted = new BlueLight();
-    beerConsumer.getBlueLightBeersToConsume().add(blueLightPersisted);
-    blueLightPersisted.setBeerConsumer(beerConsumer);
-    em.persist(beerConsumer);
-    blueLightPersisted.setUniqueKey(blueLightPersisted.getId().toBigInteger());
-    commitTransaction(em);
-    assertTrue(em.contains(beerConsumer));
-    assertTrue(em.contains(blueLightPersisted));
-    beginTransaction(em);
-    blueLightDetached = new BlueLight();
-    blueLightDetached.setUniqueKey(new BigDecimal(blueLightPersisted.getUniqueKey().intValue() + 1).toBigInteger());
-    beerConsumer.getBlueLightBeersToConsume().add(blueLightDetached);
-    blueLightDetached.setBeerConsumer(beerConsumer);
-    em.remove(beerConsumer);
-    assertFalse(em.contains(blueLightDetached));
+    try {
+        beginTransaction(em);
+        beerConsumer = new BeerConsumer();
+        beerConsumer.setName("String_Node_Str");
+        blueLightPersisted = new BlueLight();
+        beerConsumer.getBlueLightBeersToConsume().add(blueLightPersisted);
+        blueLightPersisted.setBeerConsumer(beerConsumer);
+        em.persist(beerConsumer);
+        blueLightPersisted.setUniqueKey(blueLightPersisted.getId().toBigInteger());
+        assertTrue(em.contains(beerConsumer));
+        assertTrue(em.contains(blueLightPersisted));
+        commitTransaction(em);
+    } catch (RuntimeException e) {
+        if (isTransactionActive(em)) {
+            rollbackTransaction(em);
+        }
+        closeEntityManager(em);
+        throw e;
+    }
+    try {
+        beginTransaction(em);
+        blueLightDetached = new BlueLight();
+        blueLightDetached.setUniqueKey(new BigDecimal(blueLightPersisted.getUniqueKey().intValue() + 1).toBigInteger());
+        beerConsumer.getBlueLightBeersToConsume().add(blueLightDetached);
+        blueLightDetached.setBeerConsumer(beerConsumer);
+        if (isOnServer()) {
+            beerConsumer = em.find(BeerConsumer.class, m_beerConsumerId);
+        }
+        em.remove(beerConsumer);
+        assertFalse(em.contains(blueLightDetached));
+    } catch (RuntimeException e) {
+        if (isTransactionActive(em)) {
+            rollbackTransaction(em);
+        }
+        closeEntityManager(em);
+        throw e;
+    }
     try {


Input:
public final <T> Reference<? extends Persistible> generateReference() {
    return new Reference(this.getClass(), getId(), getVersion());
}

Output:
 public final <T> Reference<? extends Persistible> generateReference() {
-    return new Reference(this.getClass(), getId(), getVersion());
+    Reference<? extends Persistible> ret;
+    if (getId() == null) {
+        ret = new Reference(this.getClass());
+    } else {
+        if (version == null) {
+            ret = new Reference(this.getClass(), getId().longValue());
+        } else {
+            ret = new Reference(this.getClass(), getId().longValue(), getVersion().longValue());
+        }
+    }
+    return ret;
 }


Input:
public V getAndReplace(K key, V value) {
    checkStatusStarted();
    if (value == null) {
        throw new NullPointerException("String_Node_Str" + key);
    }
    long now = System.currentTimeMillis();
    V result;
    lockManager.lock(key);
    try {
        Object internalKey = keyConverter.toInternal(key);
        RICachedValue cachedValue = entries.get(internalKey);
        if (cachedValue == null || cachedValue.isExpiredAt(now)) {
            result = null;
        } else {
            RIEntry<K, V> entry = new RIEntry<K, V>(key, value);
            writeCacheEntry(entry);
            result = valueConverter.fromInternal(cachedValue.getInternalValue(now));
            Duration duration;
            try {
                duration = expiryPolicy.getTTLForModifiedEntry(entry, new Duration(now, cachedValue.getExpiryTime()));
            } catch (Throwable t) {
                duration = getDefaultDuration();
            }
            long expiryTime = duration.getAdjustedTime(now);
            Object internalValue = valueConverter.toInternal(value);
            cachedValue.setInternalValue(internalValue, now);
            cachedValue.setExpiryTime(expiryTime);
            RICacheEventEventDispatcher<K, V> dispatcher = new RICacheEventEventDispatcher<K, V>();
            dispatcher.addEvent(CacheEntryUpdatedListener.class, new RICacheEntryEvent<K, V>(this, key, value, result));
            dispatcher.dispatch(cacheEntryListenerRegistrations.values());
        }
    } finally {
        lockManager.unLock(key);
    }
    if (statisticsEnabled()) {
        if (result != null) {
            statistics.increaseCacheHits(1);
            statistics.increaseCachePuts(1);
        } else {
            statistics.increaseCacheMisses(1);
        }
    }
    return result;
}

Output:
             try {
-                duration = expiryPolicy.getTTLForModifiedEntry(entry, new Duration(now, cachedValue.getExpiryTime()));
+                Duration duration = expiryPolicy.getTTLForModifiedEntry(entry, new Duration(now, cachedValue.getExpiryTime()));
+                long expiryTime = duration.getAdjustedTime(now);
+                cachedValue.setExpiryTime(expiryTime);
             } catch (Throwable t) {


Input:
public CheckedListenableFuture<P> leave() {
    this.transition.leave(AtomicMarkedState.this.parent, this);
    return this.transitionFuture;
}

Output:
 public CheckedListenableFuture<P> leave() {
-    this.transition.leave(AtomicMarkedState.this.parent, this);
-    return this.transitionFuture;
+    try {
+        this.transition.leave(AtomicMarkedState.this.parent, this);
+        return this.transitionFuture;
+    } catch (Exception ex) {
+        this.transitionFuture.setException(ex);
+        return this.transitionFuture;
+    }
 }


Input:
protected void onMessage(String channel, String sender, String login, String hostname, String message) {
    if (message.equalsIgnoreCase("String_Node_Str")) {
        String time = new java.util.Date().toString();
        botManager.sendMessage(channel, sender + "String_Node_Str" + time);
    } else if (message.equalsIgnoreCase("String_Node_Str")) {
        botManager.sendMessage(channel, sender + "String_Node_Str" + "String_Node_Str");
    } else if (message.equalsIgnoreCase("String_Node_Str") && sender.startsWith(trustedSender)) {
        forwardMessages = false;
        botManager.sendMessage(channel, "String_Node_Str");
    } else if (message.equalsIgnoreCase("String_Node_Str") && sender.startsWith(trustedSender)) {
        forwardMessages = true;
        botManager.sendMessage(channel, "String_Node_Str");
    } else {
        try {
            if (forwardMessages && sender.startsWith(trustedSender))
                chat.sendMessage("String_Node_Str" + sender + "String_Node_Str" + message);
        } catch (Exception e) {
            System.err.println("String_Node_Str");
            e.printStackTrace();
        }
    }
}

Output:
         try {
-            if (forwardMessages && sender.startsWith(trustedSender))
+            if (forwardMessages && !sender.startsWith(trustedSender))
                 chat.sendMessage("String_Node_Str" + sender + "String_Node_Str" + message);


Input:
public Object visitListItem(ListItemDesign list, Object value) {
    BaseQueryDefinition query = createQuery(list, value);
    if (query == null) {
        handleListingBand(list.getHeader(), query, true, null);
        handleListingBand(list.getFooter(), query, true, null);
    } else {
        handleListingBand(list.getHeader(), query, true, null);
        SlotHandle groupsSlot = ((ListHandle) list.getHandle()).getGroups();
        for (int i = 0; i < list.getGroupCount(); i++) {
            handleListingGroup(list.getGroup(i), (GroupHandle) groupsSlot.get(i), query);
        }
        BandDesign detail = list.getDetail();
        if (detail == null || detail.getContentCount() == 0) {
            query.setUsesDetails(false);
        }
        handleListingBand(detail, query, false, null);
        handleListingBand(list.getFooter(), query, true, null);
    }
    finishVisit(list, query);
    if (query != value) {
        return new IBaseQueryDefinition[] { query };
    }
    return null;
}

Output:
     finishVisit(list, query);
-    if (query != value) {
-        return new IBaseQueryDefinition[] { query };
-    }
-    return null;
+    return getResultQuery(query, value);
 }


Input:
public List<Status> search(String searchTerm, ICallback callback, int rpp) {
    if (rpp > 100 && maxResults < rpp)
        throw new IllegalArgumentException("String_Node_Str" + rpp);
    Map vars;
    if (maxResults < 100 && maxResults > 0) {
        vars = getSearchParams(searchTerm, maxResults);
    } else {
        vars = getSearchParams(searchTerm, rpp);
    }
    List<Status> allResults = new ArrayList<Status>(Math.max(maxResults, rpp));
    String url = TWITTER_URL + "String_Node_Str";
    BigInteger maxId = untilId;
    do {
        vars.put("String_Node_Str", maxId);
        List<Status> stati;
        try {
            String json = http.getPage(url, vars, true);
            stati = Status.getStatusesFromSearch(this, json);
        } catch (TwitterException.Parsing pex) {
            if (http.isRetryOnError()) {
                InternalUtils.sleep(250);
                String json = http.getPage(url, vars, true);
                stati = Status.getStatusesFromSearch(this, json);
            } else {
                throw pex;
            }
        }
        int numResults = stati.size();
        maxId = InternalUtils.getMinId(maxId, stati);
        stati = dateFilter(stati);
        allResults.addAll(stati);
        if (callback != null) {
            if (callback.process(stati)) {
                break;
            }
        }
        if (numResults < rpp) {
            break;
        }
    } while (allResults.size() < maxResults);
    return allResults;
}

Output:
         }
-        if (numResults < rpp) {
+        if ((rpp == 100 && numResults < 70) || numResults < rpp) {
             break;


Input:
public void setExpression(String expr) {
    codec.decode(expr);
    eHelper.setExpressionType(codec.getType());
    eHelper.setExpression(codec.getExpression());
    eb.refresh();
}

Output:
 public void setExpression(String expr) {
-    codec.decode(expr);
-    eHelper.setExpressionType(codec.getType());
-    eHelper.setExpression(codec.getExpression());
+    if (expr != null && expr.length() > 0) {
+        codec.decode(expr);
+        eHelper.setExpression(codec.getExpression());
+        eHelper.setExpressionType(codec.getType());
+    } else {
+        eHelper.setExpression(codec.getExpression());
+    }
     eb.refresh();


Input:
public void checksForHeader() throws Exception {
    requestTrackerServletFilter.doFilter(request, response, chain);
    verify(request).getHeader(RequestTrackerConstants.DEFAULT_LOG_ID_HEADER);
}

Output:
     requestTrackerServletFilter.doFilter(request, response, chain);
-    verify(request).getHeader(RequestTrackerConstants.DEFAULT_LOG_ID_HEADER);
+    verify(request).getHeader(RequestTrackerConstants.DEFAULT_HEADER);
 }