Input:
public static void addServiceGroup(GroupBean serviceGroupDefinition) throws RestAPIException {
    try {
        if (serviceGroupDefinition == null) {
            throw new RuntimeException("String_Node_Str");
        }
        List<String> cartridgeTypes = null;
        List<String> groupNames = null;
        if (serviceGroupDefinition.getCartridges() != null) {
            if (log.isDebugEnabled()) {
                log.debug("String_Node_Str" + serviceGroupDefinition.getName());
            }
            cartridgeTypes = serviceGroupDefinition.getCartridges();
            Set<String> duplicates = findDuplicates(cartridgeTypes);
            if (duplicates.size() > 0) {
                StringBuffer buf = new StringBuffer();
                for (String dup : duplicates) {
                    buf.append(dup).append("String_Node_Str");
                }
                if (log.isDebugEnabled()) {
                    log.debug("String_Node_Str" + buf.toString());
                }
                throw new RestAPIException("String_Node_Str" + buf.toString());
            }
            CloudControllerServiceClient ccServiceClient = getCloudControllerServiceClient();
            for (String cartridgeType : cartridgeTypes) {
                try {
                    if (ccServiceClient.getCartridgeInfo(cartridgeType) == null) {
                        log.error("String_Node_Str" + cartridgeType);
                        throw new RestAPIException("String_Node_Str" + cartridgeType);
                    }
                } catch (RemoteException e) {
                    throw new RestAPIException(e);
                } catch (CloudControllerServiceCartridgeNotFoundExceptionException e) {
                    throw new RestAPIException(e);
                }
            }
        }
        if (serviceGroupDefinition.getGroups() != null) {
            if (log.isDebugEnabled()) {
                log.debug("String_Node_Str" + serviceGroupDefinition.getName());
            }
            List<GroupBean> groupDefinitions = serviceGroupDefinition.getGroups();
            groupNames = new ArrayList<String>();
            for (GroupBean groupList : groupDefinitions) {
                groupNames.add(groupList.getName());
            }
            Set<String> duplicates = findDuplicates(groupNames);
            if (duplicates.size() > 0) {
                StringBuffer buf = new StringBuffer();
                for (String dup : duplicates) {
                    buf.append(dup).append("String_Node_Str");
                }
                if (log.isDebugEnabled()) {
                    log.debug("String_Node_Str" + buf.toString());
                }
                throw new RestAPIException("String_Node_Str" + buf.toString());
            }
        }
        ServiceGroup serviceGroup = ObjectConverter.convertServiceGroupDefinitionToASStubServiceGroup(serviceGroupDefinition);
        AutoscalerServiceClient asServiceClient = getAutoscalerServiceClient();
        asServiceClient.addServiceGroup(serviceGroup);
        StratosManagerServiceClient smServiceClient = getStratosManagerServiceClient();
        if (cartridgeTypes != null) {
            smServiceClient.addUsedCartridgesInCartridgeGroups(serviceGroupDefinition.getName(), (String[]) cartridgeTypes.toArray());
        }
        if (groupNames != null) {
            smServiceClient.addUsedCartridgeGroupsInCartridgeSubGroups(serviceGroupDefinition.getName(), (String[]) groupNames.toArray());
        }
    } catch (Exception e) {
        String message = "String_Node_Str";
        log.error(message, e);
        throw new RestAPIException(message, e);
    }
}

Output:
         if (cartridgeTypes != null) {
-            smServiceClient.addUsedCartridgesInCartridgeGroups(serviceGroupDefinition.getName(), (String[]) cartridgeTypes.toArray());
+            smServiceClient.addUsedCartridgesInCartridgeGroups(serviceGroupDefinition.getName(), cartridgeNames);
         }


Input:
public Command[] getCommands() {
    if (_cmds == null) {
        try {
            _cmds = s_gson.fromJson(_content, Command[].class);
        } catch (RuntimeException e) {
            s_logger.error("String_Node_Str" + _content, e);
            throw e;
        }
    }
    return _cmds;
}

Output:
         try {
-            _cmds = s_gson.fromJson(_content, Command[].class);
+            StringReader reader = new StringReader(_content);
+            JsonReader jsonReader = new JsonReader(reader);
+            jsonReader.setLenient(true);
+            _cmds = s_gson.fromJson(jsonReader, (Type) Command[].class);
         } catch (RuntimeException e) {


Input:
public static String executePdfToPdfa(Path p, Path fixed) throws IOException, VeraPDFException, GhostscriptException {
    Path pdfa = Files.createTempFile("String_Node_Str", "String_Node_Str");
    String[] gsArgs = new String[10];
    gsArgs[0] = "String_Node_Str";
    gsArgs[1] = "String_Node_Str";
    gsArgs[2] = "String_Node_Str";
    gsArgs[3] = "String_Node_Str";
    gsArgs[4] = "String_Node_Str";
    gsArgs[5] = "String_Node_Str";
    gsArgs[6] = "String_Node_Str";
    gsArgs[7] = "String_Node_Str";
    gsArgs[8] = "String_Node_Str" + pdfa.toString();
    gsArgs[9] = p.toString();
    Ghostscript gs = Ghostscript.getInstance();
    try {
        gs.initialize(gsArgs);
        gs.exit();
    } catch (GhostscriptException e) {
        throw new GhostscriptException("String_Node_Str", e);
    }
    InputStream is = new FileInputStream(pdfa.toString());
    try (ModelParser loader = new ModelParser(is)) {
        ValidationProfile profile = Profiles.getVeraProfileDirectory().getValidationProfileByFlavour(PDFAFlavour.PDFA_1_B);
        PDFAValidator validator = Validators.createValidator(profile, true);
        ValidationResult result = validator.validate(loader);
        is.close();
        OutputStream fixedOutputStream = new FileOutputStream(fixed.toString());
        FixerConfig fconf = FixerConfigImpl.getFixerConfig(loader.getPDDocument(), result);
        MetadataFixerImpl.fixMetadata(fixedOutputStream, fconf);
        fixedOutputStream.close();
        loader.close();
    } catch (ValidationException | FileNotFoundException e) {
        throw new VeraPDFException("String_Node_Str", e);
    }
    return "String_Node_Str";
}

Output:
         is.close();
-        OutputStream fixedOutputStream = new FileOutputStream(fixed.toString());
-        FixerConfig fconf = FixerConfigImpl.getFixerConfig(loader.getPDDocument(), result);
-        MetadataFixerImpl.fixMetadata(fixedOutputStream, fconf);
-        fixedOutputStream.close();
+        if (result.isCompliant()) {
+            FileUtils.copyFile(pdfa.toFile(), fixed.toFile());
+        } else {
+            OutputStream fixedOutputStream = new FileOutputStream(fixed.toString());
+            FixerConfig fconf = FixerConfigImpl.getFixerConfig(loader.getPDDocument(), result);
+            MetadataFixerResult mfr = MetadataFixerImpl.fixMetadata(fixedOutputStream, fconf);
+            fixedOutputStream.close();
+        }
         loader.close();


Input:
private TickList generateTickList(int i) {
    TickList current;
    current = new TickList((String) model.getValueAt(i, 0), Integer.parseInt((String) model.getValueAt(i, 1)), Integer.parseInt((String) model.getValueAt(i, 2)));
    if (i + 1 == view.getTableTicks().getRowCount())
        return current;
    current.setNext(generateTickList(i + 1));
    return current;
}

Output:
     TickList current;
-    current = new TickList((String) model.getValueAt(i, 0), Integer.parseInt((String) model.getValueAt(i, 1)), Integer.parseInt((String) model.getValueAt(i, 2)));
+    current = new TickList((String) model.getValueAt(i, 0), (int) model.getValueAt(i, 1), (int) model.getValueAt(i, 2));
     if (i + 1 == view.getTableTicks().getRowCount())


Input:
public boolean runCommand(String[] args, IMessageHandler handler) {
    buildManager = new AjBuildManager(handler);
    savedArgs = new String[args.length];
    System.arraycopy(args, 0, savedArgs, 0, savedArgs.length);
    for (int i = 0; i < args.length; i++) {
        if ("String_Node_Str".equals(args[i])) {
            MessageUtil.abort(handler, BuildArgParser.getUsage());
            return true;
        }
    }
    return doCommand(handler, false);
}

Output:
         if ("String_Node_Str".equals(args[i])) {
-            MessageUtil.abort(handler, BuildArgParser.getUsage());
+            MessageUtil.abort(handler, BuildArgParser.getXOptionUsage());
             return true;


Input:
private ListenableFuture<Object> downloadDependenciesInternal(final Transaction tx, final Object marker, final List<Transaction> results) {
    final SettableFuture<Object> resultFuture = SettableFuture.create();
    final Sha256Hash rootTxHash = tx.getHash();
    Set<Transaction> dependencies = new CopyOnWriteArraySet<Transaction>();
    Set<Sha256Hash> needToRequest = new CopyOnWriteArraySet<Sha256Hash>();
    for (TransactionInput input : tx.getInputs()) {
        Sha256Hash hash = input.getOutpoint().getHash();
        Transaction dep = memoryPool.get(hash);
        if (dep == null) {
            needToRequest.add(hash);
        } else {
            dependencies.add(dep);
        }
    }
    results.addAll(dependencies);
    lock.lock();
    try {
        List<ListenableFuture<Transaction>> futures = Lists.newArrayList();
        GetDataMessage getdata = new GetDataMessage(params);
        final long nonce = (long) (Math.random() * Long.MAX_VALUE);
        if (needToRequest.size() > 1)
            log.info("String_Node_Str", needToRequest.size());
        for (Sha256Hash hash : needToRequest) {
            getdata.addTransaction(hash);
            GetDataRequest req = new GetDataRequest();
            req.hash = hash;
            req.future = SettableFuture.create();
            if (!isNotFoundMessageSupported()) {
                req.nonce = nonce;
            }
            futures.add(req.future);
            getDataFutures.add(req);
        }
        for (Transaction dep : dependencies) {
            futures.add(Futures.immediateFuture(dep));
        }
        ListenableFuture<List<Transaction>> successful = Futures.successfulAsList(futures);
        Futures.addCallback(successful, new FutureCallback<List<Transaction>>() {
            public void onSuccess(List<Transaction> transactions) {
                List<ListenableFuture<Object>> childFutures = Lists.newLinkedList();
                for (Transaction tx : transactions) {
                    if (tx == null)
                        continue;
                    log.info("String_Node_Str", new Object[] { vAddress, rootTxHash, tx.getHashAsString() });
                    results.add(tx);
                    childFutures.add(downloadDependenciesInternal(tx, marker, results));
                }
                if (childFutures.size() == 0) {
                    resultFuture.set(marker);
                } else {
                    Futures.addCallback(Futures.successfulAsList(childFutures), new FutureCallback<List<Object>>() {
                        public void onSuccess(List<Object> objects) {
                            resultFuture.set(marker);
                        }
                        public void onFailure(Throwable throwable) {
                            resultFuture.setException(throwable);
                        }
                    });
                }
            }
            public void onFailure(Throwable throwable) {
                resultFuture.setException(throwable);
            }
        });
        sendMessage(getdata);
        if (!isNotFoundMessageSupported()) {
            log.info("String_Node_Str", this, nonce);
            ping(nonce).addListener(new Runnable() {
                public void run() {
                    for (GetDataRequest req : getDataFutures) {
                        if (req.nonce == nonce) {
                            log.info("String_Node_Str", this, req.hash);
                            req.future.cancel(true);
                            getDataFutures.remove(req);
                        }
                    }
                }
            }, MoreExecutors.sameThreadExecutor());
        }
    } catch (Exception e) {
        log.error("String_Node_Str", this, tx.getHash());
        resultFuture.setException(e);
        return resultFuture;
    } finally {
        lock.unlock();
    }
    return resultFuture;
}

Output:
         if (needToRequest.size() > 1)
-            log.info("String_Node_Str", needToRequest.size());
+            log.info("String_Node_Str", vAddress, needToRequest.size());
         for (Sha256Hash hash : needToRequest) {


Input:
public static List<IRepositoryNode> getUdisRepositoryNodes(boolean withDeleted) {
    RepositoryNode node = getRootNode(ERepositoryObjectType.TDQ_LIBRARIES);
    List<IRepositoryNode> udisNodes = new ArrayList<IRepositoryNode>();
    if (node != null) {
        List<IRepositoryNode> childrens = node.getChildren();
        for (IRepositoryNode subNode : childrens) {
            if (EResourceConstant.INDICATORS.getName().equals((subNode.getObject().getLabel())) || EResourceConstant.RULES.getName().equals((subNode.getObject().getLabel()))) {
                List<IRepositoryNode> subChildren = subNode.getChildren();
                for (IRepositoryNode udisNode : subChildren) {
                    if (udisNode instanceof UserDefIndicatorFolderRepNode || udisNode instanceof RulesFolderRepNode) {
                        udisNodes.addAll(getModelElementFromFolder(udisNode, withDeleted));
                    }
                }
            }
        }
    }
    return udisNodes;
}

Output:
                 for (IRepositoryNode udisNode : subChildren) {
-                    if (udisNode instanceof UserDefIndicatorFolderRepNode || udisNode instanceof RulesFolderRepNode) {
+                    if (udisNode instanceof UserDefIndicatorFolderRepNode || udisNode instanceof RulesSQLFolderRepNode) {
                         udisNodes.addAll(getModelElementFromFolder(udisNode, withDeleted));


Input:
private void changeFollowStatus(final TextView textView, final int position, final boolean isAskingToFollow) {
    if (position >= getBlogCount()) {
        return;
    }
    final long blogId;
    final String blogUrl;
    switch(getBlogType()) {
        case RECOMMENDED:
            ReaderRecommendedBlog blog = mRecommendedBlogs.get(position);
            blogId = blog.blogId;
            blogUrl = blog.getBlogUrl();
            break;
        case FOLLOWED:
            if (position >= mRecommendedBlogs.size()) {
                return;
            }
            ReaderBlog info = mFollowedBlogs.get(position);
            blogId = info.blogId;
            blogUrl = info.getUrl();
            break;
        default:
            return;
    }
    ReaderActions.ActionListener actionListener = new ReaderActions.ActionListener() {
        public void onActionResult(boolean succeeded) {
            Context context = textView.getContext();
            if (!succeeded && context != null) {
                int resId = (isAskingToFollow ? R.string.reader_toast_err_follow_blog : R.string.reader_toast_err_unfollow_blog);
                ToastUtils.showToast(context, resId);
                ReaderUtils.showFollowStatus(textView, !isAskingToFollow);
                checkFollowStatus();
            }
        }
    };
    if (ReaderBlogActions.performFollowAction(blogId, blogUrl, isAskingToFollow, actionListener)) {
        if (getBlogType() == ReaderBlogType.FOLLOWED) {
            mFollowedBlogs.get(position).isFollowing = isAskingToFollow;
        }
        notifyItemChanged(position);
        if (mFollowListener != null) {
            mFollowListener.onFollowBlogChanged();
        }
    }
}

Output:
 private void changeFollowStatus(final TextView textView, final int position, final boolean isAskingToFollow) {
-    if (position >= getBlogCount()) {
+    if (getItemViewType(position) != VIEW_TYPE_ITEM) {
         return;


Input:
private void testFactTableSaveAndLoad1(IDocumentManager documentManager) throws IOException, BirtException {
    Dimension[] dimensions = new Dimension[3];
    ILevelDefn[] levelDefs = new ILevelDefn[1];
    String[] levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension1Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension2Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension3Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[2] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[2].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    IDatasetIterator factTableIterator = new LevelsAndFactTableDataset();
    String[] measureColumnName = new String[2];
    measureColumnName[0] = "String_Node_Str";
    measureColumnName[1] = "String_Node_Str";
    FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), factTableIterator, dimensions, measureColumnName, new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    assertEquals(factTable.getDimensionInfo()[0].dimensionName, "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[0].dimensionLength, 3);
    assertEquals(factTable.getDimensionInfo()[1].dimensionName, "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[1].dimensionLength, 7);
    assertEquals(factTable.getDimensionInfo()[2].dimensionName, "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[2].dimensionLength, 14);
    assertEquals(factTable.getMeasureInfo()[0].measureName, "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[0].dataType, DataType.INTEGER_TYPE);
    assertEquals(factTable.getMeasureInfo()[1].measureName, "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[1].dataType, DataType.DOUBLE_TYPE);
    String[] dimensionNames = new String[1];
    dimensionNames[0] = "String_Node_Str";
    IDiskArray[] dimensionPosition = new IDiskArray[1];
    dimensionPosition[0] = new BufferedPrimitiveDiskArray();
    dimensionPosition[0].add(new Integer(1));
    dimensionPosition[0].add(new Integer(2));
    IFactTableRowIterator facttableRowIterator = new FactTableRowIterator(factTable, dimensionNames, dimensionPosition, new StopSign());
    facttableRowIterator = new FactTableRowIteratorWithFilter(dimensions, facttableRowIterator);
    assertTrue(facttableRowIterator != null);
    assertTrue(facttableRowIterator.next());
    assertEquals(0, facttableRowIterator.getDimensionPosition(0));
    assertEquals(1, facttableRowIterator.getDimensionPosition(1));
    assertEquals(3, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(121), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(121), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(0, facttableRowIterator.getDimensionPosition(0));
    assertEquals(1, facttableRowIterator.getDimensionPosition(1));
    assertEquals(4, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(122), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(122), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(5, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(211), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(211), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(6, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(212), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(212), facttableRowIterator.getMeasure(1));
    assertFalse(facttableRowIterator.next());
}

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


Input:
public ResultSet getTableColumns(String schemaPattern, String tableNamePattern, String columnNamePattern) {
    if (connection == null) {
        try {
            reconnect();
        } catch (Exception e) {
            logger.log(Level.WARNING, e.getMessage(), e);
            return null;
        }
        try {
            return connection.getMetaData().getColumns(connection.getCatalog(), schemaPattern, tableNamePattern, columnNamePattern);
        } catch (SQLException e) {
            logger.log(Level.WARNING, e.getMessage(), e);
            return null;
        }
    }
    try {
        return connection.getMetaData().getColumns(connection.getCatalog(), schemaPattern, tableNamePattern, columnNamePattern);
    } catch (SQLException e) {
        try {
            reconnect();
            return connection.getMetaData().getColumns(connection.getCatalog(), schemaPattern, tableNamePattern, columnNamePattern);
        } catch (Exception e1) {
            logger.log(Level.WARNING, e.getMessage(), e);
            return null;
        }
    }
}

Output:
             return connection.getMetaData().getColumns(connection.getCatalog(), schemaPattern, tableNamePattern, columnNamePattern);
-        } catch (Exception e1) {
-            logger.log(Level.WARNING, e.getMessage(), e);
+        } catch (SQLException e1) {
+            logger.log(Level.WARNING, e1.getMessage(), e1);
+            return null;
+        } catch (OdaException e1) {
+            logger.log(Level.WARNING, e1.getMessage(), e1);
             return null;


Input:
public void generateSnapshot(StructureDefinition base, StructureDefinition derived, String url, String profileName) throws DefinitionException, FHIRException {
    if (base == null)
        throw new DefinitionException("String_Node_Str");
    if (derived == null)
        throw new DefinitionException("String_Node_Str");
    if (snapshotStack.contains(derived.getUrl()))
        throw new DefinitionException("String_Node_Str" + snapshotStack.toString() + "String_Node_Str");
    snapshotStack.add(derived.getUrl());
    derived.setSnapshot(new StructureDefinitionSnapshotComponent());
    int baseCursor = 0;
    int diffCursor = 0;
    if (!derived.getDifferential().getElementFirstRep().getType().isEmpty())
        throw new Error("String_Node_Str");
    processPaths(derived.getSnapshot(), base.getSnapshot(), derived.getDifferential(), baseCursor, diffCursor, base.getSnapshot().getElement().size() - 1, derived.getDifferential().getElement().size() - 1, url, derived.getId(), null, false, base.getUrl(), null, false);
    if (!derived.getSnapshot().getElementFirstRep().getType().isEmpty())
        throw new Error("String_Node_Str");
    updateMaps(base, derived);
    setIds(derived, derived.getName());
}

Output:
     if (!derived.getSnapshot().getElementFirstRep().getType().isEmpty())
-        throw new Error("String_Node_Str");
+        throw new Error("String_Node_Str" + derived.getSnapshot().getElementFirstRep().getPath() + "String_Node_Str" + derived.getUrl() + "String_Node_Str" + base.getUrl());
     updateMaps(base, derived);


Input:
public Set<ItemReferenceBean> checkItemReferenceBeans(IProxyRepositoryFactory factory, DeleteActionCache deleteActionCache, IRepositoryViewObject object) {
    Item nodeItem = object.getProperty().getItem();
    boolean needCheckJobIfUsedInProcess = false;
    if (nodeItem instanceof ProcessItem) {
        needCheckJobIfUsedInProcess = true;
    }
    Set<ItemReferenceBean> list = new HashSet<ItemReferenceBean>();
    if (needCheckJobIfUsedInProcess) {
        Property property = object.getProperty();
        if (property != null) {
            String label = property.getLabel();
            String version = property.getVersion();
            ERepositoryObjectType type = object.getRepositoryObjectType();
            boolean isItemDeleted = factory.getStatus(object) == ERepositoryStatus.DELETED;
            Item item = property.getItem();
            if (!(item instanceof ProcessItem)) {
                return list;
            }
            List<Relation> relations = RelationshipItemBuilder.getInstance().getItemsHaveRelationWith(property.getId());
            if (relations.isEmpty()) {
                return list;
            }
            Set<Project> refParentProjects = new HashSet<Project>();
            try {
                refParentProjects.add(ProjectManager.getInstance().getCurrentProject());
                refParentProjects.addAll(ProjectManager.getInstance().getReferencedProjects());
                for (Project refP : refParentProjects) {
                    List<IRepositoryViewObject> processes = factory.getAll(refP, ERepositoryObjectType.PROCESS, true);
                    deleteActionCache.setProcessList(processes);
                    for (IRepositoryViewObject process : deleteActionCache.getProcessList()) {
                        Property property2 = process.getProperty();
                        if (isOpenedItem(property2, deleteActionCache.getOpenProcessMap())) {
                            continue;
                        }
                        Relation current = new Relation();
                        current.setId(property2.getId());
                        current.setType(RelationshipItemBuilder.JOB_RELATION);
                        current.setVersion(property2.getVersion());
                        if (!relations.contains(current)) {
                            continue;
                        }
                        boolean isDelete = factory.getStatus(process) == ERepositoryStatus.DELETED;
                        Item item2 = property2.getItem();
                        if (item == item2) {
                            continue;
                        }
                        String path = item2.getState().getPath();
                        boolean found = false;
                        ItemReferenceBean bean = new ItemReferenceBean();
                        bean.setItemName(label);
                        bean.setItemVersion(version);
                        bean.setItemType(type);
                        bean.setItemDeleted(isItemDeleted);
                        bean.setReferenceItemName(property2.getLabel());
                        bean.setReferenceItemVersion(property2.getVersion());
                        bean.setReferenceItemType(process.getRepositoryObjectType());
                        bean.setReferenceItemPath(path);
                        bean.setReferenceProjectName(refP.getLabel());
                        bean.setReferenceItemDeleted(isDelete);
                        for (ItemReferenceBean b : list) {
                            if (b.equals(bean)) {
                                found = true;
                                b.addNodeNum();
                                break;
                            }
                        }
                        if (!found) {
                            list.add(bean);
                        }
                    }
                }
                for (IProcess2 openedProcess : deleteActionCache.getOpenedProcessList()) {
                    for (INode node : openedProcess.getGraphicalNodes()) {
                        boolean equals = false;
                        IElementParameter processTypeParam = node.getElementParameter(PROCESS_TYPE_PROCESS);
                        if (processTypeParam != null) {
                            IElementParameter isUseDynamicJob = node.getElementParameter(USE_DYNAMIC_JOB);
                            if (isUseDynamicJob != null && (Boolean) isUseDynamicJob.getValue()) {
                                String[] jobsID = ((String) processTypeParam.getValue()).split("String_Node_Str");
                                for (String jobID : jobsID) {
                                    if (property.getId().equals(jobID)) {
                                        equals = true;
                                        break;
                                    }
                                }
                            } else if (property.getId().equals(processTypeParam.getValue())) {
                                equals = true;
                            }
                        }
                        boolean isDelete = factory.getStatus(openedProcess) == ERepositoryStatus.DELETED;
                        Property property2 = openedProcess.getProperty();
                        Item item2 = property2.getItem();
                        String path = item2.getState().getPath();
                        if (equals) {
                            boolean found = false;
                            ItemReferenceBean bean = new ItemReferenceBean();
                            bean.setItemName(label);
                            bean.setItemVersion(version);
                            bean.setItemType(type);
                            bean.setItemDeleted(isItemDeleted);
                            bean.setReferenceItemName(property2.getLabel());
                            bean.setReferenceItemVersion(property2.getVersion());
                            bean.setReferenceItemType(ERepositoryObjectType.getItemType(item2));
                            bean.setReferenceItemPath(path);
                            bean.setReferenceProjectName(ProjectManager.getInstance().getProject(property2).getLabel());
                            bean.setReferenceItemDeleted(isDelete);
                            for (ItemReferenceBean b : list) {
                                if (b.equals(bean)) {
                                    found = true;
                                    b.addNodeNum();
                                    break;
                                }
                            }
                            if (!found) {
                                list.add(bean);
                            }
                        }
                    }
                }
            } catch (PersistenceException e) {
                ExceptionHandler.process(e);
            }
        }
    }
    Iterator<ItemReferenceBean> it = list.iterator();
    while (it.hasNext()) {
        ItemReferenceBean bean = it.next();
        if ((!bean.isItemDeleted() && bean.isReferenceItemDeleted()) || (bean.isItemDeleted() && bean.isReferenceItemDeleted() && isItemInDeleteList(bean, true)) || (!bean.isItemDeleted() && !bean.isReferenceItemDeleted() && isItemInDeleteList(bean, true))) {
            it.remove();
        }
    }
    return list;
}

Output:
                 for (Project refP : refParentProjects) {
-                    List<IRepositoryViewObject> processes = factory.getAll(refP, ERepositoryObjectType.PROCESS, true);
+                    List<IRepositoryViewObject> processes = new LinkedList<IRepositoryViewObject>();
+                    List<ERepositoryObjectType> allTypesOfProcess = ERepositoryObjectType.getAllTypesOfProcess();
+                    Iterator<ERepositoryObjectType> processIter = allTypesOfProcess.iterator();
+                    while (processIter.hasNext()) {
+                        ERepositoryObjectType process = processIter.next();
+                        List<IRepositoryViewObject> repositoryViewObjectList = factory.getAll(refP, process, true);
+                        if (repositoryViewObjectList != null) {
+                            processes.addAll(repositoryViewObjectList);
+                        }
+                    }
                     deleteActionCache.setProcessList(processes);


Input:
public void mouseDragged(MouseEvent event) {
    PlotBox.this._zoomBox(event.getX(), event.getY());
}

Output:
 public void mouseDragged(MouseEvent event) {
-    PlotBox.this._zoomBox(event.getX(), event.getY());
+    if ((event.getModifiers() & event.BUTTON1_MASK) != 0 && ((event.getModifiers() & InputEvent.BUTTON3_MASK) == 0)) {
+        PlotBox.this._zoomBox(event.getX(), event.getY());
+    }
 }


Input:
public void onKeyDown(KeyDownEvent event) {
    if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
        boolean isValid = validator.test(inputBox.getText());
        if (isValid) {
            dialogBox.hide();
            callback.onSuccess(inputBox.getText());
        }
    } else {
        TextBox box = (TextBox) event.getSource();
        confirmButton.setEnabled(validator.test(box.getText()));
    }
}

Output:
 public void onKeyDown(KeyDownEvent event) {
-    if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
-        boolean isValid = validator.test(inputBox.getText());
-        if (isValid) {
-            dialogBox.hide();
-            callback.onSuccess(inputBox.getText());
-        }
-    } else {
-        TextBox box = (TextBox) event.getSource();
-        confirmButton.setEnabled(validator.test(box.getText()));
-    }
+    TextBox box = (TextBox) event.getSource();
+    confirmButton.setEnabled(validator.test(box.getText()));
 }


Input:
public String parse(int ident) {
    String space, content;
    if (ident < 0)
        ident = 0;
    space = "String_Node_Str";
    for (int i = 0; i < ident; i++) space += "String_Node_Str";
    content = space + "String_Node_Str";
    content += "String_Node_Str" + getComparator().toString() + "String_Node_Str";
    content += "String_Node_Str";
    for (A attribute : attributeAssessments) content += attribute.parse(ident + 1);
    if (valueAssessment != null)
        content += valueAssessment.parse(ident + 1);
    content += space + "String_Node_Str";
    return content;
}

Output:
     content = space + "String_Node_Str";
-    content += "String_Node_Str" + getComparator().toString() + "String_Node_Str";
+    if (getComparator() != null)
+        content += "String_Node_Str" + getComparator().toString() + "String_Node_Str";
     content += "String_Node_Str";


Input:
public boolean apply(Snapshot snap) {
    if (!State.EXTANT.equals(snap.getState()) && !State.FAIL.equals(snap.getState())) {
        return false;
    } else if (!RestrictedTypes.filterPrivileged().apply(snap)) {
        throw Exceptions.toUndeclared(new EucalyptusCloudException("String_Node_Str" + request.getSnapshotId() + "String_Node_Str" + ctx.getUser().getName()));
    } else if (isReservedSnapshot(snapshotId)) {
        throw Exceptions.toUndeclared(new EucalyptusCloudException("String_Node_Str" + request.getSnapshotId() + "String_Node_Str"));
    } else {
        fireUsageEvent(snap, SnapShotEvent.forSnapShotDelete());
        final String partition = snap.getPartition();
        final String snapshotId = snap.getDisplayName();
        Callable<Boolean> deleteBroadcast = new Callable<Boolean>() {
            public Boolean call() {
                final DeleteStorageSnapshotType deleteMsg = new DeleteStorageSnapshotType(snapshotId);
                return Iterables.all(Topology.enabledServices(Storage.class), new Predicate<ServiceConfiguration>() {
                    public boolean apply(ServiceConfiguration arg0) {
                        if (!arg0.getPartition().equals(partition)) {
                            try {
                                AsyncRequests.sendSync(arg0, deleteMsg);
                            } catch (Exception ex) {
                                LOG.error(ex);
                                Logs.extreme().error(ex, ex);
                            }
                        }
                        return true;
                    }
                });
            }
        };
        ServiceConfiguration sc = null;
        try {
            sc = Topology.lookup(Storage.class, Partitions.lookupByName(snap.getPartition()));
        } catch (final Exception ex) {
            sc = null;
        }
        if (sc != null) {
            try {
                DeleteStorageSnapshotResponseType scReply = AsyncRequests.sendSync(sc, new DeleteStorageSnapshotType(snap.getDisplayName()));
                if (scReply.get_return()) {
                    Threads.enqueue(Eucalyptus.class, Snapshots.class, deleteBroadcast);
                } else {
                    throw Exceptions.toUndeclared(new EucalyptusCloudException("String_Node_Str" + snap));
                }
            } catch (Exception ex1) {
                throw Exceptions.toUndeclared(ex1.getMessage(), ex1);
            }
        } else {
            Threads.enqueue(Eucalyptus.class, Snapshots.class, deleteBroadcast);
        }
        return true;
    }
}

Output:
     } else if (!RestrictedTypes.filterPrivileged().apply(snap)) {
-        throw Exceptions.toUndeclared(new EucalyptusCloudException("String_Node_Str" + request.getSnapshotId() + "String_Node_Str" + ctx.getUser().getName()));
+        throw Exceptions.toUndeclared(new ClientUnauthorizedComputeException("String_Node_Str" + request.getSnapshotId() + "String_Node_Str" + ctx.getUser().getName()));
     } else if (isReservedSnapshot(snapshotId)) {


Input:
private final void showRightValue(IPrimitiveRenderer ipr, Location lo, Label la, boolean bShadow) {
    Graphics2D g2d = (Graphics2D) ((IDeviceRenderer) ipr).getGraphicsContext();
    double dX = lo.getX(), dY = lo.getY();
    FontDefinition fd = la.getCaption().getFont();
    double dAngleInDegrees = fd.getRotation();
    if (bShadow) {
        bShadow = la.getShadowColor() != null;
    }
    Color clrText = (Color) _sxs.getColor(la.getCaption().getColor());
    Color clrBackground = null;
    if (la.getBackground() != null) {
        clrBackground = (Color) _sxs.getColor((ColorDefinition) la.getBackground());
    }
    dY += 1;
    final ITextMetrics itm = new SVGTextMetrics(_sxs, la);
    final double dFW = itm.getFullWidth();
    final double dH = itm.getHeight();
    final double dD = itm.getDescent();
    final double dFH = itm.getFullHeight();
    double dXOffset = 0, dW = 0;
    final int iLC = itm.getLineCount();
    final Insets ins = la.getInsets().scaledInstance(_sxs.getDpiResolution() / 72d);
    SVGTextLayout tl;
    final HorizontalAlignment ha = la.getCaption().getFont().getAlignment().getHorizontalAlignment();
    final boolean bRightAligned = ha.getValue() == HorizontalAlignment.RIGHT;
    final boolean bCenterAligned = ha.getValue() == HorizontalAlignment.CENTER;
    double dAngleInRadians = ((-dAngleInDegrees * Math.PI) / 180.0);
    int iRotateX = (int) dX;
    int iRotateY = (int) (dY + dH / 2);
    dY += dH / 2;
    if (dAngleInDegrees == 0) {
        double dYHalfOffset = (dFH + dH) / 2d;
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dYHalfOffset) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dYHalfOffset) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dYHalfOffset) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dYHalfOffset, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) (dY - dYHalfOffset + ins.getTop() + dH * (i + 1) - dD));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
    } else if (dAngleInDegrees > 0 && dAngleInDegrees < 90) {
        double dDeltaX = dH * Math.sin(dAngleInRadians);
        double dDeltaY = dH * Math.cos(dAngleInRadians) - dH / 2;
        dX -= dDeltaX;
        dY += dDeltaY;
        g2d.rotate(dAngleInRadians, iRotateX - dDeltaX, iRotateY + dDeltaY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, (dY - dH), dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) ((dY - dD + dH * i) + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, iRotateX - dDeltaX, iRotateY + dDeltaY);
    } else if (dAngleInDegrees < 0 && dAngleInDegrees > -90) {
        double dDeltaY = -dH / 2;
        dY += dDeltaY;
        g2d.rotate(dAngleInRadians, iRotateX, iRotateY + dDeltaY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dFH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dFH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dFH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dFH, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) ((dY - dD - dH * (iLC - i - 1)) - ins.getBottom()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, iRotateX, iRotateY + dDeltaY);
    } else if (dAngleInDegrees == 90) {
        double dDeltaX = dH;
        double dDeltaY = (dFW - dH) / 2;
        dX += dDeltaX;
        dY += dDeltaY;
        g2d.rotate(dAngleInRadians, dX, dY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dH, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) ((dY - dD + dH * i) + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, dX, dY);
    } else if (dAngleInDegrees == -90) {
        double dDeltaX = 0;
        double dDeltaY = (dFW + dH) / 2;
        dX += dDeltaX;
        dY -= dDeltaY;
        g2d.rotate(dAngleInRadians, dX, dY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dH, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) ((dY - dD + dH * i) + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, dX, dY);
    }
    itm.dispose();
}

Output:
 private final void showRightValue(IPrimitiveRenderer ipr, Location lo, Label la, boolean bShadow) {
-    Graphics2D g2d = (Graphics2D) ((IDeviceRenderer) ipr).getGraphicsContext();
+    SVGGraphics2D g2d = (SVGGraphics2D) ((IDeviceRenderer) ipr).getGraphicsContext();
     double dX = lo.getX(), dY = lo.getY();


Input:
private void valueChangedFloat(Text text, boolean bGeneFactor) {
    if (!text.isFocusControl())
        return;
    float temp = 0;
    try {
        temp = Float.parseFloat(text.getText());
        if (temp >= 1f && temp < 10) {
            if (bGeneFactor == true)
                fclusterFactorGenes = temp;
            else
                fclusterFactorExperiments = temp;
        } else {
            Shell shell = new Shell();
            MessageBox messageBox = new MessageBox(shell, SWT.OK);
            messageBox.setText("String_Node_Str");
            messageBox.setMessage("String_Node_Str");
            messageBox.open();
        }
    } catch (NumberFormatException e) {
        System.out.println("String_Node_Str");
    }
}

Output:
         temp = Float.parseFloat(text.getText());
-        if (temp >= 1f && temp < 10) {
+        if (temp >= 1f && temp <= 10) {
             if (bGeneFactor == true)


Input:
public EntityAction compile(CompilerContext context, Type type, String actionName, Code code) {
    String name = type.name + "String_Node_Str" + NamesEncoding.encode(actionName) + "String_Node_Str" + String.valueOf(count++);
    try {
        byte[] b = this.doCompile(name, code, context);
        if (log.isDebugEnabled()) {
            try {
                FileOutputStream fos = new FileOutputStream("String_Node_Str" + name + "String_Node_Str");
                fos.write(b);
                fos.close();
            } catch (FileNotFoundException e) {
                log.error(e);
                throw new RuntimeException(e);
            } catch (IOException e) {
                log.error(e);
                throw new RuntimeException(e);
            }
        }
        Class<?> expClass = NebulaClassLoader.defineClass(name, b);
        EntityAction expr = (EntityAction) expClass.newInstance();
        return expr;
    } catch (ClassFormatError e) {
        throw new RuntimeException(e);
    } catch (InstantiationException e) {
        throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

Output:
 public EntityAction compile(CompilerContext context, Type type, String actionName, Code code) {
-    String name = type.name + "String_Node_Str" + NamesEncoding.encode(actionName) + "String_Node_Str" + String.valueOf(count++);
+    if (code instanceof Compiler.Block && ((Compiler.Block) code).statements.size() == 0) {
+        return this.noop;
+    }
+    String name = this.getClass().getSimpleName() + "String_Node_Str" + type.name + "String_Node_Str" + NamesEncoding.encode(actionName) + "String_Node_Str" + String.valueOf(count++);
     try {


Input:
public long getFileModified(String name) throws IOException {
    return 0;
}

Output:
 public long getFileModified(String name) throws IOException {
-    return 0;
+    if (_shortTermStorage.fileExists(name)) {
+        return ((LastModified) _shortTermStorage).getFileModified(name);
+    }
+    return ((LastModified) _longTermStorage).getFileModified(name);
 }


Input:
public boolean createUser(String pseudo, String password, String firstname, String lastname, String country, boolean isProxyEnabled, String proxyHost, String proxyPort) throws BusinessException {
    BigInteger result = BigInteger.valueOf(-1);
    registNumber = null;
    if (isProxyEnabled) {
        System.setProperty("String_Node_Str", proxyHost);
        System.setProperty("String_Node_Str", proxyPort);
        if (proxyPort != null && proxyPort.trim().equals("String_Node_Str")) {
            proxyPort = null;
        }
        SiteManager.setHttpProxyInfo(true, proxyHost, proxyPort);
    }
    String osName = System.getProperty("String_Node_Str");
    String osVersion = System.getProperty("String_Node_Str");
    String javaVersion = System.getProperty("String_Node_Str");
    long totalMemory = Runtime.getRuntime().totalMemory();
    com.sun.management.OperatingSystemMXBean composantSystem = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
    Long memRAM = new Long(composantSystem.getTotalPhysicalMemorySize() / 1024);
    int nbProc = Runtime.getRuntime().availableProcessors();
    String version = VersionUtils.getVersion();
    RegisterUserPortTypeProxy proxy = new RegisterUserPortTypeProxy();
    proxy.setEndpoint("String_Node_Str");
    try {
        IBrandingService brandingService = (IBrandingService) GlobalServiceRegister.getDefault().getService(IBrandingService.class);
        result = proxy.createUser50(pseudo, password, firstname, lastname, country, version, brandingService.getAcronym(), osName, osVersion, javaVersion, totalMemory + "String_Node_Str", memRAM + "String_Node_Str", nbProc + "String_Node_Str");
        if (result.intValue() != -110 && result.signum() < 0) {
            checkErrors(result.intValue());
        }
    } catch (RemoteException e) {
        throw new BusinessException(e);
    }
    return result.intValue() == -110;
}

Output:
     if (isProxyEnabled) {
-        System.setProperty("String_Node_Str", proxyHost);
-        System.setProperty("String_Node_Str", proxyPort);
-        if (proxyPort != null && proxyPort.trim().equals("String_Node_Str")) {
-            proxyPort = null;
-        }
-        SiteManager.setHttpProxyInfo(true, proxyHost, proxyPort);
+        Properties properties = System.getProperties();
+        properties.put("String_Node_Str", "String_Node_Str");
+        properties.put("String_Node_Str", proxyHost);
+        properties.put("String_Node_Str", proxyPort);
+        properties.put("String_Node_Str", proxyUser);
+        properties.put("String_Node_Str", proxyPassword);
     }


Input:
private static CompletionTargetVariable createInvokedVariable(final String receiverName, final ITypeName receiverType, final IIntelligentCompletionContext context, final boolean needsConstructor) {
    CompletionTargetVariable completionTargetVariable = null;
    if (receiverType != null) {
        int documentOffset;
        int variableNameLength = 0;
        if (!needsConstructor && receiverName.length() > 0) {
            variableNameLength = receiverName.length() + 1;
        }
        if (needsConstructor) {
            documentOffset = context.getReplacementRegion().getOffset();
        } else {
            documentOffset = context.getInvocationOffset() - variableNameLength;
        }
        final int replacementLength = context.getReplacementRegion().getLength() + variableNameLength;
        completionTargetVariable = new CompletionTargetVariable(receiverName, receiverType, new Region(documentOffset, replacementLength), needsConstructor);
    }
    return completionTargetVariable;
}

Output:
         }
-        if (needsConstructor) {
-            documentOffset = context.getReplacementRegion().getOffset();
-        } else {
-            documentOffset = context.getInvocationOffset() - variableNameLength;
-        }
+        final int documentOffset = context.getReplacementRegion().getOffset() - variableNameLength;
         final int replacementLength = context.getReplacementRegion().getLength() + variableNameLength;


Input:
public boolean apply(Game game, Ability source) {
    Permanent creature = null;
    if (fixedTarget) {
        creature = game.getPermanent(targetPointer.getFirst(game, source));
    } else {
        Permanent equipment = game.getPermanent(source.getSourceId());
        if (equipment != null && equipment.getAttachedTo() != null) {
            creature = game.getPermanent(equipment.getAttachedTo());
        }
    }
    if (creature != null) {
        creature.addAbility(ability, source.getSourceId(), game);
    }
    return true;
}

Output:
     if (creature != null) {
-        creature.addAbility(ability, source.getSourceId(), game);
+        creature.addAbility(ability, source.getSourceId(), game, false);
     }


Input:
private static Intent prepareVideoLibraryIntent(Context context, boolean multiSelect) {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.setType("String_Node_Str");
    if (multiSelect) {
        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
    }
    return Intent.createChooser(intent, context.getString(R.string.pick_video));
}

Output:
     if (multiSelect) {
-        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
+        }
     }


Input:
protected String getVersion() {
    return (_version);
}

Output:
 protected String getVersion() {
-    return (_version);
+    return (_network.getVersion());
 }


Input:
public static ICalculator getCalculator(Class<?> clz) {
    if (clz.equals(Boolean.class)) {
        return new BooleanCalculator();
    } else if (clz.equals(Date.class)) {
        return new DateCalculator();
    } else if (clz.equals(String.class)) {
        return new StringCalculator();
    } else if (clz.equals(BigDecimal.class)) {
        return new BigDecimalCalculator();
    } else {
        return new NumberCalculator();
    }
}

Output:
         return new BooleanCalculator();
-    } else if (clz.equals(Date.class)) {
+    } else if (Date.class.isAssignableFrom(clz)) {
         return new DateCalculator();


Input:
public static String getSetFlexiFormDirtyForCheckbox(Form form, String id) {
    String result;
    String prefix = id + "String_Node_Str";
    String postfix = "String_Node_Str" + form.getDispatchFieldId() + "String_Node_Str";
    result = prefix + "String_Node_Str" + postfix;
    result += prefix + "String_Node_Str" + postfix;
    return result;
}

Output:
     String result;
-    String prefix = id + "String_Node_Str";
+    String prefix = secureJSVarName(id) + "String_Node_Str";
     String postfix = "String_Node_Str" + form.getDispatchFieldId() + "String_Node_Str";


Input:
protected void handleSecureFlag() throws JspException {
    BaseURL url = getUrl();
    if (url == null) {
        throw new IllegalStateException("String_Node_Str");
    }
    if (var != null) {
        pageContext.removeAttribute(var, PageContext.PAGE_SCOPE);
    }
    if (secure != null) {
        try {
            url.setSecure(getSecureBoolean());
        } catch (PortletSecurityException e) {
        }
    }
}

Output:
         try {
-            url.setSecure(getSecureBoolean());
+            url.setSecure(isSecure());
         } catch (PortletSecurityException e) {


Input:
public void onReturn(Intent result) {
    switch(result.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR)) {
        case OpenPgpApi.RESULT_CODE_SUCCESS:
            {
                if (requestCode == REQUEST_CODE_DECRYPT_AND_VERIFY && os != null) {
                    try {
                        Log.d(OpenPgpApi.TAG, "String_Node_Str" + os.toByteArray().length + "String_Node_Str" + os.toString("String_Node_Str"));
                        bindingDialog.dismiss();
                        if (returnToCiphertextField) {
                            findViewById(R.id.crypto_container).setVisibility(View.VISIBLE);
                            String[] passContent = os.toString("String_Node_Str").split("String_Node_Str");
                            ((TextView) findViewById(R.id.crypto_password_show)).setText(passContent[0]);
                            String extraContent = os.toString("String_Node_Str").replaceFirst("String_Node_Str", "String_Node_Str");
                            if (extraContent.length() != 0) {
                                ((TextView) findViewById(R.id.crypto_extra_show)).setText(extraContent);
                            }
                            new DelayShow().execute();
                            if (settings.getBoolean("String_Node_Str", true)) {
                                copyToClipBoard();
                            }
                        } else {
                            showToast(os.toString());
                        }
                    } catch (UnsupportedEncodingException e) {
                        Log.e(Constants.TAG, "String_Node_Str", e);
                    }
                }
                if (requestCode == REQUEST_CODE_ENCRYPT && os != null) {
                    try {
                        String path = getIntent().getExtras().getString("String_Node_Str") + "String_Node_Str" + ((EditText) findViewById(R.id.crypto_password_file_edit)).getText().toString() + "String_Node_Str";
                        OutputStream outputStream = FileUtils.openOutputStream(new File(path));
                        outputStream.write(os.toByteArray());
                        Intent data = new Intent();
                        data.putExtra("String_Node_Str", path);
                        data.putExtra("String_Node_Str", ((EditText) findViewById(R.id.crypto_password_file_edit)).getText().toString());
                        setResult(RESULT_OK, data);
                        finish();
                    } catch (Exception e) {
                        Log.e(Constants.TAG, "String_Node_Str", e);
                    }
                }
                if (result.hasExtra(OpenPgpApi.RESULT_KEY_IDS)) {
                    long[] ids = result.getLongArrayExtra(OpenPgpApi.RESULT_KEY_IDS);
                    ArrayList<String> keys = new ArrayList<String>();
                    for (int i = 0; i < ids.length; i++) {
                        keys.add(OpenPgpUtils.convertKeyIdToHex(ids[i]));
                    }
                    keyIDs = StringUtils.join(keys, "String_Node_Str");
                    if (!keyIDs.isEmpty()) {
                        String mKeys = keyIDs.split("String_Node_Str").length > 1 ? keyIDs : keyIDs.split("String_Node_Str")[0];
                        settings.edit().putString("String_Node_Str", keyIDs).apply();
                        Log.i("String_Node_Str", mKeys);
                    }
                    setResult(RESULT_OK);
                    finish();
                }
                break;
            }
        case OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED:
            {
                Log.i("String_Node_Str", "String_Node_Str");
                PendingIntent pi = result.getParcelableExtra(OpenPgpApi.RESULT_INTENT);
                try {
                    PgpHandler.this.startIntentSenderForResult(pi.getIntentSender(), requestCode, null, 0, 0, 0);
                } catch (IntentSender.SendIntentException e) {
                    Log.e(Constants.TAG, "String_Node_Str", e);
                }
                break;
            }
        case OpenPgpApi.RESULT_CODE_ERROR:
            {
                showToast("String_Node_Str");
                OpenPgpError error = result.getParcelableExtra(OpenPgpApi.RESULT_ERROR);
                handleError(error);
                bindingDialog.dismiss();
                break;
            }
    }
}

Output:
                         } else {
-                            showToast(os.toString());
+                            Log.d("String_Node_Str", "String_Node_Str" + os.toString());
                         }


Input:
public void handle(AsyncResult<DatagramSocket> event) {
    tu.azzert(event.succeeded());
    vertx.setTimer(1000, new Handler<Long>() {

        public void handle(Long event) {
            tu.azzert(!received.get());
            tu.testComplete();
        }
    });
}

Output:
     tu.azzert(event.succeeded());
-    vertx.setTimer(1000, new Handler<Long>() {
+    final AtomicBoolean receivedAfter = new AtomicBoolean();
+    peer1.dataHandler(new Handler<DatagramPacket>() {


Input:
public void testSystemServices() throws Exception {
    Type token = new TypeToken<List<SystemServiceMeta>>() {
    }.getType();
    HttpURLConnection urlConn = openURL("String_Node_Str", HttpMethod.GET);
    Assert.assertEquals(HttpResponseStatus.OK.getCode(), urlConn.getResponseCode());
    List<SystemServiceMeta> actual = GSON.fromJson(new String(ByteStreams.toByteArray(urlConn.getInputStream()), Charsets.UTF_8), token);
    Assert.assertEquals(8, actual.size());
    urlConn.disconnect();
}

Output:
     List<SystemServiceMeta> actual = GSON.fromJson(new String(ByteStreams.toByteArray(urlConn.getInputStream()), Charsets.UTF_8), token);
-    Assert.assertEquals(8, actual.size());
+    Assert.assertEquals(9, actual.size());
     urlConn.disconnect();


Input:
public static void addDataType(String type, int dataType) {
    typeMappings.put(type, new Integer(dataType));
}

Output:
 public static void addDataType(String type, int dataType) {
-    typeMappings.put(type, new Integer(dataType));
+    typeMappings.put(type, DataUtil.integer(dataType));
 }


Input:
private String finalizeQuery(ZQuery zQuery) {
    StringBuffer buf = new StringBuffer();
    buf.append(zQuery.toString());
    if (containsLimitClause) {
        buf.append("String_Node_Str" + withoutLimit[1]);
    }
    return buf.toString();
}

Output:
     StringBuffer buf = new StringBuffer();
-    buf.append(zQuery.toString());
+    buf.append(query.toString());
     if (containsLimitClause) {


Input:
public void rcWaitForWindow(final String title, String operator, int pTimeout, int delay) {
    final Stage s = getStageByTitle(title, operator);
    if (s == null) {
        log.error("String_Node_Str" + title + "String_Node_Str" + operator);
        throw new StepExecutionException("String_Node_Str", EventFactory.createActionError(TestErrorEvent.COMP_NOT_FOUND));
    }
    final CountDownLatch signal = new CountDownLatch(1);
    final EventHandler<WindowEvent> showHandler = new EventHandler<WindowEvent>() {
        public void handle(WindowEvent event) {
            signal.countDown();
        }
    };
    boolean isShowing = EventThreadQueuerJavaFXImpl.invokeAndWait("String_Node_Str", new Callable<Boolean>() {
        public Boolean call() throws Exception {
            if (!s.isShowing()) {
                s.addEventFilter(WindowEvent.WINDOW_SHOWN, showHandler);
                return false;
            }
            return true;
        }
    });
    if (!isShowing) {
        try {
            signal.await(pTimeout, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            throw new StepExecutionException("String_Node_Str", EventFactory.createActionError(TestErrorEvent.EXECUTION_ERROR));
        } finally {
            s.removeEventFilter(WindowEvent.WINDOW_SHOWN, showHandler);
        }
        boolean result = EventThreadQueuerJavaFXImpl.invokeAndWait("String_Node_Str", new Callable<Boolean>() {
            public Boolean call() throws Exception {
                return s.isShowing();
            }
        });
        if (!result) {
            throw new StepExecutionException("String_Node_Str", EventFactory.createActionError(TestErrorEvent.TIMEOUT_EXPIRED));
        }
    }
    TimeUtil.delay(delay);
}

Output:
 public void rcWaitForWindow(final String title, String operator, int pTimeout, int delay) {
-    final Stage s = getStageByTitle(title, operator);
+    Stage s = null;
+    try {
+        long timeout = pTimeout;
+        long done = System.currentTimeMillis() + timeout;
+        long now;
+        do {
+            s = getStageByTitle(title, operator);
+            now = System.currentTimeMillis();
+            timeout = done - now;
+            Thread.sleep(50);
+        } while (timeout > 0 && s == null);
+    } catch (InterruptedException e) {
+        throw new RobotException(e);
+    }
     if (s == null) {


Input:
private static void queueSubscription(Context context, SQLiteDatabase db, long accountId, String subreddit, boolean subscribe) {
    String[] credentials = getCredentials(db, accountId);
    Intent intent = new Intent(context, SyncService.class);
    intent.putExtra(SyncService.EXTRA_COOKIE, credentials[INDEX_COOKIE]);
    intent.putExtra(SyncService.EXTRA_MODHASH, credentials[INDEX_MODHASH]);
    intent.putExtra(SyncService.EXTRA_SUBREDDIT, subreddit);
    intent.putExtra(SyncService.EXTRA_SUBSCRIBE, subscribe);
    context.startService(intent);
}

Output:
     Intent intent = new Intent(context, SyncService.class);
-    intent.putExtra(SyncService.EXTRA_COOKIE, credentials[INDEX_COOKIE]);
-    intent.putExtra(SyncService.EXTRA_MODHASH, credentials[INDEX_MODHASH]);
-    intent.putExtra(SyncService.EXTRA_SUBREDDIT, subreddit);
-    intent.putExtra(SyncService.EXTRA_SUBSCRIBE, subscribe);
+    intent.setData(taskUri);
     context.startService(intent);


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    layout = (LinearLayout) inflater.inflate(R.layout.recording_fragment, container);
    prepareButtons();
    prepareText();
    setWindowSize();
    fileName = Environment.getExternalStorageDirectory().getAbsolutePath();
    fileName += FILE_EXT;
    return layout;
}

Output:
     setWindowSize();
-    fileName = Environment.getExternalStorageDirectory().getAbsolutePath();
-    fileName += FILE_EXT;
+    fileName = Environment.getExternalStorageDirectory().getAbsolutePath() + FILE_EXT;
     return layout;


Input:
public void mouseWheelMoved(GlimpseMouseEvent event) {
    GlimpseAxisLayout2D layout = getAxisLayout(event);
    if (layout == null)
        return;
    Axis2D axis2D = layout.getAxis(event.getTargetStack());
    double xTileDim = axis2D.getAxisX().getSizePixels() / 256;
    double yTileDim = axis2D.getAxisY().getSizePixels() / 256;
    double minX = axis2D.getAxisX().getMin();
    double maxX = axis2D.getAxisX().getMax();
    double minY = axis2D.getAxisY().getMin();
    double maxY = axis2D.getAxisY().getMax();
    LatLonGeo center = geoProj.unproject((minX + maxX) / 2., (minY + maxY) / 2.);
    LatLonGeo ne = geoProj.unproject(maxX, maxY);
    LatLonGeo sw = geoProj.unproject(minX, minY);
    double east = ne.getLonDeg();
    double west = sw.getLonDeg();
    double lonSizeDeg = (east - west) / xTileDim;
    double zoomApprox = Math.log(360 / lonSizeDeg) / LOG2;
    int currentZoom = (int) Math.round(zoomApprox);
    int zoom = currentZoom;
    if (event.getWheelIncrement() == 0) {
    } else if (event.getWheelIncrement() > 0) {
        zoom--;
    } else {
        zoom++;
    }
    zoom = Math.max(0, Math.min(zoom, MAX_ZOOM));
    if (zoom == currentZoom) {
        return;
    }
    double zoomFactor = 1 << zoom;
    double lonTileSizeDeg = 360 / zoomFactor;
    double latTileSizeDeg = 170.1022 / zoomFactor;
    double dLat = (yTileDim / 2.) * latTileSizeDeg;
    double dLon = (xTileDim / 2.) * lonTileSizeDeg;
    Vector2d maxVec = geoProj.project(LatLonGeo.fromDeg(center.getLatDeg() + dLat, center.getLonDeg() + dLon));
    Vector2d minVec = geoProj.project(LatLonGeo.fromDeg(center.getLatDeg() - dLat, center.getLonDeg() - dLon));
    this.xSpan = maxVec.getX() - minVec.getX();
    this.ySpan = maxVec.getY() - minVec.getY();
    this.mouseWheelMoved(event, axis2D.getAxisX(), true);
    this.mouseWheelMoved(event, axis2D.getAxisY(), false);
    this.applyAndUpdate(axis2D.getAxisX(), axis2D.getAxisY());
}

Output:
     Axis2D axis2D = layout.getAxis(event.getTargetStack());
-    double xTileDim = axis2D.getAxisX().getSizePixels() / 256;
-    double yTileDim = axis2D.getAxisY().getSizePixels() / 256;
+    double xTileDim = axis2D.getAxisX().getSizePixels() / 256.;
+    double yTileDim = axis2D.getAxisY().getSizePixels() / 256.;
     double minX = axis2D.getAxisX().getMin();


Input:
public void writeStatement(MethodWriter writer) {
    Variable var = this.variable;
    if (this.type == DEFAULT) {
        if (var != null) {
            writer.addLocal(var.index, MethodWriter.TOP);
            var.value.writeExpression(writer);
            var.writeSet(writer);
        }
        writer.visitLabel(this.startLabel);
        if (this.condition != null) {
            this.condition.writeJump(writer, this.endLabel);
        }
        if (this.then != null) {
            this.then.writeStatement(writer);
        }
        writer.visitLabel(this.updateLabel);
        if (this.update != null) {
            this.update.writeStatement(writer);
        }
        writer.visitJumpInsn(Opcodes.GOTO, this.startLabel);
        writer.visitLabel(this.endLabel);
        if (var != null) {
            writer.visitLocalVariable(var.qualifiedName, var.type.getExtendedName(), var.type.getSignature(), this.startLabel, this.endLabel, var.index);
        }
        return;
    }
    if (this.type == ARRAY) {
        Variable arrayVar = this.arrayVar;
        Variable indexVar = this.indexVar;
        writer.addLocal(var.index, MethodWriter.TOP);
        writer.addLocal(indexVar.index, indexVar.type);
        writer.addLocal(this.lengthVar.index, this.lengthVar.type);
        writer.addLocal(arrayVar.index, arrayVar.type);
        var.value.writeExpression(writer);
        writer.visitInsn(Opcodes.DUP);
        arrayVar.writeSet(writer);
        writer.visitInsn(Opcodes.ARRAYLENGTH);
        this.lengthVar.writeSet(writer);
        writer.visitLdcInsn(0);
        indexVar.writeSet(writer);
        writer.visitJumpInsn(Opcodes.GOTO, this.updateLabel);
        writer.visitLabel(this.startLabel);
        arrayVar.writeGet(writer);
        indexVar.writeGet(writer);
        writer.visitInsn(arrayVar.type.getArrayLoadOpcode());
        var.writeSet(writer);
        this.then.writeStatement(writer);
        writer.visitIincInsn(indexVar.index, 1);
        writer.visitLabel(this.updateLabel);
        indexVar.writeGet(writer);
        this.lengthVar.writeGet(writer);
        writer.visitJumpInsn(Opcodes.IF_ICMPLT, this.startLabel);
        writer.visitLabel(this.endLabel);
        writer.visitLocalVariable(var.qualifiedName, var.type.getExtendedName(), var.type.getSignature(), this.startLabel, this.endLabel, var.index);
        writer.visitLocalVariable("String_Node_Str", "String_Node_Str", null, this.startLabel, this.endLabel, indexVar.index);
        writer.visitLocalVariable("String_Node_Str", "String_Node_Str", null, this.startLabel, this.endLabel, this.lengthVar.index);
        writer.visitLocalVariable("String_Node_Str", arrayVar.type.getExtendedName(), arrayVar.type.getSignature(), this.startLabel, this.endLabel, arrayVar.index);
        return;
    }
}

Output:
         if (var != null) {
-            writer.addLocal(var.index, MethodWriter.TOP);
+            writer.addLocal(var.index, var.type);
             var.value.writeExpression(writer);


Input:
public String generatePreinitializeMethodBodyCode() throws IllegalActionException {
    String actorClassName = getComponent().getClass().getName();
    StringBuffer containmentCode = new StringBuffer();
    NamedObj parentContainer = getComponent().getContainer();
    NamedObj grandparentContainer = parentContainer.getContainer();
    if (grandparentContainer == null) {
        containmentCode.append("String_Node_Str" + getComponent().getContainer().getClass().getName() + "String_Node_Str" + getComponent().getName() + "String_Node_Str" + _eol);
    } else {
        while (parentContainer != null) {
            containmentCode.insert(0, "String_Node_Str" + parentContainer.getName() + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + parentContainer.getClass().getName() + "String_Node_Str" + parentContainer.getName() + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol);
            parentContainer = parentContainer.getContainer();
        }
        NamedObj container = grandparentContainer;
        containmentCode.insert(0, "String_Node_Str" + _eol + getCodeGenerator().comment(getComponent().getFullName()) + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + container.getName() + "String_Node_Str" + _eol + "String_Node_Str" + container.getClass().getName() + "String_Node_Str" + container.getName() + "String_Node_Str" + _eol + "String_Node_Str" + _eol);
        containmentCode.append("String_Node_Str" + getComponent().getContainer().getClass().getName() + "String_Node_Str" + getComponent().getName() + "String_Node_Str" + "String_Node_Str" + _eol + "String_Node_Str" + _eol);
    }
    StringBuffer code = new StringBuffer();
    Iterator entityPorts = ((Entity) getComponent()).portList().iterator();
    while (entityPorts.hasNext()) {
        ComponentPort insidePort = (ComponentPort) entityPorts.next();
        if (insidePort instanceof TypedIOPort) {
            TypedIOPort castPort = (TypedIOPort) insidePort;
            String name = TemplateParser.escapePortName(castPort.getName());
            if (!castPort.isMultiport() && castPort.isOutsideConnected()) {
                code.append(_generatePortInstantiation(name, castPort.getName(), castPort, 0));
            } else {
                TypedIOPort actorPort = null;
                try {
                    Field foundPortField = _findFieldByPortName(castPort.getName());
                    actorPort = (TypedIOPort) foundPortField.get(getComponent());
                    code.append("String_Node_Str" + getComponent().getClass().getName() + "String_Node_Str" + foundPortField.getName() + "String_Node_Str" + _typeToBaseType(actorPort.getType()) + "String_Node_Str" + _eol);
                } catch (Throwable throwable) {
                    actorPort = (TypedIOPort) ((Entity) getComponent()).getPort(castPort.getName());
                    code.append("String_Node_Str" + actorPort.getName().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + actorPort.isInput() + "String_Node_Str" + actorPort.isOutput() + "String_Node_Str" + _eol);
                }
                int sources = actorPort.numberOfSources();
                for (int i = 0; i < sources; i++) {
                    code.append(_generatePortInstantiation(name, name + "String_Node_Str" + i, actorPort, i));
                }
                int sinks = actorPort.numberOfSinks();
                for (int i = 0; i < sinks; i++) {
                    code.append(_generatePortInstantiation(name, name + "String_Node_Str" + i, actorPort, i));
                }
            }
            List<TypeAttribute> typeAttributes = insidePort.attributeList(TypeAttribute.class);
            if (typeAttributes.size() > 0) {
                if (typeAttributes.size() > 1) {
                    new Exception("String_Node_Str" + insidePort.getFullName() + "String_Node_Str").printStackTrace();
                }
                TypeAttribute typeAttribute = typeAttributes.get(0);
                code.append("String_Node_Str" + _eol + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + insidePort.getName().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + _eol + "String_Node_Str" + typeAttribute.getExpression() + "String_Node_Str" + _eol + "String_Node_Str" + _eol);
            }
        }
    }
    String[] splitInitializeConnectionCode = getCodeGenerator()._splitBody("String_Node_Str", code.toString());
    String result = getCodeGenerator().comment("String_Node_Str") + "String_Node_Str" + _eol + "String_Node_Str" + getComponent().toplevel().getName() + "String_Node_Str" + _eol + containmentCode + "String_Node_Str" + actorClassName + "String_Node_Str" + _eol + "String_Node_Str" + getComponent().getName() + "String_Node_Str" + _eol + splitInitializeConnectionCode[0] + splitInitializeConnectionCode[1] + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol;
    return processCode(result);
}

Output:
     } else {
-        while (parentContainer != null) {
+        while (parentContainer != null && parentContainer.getContainer() != null) {
             containmentCode.insert(0, "String_Node_Str" + parentContainer.getName() + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + parentContainer.getClass().getName() + "String_Node_Str" + parentContainer.getName() + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol);


Input:
public static boolean isSubTypeOf(String typeA, ClassLoader loader, String... types) {
    if (typeA == null || typeA.equals(Constants.OBJECT_INTERNAL)) {
        return false;
    }
    if (types.length == 0) {
        return false;
    }
    boolean internal = types[0].contains("String_Node_Str");
    loader = (loader != null ? loader : ClassLoader.getSystemClassLoader());
    if (internal) {
        typeA = typeA.replace('.', '/');
    } else {
        typeA = typeA.replace('/', '.');
    }
    Set<String> typeSet = new HashSet<>(Arrays.asList(types));
    if (typeSet.contains(typeA)) {
        return true;
    }
    ClassInfo ci = ClassCache.getInstance().get(loader, typeA);
    Collection<String> sTypes = new LinkedList<>();
    for (ClassInfo sCi : ci.getSupertypes(false)) {
        sTypes.add(internal ? sCi.getClassName() : sCi.getJavaClassName());
    }
    sTypes.retainAll(typeSet);
    return !sTypes.isEmpty();
}

Output:
     ClassInfo ci = ClassCache.getInstance().get(loader, typeA);
-    Collection<String> sTypes = new LinkedList<>();
-    for (ClassInfo sCi : ci.getSupertypes(false)) {
-        sTypes.add(internal ? sCi.getClassName() : sCi.getJavaClassName());
+    Collection<ClassInfo> sTypesInfo = ci.getSupertypes(false);
+    if (sTypesInfo != null) {
+        Collection<String> sTypes = new ArrayList<>(sTypesInfo.size());
+        for (ClassInfo sCi : sTypesInfo) {
+            sTypes.add(internal ? sCi.getClassName() : sCi.getJavaClassName());
+        }
+        sTypes.retainAll(typeSet);
+        return !sTypes.isEmpty();
+    } else {
+        return false;
     }


Input:
public ID getConnectedID() {
    synchronized (getConnectLock()) {
        return remoteServerID;
    }
}

Output:
 public ID getConnectedID() {
-    synchronized (getConnectLock()) {
-        return remoteServerID;
-    }
+    return remoteServerID;
 }


Input:
public Set<Pair<Long, Long>> listIsos(ListIsosCmd cmd) throws IllegalArgumentException, InvalidParameterValueException {
    TemplateFilter isoFilter = TemplateFilter.valueOf(cmd.getIsoFilter());
    Account caller = UserContext.current().getCaller();
    boolean listAll = (caller.getType() != Account.ACCOUNT_TYPE_NORMAL && (isoFilter != null && isoFilter == TemplateFilter.all));
    List<Long> permittedAccountIds = new ArrayList<Long>();
    Ternary<Long, Boolean, ListProjectResourcesCriteria> domainIdRecursiveListProject = new Ternary<Long, Boolean, ListProjectResourcesCriteria>(cmd.getDomainId(), cmd.isRecursive(), null);
    _accountMgr.buildACLSearchParameters(caller, cmd.getId(), cmd.getAccountName(), cmd.getProjectId(), permittedAccountIds, domainIdRecursiveListProject, listAll);
    ListProjectResourcesCriteria listProjectResourcesCriteria = domainIdRecursiveListProject.third();
    List<Account> permittedAccounts = new ArrayList<Account>();
    for (Long accountId : permittedAccountIds) {
        permittedAccounts.add(_accountMgr.getAccount(accountId));
    }
    HypervisorType hypervisorType = HypervisorType.getType(cmd.getHypervisor());
    return listTemplates(cmd.getId(), cmd.getIsoName(), cmd.getKeyword(), isoFilter, true, cmd.isBootable(), cmd.getPageSizeVal(), cmd.getStartIndex(), cmd.getZoneId(), hypervisorType, true, cmd.listInReadyState(), permittedAccounts, caller, listProjectResourcesCriteria);
}

Output:
     Ternary<Long, Boolean, ListProjectResourcesCriteria> domainIdRecursiveListProject = new Ternary<Long, Boolean, ListProjectResourcesCriteria>(cmd.getDomainId(), cmd.isRecursive(), null);
-    _accountMgr.buildACLSearchParameters(caller, cmd.getId(), cmd.getAccountName(), cmd.getProjectId(), permittedAccountIds, domainIdRecursiveListProject, listAll);
+    _accountMgr.buildACLSearchParameters(caller, cmd.getId(), cmd.getAccountName(), cmd.getProjectId(), permittedAccountIds, domainIdRecursiveListProject, listAll, false);
     ListProjectResourcesCriteria listProjectResourcesCriteria = domainIdRecursiveListProject.third();


Input:
public void testHoldsLockOnAllOperations() {
    create().element();
    create().offer("String_Node_Str");
    create().peek();
    create().poll();
    create().remove();
    create().add("String_Node_Str");
    create().addAll(ImmutableList.of("String_Node_Str"));
    create().clear();
    create().contains("String_Node_Str");
    create().containsAll(ImmutableList.of("String_Node_Str"));
    create().equals(ImmutableList.of("String_Node_Str"));
    create().hashCode();
    create().isEmpty();
    create().iterator();
    create().remove("String_Node_Str");
    create().removeAll(ImmutableList.of("String_Node_Str"));
    create().retainAll(ImmutableList.of("String_Node_Str"));
    create().size();
    create().toArray();
    create().toArray(new String[] { "String_Node_Str" });
}

Output:
     create().containsAll(ImmutableList.of("String_Node_Str"));
-    create().equals(ImmutableList.of("String_Node_Str"));
+    create().equals(new ArrayDeque<>(ImmutableList.of("String_Node_Str")));
     create().hashCode();


Input:
void updateDimLayer(DimLayer.DimLayerUser dimLayerUser) {
    DimLayerState state = getOrCreateDimLayerState(dimLayerUser);
    final boolean previousFullscreen = state.dimLayer != null && state.dimLayer == mSharedFullScreenDimLayer;
    DimLayer newDimLayer;
    final int displayId = mDisplayContent.getDisplayId();
    if (dimLayerUser.isFullscreen()) {
        if (previousFullscreen) {
            return;
        }
        newDimLayer = mSharedFullScreenDimLayer;
        if (newDimLayer == null) {
            if (state.dimLayer != null) {
                newDimLayer = state.dimLayer;
            } else {
                newDimLayer = new DimLayer(mDisplayContent.mService, dimLayerUser, displayId, getDimLayerTag(dimLayerUser));
            }
            dimLayerUser.getDimBounds(mTmpBounds);
            newDimLayer.setBounds(mTmpBounds);
            mSharedFullScreenDimLayer = newDimLayer;
        } else if (state.dimLayer != null) {
            state.dimLayer.destroySurface();
        }
    } else {
        newDimLayer = (state.dimLayer == null || previousFullscreen) ? new DimLayer(mDisplayContent.mService, dimLayerUser, displayId, getDimLayerTag(dimLayerUser)) : state.dimLayer;
        dimLayerUser.getDimBounds(mTmpBounds);
        newDimLayer.setBounds(mTmpBounds);
    }
    state.dimLayer = newDimLayer;
}

Output:
 void updateDimLayer(DimLayer.DimLayerUser dimLayerUser) {
-    DimLayerState state = getOrCreateDimLayerState(dimLayerUser);
+    final DimLayerState state = getOrCreateDimLayerState(dimLayerUser);
     final boolean previousFullscreen = state.dimLayer != null && state.dimLayer == mSharedFullScreenDimLayer;


Input:
protected void closeStream() throws IOException {
    try {
        synchronized (this) {
            assocIsUp = false;
            peerAddrIsConfirmed = false;
            if (sctpSocket != null) {
                sctpSocket.close();
                sctpSocket = null;
            }
        }
    } finally {
        if (iceSocket != null) {
        }
    }
}

Output:
             assocIsUp = false;
-            peerAddrIsConfirmed = false;
+            acceptedIncomingConnection = false;
             if (sctpSocket != null) {


Input:
private SortedSet<String> getAllResources(String query) {
    SortedSet<String> resources = new TreeSet<String>();
    query = "String_Node_Str" + query.substring(7) + "String_Node_Str";
    ResultSet rs;
    if (selectCache == null) {
        rs = executeSelectQuery(query);
    } else {
        String result = selectCache.executeSelectQuery(endpoint, query);
        rs = SparqlQuery.convertJSONtoResultSet(result);
    }
    String uri;
    QuerySolution qs;
    while (rs.hasNext()) {
        qs = rs.next();
        uri = qs.getResource("String_Node_Str").getURI();
        resources.add(uri);
    }
    return resources;
}

Output:
     SortedSet<String> resources = new TreeSet<String>();
-    query = "String_Node_Str" + query.substring(7) + "String_Node_Str";
+    query = query + "String_Node_Str";
     ResultSet rs;


Input:
protected Vector<?> doInBackground(String... args) {
    if (WordPress.currentBlog == null) {
        try {
            WordPress.currentBlog = new Blog(WordPress.wpDB.getLastBlogID(Read.this), Read.this);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    loginURL = WordPress.currentBlog.getUrl().replace("String_Node_Str", "String_Node_Str");
    if (WordPress.currentBlog.getUrl().lastIndexOf("String_Node_Str") != -1)
        loginURL = WordPress.currentBlog.getUrl().substring(0, WordPress.currentBlog.getUrl().lastIndexOf("String_Node_Str")) + "String_Node_Str";
    else
        loginURL = WordPress.currentBlog.getUrl().replace("String_Node_Str", "String_Node_Str");
    String readerURL = Constants.readerURL;
    if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == 4) {
        readerURL += "String_Node_Str";
    }
    if (loadAdmin) {
        if (WordPress.currentBlog.getUrl().lastIndexOf("String_Node_Str") != -1)
            readerURL = WordPress.currentBlog.getUrl().substring(0, WordPress.currentBlog.getUrl().lastIndexOf("String_Node_Str")) + "String_Node_Str";
        else
            readerURL = WordPress.currentBlog.getUrl().replace("String_Node_Str", "String_Node_Str");
    }
    try {
        String responseContent = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + loginURL + "String_Node_Str" + "String_Node_Str" + WordPress.currentBlog.getUsername() + "String_Node_Str" + "String_Node_Str" + WordPress.currentBlog.getPassword() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + readerURL + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
        wv.setWebViewClient(new WebViewClient() {
            public boolean shouldOverrideUrlLoading(WebView view, String url) {
                view.loadUrl(url);
                return false;
            }
            public void onPageFinished(WebView view, String url) {
            }
        });
        wv.setWebChromeClient(new WebChromeClient() {
            public void onProgressChanged(WebView view, int progress) {
                Read.this.setTitle("String_Node_Str");
                Read.this.setProgress(progress * 100);
                if (progress == 100) {
                    if (loadReader)
                        Read.this.setTitle(getResources().getText(R.string.reader));
                    else
                        Read.this.setTitle(getResources().getText(R.string.wp_admin));
                }
            }
        });
        wv.getSettings().setUserAgentString("String_Node_Str");
        wv.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
        wv.getSettings().setSavePassword(false);
        wv.getSettings().setBuiltInZoomControls(true);
        wv.getSettings().setJavaScriptEnabled(true);
        wv.getSettings().setPluginsEnabled(true);
        wv.getSettings().setDomStorageEnabled(true);
        wv.loadData(responseContent, "String_Node_Str", HTTP.UTF_8);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return null;
}

Output:
         wv.getSettings().setDomStorageEnabled(true);
-        wv.loadData(responseContent, "String_Node_Str", HTTP.UTF_8);
+        wv.loadData(Uri.encode(responseContent), "String_Node_Str", HTTP.UTF_8);
     } catch (Exception ex) {


Input:
public Future<?> submit(Runnable task) {
    return super.submit(wrapRunnable(task));
}

Output:
 public Future<?> submit(Runnable task) {
-    return super.submit(wrapRunnable(task));
+    return super.submit(WrappedRunnable.wrap(LOG, task));
 }


Input:
public void setSendingResult(QueueInfo qi) {
    final Session session = sessionManager.open();
    Transaction tx = session.beginTransaction();
    try {
        Long id = Long.parseLong(qi.getMailid());
        EmailItem i = (EmailItem) session.get(EmailItem.class, id);
        if (i == null) {
            return;
        }
        log.info("String_Node_Str" + i.getRecipientAddress() + "String_Node_Str" + i.getNumAttempts() + "String_Node_Str" + i.getId());
        log.info("String_Node_Str" + qi.getResultInfo() + "String_Node_Str" + qi.getState());
        EmailSendAttempt a = new EmailSendAttempt();
        a.setEmailItem(i);
        a.setStatus(qi.getResultInfo());
        a.setStatusDate(currentDateService.getNow());
        session.save(a);
        i.setSendStatusDate(currentDateService.getNow());
        String sStatus = qi.getResultInfo();
        Integer status = SmtpUtils.getStatusCode(sStatus);
        if (status != null && (status >= 200 || status < 300)) {
            System.out.println("String_Node_Str");
            i.setSendStatus("String_Node_Str");
        } else {
            long tm = currentDateService.getNow().getTime();
            tm = tm + retryIntervalMs;
            Date retryDate = new Date(tm);
            int attempts = 0;
            if (i.getNumAttempts() != null) {
                attempts = i.getNumAttempts();
            }
            if (attempts >= maxAttempts) {
                i.setSendStatus("String_Node_Str");
                log.warn("String_Node_Str" + attempts + "String_Node_Str" + i.getId());
            } else {
                attempts++;
                i.setNextAttempt(retryDate);
                i.setNumAttempts(attempts);
                i.setSendStatus("String_Node_Str");
                log.warn("String_Node_Str" + attempts + "String_Node_Str" + i.getId());
            }
        }
        session.save(i);
        log.info("String_Node_Str");
        BaseEmailJob job = i.getJob();
        if (job != null) {
            log.info("String_Node_Str");
            job.accept(new AbstractEmailJobVisitor() {
                public void visit(GroupEmailJob r) {
                    Date now = currentDateService.getNow();
                    r.checkStatus(now, session);
                }
            });
        } else {
            log.info("String_Node_Str");
        }
        tx.commit();
    } finally {
        sessionManager.close();
    }
}

Output:
         if (status != null && (status >= 200 || status < 300)) {
-            System.out.println("String_Node_Str");
+            log.info("String_Node_Str" + status + "String_Node_Str" + sStatus);
             i.setSendStatus("String_Node_Str");


Input:
public Result verifyEmail(String study) {
    Study studyObj = studyService.getStudy(study);
    return ok(views.html.verifyEmail.render(ASSETS_HOST, ASSETS_BUILD, studyObj.getName(), studyObj.getSupportEmail()));
}

Output:
     Study studyObj = studyService.getStudy(study);
-    return ok(views.html.verifyEmail.render(ASSETS_HOST, ASSETS_BUILD, studyObj.getName(), studyObj.getSupportEmail()));
+    return ok(views.html.verifyEmail.render(ASSETS_HOST, ASSETS_BUILD, StringEscapeUtils.escapeHtml4("String_Node_Str"), studyObj.getSupportEmail()));
 }


Input:
public void finish() {
    super.finish();
    if (dataBytes != null) {
        int length = ~(int) (positionAddr - startAddr);
        NativeBytes.UNSAFE.putOrderedInt(null, startAddr - 4, length);
        long indexValue = ((long) appenderThreadId << INDEX_DATA_OFFSET_BITS) + dataOffset;
        try {
            long position = VanillaIndexCache.append(indexBytes, indexValue, nextSynchronous);
            if (position < 0) {
                if (indexBytes != null) {
                    indexBytes.release();
                    indexBytes = null;
                }
                indexBytes = indexCache.append(appenderCycle, indexValue, nextSynchronous, positionArr);
                setLastWrittenIndex(indexFrom(appenderCycle, positionArr[0]));
            } else {
                setLastWrittenIndex(indexFrom(appenderCycle, position));
            }
        } catch (IOException e) {
            throw new AssertionError(e);
        }
        setIndex(lastWrittenIndex() + 1);
        dataBytes.positionAddr(positionAddr);
        dataBytes.alignPositionAddr(4);
        if (nextSynchronous) {
            dataBytes.force();
        }
    }
}

Output:
     super.finish();
-    if (dataBytes != null) {
-        int length = ~(int) (positionAddr - startAddr);
-        NativeBytes.UNSAFE.putOrderedInt(null, startAddr - 4, length);
-        long indexValue = ((long) appenderThreadId << INDEX_DATA_OFFSET_BITS) + dataOffset;
-        try {
-            long position = VanillaIndexCache.append(indexBytes, indexValue, nextSynchronous);
-            if (position < 0) {
-                if (indexBytes != null) {
-                    indexBytes.release();
-                    indexBytes = null;
-                }
-                indexBytes = indexCache.append(appenderCycle, indexValue, nextSynchronous, positionArr);
-                setLastWrittenIndex(indexFrom(appenderCycle, positionArr[0]));
-            } else {
-                setLastWrittenIndex(indexFrom(appenderCycle, position));
+    if (dataBytes == null)
+        return;
+    int length = ~(int) (positionAddr - startAddr);
+    NativeBytes.UNSAFE.putOrderedInt(null, startAddr - 4, length);
+    int offset = (int) (startAddr - dataBytes.address());
+    long dataOffset = dataBytes.index() * config.dataBlockSize() + offset;
+    long indexValue = ((long) appenderThreadId << INDEX_DATA_OFFSET_BITS) + dataOffset;
+    try {
+        long position = VanillaIndexCache.append(indexBytes, indexValue, nextSynchronous);
+        if (position < 0) {
+            if (indexBytes != null) {
+                indexBytes.release();
+                indexBytes = null;
             }


Input:
public MethodInfo identitySetter() {
    for (MethodInfo methodInfo : methodsInfo().setters()) {
        AnnotationInfo annotationInfo = methodInfo.getAnnotations().get(GraphId.CLASS);
        if (annotationInfo != null) {
            if (methodInfo.getDescriptor().equals("String_Node_Str")) {
                return methodInfo;
            }
        }
    }
    MethodInfo methodInfo = methodsInfo().get("String_Node_Str");
    if (methodInfo != null) {
        if (methodInfo.getDescriptor().equals("String_Node_Str")) {
            return methodInfo;
        }
    }
    return null;
}

Output:
         if (annotationInfo != null) {
-            if (methodInfo.getDescriptor().equals("String_Node_Str")) {
+            if (methodInfo.getTypeDescriptor().equals("String_Node_Str")) {
                 return methodInfo;


Input:
public float getHeight() {
    if (data != null) {
        return data.getHeight();
    }
    return super.getHeight();
}

Output:
 public float getHeight() {
-    if (data != null) {
-        return data.getHeight();
-    }
-    return super.getHeight();
+    return data.getHeight();
 }