Input:
public boolean onMessage(int source, int destination, int target, int flags, Object object) {
    Shuffle sortedMerger = sortedMergers.get(target);
    if (sortedMerger == null) {
        throw new RuntimeException("String_Node_Str" + target);
    }
    if ((flags & MessageFlags.EMPTY) == MessageFlags.EMPTY) {
        Set<Integer> finished = finishedSources.get(target);
        int worker = taskPlan.getExecutorForChannel(source);
        if (finished.contains(worker)) {
            LOG.log(Level.WARNING, String.format("String_Node_Str", this.thisWorker, worker));
        } else {
            finished.add(worker);
        }
        if (finished.size() == participatingWorkers.size()) {
            finishedTargets.add(target);
        }
        return true;
    }
    if (keyed) {
        List<KeyedContent> keyedContents = (List<KeyedContent>) object;
        for (KeyedContent kc : keyedContents) {
            Object data = kc.getValue();
            byte[] d = kryoSerializer.serialize(data);
            sortedMerger.add(kc.getKey(), d, d.length);
        }
        int total = totalReceives.get(target);
        total += keyedContents.size();
        totalReceives.put(target, total);
    } else {
        List<Object> contents = (List<Object>) object;
        for (Object kc : contents) {
            byte[] d = kryoSerializer.serialize(kc);
            sortedMerger.add(d, d.length);
        }
        int total = totalReceives.get(target);
        total += contents.size();
        totalReceives.put(target, total);
    }
    return true;
}

Output:
         Set<Integer> finished = finishedSources.get(target);
-        int worker = taskPlan.getExecutorForChannel(source);
-        if (finished.contains(worker)) {
-            LOG.log(Level.WARNING, String.format("String_Node_Str", this.thisWorker, worker));
+        if (finished.contains(source)) {
+            LOG.log(Level.WARNING, String.format("String_Node_Str", this.thisWorker, source));
         } else {


Input:
public void fireMessageEvent(EventObject evt) {
    logger.debug("String_Node_Str" + messageListeners.size() + "String_Node_Str" + evt.toString());
    Iterator listeners = null;
    synchronized (messageListeners) {
        listeners = new ArrayList(messageListeners).iterator();
    }
    while (listeners.hasNext()) {
        WhiteboardObjectListener listener = (WhiteboardObjectListener) listeners.next();
        if (evt instanceof WhiteboardObjectDeliveredEvent) {
            listener.whiteboardObjectDelivered((WhiteboardObjectDeliveredEvent) evt);
        } else if (evt instanceof WhiteboardObjectReceivedEvent) {
            WhiteboardObjectJabberImpl wbObj = (WhiteboardObjectJabberImpl) ((WhiteboardObjectReceivedEvent) evt).getSourceWhiteboardObject();
            listener.whiteboardObjectReceived((WhiteboardObjectReceivedEvent) evt);
            whiteboardObjects.add(wbObj);
        } else if (evt instanceof WhiteboardObjectDeletedEvent) {
            String wbObjID = ((WhiteboardObjectDeletedEvent) evt).getId();
            listener.whiteboardObjectDeleted((WhiteboardObjectDeletedEvent) evt);
            int i = 0;
            while (i < whiteboardObjects.size()) {
                WhiteboardObjectJabberImpl wbObj = (WhiteboardObjectJabberImpl) whiteboardObjects.get(i);
                if (wbObj.getID().equals(wbObjID))
                    whiteboardObjects.remove(i);
                else
                    i++;
            }
        } else if (evt instanceof WhiteboardObjectModifiedEvent) {
            WhiteboardObjectJabberImpl wbObj = (WhiteboardObjectJabberImpl) ((WhiteboardObjectReceivedEvent) evt).getSourceWhiteboardObject();
            listener.whiteboardObjecModified((WhiteboardObjectModifiedEvent) evt);
            whiteboardObjects.remove(wbObj);
            whiteboardObjects.add(wbObj);
        } else if (evt instanceof WhiteboardObjectDeliveryFailedEvent) {
            listener.whiteboardObjectDeliveryFailed((WhiteboardObjectDeliveryFailedEvent) evt);
        }
    }
}

Output:
             while (i < whiteboardObjects.size()) {
-                WhiteboardObjectJabberImpl wbObj = (WhiteboardObjectJabberImpl) whiteboardObjects.get(i);
+                WhiteboardObjectJabberImpl wbObj = whiteboardObjects.get(i);
                 if (wbObj.getID().equals(wbObjID))


Input:
public void updateACLForMilestone(String pWorkspaceId, int pId, Map<String, String> pUserEntries, Map<String, String> pGroupEntries) throws UserNotFoundException, UserNotActiveException, WorkspaceNotFoundException, MilestoneNotFoundException, AccessRightException {
    User user = userManager.checkWorkspaceReadAccess(pWorkspaceId);
    Milestone milestone = new MilestoneDAO(new Locale(user.getLanguage()), em).loadMilestone(pId);
    checkMilestoneWriteAccess(milestone, user);
    ACLFactory aclFactory = new ACLFactory(em);
    if (milestone.getACL() == null) {
        ACL acl = aclFactory.createACL(pWorkspaceId, pUserEntries, pGroupEntries);
        milestone.setACL(acl);
    } else {
        ACL acl = milestone.getACL();
        aclFactory.updateACL(acl, pUserEntries, pGroupEntries);
    }
}

Output:
         ACL acl = milestone.getACL();
-        aclFactory.updateACL(acl, pUserEntries, pGroupEntries);
+        aclFactory.updateACL(pWorkspaceId, acl, pUserEntries, pGroupEntries);
     }


Input:
public void deleteAllApps(HttpRequest request, HttpResponder responder) {
    appLifecycleHttpHandler.deleteAllApps(rewriteRequest(request), responder, Constants.DEFAULT_NAMESPACE);
}

Output:
 public void deleteAllApps(HttpRequest request, HttpResponder responder) {
-    appLifecycleHttpHandler.deleteAllApps(rewriteRequest(request), responder, Constants.DEFAULT_NAMESPACE);
+    appLifecycleHttpHandler.deleteAllApps(RESTMigrationUtils.rewriteV2RequestToV3(request), responder, Constants.DEFAULT_NAMESPACE);
 }


Input:
public void prepareForDeployment(final CloudFoundryServer server, final CloudFoundryApplicationModule appModule, final IProgressMonitor monitor) throws CoreException, OperationCanceledException {
    IModule module = appModule.getLocalModule();
    RepublishModule repModule = CloudFoundryPlugin.getModuleCache().getData(server.getServerOriginal()).untagForAutomaticRepublish(module);
    if (repModule != null) {
        ApplicationDeploymentInfo republishDeploymentInfo = repModule.getDeploymentInfo();
        if (republishDeploymentInfo != null) {
            DeploymentInfoWorkingCopy copy = appModule.getDeploymentInfoWorkingCopy();
            copy.setInfo(republishDeploymentInfo);
            copy.save();
        }
    }
    if (!appModule.validateDeploymentInfo().isOK()) {
        final ApplicationWizardDelegate providerDelegate = ApplicationWizardRegistry.getWizardProvider(appModule.getLocalModule());
        if (providerDelegate == null) {
            throw CloudErrorUtil.toCoreException("String_Node_Str" + appModule.getDeployedApplicationName() + "String_Node_Str" + server.getServer().getName() + "String_Node_Str" + appModule.getLocalModule().getModuleType().getId());
        }
        DeploymentInfoWorkingCopy workingCopy = null;
        try {
            workingCopy = new ManifestParser(appModule, server).load();
        } catch (CoreException ce) {
            CloudFoundryPlugin.log(ce);
        }
        final boolean[] cancelled = { false };
        final boolean[] writeToManifest = { false };
        final DeploymentInfoWorkingCopy finWorkingCopy = workingCopy;
        Display.getDefault().syncExec(new Runnable() {
            public void run() {
                CloudFoundryApplicationWizard wizard = new CloudFoundryApplicationWizard(server, appModule, finWorkingCopy, providerDelegate);
                WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getModalDialogShellProvider().getShell(), wizard);
                int status = dialog.open();
                if (status == Dialog.OK) {
                    final List<CloudService> addedServices = wizard.getCreatedCloudServices();
                    writeToManifest[0] = wizard.persistManifestChanges();
                    if (addedServices != null && !addedServices.isEmpty()) {
                        IProgressMonitor subMonitor = new SubProgressMonitor(monitor, addedServices.size());
                        try {
                            server.getBehaviour().createService(addedServices.toArray(new CloudService[0]), subMonitor);
                        } catch (CoreException e) {
                            CloudFoundryPlugin.log(e);
                        } finally {
                            subMonitor.done();
                        }
                    }
                } else {
                    cancelled[0] = true;
                }
            }
        });
        if (cancelled[0]) {
            throw new OperationCanceledException();
        } else {
            IStatus status = appModule.validateDeploymentInfo();
            if (!status.isOK()) {
                throw new CoreException(status);
            } else if (writeToManifest[0]) {
                IProgressMonitor subMonitor = new SubProgressMonitor(monitor, 1);
                try {
                    new ManifestParser(appModule, server).write(subMonitor);
                } catch (CoreException ce) {
                    CloudFoundryPlugin.logError(ce);
                } finally {
                    subMonitor.done();
                }
            }
        }
    }
}

Output:
         } else {
-            IStatus status = appModule.validateDeploymentInfo();
-            if (!status.isOK()) {
-                throw new CoreException(status);
+            if (status[0].isOK()) {
+                status[0] = appModule.validateDeploymentInfo();
+            }
+            if (!status[0].isOK()) {
+                throw new CoreException(status[0]);
             } else if (writeToManifest[0]) {


Input:
public boolean login(String serverURL, String username, String password, boolean validateLogin) throws Exception {
    try {
        SSLContext sc;
        sc = SSLContext.getInstance("String_Node_Str");
        HostnameVerifier hv = new HostnameVerifier() {
            public boolean verify(String urlHostName, SSLSession session) {
                return true;
            }
        };
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
            }
            public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
            }
        } };
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        SSLContext.setDefault(sc);
        HttpsURLConnection.setDefaultHostnameVerifier(hv);
    } catch (Exception e) {
        throw new RuntimeException("String_Node_Str", e);
    }
    try {
        initializeRestClient(serverURL, username, password);
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str", username);
        }
    } catch (AxisFault e) {
        System.out.println("String_Node_Str");
        throw new CommandException(e);
    }
    DefaultHttpClient httpClient = new DefaultHttpClient();
    try {
        if (validateLogin) {
            HttpResponse response = restClient.doGet(httpClient, restClient.getBaseURL() + initializeCookieEndpoint);
            if (response != null) {
                String responseCode = "String_Node_Str" + response.getStatusLine().getStatusCode();
                if ((responseCode.equals(CliConstants.RESPONSE_OK)) && (response.toString().contains("String_Node_Str"))) {
                    return true;
                } else {
                    System.out.println("String_Node_Str");
                    return false;
                }
            }
            return true;
        } else {
            return true;
        }
    } catch (ClientProtocolException e) {
        System.out.println("String_Node_Str");
        return false;
    } catch (ConnectException e) {
        System.out.println("String_Node_Str");
        return false;
    } finally {
        httpClient.getConnectionManager().shutdown();
    }
}

Output:
             }
-            return true;
+            return false;
         } else {


Input:
private void upgradeSettingsValues(SharedPreferences sp) {
    Log.d(TAG, "String_Node_Str");
    int configurationVersion = sp.getInt(CONFIGURATION_VERSION, 5);
    if (configurationVersion < 1) {
        boolean oldLandscapeFullScreenValue = sp.getBoolean("String_Node_Str", mContext.getResources().getBoolean(R.bool.settings_default_landscape_fullscreen));
        Log.i(TAG, "String_Node_Str");
        Editor e = sp.edit();
        e.putBoolean(mContext.getString(R.string.settings_key_landscape_fullscreen), oldLandscapeFullScreenValue);
        e.remove("String_Node_Str");
        e.putInt(CONFIGURATION_VERSION, 1);
        e.commit();
    }
    if (configurationVersion < 2) {
        Log.i(TAG, "String_Node_Str");
        Editor e = sp.edit();
        e.putString("String_Node_Str", mContext.getString(R.string.settings_default_portrait_keyboard_height_factor));
        e.putString("String_Node_Str", mContext.getString(R.string.settings_default_landscape_keyboard_height_factor));
        e.putInt(CONFIGURATION_VERSION, 2);
        e.commit();
    }
    if (configurationVersion < 3) {
        Editor e = sp.edit();
        if (Workarounds.getApiLevel() <= 7) {
            Log.i(TAG, "String_Node_Str");
            final String bottomRowKey = mContext.getString(R.string.settings_key_ext_kbd_bottom_row_key);
            String currentBottomRowId = sp.getString(bottomRowKey, mContext.getString(R.string.settings_default_ext_kbd_bottom_row_key));
            String newBottomRowId = "String_Node_Str";
            if (currentBottomRowId.equals("String_Node_Str")) {
                newBottomRowId = "String_Node_Str";
            } else if (currentBottomRowId.equals("String_Node_Str")) {
                newBottomRowId = "String_Node_Str";
            }
            if (!TextUtils.isEmpty(newBottomRowId)) {
                Log.i(TAG, "String_Node_Str" + currentBottomRowId + "String_Node_Str" + newBottomRowId + "String_Node_Str");
                e.putString(bottomRowKey, newBottomRowId);
            }
        }
        e.putInt(CONFIGURATION_VERSION, 3);
        e.commit();
    }
    if (configurationVersion < 4) {
        Editor e = sp.edit();
        Log.i(TAG, "String_Node_Str");
        e.putBoolean(mContext.getString(R.string.settings_key_landscape_fullscreen), mContext.getResources().getBoolean(R.bool.settings_default_landscape_fullscreen));
        e.putInt(CONFIGURATION_VERSION, 4);
        e.commit();
    }
    if (configurationVersion < 5) {
        Editor e = sp.edit();
        Log.i(TAG, "String_Node_Str");
        e.putBoolean(mContext.getString(R.string.settings_key_workaround_disable_rtl_fix), getAlwaysUseDrawTextDefault());
        e.putInt(CONFIGURATION_VERSION, 5);
        e.commit();
    }
}

Output:
     Log.d(TAG, "String_Node_Str");
-    int configurationVersion = sp.getInt(CONFIGURATION_VERSION, 5);
+    int configurationVersion = sp.getInt(CONFIGURATION_VERSION, 6);
     if (configurationVersion < 1) {


Input:
public static boolean isUpperCase(String in) {
    return in.equals(in.toUpperCase());
}

Output:
 public static boolean isUpperCase(String in) {
-    return in.equals(in.toUpperCase());
+    if (in == null || in.length() == 0)
+        return false;
+    for (int i = 0; i < in.length(); i++) {
+        if (!Character.isUpperCase(in.charAt(i)))
+            return false;
+    }
+    return true;
 }


Input:
public void caseStaticPutInst(StaticPutInst i) {
    emit("String_Node_Str" + slashify(i.getField().getDeclaringClass().getName()) + "String_Node_Str" + i.getField().getName() + "String_Node_Str" + jasminDescriptorOf(i.getField().getType()));
}

Output:
 public void caseStaticPutInst(StaticPutInst i) {
-    emit("String_Node_Str" + slashify(i.getField().getDeclaringClass().getName()) + "String_Node_Str" + i.getField().getName() + "String_Node_Str" + jasminDescriptorOf(i.getField().getType()));
+    emit("String_Node_Str" + slashify(i.getFieldRef().declaringClass().getName()) + "String_Node_Str" + i.getFieldRef().name() + "String_Node_Str" + jasminDescriptorOf(i.getFieldRef().type()));
 }


Input:
public void endElement(XPathFragment xPathFragment, UnmarshalRecord unmarshalRecord) {
    unmarshalRecord.removeNullCapableValue(this);
    XMLField xmlField = (XMLField) xmlDirectMapping.getField();
    if (!xmlField.getLastXPathFragment().nameIsText()) {
        return;
    }
    Object value = unmarshalRecord.getStringBuffer().toString();
    if (value.equals(EMPTY_STRING)) {
        value = null;
    }
    unmarshalRecord.resetStringBuffer();
    XMLConversionManager xmlConversionManager = (XMLConversionManager) unmarshalRecord.getSession().getDatasourcePlatform().getConversionManager();
    if (unmarshalRecord.getTypeQName() != null) {
        Class typeClass = xmlField.getJavaClass(unmarshalRecord.getTypeQName());
        value = xmlConversionManager.convertObject(value, typeClass, unmarshalRecord.getTypeQName());
    } else {
        value = xmlField.convertValueBasedOnSchemaType(value, xmlConversionManager);
    }
    Object convertedValue = xmlDirectMapping.getAttributeValue(value, unmarshalRecord.getSession(), unmarshalRecord);
    unmarshalRecord.setAttributeValue(convertedValue, xmlDirectMapping);
}

Output:
     } else {
-        value = xmlField.convertValueBasedOnSchemaType(value, xmlConversionManager);
+        value = xmlField.convertValueBasedOnSchemaType(value, xmlConversionManager, unmarshalRecord);
     }


Input:
private void testFactTableSaveAndLoad(IDocumentManager documentManager) throws IOException, BirtException {
    Dimension[] dimensions = new Dimension[3];
    String[] levelNames = new String[3];
    levelNames[0] = "String_Node_Str";
    levelNames[1] = "String_Node_Str";
    levelNames[2] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, FactTable1.L1Col);
    iterator.setLevelMember(1, FactTable1.L2Col);
    iterator.setLevelMember(2, FactTable1.L3Col);
    ILevelDefn[] levelDefs = new ILevelDefn[3];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    levelDefs[1] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    levelDefs[2] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[0].length(), FactTable1.L1Col.length);
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(FactTable1.L1Col));
    levelDefs = new ILevelDefn[1];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[1].length(), 3);
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    int[] lL1Col = { 1, 2, 3 };
    iterator.setLevelMember(0, lL1Col);
    levelDefs = new ILevelDefn[1];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[2] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[2].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[2].length(), 3);
    FactTable1 factTable1 = new FactTable1();
    String[] measureColumnName = new String[2];
    measureColumnName[0] = "String_Node_Str";
    measureColumnName[1] = "String_Node_Str";
    FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), factTable1, dimensions, measureColumnName, new StopSign());
    factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());
    assertEquals(factTable.getDimensionInfo()[0].dimensionName, "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[0].dimensionLength, FactTable1.L1Col.length);
    assertEquals(factTable.getDimensionInfo()[1].dimensionName, "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[1].dimensionLength, 3);
    assertEquals(factTable.getDimensionInfo()[2].dimensionName, "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[2].dimensionLength, 3);
    assertEquals(factTable.getMeasureInfo()[0].measureName, "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[0].dataType, DataType.INTEGER_TYPE);
    assertEquals(factTable.getMeasureInfo()[1].measureName, "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[1].dataType, DataType.DOUBLE_TYPE);
    String[] dimensionNames = new String[3];
    dimensionNames[0] = "String_Node_Str";
    dimensionNames[1] = "String_Node_Str";
    dimensionNames[2] = "String_Node_Str";
    IDiskArray[] dimensionPosition = new IDiskArray[3];
    dimensionPosition[0] = new BufferedPrimitiveDiskArray();
    dimensionPosition[0].add(new Integer(10));
    dimensionPosition[0].add(new Integer(11));
    dimensionPosition[1] = new BufferedPrimitiveDiskArray();
    dimensionPosition[1].add(new Integer(1));
    dimensionPosition[1].add(new Integer(2));
    dimensionPosition[2] = new BufferedPrimitiveDiskArray();
    dimensionPosition[2].add(new Integer(1));
    dimensionPosition[2].add(new Integer(2));
    dimensionPosition[2].add(new Integer(3));
    FactTableRowIterator facttableRowIterator = new FactTableRowIterator(factTable, dimensionNames, dimensionPosition, new StopSign());
    assertTrue(facttableRowIterator != null);
    assertTrue(facttableRowIterator.next());
    assertEquals(10, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(2, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(10), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(10), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(11, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(2, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(11), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(11), facttableRowIterator.getMeasure(1));
    assertFalse(facttableRowIterator.next());
}

Output:
     FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
-    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), factTable1, dimensions, measureColumnName, new StopSign());
+    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTable1, dimensions, measureColumnName, new StopSign());
     factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());


Input:
public void testClearUrlTranslatorCache() throws Exception {
    IdGenerator idGenerator = new FakeIdGenerator(ID);
    URLTranslator urlTranslator = new URLTranslator(idGenerator);
    urlTranslator.translate(ORIGINAL_URL);
    urlTranslator.clear();
    assertNull(urlTranslator.getOriginal(urlTranslator.getTranslation(ORIGINAL_URL)));
}

Output:
 public void testClearUrlTranslatorCache() throws Exception {
-    IdGenerator idGenerator = new FakeIdGenerator(ID);
-    URLTranslator urlTranslator = new URLTranslator(idGenerator);
+    URLTranslator urlTranslator = new URLTranslator();
     urlTranslator.translate(ORIGINAL_URL);


Input:
public void testAnalyticalDifferentiation() throws IntegratorException, DerivativeException {
    FirstOrderIntegrator integ = new DormandPrince54Integrator(1.0e-8, 100.0, 1.0e-4, 1.0e-4);
    SummaryStatistics residuals0 = new SummaryStatistics();
    SummaryStatistics residuals1 = new SummaryStatistics();
    for (double b = 2.88; b < 3.08; b += 0.001) {
        Brusselator brusselator = new Brusselator(b);
        brusselator.setParameter(0, b);
        double[] z = { 1.3, b };
        double[][] dZdZ0 = new double[2][2];
        double[][] dZdP = new double[2][1];
        FirstOrderIntegratorWithJacobians extInt = new FirstOrderIntegratorWithJacobians(integ, brusselator);
        extInt.integrate(0, z, new double[][] { { 0.0 }, { 1.0 } }, 20.0, z, dZdZ0, dZdP);
        residuals0.addValue(dZdP[0][0] - brusselator.dYdP0());
        residuals1.addValue(dZdP[1][0] - brusselator.dYdP1());
    }
    Assert.assertTrue((residuals0.getMax() - residuals0.getMin()) < 0.004);
    Assert.assertTrue(residuals0.getStandardDeviation() < 0.001);
    Assert.assertTrue((residuals1.getMax() - residuals1.getMin()) < 0.005);
    Assert.assertTrue(residuals1.getStandardDeviation() < 0.001);
}

Output:
         extInt.integrate(0, z, new double[][] { { 0.0 }, { 1.0 } }, 20.0, z, dZdZ0, dZdP);
-        residuals0.addValue(dZdP[0][0] - brusselator.dYdP0());
-        residuals1.addValue(dZdP[1][0] - brusselator.dYdP1());
+        residualsP0.addValue(dZdP[0][0] - brusselator.dYdP0());
+        residualsP1.addValue(dZdP[1][0] - brusselator.dYdP1());
     }


Input:
static <T extends AccountInfo> void serialize(JsonObject object, T src) {
    object.addProperty(MEMBER_ACCOUNT, src.account);
    object.addProperty(MEMBER_BALANCE, src.balance);
    object.addProperty(MEMBER_CURRENCY, src.currency.numericCode);
    object.addProperty(MEMBER_STATUS, src.accountStatus.code);
    object.addProperty(MEMBER_TYPE, src.accountType.code);
    object.add(MEMBER_BALANCE_DETAILS, BalanceDetailsTypeAdapter.getInstance().toJsonTree(src.balanceDetails));
}

Output:
     object.addProperty(MEMBER_BALANCE, src.balance);
-    object.addProperty(MEMBER_CURRENCY, src.currency.numericCode);
+    object.addProperty(MEMBER_CURRENCY, src.currency.numericCode.toString());
     object.addProperty(MEMBER_STATUS, src.accountStatus.code);


Input:
private static void start() throws Exception {
    File dataDir = new File("String_Node_Str");
    File gdalDir = new File("String_Node_Str");
    if (!dataDir.exists()) {
        throw new FileNotFoundException("String_Node_Str" + dataDir.getAbsolutePath());
    }
    if (!gdalDir.exists()) {
        throw new FileNotFoundException("String_Node_Str" + gdalDir.getAbsolutePath());
    }
    Object libc = Native.loadLibrary("String_Node_Str", WinLibC.class);
    ((WinLibC) libc)._putenv("String_Node_Str" + dataDir.getAbsolutePath());
    String path = System.getenv("String_Node_Str");
    path = path + "String_Node_Str" + gdalDir.getAbsolutePath();
    ((WinLibC) libc)._putenv("String_Node_Str" + path);
    String newLibPath = gdalDir.getAbsolutePath() + File.pathSeparator + System.getProperty("String_Node_Str");
    System.setProperty("String_Node_Str", newLibPath);
    Field fieldSysPath = ClassLoader.class.getDeclaredField("String_Node_Str");
    if (fieldSysPath != null) {
        fieldSysPath.setAccessible(true);
        fieldSysPath.set(System.class.getClassLoader(), null);
    }
    Application.start();
}

Output:
     String path = System.getenv("String_Node_Str");
-    path = path + "String_Node_Str" + gdalDir.getAbsolutePath();
+    path = gdalDir.getAbsolutePath() + "String_Node_Str" + path;
     ((WinLibC) libc)._putenv("String_Node_Str" + path);


Input:
private void prepareMetaData() {
    if (isMetaDataPrepared == true)
        return;
    HashMap queryIds = report.getQueryIDs();
    HashMap query2itemMapping = report.getReportItemToQueryMap();
    Iterator iter = queryIds.entrySet().iterator();
    while (iter.hasNext()) {
        Map.Entry entry = (Map.Entry) iter.next();
        IDataQueryDefinition baseQuery = (IDataQueryDefinition) entry.getKey();
        if (baseQuery instanceof IQueryDefinition) {
            IQueryDefinition query = (IQueryDefinition) baseQuery;
            String queryId = (String) entry.getValue();
            ReportItemDesign item = (ReportItemDesign) query2itemMapping.get(query);
            String queryName = item.getName();
            if (queryName == null) {
                queryName = "String_Node_Str" + item.getID();
            }
            queryId2NameMapping.put(queryId, queryName);
            queryId2QueryMapping.put(queryId, query);
            ;
        }
    }
    try {
        loadResultSetMetaData();
    } catch (EngineException e) {
        logger.log(Level.WARNING, e.getMessage(), e);
        executionContext.addException(e);
    }
    isMetaDataPrepared = true;
}

Output:
         loadResultSetMetaData();
-    } catch (EngineException e) {
+    } catch (Exception e) {
         logger.log(Level.WARNING, e.getMessage(), e);


Input:
public void onNext(HashMap<String, Object> map) {
    BaseResponse<LoginData> loginResponse = CommonUtils.cast(map.get(Constants.LOGIN_DATA));
    if (loginResponse.getErrorCode() == BaseResponse.SUCCESS) {
        mView.showAutoLoginSuccess();
    }
    mView.showBannerData(CommonUtils.cast(map.get(Constants.BANNER_DATA)));
    mView.showArticleList(CommonUtils.cast(map.get(Constants.ARTICLE_DATA)), true);
}

Output:
     mView.showBannerData(CommonUtils.cast(map.get(Constants.BANNER_DATA)));
-    mView.showArticleList(CommonUtils.cast(map.get(Constants.ARTICLE_DATA)), true);
+    mView.showArticleList(CommonUtils.cast(map.get(Constants.ARTICLE_DATA)));
 }


Input:
public void configure(Binder binder) {
    final ImmutableSet<Dependency<?>> dependencies = ImmutableSet.<Dependency<?>>of(Dependency.get(entrySetKey));
    final Provider<Set<Entry<K, Provider<V>>>> entrySetProvider = binder.getProvider(entrySetKey);
    binder.bind(providerMultimapKey).toProvider(new ProviderWithDependencies<Map<K, Set<Provider<V>>>>() {
        private Map<K, Set<Provider<V>>> providerMultimap;
        void initialize(Injector injector) {
            Map<K, ImmutableSet.Builder<Provider<V>>> providerMultimapMutable = new LinkedHashMap<K, ImmutableSet.Builder<Provider<V>>>();
            for (Entry<K, Provider<V>> entry : entrySetProvider.get()) {
                if (!providerMultimapMutable.containsKey(entry.getKey())) {
                    providerMultimapMutable.put(entry.getKey(), ImmutableSet.<Provider<V>>builder());
                }
                providerMultimapMutable.get(entry.getKey()).add(entry.getValue());
            }
            ImmutableMap.Builder<K, Set<Provider<V>>> providerMultimapBuilder = ImmutableMap.builder();
            for (Entry<K, ImmutableSet.Builder<Provider<V>>> entry : providerMultimapMutable.entrySet()) {
                providerMultimapBuilder.put(entry.getKey(), entry.getValue().build());
            }
            providerMultimap = providerMultimapBuilder.build();
        }
        public Map<K, Set<Provider<V>>> get() {
            return providerMultimap;
        }
        public Set<Dependency<?>> getDependencies() {
            return dependencies;
        }
    });
    final Provider<Map<K, Set<Provider<V>>>> multimapProvider = binder.getProvider(providerMultimapKey);
    binder.bind(multimapKey).toProvider(new ProviderWithDependencies<Map<K, Set<V>>>() {

        public Map<K, Set<V>> get() {
            ImmutableMap.Builder<K, Set<V>> multimapBuilder = ImmutableMap.builder();
            for (Entry<K, Set<Provider<V>>> entry : multimapProvider.get().entrySet()) {
                K key = entry.getKey();
                ImmutableSet.Builder<V> valuesBuilder = ImmutableSet.builder();
                for (Provider<V> valueProvider : entry.getValue()) {
                    V value = valueProvider.get();
                    checkConfiguration(value != null, "String_Node_Str", key);
                    valuesBuilder.add(value);
                }
                multimapBuilder.put(key, valuesBuilder.build());
            }
            return multimapBuilder.build();
        }
        public Set<Dependency<?>> getDependencies() {
            return dependencies;
        }
    });
}

Output:
     final Provider<Map<K, Set<Provider<V>>>> multimapProvider = binder.getProvider(providerMultimapKey);
-    binder.bind(multimapKey).toProvider(new ProviderWithDependencies<Map<K, Set<V>>>() {
+    binder.bind(multimapKey).toProvider(new RealMapBinderProviderWithDependencies<Map<K, Set<V>>>(multimapKey) {


Input:
protected void handleSendComplete(AsyncResult ar) {
    SmsTracker tracker = (SmsTracker) ar.userObj;
    PendingIntent sentIntent = tracker.mSentIntent;
    if (ar.exception == null) {
        if (Config.LOGD) {
            Log.d(TAG, "String_Node_Str" + "String_Node_Str" + sentIntent);
        }
        if (tracker.mDeliveryIntent != null) {
            int messageRef = ((SmsResponse) ar.result).messageRef;
            tracker.mMessageRef = messageRef;
            deliveryPendingList.add(tracker);
        }
        if (sentIntent != null) {
            try {
                sentIntent.send(Activity.RESULT_OK);
            } catch (CanceledException ex) {
            }
        }
    } else {
        if (Config.LOGD) {
            Log.d(TAG, "String_Node_Str");
        }
        int ss = mPhone.getServiceState().getState();
        if (ss != ServiceState.STATE_IN_SERVICE) {
            handleNotInService(ss, tracker);
        } else if ((((CommandException) (ar.exception)).getCommandError() == CommandException.Error.SMS_FAIL_RETRY) && tracker.mRetryCount < MAX_SEND_RETRIES) {
            tracker.mRetryCount++;
            Message retryMsg = obtainMessage(EVENT_SEND_RETRY, tracker);
            sendMessageDelayed(retryMsg, SEND_RETRY_DELAY);
        } else if (tracker.mSentIntent != null) {
            int error = RESULT_ERROR_GENERIC_FAILURE;
            if (((CommandException) (ar.exception)).getCommandError() == CommandException.Error.FDN_CHECK_FAILURE) {
                error = RESULT_ERROR_FDN_CHECK_FAILURE;
            }
            try {
                Intent fillIn = new Intent();
                if (ar.result != null) {
                    fillIn.putExtra("String_Node_Str", ((SmsResponse) ar.result).errorCode);
                }
                tracker.mSentIntent.send(mContext, error, fillIn);
            } catch (CanceledException ex) {
            }
        }
    }
}

Output:
             try {
-                sentIntent.send(Activity.RESULT_OK);
+                if (mRemainingMessages > -1) {
+                    mRemainingMessages--;
+                }
+                if (mRemainingMessages == 0) {
+                    Intent sendNext = new Intent();
+                    sendNext.putExtra(SEND_NEXT_MSG_EXTRA, true);
+                    sentIntent.send(mContext, Activity.RESULT_OK, sendNext);
+                } else {
+                    sentIntent.send(Activity.RESULT_OK);
+                }
             } catch (CanceledException ex) {


Input:
DataRowImpl getRow(int rowIdx, boolean create) {
    DataRowImpl rowObj = rows.get(rowIdx);
    if (rowObj == null) {
        rowObj = new DataRowImpl(this, rowIdx);
        rows.put(rowIdx, rowObj);
    }
    return rowObj;
}

Output:
     DataRowImpl rowObj = rows.get(rowIdx);
-    if (rowObj == null) {
+    if (rowObj == null && create) {
         rowObj = new DataRowImpl(this, rowIdx);


Input:
public void onPlayerJoin(final PlayerJoinEvent event) {
    Player p = event.getPlayer();
    if (p == null || !p.isOnline())
        return;
    xAuthPlayer xp = plyrMngr.getPlayer(p, plugin.getConfig().getBoolean("String_Node_Str"));
    String node = "String_Node_Str";
    if (xp.isFixSS()) {
        plyrMngr.unprotect(xp);
        xp.setFixSS(false);
    }
    if (xp.isRegistered() || plugin.isAuthURL()) {
        if (plyrMngr.checkSession(xp)) {
            xp.setStatus(Status.Authenticated);
            plugin.getAuthClass(xp).online(p.getName());
            node = "String_Node_Str";
        } else {
            xp.setStatus(Status.Registered);
            node = "String_Node_Str";
            plyrMngr.protect(xp);
        }
    } else if (plyrMngr.mustRegister(p)) {
        xp.setStatus(Status.Guest);
        node = "String_Node_Str";
        plyrMngr.protect(xp);
    }
    if (!node.isEmpty())
        sendDelayedMessage(p, node, 1);
}

Output:
             node = "String_Node_Str";
-            plyrMngr.protect(xp);
+            protect = true;
         }


Input:
public String getOwnOption(String option, String world) {
    return this.getOwnOption(option, world, "String_Node_Str");
}

Output:
 public String getOwnOption(String option, String world) {
-    return this.getOwnOption(option, world, "String_Node_Str");
+    return this.getOwnOption(option, world, null);
 }


Input:
public Response call() {
    Response response = null;
    if (processCommand != null && process != null) {
        Debug.log("String_Node_Str" + processCommand.getPID() + "String_Node_Str" + processCommand.getExpId() + "String_Node_Str");
        process.status = Process.STATUS_STARTED;
        try {
            processCommand.setFilePaths();
        } catch (SQLException | IOException e) {
            Debug.log(e.getMessage());
            ErrorLogger.log(process.author, "String_Node_Str" + e.getMessage());
            process.status = Process.STATUS_CRASHED;
            return null;
        }
        process.outputFiles = processCommand.getFilePaths();
        process.timeStarted = System.currentTimeMillis();
        try {
            response = processCommand.execute();
            if (response.getCode() == HttpStatusCode.CREATED || response.getCode() == HttpStatusCode.OK) {
                process.status = Process.STATUS_FINISHED;
                String successMsg = "String_Node_Str" + processCommand.getPID() + "String_Node_Str" + processCommand.getExpId() + "String_Node_Str";
                Debug.log(successMsg);
                ErrorLogger.log("String_Node_Str", successMsg);
            } else {
                System.out.println("String_Node_Str" + response.getCode());
                process.status = Process.STATUS_CRASHED;
                String crashedMsg = "String_Node_Str" + processCommand.getPID() + "String_Node_Str" + processCommand.getExpId() + "String_Node_Str";
                Debug.log(crashedMsg);
                ErrorLogger.log("String_Node_Str", crashedMsg);
            }
        } catch (NullPointerException e) {
            process.status = Process.STATUS_CRASHED;
        }
        if (simulateLongProcess) {
            ErrorLogger.log("String_Node_Str", "String_Node_Str");
            Debug.log("String_Node_Str" + processCommand.getPID());
            try {
                Thread.sleep(30000);
            } catch (InterruptedException ex) {
                Debug.log("String_Node_Str");
            }
            Debug.log("String_Node_Str" + processCommand.getPID());
        }
        process.timeFinished = System.currentTimeMillis();
        String timeMsg = "String_Node_Str" + processCommand.getPID() + "String_Node_Str" + formatTimeDifference((process.timeFinished - process.timeStarted) / 1000);
        Debug.log(timeMsg);
        ErrorLogger.log("String_Node_Str", timeMsg);
    }
    Debug.log("String_Node_Str" + processCommand.getPID());
    Debug.log("String_Node_Str" + ((ProcessResponse) response).getMessage());
    return response;
}

Output:
     Debug.log("String_Node_Str" + processCommand.getPID());
-    Debug.log("String_Node_Str" + ((ProcessResponse) response).getMessage());
+    Debug.log("String_Node_Str" + response.getMessage());
     return response;


Input:
public void clearLocalProperties() throws SemanticException {
    ActivityStack stack = module.getActivityStack();
    stack.startTrans();
    try {
        Iterator iter = propertyIterator();
        while (iter.hasNext()) {
            GroupPropertyHandle propHandle = (GroupPropertyHandle) iter.next();
            String propName = propHandle.getPropertyDefn().getName();
            if (DesignElement.EXTENDS_PROP.equals(propName)) {
                continue;
            }
            propHandle.clearValue();
        }
    } catch (SemanticException e) {
        stack.rollback();
        throw e;
    }
    stack.commit();
}

Output:
             }
-            propHandle.clearValue();
+            if (DesignElement.NAME_PROP.equals(propName)) {
+                for (Iterator elementIter = elements.iterator(); elementIter.hasNext(); ) {
+                    DesignElementHandle handle = (DesignElementHandle) elementIter.next();
+                    NameCommand nameCmd = new NameCommand(module, handle.getElement());
+                    try {
+                        nameCmd.checkName(null);
+                    } catch (NameException e) {
+                        continue;
+                    }
+                    PropertyHandle tmpPropHandle = handle.getPropertyHandle(propName);
+                    if (tmpPropHandle.isLocal())
+                        propHandle.clearValue();
+                }
+            } else {
+                String localValue = propHandle.getLocalStringValue();
+                if (localValue != null) {
+                    propHandle.clearValue();
+                }
+            }
         }


Input:
public void fire() throws IllegalActionException {
    super.fire();
    if (A.isKnown() && B.isKnown()) {
        BigInteger intResult = null;
        int bitsInResult = 0;
        if (A.hasToken(0) && B.hasToken(0)) {
            FixPoint valueA = ((FixToken) A.get(0)).fixValue();
            FixPoint valueB = ((FixToken) B.get(0)).fixValue();
            int bitsInA = valueA.getPrecision().getNumberOfBits();
            int bitsInB = valueB.getPrecision().getNumberOfBits();
            bitsInResult = bitsInA < bitsInB ? bitsInA : bitsInB;
            BigInteger bigIntA = valueA.getUnscaledValue();
            BigInteger bigIntB = valueB.getUnscaledValue();
            if (operation.getExpression().equals("String_Node_Str")) {
                intResult = bigIntA.and(bigIntB);
            } else if (operation.getExpression().equals("String_Node_Str")) {
                intResult = bigIntA.or(bigIntB);
            } else if (operation.getExpression().equals("String_Node_Str")) {
                intResult = bigIntA.and(bigIntB).not();
            } else if (operation.getExpression().equals("String_Node_Str")) {
                intResult = bigIntA.or(bigIntB).not();
            } else if (operation.getExpression().equals("String_Node_Str")) {
                intResult = bigIntA.xor(bigIntB);
            } else if (operation.getExpression().equals("String_Node_Str")) {
                intResult = bigIntA.xor(bigIntB).not();
            }
        }
        if (intResult != null) {
            Precision precision = new Precision(1, bitsInResult, 0);
            FixToken result = new FixToken(intResult.doubleValue(), precision);
            output.send(0, result);
        }
    } else {
        ((QueuedTypedIOPort) output).resend(0);
    }
}

Output:
             FixToken result = new FixToken(intResult.doubleValue(), precision);
-            output.send(0, result);
+            sendOutput(output, 0, result);
         }


Input:
public void reset() throws IOException {
    super.reset();
    jieba.reset();
}

Output:
     super.reset();
-    jieba.reset();
+    jieba.reset(this.input);
 }


Input:
public boolean hasExtensions() {
    for (DotNetQualifiedElement qualifiedElement : getMembers()) {
        if (CSharpMethodImplUtil.isExtensionMethod(qualifiedElement)) {
            return true;
        }
    }
    return false;
}

Output:
 public boolean hasExtensions() {
-    for (DotNetQualifiedElement qualifiedElement : getMembers()) {
-        if (CSharpMethodImplUtil.isExtensionMethod(qualifiedElement)) {
-            return true;
-        }
-    }
-    return false;
+    return CSharpTypeDeclarationImplUtil.hasExtensions(this);
 }


Input:
protected void createContentArea(Composite composite) {
    super.createContentArea(composite);
    composite.setLayout(new GridLayout(1, true));
    Link link = new Link(composite, SWT.NONE);
    link.setText(message);
    link.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            Browsers.openInExternalBrowser(e.text);
        }
    });
}

Output:
     composite.setLayout(new GridLayout(1, true));
-    Link link = new Link(composite, SWT.NONE);
+    Link link = new Link(composite, SWT.WRAP);
     link.setText(message);


Input:
public void trainOnInstanceImpl(Instance instance) {
    if (batch_ == null) {
        setParallelMode_(parallelModeOption.isSet());
        setNumClusters(numberClustersOption.getValue());
        attributes_ = Converter.convertAttributes(instance.enumerateAttributes(), instance.classAttribute());
        Variables modelHeader = new Variables(attributes_);
        clusterVar_ = modelHeader.newMultionomialVariable("String_Node_Str", getNumClusters());
        batch_ = new DataOnMemoryListContainer(attributes_);
        predictions_ = new VMP();
        predictions_.setSeed(this.randomSeed);
        dag = new DAG(modelHeader);
        if (isParallelMode_()) {
            dag.getParentSets().parallelStream().filter(w -> w.getMainVar().getVarID() != clusterVar_.getVarID()).forEach(w -> w.addParent(clusterVar_));
        } else {
            dag.getParentSets().stream().filter(w -> w.getMainVar().getVarID() != clusterVar_.getVarID()).filter(w -> w.getMainVar().isObservable()).forEach(w -> w.addParent(clusterVar_));
        }
        System.out.println(dag.toString());
        parameterLearningAlgorithm_ = new SVB();
    }
    if (windowCounter >= timeWindowOption.getValue()) {
        batch_ = new DataOnMemoryListContainer(attributes_);
        windowCounter = 0;
    }
    DataInstance dataInstance = new DataInstanceImpl(new DataRowWeka(instance, attributes_));
    windowCounter++;
    batch_.add(dataInstance);
}

Output:
         setNumClusters(numberClustersOption.getValue());
-        attributes_ = Converter.convertAttributes(instance.enumerateAttributes(), instance.classAttribute());
+        attributes_ = Converter.convertAttributes(getDataset(instance.numAttributes(), 0).enumerateAttributes());
         Variables modelHeader = new Variables(attributes_);


Input:
public TrainerBuilder skipSpaceFrequencyonCount(int count) {
    this.skipSpaceFrequency = skipSpaceFrequency;
    return this;
}

Output:
 public TrainerBuilder skipSpaceFrequencyonCount(int count) {
-    this.skipSpaceFrequency = skipSpaceFrequency;
+    this.skipSpaceFrequency = count;
     return this;


Input:
public Object getValue(int index, int selector, Object parameters) {
    if (index == 1) {
        return getLogicalName();
    } else if (index == 2) {
        int cnt = m_ObjectList.size();
        try {
            ByteArrayOutputStream data = new ByteArrayOutputStream();
            data.write((byte) DataType.ARRAY.getValue());
            GXCommon.setObjectCount(cnt, data);
            if (cnt != 0) {
                for (GXDLMSObject it : m_ObjectList) {
                    data.write((byte) DataType.STRUCTURE.getValue());
                    data.write((byte) 4);
                    GXCommon.setData(data, DataType.UINT16, it.getShortName());
                    GXCommon.setData(data, DataType.UINT16, it.getObjectType().getValue());
                    GXCommon.setData(data, DataType.UINT8, 0);
                    GXCommon.setData(data, DataType.OCTET_STRING, it.getLogicalName());
                }
                if (m_ObjectList.findBySN(this.getShortName()) == null) {
                    data.write((byte) DataType.STRUCTURE.getValue());
                    data.write((byte) 4);
                    GXCommon.setData(data, DataType.UINT16, this.getShortName());
                    GXCommon.setData(data, DataType.UINT16, this.getObjectType().getValue());
                    GXCommon.setData(data, DataType.UINT8, 0);
                    GXCommon.setData(data, DataType.OCTET_STRING, this.getLogicalName());
                }
            }
            return data.toByteArray();
        } catch (Exception ex) {
            Logger.getLogger(GXDLMSAssociationShortName.class.getName()).log(Level.SEVERE, null, ex);
            throw new RuntimeException(ex.getMessage());
        }
    } else if (index == 3) {
        boolean lnExists = m_ObjectList.findBySN(this.getShortName()) != null;
        int cnt = m_ObjectList.size();
        if (!lnExists) {
            ++cnt;
        }
        ByteArrayOutputStream data = new ByteArrayOutputStream();
        data.write((byte) DataType.ARRAY.getValue());
        GXCommon.setObjectCount(cnt, data);
        try {
            for (GXDLMSObject it : m_ObjectList) {
                getAccessRights(it, data);
            }
            if (!lnExists) {
                getAccessRights(this, data);
            }
        } catch (Exception ex) {
            Logger.getLogger(GXDLMSAssociationShortName.class.getName()).log(Level.SEVERE, null, ex);
            throw new RuntimeException(ex.getMessage());
        }
        return data.toByteArray();
    } else if (index == 4) {
    }
    throw new IllegalArgumentException("String_Node_Str");
}

Output:
                     data.write((byte) 4);
-                    GXCommon.setData(data, DataType.UINT16, it.getShortName());
+                    GXCommon.setData(data, DataType.INT16, it.getShortName());
                     GXCommon.setData(data, DataType.UINT16, it.getObjectType().getValue());


Input:
public static void main(String[] args) {
    RemoteRunner runner = new RemoteRunner();
    Thread debugthread = new Thread(runner, "String_Node_Str");
    debugthread.start();
    System.out.println("String_Node_Str");
    ReportVMClient client = new ReportVMClient();
    runner.client = client;
    client.addVMListener(runner);
    runner.installBreakpoints();
    try {
        client.connect(10000, 10001);
        System.out.println("String_Node_Str");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        client.connect(10000, 10001);
+        client.connect(10000);
         System.out.println("String_Node_Str");


Input:
private Node children(Node parent) throws XMLStreamException {
    while (reader.hasNext()) {
        XMLEvent event = reader.nextEvent();
        if (event instanceof EndElement)
            return parent;
        if (event instanceof CharacterEvent) {
            parent.setTextContent(((CharacterEvent) event).getData());
            return parent;
        }
        if (event instanceof StartElement)
            children(child(parent, (StartElement) event));
    }
    return parent;
}

Output:
             return parent;
-        if (event instanceof CharacterEvent) {
-            parent.setTextContent(((CharacterEvent) event).getData());
-            return parent;
-        }
+        if (event instanceof Characters)
+            parent.appendChild(parent.getOwnerDocument().createTextNode(((Characters) event).getData()));
         if (event instanceof StartElement)


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

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


Input:
public void addGetter(String getterTypeName, String fieldName) throws InstrumentException {
    try {
        Class<?> getterType = pluginContext.injectClass(classLoader, getterTypeName);
        GetterDetails getterDetails = new GetterAnalyzer().analyze(getterType);
        CtField field = ctClass.getField(fieldName);
        if (!field.getType().getName().equals(getterDetails.getFieldType().getName())) {
            throw new IllegalArgumentException("String_Node_Str" + getterDetails.getGetter() + "String_Node_Str" + field.getType().getName());
        }
        CtMethod getterMethod = CtNewMethod.getter(getterDetails.getGetter().getName(), field);
        if (getterMethod.getDeclaringClass() != ctClass) {
            getterMethod = CtNewMethod.copy(getterMethod, ctClass, null);
        }
        ctClass.addMethod(getterMethod);
        CtClass ctInterface = ctClass.getClassPool().get(getterTypeName);
        ctClass.addInterface(ctInterface);
    } catch (Exception e) {
        throw new InstrumentException("String_Node_Str" + getterTypeName, e);
    }
}

Output:
         CtField field = ctClass.getField(fieldName);
-        if (!field.getType().getName().equals(getterDetails.getFieldType().getName())) {
+        String fieldTypeName = JavaAssistUtils.javaClassNameToObjectName(getterDetails.getFieldType().getName());
+        if (!field.getType().getName().equals(fieldTypeName)) {
             throw new IllegalArgumentException("String_Node_Str" + getterDetails.getGetter() + "String_Node_Str" + field.getType().getName());


Input:
public void setUploadStatus(String jobId, Status status) {
    UploadJob uj = jobs.get(jobId);
    if (uj == null) {
        s_logger.warn("String_Node_Str" + jobId + "String_Node_Str" + status + "String_Node_Str");
        return;
    }
    TemplateUploader tu = uj.getTemplateUploader();
    s_logger.warn("String_Node_Str" + jobId + "String_Node_Str" + status);
    s_logger.warn("String_Node_Str" + tu.getUploadedBytes() + "String_Node_Str" + tu.getUploadError() + "String_Node_Str" + tu.getUploadPercent());
    switch(status) {
        case ABORTED:
        case NOT_STARTED:
        case UNRECOVERABLE_ERROR:
            uj.cleanup();
            break;
        case UNKNOWN:
            return;
        case IN_PROGRESS:
            s_logger.info("String_Node_Str" + jobId + "String_Node_Str" + status);
            tu.setResume(true);
            threadPool.execute(tu);
            break;
        case RECOVERABLE_ERROR:
            threadPool.execute(tu);
            break;
        case UPLOAD_FINISHED:
            tu.setUploadError("String_Node_Str");
            String result = postUpload(jobId);
            if (result != null) {
                s_logger.error("String_Node_Str" + result);
                tu.setStatus(Status.UNRECOVERABLE_ERROR);
                tu.setUploadError("String_Node_Str" + result);
            } else {
                s_logger.warn("String_Node_Str" + new SimpleDateFormat().format(new Date()));
                tu.setStatus(Status.POST_UPLOAD_FINISHED);
                tu.setUploadError("String_Node_Str" + new SimpleDateFormat().format(new Date()));
            }
            uj.cleanup();
            break;
        default:
            break;
    }
}

Output:
         case UNRECOVERABLE_ERROR:
-            uj.cleanup();
+            if (uj.getTemplateUploader().getUploadLocalPath().indexOf("String_Node_Str") > -1) {
+                uj.cleanup();
+            }
             break;


Input:
public void addLineToTicket(String ticketId, String productId) {
    ticket = new TicketDAO();
    product = new ProductDAO();
    category = new CategoryDAO();
    tax = new TaxDAO();
    taxesLogic = new TaxesLogic(tax.getTaxList());
    TicketInfo obj = ticket.getTicket(ticketId);
    ProductInfo productObj = null;
    productObj = product.findProductById(productId);
    TicketLineInfo line = new TicketLineInfo(productObj, productObj.getPriceSell(), taxesLogic.getTaxInfo(productObj.getCategoryId()));
    obj.addLine(line);
    ticket.updateTicket(ticketId, obj);
    refreshTax(obj);
}

Output:
     TicketInfo obj = ticket.getTicket(ticketId);
-    ProductInfo productObj = null;
-    productObj = product.findProductById(productId);
+    ProductInfo productObj = product.findProductById(productId);
     TicketLineInfo line = new TicketLineInfo(productObj, productObj.getPriceSell(), taxesLogic.getTaxInfo(productObj.getCategoryId()));


Input:
public void handleKey(KeyEvent event, Runnable finishedCallback) {
    mFinishedCallback = finishedCallback;
    dispatchKey(event);
}

Output:
     mFinishedCallback = finishedCallback;
-    dispatchKey(event);
+    dispatchKey(event, true);
 }


Input:
private void squaresToPositionList() {
    this.positionPatterns.reset();
    List<DetectPolygonFromContour.Info> infoList = squareDetector.getPolygonInfo();
    for (int i = 0; i < infoList.size(); i++) {
        DetectPolygonFromContour.Info info = infoList.get(i);
        if (info.hasInternal())
            continue;
        double grayThreshold = (info.edgeInside + info.edgeOutside) / 2;
        if (!checkPositionPatternAppearance(info.polygon, (float) grayThreshold))
            continue;
        squareDetector.refine(info);
        PositionPatternNode pp = this.positionPatterns.grow();
        pp.reset();
        pp.square = info.polygon;
        pp.grayThreshold = grayThreshold;
        graph.computeNodeInfo(pp);
    }
}

Output:
         DetectPolygonFromContour.Info info = infoList.get(i);
-        if (info.hasInternal())
+        if (!info.hasInternal())
             continue;


Input:
protected void writeValue(String value) {
    try {
        if (value.indexOf('&') > -1 || value.indexOf('<') > -1) {
            char[] chars = value.toCharArray();
            for (int x = 0, charsSize = chars.length; x < charsSize; x++) {
                char character = chars[x];
                switch(character) {
                    case '&':
                        {
                            writer.write("String_Node_Str");
                            break;
                        }
                    case '<':
                        {
                            writer.write("String_Node_Str");
                            break;
                        }
                    case '"':
                        {
                            writer.write("String_Node_Str");
                            break;
                        }
                    default:
                        writer.write(character);
                }
            }
        } else {
            writer.write(value);
        }
    } catch (IOException e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
     try {
-        if (value.indexOf('&') > -1 || value.indexOf('<') > -1) {
+        if (value.indexOf('"') > -1 || value.indexOf('&') > -1 || value.indexOf('<') > -1) {
             char[] chars = value.toCharArray();


Input:
public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    Component c = lafRenderer.getListCellRendererComponent(list, value, index, isSelected, false);
    selected = isSelected;
    JLabel label = (JLabel) c;
    SMS sms = (SMS) value;
    label.setText(!Nullator.isEmpty(sms.getName()) ? sms.getName() : OperatorUtil.stripCountryPrefix(sms.getNumber()));
    if ((sms.getStatus() == SMS.Status.PROBLEMATIC) && !isSelected) {
        label.setBackground(Color.RED);
    }
    delayLabel.setForeground(label.getForeground());
    delayLabel.setBackground(label.getBackground());
    panel.setBackground(label.getBackground());
    Operator operator = OperatorUtil.getOperator(sms.getOperator());
    label.setIcon(operator != null ? operator.getIcon() : Icons.OPERATOR_BLANK);
    String text = WordUtils.wrap(sms.getText(), 50, null, true);
    text = StringEscapeUtils.escapeHtml(text);
    text = text.replaceAll("String_Node_Str", "String_Node_Str");
    String tooltip = "String_Node_Str" + messageIconURI + "String_Node_Str" + label.getText() + "String_Node_Str" + (Nullator.isEmpty(sms.getName()) ? "String_Node_Str" : OperatorUtil.stripCountryPrefix(sms.getNumber()) + "String_Node_Str") + sms.getOperator() + "String_Node_Str" + text + "String_Node_Str";
    panel.setToolTipText(tooltip);
    if (sendingSMS.contains(sms)) {
        delayLabel.setIcon(sendIcon);
        delayLabel.setText(null);
    } else {
        delayLabel.setIcon(null);
        delayLabel.setText(convertDelayToHumanString(findCurrentDelay(sms)));
    }
    panel.add(label, BorderLayout.CENTER);
    return panel;
}

Output:
     String text = WordUtils.wrap(sms.getText(), 50, null, true);
-    text = StringEscapeUtils.escapeHtml(text);
+    text = Workarounds.escapeHtml(text);
     text = text.replaceAll("String_Node_Str", "String_Node_Str");


Input:
HttpURLConnection connect2() throws Exception {
    connect3_rateLimit();
    String url = "String_Node_Str" + method + "String_Node_Str";
    Map<String, String> vars = new HashMap();
    if (follow != null) {
        vars.put("String_Node_Str", InternalUtils.join(follow, 0, Integer.MAX_VALUE));
    }
    if (track != null) {
        vars.put("String_Node_Str", InternalUtils.join(track, 0, Integer.MAX_VALUE));
    }
    HttpURLConnection con = client.post2_connect(url, vars);
    return con;
}

Output:
     Map<String, String> vars = new HashMap();
-    if (follow != null) {
+    if (follow != null && (!follow.isEmpty())) {
         vars.put("String_Node_Str", InternalUtils.join(follow, 0, Integer.MAX_VALUE));


Input:
public void getDebugInfo(List<String> left, List<String> right, EnumFacing side) {
    left.add("String_Node_Str" + tank.getDebugString());
    if (world.isRemote) {
        left.add("String_Node_Str" + amount + "String_Node_Str" + target);
        left.add("String_Node_Str" + lastMessage + "String_Node_Str" + lastMessageMinus1 + "String_Node_Str" + (lastMessage - lastMessageMinus1));
    } else {
        left.add("String_Node_Str" + tank.getFluidAmount() + "String_Node_Str" + ((tank.getFluid() != null) ? "String_Node_Str" : "String_Node_Str"));
        left.add("String_Node_Str" + lastSentAmount + "String_Node_Str" + (lastSentFluid ? "String_Node_Str" : "String_Node_Str"));
    }
}

Output:
     left.add("String_Node_Str" + tank.getDebugString());
-    if (world.isRemote) {
-        left.add("String_Node_Str" + amount + "String_Node_Str" + target);
-        left.add("String_Node_Str" + lastMessage + "String_Node_Str" + lastMessageMinus1 + "String_Node_Str" + (lastMessage - lastMessageMinus1));
-    } else {
-        left.add("String_Node_Str" + tank.getFluidAmount() + "String_Node_Str" + ((tank.getFluid() != null) ? "String_Node_Str" : "String_Node_Str"));
-        left.add("String_Node_Str" + lastSentAmount + "String_Node_Str" + (lastSentFluid ? "String_Node_Str" : "String_Node_Str"));
-    }
+    smoothedTank.getDebugInfo(left, right, side);
 }


Input:
private void drawFilledCurve(GL2 gl, ArrayList<Float> dataVector) {
    float plotHeight = getPlotHeight();
    float plotWidth = getPlotWidth();
    float bottomAxisSpacing = (detailLevel == EDetailLevel.HIGH ? pixelGLConverter.getGLWidthForPixelWidth(BOTTOM_AXIS_SPACING_PIXELS) : 0);
    float leftAxisSpacing = (detailLevel == EDetailLevel.HIGH ? pixelGLConverter.getGLWidthForPixelWidth(LEFT_AXIS_SPACING_PIXELS) : 0);
    float TIME_BINS = maxAxisTime;
    float timeBinStepSize = 1 / TIME_BINS;
    float currentTimeBin = 0;
    int remainingItemCount = dataVector.size();
    float ySingleSampleSize = plotHeight / dataVector.size();
    for (int binIndex = 0; binIndex < TIME_BINS; binIndex++) {
        while (dataVector.size() > 0 && dataVector.get(0) <= currentTimeBin) {
            dataVector.remove(0);
            remainingItemCount--;
        }
        float y = (float) remainingItemCount * ySingleSampleSize;
        gl.glBegin(GL2.GL_QUADS);
        gl.glVertex3f(leftAxisSpacing + currentTimeBin * plotWidth, bottomAxisSpacing, 0);
        gl.glVertex3f(leftAxisSpacing + currentTimeBin * plotWidth, bottomAxisSpacing + y, 0);
        currentTimeBin += timeBinStepSize;
        gl.glVertex3f(leftAxisSpacing + currentTimeBin * plotWidth, bottomAxisSpacing + y, 0);
        gl.glVertex3f(leftAxisSpacing + currentTimeBin * plotWidth, bottomAxisSpacing, 0);
        gl.glEnd();
    }
}

Output:
     float leftAxisSpacing = (detailLevel == EDetailLevel.HIGH ? pixelGLConverter.getGLWidthForPixelWidth(LEFT_AXIS_SPACING_PIXELS) : 0);
-    float TIME_BINS = maxAxisTime;
-    float timeBinStepSize = 1 / TIME_BINS;
+    float timeBinStepSize = 1 / maxAxisTime;
     float currentTimeBin = 0;


Input:
public void onCallDisconnected(final Call call) {
    try {
        mSipAccount.setRegistration(false);
    } catch (Exception e) {
        e.printStackTrace();
    }
    if (!mUserHangupCall && mCallIsConnected) {
        mToneGenerator.startTone(ToneGenerator.TONE_CDMA_NETWORK_BUSY, 1500);
    }
    setCurrentCall(null);
    if (PhonePermission.hasPermission(getApplicationContext())) {
        unregisterReceiver(mGsmCallListener);
    }
    broadcast(SipConstants.CALL_DISCONNECTED_MESSAGE);
    stopSelf();
}

Output:
     setCurrentCall(null);
-    if (PhonePermission.hasPermission(getApplicationContext())) {
+    if (PhonePermission.hasPermission(getApplicationContext()) && mCallIsConnected) {
         unregisterReceiver(mGsmCallListener);


Input:
public CAstNode visitSwitchStatement(SwitchStatement node, WalkContext context) {
    int i = 0;
    CAstNode[] children = new CAstNode[node.getCases().size() * 2];
    for (SwitchCase sc : node.getCases()) {
        CAstNode label = Ast.makeNode(CAstNode.LABEL_STMT, Ast.makeConstant(String.valueOf(i / 2)), Ast.makeNode(CAstNode.EMPTY));
        context.cfg().map(label, label);
        children[i++] = label;
        if (sc.isDefault()) {
            context.cfg().add(node, label, CAstControlFlowMap.SWITCH_DEFAULT);
        } else {
            CAstNode labelCAst = visit(sc.getExpression(), context);
            context.cfg().add(node, label, labelCAst);
        }
        children[i++] = visit(sc, context);
    }
    CAstNode s = Ast.makeNode(CAstNode.SWITCH, visit(node.getExpression(), context), Ast.makeNode(CAstNode.BLOCK_STMT, children));
    context.cfg().map(node, s);
    return s;
}

Output:
         }
-        children[i++] = visit(sc, context);
+        children[i++] = visit(sc, switchBodyContext);
     }


Input:
public AccountInfo getAccountInformation(Account account) throws Exception {
    AccountInfo ai = new AccountInfo(this, account);
    this.setBrowserExclusive();
    try {
        login(account);
    } catch (PluginException e) {
        ai.setValid(false);
        return ai;
    }
    String trafficleft = br.getRegex(Pattern.compile("String_Node_Str", Pattern.CASE_INSENSITIVE | Pattern.DOTALL)).getMatch(0);
    String validuntil = br.getRegex(Pattern.compile("String_Node_Str", Pattern.CASE_INSENSITIVE | Pattern.DOTALL)).getMatch(0);
    ai.setTrafficLeft(trafficleft);
    SimpleDateFormat dateFormat = new SimpleDateFormat("String_Node_Str");
    try {
        Date date = dateFormat.parse(validuntil);
        ai.setValidUntil(date.getTime());
    } catch (ParseException e) {
        return null;
    }
    ai.setValid(true);
    return ai;
}

Output:
     SimpleDateFormat dateFormat = new SimpleDateFormat("String_Node_Str");
-    try {
-        Date date = dateFormat.parse(validuntil);
-        ai.setValidUntil(date.getTime());
-    } catch (ParseException e) {
-        return null;
-    }
+    String[] splitted = validuntil.split("String_Node_Str");
+    Date date = dateFormat.parse(splitted[2] + "String_Node_Str" + splitted[1] + "String_Node_Str" + splitted[0]);
+    ai.setValidUntil(date.getTime());
     ai.setValid(true);


Input:
public boolean apply(Game game, Ability source) {
    Player defender = null;
    if (attackerIsSource) {
        defender = game.getPlayer(game.getCombat().getDefenderId(source.getSourceId()));
    } else {
        defender = game.getPlayer(game.getCombat().getDefenderId(getTargetPointer().getFirst(game, source)));
    }
    if (defender != null) {
        defender.loseLife(amount.calculate(game, source, this), game);
    }
    return true;
}

Output:
     } else {
-        defender = game.getPlayer(game.getCombat().getDefenderId(getTargetPointer().getFirst(game, source)));
+        defender = game.getPlayer(getTargetPointer().getFirst(game, source));
     }


Input:
public void createCriteriaAndDefinition(ModelConfiguration config) {
    config.removeAllCriteria();
    for (String attr : config.getInput().getDefinition().getQuasiIdentifyingAttributes()) {
        config.getInput().getDefinition().setAttributeType(attr, config.getHierarchy(attr));
    }
    if (this.kAnonymityModel != null && this.kAnonymityModel.isActive() && this.kAnonymityModel.isEnabled()) {
        config.addCriterion(this.kAnonymityModel.getCriterion(this));
    }
    if (this.dPresenceModel != null && this.dPresenceModel.isActive() && this.dPresenceModel.isEnabled()) {
        config.addCriterion(this.dPresenceModel.getCriterion(this));
    }
    for (Entry<String, ModelLDiversityCriterion> entry : this.lDiversityModel.entrySet()) {
        if (entry.getValue() != null && entry.getValue().isActive() && entry.getValue().isEnabled()) {
            config.addCriterion(entry.getValue().getCriterion(this));
        }
    }
    for (Entry<String, ModelTClosenessCriterion> entry : this.tClosenessModel.entrySet()) {
        if (entry.getValue() != null && entry.getValue().isActive() && entry.getValue().isEnabled()) {
            config.addCriterion(entry.getValue().getCriterion(this));
        }
    }
    if (!config.containsCriterion(DPresence.class)) {
        if (getInputConfig() != null && getInputConfig().getInput() != null && getInputConfig().getResearchSubset() != null) {
            DataSubset subset = DataSubset.create(getInputConfig().getInput(), getInputConfig().getResearchSubset());
            config.addCriterion(new Inclusion(subset));
        }
    }
}

Output:
     for (String attr : config.getInput().getDefinition().getQuasiIdentifyingAttributes()) {
-        config.getInput().getDefinition().setAttributeType(attr, config.getHierarchy(attr));
+        Hierarchy hierarchy = config.getHierarchy(attr);
+        Integer min = config.getMinimumGeneralization(attr);
+        Integer max = config.getMaximumGeneralization(attr);
+        if (min == null) {
+            min = 0;
+        }
+        if (max == null) {
+            if (hierarchy.getHierarchy().length == 0) {
+                max = 0;
+            } else {
+                max = hierarchy.getHierarchy()[0].length - 1;
+            }
+        }
+        config.getInput().getDefinition().setAttributeType(attr, hierarchy);
+        config.setMinimumGeneralization(attr, min);
+        config.setMaximumGeneralization(attr, max);
     }


Input:
private XhtmlNode addTableHeaderRowStandard(XhtmlNode t, boolean hasHierarchy, boolean hasDisplay, boolean definitions, boolean comments, boolean version, boolean deprecated, String lang) {
    XhtmlNode tr = t.tr();
    if (hasHierarchy)
        tr.td().b().tx("String_Node_Str");
    tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
    if (hasDisplay)
        tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
    if (definitions)
        tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
    if (deprecated)
        tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
    if (comments)
        tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
    if (version)
        tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
    return tr;
}

Output:
         tr.td().b().tx("String_Node_Str");
-    tr.td().b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
+    tr.td().attribute("String_Node_Str", "String_Node_Str").b().tx(context.translator().translate("String_Node_Str", "String_Node_Str", lang));
     if (hasDisplay)


Input:
private boolean doForwardStep() {
    Vector2 hit = CastRay(this.position, target.position);
    if (hit == target.position) {
        return true;
    }
    WayPoint wp = new WayPoint(hit, this, this.target, true);
    if (wp.CalculateNextPossibleWayPoints()) {
        possibleNextWaypoints.add(wp);
        return true;
    }
    return false;
}

Output:
 private boolean doForwardStep() {
-    Vector2 hit = CastRay(this.position, target.position);
-    if (hit == target.position) {
+    Vector2 hit = CastRay(this.position, target);
+    if (hit == target) {
+        Gdx.app.log("String_Node_Str", "String_Node_Str");
         return true;


Input:
public void place() {
    float offsetCounterX = 0.0f, offsetCounterY = 0.0f;
    if (this.mNextX != 0) {
        offsetCounterX = this.mNextX * this.mSpeed * this.mDeltaTime;
        this.mX += offsetCounterX;
        if (this.mNextX == 1) {
            if (this.mX >= (this.mUserPosX) * TILE_PIXEL_WIDTH) {
                this.updateUserPos();
                this.mMoving = false;
                this.mNextX = 0;
            }
        } else if (this.mNextX == -1) {
            if (this.mX <= (this.mUserPosX) * TILE_PIXEL_WIDTH) {
                this.updateUserPos();
                this.mMoving = false;
                this.mNextX = 0;
            }
        }
    }
    if (this.mNextY != 0) {
        offsetCounterY = this.mNextY * this.mSpeed * this.mDeltaTime;
        this.mY += offsetCounterY;
        if (this.mNextY == 1) {
            if (this.mY >= (this.mUserPosY) * TILE_PIXEL_HEIGHT) {
                this.updateUserPos();
                this.mMoving = false;
                this.mNextY = 0;
            }
        } else if (this.mNextY == -1) {
            if (this.mY <= (this.mUserPosY) * TILE_PIXEL_HEIGHT) {
                this.updateUserPos();
                this.mMoving = false;
                this.mNextY = 0;
            }
        }
    }
    this.updateLight(this.mX, this.mY);
}

Output:
     float offsetCounterX = 0.0f, offsetCounterY = 0.0f;
-    if (this.mNextX != 0) {
-        offsetCounterX = this.mNextX * this.mSpeed * this.mDeltaTime;
-        this.mX += offsetCounterX;
-        if (this.mNextX == 1) {
-            if (this.mX >= (this.mUserPosX) * TILE_PIXEL_WIDTH) {
-                this.updateUserPos();
-                this.mMoving = false;
-                this.mNextX = 0;
-            }
-        } else if (this.mNextX == -1) {
-            if (this.mX <= (this.mUserPosX) * TILE_PIXEL_WIDTH) {
-                this.updateUserPos();
-                this.mMoving = false;
-                this.mNextX = 0;
-            }
+    offsetCounterX = this.mNextX * this.mSpeed * this.mDeltaTime;
+    this.mX += offsetCounterX;
+    offsetCounterY = this.mNextY * this.mSpeed * this.mDeltaTime;
+    this.mY += offsetCounterY;
+    if (this.mNextX == 1) {
+        if (this.mX >= (this.mUserPosX) * TILE_PIXEL_WIDTH) {
+            this.updateUserPos();
+            this.mMoving = false;
+            this.mNextX = 0;
+        }
+    } else if (this.mNextX == -1) {
+        if (this.mX <= (this.mUserPosX) * TILE_PIXEL_WIDTH) {
+            this.updateUserPos();
+            this.mMoving = false;
+            this.mNextX = 0;
         }


Input:
public List<Object> findByRelation(String colName, Object colValue, Class entityClazz) {
    EntityMetadata m = KunderaMetadataManager.getEntityMetadata(entityClazz);
    DBCollection dbCollection = mongoDb.getCollection(m.getTableName());
    BasicDBObject query = new BasicDBObject();
    query.put(colName, colValue);
    DBCursor cursor = dbCollection.find(query);
    DBObject fetchedDocument = null;
    List<Object> results = new ArrayList<Object>();
    while (cursor.hasNext()) {
        fetchedDocument = cursor.next();
        Object entity = handler.getEntityFromDocument(m.getEntityClazz(), m, fetchedDocument, null);
        results.add(entity);
    }
    return results.isEmpty() ? null : results;
}

Output:
     BasicDBObject query = new BasicDBObject();
-    query.put(colName, colValue);
+    query.put(colName, handler.populateValue(colValue, colValue.getClass()));
     DBCursor cursor = dbCollection.find(query);


Input:
public void resumeSchedule(HttpRequest request, HttpResponder responder, String appId, String scheduleName) {
    programLifecycleHttpHandler.performAction(rewriteRequest(request), responder, Constants.DEFAULT_NAMESPACE, appId, "String_Node_Str", scheduleName, "String_Node_Str");
}

Output:
 public void resumeSchedule(HttpRequest request, HttpResponder responder, String appId, String scheduleName) {
-    programLifecycleHttpHandler.performAction(rewriteRequest(request), responder, Constants.DEFAULT_NAMESPACE, appId, "String_Node_Str", scheduleName, "String_Node_Str");
+    programLifecycleHttpHandler.performAction(RESTMigrationUtils.rewriteV2RequestToV3(request), responder, Constants.DEFAULT_NAMESPACE, appId, "String_Node_Str", scheduleName, "String_Node_Str");
 }


Input:
public boolean setOutline(PlotArea plotArea, PlotId plotId, PlotBlock[] blocks) {
    ClassicPlotWorld dpw = (ClassicPlotWorld) plotArea;
    if (dpw.ROAD_WIDTH == 0) {
        return false;
    }
    Plot plot = plotArea.getPlotAbs(plotId);
    Location bottom = plot.getBottomAbs();
    Location top = plot.getExtendedTopAbs();
    PseudoRandom random = new PseudoRandom();
    LocalBlockQueue queue = plotArea.getQueue(false);
    int maxY = plotArea.getPlotManager().getWorldHeight();
    if (!plot.getMerged(0)) {
        int z = bottom.getZ();
        for (int x = bottom.getX(); x <= top.getX(); x++) {
            for (int y = dpw.PLOT_HEIGHT; y <= Math.min(maxY, 255); y++) {
                queue.setBlock(x, y, z, blocks[random.random(blocks.length)]);
            }
        }
    }
    if (!plot.getMerged(3)) {
        int x = bottom.getX();
        for (int z = bottom.getZ(); z <= top.getZ(); z++) {
            for (int y = dpw.PLOT_HEIGHT; y <= Math.min(maxY, 255); y++) {
                queue.setBlock(x, y, z, blocks[random.random(blocks.length)]);
            }
        }
    }
    if (!plot.getMerged(2)) {
        int z = top.getZ();
        for (int x = bottom.getX(); x <= top.getX(); x++) {
            for (int y = dpw.PLOT_HEIGHT; y <= Math.min(maxY, 255); y++) {
                queue.setBlock(x, y, z, blocks[random.random(blocks.length)]);
            }
        }
    }
    if (!plot.getMerged(1)) {
        int x = top.getX();
        for (int z = bottom.getZ(); z <= top.getZ(); z++) {
            for (int y = dpw.PLOT_HEIGHT; y <= Math.min(maxY, 255); y++) {
                queue.setBlock(x, y, z, blocks[random.random(blocks.length)]);
            }
        }
    }
    if (plot.isBasePlot()) {
        for (RegionWrapper region : plot.getRegions()) {
            Location pos1 = new Location(plotArea.worldname, region.minX, Math.min(maxY, 255), region.minZ);
            Location pos2 = new Location(plotArea.worldname, region.maxX, Math.min(maxY, 255), region.maxZ);
            queue.setCuboid(pos1, pos2, blocks);
        }
    }
    queue.enqueue();
    return true;
}

Output:
         for (int x = bottom.getX(); x <= top.getX(); x++) {
-            for (int y = dpw.PLOT_HEIGHT; y <= Math.min(maxY, 255); y++) {
+            for (int y = dpw.PLOT_HEIGHT; y <= maxY; y++) {
                 queue.setBlock(x, y, z, blocks[random.random(blocks.length)]);


Input:
public static int hash(String str) {
    int len = str.length();
    return len + asso_values[str.charAt(len - 1)] + asso_values[str.charAt(0)];
}

Output:
 public static int hash(String str) {
-    int len = str.length();
-    return len + asso_values[str.charAt(len - 1)] + asso_values[str.charAt(0)];
+    int hashValue = str.length();
+    switch(hashValue) {
+        default:
+            hashValue += asso_values[str.charAt(11)];
+        case 11:
+        case 10:
+        case 9:
+        case 8:
+        case 7:
+        case 6:
+        case 5:
+        case 4:
+        case 3:
+            hashValue += asso_values[str.charAt(2)];
+        case 2:
+        case 1:
+            hashValue += asso_values[str.charAt(0)];
+            break;
+    }
+    return hashValue + asso_values[str.charAt(str.length() - 1)];
 }


Input:
public static void process() {
    if (current != null) {
        return;
    }
    boolean doNext;
    do {
        now = Float.MAX_VALUE;
        current = null;
        Arrays.fill(chars, null);
        for (Actor actor : all) {
            if (actor.time < now) {
                now = actor.time;
                current = actor;
            }
            if (actor instanceof Char) {
                Char ch = (Char) actor;
                chars[ch.pos] = ch;
            }
        }
        if (current != null) {
            doNext = current.act();
            if (doNext && !Dungeon.hero.isAlive()) {
                doNext = false;
                current = null;
            }
        } else {
            doNext = false;
        }
    } while (doNext);
}

Output:
         for (Actor actor : all) {
-            if (actor.time < now) {
+            if (actor.time < now || (actor instanceof Hero && actor.time == now)) {
                 now = actor.time;


Input:
public static void main(final String[] args) throws Exception {
    final CheckHandleTest test = new CheckHandleTest();
    test.testCheck();
}

Output:
 public static void main(final String[] args) throws Exception {
-    final CheckHandleTest test = new CheckHandleTest();
-    test.testCheck();
+    final IdleHandleTest test = new IdleHandleTest();
+    test.testIdle();
 }


Input:
private void writeResponse(RopResponse ropResponse, HttpServletResponse httpServletResponse, MessageFormat messageFormat) {
    try {
        httpServletResponse.setCharacterEncoding(UTF_8);
        if (messageFormat == MessageFormat.xml) {
            httpServletResponse.setContentType(APPLICATION_XML);
            xmlMarshallerRop.marshaller(ropResponse, httpServletResponse.getOutputStream());
        } else {
            httpServletResponse.setContentType(APPLICATION_JSON);
            jsonMarshallerRop.marshaller(ropResponse, httpServletResponse.getOutputStream());
        }
    } catch (IOException e) {
        throw new RopException(e);
    }
}

Output:
     try {
-        httpServletResponse.setCharacterEncoding(UTF_8);
+        httpServletResponse.setCharacterEncoding(Constants.UTF8);
         if (messageFormat == MessageFormat.xml) {


Input:
public static org.hl7.fhir.dstu2016may.model.StructureDefinition.StructureDefinitionDifferentialComponent convertStructureDefinitionDifferentialComponent(org.hl7.fhir.dstu3.model.StructureDefinition.StructureDefinitionDifferentialComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.StructureDefinition.StructureDefinitionDifferentialComponent tgt = new org.hl7.fhir.dstu2016may.model.StructureDefinition.StructureDefinitionDifferentialComponent();
    copyElement(src, tgt);
    for (org.hl7.fhir.dstu3.model.ElementDefinition t : src.getElement()) tgt.addElement(convertElementDefinition(t));
    return tgt;
}

Output:
 public static org.hl7.fhir.dstu2016may.model.StructureDefinition.StructureDefinitionDifferentialComponent convertStructureDefinitionDifferentialComponent(org.hl7.fhir.dstu3.model.StructureDefinition.StructureDefinitionDifferentialComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
protected void paintTo(GlimpseContext context, GlimpseBounds bounds, Axis2D axis) {
    if (axis == null && !drawInPixelCoords) {
        throw new AxisNotSetException(this, context);
    }
    double x = drawInPixelCoords ? this.x : axis.getAxisX().valueToScreenPixelUnits(this.x);
    double y = drawInPixelCoords ? this.y : axis.getAxisY().valueToScreenPixelUnits(this.y);
    if (icons == null) {
        loadIcons();
    }
    if (newFont != null) {
        updateTextRenderer();
    }
    if (text != null && textLayout == null && textRenderer != null) {
        updateTextLayout();
    }
    GL2 gl = context.getGL().getGL2();
    int width = bounds.getWidth();
    int height = bounds.getHeight();
    gl.glMatrixMode(GL2.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(-0.5, width - 1 + 0.5, -0.5, height - 1 + 0.5, -1, 1);
    gl.glMatrixMode(GL2.GL_MODELVIEW);
    gl.glLoadIdentity();
    gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
    gl.glEnable(GL2.GL_BLEND);
    double iconHeight = 0;
    if (icons != null)
        iconHeight = iconSize * icons.size() + iconSpacing * (icons.size() - 1);
    double textHeight = 0;
    if (lines != null)
        textHeight = (textLayout.getAscent()) * lines.size() + lineSpacing * (lines.size() - 1);
    int boundingHeight = (int) (borderSize * 2 + Math.max(iconHeight, textHeight));
    float textLength = 0;
    if (lines != null)
        for (int k = 0; k < lines.size(); k++) textLength = Math.max(textLength, lines.get(0).width);
    int boundingWidth = (int) (borderSize * 2 + iconSize + textLength);
    if (iconIds != null && !iconIds.isEmpty() && lines != null)
        boundingWidth += textIconSpacing;
    double clampX = offsetX, clampY = offsetY;
    if (clampToScreenEdges) {
        if (x + boundingWidth + offsetX > bounds.getWidth())
            clampX = bounds.getWidth() - boundingWidth - x;
        if (x + offsetX < 0)
            clampX = -x;
        if (y + offsetY > bounds.getHeight())
            clampY = bounds.getHeight() - y;
        if (boundingHeight > y + offsetY)
            clampY = boundingHeight - y;
    }
    if (this.paintBackground || this.paintBorder) {
        if (this.paintBackground) {
            gl.glColor4fv(backgroundColor, 0);
            gl.glBegin(GL2.GL_QUADS);
            try {
                borderVertices(gl, boundingHeight, boundingWidth, x + clampX, y + clampY);
            } finally {
                gl.glEnd();
            }
        }
        if (this.paintBorder) {
            gl.glColor4fv(borderColor, 0);
            gl.glEnable(GL2.GL_LINE_SMOOTH);
            gl.glBegin(GL2.GL_LINE_LOOP);
            try {
                borderVertices(gl, boundingHeight, boundingWidth, x + clampX, y + clampY);
            } finally {
                gl.glEnd();
            }
        }
    }
    gl.glDisable(GL2.GL_BLEND);
    if (lines != null && textRenderer != null) {
        GlimpseColor.setColor(textRenderer, textColor);
        textRenderer.beginRendering(width, height);
        try {
            double posX = x + iconSize + borderSize;
            if (iconIds != null && !iconIds.isEmpty())
                posX += textIconSpacing;
            double posY = y - borderSize - textLayout.getAscent();
            double iconPosY = Float.NEGATIVE_INFINITY;
            if (wrapTextAroundIcon && icons != null)
                iconPosY = y - (iconSize * icons.size() + iconSpacing * (icons.size() - 1) + borderSize);
            for (int i = 0; i < lines.size(); i++) {
                if (posY + textLayout.getAscent() < iconPosY)
                    posX = x + borderSize;
                textRenderer.draw(lines.get(i).text, (int) (posX + clampX), (int) (posY + clampY));
                posY = posY - lineSpacing - (textLayout.getAscent());
            }
        } finally {
            textRenderer.endRendering();
        }
    }
    if (iconIds != null && !iconIds.isEmpty()) {
        atlas.beginRendering();
        try {
            double posY = y - borderSize - iconSize;
            for (int i = 0; i < iconIds.size(); i++) {
                Object iconId = iconIds.get(i);
                ImageData iconData = icons.get(i);
                if (iconId != null && iconData != null) {
                    double iconScale = iconSize / (double) iconData.getWidth();
                    float[] color = defaultIconColor;
                    if (iconColors != null && i < iconColors.size()) {
                        float[] iconColor = iconColors.get(i);
                        if (iconColor != null)
                            color = iconColor;
                    }
                    GlimpseColor.glColor(gl, color);
                    atlas.drawImage(gl, iconId, (int) (x + borderSize + clampX), (int) (posY + clampY), iconScale, iconScale, 0, iconData.getHeight());
                    posY = posY - iconSize - iconSpacing;
                }
            }
        } finally {
            atlas.endRendering();
        }
    }
}

Output:
     if (lines != null)
-        textHeight = (textLayout.getAscent()) * lines.size() + lineSpacing * (lines.size() - 1);
+        textHeight = (textLayout.getLineHeight()) * lines.size() + lineSpacing * (lines.size() - 1);
     int boundingHeight = (int) (borderSize * 2 + Math.max(iconHeight, textHeight));


Input:
public void LoadWolves() {
    int anzahlWolves = 0;
    int invSlot = 0;
    double WolfX;
    double WolfY;
    double WolfZ;
    String WolfWorld;
    int WolfHealthNow;
    int WolfHealthMax;
    int WolfLives;
    int WolfHealthRespawnTime;
    String WolfName;
    boolean Wolvesitting;
    boolean WolfhasInventory;
    boolean WolfhasPickup;
    cb.WolvesConfig.load();
    List<String> WolfList = cb.WolvesConfig.getKeys("String_Node_Str");
    if (WolfList != null) {
        for (String ownername : WolfList) {
            invSlot = 0;
            WolfX = cb.WolvesConfig.getDouble("String_Node_Str" + ownername + "String_Node_Str", 0);
            WolfY = cb.WolvesConfig.getDouble("String_Node_Str" + ownername + "String_Node_Str", 0);
            WolfZ = cb.WolvesConfig.getDouble("String_Node_Str" + ownername + "String_Node_Str", 0);
            WolfWorld = cb.WolvesConfig.getString("String_Node_Str" + ownername + "String_Node_Str", cb.Plugin.getServer().getWorlds().get(0).getName());
            WolfHealthNow = cb.WolvesConfig.getInt("String_Node_Str" + ownername + "String_Node_Str", 6);
            WolfHealthMax = cb.WolvesConfig.getInt("String_Node_Str" + ownername + "String_Node_Str", 6);
            WolfLives = cb.WolvesConfig.getInt("String_Node_Str" + ownername + "String_Node_Str", 3);
            WolfHealthRespawnTime = cb.WolvesConfig.getInt("String_Node_Str" + ownername + "String_Node_Str", 0);
            WolfName = cb.WolvesConfig.getString("String_Node_Str" + ownername + "String_Node_Str", "String_Node_Str");
            Wolvesitting = cb.WolvesConfig.getBoolean("String_Node_Str" + ownername + "String_Node_Str", false);
            WolfhasInventory = cb.WolvesConfig.getBoolean("String_Node_Str" + ownername + "String_Node_Str", false);
            WolfhasPickup = cb.WolvesConfig.getBoolean("String_Node_Str" + ownername + "String_Node_Str", false);
            if (WolfLives == 0) {
                continue;
            }
            if (cb.Plugin.getServer().getWorld(WolfWorld) == null) {
                cb.log.info("String_Node_Str" + WolfWorld + "String_Node_Str" + ownername + "String_Node_Str" + WolfName + "String_Node_Str");
                continue;
            }
            cb.mWolves.put(ownername, new Wolves(cb, ownername));
            cb.mWolves.get(ownername).Location = new Location(this.getServer().getWorld(WolfWorld), WolfX, WolfY, WolfZ);
            if (WolfLives > cb.cv.WolfMaxLives) {
                WolfLives = cb.cv.WolfMaxLives;
            }
            if (WolfHealthMax > cb.cv.WolfRespawnMaxHP) {
                WolfHealthMax = cb.cv.WolfRespawnMaxHP;
            }
            if (WolfHealthNow > WolfHealthMax) {
                WolfHealthNow = WolfHealthMax;
            }
            if (WolfHealthRespawnTime == 0 && WolfHealthNow <= 0) {
                WolfHealthNow = WolfHealthMax;
            }
            cb.mWolves.get(ownername).HealthMax = WolfHealthMax;
            cb.mWolves.get(ownername).setWolfHealth(WolfHealthNow);
            cb.mWolves.get(ownername).RespawnTime = WolfHealthRespawnTime;
            cb.mWolves.get(ownername).Name = WolfName;
            cb.mWolves.get(ownername).isSitting = Wolvesitting;
            cb.mWolves.get(ownername).hasInventory = WolfhasInventory;
            cb.mWolves.get(ownername).hasPickup = WolfhasPickup;
            for (String item : cb.WolvesConfig.getString("String_Node_Str" + ownername + "String_Node_Str", "String_Node_Str").split("String_Node_Str")) {
                String[] itemvalues = item.split("String_Node_Str");
                if (itemvalues.length == 3 && isInt(itemvalues[0]) && isInt(itemvalues[1]) && isInt(itemvalues[2])) {
                    if (Material.getMaterial(Integer.parseInt(itemvalues[0])) != null) {
                        if (Integer.parseInt(itemvalues[1]) <= 64) {
                            cb.mWolves.get(ownername).Inventory.setItem(invSlot, new ItemStack(Integer.parseInt(itemvalues[0]), Integer.parseInt(itemvalues[1]), Integer.parseInt(itemvalues[2])));
                        }
                    }
                }
                invSlot++;
            }
            anzahlWolves++;
        }
    }
    cb.log.info("String_Node_Str" + this.getDescription().getName() + "String_Node_Str" + anzahlWolves + "String_Node_Str");
}

Output:
             Wolvesitting = cb.WolvesConfig.getBoolean("String_Node_Str" + ownername + "String_Node_Str", false);
-            WolfhasInventory = cb.WolvesConfig.getBoolean("String_Node_Str" + ownername + "String_Node_Str", false);
+            WolfInventoryMode = cb.WolvesConfig.getString("String_Node_Str" + ownername + "String_Node_Str", "String_Node_Str");
             WolfhasPickup = cb.WolvesConfig.getBoolean("String_Node_Str" + ownername + "String_Node_Str", false);


Input:
public Object call() throws Exception {
    try (Socket socket = server1.accept()) {
        readHttpRequest(socket.getInputStream());
        sendLines(socket, "String_Node_Str", "String_Node_Str", "String_Node_Str", String.format("String_Node_Str", server2.getLocalPort()), "String_Node_Str", "String_Node_Str", "String_Node_Str");
    }
    return null;
}

Output:
         readHttpRequest(socket.getInputStream());
-        sendLines(socket, "String_Node_Str", "String_Node_Str", "String_Node_Str", String.format("String_Node_Str", server2.getLocalPort()), "String_Node_Str", "String_Node_Str", "String_Node_Str");
+        sendLines(socket, redirectCode, "String_Node_Str", "String_Node_Str", String.format("String_Node_Str", server2.getLocalPort()), "String_Node_Str", "String_Node_Str", "String_Node_Str");
     }


Input:
private void updateStudentSection(String currentSection, StudentAttributes student) {
    try {
        if (isPreview) {
            System.out.println("String_Node_Str" + student.email + "String_Node_Str" + currentSection);
            return;
        }
        PersistenceManager pm = Datastore.getPersistenceManager();
        Student studentEntity = getStudent(student.email, student.course, pm);
        updateStudentToBeInSection(studentEntity, currentSection);
        List<FeedbackResponse> responsesForStudent = getResponsesForStudent(student.email, pm);
        updateFeedbackResponsesToBeInSection(responsesForStudent, student, currentSection);
        pm.close();
    } catch (InvalidParametersException | EntityDoesNotExistException e) {
        System.out.println("String_Node_Str" + student.email);
        e.printStackTrace();
        confirmToContinue();
    }
}

Output:
         updateStudentToBeInSection(studentEntity, currentSection);
-        List<FeedbackResponse> responsesForStudent = getResponsesForStudent(student.email, pm);
+        List<FeedbackResponse> responsesForStudent = getResponsesForStudent(student, pm);
         updateFeedbackResponsesToBeInSection(responsesForStudent, student, currentSection);


Input:
private IMetadataTable getMetadataTableBySalesforceServerAPI(final String endPoint, final String user, final String pass, final String timeOut, final String moduleName, final String proxy, final String proxyHost, final String proxyPort, final String proxyUsername, final String proxyPassword) {
    IMetadataTable metadataTable = new org.talend.core.model.metadata.MetadataTable();
    if (user == null || pass == null || user.equals("String_Node_Str") || pass.equals("String_Node_Str") || moduleName == null || moduleName.equals("String_Node_Str")) {
        return null;
    }
    boolean socksProxy = false;
    boolean httpProxy = false;
    boolean httpsProxy = false;
    if (SalesforceModuleParseAPI.USE_SOCKS_PROXY.equals(proxy)) {
        socksProxy = true;
    }
    if (SalesforceModuleParseAPI.USE_HTTP_PROXY.equals(proxy)) {
        if (endPoint.startsWith("String_Node_Str")) {
            httpsProxy = true;
        } else {
            httpProxy = true;
        }
    }
    salesforceAPI.resetAllProxy();
    salesforceAPI.setProxy(proxyHost, proxyPort, proxyUsername, proxyPassword, httpProxy, socksProxy, httpsProxy);
    if (!salesforceAPI.isLogin()) {
        try {
            ArrayList loginList = salesforceAPI.login(endPoint, user, pass, timeOut);
            for (int i = 0; i < loginList.size(); i++) {
                if (loginList.get(i) instanceof SoapBindingStub) {
                    binding = (SoapBindingStub) loginList.get(i);
                } else {
                    bindingPartner = new SforceServiceStub(endPoint);
                }
            }
        } catch (Throwable e) {
            ExceptionHandler.process(e);
        }
    }
    salesforceAPI.fetchMetaDataColumns(moduleName);
    salesforceAPI.resetAllProxy();
    if (salesforceAPI.getCurrentMetadataColumns() == null) {
        return null;
    }
    metadataTable.setListColumns(salesforceAPI.getCurrentMetadataColumns());
    return metadataTable;
}

Output:
                     binding = (SoapBindingStub) loginList.get(i);
-                } else {
-                    bindingPartner = new SforceServiceStub(endPoint);
+                }
+                if (loginList.get(i) instanceof SforceManagement) {
+                    sforceMgr = (SforceManagement) loginList.get(i);
                 }


Input:
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    final AbstractCapability other = (AbstractCapability) obj;
    if (getName() == null) {
        if (other.getName() != null)
            return false;
    } else if (!getName().equals(other.getName()))
        return false;
    return true;
}

Output:
 public boolean equals(Object obj) {
-    if (this == obj)
+    if (this == obj) {
         return true;