Input:
public String formatCustomMessageLive(final String message, final Object... args) throws Exception {
    String outMessage = message.replaceAll("String_Node_Str", timeUntil(true));
    outMessage = outMessage.replaceAll("String_Node_Str", timeUntil(false));
    outMessage = outMessage.replaceAll("String_Node_Str", Etc.formatCost(lConfig.getCost(), lConfig));
    outMessage = outMessage.replaceAll("String_Node_Str", Etc.formatCost(winningAmount(), lConfig));
    outMessage = outMessage.replaceAll("String_Node_Str", lConfig.getMessage("String_Node_Str").get(0));
    for (int i = 0; i < args.length; i++) {
        outMessage = outMessage.replaceAll("String_Node_Str" + i + "String_Node_Str", Matcher.quoteReplacement(args[i].toString()));
    }
    outMessage = outMessage.replaceAll("String_Node_Str", "String_Node_Str");
    return outMessage;
}

Output:
 public String formatCustomMessageLive(final String message, final Object... args) throws Exception {
-    String outMessage = message.replaceAll("String_Node_Str", timeUntil(true));
-    outMessage = outMessage.replaceAll("String_Node_Str", timeUntil(false));
-    outMessage = outMessage.replaceAll("String_Node_Str", Etc.formatCost(lConfig.getCost(), lConfig));
-    outMessage = outMessage.replaceAll("String_Node_Str", Etc.formatCost(winningAmount(), lConfig));
-    outMessage = outMessage.replaceAll("String_Node_Str", lConfig.getMessage("String_Node_Str").get(0));
+    String outMessage = message.replaceAll("String_Node_Str", Matcher.quoteReplacement(timeUntil(true)));
+    outMessage = outMessage.replaceAll("String_Node_Str", Matcher.quoteReplacement(timeUntil(false)));
+    outMessage = outMessage.replaceAll("String_Node_Str", Matcher.quoteReplacement(Etc.formatCost(lConfig.getCost(), lConfig)));
+    outMessage = outMessage.replaceAll("String_Node_Str", Matcher.quoteReplacement(Etc.formatCost(winningAmount(), lConfig)));
+    outMessage = outMessage.replaceAll("String_Node_Str", Matcher.quoteReplacement(lConfig.getMessage("String_Node_Str").get(0)));
     for (int i = 0; i < args.length; i++) {


Input:
public List<Order> parseOrders(String orderRespStr) throws JSONException {
    List<Order> resultList = null;
    JSONObject orders = new JSONObject(orderRespStr);
    resultList = new ArrayList<Order>();
    Order tempOrder = null;
    JSONArray dishArray = orders.getJSONArray("String_Node_Str");
    for (int i = 0; i < dishArray.length(); i++) {
        tempOrder = new Order();
        JSONObject dishObj = dishArray.getJSONObject(i);
        tempOrder.setId(Integer.parseInt(dishObj.getString("String_Node_Str")));
        tempOrder.setStatus(Integer.parseInt(dishObj.getString("String_Node_Str")));
        tempOrder.setOrderTotal(Integer.parseInt(dishObj.getString("String_Node_Str")));
        long createTimeValue = Long.parseLong(dishObj.getString("String_Node_Str"));
        long payTimeValue = Long.parseLong(dishObj.getString("String_Node_Str"));
        Date createTime = new Date();
        Date payTime = new Date();
        createTime.setTime(createTimeValue);
        payTime.setTime(payTimeValue);
        tempOrder.setCreateTime(createTime);
        tempOrder.setPayTime(payTime);
        resultList.add(tempOrder);
    }
    return resultList;
}

Output:
         JSONObject dishObj = dishArray.getJSONObject(i);
-        tempOrder.setId(Integer.parseInt(dishObj.getString("String_Node_Str")));
-        tempOrder.setStatus(Integer.parseInt(dishObj.getString("String_Node_Str")));
-        tempOrder.setOrderTotal(Integer.parseInt(dishObj.getString("String_Node_Str")));
-        long createTimeValue = Long.parseLong(dishObj.getString("String_Node_Str"));
-        long payTimeValue = Long.parseLong(dishObj.getString("String_Node_Str"));
+        tempOrder.setId(dishObj.getInt("String_Node_Str"));
+        tempOrder.setStatus(dishObj.getInt("String_Node_Str"));
+        tempOrder.setOrderTotal(dishObj.getInt("String_Node_Str"));
+        long createTimeValue = dishObj.getLong("String_Node_Str");
+        long payTimeValue = dishObj.getLong("String_Node_Str");
         Date createTime = new Date();


Input:
public void delete() {
    if (isDeleteable()) {
        if (getLibrary() != null && getLibrary().isInChain())
            getLibrary().getChain().removeAggregate((ComponentNode) this);
        NodeVisitor visitor = new NodeVisitors().new deleteVisitor();
        this.visitAllNodes(visitor);
    }
}

Output:
         this.visitAllNodes(visitor);
-    }
+    } else if (!(this instanceof VersionNode) && (!(this instanceof FacetNode)) && !(this instanceof SimpleAttributeNode))
+        LOGGER.warn(this + "String_Node_Str" + isDeleteable());
 }


Input:
private void instantiateQuery(Indicator indicator) {
    if (ColumnsetPackage.eINSTANCE.getColumnSetMultiValueIndicator().isSuperTypeOf(indicator.eClass())) {
        ColumnSetMultiValueIndicator colSetMultValIndicator = (ColumnSetMultiValueIndicator) indicator;
        final EList<ModelElement> analyzedColumns = colSetMultValIndicator.getAnalyzedColumns();
        final EList<String> numericFunctions = initializeNumericFunctions(colSetMultValIndicator);
        final EList<String> dateFunctions = initializeDateFunctions(colSetMultValIndicator);
        final String caseStr = "String_Node_Str";
        if ("String_Node_Str".equals(dbms().getDbmsName()) && (dateFunctions.contains(caseStr) || numericFunctions.contains(caseStr))) {
            this.errorMessage = Messages.getString("String_Node_Str");
            Display.getDefault().syncExec(new Runnable() {
                public void run() {
                    MessageDialog.openWarning(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), Messages.getString("String_Node_Str"), errorMessage);
                    return;
                }
            });
        }
        List<String> nominalColumns = new ArrayList<String>();
        for (ModelElement column : colSetMultValIndicator.getNominalColumns()) {
            nominalColumns.add(getQuotedColumnName(column));
        }
        List<String> computedColumns = new ArrayList<String>();
        for (ModelElement column : colSetMultValIndicator.getNumericColumns()) {
            for (String f : numericFunctions) {
                computedColumns.add(replaceVariablesLow(f, getQuotedColumnName(column)));
            }
        }
        for (ModelElement column : colSetMultValIndicator.getDateColumns()) {
            for (String f : dateFunctions) {
                computedColumns.add(replaceVariablesLow(f, getQuotedColumnName(column)));
            }
        }
        computedColumns.add(colSetMultValIndicator.getCountAll());
        String selectItems = createSelect(nominalColumns, computedColumns);
        final Expression sqlGenericExpression = dbms().getSqlExpression(indicator.getIndicatorDefinition());
        String grpByClause = createGroupBy(nominalColumns);
        String tableName = getTableName(analyzedColumns);
        String sqlExpr = dbms().fillGenericQueryWithColumnTableAndAlias(sqlGenericExpression.getBody(), selectItems, tableName, grpByClause);
        String stringDataFilter = AnalysisHelper.getStringDataFilter(cachedAnalysis);
        if (stringDataFilter == null) {
            stringDataFilter = PluginConstant.EMPTY_STRING;
        }
        sqlExpr = dbms().addWhereToStatement(sqlExpr, stringDataFilter);
        indicator.setInstantiatedExpression(BooleanExpressionHelper.createTdExpression(sqlGenericExpression.getLanguage(), sqlExpr));
        if (ColumnsetPackage.eINSTANCE.getSimpleStatIndicator().isSuperTypeOf(indicator.eClass())) {
            SimpleStatIndicator simpleIndicator = (SimpleStatIndicator) indicator;
            String columnsName = createSelect(nominalColumns, new ArrayList<String>());
            for (Indicator leafIndicator : simpleIndicator.getLeafIndicators()) {
                final Expression leafSqlGenericExpression = dbms().getSqlExpression(leafIndicator.getIndicatorDefinition());
                String leafSqlExpr = dbms().fillGenericQueryWithColumnTableAndAlias(leafSqlGenericExpression.getBody(), columnsName, tableName, grpByClause);
                leafSqlExpr = dbms().addWhereToStatement(leafSqlExpr, stringDataFilter);
                leafIndicator.setInstantiatedExpression(BooleanExpressionHelper.createTdExpression(leafSqlGenericExpression.getLanguage(), leafSqlExpr));
            }
        }
    }
}

Output:
         computedColumns.add(colSetMultValIndicator.getCountAll());
-        String selectItems = createSelect(nominalColumns, computedColumns);
-        final Expression sqlGenericExpression = dbms().getSqlExpression(indicator.getIndicatorDefinition());
-        String grpByClause = createGroupBy(nominalColumns);
+        List<String> columns = new ArrayList<String>();
+        if (AnalysisType.COLUMN_SET == cachedAnalysis.getParameters().getAnalysisType()) {
+            for (ModelElement column : analyzedColumns) {
+                columns.add(getQuotedColumnName(column));
+            }
+        } else {
+            columns = nominalColumns;
+        }
+        String selectItems = createSelect(columns, computedColumns);
+        String grpByClause = createGroupBy(columns);
         String tableName = getTableName(analyzedColumns);


Input:
private void updateList(final Map<String, String> changeTable, final Map<String, String> conflictTable) {
    final URI xmlDitalist = new File(job.tempDir, "String_Node_Str").toURI();
    final Set<URI> hrefTopics = new HashSet<>();
    for (final FileInfo f : job.getFileInfo()) {
        if (f.isNonConrefTarget) {
            hrefTopics.add(f.uri);
        }
    }
    for (final FileInfo f : job.getFileInfo()) {
        if (f.isSkipChunk) {
            final URI s = f.uri;
            if (s.getFragment() == null) {
                final Iterator<URI> hrefit = hrefTopics.iterator();
                while (hrefit.hasNext()) {
                    final URI ent = hrefit.next();
                    if (resolve(job.tempDir, ent).equals(resolve(job.tempDir, s))) {
                        hrefit.remove();
                    }
                }
            } else if (hrefTopics.contains(s)) {
                hrefTopics.remove(s);
            }
        }
    }
    final Set<URI> topicList = new LinkedHashSet<>(128);
    final Set<URI> oldTopicList = new HashSet<>();
    for (final FileInfo f : job.getFileInfo()) {
        if (ATTR_FORMAT_VALUE_DITA.equals(f.format)) {
            oldTopicList.add(f.uri);
        }
    }
    for (final URI hrefTopic : hrefTopics) {
        final URI t = getRelativePath(xmlDitalist, job.tempDir.toURI().resolve(stripFragment(hrefTopic.toString())));
        topicList.add(t);
        if (oldTopicList.contains(t)) {
            oldTopicList.remove(t);
        }
    }
    final Set<URI> chunkedTopicSet = new LinkedHashSet<>(128);
    final Set<URI> chunkedDitamapSet = new LinkedHashSet<>(128);
    final Set<URI> ditamapList = new HashSet<>();
    for (final FileInfo f : job.getFileInfo()) {
        if (ATTR_FORMAT_VALUE_DITAMAP.equals(f.format)) {
            ditamapList.add(f.uri);
        }
    }
    for (final Map.Entry<String, String> entry : changeTable.entrySet()) {
        final String oldFile = entry.getKey();
        if (entry.getValue().equals(oldFile)) {
            URI newChunkedFile = new File(entry.getValue()).toURI();
            newChunkedFile = getRelativePath(xmlDitalist, newChunkedFile);
            final String extName = getExtension(newChunkedFile.getPath());
            if (extName != null && !extName.equalsIgnoreCase(ATTR_FORMAT_VALUE_DITAMAP)) {
                chunkedTopicSet.add(newChunkedFile);
                if (!topicList.contains(newChunkedFile)) {
                    topicList.add(newChunkedFile);
                    if (oldTopicList.contains(newChunkedFile)) {
                        oldTopicList.remove(newChunkedFile);
                    }
                }
            } else {
                if (!ditamapList.contains(newChunkedFile)) {
                    ditamapList.add(newChunkedFile);
                    if (oldTopicList.contains(newChunkedFile)) {
                        oldTopicList.remove(newChunkedFile);
                    }
                }
                chunkedDitamapSet.add(newChunkedFile);
            }
        }
    }
    for (final URI s : oldTopicList) {
        final File f = new File(job.tempDir.toURI().resolve(s));
        if (f.exists() && !f.delete()) {
            logger.error("String_Node_Str" + f.getAbsolutePath());
        }
    }
    for (final Map.Entry<String, String> entry : changeTable.entrySet()) {
        final String oldFile = entry.getKey();
        if (entry.getValue().equals(oldFile)) {
            final String targetPath = conflictTable.get(entry.getKey());
            if (targetPath != null) {
                final URI target = new File(targetPath).toURI();
                if (!new File(target).exists()) {
                    final URI from = new File(entry.getValue()).toURI();
                    URI relativePath = getRelativePath(xmlDitalist, from);
                    final URI relativeTargetPath = getRelativePath(xmlDitalist, target);
                    if (relativeTargetPath.getPath().lastIndexOf(File.separator) != -1) {
                        relativePath2fix.put(relativeTargetPath.getPath(), relativeTargetPath.getPath().substring(0, relativeTargetPath.getPath().lastIndexOf(File.separator) + 1));
                    }
                    try {
                        deleteQuietly(new File(target));
                        moveFile(new File(from), new File(target));
                    } catch (final IOException e) {
                        logger.error("String_Node_Str" + e.getMessage(), e);
                    }
                    if (topicList.contains(relativePath)) {
                        topicList.remove(relativePath);
                    }
                    if (chunkedTopicSet.contains(relativePath)) {
                        chunkedTopicSet.remove(relativePath);
                    }
                    relativePath = getRelativePath(xmlDitalist, target);
                    topicList.add(relativePath);
                    chunkedTopicSet.add(relativePath);
                } else {
                    conflictTable.remove(entry.getKey());
                }
            }
        }
    }
    final Set<URI> all = new HashSet<>();
    all.addAll(topicList);
    all.addAll(ditamapList);
    all.addAll(chunkedDitamapSet);
    all.addAll(chunkedTopicSet);
    for (final URI file : oldTopicList) {
        if (!all.contains(file)) {
            job.remove(job.getOrCreateFileInfo(file));
        }
    }
    for (final URI file : topicList) {
        final FileInfo ff = job.getOrCreateFileInfo(file);
        ff.format = ATTR_FORMAT_VALUE_DITA;
    }
    for (final URI file : ditamapList) {
        final FileInfo ff = job.getOrCreateFileInfo(file);
        ff.format = ATTR_FORMAT_VALUE_DITAMAP;
    }
    for (final URI file : chunkedDitamapSet) {
        final FileInfo f = job.getOrCreateFileInfo(file);
        f.format = ATTR_FORMAT_VALUE_DITAMAP;
        f.isResourceOnly = false;
    }
    for (final URI file : chunkedTopicSet) {
        final FileInfo f = job.getOrCreateFileInfo(file);
        f.format = ATTR_FORMAT_VALUE_DITA;
        f.isResourceOnly = false;
    }
    try {
        job.write();
    } catch (final IOException ex) {
        logger.error(ex.getMessage(), ex);
    }
}

Output:
                     final URI relativeTargetPath = getRelativePath(xmlDitalist, target);
-                    if (relativeTargetPath.getPath().lastIndexOf(File.separator) != -1) {
-                        relativePath2fix.put(relativeTargetPath.getPath(), relativeTargetPath.getPath().substring(0, relativeTargetPath.getPath().lastIndexOf(File.separator) + 1));
+                    if (relativeTargetPath.getPath().indexOf(URI_SEPARATOR) != -1) {
+                        relativePath2fix.put(relativeTargetPath.getPath(), relativeTargetPath.getPath().substring(0, relativeTargetPath.getPath().lastIndexOf(URI_SEPARATOR) + 1));
                     }


Input:
public void onBlockBreakEvent(BlockEvent.BreakEvent event) {
    int x = event.getPos().getX();
    int y = event.getPos().getY();
    int z = event.getPos().getZ();
    World world = event.getWorld();
    Collection<GlobalCoordinate> protectors = BlockProtectors.getProtectors(world.provider.getDimension(), x, y, z);
    if (BlockProtectors.checkHarvestProtection(x, y, z, world, protectors)) {
        event.setCanceled(true);
    }
}

Output:
     World world = event.getWorld();
-    Collection<GlobalCoordinate> protectors = BlockProtectors.getProtectors(world.provider.getDimension(), x, y, z);
+    Collection<GlobalCoordinate> protectors = BlockProtectors.getProtectors(world, x, y, z);
     if (BlockProtectors.checkHarvestProtection(x, y, z, world, protectors)) {


Input:
private static void parseSystemConfig(Configuration config, Element el) throws Exception {
    String s = el.getElementValue("String_Node_Str", true);
    if (s != null) {
        final boolean enable = "String_Node_Str".equals(s);
        if (!enable)
            log.info("String_Node_Str");
        config.enableEventThread(enable);
    }
    Integer v = parseInteger(el, "String_Node_Str", false);
    if (v != null)
        config.setMaxSpareThreads(v.intValue());
    v = parseInteger(el, "String_Node_Str", false);
    if (v != null)
        config.setMaxSuspendedThreads(v.intValue());
    v = parseInteger(el, "String_Node_Str", false);
    if (v != null)
        config.setEventTimeWarning(v.intValue());
    v = parseInteger(el, "String_Node_Str", false);
    if (v != null)
        config.setMaxUploadSize(v.intValue());
    v = parseInteger(el, "String_Node_Str", true);
    if (v != null)
        config.setMaxProcessTime(v.intValue());
    s = el.getElementValue("String_Node_Str", true);
    if (s != null)
        config.setUploadCharset(s);
    s = el.getElementValue("String_Node_Str", true);
    if (s != null)
        config.setResponseCharset(s);
    s = el.getElementValue("String_Node_Str", true);
    if (s != null)
        config.setCrawlable(!"String_Node_Str".equals(s));
    s = el.getElementValue("String_Node_Str", true);
    if (s != null && s.length() != 0)
        config.addLabelLocation(s);
    Class cls = parseClass(el, "String_Node_Str", CharsetFinder.class);
    if (cls != null)
        config.setUploadCharsetFinder((CharsetFinder) cls.newInstance());
    cls = parseClass(el, "String_Node_Str", DesktopCacheProvider.class);
    if (cls != null)
        config.setDesktopCacheProviderClass(cls);
    cls = parseClass(el, "String_Node_Str", UiFactory.class);
    if (cls != null)
        config.setUiFactoryClass(cls);
    cls = parseClass(el, "String_Node_Str", FailoverManager.class);
    if (cls != null)
        config.setFailoverManagerClass(cls);
    cls = parseClass(el, "String_Node_Str", UiEngine.class);
    if (cls != null)
        config.setUiEngineClass(cls);
    cls = parseClass(el, "String_Node_Str", IdGenerator.class);
    if (cls != null)
        config.setIdGeneratorClass(cls);
    cls = parseClass(el, "String_Node_Str", SessionCache.class);
    if (cls != null)
        config.setSessionCacheClass(cls);
    cls = parseClass(el, "String_Node_Str", AuDecoder.class);
    if (cls != null)
        config.setAuDecoderClass(cls);
    cls = parseClass(el, "String_Node_Str", WebApp.class);
    if (cls != null)
        config.setWebAppClass(cls);
    cls = parseClass(el, "String_Node_Str", Cache.class);
    if (cls != null)
        ComponentsCtrl.setEventMethodCache((Cache) cls.newInstance());
    cls = parseClass(el, "String_Node_Str", AuWriter.class);
    if (cls != null)
        AuWriters.setImplementationClass(cls);
}

Output:
         config.setCrawlable(!"String_Node_Str".equals(s));
-    s = el.getElementValue("String_Node_Str", true);
-    if (s != null && s.length() != 0)
-        config.addLabelLocation(s);
+    for (Iterator it = el.getElements("String_Node_Str").iterator(); it.hasNext(); ) {
+        final Element elinner = (Element) it.next();
+        final String path = elinner.getText(true);
+        if (!Strings.isEmpty(path))
+            config.addLabelLocation(path);
+    }
     Class cls = parseClass(el, "String_Node_Str", CharsetFinder.class);


Input:
public void testFindDeleteAllPersist() {
    String firstName = "String_Node_Str";
    Employee empWithAddress = new Employee();
    empWithAddress.setFirstName(firstName);
    empWithAddress.setLastName("String_Node_Str");
    empWithAddress.setAddress(new Address());
    Employee empWithoutAddress = new Employee();
    empWithoutAddress.setFirstName(firstName);
    empWithoutAddress.setLastName("String_Node_Str");
    EntityManager em = createEntityManager("String_Node_Str");
    Query deleteQuery = em.createQuery("String_Node_Str" + firstName + "String_Node_Str");
    beginTransaction(em);
    try {
        deleteQuery.executeUpdate();
        commitTransaction(em);
    } catch (RuntimeException ex) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        throw ex;
    }
    beginTransaction(em);
    try {
        em.persist(empWithAddress);
        em.persist(empWithoutAddress);
        commitTransaction(em);
    } catch (RuntimeException ex) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        throw ex;
    }
    clearCache("String_Node_Str");
    em.clear();
    beginTransaction(em);
    try {
        Employee empWithAddressFound = em.find(Employee.class, empWithAddress.getId());
        Employee empWithoutAddressFound = em.find(Employee.class, empWithoutAddress.getId());
        int nDeleted = em.createQuery("String_Node_Str" + firstName + "String_Node_Str").executeUpdate();
        commitTransaction(em);
    } catch (RuntimeException ex) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        throw ex;
    }
    em.clear();
    beginTransaction(em);
    try {
        Employee newEmpWithoutAddress = new Employee();
        newEmpWithoutAddress.setFirstName(firstName);
        newEmpWithoutAddress.setLastName("String_Node_Str");
        newEmpWithoutAddress.setId(empWithoutAddress.getId());
        em.persist(newEmpWithoutAddress);
        commitTransaction(em);
    } catch (RuntimeException ex) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        throw ex;
    }
    beginTransaction(em);
    try {
        Employee newEmpWithAddress = new Employee();
        newEmpWithAddress.setFirstName(firstName);
        newEmpWithAddress.setLastName("String_Node_Str");
        newEmpWithAddress.setId(empWithAddress.getId());
        em.persist(newEmpWithAddress);
        fail("String_Node_Str");
    } catch (EntityExistsException ex) {
    } finally {
        rollbackTransaction(em);
    }
    beginTransaction(em);
    deleteQuery.executeUpdate();
    commitTransaction(em);
}

Output:
     try {
-        deleteQuery.executeUpdate();
+        em.createQuery("String_Node_Str" + firstName + "String_Node_Str").executeUpdate();
         commitTransaction(em);


Input:
public Bitmap thumbBitmap(boolean rotateAsNeeded) {
    return fullSizeBitmap(IImage.THUMBNAIL_TARGET_SIZE, IImage.UNCONSTRAINED);
}

Output:
 public Bitmap thumbBitmap(boolean rotateAsNeeded) {
-    return fullSizeBitmap(IImage.THUMBNAIL_TARGET_SIZE, IImage.UNCONSTRAINED);
+    return fullSizeBitmap(IImage.THUMBNAIL_TARGET_SIZE, IImage.THUMBNAIL_MAX_NUM_PIXELS);
 }


Input:
public void run(IAction action) {
    super.run(action);
    setDoNotContinue(false);
    if (getSootSelection().getType() == SootSelection.CLASSFILE_SELECTED_TYPE) {
        IClassFile cf = getSootSelection().getClassFile();
        IPackageFragmentRoot pfr = (IPackageFragmentRoot) cf.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
        IPackageFragment pf = (IPackageFragment) cf.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
        setClasspathAppend(platform_location + pfr.getPath().toOSString());
        if (pf.isDefaultPackage()) {
            setToProcess(removeFileExt(cf.getElementName()));
        } else {
            setToProcess(pf.getElementName() + "String_Node_Str" + removeFileExt(cf.getElementName()));
        }
    } else if (getSootSelection().getType() == SootSelection.FILE_SELECTED_TYPE) {
        IFile file = getSootSelection().getFile();
        if (file.getFileExtension().compareTo("String_Node_Str") == 0) {
            setClasspathAppend(platform_location + file.getParent().getFullPath().toOSString());
            setIsSrcPrec(true);
            setSrcPrec(LaunchCommands.JIMPLE_IN);
            setToProcess(removeFileExt(file.getName()));
        } else if (file.getFileExtension().compareTo("String_Node_Str") == 0) {
            try {
                handleClassFile(file);
            } catch (Exception e) {
                System.out.println("String_Node_Str");
            }
        }
    } else if (getSootSelection().getType() == SootSelection.CU_SELECTED_TYPE) {
        ICompilationUnit cu = getSootSelection().getJavaFile();
        IPackageFragmentRoot pfr = (IPackageFragmentRoot) cu.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
        IPackageFragment pf = (IPackageFragment) cu.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
        try {
            IProject proj = cu.getJavaProject().getProject();
            IFolder output = proj.getFolder(cu.getJavaProject().getOutputLocation().lastSegment());
            IPackageFragment pkf = (IPackageFragment) cu.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
            IFile exists = null;
            if (pkf.isDefaultPackage()) {
                exists = output.getFile(removeFileExt(cu.getElementName()) + "String_Node_Str");
            } else {
                IFolder pkg = output.getFolder(pf.getElementName());
                exists = pkg.getFile(removeFileExt(cu.getElementName()) + "String_Node_Str");
            }
            if (!exists.exists()) {
                window = SootPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow();
                MessageDialog noClassFound = new MessageDialog(window.getShell(), "String_Node_Str", null, "String_Node_Str", 0, new String[] { "String_Node_Str" }, 0);
                noClassFound.open();
                setDoNotContinue(true);
            }
            setClasspathAppend(platform_location + cu.getJavaProject().getOutputLocation().toOSString());
        } catch (CoreException e) {
        }
        if (pf.isDefaultPackage()) {
            setToProcess(removeFileExt(cu.getElementName()));
        } else {
            setToProcess(pf.getElementName() + "String_Node_Str" + removeFileExt(cu.getElementName()));
        }
    }
}

Output:
             } else {
-                IFolder pkg = output.getFolder(pf.getElementName());
+                IFolder pkg = output.getFolder(dotsToSlashes(pf.getElementName()));
+                System.out.println("String_Node_Str" + pkg.getLocation().toOSString());
+                System.out.println("String_Node_Str" + pf.getPath().toOSString());
+                if (pkg.exists()) {
+                    System.out.println("String_Node_Str");
+                }
                 exists = pkg.getFile(removeFileExt(cu.getElementName()) + "String_Node_Str");


Input:
private void truncateLogicalLog(int size) throws IOException {
    char active = '1';
    FileChannel af = new RandomAccessFile("String_Node_Str", "String_Node_Str").getChannel();
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    af.read(buffer);
    af.close();
    buffer.flip();
    active = buffer.asCharBuffer().get();
    buffer.clear();
    FileChannel fileChannel = new RandomAccessFile("String_Node_Str" + active, "String_Node_Str").getChannel();
    if (size < 0) {
        fileChannel.truncate(fileChannel.size() - 3);
    } else {
        fileChannel.truncate(size);
    }
    fileChannel.force(false);
    fileChannel.close();
}

Output:
     FileChannel fileChannel = new RandomAccessFile("String_Node_Str" + active, "String_Node_Str").getChannel();
-    if (size < 0) {
-        fileChannel.truncate(fileChannel.size() - 3);
-    } else {
+    if (fileChannel.size() > size) {
         fileChannel.truncate(size);


Input:
public int removeObsoleteGeneratedCode(ProcessingContext context, long beforeTimestamp) {
    File directory = new File(context.getOutputPath());
    IOFileFilter fileFilter = new AndFileFilter(new SuffixFileFilter("String_Node_Str"), new ObsoleteGeneratedCodeFilter());
    IOFileFilter dirFilter = TrueFileFilter.TRUE;
    Collection<File> files = FileUtils.listFiles(directory, fileFilter, dirFilter);
    int removedFilesCount = 0;
    for (File file : files) {
        if (file.lastModified() < beforeTimestamp) {
            context.getLogger().info("String_Node_Str", file);
            removedFilesCount++;
            file.deleteOnExit();
        }
    }
    return removedFilesCount;
}

Output:
             removedFilesCount++;
-            file.deleteOnExit();
+            try {
+                if (!file.delete()) {
+                    context.getLogger().warn("String_Node_Str", file);
+                    file.deleteOnExit();
+                }
+            } catch (Exception e) {
+                context.getLogger().warn("String_Node_Str", file);
+                file.deleteOnExit();
+            }
         }


Input:
public void queryIVCData(String data, AsyncResponse response) {
    UAVHttpMessage msg = new UAVHttpMessage(data);
    this.doHttpPost("String_Node_Str", "String_Node_Str", JSONHelper.toString(msg).getBytes(), "String_Node_Str", "String_Node_Str", new IVCCallback(response));
}

Output:
     UAVHttpMessage msg = new UAVHttpMessage(data);
-    this.doHttpPost("String_Node_Str", "String_Node_Str", JSONHelper.toString(msg).getBytes(), "String_Node_Str", "String_Node_Str", new IVCCallback(response));
+    this.doHttpPost("String_Node_Str", "String_Node_Str", msg, new IVCCallback(response));
 }


Input:
public Map<String, Object> readMap(String input) {
    if (empty(input)) {
        return Collections.emptyMap();
    }
    throw new WebApplicationException(noInputType());
}

Output:
     }
-    throw new WebApplicationException(noInputType());
+    throw new MediaTypeNotSupportedException(Response.Status.UNSUPPORTED_MEDIA_TYPE, supported, requested);
 }


Input:
public void execute() {
    BimDatabaseSession session = bimServer.getDatabase().createSession(true);
    try {
        createCheckinAction.setDatabaseSession(session);
        session.executeAndCommitAction(createCheckinAction, 10, new ProgressHandler() {
            public void progress(int current, int max) {
                LongCheckinAction.this.progress = current * 100 / max;
            }
        });
        session.close();
        BimDatabaseSession extraSession = bimServer.getDatabase().createSession(true);
        try {
            ConcreteRevision concreteRevision = (ConcreteRevision) extraSession.get(StorePackage.eINSTANCE.getConcreteRevision(), createCheckinAction.getCroid(), false, null);
            for (Revision r : concreteRevision.getRevisions()) {
                Revision latest = null;
                for (Revision r2 : r.getProject().getRevisions()) {
                    if (latest == null || r2.getId() > latest.getId()) {
                        latest = r2;
                    }
                }
                if (latest != null) {
                    latest.getProject().setLastRevision(latest);
                    extraSession.store(latest.getProject());
                }
            }
            extraSession.commit();
        } finally {
            extraSession.close();
        }
        session = bimServer.getDatabase().createReadOnlySession();
        for (Revision revision : createCheckinAction.getConcreteRevision(createCheckinAction.getCroid()).getRevisions()) {
            NewRevisionAdded newRevisionAdded = LogFactory.eINSTANCE.createNewRevisionAdded();
            newRevisionAdded.setDate(new Date());
            newRevisionAdded.setExecutor(user);
            newRevisionAdded.setRevision(revision);
            newRevisionAdded.setAccessMethod(createCheckinAction.getAccessMethod());
        }
        startClashDetection(session);
    } catch (OutOfMemoryError e) {
        bimServer.getServerInfoManager().setOutOfMemory();
        return;
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e);
        long croid = createCheckinAction.getCroid();
        try {
            BimDatabaseSession rollBackSession = bimServer.getDatabase().createSession(true);
            try {
                Throwable throwable = e;
                while (throwable.getCause() != null) {
                    throwable = throwable.getCause();
                }
                ConcreteRevision concreteRevision = (ConcreteRevision) rollBackSession.get(StorePackage.eINSTANCE.getConcreteRevision(), croid, false, null);
                concreteRevision.setState(CheckinState.ERROR);
                concreteRevision.setLastError(throwable.getMessage());
                for (Revision revision : concreteRevision.getRevisions()) {
                    revision.setState(CheckinState.ERROR);
                    revision.setLastError(throwable.getMessage());
                }
                rollBackSession.store(concreteRevision);
                rollBackSession.commit();
            } finally {
                rollBackSession.close();
            }
        } catch (BimDeadlockException e1) {
            LOGGER.error("String_Node_Str", e1);
        } catch (BimDatabaseException e1) {
            LOGGER.error("String_Node_Str", e1);
        }
    } finally {
        session.close();
    }
    done();
}

Output:
                 Revision latest = null;
-                for (Revision r2 : r.getProject().getRevisions()) {
+                for (Revision r2 : projects.get(r).getRevisions()) {
                     if (latest == null || r2.getId() > latest.getId()) {


Input:
public void init(final NodeEngine nodeEngine, Properties properties) {
    long mergeFirstRunDelay = node.getGroupProperties().MERGE_FIRST_RUN_DELAY_SECONDS.getLong() * 1000;
    mergeFirstRunDelay = mergeFirstRunDelay <= 0 ? 100 : mergeFirstRunDelay;
    ExecutionService executionService = nodeEngine.getExecutionService();
    final String executor = "String_Node_Str";
    executionService.register(executor, 8, 100000);
    long mergeNextRunDelay = node.getGroupProperties().MERGE_NEXT_RUN_DELAY_SECONDS.getLong() * 1000;
    mergeNextRunDelay = mergeNextRunDelay <= 0 ? 100 : mergeNextRunDelay;
    executionService.scheduleWithFixedDelay(executor, new SplitBrainHandler(node), mergeFirstRunDelay, mergeNextRunDelay, TimeUnit.MILLISECONDS);
    long heartbeatInterval = node.groupProperties.HEARTBEAT_INTERVAL_SECONDS.getInteger();
    heartbeatInterval = heartbeatInterval <= 0 ? 1 : heartbeatInterval;
    executionService.scheduleWithFixedDelay(executor, new Runnable() {

        public void run() {
            heartBeater();
        }
    }, heartbeatInterval, heartbeatInterval, TimeUnit.SECONDS);
    long masterConfirmationInterval = node.groupProperties.MASTER_CONFIRMATION_INTERVAL_SECONDS.getInteger();
    masterConfirmationInterval = masterConfirmationInterval <= 0 ? 1 : masterConfirmationInterval;
    executionService.scheduleWithFixedDelay(executor, new Runnable() {
        public void run() {
            sendMasterConfirmation();
        }
    }, masterConfirmationInterval, masterConfirmationInterval, TimeUnit.SECONDS);
    long memberListPublishInterval = node.groupProperties.MEMBER_LIST_PUBLISH_INTERVAL_SECONDS.getInteger();
    memberListPublishInterval = memberListPublishInterval <= 0 ? 1 : memberListPublishInterval;
    executionService.scheduleWithFixedDelay(executor, new Runnable() {
        public void run() {
            sendMemberListToOthers();
        }
    }, memberListPublishInterval, memberListPublishInterval, TimeUnit.SECONDS);
}

Output:
     heartbeatInterval = heartbeatInterval <= 0 ? 1 : heartbeatInterval;
-    executionService.scheduleWithFixedDelay(executor, new Runnable() {
+    executionService.scheduleWithFixedDelay(executorName, new Runnable() {


Input:
protected float getModelAttribute(ItemStack item, EntityLivingBase entity) {
    if (entity instanceof EntityPlayer) {
        EntityPlayer player = (EntityPlayer) entity;
        InfWeapon inf = WMInformation.getInformation(player);
        if (inf != null) {
            if (inf.isActionPresent("String_Node_Str"))
                return 0.0F;
            if (InfUtils.getDeltaTick(inf, "String_Node_Str") < 15)
                return 1.0F;
        }
        return 2.0F;
    }
    return 2.0F;
}

Output:
         EntityPlayer player = (EntityPlayer) entity;
-        InfWeapon inf = WMInformation.getInformation(player);
+        InfWeapon inf = WMInformation.instance.getInformation(player);
         if (inf != null) {


Input:
ComboResult canKill(Color targetColor, int level, long startTime, long limitTime) {
    if (level % 2 == 1) {
        level--;
    }
    this.startTime = startTime;
    this.limitTime = limitTime;
    currentLevel = level;
    result = new ComboResult();
    result.point = null;
    cache.clear();
    dfsKill(gameMap, targetColor, targetColor, level, score, ComboTye.FOUR, null, null, null);
    if (result.point != null)
        return result;
    result.point = null;
    cache.clear();
    dfsKill(gameMap, targetColor.getOtherColor(), targetColor.getOtherColor(), level, score, ComboTye.FOUR, null, null, null);
    if (result.point != null) {
        result.point = null;
        return result;
    }
    result.point = null;
    cache.clear();
    dfsKill(gameMap, targetColor, targetColor, level, score, ComboTye.THREE, null, null, null);
    return result;
}

Output:
     dfsKill(gameMap, targetColor, targetColor, level, score, ComboTye.FOUR, null, null, null);
-    if (result.point != null)
+    if (result.point != null) {
+        result.fourWin = true;
         return result;


Input:
public boolean retryExecution() throws KeeperException, InterruptedException {
    int doneWorkers;
    synchronized (LOCK) {
        doneWorkers = (int) NettyMasterCoordinator.this.iterResults.size();
    }
    int[] dumpArray = { context.getWorkers() / 5, context.getWorkers() * 2 / 5, context.getWorkers() * 3 / 5, context.getWorkers() * 4 / 5, context.getWorkers() };
    for (int i = nextIndex; i < dumpArray.length; i++) {
        if (doneWorkers >= dumpArray[i]) {
            nextIndex = i + 1;
            LOG.info("String_Node_Str", context.getCurrentIteration(), doneWorkers, (context.getWorkers() - doneWorkers));
        }
    }
    if (System.nanoTime() % 100 == 0) {
        LOG.info("String_Node_Str", context.getCurrentIteration(), doneWorkers, (context.getWorkers() - doneWorkers));
    }
    long timeOut = 0L;
    if (context.isFirstIteration() || context.getCurrentIteration() == context.getTotalIteration()) {
        timeOut = GuaguaConstants.GUAGUA_DEFAULT_MIN_WORKERS_TIMEOUT;
    } else {
        timeOut = context.getMinWorkersTimeOut();
    }
    boolean isTerminated = isTerminated(doneWorkers, context.getWorkers(), context.getMinWorkersRatio(), timeOut);
    if (isTerminated) {
        synchronized (LOCK) {
            NettyMasterCoordinator.this.canUpdateWorkerResultMap = false;
        }
        LOG.info("String_Node_Str" + "String_Node_Str", context.getCurrentIteration(), context.getWorkers(), doneWorkers, context.getMinWorkersRatio(), GuaguaConstants.GUAGUA_DEFAULT_MIN_WORKERS_TIMEOUT);
    }
    return isTerminated;
}

Output:
     }
-    int[] dumpArray = { context.getWorkers() / 5, context.getWorkers() * 2 / 5, context.getWorkers() * 3 / 5, context.getWorkers() * 4 / 5, context.getWorkers() };
+    int[] dumpArray = { context.getWorkers() / 4, context.getWorkers() * 2 / 4, context.getWorkers() * 3 / 4, context.getWorkers() };
     for (int i = nextIndex; i < dumpArray.length; i++) {


Input:
public PreparedStatement createPreparedStatement(final Connection conn) throws SQLException {
    final float cores_used = task.cpuPercent / 100.0f;
    final Long[] io_stats = { task.diskIO.readCount, task.diskIO.writeCount, task.diskIO.readBytes, task.diskIO.writeBytes };
    final PreparedStatement ret = conn.prepareStatement(UPDATE_RUNTIME);
    ret.setInt(1, task.rssMb);
    ret.setInt(2, task.rssMb);
    ret.setInt(3, (int) Math.min(100, Math.round(task.progress)));
    ret.setFloat(4, cores_used);
    ret.setFloat(5, cores_used);
    ret.setString(6, task.lastLog);
    ret.setArray(7, conn.createArrayOf("String_Node_Str", io_stats));
    ret.setObject(8, UUID.fromString(task.procId));
    ret.setObject(9, UUID.fromString(task.taskId));
    return ret;
}

Output:
     final float cores_used = task.cpuPercent / 100.0f;
-    final Long[] io_stats = { task.diskIO.readCount, task.diskIO.writeCount, task.diskIO.readBytes, task.diskIO.writeBytes };
+    final Long[] io_stats = new Long[] { 0L, 0L, 0L, 0L };
+    if (task.diskIO != null) {
+        io_stats[0] = task.diskIO.readCount;
+        io_stats[1] = task.diskIO.writeCount;
+        io_stats[2] = task.diskIO.readBytes;
+        io_stats[3] = task.diskIO.writeBytes;
+        ;
+    }
     final PreparedStatement ret = conn.prepareStatement(UPDATE_RUNTIME);