Input:
public static GeometricLayer createFromSimpleGeometry(final Polygon imageP, final String geoName, FeatureCollection fc, final String[] schema, final String[] types) throws IOException {
    GeometricLayer out = null;
    if (geoName.contains("String_Node_Str") || geoName.contains("String_Node_Str")) {
        out = new GeometricLayer(GeometricLayer.POLYGON);
        out.setFeatureCollection(fc);
        FeatureIterator<?> fi = fc.features();
        try {
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, Runtime.getRuntime().availableProcessors(), 2, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
            List<Callable<Object[][]>> tasks = new ArrayList<Callable<Object[][]>>();
            while (fi.hasNext()) {
                final Feature f = fi.next();
                Callable<Object[][]> run = new Callable<Object[][]>() {
                    Geometry g = (Geometry) f.getDefaultGeometryProperty().getValue();
                    public Object[][] call() {
                        List<Object[]> result = java.util.Collections.synchronizedList(new ArrayList<Object[]>());
                        try {
                            AttributesGeometry at = new AttributesGeometry(schema);
                            for (int i = 0; i < f.getProperties().size(); i++) {
                                at.set(schema[i], f.getProperty(schema[i]).getValue());
                            }
                            Geometry gbuff = g.buffer(0);
                            for (int i = 0; i < gbuff.getNumGeometries(); i++) {
                                if (imageP.contains(gbuff)) {
                                    Object[] o = new Object[2];
                                    o[0] = gbuff;
                                    o[1] = at;
                                    result.add(o);
                                } else if (imageP.intersects(gbuff)) {
                                    Geometry p2 = EnhancedPrecisionOp.intersection(imageP, gbuff);
                                    p2 = p2.buffer(0);
                                    if (!p2.isEmpty()) {
                                        for (int ii = 0; ii < p2.getNumGeometries(); ii++) {
                                            Object[] o = new Object[2];
                                            o[0] = p2.getGeometryN(ii);
                                            o[1] = at;
                                            result.add(o);
                                        }
                                    }
                                }
                            }
                        } catch (Exception ex) {
                            logger.error(ex.getMessage(), ex);
                        }
                        return result.toArray(new Object[0][]);
                    }
                };
                tasks.add(run);
            }
            List<Future<Object[][]>> results = executor.invokeAll(tasks);
            executor.shutdown();
            for (Future<Object[][]> f : results) {
                Object[][] o = f.get();
                if (o != null) {
                    for (int i = 0; i < o.length; i++) {
                        out.put((Geometry) o[i][0], (AttributesGeometry) o[i][1]);
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            fi.close();
        }
    } else if (geoName.contains("String_Node_Str")) {
        out = new GeometricLayer(GeometricLayer.POINT);
        FeatureIterator<?> fi = fc.features();
        try {
            while (fi.hasNext()) {
                Feature f = fi.next();
                AttributesGeometry at = new AttributesGeometry(schema);
                for (int i = 0; i < f.getProperties().size(); i++) {
                    at.set(schema[i], f.getProperty(schema[i]).getValue());
                }
                Geometry p2 = ((Geometry) (f.getDefaultGeometryProperty().getValue())).intersection(imageP);
                if (!p2.isEmpty()) {
                    out.put(p2, at);
                }
            }
        } finally {
            fi.close();
        }
    }
    return out;
}

Output:
                     for (int i = 0; i < o.length; i++) {
-                        out.put((Geometry) o[i][0], (AttributesGeometry) o[i][1]);
+                        Geometry g = (Geometry) o[i][0];
+                        if (applayTransformation && transform != null)
+                            g = transform.transformGeometryPixelFromGeo(g);
+                        out.put(g, (AttributesGeometry) o[i][1]);
                     }


Input:
protected void initActionBar(String title) {
    ActionBar actionBar = getActionBar();
    if (actionBar == null) {
        throw new NullPointerException("String_Node_Str");
    }
    if (title != null) {
        actionBar.setTitle(title);
    }
    actionBar.setDisplayUseLogoEnabled(false);
    actionBar.setDisplayHomeAsUpEnabled(true);
}

Output:
     ActionBar actionBar = getActionBar();
-    if (actionBar == null) {
-        throw new NullPointerException("String_Node_Str");
+    if (actionBar != null) {
+        if (title != null) {
+            actionBar.setTitle(title);
+        }
+        actionBar.setDisplayUseLogoEnabled(false);
+        actionBar.setDisplayHomeAsUpEnabled(true);
+    } else {
+        LogUtils.i("String_Node_Str");
     }


Input:
public void onFinish() {
    Logger.d(TAG, "String_Node_Str");
    closeActivity();
}

Output:
     Logger.d(TAG, "String_Node_Str");
-    closeActivity();
+    CountdownTimerActivity.this.mSecondsWheel.setText("String_Node_Str");
+    CountdownTimerActivity.this.mSecondsWheel.setProgress(0);
 }


Input:
public void projectionEnabled() {
    fFoldingStructureProvider = new YangFoldingStructureProvider(this);
    fFoldingStructureProvider.setDocument(getDocumentProvider().getDocument(getEditorInput()));
    Module module = YangParserUtil.parseYangFile(getDocumentProvider().getDocument(getEditorInput()).get().toCharArray());
    fFoldingStructureProvider.updateFoldingRegions(module);
}

Output:
     Module module = YangParserUtil.parseYangFile(getDocumentProvider().getDocument(getEditorInput()).get().toCharArray());
-    fFoldingStructureProvider.updateFoldingRegions(module);
+    if (module != null)
+        fFoldingStructureProvider.updateFoldingRegions(module);
 }


Input:
public void saveData(long globalId, long shardingId) {
    TestGlobalEntity testGlobalEntity = new TestGlobalEntity();
    testGlobalEntity.setId(globalId);
    TestEntity testEntity = new TestEntity();
    testEntity.setId(shardingId);
    testEntity.setTestInt(10);
    storageClient.globalSave(testGlobalEntity);
    storageClient.save(testEntity);
}

Output:
     TestGlobalEntity testGlobalEntity = new TestGlobalEntity();
-    testGlobalEntity.setId(globalId);
+    testGlobalEntity.setId((int) globalId);
     TestEntity testEntity = new TestEntity();


Input:
static InputStream getRealInputStream(final URLConnection uc, InputStream is) throws IOException {
    final String encoding = uc.getContentEncoding();
    if (encoding != null && encoding.equalsIgnoreCase("String_Node_Str")) {
        is = new GZIPInputStream(is);
    } else if (encoding != null && encoding.equalsIgnoreCase("String_Node_Str")) {
        is = new InflaterInputStream(is, new Inflater(true));
    }
    return is;
}

Output:
     if (encoding != null && encoding.equalsIgnoreCase("String_Node_Str")) {
-        is = new GZIPInputStream(is);
+        is = new StreamingGZIPInputStream(is);
     } else if (encoding != null && encoding.equalsIgnoreCase("String_Node_Str")) {


Input:
public void performDataSync(OSyncAdapter adapter, Bundle extras, OUser user) {
    if (adapter.getModel().getModelName().equals("String_Node_Str")) {
        adapter.onSyncFinish(this);
    }
}

Output:
     if (adapter.getModel().getModelName().equals("String_Node_Str")) {
-        adapter.onSyncFinish(this);
+        adapter.onSyncFinish(this).syncDataLimit(50);
     }


Input:
protected boolean internalClearCell(Element td, boolean clearInnerHTML) {
    Element maybeChild = DOM.getFirstChild(td);
    Widget widget = null;
    if (maybeChild != null) {
        widget = getWidget(maybeChild);
    }
    if (widget != null) {
        removeWidget(widget);
        return true;
    } else {
        if (clearInnerHTML) {
            DOM.setInnerHTML(td, "String_Node_Str");
        }
        return false;
    }
}

Output:
     if (maybeChild != null) {
-        widget = getWidget(maybeChild);
+        widget = widgetMap.getWidget(maybeChild);
     }


Input:
private void computeAliases(Object element, SortedSet<String> aliases) {
    for (Map.Entry<String, Object> entry : DataUtil.mapOf(element).entrySet()) {
        Object value = entry.getValue();
        if (value != null) {
            String name = entry.getKey();
            if (!"String_Node_Str".equals(name)) {
                int colon = name.indexOf(':');
                boolean isAttribute = name.charAt(0) == '@';
                if (colon != -1 || !isAttribute) {
                    String alias = colon == -1 ? "String_Node_Str" : name.substring(name.charAt(0) == '@' ? 1 : 0, colon);
                    aliases.add(alias);
                }
                if (!isAttribute && !FieldInfo.isPrimitive(value)) {
                    computeAliases(value, aliases);
                }
            }
        }
    }
}

Output:
                 if (!isAttribute && !FieldInfo.isPrimitive(value)) {
-                    computeAliases(value, aliases);
+                    if (value instanceof Collection<?>) {
+                        for (Object subValue : (Collection<?>) value) {
+                            computeAliases(subValue, aliases);
+                        }
+                    } else {
+                        computeAliases(value, aliases);
+                    }
                 }


Input:
public static String getOriginalConntextValue(Connection connection, String rawValue) {
    String origValu = null;
    if (connection != null && connection.isContextMode()) {
        String contextName = connection.getContextName();
        ContextType contextType = null;
        if (contextName == null) {
            contextType = ConnectionContextHelper.getContextTypeForContextMode(connection, true);
        } else {
            contextType = ConnectionContextHelper.getContextTypeForContextMode(null, connection, contextName, false);
        }
        origValu = ConnectionContextHelper.getOriginalValue(contextType, rawValue);
    }
    return origValu == null ? PluginConstant.EMPTY_STRING : origValu;
}

Output:
     }
-    return origValu == null ? PluginConstant.EMPTY_STRING : origValu;
+    return origValu == null ? rawValue : origValu;
 }


Input:
protected QueryParam getQueryParam(UserArticleCriteria criteria, FilterCriteria filterCriteria) {
    List<String> criteriaList = new ArrayList<String>();
    Map<String, Object> parameterMap = new HashMap<String, Object>();
    StringBuilder sb = new StringBuilder("String_Node_Str");
    if (criteria.isVisible()) {
        if (criteria.isUnread() || criteria.isStarred()) {
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        } else {
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        }
        criteriaList.add("String_Node_Str");
    } else if (criteria.getUserId() != null) {
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
    } else {
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    if (criteria.isFetchAllFeedSubscription()) {
        sb.append("String_Node_Str");
    } else {
        sb.append("String_Node_Str");
    }
    criteriaList.add("String_Node_Str");
    if (criteria.getUserId() != null) {
        parameterMap.put("String_Node_Str", criteria.getUserId());
    }
    if (criteria.getFeedId() != null) {
        criteriaList.add("String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getFeedId());
    }
    if (criteria.getArticleId() != null) {
        criteriaList.add("String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getArticleId());
    }
    if (criteria.getArticleIdIn() != null) {
        criteriaList.add("String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getArticleIdIn());
    }
    if (criteria.getUserArticleId() != null) {
        criteriaList.add("String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getUserArticleId());
    }
    if (criteria.isSubscribed()) {
        criteriaList.add("String_Node_Str");
    }
    if (criteria.getCategoryId() != null) {
        criteriaList.add("String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getCategoryId());
    }
    if (criteria.isUnread()) {
        criteriaList.add("String_Node_Str");
    }
    if (criteria.isStarred()) {
        criteriaList.add("String_Node_Str");
    }
    if (criteria.getArticlePublicationDateMax() != null && criteria.getArticleIdMax() != null) {
        criteriaList.add("String_Node_Str" + DialectUtil.getTimeStamp("String_Node_Str") + "String_Node_Str" + DialectUtil.getTimeStamp("String_Node_Str") + "String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getArticlePublicationDateMax());
        parameterMap.put("String_Node_Str", criteria.getArticleIdMax());
    }
    if (criteria.getUserArticleStarredDateMax() != null && criteria.getUserArticleIdMax() != null) {
        criteriaList.add("String_Node_Str" + DialectUtil.getTimeStamp("String_Node_Str") + "String_Node_Str" + DialectUtil.getTimeStamp("String_Node_Str") + "String_Node_Str");
        parameterMap.put("String_Node_Str", criteria.getUserArticleStarredDateMax());
        parameterMap.put("String_Node_Str", criteria.getUserArticleIdMax());
    }
    SortCriteria sortCriteria;
    if (criteria.isStarred()) {
        sortCriteria = new SortCriteria("String_Node_Str");
    } else {
        sortCriteria = new SortCriteria("String_Node_Str");
    }
    return new QueryParam(sb.toString(), criteriaList, parameterMap, sortCriteria, filterCriteria, new UserArticleMapper());
}

Output:
     if (criteria.getArticlePublicationDateMax() != null && criteria.getArticleIdMax() != null) {
-        criteriaList.add("String_Node_Str" + DialectUtil.getTimeStamp("String_Node_Str") + "String_Node_Str" + DialectUtil.getTimeStamp("String_Node_Str") + "String_Node_Str");
+        criteriaList.add("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
         parameterMap.put("String_Node_Str", criteria.getArticlePublicationDateMax());


Input:
public int getYear() {
    return cal.get(Calendar.YEAR);
}

Output:
 public int getYear() {
-    return cal.get(Calendar.YEAR);
+    return year;
 }


Input:
public final EvaluationResult evaluate(File originalDataDir, double trainingPercentage, double evaluationPercentage, RescorerProvider provider) throws TasteException, IOException, InterruptedException {
    Preconditions.checkArgument(trainingPercentage > 0.0 && trainingPercentage < 1.0, "String_Node_Str", trainingPercentage);
    Preconditions.checkArgument(evaluationPercentage > 0.0 && evaluationPercentage <= 1.0, "String_Node_Str", evaluationPercentage);
    Preconditions.checkArgument(originalDataDir.exists() && originalDataDir.isDirectory(), "String_Node_Str", originalDataDir);
    File trainingDataDir = Files.createTempDir();
    trainingDataDir.deleteOnExit();
    File trainingFile = new File(trainingDataDir, "String_Node_Str");
    trainingFile.deleteOnExit();
    File trainingModelFile = new File(originalDataDir, "String_Node_Str");
    if (trainingModelFile.exists() && trainingModelFile.isFile()) {
        Files.copy(trainingModelFile, new File(trainingDataDir, trainingModelFile.getName()));
    }
    ServerRecommender recommender = null;
    try {
        Multimap<Long, RecommendedItem> testData = split(originalDataDir, trainingFile, trainingPercentage, evaluationPercentage, provider);
        recommender = new ServerRecommender(trainingDataDir);
        recommender.await();
        return evaluate(recommender, testData);
    } finally {
        recommender.close();
        IOUtils.deleteRecursively(trainingDataDir);
    }
}

Output:
     } finally {
-        recommender.close();
+        if (recommender != null) {
+            recommender.close();
+        }
         IOUtils.deleteRecursively(trainingDataDir);


Input:
public Operation get() {
    return new ClientReAuthOperation(uuid);
}

Output:
 public Operation get() {
-    return new ClientReAuthOperation(uuid);
+    return new ClientReAuthOperation(uuid, authCorrelationId);
 }


Input:
public Record getTotalPublication(List<SubmissionLookupProvider> providers) {
    if (publications == null) {
        return null;
    } else if (publications.size() == 1) {
        return publications.get(0);
    } else {
        MutableRecord pub = new SubmissionLookupPublication(MERGED_PUBLICATION_PROVIDER);
        for (SubmissionLookupProvider prov : providers) {
            for (Record p : publications) {
                if (!SubmissionLookupService.getProviderName(p).equals(prov.getShortName())) {
                    continue;
                }
                for (String field : p.getFields()) {
                    List<Value> values = p.getValues(field);
                    if (values != null && values.size() > 0) {
                        if (!pub.getFields().contains(field)) {
                            for (Value v : values) {
                                pub.addValue(field, v);
                            }
                        }
                    }
                }
            }
        }
        return pub;
    }
}

Output:
         MutableRecord pub = new SubmissionLookupPublication(MERGED_PUBLICATION_PROVIDER);
-        for (SubmissionLookupProvider prov : providers) {
-            for (Record p : publications) {
-                if (!SubmissionLookupService.getProviderName(p).equals(prov.getShortName())) {
-                    continue;
-                }
-                for (String field : p.getFields()) {
-                    List<Value> values = p.getValues(field);
-                    if (values != null && values.size() > 0) {
-                        if (!pub.getFields().contains(field)) {
-                            for (Value v : values) {
-                                pub.addValue(field, v);
-                            }
+        for (Record p : publications) {
+            for (String field : p.getFields()) {
+                List<Value> values = p.getValues(field);
+                if (values != null && values.size() > 0) {
+                    if (!pub.getFields().contains(field)) {
+                        for (Value v : values) {
+                            pub.addValue(field, v);
                         }


Input:
public boolean isBuiltIn() {
    return getTLaLib() instanceof BuiltInLibrary;
}

Output:
 public boolean isBuiltIn() {
-    return getTLaLib() instanceof BuiltInLibrary;
+    return getTLModelObject() instanceof BuiltInLibrary;
 }


Input:
public void handleSystemNavigationKey(int key) {
    if (SPEW)
        Log.d(TAG, "String_Node_Str" + key);
    if (!panelsEnabled()) {
        return;
    }
    if (!mUserSetup)
        return;
    if (KeyEvent.KEYCODE_SYSTEM_NAVIGATION_UP == key) {
        mNotificationPanel.collapse(false, 1.0f);
    } else if (KeyEvent.KEYCODE_SYSTEM_NAVIGATION_DOWN == key) {
        if (mNotificationPanel.isFullyCollapsed()) {
            mNotificationPanel.expand(true);
        } else if (!mNotificationPanel.isInSettings() && !mNotificationPanel.isExpanding()) {
            mNotificationPanel.flingSettings(0, true);
        }
    }
}

Output:
         Log.d(TAG, "String_Node_Str" + key);
-    if (!panelsEnabled()) {
+    if (!panelsEnabled() || !mKeyguardMonitor.isDeviceInteractive()) {
         return;


Input:
public static long readLength(InputStream in) throws IOException {
    long ret = 0;
    for (int count = 0; count < 9; count++) {
        int bite = in.read();
        if (bite == -1) {
            throw new EOFException();
        }
        ret = (ret << 7) | (bite & 0x7f);
        if ((bite & 0x80) == 0) {
            if (count > 0 && ((bite & 0x7f) == 0)) {
                break;
            }
            return ret;
        }
    }
    throw new StreamCorruptedException();
}

Output:
         }
-        ret = (ret << 7) | (bite & 0x7f);
+        ret |= (bite & 0x7f) << (count * 7);
         if ((bite & 0x80) == 0) {


Input:
public void run() {
    try {
        try {
            serverSocket = openServerSocket();
            setRunning(true);
            synchronized (this) {
                this.notifyAll();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        while (keepOn()) {
            try {
                Socket clientSocket = serverSocket.accept();
                SmtpHandler smtpHandler = new SmtpHandler(new SmtpCommandRegistry(), managers.getSmtpManager(), new InMemoryWorkspace(), clientSocket);
                handlers.add(smtpHandler);
                smtpHandler.start();
            } catch (SocketException ignored) {
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }
        }
    } finally {
        quit();
    }
}

Output:
                 Socket clientSocket = serverSocket.accept();
-                SmtpHandler smtpHandler = new SmtpHandler(new SmtpCommandRegistry(), managers.getSmtpManager(), new InMemoryWorkspace(), clientSocket);
-                handlers.add(smtpHandler);
-                smtpHandler.start();
+                synchronized (handlers) {
+                    if (!keepOn()) {
+                        clientSocket.close();
+                    } else {
+                        SmtpHandler smtpHandler = new SmtpHandler(new SmtpCommandRegistry(), managers.getSmtpManager(), new InMemoryWorkspace(), clientSocket);
+                        handlers.add(smtpHandler);
+                        smtpHandler.start();
+                    }
+                }
             } catch (SocketException ignored) {


Input:
private void validateRemoteConnection(ParameterMap map) throws CommandValidationException {
    RemoteType type = parseType(map);
    if (type == RemoteType.SSH)
        validateSSHConnection(map);
    else
        validateDcomConnection(map);
}

Output:
         validateSSHConnection(map);
-    else
+    else if (type == RemoteType.DCOM)
         validateDcomConnection(map);


Input:
public static void setFixQualEnc(Configuration conf, boolean val) {
    if (val)
        conf.set(fixQualEnc, "String_Node_Str");
    else
        conf.set(fixQualEnc, "String_Node_Str");
}

Output:
 public static void setFixQualEnc(Configuration conf, boolean val) {
-    if (val)
-        conf.set(fixQualEnc, "String_Node_Str");
-    else
-        conf.set(fixQualEnc, "String_Node_Str");
+    conf.setBoolean(fixQualEnc, val);
 }


Input:
public void init() {
    super.init();
    this.mode = CopyMoveLinkFileToActionMode.COPY;
}

Output:
     super.init();
-    this.mode = CopyMoveLinkFileToActionMode.COPY;
+    setMode(CopyMoveLinkFileToActionMode.COPY);
 }


Input:
public String getErrorMessage(String clientID) {
    if (isClientBlacklisted(clientID)) {
        return "String_Node_Str";
    }
    if (!isClientWhitelisted(clientID)) {
        return "String_Node_Str";
    }
    return null;
}

Output:
     if (isClientBlacklisted(clientID)) {
-        return "String_Node_Str";
+        return translationSystem.translate("String_Node_Str");
     }


Input:
public void actionPerformed(ActionEvent e) {
    new SDKUpdater();
}

Output:
 public void actionPerformed(ActionEvent e) {
-    new SDKUpdater();
+    new SDKUpdater(AndroidEditor.this, androidMode);
 }


Input:
protected void okPressed() {
    int year = timec.getYear();
    int month = timec.getMonth();
    int day = timec.getDay();
    Calendar cenlendar = Calendar.getInstance();
    cenlendar.set(year, month, day);
    SimpleDateFormat format = new SimpleDateFormat("String_Node_Str");
    selectDate = format.format(cenlendar.getTime());
    super.okPressed();
}

Output:
     Calendar cenlendar = Calendar.getInstance();
-    cenlendar.set(year, month, day);
-    SimpleDateFormat format = new SimpleDateFormat("String_Node_Str");
+    SimpleDateFormat format = null;
+    int year = timed.getYear();
+    int month = timed.getMonth();
+    int day = timed.getDay();
+    if (timet != null) {
+        format = new SimpleDateFormat("String_Node_Str");
+        int hour = timet.getHours();
+        int mnts = timet.getMinutes();
+        int secds = timet.getSeconds();
+        cenlendar.set(year, month, day, hour, mnts, secds);
+    } else {
+        format = new SimpleDateFormat("String_Node_Str");
+        cenlendar.set(year, month, day);
+    }
     selectDate = format.format(cenlendar.getTime());


Input:
public void copyDispoSetCoverage(long sourceBranch, String sourceCoverageGuid, DispoProgram destDispProgram, DispoSet destination, CopySetParams params) {
    Map<String, ArtifactReadable> coverageUnits = getQuery().getCoverageUnits(sourceBranch, sourceCoverageGuid);
    List<DispoItem> destItems = getDispoItems(destDispProgram, destination.getGuid());
    OperationReport report = new OperationReport();
    CoverageAdapter coverageAdapter = new CoverageAdapter(dispoConnector);
    List<DispoItem> copyData = coverageAdapter.copyData(coverageUnits, destItems, report);
    String operation = String.format("String_Node_Str", sourceBranch, sourceCoverageGuid);
    if (!copyData.isEmpty()) {
        editDispoItems(destDispProgram, copyData, false, operation);
    }
    storageProvider.get().updateOperationSummary(null, destDispProgram, destination, report);
}

Output:
     List<DispoItem> copyData = coverageAdapter.copyData(coverageUnits, destItems, report);
-    String operation = String.format("String_Node_Str", sourceBranch, sourceCoverageGuid);
+    String operation = String.format("String_Node_Str", sourceBranch, sourceCoverageUuid);
     if (!copyData.isEmpty()) {


Input:
public CompilerResult sendCommand(String modelicaCommand) throws ConnectException {
    String error = null;
    String[] retval = { "String_Node_Str" };
    if (_couldNotStartOMC) {
        return CompilerResult.makeResult(retval, error);
    }
    if (_numberOfErrors > _showMaxErrors) {
        return CompilerResult.makeResult(retval, error);
    }
    modelicaCommand = modelicaCommand.trim();
    if (hasInitialized == false) {
        initServer();
    }
    try {
        retval[0] = omcc.sendExpression(modelicaCommand);
        if (!modelicaCommand.equalsIgnoreCase("String_Node_Str")) {
            error = omcc.sendExpression("String_Node_Str");
        }
        if (error != null && error.length() > 2) {
            error = error.trim();
            error = error.substring(1, error.length() - 1);
        } else {
            error = null;
        }
        return CompilerResult.makeResult(retval, error);
    } catch (org.omg.CORBA.COMM_FAILURE x) {
        _numberOfErrors++;
        throw new ConnectException("String_Node_Str" + modelicaCommand);
    }
}

Output:
     String[] retval = { "String_Node_Str" };
-    if (_couldNotStartOMC) {
+    if (_couldNotStartOMC)
         return CompilerResult.makeResult(retval, error);


Input:
public void setPrefix(String prefix) {
    backend.setPrefix(prefix);
    this.prefix = prefix;
}

Output:
     backend.setPrefix(prefix);
-    this.prefix = prefix;
+    super.setPrefix(prefix);
 }


Input:
public void handle(Message<JsonObject> m) {
    if (m != null && "String_Node_Str".equals(m.body().getString("String_Node_Str"))) {
        logger.info(m.body().encode());
        if (executePostImport) {
            postImport.execute();
        }
    } else {
        Validator.initLogin(neo4j, vertx);
        if (m != null) {
            logger.error(m.body().getString("String_Node_Str"));
            report.addError(m.body().getString("String_Node_Str"));
        } else if (report.getResult().getObject("String_Node_Str").size() < 1) {
            logger.error("String_Node_Str");
            report.addError("String_Node_Str");
        }
    }
    report.getResult().putArray("String_Node_Str", new JsonArray(importer.getUserImportedExternalId().toArray()));
    h.handle(report);
    logger.info("String_Node_Str" + (System.currentTimeMillis() - start) + "String_Node_Str");
    importer.clear();
    checkEventQueue();
}

Output:
     }
-    report.getResult().putArray("String_Node_Str", new JsonArray(importer.getUserImportedExternalId().toArray()));
+    report.setUsersExternalId(new JsonArray(importer.getUserImportedExternalId().toArray()));
     h.handle(report);


Input:
private boolean searchForSearchResults(Spinner spinner, String query) {
    ArrayAdapter<String> spinneradapter = (ArrayAdapter<String>) spinner.getAdapter();
    ViewTypeSpinnerOnItemSelectedListener onItemClickListener = (ViewTypeSpinnerOnItemSelectedListener) spinner.getOnItemSelectedListener();
    for (int i = 0; i < spinneradapter.getCount(); i++) {
        String sname = onItemClickListener.getViewType(i).getName();
        String lname = onItemClickListener.getViewType(i).getLongName();
        if (sname.equalsIgnoreCase(query)) {
            onItemClickListener.fireEvent(i);
            return true;
        }
        if (lname.length() > 4 && lname.toLowerCase().contains(query.toLowerCase())) {
            onItemClickListener.fireEvent(i);
            return true;
        }
    }
    return false;
}

Output:
         }
-        if (lname.length() > 4 && lname.toLowerCase().contains(query.toLowerCase())) {
+        if (query.length() > 4 && lname.toLowerCase().contains(query.toLowerCase())) {
+            Log.d("String_Node_Str", "String_Node_Str" + lname);
             onItemClickListener.fireEvent(i);


Input:
public boolean isAvailable(final Project currentProject, final PluginMetadata plugin) {
    try {
        verifyAvailable(null, plugin);
    } catch (ConstraintException e) {
        return false;
    }
    return true;
}

Output:
     try {
-        verifyAvailable(null, plugin);
+        verifyAvailable(currentProject, plugin);
     } catch (ConstraintException e) {


Input:
private static void validateInterval(int interval, int dataType) throws DataException {
    if (interval != IGroupDefinition.NO_INTERVAL && interval != IGroupDefinition.NUMERIC_INTERVAL && interval != IGroupDefinition.STRING_PREFIX_INTERVAL && interval != IGroupDefinition.SECOND_INTERVAL && interval != IGroupDefinition.MINUTE_INTERVAL && interval != IGroupDefinition.HOUR_INTERVAL && interval != IGroupDefinition.DAY_INTERVAL && interval != IGroupDefinition.WEEK_INTERVAL && interval != IGroupDefinition.MONTH_INTERVAL && interval != IGroupDefinition.QUARTER_INTERVAL && interval != IGroupDefinition.YEAR_INTERVAL) {
        throw new DataException(ResourceConstants.BAD_GROUP_INTERVAL_INVALID);
    }
    if (dataType == DataType.ANY_TYPE || dataType == DataType.UNKNOWN_TYPE) {
        return;
    }
    switch(interval) {
        case IGroupDefinition.NO_INTERVAL:
            return;
        case IGroupDefinition.NUMERIC_INTERVAL:
            if (isNumber(dataType))
                return;
            else
                throw new DataException(ResourceConstants.BAD_GROUP_INTERVAL_TYPE, new Object[] { "String_Node_Str", DataType.getName(dataType) });
        case IGroupDefinition.STRING_PREFIX_INTERVAL:
            if (isString(dataType))
                return;
            else
                throw new DataException(ResourceConstants.BAD_GROUP_INTERVAL_TYPE, new Object[] { "String_Node_Str", DataType.getName(dataType) });
        default:
            if (isDate(dataType))
                return;
            else
                throw new DataException(ResourceConstants.BAD_GROUP_INTERVAL_TYPE, new Object[] { "String_Node_Str", DataType.getName(dataType) });
    }
}

Output:
         default:
-            if (isDate(dataType))
+            if (canBeConvertToDate(dataType))
                 return;


Input:
public void onClick(View v) {
    if (end) {
        Toast.makeText(VideoActivity.this, R.string.msg_try_again, Toast.LENGTH_SHORT).show();
        return;
    }
    if (isProgressViewVisible())
        return;
    if (!paused && !end) {
        if (playPauseImageView.getVisibility() == View.VISIBLE) {
            showAllControlMenus(false);
            clearControlMenuAnimation();
            fadeInAnimation.reset();
        } else {
            showToolbar();
            playPauseImageView.setImageResource(R.drawable.ic_pause);
            showAllControlMenus(true);
            startMediaPlayerAnimation();
        }
    }
}

Output:
         return;
-    if (!paused && !end) {
+    if (!paused && !end && offlineTextView.getVisibility() != View.VISIBLE) {
         if (playPauseImageView.getVisibility() == View.VISIBLE) {


Input:
protected void removeThreadAndReleaseMonitor(Thread thread) {
    if (s_logger.isLoggable(Level.FINE))
        s_logger.log(Level.FINE, m_connector.getAddr().toString());
    m_lock.lock();
    try {
        assert (m_callbackThread == thread);
        assert (m_state == RUNNING);
        m_callbackThread = null;
        m_state = STOPPED;
        m_socketChannel = null;
        m_selectionKey = null;
        if (m_stop)
            m_cond.signalAll();
    } finally {
        m_lock.unlock();
    }
    m_collider.removeEmitterNoWait(m_connector);
}

Output:
     if (s_logger.isLoggable(Level.FINE))
-        s_logger.log(Level.FINE, m_connector.getAddr().toString());
+        s_logger.log(Level.FINE, m_connector.getAddr() + "String_Node_Str" + this.toString());
     m_lock.lock();


Input:
public DDF sql2ddf(String command, Schema schema, DataSourceDescriptor dataSource, DataFormat dataFormat) throws DDFException {
    this.getManager().log("String_Node_Str");
    Connection conn = this.getConn();
    try {
        Statement statement = conn.createStatement();
        statement.execute("String_Node_Str" + command + "String_Node_Str");
        DDF ddf = new JDBCDDF((JDBCDDFManager) this.getManager(), null, null, null, "String_Node_Str");
        this.getManager().addDDF(ddf);
        this.getManager().log("String_Node_Str");
        return ddf;
    } catch (SQLException e) {
        e.printStackTrace();
        throw new DDFException("String_Node_Str");
    }
}

Output:
         Statement statement = conn.createStatement();
-        statement.execute("String_Node_Str" + command + "String_Node_Str");
-        DDF ddf = new JDBCDDF((JDBCDDFManager) this.getManager(), null, null, null, "String_Node_Str");
+        String randomTbName = this.randomString(24);
+        this.getManager().log("String_Node_Str" + randomTbName);
+        statement.execute("String_Node_Str" + randomTbName + "String_Node_Str" + command + "String_Node_Str");
+        DDF ddf = new JDBCDDF((JDBCDDFManager) this.getManager(), null, null, null, randomTbName);
         this.getManager().addDDF(ddf);


Input:
protected void onImpact(MovingObjectPosition mop) {
    if (mop.entityHit instanceof EntityMiniBossFireFiend || mop.entityHit instanceof EntityProjectileFiendFireball)
        return;
    if (mop.entityHit != null)
        mop.entityHit.attackEntityFrom(DamageSource.causeFireballDamage(this, shootingEntity), ModCommonProxy.opMobs ? 9F : 4F);
    if (!worldObj.isRemote) {
        Explosion explosion = new FieryExplosion(worldObj, shootingEntity, worldObj.isRemote ? actualPosX : posX, posY, worldObj.isRemote ? actualPosZ : posZ, ModCommonProxy.opMobs ? 3.5F : 2.7F);
        explosion.doExplosionA();
        explosion.doExplosionB(true);
        PacketPipeline.sendToAllAround(this, 128D, new C12FiendFireballExplosion(this));
    }
    setDead();
}

Output:
     if (!worldObj.isRemote) {
-        Explosion explosion = new FieryExplosion(worldObj, shootingEntity, worldObj.isRemote ? actualPosX : posX, posY, worldObj.isRemote ? actualPosZ : posZ, ModCommonProxy.opMobs ? 3.5F : 2.7F);
+        Explosion explosion = new FieryExplosion(worldObj, shootingEntity, posX, posY, posZ, ModCommonProxy.opMobs ? 3.5F : 2.7F);
         explosion.doExplosionA();


Input:
public Document getDocument(String id) {
    return null;
}

Output:
 public Document getDocument(String id) {
-    return null;
+    return this._getDocument(id);
 }


Input:
private static Sequence parseDnaSequenceV1(SBOLDocument SBOLDoc, IdentifiableDocument<QName> topLevel) {
    String elements = null;
    String displayId = null;
    String name = null;
    String description = null;
    URI identity = topLevel.getIdentity();
    URI encoding = Sbol2Terms.SequenceURI.DnaSequenceV1;
    List<Annotation> annotations = new ArrayList<Annotation>();
    if (setURIPrefix != null) {
        if (topLevel.getIdentity().toString().lastIndexOf('/') != -1) {
            displayId = topLevel.getIdentity().toString().substring(topLevel.getIdentity().toString().lastIndexOf('/') + 1);
            identity = URI.create(setURIPrefix + "String_Node_Str" + displayId + "String_Node_Str");
        }
    }
    for (NamedProperty<QName> namedProperty : topLevel.getProperties()) {
        if (namedProperty.getName().equals(Sbol1Terms.DNASequence.nucleotides)) {
            elements = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Documented.displayId)) {
            displayId = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
            if (setURIPrefix != null) {
                identity = URI.create(setURIPrefix + "String_Node_Str" + displayId + "String_Node_Str");
            }
        } else if (namedProperty.getName().equals(Sbol2Terms.Documented.title)) {
            name = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Documented.description)) {
            description = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else {
            annotations.add(new Annotation(namedProperty));
        }
    }
    Sequence sequence = SBOLDoc.createSequence(identity, elements, encoding);
    if (identity != topLevel.getIdentity())
        sequence.setWasDerivedFrom(topLevel.getIdentity());
    if (displayId != null)
        sequence.setDisplayId(displayId);
    if (name != null)
        sequence.setName(name);
    if (description != null)
        sequence.setDescription(description);
    if (!annotations.isEmpty())
        sequence.setAnnotations(annotations);
    return sequence;
}

Output:
             displayId = topLevel.getIdentity().toString().substring(topLevel.getIdentity().toString().lastIndexOf('/') + 1);
-            identity = URI.create(setURIPrefix + "String_Node_Str" + displayId + "String_Node_Str");
+            identity = URI.create(setURIPrefix + "String_Node_Str" + SBOLDocument.TopLevelTypes.sequence + "String_Node_Str" + displayId + "String_Node_Str");
         }


Input:
public Highlight getHighlightByTouchPoint(float x, float y) {
    if (mDataNotSet || mCurrentData == null) {
        Log.e(LOG_TAG, "String_Node_Str");
        return null;
    }
    float[] pts = new float[2];
    pts[0] = x;
    pts[1] = y;
    Matrix tmp = new Matrix();
    mMatrixOffset.invert(tmp);
    tmp.mapPoints(pts);
    mMatrixTouch.invert(tmp);
    tmp.mapPoints(pts);
    mMatrixValueToPx.invert(tmp);
    tmp.mapPoints(pts);
    double xTouchVal = pts[0];
    double base = xTouchVal;
    if (xTouchVal < 0 || xTouchVal > mDeltaX)
        return null;
    if (base < 0)
        base = 0;
    if (base >= mDeltaX)
        base = mDeltaX - 1;
    int setCount = mOriginalData.getDataSetCount();
    int valCount = setCount * mOriginalData.getXValCount();
    BarData bd = (BarData) mCurrentData;
    float space = (float) (((float) valCount / (float) setCount) / (mDeltaX / base));
    float reduction = (float) space * bd.getGroupSpace();
    int xIndex = (int) ((base - reduction) / setCount);
    int dataSetIndex = ((int) (base - reduction)) % setCount;
    if (dataSetIndex == -1)
        return null;
    return new Highlight(xIndex, dataSetIndex);
}

Output:
     float space = (float) (((float) valCount / (float) setCount) / (mDeltaX / base));
-    float reduction = (float) space * bd.getGroupSpace();
+    float reduction = (float) space * mOriginalData.getGroupSpace();
     int xIndex = (int) ((base - reduction) / setCount);


Input:
private boolean parseFinal(List<String> content) {
    String line = parseFieldDefinition(content);
    String[] parts = line.split("String_Node_Str");
    if (parts.length < 2) {
        throw new RuntimeException("String_Node_Str" + annotationIndex);
    }
    if (parts[0].equals("String_Node_Str") || parts[1].equals("String_Node_Str") || (parts.length >= 3 && parts[2].equals("String_Node_Str"))) {
        return true;
    }
    return false;
}

Output:
     if (parts.length < 2) {
-        throw new RuntimeException("String_Node_Str" + annotationIndex);
+        throw new RuntimeException("String_Node_Str" + propertyIndex);
     }


Input:
public File getIndex(I id) {
    I response = id;
    I lastResponse = null;
    while (response != null && !response.equals(lastResponse)) {
        if (lastResponse != null) {
            log.info("String_Node_Str" + this.getCacheDir().getName() + "String_Node_Str" + lastResponse + "String_Node_Str" + response + "String_Node_Str");
        }
        lastResponse = response;
        response = cache(lastResponse);
    }
    File cacheFile = getCacheFile(response);
    log.info("String_Node_Str" + cacheFile + "String_Node_Str" + response + "String_Node_Str" + id + "String_Node_Str");
    return cacheFile;
}

Output:
     log.info("String_Node_Str" + cacheFile + "String_Node_Str" + response + "String_Node_Str" + id + "String_Node_Str");
-    return cacheFile;
+    return new JobIndexCache.JobIndex(cacheFile, response);
 }


Input:
private void handleInnerClassTags(polyglot.ast.ClassBody classBody) {
    if (sootClass.hasTag("String_Node_Str")) {
        soot.tagkit.OuterClassTag tag = (soot.tagkit.OuterClassTag) sootClass.getTag("String_Node_Str");
        Util.addInnerClassTag(sootClass, sootClass.getName(), tag.isAnon() ? null : tag.getOuterClass().getName(), tag.isAnon() ? null : tag.getSimpleName(), soot.Modifier.isInterface(tag.getOuterClass().getModifiers()) ? soot.Modifier.STATIC | soot.Modifier.PUBLIC : sootClass.getModifiers());
        SootClass outerClass = tag.getOuterClass();
        while (outerClass.hasTag("String_Node_Str")) {
            soot.tagkit.OuterClassTag tag2 = (soot.tagkit.OuterClassTag) outerClass.getTag("String_Node_Str");
            Util.addInnerClassTag(sootClass, outerClass.getName(), tag2.isAnon() ? null : tag2.getOuterClass().getName(), tag2.isAnon() ? null : tag2.getSimpleName(), tag2.isAnon() && soot.Modifier.isInterface(tag2.getOuterClass().getModifiers()) ? soot.Modifier.STATIC | soot.Modifier.PUBLIC : outerClass.getModifiers());
            outerClass = tag2.getOuterClass();
        }
    }
}

Output:
 private void handleInnerClassTags(polyglot.ast.ClassBody classBody) {
-    if (sootClass.hasTag("String_Node_Str")) {
-        soot.tagkit.OuterClassTag tag = (soot.tagkit.OuterClassTag) sootClass.getTag("String_Node_Str");
-        Util.addInnerClassTag(sootClass, sootClass.getName(), tag.isAnon() ? null : tag.getOuterClass().getName(), tag.isAnon() ? null : tag.getSimpleName(), soot.Modifier.isInterface(tag.getOuterClass().getModifiers()) ? soot.Modifier.STATIC | soot.Modifier.PUBLIC : sootClass.getModifiers());
+    if ((innerClassInfoMap != null) && (innerClassInfoMap.containsKey(sootClass))) {
+        InnerClassInfo tag = (InnerClassInfo) innerClassInfoMap.get(sootClass);
+        Util.addInnerClassTag(sootClass, sootClass.getName(), tag.getInnerType() == InnerClassInfo.ANON ? null : tag.getOuterClass().getName(), tag.getInnerType() == InnerClassInfo.ANON ? null : tag.getSimpleName(), soot.Modifier.isInterface(tag.getOuterClass().getModifiers()) ? soot.Modifier.STATIC | soot.Modifier.PUBLIC : sootClass.getModifiers());
         SootClass outerClass = tag.getOuterClass();


Input:
public void testRelateNoSorting() throws OseeCoreException {
    when(container1.getRelation(node1, TYPE_1, node2, INCLUDE_DELETED)).thenReturn(null);
    when(container2.getRelation(node1, TYPE_1, node2, INCLUDE_DELETED)).thenReturn(null);
    when(relationFactory.createRelation(node1, TYPE_1, node2)).thenReturn(relation1);
    when(orderFactory.createOrderManager(node1)).thenReturn(orderManager1);
    IRelationTypeSide typeSide = RelationUtil.asTypeSide(TYPE_1, SIDE_B);
    when(orderManager1.getSorterId(typeSide)).thenReturn(UNORDERED);
    when(node1.getArtifactType()).thenReturn(artifactType1);
    when(node2.getArtifactType()).thenReturn(artifactType2);
    when(validity.getMaximumRelationsAllowed(TYPE_1, artifactType1, SIDE_A)).thenReturn(10);
    when(validity.getMaximumRelationsAllowed(TYPE_1, artifactType2, SIDE_B)).thenReturn(10);
    manager.relate(session, node1, TYPE_1, node2);
    verify(container1).getRelation(node1, TYPE_1, node2, INCLUDE_DELETED);
    verify(container2).getRelation(node1, TYPE_1, node2, INCLUDE_DELETED);
    verify(relationFactory).createRelation(node1, TYPE_1, node2);
    verify(orderManager1).getSorterId(typeSide);
    verify(orderManager1).setOrder(eq(typeSide), eq(UNORDERED), sortedListCaptor.capture());
    verify(container1).add(TYPE_1.getGuid(), relation1);
    verify(container2).add(TYPE_1.getGuid(), relation1);
}

Output:
     when(container2.getRelation(node1, TYPE_1, node2, INCLUDE_DELETED)).thenReturn(null);
-    when(relationFactory.createRelation(node1, TYPE_1, node2)).thenReturn(relation1);
+    when(relationFactory.createRelation(eq(node1), eq(TYPE_1), eq(node2), Matchers.anyString())).thenReturn(relation1);
     when(orderFactory.createOrderManager(node1)).thenReturn(orderManager1);


Input:
public Property savePerperties(ModelElement element) {
    Resource resource = element.eResource();
    String fileName = resource.getURI().lastSegment();
    Property property = initProperty(element);
    TDQItem item = initItem(element, property);
    item.setFilename(fileName);
    URI uri = element.eResource().getURI();
    serialize(property, uri);
    return property;
}

Output:
     serialize(property, uri);
-    return property;
+    String propertyPath = property.eResource().getURI().toPlatformString(true);
+    TaggedValueHelper.setTaggedValue(element, TaggedValueHelper.PROPERTY_FILE, propertyPath);
 }


Input:
public HttpSession getSession(boolean arg0) {
    return this.getSession(arg0);
}

Output:
 public HttpSession getSession(boolean arg0) {
-    return this.getSession(arg0);
+    return (HttpSession) this.cocoonRequest.getSession(arg0);
 }


Input:
private boolean tryInlineSimpleMethodCall(JMethodCall x, Mutator m, JMethod method, JReturnStatement returnStmt) {
    List params = method.params;
    HolderList args = x.args;
    ChangeList changes = new ChangeList("String_Node_Str" + method + "String_Node_Str");
    Mutator resultExpression;
    int[] magicArg = new int[1];
    JExpression targetReturnExpr = returnStmt.getExpression();
    resultExpression = canInlineResultExpression(targetReturnExpr, params, args, magicArg, changes);
    if (resultExpression == null) {
        return false;
    }
    int iMagicArg = magicArg[0];
    JMultiExpression multi = new JMultiExpression(program);
    JExpression instance = x.getInstance();
    if (instance != null && instance.hasSideEffects()) {
        changes.addExpression(x.instance, multi.exprs);
    }
    for (int i = 0; i < params.size(); ++i) {
        if (args.getExpr(i).hasSideEffects()) {
            if (i < iMagicArg) {
                changes.addExpression(args.getMutator(i), multi.exprs);
            } else if (i == iMagicArg) {
            } else {
                assert (i > iMagicArg);
                return false;
            }
        }
    }
    changes.addExpression(resultExpression, multi.exprs);
    changes.replaceExpression(m, multi);
    changeList.add(changes);
    return true;
}

Output:
                 assert (i > iMagicArg);
-                return false;
+                return true;
             }


Input:
private void checkAdded() {
    if (isAttached()) {
        getConfiguration().setNode(this);
        setAttached(true);
    }
}

Output:
 private void checkAdded() {
-    if (isAttached()) {
+    if (!isAttached()) {
         getConfiguration().setNode(this);


Input:
public void upgrade(ResourceTable global, ResourceTable temporary) throws UnfullfilledRequirementsException {
    if (!global.isReady()) {
        throw new RuntimeException("String_Node_Str");
    }
    try {
        temporary.prepareResources(global, this);
        global.upgradeTable(temporary);
        temporary.destroy();
    } catch (UnresolvedResourceException e) {
        e.printStackTrace();
        throw new RuntimeException("String_Node_Str");
    }
    profile = -1;
    suites.removeAllElements();
    initialize(global);
}

Output:
     } catch (UnresolvedResourceException e) {
-        e.printStackTrace();
+        Logger.exception(e);
         throw new RuntimeException("String_Node_Str");


Input:
public final EResourceType getResourceTypeAt(short x, short y) {
    return resourceType[x][y];
}

Output:
 public final EResourceType getResourceTypeAt(short x, short y) {
-    return resourceType[x][y];
+    return resourceType[getIdx(x, y)];
 }


Input:
public String toString() {
    return "String_Node_Str" + source + "String_Node_Str" + destination + "String_Node_Str" + birthDate + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + source + "String_Node_Str" + destination + "String_Node_Str" + birthDate + "String_Node_Str";
+    return "String_Node_Str" + source + "String_Node_Str" + destination + "String_Node_Str";
 }


Input:
private void updateHeaderVisibilities() {
    int top;
    if (mHeader != null) {
        top = mHeader.getMeasuredHeight() + (mHeaderOffset != null ? mHeaderOffset : 0) + mStickyHeaderTopOffset;
    } else {
        top = stickyHeaderTop();
    }
    int childCount = mList.getChildCount();
    for (int i = 0; i < childCount; i++) {
        View child = mList.getChildAt(i);
        if (!(child instanceof WrapperView)) {
            continue;
        }
        WrapperView wrapperViewChild = (WrapperView) child;
        if (!wrapperViewChild.hasHeader()) {
            continue;
        }
        View childHeader = wrapperViewChild.mHeader;
        if (wrapperViewChild.getTop() < top) {
            if (childHeader.getVisibility() != View.INVISIBLE) {
                childHeader.setVisibility(View.INVISIBLE);
            }
        } else {
            if (childHeader.getVisibility() != View.VISIBLE) {
                childHeader.setVisibility(View.VISIBLE);
            }
        }
    }
}

Output:
 private void updateHeaderVisibilities() {
-    int top;
-    if (mHeader != null) {
-        top = mHeader.getMeasuredHeight() + (mHeaderOffset != null ? mHeaderOffset : 0) + mStickyHeaderTopOffset;
-    } else {
-        top = stickyHeaderTop();
-    }
+    int top = stickyHeaderTop();
     int childCount = mList.getChildCount();


Input:
public static VarMapping mapVariables(List<CtVariable> varContext, CtElement ingredientCtElement) {
    Map<VarAccessWrapper, List<CtVariable>> varMaps = new HashMap<>();
    List<CtVariableAccess> notMappedVariables = new ArrayList<>();
    ClassLoader classLoader = VariableResolver.class.getClassLoader();
    Map<String, List<String>> clusters = cluster.readClusterFile(Paths.get(ConfigurationProperties.getProperty("String_Node_Str") + File.separator + ConfigurationProperties.getProperty("String_Node_Str")));
    List<CtVariableAccess> variablesOutOfScope = retriveVariablesOutOfContext(varContext, ingredientCtElement);
    logger.debug("String_Node_Str" + variablesOutOfScope);
    for (CtVariableAccess wOut : variablesOutOfScope) {
        List<String> wcluster = clusters.get(wOut.getVariable().getSimpleName());
        if (wcluster == null) {
            logger.debug("String_Node_Str" + wOut);
            continue;
        }
        logger.debug("String_Node_Str" + wOut + "String_Node_Str" + wcluster);
        boolean mapped = false;
        VarAccessWrapper varOutWrapper = new VarAccessWrapper(wOut);
        for (String wordFromCluster : wcluster) {
            List<CtVariable> varExist = existVariableWithName(varContext, wordFromCluster);
            for (CtVariable varFromCluster : varExist) {
                CtTypeReference typeref_i = varFromCluster.getType();
                try {
                    if (typeref_i.isSubtypeOf(wOut.getType())) {
                        List<CtVariable> vars = varMaps.get(varOutWrapper);
                        if (vars == null) {
                            vars = new ArrayList<>();
                            varMaps.put(varOutWrapper, vars);
                        }
                        vars.add(varFromCluster);
                        mapped = true;
                    }
                } catch (Exception e) {
                    logger.error(e);
                }
            }
        }
        if (!mapped)
            notMappedVariables.add(wOut);
    }
    VarMapping mappings = new VarMapping(varMaps, notMappedVariables);
    return mappings;
}

Output:
                 try {
-                    if (typeref_i.isSubtypeOf(wOut.getType())) {
+                    CtTypeReference refCluster = varFromCluster.getType();
+                    CtTypeReference refOut = wOut.getType();
+                    boolean bothArray = false;
+                    boolean notCompatible = false;
+                    do {
+                        boolean clusterIsArray = refCluster instanceof CtArrayTypeReference;
+                        boolean ourIsArray = refOut instanceof CtArrayTypeReference;
+                        if (clusterIsArray ^ ourIsArray) {
+                            notCompatible = true;
+                            break;
+                        }
+                        bothArray = clusterIsArray && ourIsArray;
+                        if (bothArray) {
+                            refCluster = ((CtArrayTypeReference) refCluster).getComponentType();
+                            refOut = ((CtArrayTypeReference) refOut).getComponentType();
+                        }
+                    } while (bothArray);
+                    if (notCompatible)
+                        continue;
+                    if (refCluster.isSubtypeOf(refOut)) {
                         List<CtVariable> vars = varMaps.get(varOutWrapper);


Input:
public void onCreate() {
    super.onCreate();
    if (!initCheck()) {
        stopSelf();
        return;
    }
    initPassed = true;
    synchronized (REGISTERED_APPS_LOCK) {
        registeredApps = new HashMap<Long, RegisteredApp>();
    }
    closing = false;
    currentContext = getBaseContext();
    startVersionCheck();
    Log.i(TAG, "String_Node_Str");
    synchronized (SESSION_LOCK) {
        this.sessionMap = new SparseArray<Long>();
        this.sessionHashIdMap = new SparseArray<Integer>();
    }
    packetExecuter = Executors.newSingleThreadExecutor();
}

Output:
     synchronized (REGISTERED_APPS_LOCK) {
-        registeredApps = new HashMap<Long, RegisteredApp>();
+        registeredApps = new HashMap<String, RegisteredApp>();
     }


Input:
protected void checkForErrors() {
    if (!new File(dirTxt.getText()).exists()) {
        setErrorMessage(Messages.getString("String_Node_Str"));
    } else {
        setErrorMessage(null);
    }
}

Output:
     if (!new File(dirTxt.getText()).exists()) {
-        setErrorMessage(Messages.getString("String_Node_Str"));
+        errors.add(Messages.getString("String_Node_Str"));
+    }
+    ItemRecord[] elements = getElements();
+    for (ItemRecord record : elements) {
+        File file = record.getFile();
+        IFile iFile = file2IFile(file);
+        File[] dependencies = computeDependencies(iFile);
+        for (File depFile : dependencies) {
+            if (!repositoryTree.getChecked(depFile)) {
+                errors.add("String_Node_Str" + record.getElement().getName() + "String_Node_Str" + depFile.getName());
+            }
+        }
+    }
+    if (!errors.isEmpty()) {
+        setErrorMessage(errors.get(0));
     } else {


Input:
protected IResultIterator executeOdiQuery(IEventHandler eventHandler) throws DataException {
    RDLoad rdLoad = RDUtil.newLoad(engine.getContext(), new QueryResultInfo(queryDefn.getQueryResultsID(), null, -1));
    DataSetResultSet dataSetResult = rdLoad.loadDataSetData();
    IResultClass meta = dataSetResult.getResultClass();
    IResultIterator resultIterator = new CachedResultSet(query, populateResultClass(meta), dataSetResult, eventHandler);
    dataSetResult.close();
    return resultIterator;
}

Output:
 protected IResultIterator executeOdiQuery(IEventHandler eventHandler) throws DataException {
-    RDLoad rdLoad = RDUtil.newLoad(engine.getContext(), new QueryResultInfo(queryDefn.getQueryResultsID(), null, -1));
+    RDLoad rdLoad = RDUtil.newLoad(engine.getContext(), new QueryResultInfo(realBasedQueryID, null, -1));
     DataSetResultSet dataSetResult = rdLoad.loadDataSetData();


Input:
public void run() {
    if (availableApps.size() == 0) {
        if (failedDueToAuth) {
            enterErrorState("String_Node_Str");
        } else {
            enterErrorState("String_Node_Str");
        }
    } else {
        showResults();
    }
}

Output:
     if (availableApps.size() == 0) {
-        if (failedDueToAuth) {
-            enterErrorState("String_Node_Str");
+        if (responseWasError) {
+            enterErrorState("String_Node_Str" + "String_Node_Str");
         } else {


Input:
public static void decodeFileToFile(String infile, String outfile) throws java.io.IOException {
    byte[] decoded = Base64.decodeFromFile(infile);
    java.io.OutputStream out = null;
    try {
        out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(outfile));
        out.write(decoded);
    } catch (java.io.IOException e) {
        throw e;
    } finally {
        try {
            out.close();
        } catch (Exception ex) {
        }
    }
}

Output:
         try {
-            out.close();
-        } catch (Exception ex) {
+            if (out != null) {
+                out.close();
+            }
+        } catch (Exception ignored) {
         }


Input:
public void deleteObjectPhysical(Project project, IRepositoryViewObject objToDelete, String version, boolean fromEmptyRecycleBin) throws PersistenceException {
    if ("String_Node_Str".equals(version)) {
        version = null;
    }
    List<IRepositoryViewObject> allVersionToDelete = getAllVersion(project, objToDelete.getId(), false);
    for (IRepositoryViewObject currentVersion : allVersionToDelete) {
        String currentVersionValue = currentVersion.getVersion();
        if (version == null || currentVersionValue.equals(version)) {
            if (currentVersion.getRepositoryObjectType() == ERepositoryObjectType.PROCESS || currentVersion.getRepositoryObjectType() == ERepositoryObjectType.JOBLET || currentVersion.getRepositoryObjectType() == ERepositoryObjectType.SPARK_JOBLET || currentVersion.getRepositoryObjectType() == ERepositoryObjectType.SPARK_STREAMING_JOBLET) {
                if (coreSerivce.isAlreadyBuilt(project)) {
                    if (currentVersion.getProperty() != null) {
                        coreSerivce.removeItemRelations(currentVersion.getProperty().getItem());
                    }
                }
            }
            Property currentProperty = currentVersion.getProperty();
            Item currentItem = currentProperty.getItem();
            if (currentItem.getParent() instanceof FolderItem) {
                ((FolderItem) currentItem.getParent()).getChildren().remove(currentItem);
            }
            currentItem.setParent(null);
            List<Resource> affectedResources = xmiResourceManager.getAffectedResources(currentProperty);
            for (Resource resource : affectedResources) {
                deleteResource(resource);
            }
            EList<EObject> eCrossReferences = currentItem.eCrossReferences();
            if (eCrossReferences != null) {
                Iterator<EObject> i = eCrossReferences.iterator();
                while (i.hasNext()) {
                    EObject object = i.next();
                    if (object != null) {
                        Resource currentResource = object.eResource();
                        if (currentResource == null) {
                            if (object.eIsProxy()) {
                                URI uri = ((InternalEObject) object).eProxyURI().trimFragment();
                                ResourceUtils.deleteFile(URIHelper.getFile(uri));
                            }
                        }
                    }
                }
            }
        }
    }
    if (!allVersionToDelete.isEmpty()) {
        RecycleBinManager.getInstance().removeFromRecycleBin(project, allVersionToDelete.get(0).getProperty().getItem());
    }
    if (!fromEmptyRecycleBin) {
        saveProject(project);
    }
}

Output:
             for (Resource resource : affectedResources) {
-                deleteResource(resource);
+                deleteResource(resource, isDeleteOnRemote);
             }


Input:
private LockableWindow allocateNewWindow(long brick) {
    if (!useDirect) {
        return new MappedPersistenceWindow(brick * brickSize / blockSize, blockSize, brickSize, fileChannel);
    }
    DirectPersistenceWindow dpw = new DirectPersistenceWindow(brick * brickSize / blockSize, blockSize, brickSize, fileChannel);
    dpw.readPosition();
    return dpw;
}

Output:
 private LockableWindow allocateNewWindow(long brick) {
-    if (!useDirect) {
+    if (useMemoryMapped) {
         return new MappedPersistenceWindow(brick * brickSize / blockSize, blockSize, brickSize, fileChannel);


Input:
private IAggregationResultSet[] executeQuery(BirtCubeView view, AggregationDefinition[] aggrDefns, boolean saveToRD, String queryResutID, IBindingValueFetcher fetcher) throws IOException, BirtException {
    IAggregationResultSet[] rs;
    CubeQueryExecutor executor = view.getCubeQueryExecutor();
    rs = cubeQueryExecutorHelper.execute(aggrDefns, executor.getSession().getStopSign());
    rs = applyNoAggrUpdateFilters(getNoAggrUpdateFilters(executor.getCubeQueryDefinition().getFilters()), executor, rs, view.getCube(), fetcher);
    MirrorOperationExecutor moe = new MirrorOperationExecutor();
    rs = moe.execute(rs, view, cubeQueryExecutorHelper);
    validateLimitSetting(view, rs);
    if (executor.getCubeQueryDefinition().cacheQueryResults()) {
        File tmpDir = new File(executor.getSession().getTempDir());
        if (!FileSecurity.fileExist(tmpDir) || !FileSecurity.fileIsDirectory(tmpDir)) {
            FileSecurity.fileMakeDirs(tmpDir);
        }
        ArchiveWriter writer = new ArchiveWriter(new ArchiveFile(executor.getSession().getTempDir() + "String_Node_Str", "String_Node_Str"));
        AggregationResultSetSaveUtil.save(queryResutID, rs, writer);
        writer.finish();
    }
    if (saveToRD) {
        CubeQueryDefinitionIOUtil.save(queryResutID, executor.getContext().getDocWriter(), executor.getCubeQueryDefinition());
        AggregationResultSetSaveUtil.save(queryResutID, rs, executor.getContext().getDocWriter());
    }
    return rs;
}

Output:
     if (saveToRD) {
-        CubeQueryDefinitionIOUtil.save(queryResutID, executor.getContext().getDocWriter(), executor.getCubeQueryDefinition());
+        CubeQueryDefinitionIOUtil.save(queryResutID, executor.getContext(), executor.getCubeQueryDefinition());
         AggregationResultSetSaveUtil.save(queryResutID, rs, executor.getContext().getDocWriter());


Input:
public Object executeImpl(ExecutionEvent event) {
    IWorkbenchPart activePart = HandlerUtil.getActivePart(event);
    if (activePart instanceof TestresultSummaryView) {
        final TestresultSummaryView summary = (TestresultSummaryView) activePart;
        summary.refreshView();
    }
    return null;
}

Output:
         final TestresultSummaryView summary = (TestresultSummaryView) activePart;
-        summary.refreshView();
+        summary.loadViewInput();
     }


Input:
public void startDialerSession() {
    mDTMFToneEnabled = Settings.System.getInt(mInCallScreen.getContentResolver(), Settings.System.DTMF_TONE_WHEN_DIALING, 1) == 1;
    if (mDTMFToneEnabled) {
        synchronized (mToneGeneratorLock) {
            if (mToneGenerator == null) {
                try {
                    mToneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL, 80);
                } catch (RuntimeException e) {
                    if (DBG)
                        log("String_Node_Str" + e);
                    mToneGenerator = null;
                }
            }
        }
    }
}

Output:
                 try {
-                    mToneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL, 80);
+                    mToneGenerator = new ToneGenerator(AudioManager.STREAM_DTMF, 80);
                 } catch (RuntimeException e) {


Input:
public int getNrUpdate() {
    return getCount(Action.MODIFY, succeededUpdates);
}

Output:
 public int getNrUpdate() {
-    return getCount(Action.MODIFY, succeededUpdates);
+    return Iterables.size(Iterables.filter(succeededUpdates, new Predicate<UpdateResult>() {
+        public boolean apply(UpdateResult input) {
+            return Action.MODIFY.equals(input.getAction()) && UpdateStatus.SUCCESS.equals(input.getStatus());
+        }
+    }));
 }


Input:
public String processCall(String payload) throws SerializationException {
    String responsePayload = null;
    RPCRequest rpcRequest = null;
    Object targetObject = null;
    if (responsePayload == null) {
        try {
            rpcRequest = RPC.decodeRequest(payload, null, this);
        } catch (NullPointerException ex) {
            Log LOG = LogFactory.getLog(GWTServlet.class);
            LOG.info("String_Node_Str");
            throw new RuntimeException("String_Node_Str");
        }
    }
    Object retval = null;
    if (responsePayload == null) {
        try {
            targetObject = retrieveTargetObject(this.getThreadLocalRequest());
            if (targetObject == null) {
                Log log = LogFactory.getLog(GWTServlet.class);
                log.info("String_Node_Str");
                throw new RuntimeException("String_Node_Str");
            }
            Method method = rpcRequest.getMethod();
            Object[] params = rpcRequest.getParameters();
            Method targetMethod = findTargetMethod(targetObject, method, params);
            Class<?>[] methodParameterTypes = method.getParameterTypes();
            Class<?>[] targetMethodParameterTypes = targetMethod.getParameterTypes();
            UserServerContext userContext = null;
            if (authApiProvider_ != null) {
                HttpSession session = getThreadLocalRequest().getSession(false);
                Object o = session.getAttribute("String_Node_Str");
                if (o == null) {
                    userContext = authApiProvider_.getAnonimousContext();
                } else {
                    if (o instanceof UserServerContext) {
                        userContext = (UserServerContext) o;
                    } else if (o instanceof String) {
                        userContext = authApiProvider_.findContextById((String) o);
                    } else {
                        throw new RuntimeException("String_Node_Str");
                    }
                }
            }
            Object[] targetParams;
            int copyOffset = 0;
            boolean copy = false;
            boolean eraseIdParam = false;
            int userIdParamIndex = -1;
            UserIdParameter uidAnn = targetMethod.getAnnotation(UserIdParameter.class);
            if (uidAnn != null) {
                userIdParamIndex = uidAnn.value();
            }
            if (targetMethodParameterTypes.length > methodParameterTypes.length) {
                targetParams = new Object[targetMethodParameterTypes.length];
                copy = true;
                copyOffset = 1;
                if (authApiProvider_ != null) {
                    targetParams[0] = userContext;
                } else {
                    throw new RuntimeException("String_Node_Str" + targetMethod.toString());
                }
            } else if (targetMethodParameterTypes.length == methodParameterTypes.length) {
                if (inputParametersReplicator_ != null) {
                    targetParams = new Object[targetMethodParameterTypes.length];
                    copy = true;
                } else {
                    copy = false;
                    targetParams = params;
                }
            } else if (targetMethodParameterTypes.length < methodParameterTypes.length) {
                targetParams = new Object[targetMethodParameterTypes.length];
                copy = true;
                eraseIdParam = true;
            } else {
                throw new IllegalStateException("String_Node_Str");
            }
            if (copy) {
                if (inputParametersReplicator_ != null) {
                    for (int i = copyOffset; i < targetMethodParameterTypes.length; ++i) {
                        if (i - copyOffset == userIdParamIndex) {
                            if (!eraseIdParam) {
                                Object o = params[i - copyOffset];
                                if (o != null) {
                                    targetParams[i] = authApiProvider_.findContextById(o.toString());
                                } else {
                                    targetParams[i] = authApiProvider_.getAnonimousContext();
                                }
                                continue;
                            } else {
                                --copyOffset;
                            }
                        }
                        targetParams[i] = inputParametersReplicator_.replicateBean(params[i - copyOffset]);
                    }
                } else {
                    for (int i = copyOffset; i < targetMethodParameterTypes.length; ++i) {
                        if (i - copyOffset == userIdParamIndex) {
                            if (!eraseIdParam) {
                                Object o = params[i - copyOffset];
                                if (o != null) {
                                    targetParams[i] = authApiProvider_.findContextById(o.toString());
                                } else {
                                    targetParams[i] = authApiProvider_.getAnonimousContext();
                                }
                                continue;
                            } else {
                                --copyOffset;
                            }
                        }
                        targetParams[i] = params[i - copyOffset];
                    }
                }
            }
            if (authApiProvider_ != null) {
                if (!AuthServerApiHelper.checkMethodPermissions(targetMethod, targetParams, userContext)) {
                    throw new RuntimeException("String_Node_Str");
                }
            }
            retval = targetMethod.invoke(targetObject, targetParams);
        } catch (RuntimeException ex) {
            Log log = LogFactory.getLog(GWTServlet.class);
            log.info("String_Node_Str", ex);
            responsePayload = RPC.encodeResponseForFailure(null, ex, rpcRequest.getSerializationPolicy());
        } catch (Exception ex) {
            boolean toLog = ((!(ex instanceof Serializable)) || debug_);
            if (toLog) {
                Log log = LogFactory.getLog(GWTServlet.class);
                log.info("String_Node_Str", ex);
            }
            responsePayload = RPC.encodeResponseForFailure(null, ex, rpcRequest.getSerializationPolicy());
        }
    }
    if (responsePayload == null) {
        if (resultReplicator_ != null) {
            retval = resultReplicator_.replicateBean(retval);
        } else if (resultHibernateBeanReplicator_ != null) {
            retval = resultHibernateBeanReplicator_.deepCopy(retval);
        }
        try {
            responsePayload = RPC.encodeResponseForSuccess(rpcRequest.getMethod(), retval, rpcRequest.getSerializationPolicy());
        } catch (IllegalArgumentException ex) {
            Log log = LogFactory.getLog(GWTServlet.class);
            log.error("String_Node_Str", ex);
            responsePayload = RPC.encodeResponseForFailure(rpcRequest.getMethod(), ex);
        }
    }
    return responsePayload;
}

Output:
             if (authApiProvider_ != null) {
-                HttpSession session = getThreadLocalRequest().getSession(false);
+                HttpSession session = getThreadLocalRequest().getSession(true);
                 Object o = session.getAttribute("String_Node_Str");


Input:
public void setKeyboard(final Keyboard keyboard) {
    mKeyTimerHandler.cancelAllKeyTimers();
    super.setKeyboard(keyboard);
    mKeyDetector.setKeyboard(keyboard, -getPaddingLeft(), -getPaddingTop() + getVerticalCorrection());
    PointerTracker.setKeyDetector(mKeyDetector);
    mMoreKeysKeyboardCache.clear();
    mSpaceKey = keyboard.getKey(Constants.CODE_SPACE);
    mSpacebarIcon = (mSpaceKey != null) ? mSpaceKey.getIcon(keyboard.mIconsSet, Constants.Color.ALPHA_OPAQUE) : null;
    final int keyHeight = keyboard.mMostCommonKeyHeight - keyboard.mVerticalGap;
    mLanguageOnSpacebarTextSize = keyHeight * mLanguageOnSpacebarTextRatio;
    if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) {
        final int orientation = getContext().getResources().getConfiguration().orientation;
        ResearchLogger.mainKeyboardView_setKeyboard(keyboard, orientation);
    }
    AccessibleKeyboardViewProxy.getInstance().setKeyboard();
}

Output:
 public void setKeyboard(final Keyboard keyboard) {
-    mKeyTimerHandler.cancelAllKeyTimers();
+    mKeyTimerHandler.cancelLongPressTimers();
     super.setKeyboard(keyboard);


Input:
public IR makeIR(SSAOptions options) {
    SSAInstruction[] instrs = getStatements(options);
    Map<Integer, ConstantValue> constants = null;
    if (valueNumberForConstantOne > -1) {
        constants = HashMapFactory.make(1);
        constants.put(new Integer(valueNumberForConstantOne), new ConstantValue(new Integer(1)));
    }
    return new SyntheticIR(this, Everywhere.EVERYWHERE, makeControlFlowGraph(), instrs, options, constants);
}

Output:
     }
-    return new SyntheticIR(this, Everywhere.EVERYWHERE, makeControlFlowGraph(), instrs, options, constants);
+    InducedCFG cfg = makeControlFlowGraph(instrs);
+    return new SyntheticIR(this, Everywhere.EVERYWHERE, cfg, instrs, options, constants);
 }


Input:
protected ClassLoader getClassLoader(XValue classpath) throws MalformedURLException, IOException, URISyntaxException {
    if (classpath == null)
        return this.getClass().getClassLoader();
    List<URL> urls = new ArrayList<URL>();
    for (XdmItem item : classpath.asXdmValue()) {
        String cp = item.getStringValue();
        URL url = getShell().getURL(cp);
        urls.add(url);
    }
    URLClassLoader loader = new URLClassLoader((URL[]) urls.toArray(new URL[urls.size()]));
    return loader;
}

Output:
         return this.getClass().getClassLoader();
-    List<URL> urls = new ArrayList<URL>();
+    final List<URL> urls = new ArrayList<URL>();
     for (XdmItem item : classpath.asXdmValue()) {


Input:
private String getJmxPassword() {
    return jmxUsername;
}

Output:
 private String getJmxPassword() {
-    return jmxUsername;
+    return jmxPassword;
 }


Input:
public Long execute() throws UserException, BimserverLockConflictException, BimserverDatabaseException {
    User user = getDatabaseSession().get(StorePackage.eINSTANCE.getUser(), authorization.getUoid(), OldQuery.getDefault());
    user.getUserSettings().getServices().add(getIdEObject());
    getDatabaseSession().store(user.getUserSettings());
    return super.execute();
}

Output:
     User user = getDatabaseSession().get(StorePackage.eINSTANCE.getUser(), authorization.getUoid(), OldQuery.getDefault());
-    user.getUserSettings().getServices().add(getIdEObject());
+    InternalServicePluginConfiguration idEObject = getIdEObject();
+    idEObject.setUserSettings(user.getUserSettings());
+    Plugin plugin = bimServer.getPluginManager().getPlugin(idEObject.getPluginDescriptor().getIdentifier(), true);
+    ObjectType settings = bimServer.convertSettings(getDatabaseSession(), plugin);
+    user.getUserSettings().getServices().add(idEObject);
+    idEObject.setSettings(settings);
     getDatabaseSession().store(user.getUserSettings());


Input:
public void mouseReleased(MouseEvent evt) {
    if (buttonCheck(evt.getModifiers(), MouseEvent.BUTTON1_MASK)) {
        int xoffset = (super.getSize().width - size.width * charWidth) / 2;
        int yoffset = (super.getSize().height - size.height * charHeight) / 2;
        mouseDragged(evt);
        if (selectBegin.x == selectEnd.x && selectBegin.y == selectEnd.y) {
            repaint();
            return;
        }
        selection = "String_Node_Str";
        if (selectEnd.x < 0)
            selectEnd.x = 0;
        if (selectEnd.y < 0)
            selectEnd.y = 0;
        if (selectEnd.y >= charArray.length)
            selectEnd.y = charArray.length - 1;
        if (selectEnd.x >= charArray[0].length)
            selectEnd.x = charArray[0].length - 1;
        for (int l = selectBegin.y; l <= selectEnd.y; l++) {
            int start, end;
            start = (l == selectBegin.y ? start = selectBegin.x : 0);
            end = (l == selectEnd.y ? end = selectEnd.x : charArray.length - 1);
            selection += (new String(charArray[l])).substring(start, end);
            if (end == charArray.length - 1)
                selection += "String_Node_Str";
        }
        repaint();
    }
}

Output:
             start = (l == selectBegin.y ? start = selectBegin.x : 0);
-            end = (l == selectEnd.y ? end = selectEnd.x : charArray.length - 1);
+            end = (l == selectEnd.y ? end = selectEnd.x : charArray[l].length - 1);
             selection += (new String(charArray[l])).substring(start, end);


Input:
public static void experiment(List<UGraph<String>> graphs, List<Double> labels) {
    long[] seeds = { 11, 21, 31, 41, 51, 61, 71, 81, 91, 101 };
    double[] cs = { 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000 };
    List<EvaluationFunction> evalFuncs = new ArrayList<EvaluationFunction>();
    evalFuncs.add(new Error());
    evalFuncs.add(new F1());
    List<Double> target = EvaluationUtils.createTarget(labels);
    LibSVMParameters svmParms = new LibSVMParameters(LibSVMParameters.C_SVC, cs);
    svmParms.setNumFolds(10);
    List<List<Statement>> rdfTriples2 = createMoleculeRDFGraphs(graphs, false);
    RDFDataSet ts = new RDFSingleDataSet();
    for (List<Statement> trips : rdfTriples2) {
        ts.addStatements(trips);
    }
    List<Resource> instances = new ArrayList<Resource>();
    List<Statement> stmts = ts.getStatementsFromStrings(null, RDF.TYPE.stringValue(), GraphUtils.NAMESPACE + "String_Node_Str");
    for (Statement stmt : stmts) {
        instances.add(stmt.getSubject());
    }
    DTGraph<String, String> sGraph = org.nodes.data.RDF.createDirectedGraph(ts.getStatements(null, null, null, false), null, null);
    ResultsTable resTable = new ResultsTable();
    resTable.setDigits(3);
    List<DTNode<String, String>> instanceNodes = new ArrayList<DTNode<String, String>>();
    for (Resource i : instances) {
        instanceNodes.add(sGraph.node(i.toString()));
    }
    int maxHubs = 1000;
    List<DTNode<String, String>> RDFTypeHubs = GraphUtils.getTypeHubs(sGraph);
    Comparator<Node<String>> compRegDeg = new DegreeComparator<String>();
    MaxObserver<Node<String>> obsRegDeg = new MaxObserver<Node<String>>(maxHubs + instances.size(), compRegDeg);
    obsRegDeg.observe(sGraph.nodes());
    List<DTNode<String, String>> regDegreeHubs = new ArrayList<DTNode<String, String>>();
    for (Node<String> n : obsRegDeg.elements()) {
        regDegreeHubs.add((DTNode<String, String>) n);
    }
    Comparator<DTNode<String, String>> compSigDeg = new SlashBurn.SignatureComparator<String, String>();
    MaxObserver<DTNode<String, String>> obsSigDeg = new MaxObserver<DTNode<String, String>>(maxHubs + instances.size(), compSigDeg);
    obsSigDeg.observe(sGraph.nodes());
    List<DTNode<String, String>> sigDegreeHubs = new ArrayList<DTNode<String, String>>(obsSigDeg.elements());
    List<Integer> classes = new ArrayList<Integer>();
    for (double d : target) {
        classes.add((int) d);
    }
    Classified<DTNode<String, String>> classified = Classification.combine(instanceNodes, classes);
    InformedAvoidance ia = new InformedAvoidance(sGraph, classified, 4);
    Comparator<DTNode<String, String>> compUnInformed = ia.uninformedComparator(4);
    MaxObserver<DTNode<String, String>> obsUnInformed = new MaxObserver<DTNode<String, String>>(maxHubs + instances.size(), compUnInformed);
    obsUnInformed.observe(sGraph.nodes());
    List<DTNode<String, String>> unInformedDegreeHubs = new ArrayList<DTNode<String, String>>(obsUnInformed.elements());
    Iterator<DTNode<String, String>> ite = unInformedDegreeHubs.iterator();
    while (ite.hasNext()) if (!ia.viableHub(ite.next(), 4, 4))
        ite.remove();
    Comparator<DTNode<String, String>> compInformed = ia.informedComparator(4);
    MaxObserver<DTNode<String, String>> obsInformed = new MaxObserver<DTNode<String, String>>(maxHubs + instances.size(), compInformed);
    obsInformed.observe(sGraph.nodes());
    List<DTNode<String, String>> informedDegreeHubs = new ArrayList<DTNode<String, String>>(obsInformed.elements());
    ite = informedDegreeHubs.iterator();
    while (ite.hasNext()) if (!ia.viableHub(ite.next(), 4, 4))
        ite.remove();
    List<DTNode<String, String>> rn = new ArrayList<DTNode<String, String>>();
    Set<String> is = new HashSet<String>();
    for (Resource r : instances) {
        is.add(r.toString());
    }
    for (DTNode<String, String> n : sGraph.nodes()) {
        if (is.contains(n.label())) {
            rn.add(n);
        }
    }
    RDFTypeHubs.removeAll(rn);
    regDegreeHubs.removeAll(rn);
    sigDegreeHubs.removeAll(rn);
    unInformedDegreeHubs.removeAll(rn);
    informedDegreeHubs.removeAll(rn);
    List<List<DTNode<String, String>>> hubLists = new ArrayList<List<DTNode<String, String>>>();
    hubLists.add(RDFTypeHubs);
    hubLists.add(regDegreeHubs);
    hubLists.add(sigDegreeHubs);
    boolean forward = true;
    int it = 6;
    int depth = 3;
    int[] hubThs = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int[] iterations = { 0, 1, 2, 3, 4, 5, 6 };
    int[] iterations2 = { 0, 2, 4, 6, 8, 10, 12 };
    List<WLUSubTreeKernel> kernelsUWL = new ArrayList<WLUSubTreeKernel>();
    for (int i : iterations) {
        kernelsUWL.add(new WLUSubTreeKernel(i, true));
    }
    MoleculeListMultiGraphExperiment<UGraph<String>> exp = new MoleculeListMultiGraphExperiment<UGraph<String>>(kernelsUWL, seeds, svmParms, graphs, labels, evalFuncs);
    System.out.println("String_Node_Str");
    exp.run();
    for (Result res : exp.getResults()) {
        resTable.addResult(res);
    }
    System.out.println(resTable);
    MoleculeListMultiGraphExperiment<DTGraph<String, String>> exp2;
    for (int th : hubThs) {
        resTable.newRow("String_Node_Str" + th);
        for (List<DTNode<String, String>> hubList : hubLists) {
            List<WLSubTreeKernel> kernelsWL = new ArrayList<WLSubTreeKernel>();
            for (int i : iterations2) {
                kernelsWL.add(new WLSubTreeKernel(i, true, forward));
            }
            List<DTNode<String, String>> newIN = new ArrayList<DTNode<String, String>>(instanceNodes);
            DTGraph<String, String> newG = GraphUtils.simplifyGraph(sGraph, GraphUtils.createHubMap(hubList, th), newIN, false, true);
            exp2 = new MoleculeListMultiGraphExperiment<DTGraph<String, String>>(kernelsWL, seeds, svmParms, GraphUtils.getSubGraphs(newG, newIN, depth), target, evalFuncs);
            System.out.println("String_Node_Str" + th);
            exp2.run();
            for (Result res : exp2.getResults()) {
                resTable.addResult(res);
            }
            kernelsWL = new ArrayList<WLSubTreeKernel>();
            for (int i : iterations2) {
                kernelsWL.add(new WLSubTreeKernel(i, true, forward));
            }
            newIN = new ArrayList<DTNode<String, String>>(instanceNodes);
            newG = GraphUtils.simplifyGraph(sGraph, GraphUtils.createHubMap(hubList, th), newIN, true, false);
            exp2 = new MoleculeListMultiGraphExperiment<DTGraph<String, String>>(kernelsWL, seeds, svmParms, GraphUtils.getSubGraphs(newG, newIN, depth), target, evalFuncs);
            System.out.println("String_Node_Str" + th);
            exp2.run();
            for (Result res : exp2.getResults()) {
                resTable.addResult(res);
            }
            kernelsWL = new ArrayList<WLSubTreeKernel>();
            for (int i : iterations2) {
                kernelsWL.add(new WLSubTreeKernel(i, true, forward));
            }
            newIN = new ArrayList<DTNode<String, String>>(instanceNodes);
            newG = GraphUtils.simplifyGraph(sGraph, GraphUtils.createHubMap(hubList, th), newIN, true, true);
            exp2 = new MoleculeListMultiGraphExperiment<DTGraph<String, String>>(kernelsWL, seeds, svmParms, GraphUtils.getSubGraphs(newG, newIN, depth), target, evalFuncs);
            System.out.println("String_Node_Str" + th);
            exp2.run();
            for (Result res : exp2.getResults()) {
                resTable.addResult(res);
            }
        }
        System.out.println(resTable);
    }
    resTable.addCompResults(resTable.getBestResults());
    System.out.println(resTable);
    System.out.println(resTable.allScoresToString());
}

Output:
     long[] seeds = { 11, 21, 31, 41, 51, 61, 71, 81, 91, 101 };
-    double[] cs = { 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000 };
+    double[] cs = { 1, 10, 100, 1000, 10000 };
     List<EvaluationFunction> evalFuncs = new ArrayList<EvaluationFunction>();


Input:
public void onBlockBurn2(BlockBurnEvent event) {
    V10Location loc = new V10Location(event.getBlock().getLocation());
    Portal portal = plugin.portalManager.borderBlocks.get(loc);
    if (portal == null)
        portal = plugin.portalManager.insideBlocks.get(loc);
    if (portal == null)
        portal = plugin.portalManager.behindBlocks.get(loc);
    if (plugin.portalManager.borderBlocks.containsKey(loc) || plugin.portalManager.insideBlocks.containsKey(loc) || plugin.portalManager.behindBlocks.containsKey(loc)) {
        event.setCancelled(true);
        return;
    }
    Region region = plugin.regionManager.getRegion(loc);
    if (plugin.blockUtil.compareBlockToString(loc, (String) region.settings.get(RegionSetting.BLUE_GEL_BLOCK)) || plugin.blockUtil.compareBlockToString(loc, (String) region.settings.get(RegionSetting.RED_GEL_BLOCK))) {
        System.out.print("String_Node_Str");
        event.setCancelled(true);
    }
}

Output:
 public void onBlockBurn2(BlockBurnEvent event) {
-    V10Location loc = new V10Location(event.getBlock().getLocation());
-    Portal portal = plugin.portalManager.borderBlocks.get(loc);
-    if (portal == null)
-        portal = plugin.portalManager.insideBlocks.get(loc);
-    if (portal == null)
-        portal = plugin.portalManager.behindBlocks.get(loc);
+    V10Location loc = new V10Location(event.getBlock());
     if (plugin.portalManager.borderBlocks.containsKey(loc) || plugin.portalManager.insideBlocks.containsKey(loc) || plugin.portalManager.behindBlocks.containsKey(loc)) {


Input:
public long stepMicros(long jumpMicros, long executeMicros) throws EmulationException {
    if (isRunning()) {
        throw new IllegalStateException("String_Node_Str");
    }
    if (jumpMicros < 0) {
        throw new IllegalArgumentException("String_Node_Str" + jumpMicros);
    }
    if (lastMicrosDelta == 0) {
        System.out.println("String_Node_Str" + cycles);
        lastMicrosCycles = cycles;
    }
    lastMicrosDelta += jumpMicros;
    long maxCycles = lastMicrosCycles + (lastMicrosDelta * dcoFrq) / 1000000;
    if (cpuOff) {
        if (maxCycles > nextEventCycles) {
            lastMicrosDelta -= jumpMicros;
            throw new IllegalArgumentException("String_Node_Str" + maxCycles + "String_Node_Str" + cycles);
        }
    } else if (maxCycles > cycles) {
        lastMicrosDelta -= jumpMicros;
        throw new IllegalArgumentException("String_Node_Str" + maxCycles + "String_Node_Str" + cycles);
    }
    maxCycles = lastMicrosCycles + ((lastMicrosDelta + executeMicros) * dcoFrq) / 1000000;
    System.out.println("String_Node_Str" + cycles + "String_Node_Str" + (jumpMicros) + "String_Node_Str" + executeMicros + "String_Node_Str" + maxCycles);
    if (debug) {
        if (servicedInterrupt >= 0) {
            disAsm.disassemble(reg[PC], memory, reg, servicedInterrupt);
        } else {
            disAsm.disassemble(reg[PC], memory, reg);
        }
    }
    boolean emuOP = false;
    if (maxCycles > 0) {
        while (cycles < maxCycles && !(emuOP = emulateOP(maxCycles))) {
        }
    }
    if (emuOP) {
        if ((instCtr % 10000007) == 0 && !debug) {
            printCPUSpeed(reg[PC]);
        }
        if (execCounter != null) {
            execCounter[reg[PC]]++;
        }
        if (trace != null) {
            trace[tracePos++] = reg[PC];
            if (tracePos > trace.length)
                tracePos = 0;
        }
    }
    if (cpuOff) {
        lastReturnedMicros = (1000000 * (nextEventCycles - cycles)) / dcoFrq;
    } else {
        lastReturnedMicros = 0;
    }
    return lastReturnedMicros;
}

Output:
     }
-    if (lastMicrosDelta == 0) {
+    if (!microClockReady) {
         System.out.println("String_Node_Str" + cycles);


Input:
public List<IEntityInstance> handle(DriverContext<RotatorDriverConfiguration, String, String> driverContext, String response) {
    if (HamlibProtocolHelper.isErrorResponse(response)) {
        return Collections.emptyList();
    } else {
        List<IEntityInstance> result = new ArrayList<IEntityInstance>(2);
        TypeConverter converter = driverContext.getTypeConverter();
        String issuedBy = driverContext.getPart().getID();
        Map<String, String> map = HamlibProtocolHelper.toMap(response);
        String args = map.get(KEY);
        String azimuthValue = StringUtils.substringBefore(args, "String_Node_Str").trim();
        String elevationValue = StringUtils.substringAfter(args, "String_Node_Str").trim();
        Parameter azimuth = new Parameter(issuedBy + "String_Node_Str" + "String_Node_Str", "String_Node_Str");
        azimuth.setDescription("String_Node_Str");
        azimuth.setValue(converter.convertTo(Double.class, azimuthValue));
        azimuth.setUnit("String_Node_Str");
        Parameter elevation = new Parameter(issuedBy + "String_Node_Str" + "String_Node_Str", "String_Node_Str");
        elevation.setDescription("String_Node_Str");
        elevation.setValue(converter.convertTo(Double.class, elevationValue));
        elevation.setUnit("String_Node_Str");
        result.add(azimuth);
        result.add(elevation);
        return result;
    }
}

Output:
         TypeConverter converter = driverContext.getTypeConverter();
-        String issuedBy = driverContext.getPart().getID();
+        String id = driverContext.getPart().getID();
         Map<String, String> map = HamlibProtocolHelper.toMap(response);


Input:
public TableDescriptor getTableDescriptor(boolean useCache, String cluster, String table) {
    if (useCache) {
        TableDescriptor tableDescriptor = _tableDescriptorCache.get(table);
        updateEnabled(useCache, tableDescriptor, cluster, table);
        if (tableDescriptor != null) {
            return tableDescriptor;
        }
    }
    long s = System.nanoTime();
    TableDescriptor tableDescriptor = new TableDescriptor();
    try {
        checkIfOpen();
        String blurTablePath = ZookeeperPathConstants.getTablePath(cluster, table);
        byte[] bytes = getData(blurTablePath);
        if (bytes == null || bytes.length == 0) {
            LOG.info("String_Node_Str", table);
            getOldTableDescriptor(useCache, cluster, table, tableDescriptor);
            BlurUtil.removeAll(_zk, blurTablePath);
            byte[] newFormatBytes = serializeTableDescriptor(tableDescriptor);
            BlurUtil.createPath(_zk, blurTablePath, newFormatBytes);
        } else {
            TDeserializer deserializer = new TDeserializer(new TJSONProtocol.Factory());
            deserializer.deserialize(tableDescriptor, bytes);
        }
    } catch (TException e) {
        throw new RuntimeException(e);
    } catch (KeeperException e) {
        throw new RuntimeException(e);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        long e = System.nanoTime();
        LOG.debug("String_Node_Str" + (e - s) / 1000000.0 + "String_Node_Str");
    }
    tableDescriptor.cluster = cluster;
    _tableDescriptorCache.put(table, tableDescriptor);
    return tableDescriptor;
}

Output:
         byte[] bytes = getData(blurTablePath);
-        if (bytes == null || bytes.length == 0) {
-            LOG.info("String_Node_Str", table);
-            getOldTableDescriptor(useCache, cluster, table, tableDescriptor);
-            BlurUtil.removeAll(_zk, blurTablePath);
-            byte[] newFormatBytes = serializeTableDescriptor(tableDescriptor);
-            BlurUtil.createPath(_zk, blurTablePath, newFormatBytes);
-        } else {
-            TDeserializer deserializer = new TDeserializer(new TJSONProtocol.Factory());
-            deserializer.deserialize(tableDescriptor, bytes);
+        if (bytes == null) {
+            throw new RuntimeException("String_Node_Str" + table + "String_Node_Str" + cluster + "String_Node_Str");
         }


Input:
public void testAggrSort1Cache() throws Exception {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    ILevelDefinition level21 = hier2.createLevel("String_Node_Str");
    createSortTestBindings(cqd);
    CubeSortDefinition sorter1 = new CubeSortDefinition();
    sorter1.setExpression("String_Node_Str");
    sorter1.setAxisQualifierLevels(null);
    sorter1.setAxisQualifierValues(null);
    sorter1.setTargetLevel(level21);
    sorter1.setSortDirection(ISortDefinition.SORT_DESC);
    cqd.addSort(sorter1);
    DataEngine engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
    this.createCube(engine);
    cqd.setCacheQueryResults(true);
    IPreparedCubeQuery pcq = engine.prepare(cqd, null);
    ICubeQueryResults queryResults = pcq.execute(null);
    CubeCursor cursor = queryResults.getCubeCursor();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    cqd.setQueryResultsID(queryResults.getID());
    pcq = engine.prepare(cqd, null);
    queryResults = pcq.execute(null);
    cursor = queryResults.getCubeCursor();
    printCube(cursor, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }, "String_Node_Str", "String_Node_Str");
}

Output:
     cqd.addSort(sorter1);
-    DataEngine engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
+    DataEngineImpl engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
     this.createCube(engine);


Input:
private void setUpSettingsSummary() {
    Preference applicationVersion = getSetting(R.string.preference_key_application_version);
    applicationVersion.setSummary(getApplicationVersionSummary());
    ListPreference serverConnection = getSetting(R.string.preference_key_server_connection);
    serverConnection.setSummary(String.format("String_Node_Str", serverConnection.getEntry()));
}

Output:
 private void setUpSettingsSummary() {
-    Preference applicationVersion = getSetting(R.string.preference_key_application_version);
+    Preference applicationVersion = getPreference(R.string.preference_key_application_version);
+    ListPreference serverConnection = getPreference(R.string.preference_key_server_connection);
     applicationVersion.setSummary(getApplicationVersionSummary());