Input:
public void handlePacket(Packet p, IoSession session) throws Exception {
    Player player = (Player) session.getAttachment();
    if (player.isBusy()) {
        player.resetPath();
        return;
    }
    player.resetAll();
    Point location = Point.location(p.readShort(), p.readShort());
    int id = p.readShort();
    final ActiveTile tile = world.getTile(location);
    final Item item = getItem(id, tile, player);
    if (item == null) {
        player.resetPath();
        return;
    }
    if (!item.getDef().canTrade()) {
        if (item.droppedby() != 0 && org.moparscape.msc.gs.tools.DataConversions.usernameToHash(player.getUsername()) != item.droppedby()) {
            player.getActionSender().sendMessage("String_Node_Str");
            return;
        }
    }
    if (player.isPMod() && !player.isMod())
        return;
    if (item.getDef().isMembers() && !World.isMembers()) {
        player.getActionSender().sendMessage("String_Node_Str");
        return;
    }
    player.setStatus(Action.TAKING_GITEM);
    Instance.getDelayedEventHandler().add(new WalkToPointEvent(player, location, 0, true) {

        public void arrived() {
            if (owner.isBusy() || owner.isRanging() || !tile.hasItem(item) || !owner.nextTo(item) || owner.getStatus() != Action.TAKING_GITEM) {
                return;
            }
            if (item.getID() == 23) {
                owner.getActionSender().sendMessage("String_Node_Str");
                owner.getActionSender().sendMessage("String_Node_Str");
                return;
            }
            int[] Rares = { 576, 577, 578, 579, 580, 581, 828, 831, 832, 1278, 593, 594, 795 };
            boolean pickedUpRare = false;
            if (item.getAmount() > 99999)
                pickedUpRare = true;
            for (int i = 0; i < Rares.length; i++) {
                if (item.getID() == Rares[i]) {
                    pickedUpRare = true;
                    break;
                }
            }
            owner.resetAll();
            InvItem invItem = new InvItem(item.getID(), item.getAmount());
            if (!owner.getInventory().canHold(invItem)) {
                owner.getActionSender().sendMessage("String_Node_Str");
                return;
            }
            try {
                if (item.getID() == 59 && item.getX() == 106 && item.getY() == 1476) {
                    Npc n = world.getNpc(37, 103, 107, 1476, 1479);
                    if (n != null && !n.inCombat()) {
                        owner.informOfNpcMessage(new ChatMessage(n, "String_Node_Str", owner));
                        fight(owner, n);
                    }
                } else if (item.getID() == 501 && item.getX() == 333 && item.getY() == 434) {
                    Npc zam = world.getNpc(140, 328, 333, 433, 438, true);
                    if (zam != null && !zam.inCombat()) {
                        owner.informOfNpcMessage(new ChatMessage(zam, "String_Node_Str", owner));
                        for (int i = 0; i < 3; i++) {
                            int stat = owner.getCurStat(i);
                            if (stat < 3)
                                owner.setCurStat(i, 0);
                            else
                                owner.setCurStat(i, stat - 3);
                        }
                        owner.getActionSender().sendStats();
                        fight(owner, zam);
                        return;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (pickedUpRare) {
                MiscPacketBuilder loginServer = Instance.getServer().getLoginConnector().getActionSender();
                final long droppedby = item.droppedby();
                final long playerLong = org.moparscape.msc.gs.tools.DataConversions.usernameToHash(owner.getUsername());
                loginServer.tradeLog(droppedby, playerLong, item.getID(), item.getAmount(), owner.getX(), owner.getY(), 3);
            }
            world.addEntryToSnapshots(new Activity(owner.getUsername(), owner.getUsername() + "String_Node_Str" + item.getDef().getName() + "String_Node_Str" + item.getID() + "String_Node_Str" + item.getAmount() + "String_Node_Str" + owner.getX() + "String_Node_Str" + owner.getY() + "String_Node_Str" + item.getX() + "String_Node_Str" + item.getY()));
            if (item.getAmount() > 10000000 || Formulae.isRareItem(item.getID()))
                DBConnection.getReport().submitDupeData(owner.getUsername(), owner.getUsernameHash());
            world.unregisterItem(item);
            owner.getActionSender().sendSound("String_Node_Str");
            owner.getInventory().add(invItem);
            owner.getActionSender().sendInventory();
        }
    });
}

Output:
     player.setStatus(Action.TAKING_GITEM);
-    Instance.getDelayedEventHandler().add(new WalkToPointEvent(player, location, 0, true) {
+    int distance = tile.hasGameObject() ? 1 : 0;
+    Instance.getDelayedEventHandler().add(new WalkToPointEvent(player, location, distance, true) {


Input:
private int getEncryptionStatus() {
    if (!StorageManager.isNonDefaultBlockEncrypted()) {
        return DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE_DEFAULT_KEY;
    } else if (StorageManager.isEncrypted()) {
        return DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE;
    } else if (StorageManager.isEncryptable()) {
        return DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE;
    } else {
        return DevicePolicyManager.ENCRYPTION_STATUS_UNSUPPORTED;
    }
}

Output:
 private int getEncryptionStatus() {
-    if (!StorageManager.isNonDefaultBlockEncrypted()) {
-        return DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE_DEFAULT_KEY;
-    } else if (StorageManager.isEncrypted()) {
-        return DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE;
+    if (StorageManager.isEncrypted()) {
+        return StorageManager.isNonDefaultBlockEncrypted() ? DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE : DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE_DEFAULT_KEY;
     } else if (StorageManager.isEncryptable()) {


Input:
public boolean resolveTextDirection() {
    mPrivateFlags2 &= ~(PFLAG2_TEXT_DIRECTION_RESOLVED | PFLAG2_TEXT_DIRECTION_RESOLVED_MASK);
    if (hasRtlSupport()) {
        final int textDirection = getRawTextDirection();
        switch(textDirection) {
            case TEXT_DIRECTION_INHERIT:
                if (!canResolveTextDirection()) {
                    mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED_DEFAULT;
                    return false;
                }
                View parent = ((View) mParent);
                if (!parent.isTextDirectionResolved()) {
                    mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED_DEFAULT;
                    return false;
                }
                final int parentResolvedDirection = parent.getTextDirection();
                switch(parentResolvedDirection) {
                    case TEXT_DIRECTION_FIRST_STRONG:
                    case TEXT_DIRECTION_ANY_RTL:
                    case TEXT_DIRECTION_LTR:
                    case TEXT_DIRECTION_RTL:
                    case TEXT_DIRECTION_LOCALE:
                        mPrivateFlags2 |= (parentResolvedDirection << PFLAG2_TEXT_DIRECTION_RESOLVED_MASK_SHIFT);
                        break;
                    default:
                        mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED_DEFAULT;
                }
                break;
            case TEXT_DIRECTION_FIRST_STRONG:
            case TEXT_DIRECTION_ANY_RTL:
            case TEXT_DIRECTION_LTR:
            case TEXT_DIRECTION_RTL:
            case TEXT_DIRECTION_LOCALE:
                mPrivateFlags2 |= (textDirection << PFLAG2_TEXT_DIRECTION_RESOLVED_MASK_SHIFT);
                break;
            default:
                mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED_DEFAULT;
        }
    } else {
        mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED_DEFAULT;
    }
    mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED;
    return true;
}

Output:
                 }
-                View parent = ((View) mParent);
-                if (!parent.isTextDirectionResolved()) {
+                if (!mParent.isTextDirectionResolved()) {
                     mPrivateFlags2 |= PFLAG2_TEXT_DIRECTION_RESOLVED_DEFAULT;


Input:
private void createDetailList(Composite composite) {
    Composite compoDetail = new Composite(composite, SWT.NONE);
    compoDetail.setLayout(new GridLayout(1, false));
    GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
    data.heightHint = 60;
    data.widthHint = 300;
    compoDetail.setLayoutData(data);
    labelDetail = new Label(compoDetail, SWT.WRAP);
    labelDetail.setLayoutData(data);
}

Output:
     GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
-    data.heightHint = 60;
+    data.heightHint = 150;
     data.widthHint = 300;


Input:
public boolean updateNote(long rowId, String title, String body, byte[] data) {
    ContentValues args = new ContentValues();
    args.put(KEY_TITLE, title);
    args.put(KEY_BODY, body);
    if (data != null)
        args.put(KEY_DATA, data);
    return mDb.update(DATABASE_TABLE, args, KEY_ROWID + "String_Node_Str" + rowId, null) > 0;
}

Output:
     args.put(KEY_BODY, body);
-    if (data != null)
+    if (data != null) {
         args.put(KEY_DATA, data);


Input:
public void notifyDataSetChanged() {
    super.notifyDataSetChanged();
    mYAxisRenderer.computeAxis(0f, mData.getYMax());
    mXAxisRenderer.computeAxis(mData.getXValAverageLength(), mData.getXVals());
}

Output:
     super.notifyDataSetChanged();
-    mYAxisRenderer.computeAxis(0f, mData.getYMax());
-    mXAxisRenderer.computeAxis(mData.getXValAverageLength(), mData.getXVals());
+    if (mData != null) {
+        mYAxisRenderer.computeAxis(0f, mData.getYMax());
+        mXAxisRenderer.computeAxis(mData.getXValAverageLength(), mData.getXVals());
+    }
 }


Input:
public void renderAxisLabels(Canvas c) {
    if (!mXAxis.isEnabled() || !mXAxis.isDrawLabelsEnabled())
        return;
    float yoffset = mXAxis.getYOffset();
    mAxisLabelPaint.setTypeface(mXAxis.getTypeface());
    mAxisLabelPaint.setTextSize(mXAxis.getTextSize());
    mAxisLabelPaint.setColor(mXAxis.getTextColor());
    if (mXAxis.getPosition() == XAxisPosition.TOP) {
        drawLabels(c, mViewPortHandler.contentTop() - yoffset, new PointF(0.5f, 1.0f));
    } else if (mXAxis.getPosition() == XAxisPosition.TOP_INSIDE) {
        drawLabels(c, mViewPortHandler.contentTop() + yoffset + mXAxis.mLabelRotatedHeight, new PointF(0.5f, 1.0f));
    } else if (mXAxis.getPosition() == XAxisPosition.BOTTOM) {
        drawLabels(c, mViewPortHandler.contentBottom() + yoffset, new PointF(0.5f, 0.0f));
    } else if (mXAxis.getPosition() == XAxisPosition.BOTTOM_INSIDE) {
        drawLabels(c, mViewPortHandler.contentBottom() - yoffset - mXAxis.mLabelRotatedHeight, new PointF(0.5f, 0.0f));
    } else {
        drawLabels(c, mViewPortHandler.contentTop() - yoffset, new PointF(0.5f, 1.0f));
        drawLabels(c, mViewPortHandler.contentBottom() + yoffset, new PointF(0.5f, 0.0f));
    }
}

Output:
     if (mXAxis.getPosition() == XAxisPosition.TOP) {
-        drawLabels(c, mViewPortHandler.contentTop() - yoffset, new PointF(0.5f, 1.0f));
+        drawLabels(c, mViewPortHandler.contentTop() - yoffset, new PointF(0.5f, 0.9f));
     } else if (mXAxis.getPosition() == XAxisPosition.TOP_INSIDE) {


Input:
private void createTosActionArea(Composite parent) {
    tosActionComposite = toolkit.createComposite(parent);
    GridData gd = new GridData(GridData.FILL_HORIZONTAL);
    gd.heightHint = 140;
    tosActionComposite.setLayoutData(gd);
    tosActionComposite.setLayout(new FormLayout());
    tosActionComposite.setBackgroundMode(SWT.INHERIT_DEFAULT);
    FormData data;
    Label projectLabel = toolkit.createLabel(tosActionComposite, Messages.getString("String_Node_Str"));
    GC gc = new GC(projectLabel);
    Point labelSize = gc.stringExtent(Messages.getString("String_Node_Str"));
    gc.dispose();
    data = new FormData();
    data.top = new FormAttachment(0, 10);
    data.left = new FormAttachment(0, 50);
    data.bottom = new FormAttachment(0, 30);
    projectLabel.setBackground(tosActionComposite.getBackground());
    projectLabel.setLayoutData(data);
    openButton = toolkit.createButton(tosActionComposite, null, SWT.PUSH);
    data = new FormData();
    data.top = new FormAttachment(projectLabel, 0, SWT.TOP);
    gc = new GC(openButton);
    Point labelSizeOpenButton = gc.stringExtent(Messages.getString("String_Node_Str"));
    gc.dispose();
    int width = OPEN_IMAGE.getBounds().width;
    gc = new GC(openButton);
    Point labelSizeDeleteButton = gc.stringExtent(Messages.getString("String_Node_Str"));
    gc.dispose();
    if (labelSizeOpenButton.x + width > labelSizeDeleteButton.x) {
        data.left = new FormAttachment(100, -20 - labelSizeOpenButton.x - width - 10);
    } else {
        data.left = new FormAttachment(100, -20 - labelSizeDeleteButton.x - 10);
    }
    data.right = new FormAttachment(100, -10);
    openButton.setText(Messages.getString("String_Node_Str"));
    openButton.setLayoutData(data);
    openButton.setImage(OPEN_IMAGE);
    projectList = new List(tosActionComposite, SWT.BORDER | SWT.V_SCROLL);
    data = new FormData();
    data.top = new FormAttachment(projectLabel, 0, SWT.TOP);
    data.left = new FormAttachment(projectLabel, 10, SWT.RIGHT);
    data.right = new FormAttachment(openButton, -10, SWT.LEFT);
    data.bottom = new FormAttachment(0, 100);
    projectList.setLayoutData(data);
    deleteButton = toolkit.createButton(tosActionComposite, null, SWT.PUSH);
    data = new FormData();
    data.top = new FormAttachment(openButton, 5, SWT.BOTTOM);
    data.left = new FormAttachment(openButton, 0, SWT.LEFT);
    data.right = new FormAttachment(openButton, 0, SWT.RIGHT);
    deleteButton.setText(Messages.getString("String_Node_Str"));
    deleteButton.setLayoutData(data);
    createButton = toolkit.createButton(tosActionComposite, null, SWT.PUSH);
    data = new FormData();
    data.top = new FormAttachment(projectList, 10, SWT.BOTTOM);
    data.left = new FormAttachment(projectList, 0, SWT.LEFT);
    data.right = new FormAttachment(projectList, 65, SWT.LEFT);
    createButton.setText(Messages.getString("String_Node_Str"));
    createButton.setLayoutData(data);
    importButton = toolkit.createButton(tosActionComposite, null, SWT.PUSH);
    data = new FormData();
    data.top = new FormAttachment(createButton, 0, SWT.TOP);
    data.left = new FormAttachment(createButton, 10, SWT.RIGHT);
    importButton.setText(Messages.getString("String_Node_Str"));
    importButton.setLayoutData(data);
    demoProjectButton = toolkit.createButton(tosActionComposite, null, SWT.PUSH);
    data = new FormData();
    data.top = new FormAttachment(importButton, 0, SWT.TOP);
    data.left = new FormAttachment(importButton, 10, SWT.RIGHT);
    data.right = new FormAttachment(100, -10);
    demoProjectButton.setText(Messages.getString("String_Node_Str"));
    demoProjectButton.setLayoutData(data);
    enableOpenAndDelete(false);
}

Output:
     openButton.setImage(OPEN_IMAGE);
-    projectList = new List(tosActionComposite, SWT.BORDER | SWT.V_SCROLL);
+    Composite projectListViewerContainer = new Composite(tosActionComposite, SWT.NONE);
+    projectListViewerContainer.setLayout(new FillLayout());
+    this.projectListViewer = new ListViewer(projectListViewerContainer);
+    this.projectListViewer.setContentProvider(new TableViewerContentProvider());
+    this.projectListViewer.setLabelProvider(new ILabelProvider() {
+        public void removeListener(ILabelProviderListener listener) {
+        }
+        public boolean isLabelProperty(Object element, String property) {
+            return false;
+        }
+        public void dispose() {
+        }
+        public void addListener(ILabelProviderListener listener) {
+        }
+        public String getText(Object element) {
+            if (element != null) {
+                return element.toString();
+            }
+            return null;
+        }
+        public Image getImage(Object element) {
+            return null;
+        }
+    });
+    this.projectListViewer.setSorter(new ViewerSorter());
     data = new FormData();


Input:
public boolean hasLoadBinding(BindingKey bkey) {
    return _initBindings.size() > 0 || _loadPromptBindings.size() > 0 || _loadEventBindings.size() > 0 || _loadAfterBindings.size() > 0 || _loadBeforeBindings.size() > 0;
}

Output:
 public boolean hasLoadBinding(BindingKey bkey) {
-    return _initBindings.size() > 0 || _loadPromptBindings.size() > 0 || _loadEventBindings.size() > 0 || _loadAfterBindings.size() > 0 || _loadBeforeBindings.size() > 0;
+    boolean r = false;
+    List<?> bindings = _initBindings.get(bkey);
+    if (bindings != null && bindings.size() > 0) {
+        return true;
+    }
+    bindings = _loadPromptBindings.get(bkey);
+    if (bindings != null && bindings.size() > 0) {
+        return true;
+    }
+    bindings = _loadEventBindings.get(bkey);
+    if (bindings != null && bindings.size() > 0) {
+        return true;
+    }
+    bindings = _loadAfterBindings.get(bkey);
+    if (bindings != null && bindings.size() > 0) {
+        return true;
+    }
+    bindings = _loadBeforeBindings.get(bkey);
+    if (bindings != null && bindings.size() > 0) {
+        return true;
+    }
+    return false;
 }


Input:
public void setLastSyncDateTimeToNow(OModel model) {
    Log.i(TAG, "String_Node_Str" + model.getModelName());
    OValues values = new OValues();
    values.put("String_Node_Str", model.getModelName());
    values.put("String_Node_Str", ODateUtils.getUTCDate());
    insertOrUpdate("String_Node_Str", new String[] { model.getModelName() }, values);
}

Output:
     values.put("String_Node_Str", model.getModelName());
-    values.put("String_Node_Str", ODateUtils.getUTCDate());
+    Date last_sync = ODateUtils.createDateObject(ODateUtils.getUTCDate(), ODateUtils.DEFAULT_FORMAT, true);
+    Calendar cal = Calendar.getInstance();
+    cal.setTime(last_sync);
+    cal.set(Calendar.SECOND, cal.get(Calendar.SECOND) + 2);
+    last_sync = cal.getTime();
+    values.put("String_Node_Str", ODateUtils.getDate(last_sync, ODateUtils.DEFAULT_FORMAT));
     insertOrUpdate("String_Node_Str", new String[] { model.getModelName() }, values);


Input:
private void findInterior(TunnelRegion.Axis axis, double rayX, double rayY, double rayZ, int[] tris, Grid grid) {
    boolean[] t_result = new boolean[numVoxels];
    float[] pos = new float[3];
    float[] workingTri;
    TriangleIntersectionDoubleUtil intersectTester = new TriangleIntersectionDoubleUtil();
    ArrayList hits = new ArrayList(tris.length);
    double rx = rayX;
    double ry = rayY;
    double rz = rayZ;
    for (int j = 0; j < tris.length; j++) {
        int id = tris[j];
        workingTri = spatial.getTriangle(id);
        switch(axis) {
            case X:
                if (intersectTester.xAxisRayTriangle(rx, ry, rz, workingTri)) {
                    hits.add(new HitRecord(axis, intersectTester.getLastIntersectionPoint(), rx, ry, rz, workingTri));
                }
                break;
            case Y:
                if (intersectTester.yAxisRayTriangle(rx, ry, rz, workingTri)) {
                    hits.add(new HitRecord(axis, intersectTester.getLastIntersectionPoint(), rx, ry, rz, workingTri));
                }
                break;
            case Z:
                if (intersectTester.zAxisRayTriangle(rx, ry, rz, workingTri)) {
                    hits.add(new HitRecord(axis, intersectTester.getLastIntersectionPoint(), rx, ry, rz, workingTri));
                }
                break;
        }
    }
    Collections.sort(hits);
    int hlen = hits.size() - 1;
    HitRecord a;
    HitRecord b;
    int idx = 0;
    double av;
    double bv;
    double dist;
    double EPSILON = 0.00000001;
    int[] minCoords = new int[3];
    int[] maxCoords = new int[3];
    boolean show_details = false;
    while (idx < hlen) {
        a = (HitRecord) hits.get(idx++);
        b = (HitRecord) hits.get(idx++);
        av = a.getPosition();
        bv = b.getPosition();
        dist = bv - av;
        if (show_details) {
            System.out.println("String_Node_Str" + a);
            System.out.println("String_Node_Str" + java.util.Arrays.toString(a.tricoords) + "String_Node_Str");
            System.out.println("String_Node_Str" + b);
            System.out.println("String_Node_Str" + java.util.Arrays.toString(b.tricoords) + "String_Node_Str");
            System.out.println("String_Node_Str" + dist);
        }
        pos[0] = (float) a.getX();
        pos[1] = (float) a.getY();
        pos[2] = (float) a.getZ();
        spatial.findGridCoordsFromWorldCoords(pos, minCoords);
        pos[0] = (float) b.getX();
        pos[1] = (float) b.getY();
        pos[2] = (float) b.getZ();
        spatial.findGridCoordsFromWorldCoords(pos, maxCoords);
        switch(axis) {
            case X:
                minCoords[0] += 1;
                maxCoords[0] -= 1;
                break;
            case Y:
                minCoords[1] += 1;
                maxCoords[1] -= 1;
                break;
            case Z:
                minCoords[2] += 1;
                maxCoords[2] -= 1;
                break;
        }
        fillCells(true, t_result, origin, axis, minCoords, maxCoords);
    }
    hits.clear();
    int[] coords = new int[3];
    pos[0] = (float) rayX;
    pos[1] = (float) rayY;
    pos[2] = (float) rayZ;
    spatial.findGridCoordsFromWorldCoords(pos, coords);
    if (axis == TunnelRegion.Axis.X) {
        int len = t_result.length;
        int start = 0;
        for (int i = start; i < len; i++) {
            if (t_result[i] == true) {
                result.setData(i - origin[0], coords[1] - origin[1], coords[2] - origin[2], Grid.INTERIOR, result.getMaterial(i - origin[0], coords[1] - origin[1], coords[2] - origin[2]) + 1);
            }
        }
    } else if (axis == TunnelRegion.Axis.Y) {
        int len = t_result.length;
        int start = 0;
        for (int i = start; i < len; i++) {
            if (t_result[i] == true) {
                result.setData(coords[0] - origin[0], i - origin[1], coords[2] - origin[2], Grid.INTERIOR, result.getMaterial(coords[0] - origin[0], i - origin[1], coords[2] - origin[2]) + 1);
            }
        }
    } else if (axis == TunnelRegion.Axis.Z) {
        int len = t_result.length;
        int start = 0;
        for (int i = start; i < len; i++) {
            if (t_result[i] == true) {
                result.setData(coords[0] - origin[0], coords[1] - origin[1], i - origin[2], Grid.INTERIOR, result.getMaterial(coords[0] - origin[0], coords[1] - origin[1], i - origin[2]) + 1);
            }
        }
    }
}

Output:
         pos[2] = (float) a.getZ();
-        spatial.findGridCoordsFromWorldCoords(pos, minCoords);
+        grid.getGridCoords(pos[0], pos[1], pos[2], minCoords);
         pos[0] = (float) b.getX();


Input:
public void execute(Tree root) {
    Tree tree = root;
    for (int i = 0; i < path.length - 1; i++) {
        tree = tree.getChild(path[i]);
    }
    if (!splitLeft) {
        if (!splitRight) {
            if (!addStyle) {
                tree.setAttribute(param, value);
            } else {
                Tree tc = tree.removeChild(path[path.length - 1]);
                Tree ts = TreeFactory.createElementTree("String_Node_Str");
                ts.setAttribute(param, value);
                ts.addChild(tc);
                tree.addChild(ts, path[path.length - 1]);
                if (tc.isInvisible()) {
                    ts.hide();
                }
            }
        } else {
            if (!addStyle) {
                String text = tree.getChild(path[path.length - 1]).split(end);
                Tree tc = TreeFactory.createTextTree(text);
                Tree ts = tree.cloneNode();
                tree.setAttribute(param, value);
                ts.addChild(tc);
                Tree parent = tree.getParent();
                parent.addChild(ts, path[path.length - 2] + 1);
                if (tree.isInvisible()) {
                    ts.hide();
                }
            } else {
                Tree t = tree.getChild(path[path.length - 1]);
                Tree tc = TreeFactory.createTextTree(t.split(end));
                Tree ts = TreeFactory.createElementTree("String_Node_Str");
                ts.setAttribute(param, value);
                ts.addChild(tree.removeChild(path[path.length - 1]));
                tree.addChild(tc, path[path.length - 1]);
                tree.addChild(ts, path[path.length - 1]);
                if (t.isInvisible()) {
                    tc.hide();
                    ts.hide();
                }
            }
        }
    } else {
        if (!splitRight) {
            if (!addStyle) {
                Tree tc = TreeFactory.createTextTree(tree.getChild(path[path.length - 1]).split(start));
                Tree ts = tree.cloneNode();
                ts.setAttribute(param, value);
                ts.addChild(tc);
                Tree parent = tree.getParent();
                parent.addChild(ts, path[path.length - 2] + 1);
                if (tree.isInvisible()) {
                    ts.hide();
                }
            } else {
                Tree t = tree.getChild(path[path.length - 1]);
                Tree tc = TreeFactory.createTextTree(t.split(start));
                Tree ts = TreeFactory.createElementTree("String_Node_Str");
                ts.setAttribute(param, value);
                ts.addChild(tc);
                tree.addChild(ts, path[path.length - 1] + 1);
                if (t.isInvisible()) {
                    tc.hide();
                    ts.hide();
                }
            }
        } else {
            if (!addStyle) {
                Tree tc = TreeFactory.createTextTree(tree.getChild(path[path.length - 1]).split(start));
                Tree tc2 = TreeFactory.createTextTree(tc.split(end - start));
                Tree ts = tree.cloneNode();
                Tree ts2 = tree.cloneNode();
                ts.setAttribute(param, value);
                ts.addChild(tc);
                ts2.addChild(tc2);
                Tree parent = tree.getParent();
                parent.addChild(ts, path[path.length - 2] + 1);
                parent.addChild(ts2, path[path.length - 2] + 2);
                if (tree.isInvisible()) {
                    ts.hide();
                    ts2.hide();
                }
            } else {
                Tree t = tree.getChild(path[path.length - 1]);
                Tree tc = TreeFactory.createTextTree(t.split(start));
                Tree tc2 = TreeFactory.createTextTree(tc.split(end - start));
                Tree ts = TreeFactory.createElementTree("String_Node_Str");
                ts.setAttribute(param, value);
                ts.addChild(tc);
                tree.addChild(ts, path[path.length - 1] + 1);
                tree.addChild(tc2, path[path.length - 1] + 2);
                if (t.isInvisible()) {
                    tc.hide();
                    ts.hide();
                    tc2.hide();
                }
            }
        }
    }
}

Output:
                 Tree tc = tree.removeChild(path[path.length - 1]);
-                Tree ts = TreeFactory.createElementTree("String_Node_Str");
+                Tree ts = TreeFactory.createElementTree(SPAN);
                 ts.setAttribute(param, value);


Input:
private FeedbackSessionResultsBundle getFeedbackSessionResultsForUserWithParams(String feedbackSessionName, String courseId, String userEmail, UserType.Role role, CourseRoster roster, Map<String, String> params) throws EntityDoesNotExistException {
    boolean isIncludeResponseStatus = Boolean.parseBoolean(params.get("String_Node_Str"));
    boolean isComplete = (params.get("String_Node_Str") != null) ? false : true;
    boolean isFromSection = Boolean.parseBoolean(params.get("String_Node_Str"));
    boolean isToSection = Boolean.parseBoolean(params.get("String_Node_Str"));
    boolean isInSection = Boolean.parseBoolean(params.get("String_Node_Str"));
    String section = params.get("String_Node_Str");
    FeedbackSessionAttributes session = fsDb.getFeedbackSession(courseId, feedbackSessionName);
    if (session == null) {
        throw new EntityDoesNotExistException("String_Node_Str");
    }
    List<FeedbackQuestionAttributes> allQuestions = fqLogic.getFeedbackQuestionsForSession(feedbackSessionName, courseId);
    List<FeedbackResponseAttributes> responses = new ArrayList<FeedbackResponseAttributes>();
    Map<String, FeedbackQuestionAttributes> relevantQuestions = new HashMap<String, FeedbackQuestionAttributes>();
    Map<String, String> emailNameTable = new HashMap<String, String>();
    Map<String, String> emailTeamNameTable = new HashMap<String, String>();
    Map<String, boolean[]> visibilityTable = new HashMap<String, boolean[]>();
    Map<String, List<FeedbackResponseCommentAttributes>> responseComments = new HashMap<String, List<FeedbackResponseCommentAttributes>>();
    FeedbackSessionResponseStatus responseStatus = new FeedbackSessionResponseStatus();
    boolean isPrivateSessionNotCreatedByThisUser = session.isPrivateSession() && !session.isCreator(userEmail);
    if (isPrivateSessionNotCreatedByThisUser) {
        return new FeedbackSessionResultsBundle(session, responses, relevantQuestions, emailNameTable, emailTeamNameTable, visibilityTable, responseStatus, responseComments);
    }
    if (params.get("String_Node_Str") != null) {
        int questionNumber = Integer.parseInt(params.get("String_Node_Str"));
        FeedbackQuestionAttributes question = fqLogic.getFeedbackQuestion(feedbackSessionName, courseId, questionNumber);
        if (question != null) {
            List<FeedbackResponseAttributes> responsesForThisQn;
            boolean isPrivateSessionCreatedByThisUser = session.isCreator(userEmail) && session.isPrivateSession();
            if (isPrivateSessionCreatedByThisUser) {
                responsesForThisQn = frLogic.getFeedbackResponsesForQuestion(question.getId());
            } else {
                responsesForThisQn = frLogic.getViewableFeedbackResponsesForQuestionInSection(question, userEmail, Role.INSTRUCTOR, null);
            }
            boolean thisQuestionHasResponses = (!responsesForThisQn.isEmpty());
            if (thisQuestionHasResponses) {
                relevantQuestions.put(question.getId(), question);
                responses.addAll(responsesForThisQn);
                for (FeedbackResponseAttributes response : responsesForThisQn) {
                    addEmailNamePairsToTable(emailNameTable, response, question, roster);
                    addEmailTeamNamePairsToTable(emailTeamNameTable, response, question, roster);
                    addVisibilityToTable(visibilityTable, question, response, userEmail, roster);
                }
            }
        }
        FeedbackSessionResultsBundle results = new FeedbackSessionResultsBundle(session, responses, relevantQuestions, emailNameTable, emailTeamNameTable, visibilityTable, responseStatus, responseComments);
        return results;
    }
    Map<String, FeedbackQuestionAttributes> allQuestionsMap = new HashMap<String, FeedbackQuestionAttributes>();
    for (FeedbackQuestionAttributes qn : allQuestions) {
        allQuestionsMap.put(qn.getId(), qn);
    }
    List<FeedbackResponseAttributes> allResponses = new ArrayList<FeedbackResponseAttributes>();
    if (params.get("String_Node_Str") != null) {
        long range = Long.parseLong(params.get("String_Node_Str"));
        if (isInSection) {
            allResponses = frLogic.getFeedbackResponsesForSessionInSectionWithinRange(feedbackSessionName, courseId, section, range);
        } else if (isFromSection) {
            allResponses = frLogic.getFeedbackResponsesForSessionFromSectionWithinRange(feedbackSessionName, courseId, section, range);
        } else if (isToSection) {
            allResponses = frLogic.getFeedbackResponsesForSessionToSectionWithinRange(feedbackSessionName, courseId, section, range);
        } else {
            Assumption.fail("String_Node_Str");
        }
        if (allResponses.size() <= range) {
            isComplete = true;
        } else {
            for (FeedbackQuestionAttributes qn : allQuestions) {
                relevantQuestions.put(qn.getId(), qn);
            }
            FeedbackSessionResultsBundle results = new FeedbackSessionResultsBundle(session, responses, allQuestionsMap, emailNameTable, emailTeamNameTable, visibilityTable, responseStatus, responseComments, isComplete);
            return results;
        }
    } else {
        if (isInSection) {
            allResponses = frLogic.getFeedbackResponsesForSessionInSection(feedbackSessionName, courseId, section);
        } else if (isFromSection) {
            allResponses = frLogic.getFeedbackResponsesForSessionFromSection(feedbackSessionName, courseId, section);
        } else if (isToSection) {
            allResponses = frLogic.getFeedbackResponsesForSessionToSection(feedbackSessionName, courseId, section);
        } else {
            Assumption.fail("String_Node_Str");
        }
    }
    responseStatus = (section == null && isIncludeResponseStatus) ? getFeedbackSessionResponseStatus(session, roster, allQuestions, allResponses) : null;
    StudentAttributes student = null;
    Set<String> studentsEmailInTeam = new HashSet<String>();
    if (role == Role.STUDENT) {
        student = studentsLogic.getStudentForEmail(courseId, userEmail);
        List<StudentAttributes> studentsInTeam = studentsLogic.getStudentsForTeam(student.team, courseId);
        for (StudentAttributes teammates : studentsInTeam) {
            studentsEmailInTeam.add(teammates.email);
        }
    }
    for (FeedbackResponseAttributes response : allResponses) {
        FeedbackQuestionAttributes relatedQuestion = allQuestionsMap.get(response.feedbackQuestionId);
        if (relatedQuestion != null) {
            Boolean isVisibleResponse = false;
            if ((response.giverEmail.equals(userEmail) && (section == null || response.recipientSection.equals(section))) || (response.recipientEmail.equals(userEmail) && relatedQuestion.isResponseVisibleTo(FeedbackParticipantType.RECEIVER) && (section == null || response.giverSection.equals(section))) || (role == Role.INSTRUCTOR && relatedQuestion.isResponseVisibleTo(FeedbackParticipantType.INSTRUCTORS) && (section == null || (response.giverSection.equals(section) && response.recipientSection.equals(section)))) || (role == Role.STUDENT && relatedQuestion.isResponseVisibleTo(FeedbackParticipantType.STUDENTS))) {
                isVisibleResponse = true;
            } else if (role == Role.STUDENT && ((relatedQuestion.recipientType == FeedbackParticipantType.TEAMS && relatedQuestion.isResponseVisibleTo(FeedbackParticipantType.RECEIVER) && response.recipientEmail.equals(student.team)) || ((relatedQuestion.giverType == FeedbackParticipantType.TEAMS || relatedQuestion.isResponseVisibleTo(FeedbackParticipantType.OWN_TEAM_MEMBERS)) && studentsEmailInTeam.contains(response.giverEmail)) || (relatedQuestion.isResponseVisibleTo(FeedbackParticipantType.RECEIVER_TEAM_MEMBERS) && studentsEmailInTeam.contains(response.recipientEmail)))) {
                isVisibleResponse = true;
            }
            if (isVisibleResponse) {
                responses.add(response);
                relevantQuestions.put(relatedQuestion.getId(), relatedQuestion);
                addEmailNamePairsToTable(emailNameTable, response, relatedQuestion, roster);
                addEmailTeamNamePairsToTable(emailTeamNameTable, response, relatedQuestion, roster);
                addVisibilityToTable(visibilityTable, relatedQuestion, response, userEmail, roster);
            }
            isVisibleResponse = false;
        }
    }
    List<FeedbackResponseCommentAttributes> allResponseComments = frcLogic.getFeedbackResponseCommentForSession(courseId, feedbackSessionName);
    for (FeedbackResponseCommentAttributes frc : allResponseComments) {
        List<FeedbackResponseCommentAttributes> frcList = responseComments.get(frc.feedbackResponseId);
        if (frcList == null) {
            frcList = new ArrayList<FeedbackResponseCommentAttributes>();
            frcList.add(frc);
            responseComments.put(frc.feedbackResponseId, frcList);
        } else {
            frcList.add(frc);
        }
    }
    for (List<FeedbackResponseCommentAttributes> responseCommentList : responseComments.values()) {
        Collections.sort(responseCommentList, new ResponseCommentCreationDateComparator());
    }
    FeedbackSessionResultsBundle results = new FeedbackSessionResultsBundle(session, responses, relevantQuestions, emailNameTable, emailTeamNameTable, visibilityTable, responseStatus, responseComments, isComplete);
    return results;
}

Output:
             for (FeedbackQuestionAttributes qn : allQuestions) {
-                relevantQuestions.put(qn.getId(), qn);
+                if (qn.isResponseVisibleTo(FeedbackParticipantType.INSTRUCTORS)) {
+                    relevantQuestions.put(qn.getId(), qn);
+                }
             }


Input:
public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) {
    ItemStack itemstack = ItemStackUtil.getEmptyStack();
    Slot slot = this.inventorySlots.get(index);
    if (slot != null && slot.getHasStack()) {
        ItemStack itemstack1 = slot.getStack();
        itemstack = itemstack1.copy();
        if (index >= 0 && index < 4) {
            if (!this.mergeItemStack(itemstack1, 3, 39, true)) {
                return null;
            }
        } else if (index >= 3 && index < 30) {
            if (!this.mergeItemStack(itemstack1, 30, 39, false)) {
                return null;
            }
        } else if (index >= 30 && index < 39) {
            if (!this.mergeItemStack(itemstack1, 3, 30, false)) {
                return null;
            }
        } else if (!this.mergeItemStack(itemstack1, 3, 39, false)) {
            return null;
        }
        if (ItemStackUtil.isEmpty(itemstack1)) {
            slot.putStack(ItemStackUtil.getEmptyStack());
        } else {
            slot.onSlotChanged();
        }
        if (ItemStackUtil.getCount(itemstack) == ItemStackUtil.getCount(itemstack1)) {
            return ItemStackUtil.getEmptyStack();
        }
        slot.onTake(playerIn, itemstack1);
    }
    return itemstack;
}

Output:
             if (!this.mergeItemStack(itemstack1, 3, 39, true)) {
-                return null;
+                return ItemStackUtil.getEmptyStack();
             }


Input:
private boolean isPredictionOfEventCorrect(EntityRef character, ActivationRequest event) {
    LocationComponent location = character.getComponent(LocationComponent.class);
    CharacterComponent characterComponent = character.getComponent(CharacterComponent.class);
    Vector3f direction = characterComponent.getLookDirection();
    if (!(vectorsAreAboutEqual(event.getDirection(), direction))) {
        logger.error("String_Node_Str", event.getDirection(), direction);
    }
    direction = event.getDirection();
    Vector3f originPos = location.getWorldPosition();
    originPos.y += characterComponent.eyeOffset;
    if (!(vectorsAreAboutEqual(event.getOrigin(), originPos))) {
        logger.info("String_Node_Str", getPlayerNameFromCharacter(character), event.getOrigin(), originPos);
        return false;
    }
    if (event.isOwnedEntityUsage()) {
        if (!event.getUsedOwnedEntity().exists()) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
        if (!networkSystem.getOwnerEntity(event.getUsedOwnedEntity()).equals(networkSystem.getOwnerEntity(character))) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
    } else {
        if (event.getUsedOwnedEntity().exists()) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
    }
    if (event.isEventWithTarget()) {
        if (!event.getTarget().exists()) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
        HitResult result = physics.rayTrace(originPos, direction, characterComponent.interactionRange, filter);
        if (!result.isHit()) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
        EntityRef hitEntity = result.getEntity();
        if (!hitEntity.equals(event.getTarget())) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
        if (!(vectorsAreAboutEqual(event.getHitPosition(), result.getHitPoint()))) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
    } else {
        if (event.getTarget().exists()) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
        if (!(vectorsAreAboutEqual(event.getHitPosition(), originPos))) {
            logger.info("String_Node_Str", getPlayerNameFromCharacter(character));
            return false;
        }
    }
    return true;
}

Output:
     if (!(vectorsAreAboutEqual(event.getOrigin(), originPos))) {
-        logger.info("String_Node_Str", getPlayerNameFromCharacter(character), event.getOrigin(), originPos);
+        String msg = "String_Node_Str";
+        logger.info(msg, getPlayerNameFromCharacter(character), event.getOrigin(), originPos);
         return false;


Input:
public boolean operate(ITreeTraverserContext<INodePO> ctx, INodePO parent, INodePO node, boolean alreadyVisited) {
    Class<? extends INodePO> nodeType = null;
    if (node instanceof ICategoryPO || node instanceof ISpecTestCasePO || node instanceof ICapPO || node instanceof ITestSuitePO || node instanceof IExecTestCasePO || node instanceof ITestJobPO || node instanceof IRefTestSuitePO || node instanceof IComponentNamePO || node instanceof IEventExecTestCasePO) {
        nodeType = node.getClass();
    }
    if (nodeType != null) {
        Integer ccount = getAmount().get(nodeType);
        if (ccount == null) {
            ccount = new Integer(0);
        }
        Integer nCount = ccount + 1;
        getAmount().put(nodeType, nCount);
        getProgressMonitor().worked(1);
        if (getProgressMonitor().isCanceled()) {
            getProgressMonitor().done();
            throw new OperationCanceledException();
        }
    }
    return !alreadyVisited;
}

Output:
     Class<? extends INodePO> nodeType = null;
-    if (node instanceof ICategoryPO || node instanceof ISpecTestCasePO || node instanceof ICapPO || node instanceof ITestSuitePO || node instanceof IExecTestCasePO || node instanceof ITestJobPO || node instanceof IRefTestSuitePO || node instanceof IComponentNamePO || node instanceof IEventExecTestCasePO) {
+    if (node instanceof ICategoryPO || node instanceof ISpecTestCasePO || node instanceof ICapPO || node instanceof ITestSuitePO || node instanceof IExecTestCasePO || node instanceof ITestJobPO || node instanceof IRefTestSuitePO || node instanceof IEventExecTestCasePO) {
         nodeType = node.getClass();


Input:
protected Control createDialogArea(Composite parent) {
    DataEventDispatcher.getInstance().getDialogStatusListenerMgr().addListener(this);
    Plugin.getHelpSystem().setHelp(parent, ContextHelpIds.AUT_CONFIG_PROP_DIALOG);
    setTitle(Messages.ProjectWizardAutSettings);
    setMessage(Messages.ProjectWizardAUTData);
    try {
        Composite autConfigComposite = ToolkitSupportBP.getAutConfigComposite(m_toolkit, parent, SWT.H_SCROLL | SWT.V_SCROLL, m_autConfig.getConfigMap(), m_autName);
        autConfigComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
        if (autConfigComposite instanceof AutConfigComponent) {
            ((AutConfigComponent) autConfigComposite).setAutIdValidator(m_autIdValidator);
        }
    } catch (ToolkitPluginException e) {
        log.error(Messages.NoAUTConfigPageForToolkit + StringConstants.COLON + StringConstants.SPACE + String.valueOf(m_toolkit), e);
        ErrorHandlingUtil.createMessageDialog(MessageIDs.E_NO_AUTCONFIG_DIALOG);
    }
    return parent;
}

Output:
         if (autConfigComposite instanceof AutConfigComponent) {
-            ((AutConfigComponent) autConfigComposite).setAutIdValidator(m_autIdValidator);
+            m_autConfigComponent = ((AutConfigComponent) autConfigComposite);
+            m_autConfigComponent.setAutIdValidator(m_autIdValidator);
+            m_autConfigComponent.setAutConfignameValidator(m_autConfigNameValidator);
         }


Input:
public static void setupResourceManagers(OptionableProperties options, String defaultConfigFileName) throws FileNotFoundException, IOException {
    ConfigurationPropertiesFile configFile = getConfigFile(options, defaultConfigFileName);
    SwingResourceLoader.setupResourcesManager(configFile);
    boolean firstRun = true;
    while (!configFile.isValidSettlersFolderSet() || !trySettingUpResources(configFile)) {
        if (!firstRun) {
            JOptionPane.showMessageDialog(null, Labels.getString("String_Node_Str"));
        }
        firstRun = false;
        final SelectSettlerFolderDialog folderChooser = new SelectSettlerFolderDialog();
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                folderChooser.setVisible(true);
            }
        });
        File selectedFolder = folderChooser.waitForUserInput();
        if (selectedFolder == null) {
            String noFolderSelctedMessage = Labels.getString("String_Node_Str");
            JOptionPane.showMessageDialog(null, noFolderSelctedMessage);
            System.err.println(noFolderSelctedMessage);
            System.exit(1);
        }
        System.out.println(selectedFolder);
        try {
            configFile.setSettlersFolder(selectedFolder);
        } catch (IOException ex) {
            String errorSavingSettingsMessage = Labels.getString("String_Node_Str");
            System.err.println(errorSavingSettingsMessage);
            JOptionPane.showMessageDialog(null, errorSavingSettingsMessage);
            ex.printStackTrace();
        }
    }
    if (!firstRun) {
        SwingResourceLoader.setupResourcesManager(configFile);
    }
}

Output:
         firstRun = false;
-        final SelectSettlerFolderDialog folderChooser = new SelectSettlerFolderDialog();
+        final SelectSettlersFolderDialog folderChooser = new SelectSettlersFolderDialog();
         SwingUtilities.invokeLater(new Runnable() {


Input:
private void genCache() throws BirtException {
    this.dataSet.setCacheRowCount(4);
    DataEngine myDataEngine = newDataEngine();
    IResultIterator ri = getResultIterator1(myDataEngine);
    while (ri.next()) {
        for (int i = 0; i < bindingNameRow.length; i++) expectedValue.add(ri.getValue(bindingNameRow[i]));
        for (int i = 0; i < totalBeArray.length; i++) expectedValue.add(ri.getValue(bindingExprRow[i]));
    }
    ri.close();
    myDataEngine.shutdown();
}

Output:
     this.dataSet.setCacheRowCount(4);
-    DataEngine myDataEngine = newDataEngine();
+    myDataEngine = newDataEngine();
     IResultIterator ri = getResultIterator1(myDataEngine);


Input:
protected synchronized void configureResource() throws LifecycleException {
    List<ApplicationParameter> appParams = context.findApplicationParameters();
    ContextParameter contextParam;
    synchronized (appParams) {
        Iterator<ApplicationParameter> i = appParams.iterator();
        while (i.hasNext()) {
            ApplicationParameter appParam = i.next();
            contextParam = new EnvironmentProperty(appParam.getName(), appParam.getValue(), appParam.getDescription());
            webBundleDescriptor.addContextParameter(contextParam);
        }
    }
    ContextEnvironment[] envs = context.findEnvironments();
    EnvironmentProperty envEntry;
    for (int i = 0; i < envs.length; i++) {
        envEntry = new EnvironmentProperty(envs[i].getName(), envs[i].getValue(), envs[i].getDescription(), envs[i].getType());
        if (envs[i].getValue() != null) {
            envEntry.setValue(envs[i].getValue());
        }
        webBundleDescriptor.addEnvironmentProperty(envEntry);
        envProps.add(envEntry);
    }
    ContextResource[] resources = context.findResources();
    ResourceReferenceDescriptor resourceReference;
    Set<ResourceReferenceDescriptor> rrs = webBundleDescriptor.getResourceReferenceDescriptors();
    ResourcePrincipal rp;
    for (int i = 0; i < resources.length; i++) {
        resourceReference = new ResourceReferenceDescriptor(resources[i].getName(), resources[i].getDescription(), resources[i].getType());
        resourceReference.setJndiName(resources[i].getName());
        if (rrs != null) {
            for (ResourceReferenceDescriptor rr : rrs) {
                if (resources[i].getName().equals(rr.getName())) {
                    resourceReference.setJndiName(rr.getJndiName());
                    rp = rr.getResourcePrincipal();
                    if (rp != null) {
                        resourceReference.setResourcePrincipal(new ResourcePrincipal(rp.getName(), rp.getPassword()));
                    }
                }
            }
        }
        resourceReference.setAuthorization(resources[i].getAuth());
        webBundleDescriptor.addResourceReferenceDescriptor(resourceReference);
        resRefs.add(resourceReference);
    }
}

Output:
         resourceReference.setJndiName(resources[i].getName());
-        if (rrs != null) {
-            for (ResourceReferenceDescriptor rr : rrs) {
-                if (resources[i].getName().equals(rr.getName())) {
-                    resourceReference.setJndiName(rr.getJndiName());
-                    rp = rr.getResourcePrincipal();
-                    if (rp != null) {
-                        resourceReference.setResourcePrincipal(new ResourcePrincipal(rp.getName(), rp.getPassword()));
-                    }
+        for (ResourceReferenceDescriptor rr : rrs) {
+            if (resources[i].getName().equals(rr.getName())) {
+                resourceReference.setJndiName(rr.getJndiName());
+                rp = rr.getResourcePrincipal();
+                if (rp != null) {
+                    resourceReference.setResourcePrincipal(new ResourcePrincipal(rp.getName(), rp.getPassword()));
                 }


Input:
protected static void addComponentsByNameFilter(final IComponentsFactory compFac, Set<IComponent> componentSet, String nameFilter) {
    if (compFac == null || componentSet == null) {
        return;
    }
    if (nameFilter != null && !nameFilter.trim().isEmpty()) {
        Set<IComponent> components = compFac.getComponents();
        Iterator<IComponent> iter = components.iterator();
        String regex = getFilterRegex(nameFilter);
        while (iter.hasNext()) {
            IComponent xmlComponent = iter.next();
            if (!xmlComponent.getName().toLowerCase().matches(regex) && !xmlComponent.getLongName().toLowerCase().matches(regex)) {
                continue;
            } else {
                componentSet.add(xmlComponent);
            }
        }
    }
}

Output:
             IComponent xmlComponent = iter.next();
-            if (!xmlComponent.getName().toLowerCase().matches(regex) && !xmlComponent.getLongName().toLowerCase().matches(regex)) {
+            Matcher matcher = pattern.matcher(xmlComponent.getName().toLowerCase());
+            if (matcher.find()) {
+                resultByName.add(new ComponentHit(xmlComponent, matcher.start()));
                 continue;


Input:
public ODomain defaultDomain() {
    ODomain domain = new ODomain();
    if (getOdooVersion().getVersion_number() <= 7) {
        domain.add("String_Node_Str");
        domain.add("String_Node_Str", "String_Node_Str", getUser().getUser_id());
        domain.add("String_Node_Str", "String_Node_Str", getUser().getPartner_id());
    } else {
        domain.add("String_Node_Str", "String_Node_Str", getUser().getPartner_id());
    }
    return domain;
}

Output:
         domain.add("String_Node_Str", "String_Node_Str", getUser().getUser_id());
-        domain.add("String_Node_Str", "String_Node_Str", getUser().getPartner_id());
+        domain.add("String_Node_Str", "String_Node_Str", new JSONArray().put(getUser().getPartner_id()));
     } else {


Input:
public boolean requireTileSync(World world, TileEntity tile) {
    for (InfoProvider plugin : Wawla.entityProviders) if (plugin.requireTileSync(world, tile))
        return true;
    return false;
}

Output:
 public boolean requireTileSync(World world, TileEntity tile) {
-    for (InfoProvider plugin : Wawla.entityProviders) if (plugin.requireTileSync(world, tile))
+    for (InfoProvider plugin : Wawla.tileProviders) if (plugin.requireTileSync(world, tile))
         return true;


Input:
protected void onDetachedFromWindow() {
    super.onDetachedFromWindow();
    dismissPopup();
    mRecycler.clear();
    final ViewTreeObserver treeObserver = getViewTreeObserver();
    treeObserver.removeOnTouchModeChangeListener(this);
    if (mTextFilterEnabled && mPopup != null) {
        treeObserver.removeOnGlobalLayoutListener(this);
        mGlobalLayoutListenerAddedFilter = false;
    }
    if (mAdapter != null) {
        mAdapter.unregisterDataSetObserver(mDataSetObserver);
        mDataSetObserver = null;
    }
    if (mScrollStrictSpan != null) {
        mScrollStrictSpan.finish();
        mScrollStrictSpan = null;
    }
    if (mFlingStrictSpan != null) {
        mFlingStrictSpan.finish();
        mFlingStrictSpan = null;
    }
    if (mFlingRunnable != null) {
        removeCallbacks(mFlingRunnable);
    }
    if (mPositionScroller != null) {
        mPositionScroller.stop();
    }
    if (mClearScrollingCache != null) {
        removeCallbacks(mClearScrollingCache);
    }
    if (mPerformClick != null) {
        removeCallbacks(mPerformClick);
    }
    if (mTouchModeReset != null) {
        removeCallbacks(mTouchModeReset);
        mTouchModeReset.run();
    }
    mIsAttached = false;
}

Output:
     }
-    if (mAdapter != null) {
+    if (mAdapter != null && mDataSetObserver != null) {
         mAdapter.unregisterDataSetObserver(mDataSetObserver);


Input:
public boolean has(String permission, String world) {
    if (permission != null && permission.isEmpty()) {
        return true;
    }
    String expression = getMatchingExpression(permission, world);
    if (expression != null) {
        return this.explainExpression(expression);
    }
    return false;
}

Output:
     String expression = getMatchingExpression(permission, world);
-    if (expression != null) {
-        return this.explainExpression(expression);
-    }
-    return false;
+    return this.explainExpression(expression);
 }


Input:
private void animateY() {
    if (this.animate.getRepeatDur() <= (System.currentTimeMillis() - repeatDuration)) {
        stopAnimation();
    }
    if (info.getY() >= to_xml) {
        if (this.animate.getRepeatCount() == count) {
            stopAnimation();
        } else {
            count++;
            from_xml = Float.parseFloat(this.animate.getFrom());
            info.setY(from_xml);
        }
    } else {
        from_xml++;
        info.setY(from_xml);
        ruicontrol.relayout();
    }
}

Output:
     }
-    if (info.getY() >= to_xml) {
+    if (from_xml >= to_xml) {
         if (this.animate.getRepeatCount() == count) {


Input:
public void testPostcode() throws IOException, RemoteGeocodeException {
    final InputStream stream = Preconditions.checkNotNull(getClass().getResourceAsStream("String_Node_Str"));
    GeocodeResponse response = new GoogleMapsGeocoder("String_Node_Str").response2Graph(stream);
}

Output:
     final InputStream stream = Preconditions.checkNotNull(getClass().getResourceAsStream("String_Node_Str"));
-    GeocodeResponse response = new GoogleMapsGeocoder("String_Node_Str").response2Graph(stream);
+    new GoogleMapsGeocoder("String_Node_Str").response2Graph(stream);
 }


Input:
private void delayGateSignalChangeIfNeeded(EntityRef entity) {
    if (!entity.hasComponent(SignalDelayedActionComponent.class)) {
        SignalDelayedActionComponent delayedAction = new SignalDelayedActionComponent();
        long whenToLookAt;
        final ImmutableBlockLocation location = new ImmutableBlockLocation(entity.getComponent(BlockComponent.class).getPosition());
        if (gateLastSignalChangeTime.containsKey(location)) {
            whenToLookAt = gateLastSignalChangeTime.get(location) + GATE_MINIMUM_SIGNAL_CHANGE_INTERVAL;
        } else {
            whenToLookAt = worldProvider.getTime();
        }
        delayedAction.executeTime = whenToLookAt;
        entity.saveComponent(delayedAction);
    }
}

Output:
         delayedAction.executeTime = whenToLookAt;
-        entity.saveComponent(delayedAction);
+        entity.addComponent(delayedAction);
     }


Input:
public static List<Pair<String, String>> parse(String value) {
    List<Pair<String, String>> result = new ArrayList<Pair<String, String>>();
    if (Strings.isEmpty(value)) {
        return result;
    }
    for (String pair : value.split("String_Node_Str")) {
        String[] nameValue = pair.split("String_Node_Str");
        if (nameValue.length == 1) {
            result.add(pair(decode(nameValue[0]), "String_Node_Str"));
        }
        if (nameValue.length == 2) {
            result.add(pair(decode(nameValue[0]), decode(nameValue[1])));
        }
    }
    return result;
}

Output:
         if (nameValue.length == 1) {
-            result.add(pair(decode(nameValue[0]), "String_Node_Str"));
+            result.add(Pair.<String, String>pair(decode(nameValue[0]), "String_Node_Str"));
+            continue;
         }


Input:
public ParseTreeCodeGenerator getParseTreeCodeGenerator() {
    _parseTreeCodeGenerator = new JavaParseTreeCodeGenerator();
    return _parseTreeCodeGenerator;
}

Output:
 public ParseTreeCodeGenerator getParseTreeCodeGenerator() {
-    _parseTreeCodeGenerator = new JavaParseTreeCodeGenerator();
+    if (!(_parseTreeCodeGenerator instanceof JavaParseTreeCodeGenerator)) {
+        _parseTreeCodeGenerator = new JavaParseTreeCodeGenerator();
+    }
     return _parseTreeCodeGenerator;


Input:
Path extractDriver(Driver driver, Path fileToExtract) throws MojoExecutionException {
    String fileExtension = FilenameUtils.getExtension(fileToExtract.toString());
    try {
        switch(fileExtension) {
            case "String_Node_Str":
                mojo.getLog().info("String_Node_Str" + quote(fileToExtract) + "String_Node_Str");
                String extractedFilename = FilenameUtils.getBaseName(fileToExtract.toString());
                Path extractedFile = Paths.get(mojo.tempDirectory.getPath(), extractedFilename);
                try (FileInputStream fin = new FileInputStream(fileToExtract.toFile())) {
                    try (BufferedInputStream bin = new BufferedInputStream(fin)) {
                        try (BZip2CompressorInputStream input = new BZip2CompressorInputStream(bin)) {
                            FileUtils.copyInputStreamToFile(input, extractedFile.toFile());
                        }
                    }
                }
                decideToDeleteFile(fileToExtract);
                return extractDriver(driver, extractedFile);
            case "String_Node_Str":
                mojo.getLog().info("String_Node_Str" + quote(fileToExtract) + "String_Node_Str");
                String extractedFromGzFilename = FilenameUtils.getBaseName(fileToExtract.toString());
                Path extractedFromGzFile = Paths.get(mojo.tempDirectory.getPath(), extractedFromGzFilename);
                try (FileInputStream fin = new FileInputStream(fileToExtract.toFile())) {
                    try (BufferedInputStream bin = new BufferedInputStream(fin)) {
                        try (GzipCompressorInputStream input = new GzipCompressorInputStream(bin)) {
                            File file = new File(extractedFromGzFile.toFile(), extractedFromGzFilename);
                            if (!extractedFromGzFile.toFile().mkdirs()) {
                                throw new RuntimeException("String_Node_Str" + quote(extractedFromGzFile) + "String_Node_Str");
                            }
                            try (FileOutputStream out = new FileOutputStream(file)) {
                                IOUtils.copy(input, out);
                            }
                        }
                    }
                }
                decideToDeleteFile(fileToExtract);
                return extractedFromGzFile;
            case "String_Node_Str":
            case "String_Node_Str":
                mojo.getLog().info("String_Node_Str" + quote(fileToExtract) + "String_Node_Str");
                Path extractToDirectory = Paths.get(mojo.tempDirectory.getPath(), FilenameUtils.getBaseName(fileToExtract.toString()));
                if (!extractToDirectory.toFile().mkdirs()) {
                    throw new RuntimeException("String_Node_Str" + quote(extractToDirectory) + "String_Node_Str");
                }
                Pattern pattern = null;
                if (null != driver.getFileMatchInside()) {
                    pattern = Pattern.compile(driver.getFileMatchInside());
                }
                try (FileInputStream fin = new FileInputStream(fileToExtract.toFile())) {
                    try (BufferedInputStream bin = new BufferedInputStream(fin)) {
                        try (ArchiveInputStream aiStream = new ArchiveStreamFactory().createArchiveInputStream(fileExtension, bin)) {
                            ArchiveEntry entry;
                            while ((entry = aiStream.getNextEntry()) != null) {
                                String name = entry.getName();
                                if (pattern != null && entry.isDirectory()) {
                                } else if (entry.isDirectory()) {
                                    File directory = new File(extractToDirectory.toFile(), name);
                                    if (!directory.mkdirs()) {
                                        throw new RuntimeException("String_Node_Str" + quote(directory));
                                    }
                                } else {
                                    File file = null;
                                    if (entry instanceof TarArchiveEntry) {
                                        TarArchiveEntry archiveEntry = (TarArchiveEntry) entry;
                                        if (archiveEntry.isFile()) {
                                            file = new File(extractToDirectory.toFile(), name);
                                        }
                                    } else if (entry instanceof ZipArchiveEntry) {
                                        ZipArchiveEntry archiveEntry = (ZipArchiveEntry) entry;
                                        if (!archiveEntry.isUnixSymlink()) {
                                            file = new File(extractToDirectory.toFile(), name);
                                        }
                                    }
                                    if (pattern != null) {
                                        if (pattern.matcher(name).matches()) {
                                            file = new File(extractToDirectory.toFile(), FilenameUtils.getName(name));
                                        } else {
                                            file = null;
                                        }
                                    }
                                    if (file != null) {
                                        try (OutputStream out = new FileOutputStream(file)) {
                                            IOUtils.copy(aiStream, out);
                                        }
                                    }
                                }
                            }
                            decideToDeleteFile(fileToExtract);
                            return extractToDirectory;
                        }
                    }
                }
            case "String_Node_Str":
            case "String_Node_Str":
                mojo.getLog().info("String_Node_Str" + quote(fileToExtract) + "String_Node_Str");
                Path copyToDirectory = Paths.get(mojo.tempDirectory.getPath(), FilenameUtils.getName(fileToExtract.toString()));
                FileUtils.copyFile(fileToExtract.toFile(), copyToDirectory.toFile());
                decideToDeleteFile(fileToExtract);
                return mojo.tempDirectory.toPath();
            default:
                throw new UnsupportedOperationException("String_Node_Str" + fileExtension);
        }
    } catch (Exception e) {
        throw new InstallDriversMojoExecutionException("String_Node_Str" + quote(fileToExtract) + "String_Node_Str" + e.getMessage(), e, mojo, driver);
    }
}

Output:
             case "String_Node_Str":
-                mojo.getLog().info("String_Node_Str" + quote(fileToExtract) + "String_Node_Str");
-                Path copyToDirectory = Paths.get(mojo.tempDirectory.getPath(), FilenameUtils.getName(fileToExtract.toString()));
-                FileUtils.copyFile(fileToExtract.toFile(), copyToDirectory.toFile());
-                decideToDeleteFile(fileToExtract);
-                return mojo.tempDirectory.toPath();
+                if (mojo.keepDownloadedWebdrivers) {
+                    mojo.getLog().info("String_Node_Str" + quote(fileToExtract) + "String_Node_Str");
+                    Path copyToDirectory = Paths.get(mojo.tempDirectory.getPath(), FilenameUtils.getName(fileToExtract.toString()));
+                    FileUtils.copyFile(fileToExtract.toFile(), copyToDirectory.toFile());
+                    decideToDeleteFile(fileToExtract);
+                    return mojo.tempDirectory.toPath();
+                } else {
+                    return fileToExtract;
+                }
             default:


Input:
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
    if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED) {
        pw.println("String_Node_Str" + Binder.getCallingPid() + "String_Node_Str" + Binder.getCallingUid() + "String_Node_Str" + android.Manifest.permission.DUMP);
        return;
    }
    boolean isCheckin = false;
    boolean isUnpluggedOnly = false;
    boolean noOutput = false;
    int reqUid = -1;
    if (args != null) {
        for (String arg : args) {
            if ("String_Node_Str".equals(arg)) {
                isCheckin = true;
            } else if ("String_Node_Str".equals(arg)) {
                isUnpluggedOnly = true;
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mStats) {
                    mStats.resetAllStatsLocked();
                    pw.println("String_Node_Str");
                    noOutput = true;
                }
            } else if ("String_Node_Str".equals(arg)) {
                synchronized (mStats) {
                    mStats.writeSyncLocked();
                    pw.println("String_Node_Str");
                    noOutput = true;
                }
            } else if ("String_Node_Str".equals(arg)) {
                dumpHelp(pw);
                return;
            } else if ("String_Node_Str".equals(arg)) {
            } else if (arg.length() > 0 && arg.charAt(0) == '-') {
                pw.println("String_Node_Str" + arg);
                dumpHelp(pw);
                return;
            } else {
                try {
                    reqUid = mContext.getPackageManager().getPackageUid(arg, UserHandle.getCallingUserId());
                } catch (PackageManager.NameNotFoundException e) {
                    pw.println("String_Node_Str" + arg);
                    dumpHelp(pw);
                    return;
                }
            }
        }
    }
    if (noOutput) {
        return;
    }
    if (isCheckin) {
        List<ApplicationInfo> apps = mContext.getPackageManager().getInstalledApplications(0);
        synchronized (mStats) {
            mStats.dumpCheckinLocked(pw, apps, isUnpluggedOnly);
        }
    } else {
        synchronized (mStats) {
            mStats.dumpLocked(pw, isUnpluggedOnly, reqUid);
        }
    }
}

Output:
         synchronized (mStats) {
-            mStats.dumpCheckinLocked(pw, apps, isUnpluggedOnly);
+            mStats.dumpCheckinLocked(pw, apps, isUnpluggedOnly, includeHistory);
         }


Input:
public List<Site> getAtomsInSphereSorted(final Vect center, double dist) {
    List<Site> result = new ArrayList<Site>();
    List<Vect> recipL = this.getRecipLVects();
    List<Double> cFracCoords = center.getComponentsWRTBasis(this.getLatticeVectors());
    int maxx = (int) Math.ceil(cFracCoords.get(0) + dist * recipL.get(0).length() / (2 * Math.PI));
    int minx = (int) Math.floor(cFracCoords.get(0) - dist * recipL.get(0).length() / (2 * Math.PI));
    int maxy = (int) Math.ceil(cFracCoords.get(1) + dist * recipL.get(1).length() / (2 * Math.PI));
    int miny = (int) Math.floor(cFracCoords.get(1) - dist * recipL.get(1).length() / (2 * Math.PI));
    int maxz = (int) Math.ceil(cFracCoords.get(2) + dist * recipL.get(2).length() / (2 * Math.PI));
    int minz = (int) Math.floor(cFracCoords.get(2) - dist * recipL.get(2).length() / (2 * Math.PI));
    for (int i = minx; i <= maxx; i++) {
        for (int j = miny; j <= maxy; j++) {
            for (int k = minz; k <= maxz; k++) {
                for (Site s : basis) {
                    Vect trialCoords = s.getCoords().plus(latticeVectors.get(0).scalarMult((double) i)).plus(latticeVectors.get(1).scalarMult((double) j)).plus(latticeVectors.get(2).scalarMult((double) k));
                    if (center.getCartDistanceTo(trialCoords) < dist)
                        result.add(new Site(s.getElement(), trialCoords));
                }
            }
        }
    }
    Comparator<Site> c = new Comparator<Site>() {
        public int compare(Site s1, Site s2) {
            if (s1.getCoords().getCartDistanceTo(center) > s2.getCoords().getCartDistanceTo(center))
                return 1;
            else
                return -1;
        }
    };
    Collections.sort(result, c);
    return result;
}

Output:
                     Vect trialCoords = s.getCoords().plus(latticeVectors.get(0).scalarMult((double) i)).plus(latticeVectors.get(1).scalarMult((double) j)).plus(latticeVectors.get(2).scalarMult((double) k));
-                    if (center.getCartDistanceTo(trialCoords) < dist)
-                        result.add(new Site(s.getElement(), trialCoords));
+                    if (center.getCartDistanceTo(trialCoords) < dist) {
+                        result.add(s);
+                        continue;
+                    }
                 }


Input:
public Vector3f getOrientation() {
    return orientation;
}

Output:
 public Vector3f getOrientation() {
-    return orientation;
+    return orientation.clone();
 }


Input:
public void zoom(int x, int y) {
    MultiTouchAction multiTouch = new MultiTouchAction(this);
    int scrHeight = manage().window().getSize().getHeight();
    int yOffset = 100;
    if (y - 100 < 0) {
        yOffset = y;
    } else if (y + 100 > scrHeight) {
        yOffset = scrHeight - y;
    }
    TouchAction action0 = new TouchAction(this).press(x, y).moveTo(x, y - yOffset).release();
    TouchAction action1 = new TouchAction(this).press(x, y).moveTo(x, y + yOffset).release();
    multiTouch.add(action0).add(action1);
    multiTouch.perform();
}

Output:
     }
-    TouchAction action0 = new TouchAction(this).press(x, y).moveTo(x, y - yOffset).release();
-    TouchAction action1 = new TouchAction(this).press(x, y).moveTo(x, y + yOffset).release();
+    TouchAction action0 = new TouchAction(this).press(x, y).moveTo(0, -yOffset).release();
+    TouchAction action1 = new TouchAction(this).press(x, y).moveTo(0, yOffset).release();
     multiTouch.add(action0).add(action1);


Input:
public Object getObjectById(Object arg0) {
    checkOpen();
    long oid = (Long) arg0;
    ZooPCImpl co = cache.findCoByOID(oid);
    if (co != null) {
        if (co.jdoZooIsStateHollow() && !co.jdoZooIsDeleted()) {
            co.jdoZooGetNode().refreshObject(co);
        }
        return co;
    }
    for (Node n : nodes) {
        co = n.loadInstanceById(oid);
        if (co != null) {
            break;
        }
    }
    return co;
}

Output:
 public Object getObjectById(Object arg0) {
-    checkOpen();
+    checkActive();
     long oid = (Long) arg0;


Input:
public NonRoleArgList leaveDisambiguation(ScribNode parent, ScribNode child, NameDisambiguator disamb, ScribNode visited) throws ScribbleException {
    NonRoleArgList nral = (NonRoleArgList) super.leaveDisambiguation(parent, child, disamb, visited);
    ProtocolDecl<?> pd = getTargetProtocolDecl((Do<?>) parent, disamb);
    Iterator<NonRoleArg> args = nral.getDoArgs().iterator();
    for (NonRoleParamDecl<?> param : pd.header.paramdecls.getDecls()) {
        NonRoleParamKind kind = param.kind;
        NonRoleArg arg = args.next();
        if (kind.equals(SigKind.KIND)) {
            if (!arg.val.isMessageSigNameNode() && !arg.val.isMessageSigNameNode()) {
                throw new RuntimeException("String_Node_Str" + arg + "String_Node_Str" + kind);
            }
        } else if (kind.equals(DataTypeKind.KIND)) {
            if (!arg.val.isDataTypeNameNode()) {
                throw new RuntimeException("String_Node_Str" + arg + "String_Node_Str" + kind);
            }
        } else {
            throw new RuntimeException("String_Node_Str" + kind);
        }
    }
    return nral;
}

Output:
         NonRoleArg arg = args.next();
-        if (kind.equals(SigKind.KIND)) {
-            if (!arg.val.isMessageSigNameNode() && !arg.val.isMessageSigNameNode()) {
-                throw new RuntimeException("String_Node_Str" + arg + "String_Node_Str" + kind);
+        if (arg.val.isParamNode()) {
+            if (!((NonRoleParamNode<?>) arg.val).kind.equals(kind)) {
+                throw new ScribbleException("String_Node_Str" + arg + "String_Node_Str" + kind);
+            }
+        } else if (kind.equals(SigKind.KIND)) {
+            if (!arg.val.isMessageSigNode() && !arg.val.isMessageSigNameNode()) {
+                throw new ScribbleException("String_Node_Str" + arg + "String_Node_Str" + kind);
             }


Input:
public static void loadSkillTrees() {
    YamlConfiguration MWConfig;
    MyPetUtil.getDebugLogger().info("String_Node_Str" + configPath);
    File skillFile;
    skillFile = new File(configPath + File.separator + "String_Node_Str");
    MyPetSkillTreeMobType skillTreeMobType = new MyPetSkillTreeMobType("String_Node_Str");
    skillTreeMobTypes.put("String_Node_Str", skillTreeMobType);
    if (skillFile.exists()) {
        MWConfig = new YamlConfiguration(skillFile);
        loadSkillTree(MWConfig, skillTreeMobType);
        MyPetUtil.getDebugLogger().info("String_Node_Str");
    }
    for (MyPetType mobType : MyPetType.values()) {
        skillFile = new File(configPath + File.separator + mobType.getTypeName() + "String_Node_Str");
        skillTreeMobType = new MyPetSkillTreeMobType(mobType.getTypeName().toLowerCase());
        skillTreeMobTypes.put(mobType.getTypeName().toLowerCase(), skillTreeMobType);
        if (!skillFile.exists()) {
            if (!skillTreeMobType.getMobTypeName().equals("String_Node_Str")) {
                addDefault(skillTreeMobType);
            }
            manageInheritance(skillTreeMobType);
            continue;
        }
        MWConfig = new YamlConfiguration(skillFile);
        loadSkillTree(MWConfig, skillTreeMobType);
        MyPetUtil.getDebugLogger().info("String_Node_Str" + mobType.getTypeName().toLowerCase() + "String_Node_Str");
    }
}

Output:
     for (MyPetType mobType : MyPetType.values()) {
-        skillFile = new File(configPath + File.separator + mobType.getTypeName() + "String_Node_Str");
-        skillTreeMobType = new MyPetSkillTreeMobType(mobType.getTypeName().toLowerCase());
+        skillFile = new File(configPath + File.separator + mobType.getTypeName().toLowerCase() + "String_Node_Str");
+        skillTreeMobType = new MyPetSkillTreeMobType(mobType.getTypeName());
         skillTreeMobTypes.put(mobType.getTypeName().toLowerCase(), skillTreeMobType);


Input:
public void characters(String value) {
    if (value.length() > 0) {
        getNode().appendChild(document.createTextNode(value));
    }
}

Output:
     if (value.length() > 0) {
-        getNode().appendChild(document.createTextNode(value));
+        node.appendChild(document.createTextNode(value));
     }


Input:
private Calendar checkIfValueIsISO8601Date(String value) {
    if (StringUtils.isBlank(value)) {
        return null;
    }
    Calendar date = null;
    try {
        Matcher dateTimeMatcher = ISO8601Pattern.matcher(value);
        if (dateTimeMatcher.matches()) {
            StringBuilder pattern = new StringBuilder("String_Node_Str");
            String timeZoneId = null;
            if (dateTimeMatcher.groupCount() >= 7 && dateTimeMatcher.group(7) != null) {
                pattern.append("String_Node_Str");
            }
            if (dateTimeMatcher.groupCount() >= 8 && dateTimeMatcher.group(8) != null) {
                if (!"String_Node_Str".equals(dateTimeMatcher.group(8))) {
                    timeZoneId = "String_Node_Str" + dateTimeMatcher.group(8);
                    value = value.replace(dateTimeMatcher.group(8), "String_Node_Str");
                } else {
                    timeZoneId = "String_Node_Str";
                    value = value.replace("String_Node_Str", "String_Node_Str");
                }
            }
            date = (Calendar) DateUtils.fromString(value, pattern.toString());
            if (timeZoneId != null) {
                TimeZone timeZone = TimeZone.getTimeZone(timeZoneId);
                if (!timeZone.getID().equals(timeZoneId)) {
                    throw new ParseException("String_Node_Str" + value);
                }
                date.setTimeZone(timeZone);
            }
        } else {
            Matcher dateMatcher = ISO8601DatePattern.matcher(value);
            if (dateMatcher.matches()) {
                date = (Calendar) DateUtils.fromString(value, ISO8601_DATE_FORMAT);
            }
        }
    } catch (Exception e) {
        return null;
    }
    return date;
}

Output:
         if (dateTimeMatcher.matches()) {
-            StringBuilder pattern = new StringBuilder("String_Node_Str");
-            String timeZoneId = null;
-            if (dateTimeMatcher.groupCount() >= 7 && dateTimeMatcher.group(7) != null) {
-                pattern.append("String_Node_Str");
-            }
-            if (dateTimeMatcher.groupCount() >= 8 && dateTimeMatcher.group(8) != null) {
-                if (!"String_Node_Str".equals(dateTimeMatcher.group(8))) {
-                    timeZoneId = "String_Node_Str" + dateTimeMatcher.group(8);
-                    value = value.replace(dateTimeMatcher.group(8), "String_Node_Str");
-                } else {
-                    timeZoneId = "String_Node_Str";
-                    value = value.replace("String_Node_Str", "String_Node_Str");
-                }
-            }
-            date = (Calendar) DateUtils.fromString(value, pattern.toString());
-            if (timeZoneId != null) {
-                TimeZone timeZone = TimeZone.getTimeZone(timeZoneId);
-                if (!timeZone.getID().equals(timeZoneId)) {
-                    throw new ParseException("String_Node_Str" + value);
-                }
-                date.setTimeZone(timeZone);
-            }
+            date = ISO8601.parse(value);
         } else {


Input:
private EntityManagerFactoryImpl getEntityManagerFactory() {
    Map<String, Object> props = new HashMap<String, Object>();
    String persistenceUnit = "String_Node_Str";
    props.put(Constants.PERSISTENCE_UNIT_NAME, persistenceUnit);
    props.put(PersistenceProperties.KUNDERA_CLIENT_FACTORY, "String_Node_Str");
    props.put(PersistenceProperties.KUNDERA_NODES, "String_Node_Str");
    props.put(PersistenceProperties.KUNDERA_PORT, "String_Node_Str");
    props.put(PersistenceProperties.KUNDERA_KEYSPACE, "String_Node_Str");
    ApplicationMetadata appMetadata = KunderaMetadata.INSTANCE.getApplicationMetadata();
    PersistenceUnitMetadata puMetadata = new PersistenceUnitMetadata();
    puMetadata.setPersistenceUnitName(persistenceUnit);
    Properties p = new Properties();
    p.putAll(props);
    puMetadata.setProperties(p);
    Map<String, PersistenceUnitMetadata> metadata = new HashMap<String, PersistenceUnitMetadata>();
    metadata.put("String_Node_Str", puMetadata);
    appMetadata.addPersistenceUnitMetadata(metadata);
    Map<String, List<String>> clazzToPu = new HashMap<String, List<String>>();
    List<String> pus = new ArrayList<String>();
    pus.add(persistenceUnit);
    clazzToPu.put(CassandraEntitySample.class.getName(), pus);
    appMetadata.setClazzToPuMap(clazzToPu);
    EntityMetadata m = new EntityMetadata(CassandraEntitySample.class);
    TableProcessor processor = new TableProcessor(null);
    processor.process(CassandraEntitySample.class, m);
    m.setPersistenceUnit(persistenceUnit);
    MetamodelImpl metaModel = new MetamodelImpl();
    metaModel.addEntityMetadata(CassandraEntitySample.class, m);
    appMetadata.getMetamodelMap().put(persistenceUnit, metaModel);
    metaModel.assignManagedTypes(appMetadata.getMetaModelBuilder(persistenceUnit).getManagedTypes());
    metaModel.assignEmbeddables(appMetadata.getMetaModelBuilder(persistenceUnit).getEmbeddables());
    metaModel.assignMappedSuperClass(appMetadata.getMetaModelBuilder(persistenceUnit).getMappedSuperClassTypes());
    EntityManagerFactoryImpl emf = new EntityManagerFactoryImpl(persistenceUnit, props);
    String[] persistenceUnits = new String[] { persistenceUnit };
    new ClientFactoryConfiguraton(null, persistenceUnits).configure();
    CoreMetadata coreMetadata = new CoreMetadata();
    coreMetadata.setLazyInitializerFactory(new CglibLazyInitializerFactory());
    KunderaMetadata.INSTANCE.setCoreMetadata(coreMetadata);
    return emf;
}

Output:
     appMetadata.setClazzToPuMap(clazzToPu);
-    EntityMetadata m = new EntityMetadata(CassandraEntitySample.class);
-    TableProcessor processor = new TableProcessor(null);
-    processor.process(CassandraEntitySample.class, m);
-    m.setPersistenceUnit(persistenceUnit);
+    MetadataBuilder metadataBuilder = new MetadataBuilder(persistenceUnit, ThriftClientFactory.class.getSimpleName(), null);
     MetamodelImpl metaModel = new MetamodelImpl();


Input:
public void testCustom() throws Exception {
    project.setProperty("String_Node_Str", "String_Node_Str");
    IvyResolve res = new IvyResolve();
    res.setValidate(false);
    res.setProject(project);
    res.execute();
    publish.setPubrevision("String_Node_Str");
    publish.setPubdate("String_Node_Str");
    publish.setResolver("String_Node_Str");
    publish.setValidate(false);
    File art = new File("String_Node_Str");
    FileUtil.copy(new File("String_Node_Str"), art, null);
    publish.execute();
    assertTrue(new File("String_Node_Str").exists());
    File dest = new File("String_Node_Str");
    assertTrue(dest.exists());
    assertTrue(new File("String_Node_Str").exists());
    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(new IvySettings(), dest.toURL(), false);
    assertEquals("String_Node_Str", md.getModuleRevisionId().getRevision());
    assertEquals("String_Node_Str", md.getModuleRevisionId().getAttribute("String_Node_Str"));
    assertEquals("String_Node_Str", md.getConfiguration("String_Node_Str").getAttribute("String_Node_Str"));
    assertEquals("String_Node_Str", md.getDependencies()[0].getAttribute("String_Node_Str"));
    String expected = FileUtil.readEntirely(new BufferedReader(new InputStreamReader(IvyPublishTest.class.getResourceAsStream("String_Node_Str"))));
    String updated = FileUtil.readEntirely(new BufferedReader(new FileReader(dest)));
    assertEquals(expected, updated);
}

Output:
     assertTrue(new File("String_Node_Str").exists());
-    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(new IvySettings(), dest.toURL(), false);
+    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(new IvySettings(), dest.toURI().toURL(), false);
     assertEquals("String_Node_Str", md.getModuleRevisionId().getRevision());


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

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


Input:
public Entry next() {
    tmp.setIndex(current.getIndex());
    if (next != null) {
        current.setIndex(next.getIndex());
        advance(next);
        if (next.getIndex() < 0) {
            next = null;
        }
    } else {
        current = null;
    }
    return tmp;
}

Output:
 public Entry next() {
-    tmp.setIndex(current.getIndex());
-    if (next != null) {
-        current.setIndex(next.getIndex());
-        advance(next);
-        if (next.getIndex() < 0) {
-            next = null;
-        }
-    } else {
-        current = null;
+    int index = next.getIndex();
+    if (index < 0) {
+        throw new NoSuchElementException();
     }


Input:
public static ResourceLocation generateTexture(OutfitPart part) {
    String texturePath = "String_Node_Str" + part.basePart + "String_Node_Str";
    ResourceLocation texture = new ResourceLocation("String_Node_Str" + part.basePart + "String_Node_Str" + part.tints[0] + "String_Node_Str" + part.tints[1] + "String_Node_Str" + part.tints[2]);
    Minecraft.getMinecraft().getTextureManager().loadTexture(texture, new TripleTintTexture("String_Node_Str", texturePath, part.tints[0], part.tints[1], part.tints[2]));
    return texture;
}

Output:
     String texturePath = "String_Node_Str" + part.basePart + "String_Node_Str";
-    ResourceLocation texture = new ResourceLocation("String_Node_Str" + part.basePart + "String_Node_Str" + part.tints[0] + "String_Node_Str" + part.tints[1] + "String_Node_Str" + part.tints[2]);
-    Minecraft.getMinecraft().getTextureManager().loadTexture(texture, new TripleTintTexture("String_Node_Str", texturePath, part.tints[0], part.tints[1], part.tints[2]));
+    ResourceLocation texture = new ResourceLocation(Tails.MOD_ID, "String_Node_Str" + part.basePart + "String_Node_Str" + part.tints[0] + "String_Node_Str" + part.tints[1] + "String_Node_Str" + part.tints[2] + "String_Node_Str" + UUID.randomUUID());
+    Minecraft.getMinecraft().getTextureManager().loadTexture(texture, new TripleTintTexture(Tails.MOD_ID, texturePath, part.tints[0], part.tints[1], part.tints[2]));
     return texture;


Input:
private void importPoiCell(NRow row, Cell poiCell) {
    NCell cell = row.getCell(poiCell.getColumnIndex());
    switch(poiCell.getCellType()) {
        case Cell.CELL_TYPE_NUMERIC:
            cell.setNumberValue(poiCell.getNumericCellValue());
            break;
        case Cell.CELL_TYPE_STRING:
            cell.setStringValue(poiCell.getStringCellValue());
            break;
        case Cell.CELL_TYPE_BOOLEAN:
            cell.setBooleanValue(poiCell.getBooleanCellValue());
            break;
        case Cell.CELL_TYPE_FORMULA:
            cell.setFormulaValue(poiCell.getCellFormula());
            break;
        case Cell.CELL_TYPE_ERROR:
            cell.setErrorValue(convertErrorCode(poiCell.getErrorCellValue()));
            break;
        case Cell.CELL_TYPE_BLANK:
            break;
        default:
    }
    if (!importedStyle.containsKey(poiCell.getCellStyle().getIndex())) {
        cell.setCellStyle(importXSSFCellStyle((XSSFCellStyle) poiCell.getCellStyle()));
    }
}

Output:
     }
-    if (!importedStyle.containsKey(poiCell.getCellStyle().getIndex())) {
-        cell.setCellStyle(importXSSFCellStyle((XSSFCellStyle) poiCell.getCellStyle()));
-    }
+    cell.setCellStyle(importXSSFCellStyle((XSSFCellStyle) poiCell.getCellStyle()));
 }


Input:
public void run() {
    try {
        status.setTextButtonState(false);
        status.setTextButtonText("String_Node_Str");
        Email.testEmail();
        long timeStarted = System.currentTimeMillis();
        while (System.currentTimeMillis() - timeStarted < 60000) {
            status.setTextButtonText((60 - (int) ((System.currentTimeMillis() - timeStarted) / 1000)) + "String_Node_Str");
            Thread.sleep(200);
        }
        status.setTextButtonText("String_Node_Str");
        status.setTextButtonState(true);
    } catch (Exception e) {
        System.out.println("String_Node_Str");
        e.printStackTrace();
        status.setTextButtonText("String_Node_Str");
        status.setTextButtonState(true);
    }
}

Output:
         status.setTextButtonText("String_Node_Str");
-        Email.testEmail();
+        if (!Email.testEmail()) {
+            status.setTextButtonText("String_Node_Str");
+            status.setTextButtonState(true);
+            return;
+        }
         long timeStarted = System.currentTimeMillis();


Input:
public HyperlinkDef parseHyperLink(IContent content) {
    IHyperlinkAction linkaction = content.getHyperlinkAction();
    if (linkaction != null) {
        String toolTip = linkaction.getTooltip();
        if (linkaction.getType() == IHyperlinkAction.ACTION_BOOKMARK) {
            String bookmark = linkaction.getBookmark();
            if (ExcelUtil.isValidBookmarkName(bookmark)) {
                return new HyperlinkDef(linkaction.getBookmark(), IHyperlinkAction.ACTION_BOOKMARK, null, toolTip);
            } else {
                return null;
            }
        } else if (linkaction.getType() == IHyperlinkAction.ACTION_HYPERLINK) {
            return new HyperlinkDef(linkaction.getHyperlink(), IHyperlinkAction.ACTION_HYPERLINK, null, toolTip);
        } else if (linkaction.getType() == IHyperlinkAction.ACTION_DRILLTHROUGH) {
            Action act = new Action(linkaction);
            IHTMLActionHandler actionHandler = null;
            Object ac = service.getOption(IRenderOption.ACTION_HANDLER);
            if (ac != null && ac instanceof IHTMLActionHandler) {
                actionHandler = (IHTMLActionHandler) ac;
                String url = actionHandler.getURL(act, service.getReportContext());
                if (null != url && url.length() > 0) {
                    return new HyperlinkDef(url, IHyperlinkAction.ACTION_DRILLTHROUGH, null, toolTip);
                } else {
                    return null;
                }
            }
        }
    }
    return null;
}

Output:
 public HyperlinkDef parseHyperLink(IContent content) {
-    IHyperlinkAction linkaction = content.getHyperlinkAction();
-    if (linkaction != null) {
-        String toolTip = linkaction.getTooltip();
-        if (linkaction.getType() == IHyperlinkAction.ACTION_BOOKMARK) {
-            String bookmark = linkaction.getBookmark();
-            if (ExcelUtil.isValidBookmarkName(bookmark)) {
-                return new HyperlinkDef(linkaction.getBookmark(), IHyperlinkAction.ACTION_BOOKMARK, null, toolTip);
-            } else {
-                return null;
-            }
-        } else if (linkaction.getType() == IHyperlinkAction.ACTION_HYPERLINK) {
-            return new HyperlinkDef(linkaction.getHyperlink(), IHyperlinkAction.ACTION_HYPERLINK, null, toolTip);
-        } else if (linkaction.getType() == IHyperlinkAction.ACTION_DRILLTHROUGH) {
-            Action act = new Action(linkaction);
-            IHTMLActionHandler actionHandler = null;
-            Object ac = service.getOption(IRenderOption.ACTION_HANDLER);
-            if (ac != null && ac instanceof IHTMLActionHandler) {
-                actionHandler = (IHTMLActionHandler) ac;
-                String url = actionHandler.getURL(act, service.getReportContext());
-                if (null != url && url.length() > 0) {
-                    return new HyperlinkDef(url, IHyperlinkAction.ACTION_DRILLTHROUGH, null, toolTip);
-                } else {
-                    return null;
+    HyperlinkDef hyperlink = null;
+    IHyperlinkAction linkAction = content.getHyperlinkAction();
+    if (linkAction != null) {
+        String tooltip = linkAction.getTooltip();
+        String bookmark = linkAction.getBookmark();
+        IReportRunnable reportRunnable = service.getReportRunnable();
+        IReportContext reportContext = service.getReportContext();
+        IHTMLActionHandler actionHandler = (IHTMLActionHandler) service.getOption(RenderOption.ACTION_HANDLER);
+        switch(linkAction.getType()) {
+            case IHyperlinkAction.ACTION_BOOKMARK:
+                if (ExcelUtil.isValidBookmarkName(bookmark)) {
+                    hyperlink = new HyperlinkDef(bookmark, IHyperlinkAction.ACTION_BOOKMARK, null, tooltip);
                 }


Input:
public void startLoading() {
    boolean recreateDisplay = Display.isResizable();
    if (recreateDisplay)
        Display.setResizable(false);
    invokeRenderProgressCallback("String_Node_Str");
    for (String texName : texturesToLoad.keySet()) {
        textures.put(texturesToLoad.get(texName), Texture.fromResource(texName));
        numLoaded++;
        invokeRenderProgressCallback(texName);
    }
    for (String fontName : fontsToLoad.keySet()) {
        String[] parts = fontName.split("String_Node_Str");
        TrueTypeFont font;
        int style = Integer.parseInt(parts[1]);
        int size = Integer.parseInt(parts[2]);
        if (parts[0].endsWith("String_Node_Str")) {
            InputStream ttfStream = FileUtils.getResource(parts[0]);
            font = new TrueTypeFont(ttfStream, style, size, true);
        } else {
            font = new TrueTypeFont(parts[0], style, size);
        }
        fonts.put(fontsToLoad.get(fontName), font);
        numLoaded++;
        invokeRenderProgressCallback(fontName);
    }
    for (String soundName : soundsToLoad.keySet()) {
        sounds.put(soundsToLoad.get(soundName), new Sound(soundName));
        numLoaded++;
        invokeRenderProgressCallback(soundName);
    }
    for (String modelName : modelsToLoad.keySet()) {
        models.put(modelsToLoad.get(modelName), Model.load(modelName));
        numLoaded++;
        invokeRenderProgressCallback(modelName);
    }
    invokeRenderProgressCallback("String_Node_Str");
    if (recreateDisplay)
        Display.setResizable(true);
}

Output:
 public void startLoading() {
-    boolean recreateDisplay = Display.isResizable();
+    if (texturesToLoad.size() + soundsToLoad.size() + fontsToLoad.size() + modelsToLoad.size() == 0)
+        return;
+    renderedProgress = 0;
+    numLoaded = 0;
+    boolean recreateDisplay = Display.isResizable() && !Display.isFullScreen();
     if (recreateDisplay)


Input:
public List<PaymentScheduleLine> getPaymentScheduleLineToDebit(Company company, LocalDate debitDate, PaymentMode paymentMode, Currency currency) {
    return PaymentScheduleLine.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", company, debitDate.getDayOfMonth(), debitDate, debitDate, currency, paymentMode).fetch();
}

Output:
 public List<PaymentScheduleLine> getPaymentScheduleLineToDebit(Company company, LocalDate debitDate, PaymentMode paymentMode, Currency currency) {
-    return PaymentScheduleLine.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", company, debitDate.getDayOfMonth(), debitDate, debitDate, currency, paymentMode).fetch();
+    return PaymentScheduleLine.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", company, debitDate, currency, paymentMode).fetch();
 }


Input:
public Comparable<T> getMinimumValue() {
    return (valueDomain != null) ? (Comparable<T>) valueDomain.getMinValue() : null;
}

Output:
 public Comparable<T> getMinimumValue() {
-    return (valueDomain != null) ? (Comparable<T>) valueDomain.getMinValue() : null;
+    return (valueDomain != null && valueDomain.getElementType() == valueClass) ? (Comparable<T>) valueDomain.getMinValue() : null;
 }


Input:
public boolean remove(Object key) {
    if (key == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    return (store.remove(key) == null);
}

Output:
     }
-    return (store.remove(key) == null);
+    return (store.remove(key) != null);
 }


Input:
public void actionPerformed(ActionEvent actionEvent) {
    final ProductNodeList<Product> products = new ProductNodeList<>();
    Product[] openedProducts = SnapApp.getDefault().getProductManager().getProducts();
    for (Product prod : openedProducts) {
        products.add(prod);
    }
    Product product = SnapApp.getDefault().getSelectedProduct(EXPLORER);
    if (product == null) {
        product = products.getAt(0);
    }
    if (MultisizeIssue.isMultiSize(product)) {
        final Product resampledProduct = MultisizeIssue.maybeResample(product);
        if (resampledProduct != null) {
            product = resampledProduct;
            products.add(resampledProduct);
        }
    }
    Collection<? extends RasterDataNode> selectedRasters = Utilities.actionsGlobalContext().lookupAll(RasterDataNode.class);
    String expression = selectedRasters.stream().map(ProductNode::getName).collect(Collectors.joining("String_Node_Str"));
    BandMathsDialog bandMathsDialog = new BandMathsDialog(product, products, expression, HELP_ID);
    bandMathsDialog.show();
}

Output:
     }
-    if (MultisizeIssue.isMultiSize(product)) {
-        final Product resampledProduct = MultisizeIssue.maybeResample(product);
+    if (MultiSizeIssue0.isMultiSize(product)) {
+        final Product resampledProduct = MultiSizeIssue0.maybeResample(product);
         if (resampledProduct != null) {