Input:
public static double distance(Vector3 a, Vector3 b) {
    double xzDist = Vector2.distance(a.toVector2(), b.toVector2());
    return Math.sqrt(Math.pow(xzDist, 2) + Math.pow(Math.abs(Vector3.subtract(a, b).getY()), 2));
}

Output:
     double xzDist = Vector2.distance(a.toVector2(), b.toVector2());
-    return Math.sqrt(Math.pow(xzDist, 2) + Math.pow(Math.abs(Vector3.subtract(a, b).getY()), 2));
+    return Math.sqrt(Math.pow(xzDist, 2) + Math.pow(Math.abs(Vector3.subtract(a, b).y), 2));
 }


Input:
public void addAdditonalFile(TestStructure testStructure, String fileName) throws SystemException {
    if (logger.isInfoEnabled()) {
        logger.info("String_Node_Str" + testStructure.getFullName());
    }
    TestProject testProject = testStructure.getRootElement();
    SVNWCClient wcClient = getSVNClientManager(testProject).getWCClient();
    File file = new File(getFile(testStructure), fileName);
    try {
        final SVNStatus info = getSVNClientManager(testProject).getStatusClient().doStatus(file, false);
        if (!info.isVersioned()) {
            wcClient.doAdd(file, false, false, false, SVNDepth.INFINITY, true, true);
        }
    } catch (Exception e) {
        logger.warn(e.getMessage(), e);
    }
}

Output:
 public void addAdditonalFile(TestStructure testStructure, String fileName) throws SystemException {
-    if (logger.isInfoEnabled()) {
-        logger.info("String_Node_Str" + testStructure.getFullName());
-    }
+    logger.trace("String_Node_Str" + testStructure.getFullName());
     TestProject testProject = testStructure.getRootElement();


Input:
protected String getParamValue() {
    if (getRelative())
        return "String_Node_Str" + getValue().intValue() + "String_Node_Str";
    else
        return "String_Node_Str" + getValue().intValue();
}

Output:
 protected String getParamValue() {
-    if (getRelative())
+    if (getRelative() != null && !getRelative())
         return "String_Node_Str" + getValue().intValue() + "String_Node_Str";


Input:
private static long hashLength65Plus(byte[] bytes, int offset, int length) {
    final int seed = 81;
    long x = seed;
    long y = seed * K1 + 113;
    long z = shiftMix(y * K2 + 113) * K2;
    long[] v = new long[2], w = new long[2];
    x = x * K2 + load64(bytes, offset);
    int end = offset + ((length - 1) / 64) * 64;
    int last64offset = end + ((length - 1) & 63) - 63;
    do {
        x = rotateRight(x + y + v[0] + load64(bytes, offset + 8), 37) * K1;
        y = rotateRight(y + v[1] + load64(bytes, offset + 48), 42) * K1;
        x ^= w[1];
        y += v[0] + load64(bytes, offset + 40);
        z = rotateRight(z + w[0], 33) * K1;
        weakHashLength32WithSeeds(bytes, offset, v[1] * K1, x + w[0], v);
        weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
        long tmp = x;
        x = z;
        z = tmp;
        offset += 64;
    } while (offset != end);
    long mul = K1 + ((z & 0xFF) << 1);
    offset = last64offset;
    w[0] += ((length - 1) & 63);
    v[0] += w[0];
    w[0] += v[0];
    x = rotateRight(x + y + v[0] + load64(bytes, offset + 8), 37) * mul;
    y = rotateRight(y + v[1] + load64(bytes, offset + 48), 42) * mul;
    x ^= w[1] * 9;
    y += v[0] * 9 + load64(bytes, offset + 40);
    z = rotateRight(z + w[0], 33) * mul;
    weakHashLength32WithSeeds(bytes, offset, v[1] * mul, x + w[0], v);
    weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
    return hashLength16(hashLength16(v[0], w[0], mul) + shiftMix(y) * K0 + x, hashLength16(v[1], w[1], mul) + z, mul);
}

Output:
     long z = shiftMix(y * K2 + 113) * K2;
-    long[] v = new long[2], w = new long[2];
+    long[] v = new long[2];
+    long[] w = new long[2];
     x = x * K2 + load64(bytes, offset);


Input:
public Object execute(ExecutionEvent event) throws ExecutionException {
    RevCommit commit = (RevCommit) getSelection(getPage()).getFirstElement();
    RevCommit newHead;
    Repository repo = getRepository(event);
    CherryPickResult cherryPickResult;
    Git git = new Git(repo);
    Shell parent = getPart(event).getSite().getShell();
    try {
        cherryPickResult = git.cherryPick().include(commit.getId()).call();
        newHead = cherryPickResult.getNewHead();
        if (newHead != null && cherryPickResult.getCherryPickedRefs().isEmpty())
            MessageDialog.openWarning(parent, UIText.CherryPickHandler_NoCherryPickPerformedTitle, UIText.CherryPickHandler_NoCherryPickPerformedMessage);
    } catch (Exception e) {
        throw new ExecutionException(UIText.CherryPickOperation_InternalError, e);
    }
    if (newHead == null)
        if (cherryPickResult.getStatus() == CherryPickStatus.CONFLICTING)
            MessageDialog.openWarning(parent, UIText.CherryPickHandler_CherryPickConflictsTitle, UIText.CherryPickHandler_CherryPickConflictsMessage);
        else
            throw new ExecutionException(UIText.CherryPickOperation_Failed);
    return null;
}

Output:
     }
-    if (newHead == null)
-        if (cherryPickResult.getStatus() == CherryPickStatus.CONFLICTING)
-            MessageDialog.openWarning(parent, UIText.CherryPickHandler_CherryPickConflictsTitle, UIText.CherryPickHandler_CherryPickConflictsMessage);
-        else
-            throw new ExecutionException(UIText.CherryPickOperation_Failed);
+    if (newHead == null) {
+        CherryPickStatus status = cherryPickResult.getStatus();
+        switch(status) {
+            case CONFLICTING:
+                MessageDialog.openWarning(parent, UIText.CherryPickHandler_CherryPickConflictsTitle, UIText.CherryPickHandler_CherryPickConflictsMessage);
+                break;
+            case FAILED:
+                IStatus details = getErrorList(cherryPickResult.getFailingPaths());
+                Activator.showErrorStatus(UIText.CherryPickHandler_CherryPickFailedMessage, details);
+                break;
+            case OK:
+                break;
+        }
+    }
     return null;


Input:
public void startRequest(MRCRequest rq) {
    try {
        Args rqArgs = (Args) rq.getRequestArgs();
        final VolumeManager vMan = master.getVolumeManager();
        final FileAccessManager faMan = master.getFileAccessManager();
        Path p = new Path(rqArgs.path);
        VolumeInfo volume = vMan.getVolumeByName(p.getComp(0));
        StorageManager sMan = vMan.getStorageManager(volume.getId());
        PathResolver res = new PathResolver(sMan, p);
        faMan.checkSearchPermission(sMan, res, rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        res.checkIfFileDoesNotExist();
        FileMetadata file = res.getFile();
        String target = sMan.getSoftlinkTarget(file.getId());
        if (target != null) {
            rqArgs.path = target;
            p = new Path(rqArgs.path);
            if (!vMan.hasVolume(p.getComp(0))) {
                finishRequest(rq, new ErrorRecord(ErrorClass.REDIRECT, target));
                return;
            }
            volume = vMan.getVolumeByName(p.getComp(0));
            sMan = vMan.getStorageManager(volume.getId());
            res = new PathResolver(sMan, p);
            file = res.getFile();
        }
        if (file.isDirectory())
            throw new UserException(ErrNo.EISDIR, "String_Node_Str");
        AccessMode mode = null;
        try {
            mode = AccessMode.valueOf(rqArgs.accessMode);
        } catch (IllegalArgumentException exc) {
            throw new UserException(ErrNo.EINVAL, "String_Node_Str" + rqArgs.accessMode);
        }
        if ((mode == AccessMode.w || mode == AccessMode.a || mode == AccessMode.ga || mode == AccessMode.t) && file.isReadOnly())
            throw new UserException(ErrNo.EPERM, "String_Node_Str");
        faMan.checkPermission(rqArgs.accessMode, sMan, file, res.getParentDirId(), rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        AtomicDBUpdate update = null;
        if (mode == AccessMode.t) {
            update = sMan.createAtomicDBUpdate(master, rq);
            file.setIssuedEpoch(file.getIssuedEpoch() + 1);
            sMan.setMetadata(file, FileMetadata.RC_METADATA, update);
        }
        String capability = MRCOpHelper.createCapability(rqArgs.accessMode, volume.getId(), file.getId(), file.getIssuedEpoch(), master.getConfig().getCapabilitySecret()).toString();
        XLocList xLocList = file.getXLocList();
        if (xLocList == null || !xLocList.iterator().hasNext()) {
            StripingPolicy sp = sMan.getDefaultStripingPolicy(file.getId());
            xLocList = MRCOpHelper.createXLocList(sp, xLocList, sMan, master.getOSDStatusManager(), res.toString(), file.getId(), res.getParentDirId(), volume, rq.getPinkyRequest().getClientAddress());
            file.setXLocList(xLocList);
            if (update == null)
                update = sMan.createAtomicDBUpdate(master, rq);
            sMan.setMetadata(file, FileMetadata.XLOC_METADATA, update);
        }
        HTTPHeaders headers = MRCOpHelper.createXCapHeaders(capability, xLocList);
        rq.setAdditionalResponseHeaders(headers);
        rq.setData(ReusableBuffer.wrap(JSONParser.writeJSON(null).getBytes()));
        if (update == null)
            update = sMan.createAtomicDBUpdate(master, rq);
        if (!master.getConfig().isNoAtime())
            MRCOpHelper.updateFileTimes(res.getParentsParentId(), res.getParentDir(), true, false, false, sMan, update);
        if (update != null)
            update.execute();
        else
            finishRequest(rq);
    } catch (UserException exc) {
        Logging.logMessage(Logging.LEVEL_TRACE, this, exc);
        finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, exc.getErrno(), exc.getMessage(), exc));
    } catch (Exception exc) {
        finishRequest(rq, new ErrorRecord(ErrorClass.INTERNAL_SERVER_ERROR, "String_Node_Str", exc));
    }
}

Output:
         }
-        String capability = MRCOpHelper.createCapability(rqArgs.accessMode, volume.getId(), file.getId(), file.getIssuedEpoch(), master.getConfig().getCapabilitySecret()).toString();
+        String capability = MRCHelper.createCapability(rqArgs.accessMode, volume.getId(), file.getId(), file.getIssuedEpoch(), master.getConfig().getCapabilitySecret()).toString();
         XLocList xLocList = file.getXLocList();


Input:
private void drawColoredCylinder(GL2 gl, int nslices, double base, double top, float[] coords0, byte[] color0, float[] coords1, byte[] color1, boolean capped, boolean useHSV) {
    utmp.set(coords1[0] - coords0[0], coords1[1] - coords0[1], coords1[2] - coords0[2]);
    Xtmp.p.set(coords0[0], coords0[1], coords0[2]);
    Xtmp.R.setZDirection(utmp);
    gl.glPushMatrix();
    GL2Viewer.mulTransform(gl, Xtmp);
    double h = utmp.norm();
    if (nslices + 1 != cosBuff.length) {
        cosBuff = new double[nslices + 1];
        sinBuff = new double[nslices + 1];
        cosBuff[0] = 1;
        sinBuff[0] = 0;
        cosBuff[nslices] = 1;
        sinBuff[nslices] = 0;
        for (int i = 1; i < nslices; i++) {
            double ang = i / (double) nslices * 2 * Math.PI;
            cosBuff[i] = Math.cos(ang);
            sinBuff[i] = Math.sin(ang);
        }
    }
    gl.glBegin(GL2.GL_QUAD_STRIP);
    double c1, s1;
    for (int i = 0; i <= nslices; i++) {
        c1 = cosBuff[i];
        s1 = sinBuff[i];
        gl.glNormal3d(c1, s1, (base - top) / h);
        setVertexColor(gl, color0, useHSV);
        gl.glColor4ubv(color0, 0);
        gl.glVertex3d(base * c1, base * s1, 0);
        setVertexColor(gl, color1, useHSV);
        gl.glVertex3d(top * c1, top * s1, h);
    }
    gl.glEnd();
    if (capped) {
        gl.glColor4ubv(color1, 0);
        if (top > 0) {
            gl.glBegin(GL2.GL_POLYGON);
            gl.glNormal3d(0, 0, 1);
            for (int i = 0; i < nslices; i++) {
                gl.glVertex3d(top * cosBuff[i], top * sinBuff[i], h);
            }
            gl.glEnd();
        }
        gl.glColor4ubv(color0, 0);
        if (base > 0) {
            gl.glBegin(GL2.GL_POLYGON);
            gl.glNormal3d(0, 0, -1);
            for (int i = 0; i < nslices; i++) {
                gl.glVertex3d(base * cosBuff[i], base * sinBuff[i], 0);
            }
            gl.glEnd();
        }
    }
    gl.glPopMatrix();
}

Output:
         s1 = sinBuff[i];
-        gl.glNormal3d(c1, s1, (base - top) / h);
-        setVertexColor(gl, color0, useHSV);
-        gl.glColor4ubv(color0, 0);
-        gl.glVertex3d(base * c1, base * s1, 0);
+        gl.glNormal3d(nscale * c1, nscale * s1, nscale * nz);
         setVertexColor(gl, color1, useHSV);


Input:
static private void addToEntityReg(String[] args) {
    File portletAppFile = new File(args[2]);
    String portletAppFileName = portletAppFile.getName();
    String portletApp = portletAppFileName.substring(0, portletAppFileName.lastIndexOf("String_Node_Str"));
    int o = (args[4].equals("String_Node_Str") ? 5 : 6);
    String appId = args[o++];
    try {
        String entityMapping = webAppsDir + portalImplWebDir + "String_Node_Str";
        File file = new File(entityMapping);
        RandomAccessFile ras = new RandomAccessFile(file, "String_Node_Str");
        long length = ras.length();
        byte[] contentByte = new byte[(int) length];
        ras.read(contentByte);
        String contentString = new String(contentByte);
        long pos = contentString.lastIndexOf("String_Node_Str");
        ras.seek(pos);
        ras.writeBytes("String_Node_Str" + appId + "String_Node_Str");
        ras.writeBytes("String_Node_Str" + portletApp + "String_Node_Str");
        StringTokenizer tokenizer;
        for (int i = o; i < args.length; ++i) {
            tokenizer = new StringTokenizer(args[i], "String_Node_Str");
            String portletId = tokenizer.nextToken();
            String portletName = tokenizer.nextToken();
            ras.writeBytes("String_Node_Str" + portletId + "String_Node_Str");
            ras.writeBytes("String_Node_Str" + portletApp + "String_Node_Str" + portletName + "String_Node_Str");
            ras.writeBytes("String_Node_Str");
        }
        ras.writeBytes("String_Node_Str");
        ras.writeBytes("String_Node_Str");
        ras.close();
    } catch (Exception e) {
        e.printStackTrace(System.out);
        throw PlutoAdminException("String_Node_Str", e);
    }
}

Output:
         e.printStackTrace(System.out);
-        throw PlutoAdminException("String_Node_Str", e);
+        throw new PlutoAdminException("String_Node_Str", e);
     }


Input:
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ) {
    if (player.isSneaking())
        return false;
    if (!world.isRemote && (player.getCurrentEquippedItem() == null || !(player.getCurrentEquippedItem().getItem() instanceof IToolWrench))) {
        player.openGui(BuildcraftAdditions.instance, Variables.Gui.ITEM_SORTER, world, x, y, z);
        return true;
    }
    Item equipped = player.getCurrentEquippedItem() != null ? player.getCurrentEquippedItem().getItem() : null;
    if (equipped != null && equipped instanceof IToolWrench && ((IToolWrench) equipped).canWrench(player, x, y, z)) {
        getSorterTile(world, x, y, z).setRotation(ForgeDirection.getOrientation(rotate(world.getBlockMetadata(x, y, z))));
        ((IToolWrench) equipped).wrenchUsed(player, x, y, z);
        return true;
    }
    return false;
}

Output:
     }
-    return false;
+    if (!world.isRemote)
+        player.openGui(BuildcraftAdditions.instance, Variables.Gui.ITEM_SORTER, world, x, y, z);
+    return true;
 }


Input:
public String getReport() {
    final StringBuilder txt = new StringBuilder();
    txt.append("String_Node_Str" + this.statusComparison.getType() + "String_Node_Str" + this.filename);
    if (this.statusComparison.getType().equals(TYPE_FAIL)) {
        txt.append("String_Node_Str" + this.statusComparison.getName());
        txt.append("String_Node_Str" + this.fileTestedPath);
        txt.append("String_Node_Str" + this.fileExpectedPath);
        txt.append("String_Node_Str" + this.message);
    }
    return txt.toString();
}

Output:
     final StringBuilder txt = new StringBuilder();
-    txt.append("String_Node_Str" + this.statusComparison.getType() + "String_Node_Str" + this.filename);
+    txt.append("String_Node_Str").append(this.statusComparison.getType()).append("String_Node_Str");
+    txt.append(this.filename);
     if (this.statusComparison.getType().equals(TYPE_FAIL)) {


Input:
public Path getTest() throws IOException {
    NodeList list = null;
    for (String s : TEST_EXPRESSION) {
        list = getNodeList(s);
        if (list.getLength() > 0)
            break;
    }
    if (list == null) {
        throw new IOException("String_Node_Str");
    }
    return manifestFile.getParent().resolve(list.item(0).getNodeValue());
}

Output:
     }
-    if (list == null) {
+    if (list == null || list.getLength() == 0) {
         throw new IOException("String_Node_Str");


Input:
public final void enviaMensagem(String msg) {
    Agente d;
    for (Entidade a : getArena().getEntidades()) {
        if ((a instanceof Agente) && (distancia(a) <= Constants.AGENTE_ALCANCE_MENSAGEM)) {
            d = (Agente) a;
            d.sinalizaRecebeuMensagem(msg, this);
        }
    }
}

Output:
     Agente d;
-    for (Entidade a : getArena().getEntidades()) {
+    for (Entidade a : super.getArena().getEntidades()) {
         if ((a instanceof Agente) && (distancia(a) <= Constants.AGENTE_ALCANCE_MENSAGEM)) {


Input:
public void putUnsignedByte(short data) {
    if (data < UNSIGNED_BYTE_MIN_VALUE || data > UNSIGNED_BYTE_MAX_VALUE) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    putByte((byte) data);
}

Output:
     if (data < UNSIGNED_BYTE_MIN_VALUE || data > UNSIGNED_BYTE_MAX_VALUE) {
-        throw new IllegalArgumentException("String_Node_Str");
+        throw new IllegalArgumentException("String_Node_Str" + data);
     }


Input:
protected void onChildActivatedEvent(String childId, String instanceId) {
    removeInstanceFromFromInactiveMap(childId, instanceId);
    removeInstanceFromFromTerminatingMap(childId, instanceId);
    boolean startDep = false;
    if (!aliasToActiveChildMonitorsMap.containsKey(childId) || !pendingChildMonitorsList.contains(childId)) {
        startDep = startDependency(childId, instanceId);
    }
    if (!startDep) {
        ServiceReferenceHolder.getInstance().getGroupStatusProcessorChain().process(this.id, this.appId, instanceId);
    } else {
        log.info("String_Node_Str" + childId + "String_Node_Str" + appId + "String_Node_Str" + getMonitorType() + "String_Node_Str" + id);
    }
}

Output:
     if (!aliasToActiveChildMonitorsMap.containsKey(childId) || !pendingChildMonitorsList.contains(childId)) {
-        startDep = startDependency(childId, instanceId);
+        Monitor childMonitor = aliasToActiveChildMonitorsMap.get(childId);
+        if (childMonitor != null) {
+            Instance instance = childMonitor.getInstance(instanceId);
+            boolean firstIteration = false;
+            if (instance != null) {
+                if (instance instanceof GroupInstance) {
+                    GroupInstance groupInstance = (GroupInstance) instance;
+                    firstIteration = groupInstance.getPreviousState() == GroupStatus.Created;
+                } else if (instance instanceof ClusterInstance) {
+                    ClusterInstance clusterInstance = (ClusterInstance) instance;
+                    firstIteration = clusterInstance.getPreviousState() == ClusterStatus.Created;
+                }
+                if (firstIteration || childMonitor.hasStartupDependents()) {
+                    startDep = startDependency(childId, instanceId);
+                }
+            } else {
+                startDep = startDependency(childId, instanceId);
+            }
+        } else {
+            startDep = startDependency(childId, instanceId);
+        }
     }


Input:
public void updateSchema(DataAccess data) throws DatabaseWriteException {
    File file = new File("String_Node_Str" + data.getName() + "String_Node_Str");
    if (!file.exists()) {
        try {
            file.createNewFile();
            initFile(file, data.getName());
        } catch (IOException e) {
            throw new DatabaseWriteException(e.getMessage());
        }
    }
    try {
        Document table = fileBuilder.build(file);
        HashSet<Column> tableLayout = data.getTableLayout();
        for (Element element : table.getRootElement().getChildren()) {
            addFields(element, tableLayout);
            removeFields(element, tableLayout);
        }
        file.setWritable(true);
        FileWriter writer = new FileWriter(file);
        xmlSerializer.output(table, writer);
        writer.close();
    } catch (JDOMException e) {
        throw new DatabaseWriteException(e.getMessage());
    } catch (IOException e) {
        throw new DatabaseWriteException(e.getMessage());
    } catch (DatabaseTableInconsistencyException e) {
        throw new DatabaseWriteException(e.getMessage());
    }
}

Output:
         FileWriter writer = new FileWriter(file);
-        xmlSerializer.output(table, writer);
+        RandomAccessFile f = new RandomAccessFile(file, "String_Node_Str");
+        f.getChannel().lock();
+        OutputStream out = new FileOutputStream(f.getFD());
+        xmlSerializer.output(table, out);
         writer.close();


Input:
public boolean isUndoable() {
    return oldTexts != null && isSheetAvailable() && !isSheetProtected();
}

Output:
 public boolean isUndoable() {
-    return oldTexts != null && isSheetAvailable() && !isSheetProtected();
+    return oldData != null && isSheetAvailable() && !isSheetProtected();
 }


Input:
public Optional<State> getNAThingProperty(String channelId) {
    if (module != null) {
        try {
            if (CHANNEL_BATTERY_LEVEL.equalsIgnoreCase(channelId) || CHANNEL_LOW_BATTERY.equalsIgnoreCase(channelId)) {
                Method getBatteryVp = module.getClass().getMethod("String_Node_Str");
                Integer value = (Integer) getBatteryVp.invoke(module);
                switch(channelId) {
                    case CHANNEL_BATTERY_LEVEL:
                        int correctedVp = Math.min(value.intValue(), batteryMax);
                        int batteryPercent = (100 * (correctedVp - batteryMin) / (batteryMax - batteryMin));
                        return Optional.of(ChannelTypeUtils.toDecimalType(batteryPercent));
                    case CHANNEL_LOW_BATTERY:
                        return Optional.of(value.intValue() < batteryLow ? OnOffType.ON : OnOffType.OFF);
                }
            }
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            logger.warn("String_Node_Str", channelId, e.getMessage());
            return Optional.of(UnDefType.NULL);
        }
    }
    return Optional.empty();
}

Output:
                     case CHANNEL_BATTERY_LEVEL:
-                        int correctedVp = Math.min(value.intValue(), batteryMax);
+                        int correctedVp = Math.min(value, batteryMax);
                         int batteryPercent = (100 * (correctedVp - batteryMin) / (batteryMax - batteryMin));


Input:
public void actionPerformed(ActionEvent e) {
    JMenuItem menuItem = (JMenuItem) e.getSource();
    String itemName = menuItem.getName();
    Iterator<ProtocolProviderService> pProviders = mainFrame.getProtocolProviders();
    while (pProviders.hasNext()) {
        ProtocolProviderService protocolProvider = pProviders.next();
        if (itemName.equals(Constants.ONLINE_STATUS)) {
            if (!protocolProvider.isRegistered()) {
                saveStatusInformation(protocolProvider, onlineItem.getName());
                GuiActivator.getUIService().getLoginManager().login(protocolProvider);
            } else {
                OperationSetPresence presence = protocolProvider.getOperationSet(OperationSetPresence.class);
                if (presence == null) {
                    saveStatusInformation(protocolProvider, onlineItem.getName());
                    continue;
                }
                Iterator<PresenceStatus> statusSet = presence.getSupportedStatusSet();
                while (statusSet.hasNext()) {
                    PresenceStatus status = statusSet.next();
                    if (status.getStatus() < PresenceStatus.EAGER_TO_COMMUNICATE_THRESHOLD && status.getStatus() >= PresenceStatus.AVAILABLE_THRESHOLD) {
                        new PublishPresenceStatusThread(presence, status).start();
                        this.saveStatusInformation(protocolProvider, status.getStatusName());
                        break;
                    }
                }
            }
        } else if (itemName.equals(Constants.OFFLINE_STATUS)) {
            if (!protocolProvider.getRegistrationState().equals(RegistrationState.UNREGISTERED) && !protocolProvider.getRegistrationState().equals(RegistrationState.UNREGISTERING)) {
                OperationSetPresence presence = protocolProvider.getOperationSet(OperationSetPresence.class);
                if (presence == null) {
                    saveStatusInformation(protocolProvider, offlineItem.getName());
                    GuiActivator.getUIService().getLoginManager().logoff(protocolProvider);
                    continue;
                }
                Iterator<PresenceStatus> statusSet = presence.getSupportedStatusSet();
                while (statusSet.hasNext()) {
                    PresenceStatus status = statusSet.next();
                    if (status.getStatus() < PresenceStatus.ONLINE_THRESHOLD) {
                        this.saveStatusInformation(protocolProvider, status.getStatusName());
                        break;
                    }
                }
                try {
                    GuiActivator.getUIService().getLoginManager().setManuallyDisconnected(true);
                    protocolProvider.unregister();
                } catch (OperationFailedException e1) {
                    logger.error("String_Node_Str" + protocolProvider + "String_Node_Str" + e1);
                }
            }
        } else if (itemName.equals(Constants.FREE_FOR_CHAT_STATUS)) {
            publishStatus(protocolProvider, PresenceStatus.AVAILABLE_THRESHOLD, PresenceStatus.MAX_STATUS_VALUE);
        } else if (itemName.equals(Constants.DO_NOT_DISTURB_STATUS)) {
            publishStatus(protocolProvider, PresenceStatus.ONLINE_THRESHOLD, PresenceStatus.AWAY_THRESHOLD);
        } else if (itemName.equals(Constants.AWAY_STATUS)) {
            publishStatus(protocolProvider, PresenceStatus.AWAY_THRESHOLD, PresenceStatus.AVAILABLE_THRESHOLD);
        }
    }
}

Output:
                     if (status.getStatus() < PresenceStatus.EAGER_TO_COMMUNICATE_THRESHOLD && status.getStatus() >= PresenceStatus.AVAILABLE_THRESHOLD) {
-                        new PublishPresenceStatusThread(presence, status).start();
+                        new PublishPresenceStatusThread(protocolProvider, presence, status).start();
                         this.saveStatusInformation(protocolProvider, status.getStatusName());


Input:
private PRQAComplianceStatus performUpload(AbstractBuild<?, ?> build, PRQAApplicationSettings appSettings, PRQARemoteToolCheck remoteToolCheck, QAFrameworkRemoteReportUpload remoteReportUpload) throws PrqaException {
    boolean success = true;
    PRQAComplianceStatus currentBuild = null;
    try {
        QaFrameworkVersion qaFrameworkVersion = new QaFrameworkVersion(build.getWorkspace().act(remoteToolCheck));
        success = isQafVersionSupported(qaFrameworkVersion);
        if (!success) {
            build.setResult(Result.FAILURE);
            throw new PrqaException("String_Node_Str");
        }
        remoteReportUpload.setQaFrameworkVersion(qaFrameworkVersion);
        build.getWorkspace().act(remoteReportUpload);
    } catch (IOException ex) {
        success = false;
        outStream.println(ex.getMessage());
        build.setResult(Result.FAILURE);
        throw new PrqaException("String_Node_Str");
    } catch (Exception ex) {
        outStream.println(Messages.PRQANotifier_FailedGettingResults());
        outStream.println(ex.getMessage());
        log.log(Level.SEVERE, "String_Node_Str", ex);
        success = false;
        build.setResult(Result.FAILURE);
        throw new PrqaException("String_Node_Str");
    }
    return currentBuild;
}

Output:
         remoteReportUpload.setQaFrameworkVersion(qaFrameworkVersion);
-        build.getWorkspace().act(remoteReportUpload);
+        currentBuild = build.getWorkspace().act(remoteReportUpload);
     } catch (IOException ex) {


Input:
public void validate(ValidationHelper helper, Context context, String key, SecurityScheme t) {
    String reference = t.getRef();
    if (reference != null && !reference.isEmpty()) {
        ValidatorUtils.referenceValidatorHelper(reference, t, helper, context, key);
        return;
    }
    Optional<ValidationEvent> op_type = ValidatorUtils.validateRequiredField(t.getType(), context, "String_Node_Str");
    if (op_type.isPresent()) {
        op_type.ifPresent(helper::addValidationEvent);
    } else {
        String type = t.getType().toString();
        if ("String_Node_Str".equals(type)) {
            ValidatorUtils.validateRequiredField(t.getName(), context, "String_Node_Str").ifPresent(helper::addValidationEvent);
            Optional<ValidationEvent> op_in = ValidatorUtils.validateRequiredField(t.getIn(), context, "String_Node_Str");
            if (op_in.isPresent()) {
                op_in.ifPresent(helper::addValidationEvent);
            } else {
                Set<String> inValues = new HashSet<String>(Arrays.asList("String_Node_Str", "String_Node_Str", "String_Node_Str"));
                if (!(inValues.contains(t.getIn().toString()))) {
                    final String message = Tr.formatMessage(tc, "String_Node_Str", key, t.getIn().toString());
                    helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation(), message));
                }
            }
        } else if ("String_Node_Str".equals(type)) {
            ValidatorUtils.validateRequiredField(t.getScheme(), context, "String_Node_Str").ifPresent(helper::addValidationEvent);
        } else if ("String_Node_Str".equals(type)) {
            ValidatorUtils.validateRequiredField(t.getFlows(), context, "String_Node_Str").ifPresent(helper::addValidationEvent);
        } else if ("String_Node_Str".equals(type)) {
            Optional<ValidationEvent> op_url = ValidatorUtils.validateRequiredField(t.getOpenIdConnectUrl(), context, "String_Node_Str");
            if (op_url.isPresent()) {
                op_url.ifPresent(helper::addValidationEvent);
            } else {
                if (!(ValidatorUtils.isValidURL(t.getOpenIdConnectUrl()))) {
                    final String message = Tr.formatMessage(tc, "String_Node_Str", t.getOpenIdConnectUrl());
                    helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation(), message));
                }
            }
        }
        if (t.getBearerFormat() != null && !t.getBearerFormat().isEmpty() && !"String_Node_Str".equals(type)) {
            final String message = Tr.formatMessage(tc, "String_Node_Str", "String_Node_Str", t.getBearerFormat(), "String_Node_Str", type);
            helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.WARNING, context.getLocation(), message));
        }
        if (t.getScheme() != null && !t.getScheme().isEmpty() && !"String_Node_Str".equals(type)) {
            final String message = Tr.formatMessage(tc, "String_Node_Str", "String_Node_Str", t.getScheme(), "String_Node_Str", type);
            helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.WARNING, context.getLocation(), message));
        }
        if (t.getIn() != null && !"String_Node_Str".equals(type)) {
            final String message = Tr.formatMessage(tc, "String_Node_Str", "String_Node_Str", t.getIn(), "String_Node_Str", type);
            helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.WARNING, context.getLocation(), message));
        }
        if (t.getName() != null && !t.getName().isEmpty() && !"String_Node_Str".equals(type)) {
            final String message = Tr.formatMessage(tc, "String_Node_Str", "String_Node_Str", t.getName(), "String_Node_Str", type);
            helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.WARNING, context.getLocation(), message));
        }
        if (t.getOpenIdConnectUrl() != null && !t.getOpenIdConnectUrl().isEmpty() && !"String_Node_Str".equals(type)) {
            final String message = Tr.formatMessage(tc, "String_Node_Str", "String_Node_Str", t.getOpenIdConnectUrl(), "String_Node_Str", type);
            helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.WARNING, context.getLocation(), message));
        }
        if (!"String_Node_Str".equals(type) && ValidatorUtils.flowsIsSet(t.getFlows())) {
            final String message = Tr.formatMessage(tc, "String_Node_Str", "String_Node_Str", "String_Node_Str", type);
            helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.WARNING, context.getLocation(), message));
        }
    }
}

Output:
             } else {
-                if (!(ValidatorUtils.isValidURL(t.getOpenIdConnectUrl()))) {
+                if (!(ValidatorUtils.isValidURI(t.getOpenIdConnectUrl()))) {
                     final String message = Tr.formatMessage(tc, "String_Node_Str", t.getOpenIdConnectUrl());


Input:
public void setVisualMode(Editor editor, DataContext context, int mode) {
    int oldMode = CommandState.getInstance().getVisualType();
    if (mode == 0) {
        int start = editor.getSelectionModel().getSelectionStart();
        int end = editor.getSelectionModel().getSelectionEnd();
        if (start != end) {
            int line = editor.offsetToLogicalPosition(start).line;
            int lstart = EditorHelper.getLineStartOffset(editor, line);
            int lend = EditorHelper.getLineEndOffset(editor, line, true);
            logger.debug("String_Node_Str" + start + "String_Node_Str" + end + "String_Node_Str" + lstart + "String_Node_Str" + lend);
            if (lstart == start && lend + 1 == end) {
                mode = Command.FLAG_MOT_LINEWISE;
            } else {
                mode = Command.FLAG_MOT_CHARACTERWISE;
            }
        }
    }
    if (oldMode == 0 && mode == 0) {
        editor.getSelectionModel().removeSelection();
        return;
    }
    CommandState.getInstance().setVisualType(mode);
    if (mode == 0) {
        resetVisual(editor);
    } else {
        CommandState.getInstance().setMode(CommandState.MODE_VISUAL);
        CommandState.getInstance().setMappingMode(KeyParser.MAPPING_VISUAL);
    }
    KeyHandler.getInstance().reset();
    visualStart = editor.getSelectionModel().getSelectionStart();
    visualEnd = editor.getSelectionModel().getSelectionEnd();
    CommandGroups.getInstance().getMark().setMark(editor, context, '<', visualStart);
    CommandGroups.getInstance().getMark().setMark(editor, context, '>', visualEnd);
}

Output:
     if (mode == 0) {
-        resetVisual(editor);
+        exitVisual(editor);
     } else {


Input:
public void objectToRequestParameters(Object o, MockHttpServletRequest request, String prefix) throws Exception {
    Class clazz = o.getClass();
    Field[] fields = getDeclaredFields(clazz);
    AccessibleObject.setAccessible(fields, true);
    for (int i = 0; i < fields.length; i++) {
        Object field = (fields[i].get(o));
        if (field instanceof BaseObject) {
            objectToRequestParameters(field, request, fields[i].getName());
        } else if (!(field instanceof List) && !(field instanceof Set)) {
            String paramName = fields[i].getName();
            if (prefix != null) {
                paramName = prefix + "String_Node_Str" + paramName;
            }
            String paramValue = String.valueOf(fields[i].get(o));
            if (field instanceof java.util.Date) {
                paramValue = DateUtil.convertDateToString((Date) fields[i].get(o));
                if ("String_Node_Str".equals(paramValue))
                    paramValue = "String_Node_Str";
            }
            request.addParameter(paramName, paramValue);
        }
    }
}

Output:
         Object field = (fields[i].get(o));
-        if (field instanceof BaseObject) {
-            objectToRequestParameters(field, request, fields[i].getName());
-        } else if (!(field instanceof List) && !(field instanceof Set)) {
-            String paramName = fields[i].getName();
-            if (prefix != null) {
-                paramName = prefix + "String_Node_Str" + paramName;
+        if (field != null) {
+            if (field instanceof BaseObject) {
+                objectToRequestParameters(field, request, fields[i].getName());
+            } else if (!(field instanceof List) && !(field instanceof Set)) {
+                String paramName = fields[i].getName();
+                if (prefix != null) {
+                    paramName = prefix + "String_Node_Str" + paramName;
+                }
+                String paramValue = String.valueOf(fields[i].get(o));
+                if (field instanceof java.util.Date) {
+                    paramValue = DateUtil.convertDateToString((Date) fields[i].get(o));
+                    if ("String_Node_Str".equals(paramValue))
+                        paramValue = "String_Node_Str";
+                }
+                request.addParameter(paramName, paramValue);
             }


Input:
public void updateJobletNodes(boolean update) {
    if (!isCollapsed()) {
        refreshJobletNodes(update, isCollapsed());
        updateSubjobContainer();
        transferLocation(update);
        refreshJobletConnections();
    }
}

Output:
 public void updateJobletNodes(boolean update) {
-    if (!isCollapsed()) {
-        refreshJobletNodes(update, isCollapsed());
-        updateSubjobContainer();
-        transferLocation(update);
-        refreshJobletConnections();
-    }
+    refreshJobletNodes(update, isCollapsed());
+    updateSubjobContainer();
+    transferLocation(update);
+    refreshJobletConnections();
 }


Input:
protected void __handleTextBox() throws Exception {
    JspWriter writer = pageContext.getOut();
    String encParamId = ParameterAccessor.htmlEncode(param.getId());
    String encParamName = ParameterAccessor.htmlEncode(param.getName());
    boolean isNullValue = param.getValue() == null;
    String displayTextId = encParamId + "String_Node_Str";
    String displayTextName = ParameterAccessor.PREFIX_DISPLAY_TEXT + encParamName;
    writer.write("String_Node_Str");
    writer.write("String_Node_Str" + displayTextId + "String_Node_Str");
    if (paramDef.isRequired() || !isNullValue) {
        writer.write("String_Node_Str" + displayTextName + "String_Node_Str");
        writer.write("String_Node_Str" + ParameterAccessor.htmlEncode(this.displayTextString) + "String_Node_Str");
    }
    writer.write("String_Node_Str");
    String valueId = encParamId + "String_Node_Str";
    writer.write("String_Node_Str");
    writer.write("String_Node_Str" + valueId + "String_Node_Str");
    writer.write("String_Node_Str" + encParamName + "String_Node_Str");
    writer.write("String_Node_Str" + ParameterAccessor.htmlEncode(this.valueString) + "String_Node_Str");
    writer.write("String_Node_Str");
    String isLocaleId = encParamId + "String_Node_Str";
    writer.write("String_Node_Str" + isLocaleId + "String_Node_Str" + ParameterAccessor.PARAM_ISLOCALE + "String_Node_Str");
    if (param.getPattern() != null) {
        writer.write("String_Node_Str" + encParamName + "String_Node_Str");
        writer.write("String_Node_Str" + ParameterAccessor.htmlEncode(param.getPattern()) + "String_Node_Str");
    }
    String valCtl = "String_Node_Str" + valueId + "String_Node_Str";
    String inputCtl = "String_Node_Str" + encParamId + "String_Node_Str";
    String displayCtl = "String_Node_Str" + displayTextId + "String_Node_Str";
    String localeCtl = "String_Node_Str" + isLocaleId + "String_Node_Str";
    String onChange = displayCtl + "String_Node_Str" + inputCtl + "String_Node_Str" + valCtl + "String_Node_Str" + inputCtl + "String_Node_Str" + localeCtl + "String_Node_Str" + encParamName + "String_Node_Str";
    if (paramDef.isRequired()) {
        writer.write("String_Node_Str");
        writer.write("String_Node_Str" + encParamId + "String_Node_Str");
        __handleGeneralDefinition();
        writer.write("String_Node_Str" + ParameterAccessor.htmlEncode(this.displayTextString) + "String_Node_Str");
        writer.write("String_Node_Str" + onChange + "String_Node_Str");
        writer.write("String_Node_Str");
    } else {
        String nullValueId = encParamId + "String_Node_Str";
        String radioTextValueId = encParamId + "String_Node_Str";
        String radioNullValueId = encParamId + "String_Node_Str";
        writer.write("String_Node_Str" + ParameterAccessor.PARAM_ISNULL + "String_Node_Str" + nullValueId + "String_Node_Str");
        if (isNullValue)
            writer.write("String_Node_Str" + encParamName + "String_Node_Str");
        writer.write("String_Node_Str");
        String nullCtl = "String_Node_Str" + nullValueId + "String_Node_Str";
        String radioTextCtl = "String_Node_Str" + radioTextValueId + "String_Node_Str";
        String radioNullCtl = "String_Node_Str" + radioNullValueId + "String_Node_Str";
        String onClick = radioTextCtl + "String_Node_Str" + radioNullCtl + "String_Node_Str" + inputCtl + "String_Node_Str" + displayCtl + "String_Node_Str" + displayTextName + "String_Node_Str" + nullCtl + "String_Node_Str";
        writer.write("String_Node_Str" + radioTextValueId + "String_Node_Str");
        writer.write("String_Node_Str" + onClick + "String_Node_Str");
        if (!isNullValue)
            writer.write("String_Node_Str");
        writer.write("String_Node_Str");
        writer.write("String_Node_Str");
        writer.write("String_Node_Str" + encParamId + "String_Node_Str");
        __handleGeneralDefinition();
        writer.write("String_Node_Str" + ParameterAccessor.htmlEncode(this.displayTextString) + "String_Node_Str");
        writer.write("String_Node_Str" + onChange + "String_Node_Str");
        if (isNullValue)
            writer.write("String_Node_Str");
        writer.write("String_Node_Str");
        onClick = radioNullCtl + "String_Node_Str" + radioTextCtl + "String_Node_Str" + inputCtl + "String_Node_Str" + displayCtl + "String_Node_Str" + nullCtl + "String_Node_Str" + encParamName + "String_Node_Str";
        writer.write("String_Node_Str" + radioNullValueId + "String_Node_Str");
        writer.write("String_Node_Str" + onClick + "String_Node_Str");
        if (isNullValue)
            writer.write("String_Node_Str");
        writer.write("String_Node_Str");
        writer.write("String_Node_Str" + (radioNullValueId + "String_Node_Str") + "String_Node_Str");
        writer.write("String_Node_Str" + ITagConstants.NULL_VALUE + "String_Node_Str");
        writer.write("String_Node_Str" + radioNullValueId + "String_Node_Str");
        writer.write(ITagConstants.NULL_VALUE);
        writer.write("String_Node_Str");
        writer.write("String_Node_Str");
    }
}

Output:
     String isLocaleId = encParamId + "String_Node_Str";
-    writer.write("String_Node_Str" + isLocaleId + "String_Node_Str" + ParameterAccessor.PARAM_ISLOCALE + "String_Node_Str");
+    writer.write("String_Node_Str" + isLocaleId + "String_Node_Str" + encParamName + "String_Node_Str");
     if (param.getPattern() != null) {


Input:
public static void removeException(String key) {
    boolean removed = false;
    String error = errors.get(key);
    if (error != null && error.equals(WizardBase.getErrors())) {
        WizardBase.removeException();
        removed = true;
    }
    errors.remove(key);
    if ((removed || WizardBase.getErrors() == null) && errors.size() > 0) {
        String es = errors.values().toArray(new String[errors.size()])[0];
        WizardBase.showException(es);
    }
}

Output:
     if (error != null && error.equals(WizardBase.getErrors())) {
-        WizardBase.removeException();
+        try {
+            WizardBase.removeException();
+        } catch (Exception e) {
+        }
         removed = true;


Input:
public void setSelectionPool(final List<CandidateProgram> pool) {
    if ((pool == null) || pool.isEmpty()) {
        throw new IllegalArgumentException("String_Node_Str" + "String_Node_Str");
    }
    this.pool = pool;
    if (overSelection) {
        Collections.sort(pool, Collections.reverseOrder());
    }
    overSelectionProportion = getOverSelectionProportion(pool.size());
    final double[] adjusted = new double[pool.size()];
    double adjustedSum = 0.0;
    for (int i = 0; i < adjusted.length; i++) {
        final double adjustedFitness = fitnessEvaluator.getFitness(pool.get(i));
        adjusted[i] = adjustedFitness;
        adjustedSum += adjustedFitness;
    }
    normalised = new double[pool.size()];
    double normalisedSum = 0.0;
    for (int i = 0; i < normalised.length; i++) {
        normalisedSum += (adjusted[i] / adjustedSum);
        normalised[i] = normalisedSum;
    }
    normalised[normalised.length - 1] = 1.0;
}

Output:
     if (overSelection) {
-        Collections.sort(pool, Collections.reverseOrder());
+        Collections.sort(pool, new FitnessComparator(fitnessEvaluator, false));
     }


Input:
public static String debugInfo(InstallDriversMojo mojo, Driver driver) {
    return System.lineSeparator() + "String_Node_Str" + driver + System.lineSeparator() + "String_Node_Str" + directoryToString(mojo.installationDirectory) + "String_Node_Str" + directoryToString(mojo.cacheDirectory) + "String_Node_Str" + directoryToString(mojo.tempDirectory);
}

Output:
 public static String debugInfo(InstallDriversMojo mojo, Driver driver) {
-    return System.lineSeparator() + "String_Node_Str" + driver + System.lineSeparator() + "String_Node_Str" + directoryToString(mojo.installationDirectory) + "String_Node_Str" + directoryToString(mojo.cacheDirectory) + "String_Node_Str" + directoryToString(mojo.tempDirectory);
+    return System.lineSeparator() + System.lineSeparator() + "String_Node_Str" + driver + System.lineSeparator() + System.lineSeparator() + "String_Node_Str" + System.lineSeparator() + directoryToString(mojo.installationDirectory) + System.lineSeparator() + "String_Node_Str" + System.lineSeparator() + directoryToString(mojo.cacheDirectory) + System.lineSeparator() + "String_Node_Str" + System.lineSeparator() + directoryToString(mojo.tempDirectory);
 }


Input:
protected void refreshData() {
    try {
        XtentisPort port = Util.getPort(getXObject());
        WSRoutingEngineV2Status status = port.routingEngineV2Action(new WSRoutingEngineV2Action(WSRoutingEngineV2ActionCode.STATUS));
        statusLabel.setText(status.getValue());
        idText.setFocus();
    } catch (Exception e) {
        log.error(e.getMessage(), e);
        MessageDialog.openError(this.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());
    }
}

Output:
     try {
-        XtentisPort port = Util.getPort(getXObject());
+        XtentisPort port = getPort();
         WSRoutingEngineV2Status status = port.routingEngineV2Action(new WSRoutingEngineV2Action(WSRoutingEngineV2ActionCode.STATUS));


Input:
public void initialize(RTIambassador rtia) throws NameNotFound, ObjectClassNotDefined, FederateNotExecutionMember, RTIinternalError, AttributeNotDefined, SaveInProgress, RestoreInProgress, ConcurrentAccessAttempted {
    this.timeAdvanceGrant = false;
    this.timeConstrained = false;
    this.timeRegulator = false;
    this.synchronizationSuccess = false;
    this.synchronizationFailed = false;
    this.inPause = false;
    setUpHlaPublisher(rtia);
    setUpHLASubscriber(rtia);
}

Output:
     setUpHlaPublisher(rtia);
-    setUpHLASubscriber(rtia);
+    setUpSubscription(rtia);
 }


Input:
public EventRequest getRequest(String location, String date, String user) throws EventNotFoundException {
    String url = createUrl(location, date, user);
    EventRequest eventRequest = dao.getRequest(url);
    if (eventRequest == null) {
        throw new EventNotFoundException(url);
    }
    return eventRequest;
}

Output:
 public EventRequest getRequest(String location, String date, String user) throws EventNotFoundException {
-    String url = createUrl(location, date, user);
-    EventRequest eventRequest = dao.getRequest(url);
+    EventRequest eventRequest = dao.getRequest(location, date, user);
     if (eventRequest == null) {


Input:
public void caseXorExpr(XorExpr xe) {
    Value firstOperand = xe.getOp1();
    Value secondOperand = xe.getOp2();
    constantV.setOrigStmt(origStmt);
    if (secondOperand.equals(IntConstant.v(-1))) {
        Register sourceReg = regAlloc.asImmediate(firstOperand, constantV);
        stmtV.addInsn(new Insn12x(Opcode.NOT_INT, destinationReg, sourceReg), origStmt);
    } else if (secondOperand.equals(LongConstant.v(-1))) {
        Register sourceReg = regAlloc.asImmediate(firstOperand, constantV);
        stmtV.addInsn(new Insn12x(Opcode.NOT_LONG, destinationReg, sourceReg), origStmt);
    } else {
        buildCalculatingBinaryInsn("String_Node_Str", firstOperand, secondOperand, xe);
    }
}

Output:
     constantV.setOrigStmt(origStmt);
-    if (secondOperand.equals(IntConstant.v(-1))) {
-        Register sourceReg = regAlloc.asImmediate(firstOperand, constantV);
-        stmtV.addInsn(new Insn12x(Opcode.NOT_INT, destinationReg, sourceReg), origStmt);
-    } else if (secondOperand.equals(LongConstant.v(-1))) {
-        Register sourceReg = regAlloc.asImmediate(firstOperand, constantV);
-        stmtV.addInsn(new Insn12x(Opcode.NOT_LONG, destinationReg, sourceReg), origStmt);
+    if (secondOperand.equals(IntConstant.v(-1)) || secondOperand.equals(LongConstant.v(-1))) {
+        PrimitiveType destRegType = PrimitiveType.getByName(destinationReg.getType().toString());
+        Register orgDestReg = destinationReg;
+        if (isBiggerThan(PrimitiveType.getByName(secondOperand.getType().toString()), destRegType)) {
+            destinationReg = regAlloc.asTmpReg(IntType.v());
+        }
+        if (secondOperand.equals(IntConstant.v(-1))) {
+            Register sourceReg = regAlloc.asImmediate(firstOperand, constantV);
+            stmtV.addInsn(new Insn12x(Opcode.NOT_INT, destinationReg, sourceReg), origStmt);
+        } else if (secondOperand.equals(LongConstant.v(-1))) {
+            Register sourceReg = regAlloc.asImmediate(firstOperand, constantV);
+            stmtV.addInsn(new Insn12x(Opcode.NOT_LONG, destinationReg, sourceReg), origStmt);
+        }
+        if (orgDestReg != destinationReg) {
+            Register tempReg = destinationReg.clone();
+            destinationReg = orgDestReg.clone();
+            castPrimitive(tempReg, secondOperand, destinationReg.getType());
+        }
     } else {


Input:
public boolean onItemUseFirst(ItemStack is, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) {
    Block b = world.getBlock(x, y, z);
    if (b != null && !player.isSneaking()) {
        if (b.rotateBlock(world, x, y, z, ForgeDirection.getOrientation(side))) {
            player.swingItem();
            return !world.isRemote;
        }
    }
    return false;
}

Output:
     if (b != null && !player.isSneaking()) {
-        if (b.rotateBlock(world, x, y, z, ForgeDirection.getOrientation(side))) {
+        ForgeDirection mySide = ForgeDirection.getOrientation(side);
+        if (b.rotateBlock(world, x, y, z, mySide)) {
+            b.onNeighborBlockChange(world, x, y, z, Platform.air);
             player.swingItem();


Input:
public void mouseDown(MouseEvent arg0) {
    dragX = arg0.x;
    dragY = arg0.y;
    dragStartX = arg0.x;
    dragStartY = arg0.y;
    if (dragType == DragType.NONE) {
        if (arg0.button == 1) {
            dragType = DragType.MOVE;
        } else if (arg0.button == 3) {
            dragType = DragType.ZOOM;
        }
    }
}

Output:
 public void mouseDown(MouseEvent arg0) {
-    dragX = arg0.x;
-    dragY = arg0.y;
-    dragStartX = arg0.x;
-    dragStartY = arg0.y;
-    if (dragType == DragType.NONE) {
-        if (arg0.button == 1) {
-            dragType = DragType.MOVE;
-        } else if (arg0.button == 3) {
-            dragType = DragType.ZOOM;
+    if (arg0.button == 1) {
+        final ARXNode node = getNode(arg0.x, arg0.y);
+        if (node != null) {
+            actionButtonClicked1(node);
+        }
+    } else if (arg0.button == 3) {
+        final ARXNode node = getNode(arg0.x, arg0.y);
+        if (node != null) {
+            Point display = canvas.toDisplay(arg0.x, arg0.y);
+            actionButtonClicked3(node, display.x, display.y);
         }


Input:
private void setUp008() throws Exception {
    final EPackage root1 = createPackage(null, "String_Node_Str");
    EClass class1 = createClass(root1, "String_Node_Str");
    createClass(root1, "String_Node_Str");
    resource1.getContents().add(root1);
    final EPackage root2 = createPackage(null, "String_Node_Str");
    EClass class3 = createClass(root2, "String_Node_Str");
    createClass(root2, "String_Node_Str");
    resource2.getContents().add(root2);
    class1.getESuperTypes().add(class3);
    save(resource1, resource2);
    repository.addAllAndCommit("String_Node_Str");
    repository.createBranch(MASTER, BRANCH);
    class1.setName("String_Node_Str");
    save(resource1);
    repository.addAndCommit(project, "String_Node_Str", file1);
    repository.checkoutBranch(BRANCH);
    reload(resource1, resource2);
    class1 = (EClass) findObject(resource1, "String_Node_Str");
    final EClass class4 = (EClass) findObject(resource2, "String_Node_Str");
    class1.getESuperTypes().clear();
    class1.getESuperTypes().add(class4);
    class4.setName("String_Node_Str");
    save(resource1, resource2);
    repository.addAndCommit(project, "String_Node_Str", file1, file2);
    repository.checkoutBranch(MASTER);
    final Status status = repository.status();
    assertFalse(status.hasUncommittedChanges());
    compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 0, 1, 3);
    compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 0, 1);
}

Output:
     compareBothDirectionsAndCheck(iFile1, MASTER, BRANCH, 0, 1, 3);
-    compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 0, 1);
+    compareBothDirectionsAndCheck(iFile2, MASTER, BRANCH, 0, 1, 3);
 }


Input:
public void run() {
    InputStream is = findConsole(KARAF_CONSOLE).getInputStream();
    int count = 0;
    byte[] bs = new byte[1024];
    try {
        while ((count = is.read(bs)) > 0) {
            pos.write(Arrays.copyOf(bs, count));
        }
    } catch (IOException e1) {
        e1.printStackTrace();
    } finally {
        try {
            pos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:
 public void run() {
-    InputStream is = findConsole(KARAF_CONSOLE).getInputStream();
+    InputStream is = findConsole().getInputStream();
     int count = 0;


Input:
private void fillProfile(Structure theStruct, StructureElement theElement, BaseRuntimeElementDefinition<?> def, LinkedList<String> path, BaseRuntimeDeclaredChildDefinition theChild) {
    fillBasics(theElement, def, path, theChild);
    String expectedPath = StringUtils.join(path, '.');
    ourLog.info("String_Node_Str", expectedPath);
    if (!expectedPath.equals(def.getName())) {
        theElement.getDefinition().getNameReference().setValue(def.getName());
        return;
    }
    fillExtensions(theStruct, path, def.getExtensionsNonModifier(), "String_Node_Str", false);
    fillExtensions(theStruct, path, def.getExtensionsModifier(), "String_Node_Str", true);
    if (def.getChildType() == ChildTypeEnum.RESOURCE) {
        StructureElement narrative = theStruct.addElement();
        narrative.setName("String_Node_Str");
        narrative.setPath(join(path, '.') + "String_Node_Str");
        narrative.getDefinition().addType().setCode(DataTypeEnum.NARRATIVE);
        narrative.getDefinition().setIsModifier(false);
        narrative.getDefinition().setMin(0);
        narrative.getDefinition().setMax("String_Node_Str");
        StructureElement contained = theStruct.addElement();
        contained.setName("String_Node_Str");
        contained.setPath(join(path, '.') + "String_Node_Str");
        contained.getDefinition().addType().getCode().setValue("String_Node_Str");
        contained.getDefinition().setIsModifier(false);
        contained.getDefinition().setMin(0);
        contained.getDefinition().setMax("String_Node_Str");
    }
    if (def instanceof BaseRuntimeElementCompositeDefinition) {
        BaseRuntimeElementCompositeDefinition<?> cdef = ((BaseRuntimeElementCompositeDefinition<?>) def);
        for (BaseRuntimeChildDefinition nextChild : cdef.getChildren()) {
            if (nextChild instanceof RuntimeChildUndeclaredExtensionDefinition) {
                continue;
            }
            BaseRuntimeDeclaredChildDefinition child = (BaseRuntimeDeclaredChildDefinition) nextChild;
            StructureElement elem = theStruct.addElement();
            fillMinAndMaxAndDefinitions(child, elem);
            if (child instanceof RuntimeChildResourceBlockDefinition) {
                RuntimeResourceBlockDefinition nextDef = (RuntimeResourceBlockDefinition) child.getSingleChildOrThrow();
                fillProfile(theStruct, elem, nextDef, path, child);
            } else if (child instanceof RuntimeChildContainedResources) {
            } else if (child instanceof RuntimeChildDeclaredExtensionDefinition) {
                throw new IllegalStateException("String_Node_Str" + child.getClass().getCanonicalName());
            } else if (child instanceof RuntimeChildCompositeDatatypeDefinition || child instanceof RuntimeChildPrimitiveDatatypeDefinition || child instanceof RuntimeChildChoiceDefinition || child instanceof RuntimeChildResourceDefinition) {
                Iterator<String> childNamesIter = child.getValidChildNames().iterator();
                String nextName = childNamesIter.next();
                BaseRuntimeElementDefinition<?> nextDef = child.getChildByName(nextName);
                fillBasics(elem, nextDef, path, child);
                fillName(elem, nextDef);
                while (childNamesIter.hasNext()) {
                    nextDef = child.getChildByName(childNamesIter.next());
                    fillName(elem, nextDef);
                }
                path.pollLast();
            } else {
                throw new IllegalStateException("String_Node_Str" + child.getClass().getCanonicalName());
            }
        }
    } else {
        throw new IllegalStateException("String_Node_Str" + def.getClass().getCanonicalName());
    }
    path.pollLast();
}

Output:
     ourLog.info("String_Node_Str", expectedPath);
-    if (!expectedPath.equals(def.getName())) {
+    String name = def.getName();
+    if (!expectedPath.equals(name)) {
+        path.pollLast();
         theElement.getDefinition().getNameReference().setValue(def.getName());


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.DAMAGED_CREATURE) {
        Permanent creature = game.getPermanent(event.getSourceId());
        Permanent damagedCreature = game.getPermanent(event.getTargetId());
        if (creature != null && damagedCreature != null && creature.getCardType().contains(CardType.CREATURE) && creature.getSubtype().contains("String_Node_Str") && creature.getControllerId().equals(controllerId)) {
            this.getEffects().get(0).setValue("String_Node_Str", event.getAmount());
            this.getEffects().get(0).setValue("String_Node_Str", damagedCreature.getControllerId());
            this.getEffects().get(0).setValue("String_Node_Str", event.getSourceId());
            return true;
        }
    }
    return false;
}

Output:
         Permanent damagedCreature = game.getPermanent(event.getTargetId());
-        if (creature != null && damagedCreature != null && creature.getCardType().contains(CardType.CREATURE) && creature.getSubtype().contains("String_Node_Str") && creature.getControllerId().equals(controllerId)) {
+        if (creature != null && damagedCreature != null && creature.getCardType().contains(CardType.CREATURE) && creature.hasSubtype("String_Node_Str") && creature.getControllerId().equals(controllerId)) {
             this.getEffects().get(0).setValue("String_Node_Str", event.getAmount());


Input:
public String toText() {
    MessageFormat mf;
    StringBuffer sb = new StringBuffer();
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str" + name + "String_Node_Str");
    sb.append("String_Node_Str" + brewer + "String_Node_Str");
    sb.append("String_Node_Str" + SBStringUtils.df1.format(postBoilVol.getValue()) + "String_Node_Str" + postBoilVol.getUnits() + "String_Node_Str");
    sb.append("String_Node_Str" + style.getName() + "String_Node_Str");
    mf = new MessageFormat("String_Node_Str");
    Object[] objs = { new Double(estOg), new Double(estFg), new Double(alcohol) };
    sb.append(mf.format(objs));
    sb.append("String_Node_Str");
    sb.append(padLeft("String_Node_Str", 30, ' ') + "String_Node_Str");
    mf = new MessageFormat("String_Node_Str");
    for (int i = 0; i < fermentables.size(); i++) {
        Fermentable f = (Fermentable) fermentables.get(i);
        Object[] objf = { padLeft(f.getName(), 30, ' '), padRight("String_Node_Str" + SBStringUtils.df2.format(f.getAmountAs(f.getUnits())), 6, ' '), f.getUnits(), new Double(f.getPppg()), padRight("String_Node_Str" + SBStringUtils.df1.format(f.getLov()), 6, ' '), new Double(f.getPercent()) };
        sb.append(mf.format(objf));
    }
    sb.append("String_Node_Str");
    sb.append(padLeft("String_Node_Str", 20, ' ') + "String_Node_Str");
    mf = new MessageFormat("String_Node_Str");
    for (int i = 0; i < hops.size(); i++) {
        Hop h = (Hop) hops.get(i);
        Object[] objh = { padLeft(h.getName(), 20, ' '), padRight("String_Node_Str" + SBStringUtils.df2.format(h.getAmountAs(h.getUnits())), 6, ' '), h.getUnits(), padRight("String_Node_Str" + h.getAlpha(), 5, ' '), padRight("String_Node_Str" + SBStringUtils.df1.format(h.getMinutes()), 6, ' '), padRight("String_Node_Str" + SBStringUtils.df1.format(h.getIBU()), 5, ' ') };
        sb.append(mf.format(objh));
    }
    sb.append("String_Node_Str");
    sb.append(padLeft("String_Node_Str", 10, ' ') + "String_Node_Str");
    mf = new MessageFormat("String_Node_Str");
    for (int i = 0; i < mash.getStepSize(); i++) {
        Object[] objm = { padLeft(mash.getStepType(i), 10, ' '), padRight("String_Node_Str" + mash.getStepStartTemp(i), 6, ' '), padRight("String_Node_Str" + mash.getStepEndTemp(i), 6, ' '), padRight("String_Node_Str" + mash.getStepRampMin(i), 4, ' '), padRight("String_Node_Str" + mash.getStepMin(i), 6, ' ') };
        sb.append(mf.format(objm));
    }
    return sb.toString();
}

Output:
     mf = new MessageFormat("String_Node_Str");
-    Object[] objs = { new Double(estOg), new Double(estFg), new Double(alcohol) };
+    Object[] objs = { new Double(estOg), new Double(estFg), new Double(alcohol), new Double(ibu) };
     sb.append(mf.format(objs));


Input:
private Operand visitCreateArray(NewExprNode node, Integer index) {
    Var baseReg = Var.builder("String_Node_Str");
    Operand size = visit(node.getDimArgs().get(index));
    Operand bitSize = visitArithComp(visitArithComp(size, MUL, PTR_SIZE, INT_TYPE_SYMBOL), ADD, LENGTH_SIZE, INT_TYPE_SYMBOL);
    currentBasicBlock.pushBack(new FunctionCallInst(Function.MALLOC, new ArrayList<>(Collections.singletonList(bitSize)), baseReg), valTag);
    currentBasicBlock.pushBack(new MoveInst(new Memory(baseReg, null, 0, 0), size), valTag);
    Boolean terminal = index == node.getDimArgs().size() - 1;
    Boolean createClass = !node.getCreateType().isPrimitiveTypeBase() && node.getEmptyDim() == 0;
    if (!terminal || createClass) {
        Var indexReg = Var.builder("String_Node_Str");
        currentBasicBlock.pushBack(new MoveInst(indexReg, ZERO_LITERAL), valTag);
        BasicBlock creatorLoopBegin = new BasicBlock(currentBasicBlock.getParentFunction(), new SymbolTable(currentSymbolTable), "String_Node_Str");
        BasicBlock next = new BasicBlock(currentBasicBlock.getParentFunction(), currentSymbolTable, "String_Node_Str");
        currentBasicBlock.pushBack(new DirectJumpInst(creatorLoopBegin));
        setCurrentEnv(creatorLoopBegin);
        newValTag();
        Operand created;
        if (!terminal)
            created = visitCreateArray(node, index + 1);
        else
            created = visitCreateClass(node.getCreateType().getBaseType());
        currentBasicBlock.pushBack(new MoveInst(new Memory(baseReg, indexReg, options.PTR_SIZE, options.LENGTH_SIZE), created), valTag);
        Operand indexTmp = visitArithComp(indexReg, ADD, ONE_LITERAL, INT_TYPE_SYMBOL);
        resetCurrentBasicBlockBackDst(indexReg, indexTmp, INT_TYPE_SYMBOL);
        Operand ltTmp = visitArithComp(indexReg, LT, size, INT_TYPE_SYMBOL);
        currentBasicBlock.pushBack(new CondJumpInst(ltTmp, creatorLoopBegin, next));
        popValTag();
        setCurrentEnv(next);
    }
    return baseReg;
}

Output:
 private Operand visitCreateArray(NewExprNode node, Integer index) {
-    Var baseReg = Var.builder("String_Node_Str");
+    Var baseReg = Var.tmpBuilder("String_Node_Str");
     Operand size = visit(node.getDimArgs().get(index));


Input:
public void onUpdate() {
    super.onUpdate();
    if (world.isRemote) {
        if (ConfigSound.soundEnabled) {
            if (this.horn == null) {
                this.horn = ImmersiveRailroading.proxy.newSound(this.getDefinition().horn, false, 100, gauge);
                this.idle = ImmersiveRailroading.proxy.newSound(this.getDefinition().idle, true, 80, gauge);
            }
            if (isRunning()) {
                if (!idle.isPlaying()) {
                    this.idle.play(getPositionVector());
                }
            } else {
                if (idle.isPlaying()) {
                    idle.stop();
                }
            }
            if (this.getDataManager().get(HORN) != 0 && !horn.isPlaying() && isRunning()) {
                horn.play(getPositionVector());
            }
            float absThrottle = Math.abs(this.getThrottle());
            if (this.soundThrottle > absThrottle) {
                this.soundThrottle -= Math.min(0.01f, this.soundThrottle - absThrottle);
            } else if (this.soundThrottle < absThrottle) {
                this.soundThrottle += Math.min(0.01f, absThrottle - this.soundThrottle);
            }
            if (horn.isPlaying()) {
                horn.setPosition(getPositionVector());
                horn.setVelocity(getVelocity());
                horn.update();
            }
            if (idle.isPlaying()) {
                idle.setPitch(0.7f + this.soundThrottle / 4);
                idle.setVolume(Math.max(0.1f, this.soundThrottle));
                idle.setPosition(getPositionVector());
                idle.setVelocity(getVelocity());
                idle.update();
            }
        }
        if (!ConfigGraphics.particlesEnabled) {
            return;
        }
        Vec3d fakeMotion = new Vec3d(this.motionX, this.motionY, this.motionZ);
        List<RenderComponent> exhausts = this.getDefinition().getComponents(RenderComponentType.DIESEL_EXHAUST_X, gauge);
        float throttle = Math.abs(this.getThrottle()) + 0.05f;
        if (exhausts != null && isRunning()) {
            for (RenderComponent exhaust : exhausts) {
                Vec3d particlePos = this.getPositionVector().add(VecUtil.rotateYaw(exhaust.center(), this.rotationYaw + 180)).addVector(0, 0.35 * gauge.scale(), 0);
                double smokeMod = (1 + Math.min(1, Math.max(0.2, Math.abs(this.getCurrentSpeed().minecraft()) * 2))) / 2;
                EntitySmokeParticle sp = new EntitySmokeParticle(world, (int) (40 * (1 + throttle) * smokeMod), throttle, throttle, exhaust.width());
                particlePos = particlePos.subtract(fakeMotion);
                sp.setPosition(particlePos.x, particlePos.y, particlePos.z);
                sp.setVelocity(fakeMotion.x, fakeMotion.y + 0.4 * gauge.scale(), fakeMotion.z);
                world.spawnEntity(sp);
            }
        }
        return;
    }
    float heatUpSpeed = 0.0029167f * Config.ConfigBalance.dieselLocoHeatTimeScale;
    float coolDownSpeed = heatUpSpeed / 2;
    float engineTemperature = getEngineTemperature();
    if (this.getLiquidAmount() > 0 && isRunning()) {
        float consumption = Math.abs(getThrottle()) + 0.05f;
        float burnTime = BurnUtil.getBurnTime(this.getLiquid());
        if (burnTime == 0) {
            burnTime = 200;
        }
        burnTime *= getDefinition().getFuelEfficiency() / 100f;
        burnTime *= (Config.ConfigBalance.locoDieselFuelEfficiency / 100f);
        while (internalBurn < 0 && this.getLiquidAmount() > 0) {
            internalBurn += burnTime;
            theTank.drain(1, true);
        }
        consumption *= 100;
        consumption *= gauge.scale();
        internalBurn -= consumption;
    }
    if (engineTemperature > ambientTemperature()) {
        engineTemperature -= coolDownSpeed;
    }
    if (isRunning()) {
        engineTemperature += heatUpSpeed * Math.abs(getThrottle()) + 0.1f;
        if (engineTemperature > 150 && Config.ConfigDamage.canEnginesOverheat) {
            engineTemperature = 150;
            setEngineOverheated(true);
        }
        if ((engineTemperature < 100 || !Config.ConfigDamage.canEnginesOverheat) && isEngineOverheated()) {
            setEngineOverheated(false);
        }
    }
    if (turnOnOffDelay > 0) {
        turnOnOffDelay -= 1;
    }
}

Output:
     if (isRunning()) {
-        engineTemperature += heatUpSpeed * Math.abs(getThrottle()) + 0.1f;
+        engineTemperature += heatUpSpeed * (Math.abs(getThrottle()) + 0.1f);
         if (engineTemperature > 150 && Config.ConfigDamage.canEnginesOverheat) {


Input:
public void run() {
    try {
        FileDialog dialog = new FileDialog(UIUtil.getDefaultShell(), SWT.OPEN);
        dialog.setFilterExtensions(new String[] { "String_Node_Str" });
        String filename;
        pref = ReportPlugin.getDefault().getPreferenceStore().getInt(PREF_KEY);
        filename = dialog.open();
        if (filename != null) {
            if (pref == PREF_PROMPT) {
                MessageDialog prefDialog = new MessageDialog(dialog.getParent(), DIALOG_TITLE, null, DIALOG_MESSAGE, MessageDialog.INFORMATION, new String[] { BUTTON_YES, BUTTON_NO, BUTTON_CANCEL }, 0) {
                    protected Control createCustomArea(Composite parent) {
                        Composite container = new Composite(parent, SWT.NONE);
                        GridLayout gridLayout = new GridLayout();
                        gridLayout.marginWidth = 20;
                        gridLayout.marginTop = 15;
                        container.setLayout(gridLayout);
                        Button chkbox = new Button(container, SWT.CHECK);
                        chkbox.setText(REMEMBER_DECISION);
                        chkbox.addSelectionListener(new SelectionListener() {
                            public void widgetSelected(SelectionEvent e) {
                                saveDecision = !saveDecision;
                            }
                            public void widgetDefaultSelected(SelectionEvent e) {
                                saveDecision = false;
                            }
                        });
                        return super.createCustomArea(parent);
                    }
                    protected void buttonPressed(int buttonId) {
                        switch(buttonId) {
                            case 0:
                                pref = PREF_OVERWRITE;
                                break;
                            case 1:
                                pref = PREF_NOT_OVERWRITE;
                                break;
                            default:
                                break;
                        }
                        if (saveDecision) {
                            ReportPlugin.getDefault().getPreferenceStore().setValue(PREF_KEY, pref);
                        }
                        super.buttonPressed(buttonId);
                    }
                };
                if (prefDialog.open() == 2)
                    return;
            }
            ElementExportUtil.exportElement((DesignElementHandle) getSelection(), filename, pref == PREF_OVERWRITE);
        }
    } catch (Exception e) {
        ExceptionHandler.handle(e);
    }
}

Output:
     try {
-        FileDialog dialog = new FileDialog(UIUtil.getDefaultShell(), SWT.OPEN);
+        FileDialog dialog;
+        if (getSelection() instanceof ReportDesignHandle)
+            dialog = new FileDialog(UIUtil.getDefaultShell(), SWT.SAVE);
+        else
+            dialog = new FileDialog(UIUtil.getDefaultShell(), SWT.OPEN);
         dialog.setFilterExtensions(new String[] { "String_Node_Str" });


Input:
public void setExhaustion(float value) {
    getHandle().setHunger(value);
}

Output:
 public void setExhaustion(float value) {
-    getHandle().setHunger(value);
+    getHandle().setExhaustion(value);
 }


Input:
protected void onClick() {
    GameScene.show(new WndInfoBuff(buff));
}

Output:
 protected void onClick() {
-    GameScene.show(new WndInfoBuff(buff));
+    if (buff.icon() != NONE)
+        GameScene.show(new WndInfoBuff(buff));
 }


Input:
private NumberedSplit<V> allocateSplit(final String evaluatorId, final BlockingQueue<NumberedSplit<V>> value) {
    if (value == null) {
        LOG.log(Level.FINE, "String_Node_Str");
        return null;
    }
    final NumberedSplit<V> split = value.poll();
    if (split != null && (value == unallocatedSplits || unallocatedSplits.remove(split))) {
        LOG.log(Level.FINE, "String_Node_Str" + split.getIndex() + "String_Node_Str");
        final NumberedSplit<V> old = evaluatorToSplits.putIfAbsent(evaluatorId, split);
        if (old != null) {
            final String msg = "String_Node_Str" + "String_Node_Str";
            LOG.severe(msg);
            throw new RuntimeException(msg);
        } else {
            LOG.log(Level.FINE, "String_Node_Str" + split.getIndex());
            return split;
        }
    }
    return null;
}

Output:
     }
-    final NumberedSplit<V> split = value.poll();
-    if (split != null && (value == unallocatedSplits || unallocatedSplits.remove(split))) {
-        LOG.log(Level.FINE, "String_Node_Str" + split.getIndex() + "String_Node_Str");
-        final NumberedSplit<V> old = evaluatorToSplits.putIfAbsent(evaluatorId, split);
-        if (old != null) {
-            final String msg = "String_Node_Str" + "String_Node_Str";
-            LOG.severe(msg);
-            throw new RuntimeException(msg);
-        } else {
-            LOG.log(Level.FINE, "String_Node_Str" + split.getIndex());
-            return split;
+    while (true) {
+        final NumberedSplit<V> split = value.poll();
+        if (split == null)
+            return null;
+        if (value == unallocatedSplits || unallocatedSplits.remove(split)) {
+            LOG.log(Level.FINE, "String_Node_Str" + split.getIndex() + "String_Node_Str");
+            final NumberedSplit<V> old = evaluatorToSplits.putIfAbsent(evaluatorId, split);
+            if (old != null) {
+                final String msg = "String_Node_Str" + "String_Node_Str";
+                LOG.severe(msg);
+                throw new RuntimeException(msg);
+            } else {
+                LOG.log(Level.FINE, "String_Node_Str" + split.getIndex());
+                return split;
+            }
         }


Input:
private static void validateServiceState(final String text) throws Exception {
    if (text.length() > 10240) {
        throw new RuntimeException("String_Node_Str");
    }
    validateServiceState();
}

Output:
 private static void validateServiceState(final String text) throws Exception {
-    if (text.length() > 10240) {
+    final int byteLength = text.getBytes(ENCODING).length;
+    if (byteLength > 10240) {
         throw new RuntimeException("String_Node_Str");


Input:
protected String _generateIncludeFiles() throws IllegalActionException {
    StringBuffer code = new StringBuffer();
    NamedProgramCodeGeneratorAdapter compositeActorAdapter = (NamedProgramCodeGeneratorAdapter) getAdapter(getContainer());
    Set<String> includingFiles = compositeActorAdapter.getHeaderFiles();
    includingFiles.add("String_Node_Str");
    if (_isTopLevel() && ((BooleanToken) measureTime.getToken()).booleanValue()) {
        includingFiles.add("String_Node_Str");
    }
    if (!_isTopLevel()) {
        includingFiles.add("String_Node_Str" + _sanitizedModelName + "String_Node_Str");
        includingFiles.addAll(_getJVMHeaderFiles());
    }
    if (((BooleanToken) generateEmbeddedCode.getToken()).booleanValue()) {
        includingFiles.addAll(_getJVMHeaderFiles());
    }
    includingFiles.add("String_Node_Str");
    includingFiles.add("String_Node_Str");
    includingFiles.add("String_Node_Str");
    includingFiles.add("String_Node_Str");
    for (String file : includingFiles) {
        if (file.endsWith("String_Node_Str"))
            code.append("String_Node_Str" + file.substring(1) + _eol);
        else
            code.append("String_Node_Str" + file + _eol);
    }
    return code.toString();
}

Output:
     for (String file : includingFiles) {
-        if (file.endsWith("String_Node_Str"))
+        if (file.endsWith("String_Node_Str") && _isTopLevel())
             code.append("String_Node_Str" + file.substring(1) + _eol);


Input:
private void rememberPackage(String packageName) {
    int i = packageName.lastIndexOf('.');
    if (i != -1) {
        rememberPackage(packageName.substring(0, i));
    }
    knownPackages.add(packageName);
}

Output:
 private void rememberPackage(String packageName) {
-    int i = packageName.lastIndexOf('.');
-    if (i != -1) {
-        rememberPackage(packageName.substring(0, i));
+    if (knownPackages.add(packageName)) {
+        int i = packageName.lastIndexOf('.');
+        if (i != -1) {
+            rememberPackage(packageName.substring(0, i));
+        }
     }


Input:
private boolean containsRpslMntner(final RpslObject rpslObject) {
    if (!rpslObject.containsAttribute(AttributeType.MNT_BY)) {
        return false;
    }
    for (RpslAttribute mntBy : rpslObject.findAttributes(AttributeType.MNT_BY)) {
        if (mntBy.getCleanValue().equals("String_Node_Str")) {
            return true;
        }
    }
    return false;
}

Output:
     for (RpslAttribute mntBy : rpslObject.findAttributes(AttributeType.MNT_BY)) {
-        if (mntBy.getCleanValue().equals("String_Node_Str")) {
-            return true;
+        for (CIString mntByStr : mntBy.getCleanValues()) {
+            if (mntByStr.equals("String_Node_Str")) {
+                return true;
+            }
         }


Input:
public TopLevel getTopLevel(URI topLevelURI) {
    TopLevel topLevel = getTopLevelLocalOnly(topLevelURI);
    if (topLevel == null) {
        for (SynBioHubFrontend frontend : getRegistries()) {
            try {
                SBOLDocument document = frontend.getSBOL(topLevelURI);
                if (document != null) {
                    topLevel = document.getTopLevel(topLevelURI);
                    createCopy(document);
                }
            } catch (SynBioHubException | SBOLValidationException e) {
                topLevel = null;
            }
        }
    }
    return null;
}

Output:
     }
-    return null;
+    return topLevel;
 }


Input:
public List getTypesToGenerateFromForSchemaTypeTest() {
    List types = new ArrayList();
    ((SDOTypeHelper) typeHelper).reset();
    SDOType dataObjectType = (SDOType) typeHelper.getType(SDOConstants.SDO_URL, SDOConstants.DATAOBJECT);
    SDOProperty xmlDataTypeProperty = (SDOProperty) typeHelper.getOpenContentProperty(SDOConstants.ORACLE_SDO_URL, SDOConstants.SDOXML_DATATYPE);
    SDOProperty xmlSchemaTypeProperty = (SDOProperty) typeHelper.getOpenContentProperty(SDOConstants.ORACLE_SDO_URL, SDOConstants.XML_SCHEMA_TYPE_NAME);
    DataObject myChildTypeDO = dataFactory.create("String_Node_Str", "String_Node_Str");
    myChildTypeDO.set("String_Node_Str", "String_Node_Str");
    myChildTypeDO.set("String_Node_Str", "String_Node_Str");
    addProperty(myChildTypeDO, "String_Node_Str", SDOConstants.SDO_STRING, false, false, true);
    DataObject myRootTypeDO = dataFactory.create("String_Node_Str", "String_Node_Str");
    myRootTypeDO.set("String_Node_Str", "String_Node_Str");
    myRootTypeDO.set("String_Node_Str", "String_Node_Str");
    DataObject test1Prop = addProperty(myRootTypeDO, "String_Node_Str", SDOConstants.SDO_INTOBJECT, false, false, true);
    DataObject test2Prop = addProperty(myRootTypeDO, "String_Node_Str", SDOConstants.SDO_BOOLEANOBJECT, false, false, true);
    test2Prop.set(xmlDataTypeProperty, SDOConstants.SDO_BOOLEANOBJECT);
    DataObject test3Prop = addProperty(myRootTypeDO, "String_Node_Str", SDOConstants.SDO_DATE, false, false, true);
    DataObject test4Prop = addProperty(myRootTypeDO, "String_Node_Str", SDOConstants.SDO_DATETIME, false, false, true);
    DataObject test5Prop = addProperty(myRootTypeDO, "String_Node_Str", SDOConstants.SDO_SHORT, false, false, true);
    test5Prop.set(xmlDataTypeProperty, SDOConstants.SDO_SHORTOBJECT);
    DataObject test6Prop = addProperty(myRootTypeDO, "String_Node_Str", dataObjectType, true, false, true);
    test6Prop.set(xmlDataTypeProperty, dataObjectType);
    DataObject test7Prop = addProperty(myRootTypeDO, "String_Node_Str", myChildTypeDO, true, false, true);
    test7Prop.set(xmlSchemaTypeProperty, myChildTypeDO);
    test7Prop.set(xmlDataTypeProperty, dataObjectType);
    Type myRootType = typeHelper.define(myRootTypeDO);
    ((SDOType) myRootType).setXsd(true);
    ((SDOType) myRootType).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) myRootType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    Type childType = typeHelper.define(myChildTypeDO);
    ((SDOProperty) childType.getProperty("String_Node_Str")).setXsd(true);
    ((SDOProperty) childType.getProperty("String_Node_Str")).setXsdLocalName("String_Node_Str");
    types.add(childType);
    types.add(myRootType);
    return types;
}

Output:
     SDOType dataObjectType = (SDOType) typeHelper.getType(SDOConstants.SDO_URL, SDOConstants.DATAOBJECT);
-    SDOProperty xmlDataTypeProperty = (SDOProperty) typeHelper.getOpenContentProperty(SDOConstants.ORACLE_SDO_URL, SDOConstants.SDOXML_DATATYPE);
+    SDOProperty xmlDataTypeProperty = (SDOProperty) typeHelper.getOpenContentProperty(SDOConstants.SDOXML_URL, SDOConstants.SDOXML_DATATYPE);
     SDOProperty xmlSchemaTypeProperty = (SDOProperty) typeHelper.getOpenContentProperty(SDOConstants.ORACLE_SDO_URL, SDOConstants.XML_SCHEMA_TYPE_NAME);


Input:
public void close() throws IOException {
    lock.lock();
    try {
        if (closed)
            return;
        LOG.info(this + "String_Node_Str");
        closed = true;
    } finally {
        lock.unlock();
    }
    notificationSockets[0].close();
    Uninterruptibles.joinUninterruptibly(watcherThread);
}

Output:
             return;
-        LOG.info(this + "String_Node_Str");
+        if (LOG.isDebugEnabled()) {
+            LOG.debug(this + "String_Node_Str");
+        }
         closed = true;


Input:
public boolean renderItemBlockBasic(int meta) {
    switch(meta) {
        case 0:
        case 4:
            return true;
    }
    return false;
}

Output:
 public boolean renderItemBlockBasic(int meta) {
-    switch(meta) {
-        case 0:
-        case 4:
-            return true;
-    }
-    return false;
+    return true;
 }


Input:
public void readData(DataInput dis) throws IOException {
    super.readData(dis);
    setRequest(dis.readBoolean());
    memberCount = dis.readInt();
}

Output:
     super.readData(dis);
-    setRequest(dis.readBoolean());
+    this.request = dis.readBoolean();
     memberCount = dis.readInt();


Input:
public void handle(RoutingContext ctx) {
    int no = Integer.parseInt(ctx.request().getParam("String_Node_Str"));
    ctx.response().setStatusCode(200);
    ctx.response().end(PostModel.getPost(2, no).toString());
    ctx.response().close();
}

Output:
     ctx.response().setStatusCode(200);
-    ctx.response().end(PostModel.getPost(2, no).toString());
+    ctx.response().end(PostModel.getPostsAtPage(2, no).toString());
     ctx.response().close();


Input:
public Control createControl(final Composite subComposite, final IElementParameter param, final int numInRow, final int nbInRow, final int top, final Control lastControl) {
    boolean hasScreenshots = false;
    byte[] screenshot = null;
    if (param.getElement() instanceof INode && ((INode) param.getElement()).getExternalNode() != null) {
        String componentType = ((INode) param.getElement()).getComponent().getName();
        if ("String_Node_Str".equals(componentType)) {
            IProcess process = ((INode) param.getElement()).getProcess();
            if (process instanceof IProcess2) {
                IProcess2 processtmp = (IProcess2) process;
                Item item = processtmp.getProperty().getItem();
                if (item instanceof ProcessItem) {
                    ProcessItem processItem = (ProcessItem) item;
                    screenshot = (byte[]) processItem.getProcess().getScreenshots().get(((INode) param.getElement()).getUniqueName());
                    if (screenshot != null) {
                        hasScreenshots = true;
                    }
                } else if (item instanceof JobletProcessItem) {
                    JobletProcessItem jobletItem = (JobletProcessItem) item;
                    screenshot = (byte[]) jobletItem.getJobletProcess().getScreenshots().get(((INode) param.getElement()).getUniqueName());
                    if (screenshot != null) {
                        hasScreenshots = true;
                    }
                }
            }
        }
    }
    if (hasScreenshots) {
        ImageDescriptor imageDesc = ImageUtils.createImageFromData(screenshot);
        ((INode) param.getElement()).getExternalNode().setScreenshot(imageDesc);
        final Composite compositeImage = new Composite(subComposite, SWT.BORDER);
        final Image image = imageDesc.createImage();
        addResourceDisposeListener(compositeImage, image);
        CLabel labelLabel = getWidgetFactory().createCLabel(subComposite, param.getDisplayName() + "String_Node_Str");
        FormData formDataLabel = new FormData();
        labelLabel.setVisible(true);
        if (numInRow != 1) {
            labelLabel.setAlignment(SWT.RIGHT);
        }
        if (lastControl != null) {
            formDataLabel.left = new FormAttachment(lastControl, 0);
        } else {
            formDataLabel.left = new FormAttachment((((numInRow - 1) * MAX_PERCENT) / nbInRow), 0);
            formDataLabel.top = new FormAttachment(0, top);
        }
        labelLabel.setLayoutData(formDataLabel);
        compositeImage.setToolTipText(param.getDisplayName());
        Point size = new Point(image.getImageData().width, image.getImageData().height);
        FormData formData = new FormData(size.x, size.y);
        formData.top = new FormAttachment(0, top);
        formData.left = new FormAttachment(labelLabel);
        compositeImage.setBackgroundImage(image);
        compositeImage.setLayoutData(formData);
        return compositeImage;
    } else {
        return lastControl;
    }
}

Output:
         Point size = new Point(image.getImageData().width, image.getImageData().height);
-        FormData formData = new FormData(size.x, size.y);
+        FormData formData = new FormData((int) (size.x * 0.8), (int) (size.y * 0.8));
         formData.top = new FormAttachment(0, top);


Input:
public void startForeachLoop(String loopName, Var container, Var memberVar, Var loopCountVar, int splitDegree, int leafDegree, boolean arrayClosed, List<PassedVar> passedVars, List<RefCount> perIterIncrs, ListMultimap<Var, RefCount> constIncrs) {
    boolean haveKeys = loopCountVar != null;
    boolean isKVContainer;
    if (Types.isArray(container) || Types.isArrayLocal(container)) {
        assert (!haveKeys || Types.isArrayKeyVal(container, loopCountVar.asArg()));
        isKVContainer = true;
    } else {
        assert (Types.isBag(container) || Types.isBagLocal(container));
        assert (!haveKeys);
        isKVContainer = false;
    }
    boolean localContainer = Types.isContainerLocal(container);
    if (localContainer) {
        if (!arrayClosed || splitDegree >= 0) {
            throw new STCRuntimeError("String_Node_Str");
        }
        assert (Types.isElemType(container, memberVar));
    } else {
        assert (Types.isElemValType(container, memberVar));
    }
    if (!arrayClosed) {
        throw new STCRuntimeError("String_Node_Str");
    }
    boolean isDict;
    Value tclContainer;
    if (splitDegree <= 0) {
        if (localContainer) {
            tclContainer = varToExpr(container);
            isDict = isKVContainer;
        } else {
            tclContainer = new Value(TCLTMP_ARRAY_CONTENTS);
            pointAdd(Turbine.enumerateAll(tclContainer.variable(), varToExpr(container), haveKeys));
            isDict = haveKeys;
        }
        Expression containerSize;
        if (isDict) {
            containerSize = Turbine.dictSize(tclContainer);
        } else {
            containerSize = Turbine.listLength(tclContainer);
        }
        handleForeachContainerRefcounts(perIterIncrs, constIncrs, containerSize);
    } else {
        assert (!localContainer);
        tclContainer = new Value(TCLTMP_ARRAY_CONTENTS);
        startForeachSplit(loopName, container, tclContainer.variable(), splitDegree, leafDegree, haveKeys, passedVars, perIterIncrs, constIncrs);
        isDict = haveKeys;
    }
    startForeachInner(tclContainer, memberVar, loopCountVar, isDict);
}

Output:
         tclContainer = new Value(TCLTMP_ARRAY_CONTENTS);
-        startForeachSplit(loopName, container, tclContainer.variable(), splitDegree, leafDegree, haveKeys, passedVars, perIterIncrs, constIncrs);
+        startForeachSplit(loopName, container, tclContainer.variable(), splitDegree, leafDegree, haveKeys, passedVars, perIterIncrs, constIncrs, perIterDecrs);
         isDict = haveKeys;


Input:
public String getStopTime() {
    return stopTime;
}

Output:
 public String getStopTime() {
-    return stopTime;
+    return _stopTime;
 }


Input:
public Set<QueryableEntry> getSubRecordsBetween(Comparable from, Comparable to) {
    takeReadLock();
    try {
        MultiResultSet results = createMultiResultSet();
        Comparable paramFrom = from;
        Comparable paramTo = to;
        int trend = paramFrom.compareTo(paramTo);
        if (trend == 0) {
            ConcurrentMap<Data, QueryableEntry> records = recordMap.get(paramFrom);
            if (records != null) {
                results.addResultSet(records);
            }
            return results;
        }
        if (trend < 0) {
            Comparable oldFrom = paramFrom;
            paramFrom = to;
            paramTo = oldFrom;
        }
        Set<Comparable> values = recordMap.keySet();
        for (Comparable value : values) {
            if (value.compareTo(paramFrom) <= 0 && value.compareTo(paramTo) >= 0) {
                ConcurrentMap<Data, QueryableEntry> records = recordMap.get(value);
                if (records != null) {
                    results.addResultSet(records);
                }
            }
        }
        return results;
    } finally {
        releaseReadLock();
    }
}

Output:
         }
-        Set<Comparable> values = recordMap.keySet();
-        for (Comparable value : values) {
+        for (Map.Entry<Comparable, ConcurrentMap<Data, QueryableEntry>> recordMapEntry : recordMap.entrySet()) {
+            Comparable value = recordMapEntry.getKey();
             if (value.compareTo(paramFrom) <= 0 && value.compareTo(paramTo) >= 0) {


Input:
private DefaultConnectFuture followRedirect(DefaultHttpSession httpSession, IoSessionEx session) {
    String location = httpSession.getReadHeader("String_Node_Str");
    ResourceAddress newConnectAddress = addressFactory.newResourceAddress(location.replaceFirst("String_Node_Str", "String_Node_Str"), new HttpRedirectResourceOptions(httpSession));
    DefaultConnectFuture connectFuture = new DefaultConnectFuture();
    HTTP_SESSION_KEY.remove(session);
    connectFuture.addListener(future -> session.close(false));
    httpSession.setRemoteAddress(newConnectAddress);
    schedulerProvider.submit(() -> {
        final HttpSessionFactory httpSessionFactory = new RedirectSessionFactory(httpSession);
        connectInternal0(connectFuture, newConnectAddress, httpSessionFactory);
    });
    return connectFuture;
}

Output:
     httpSession.setRemoteAddress(newConnectAddress);
-    schedulerProvider.submit(() -> {
-        final HttpSessionFactory httpSessionFactory = new RedirectSessionFactory(httpSession);
-        connectInternal0(connectFuture, newConnectAddress, httpSessionFactory);
-    });
+    final HttpSessionFactory httpSessionFactory = new RedirectSessionFactory(httpSession);
+    connectInternal0(connectFuture, newConnectAddress, httpSessionFactory);
     return connectFuture;


Input:
protected void createFilterConditionContent(Composite innerParent) {
    Composite anotherParent = new Composite(innerParent, SWT.NONE);
    GridData gd = new GridData(GridData.FILL_HORIZONTAL);
    anotherParent.setLayoutData(gd);
    GridLayout glayout = new GridLayout(4, false);
    anotherParent.setLayout(glayout);
    Label lb = new Label(anotherParent, SWT.NONE);
    lb.setText(Messages.getString("String_Node_Str"));
    Label lb2 = new Label(anotherParent, SWT.NONE);
    lb2.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    new Label(anotherParent, SWT.NONE);
    Composite condition = new Composite(innerParent, SWT.NONE);
    gd = new GridData(GridData.FILL_BOTH);
    gd.heightHint = 180;
    condition.setLayoutData(gd);
    glayout = new GridLayout(4, false);
    condition.setLayout(glayout);
    expression = new Combo(condition, SWT.NONE);
    GridData gdata = new GridData();
    gdata.widthHint = 100;
    expression.setLayoutData(gdata);
    expression.addListener(SWT.Selection, ComboModify);
    expression.setItems(getDataSetColumns());
    if (expression.getItemCount() == 0) {
        expression.add(DEUtil.resolveNull(null));
    }
    expression.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            if (expression.getText().equals(VALUE_OF_THIS_DATA_ITEM) && designHandle instanceof DataItemHandle) {
                expression.setText(DEUtil.getColumnExpression(((DataItemHandle) designHandle).getResultSetColumn()));
            }
            updateButtons();
            expression.setText(getExpression(expression.getText()));
        }
    });
    expression.addMouseListener(new MouseAdapter() {
        public void mouseUp(MouseEvent e) {
            if (expression.getItem(0).length() == 0 && tipsForCube != null) {
                updateMessage(tipsForCube, IMessageProvider.INFORMATION);
                tipsForCube = null;
            }
        }
    });
    expression.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            updateButtons();
            if (!expression.getText().equals(fCurrentExpr)) {
                needRefreshList = true;
                fCurrentExpr = expression.getText();
            }
        }
    });
    Button expBuilder = new Button(condition, SWT.PUSH);
    gdata = new GridData();
    gdata.heightHint = 20;
    gdata.widthHint = 20;
    expBuilder.setLayoutData(gdata);
    UIUtil.setExpressionButtonImage(expBuilder);
    expBuilder.setToolTipText(Messages.getString("String_Node_Str"));
    expBuilder.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            editValue(expression);
        }
    });
    operator = new Combo(condition, SWT.READ_ONLY);
    for (int i = 0; i < OPERATOR.length; i++) {
        operator.add(OPERATOR[i][0]);
    }
    operator.addSelectionListener(OpoertorSelection);
    create2ValueComposite(condition);
    if (inputHandle != null) {
        syncViewProperties();
    }
    lb = new Label(innerParent, SWT.SEPARATOR | SWT.HORIZONTAL);
    lb.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
}

Output:
     expression.setLayoutData(gdata);
-    expression.addListener(SWT.Selection, ComboModify);
+    expression.addListener(SWT.Selection, comboModifyListener);
     expression.setItems(getDataSetColumns());