Input:
protected void doDelete(HttpServletRequest request, HttpServletResponse response) throws IOException {
    try {
        UnsubscribeRequest data = UnsubscribeRequest.createFromXML(request);
        QueryFactory queryFactory = getOrcsApi().getQueryFactory(null);
        ArtifactReadable authorArtifact = getArtifactById(queryFactory, data.getUserId());
        ArtifactReadable groupArtifact = getArtifactById(queryFactory, data.getGroupId());
        String comment = String.format("String_Node_Str", authorArtifact.getSoleAttributeAsString(CoreAttributeTypes.UserId), groupArtifact.getName());
        GraphReadable readableGraph = orcsApi.getGraph(null);
        TransactionFactory factory = orcsApi.getTransactionFactory(null);
        OrcsTransaction txn = factory.createTransaction(CoreBranches.COMMON, authorArtifact, comment);
        txn.asWriteableGraph(readableGraph).deleteRelation(groupArtifact, CoreRelationTypes.Users_Artifact, authorArtifact);
        txn.commit();
        String message = String.format("String_Node_Str");
        response.setStatus(HttpServletResponse.SC_OK);
        response.setContentType("String_Node_Str");
        response.setContentLength(message.length());
        response.getWriter().append(message);
    } catch (Exception ex) {
        handleError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "String_Node_Str", ex);
    }
}

Output:
     try {
-        UnsubscribeRequest data = UnsubscribeRequest.createFromXML(request);
+        UnsubscribeData data = UnsubscribeParser.createFromXML(request);
         QueryFactory queryFactory = getOrcsApi().getQueryFactory(null);


Input:
public Long apply(OwnerFullName input) {
    EntityWrapper<Volume> db = Entities.get(Volume.class);
    List<Volume> vols = db.createCriteria(Volume.class).add(Example.create(Snapshots.named(input, null))).setReadOnly(true).setCacheable(false).list();
    Long size = 0l;
    for (Volume v : vols) {
        size += v.getSize();
    }
    db.rollback();
    return size;
}

Output:
     EntityWrapper<Volume> db = Entities.get(Volume.class);
-    List<Volume> vols = db.createCriteria(Volume.class).add(Example.create(Snapshots.named(input, null))).setReadOnly(true).setCacheable(false).list();
+    List<Volume> vols = db.createCriteria(Volume.class).add(Example.create(Volume.named(input, null))).setReadOnly(true).setCacheable(false).list();
     Long size = 0l;


Input:
private void addComponent(CellClientComponentMessage message) {
    CellComponentClientState clientState = message.getCellComponentClientState();
    String compClassname = message.getCellComponentClientClassName();
    if (compClassname == null) {
        return;
    }
    try {
        WonderlandSession session = cell.getCellCache().getSession();
        ServerSessionManager ssm = session.getSessionManager();
        ClassLoader cl = ssm.getClassloader();
        Class compClazz = cl.loadClass(compClassname);
        Class lookupClazz = CellComponent.getLookupClass(compClazz);
        CellComponent component = cell.getComponent(lookupClazz);
        if (component == null) {
            Constructor<CellComponent> constructor = compClazz.getConstructor(Cell.class);
            component = constructor.newInstance(cell);
            component.setClientState(clientState);
            cell.addComponent(component, CellComponent.getLookupClass(component.getClass()));
        } else {
            component.setClientState(clientState);
        }
    } catch (InstantiationException ex) {
        logger.log(Level.SEVERE, "String_Node_Str" + compClassname + "String_Node_Str" + getClass().getName(), ex);
    } catch (ClassNotFoundException ex) {
        logger.log(Level.SEVERE, "String_Node_Str" + compClassname, ex);
    } catch (Exception ex) {
        logger.log(Level.SEVERE, null, ex);
    }
}

Output:
         Class compClazz = cl.loadClass(compClassname);
-        Class lookupClazz = CellComponent.getLookupClass(compClazz);
+        Class lookupClazz = CellComponentUtils.getLookupClass(compClazz);
         CellComponent component = cell.getComponent(lookupClazz);


Input:
private InstanceType[] populateInstanceTypeArray() {
    final List<InstanceType> instanceTypes = Lists.newArrayList();
    int count = 1;
    while (true) {
        final String key = INSTANCE_TYPE_PREFIX_KEY + Integer.toString(count);
        String descr = GlobalConfiguration.getString(key, null);
        if (descr == null) {
            if (count == 1) {
                LOG.error("String_Node_Str" + DEFAULT_INSTANCE_TYPE);
                descr = DEFAULT_INSTANCE_TYPE;
            } else {
                break;
            }
        }
        try {
            instanceTypes.add(InstanceType.getTypeFromString(descr));
        } catch (Throwable t) {
            LOG.error("String_Node_Str" + key + "String_Node_Str" + descr, t);
        }
        ++count;
    }
    Collections.sort(instanceTypes, new Comparator<InstanceType>() {
        public int compare(InstanceType o1, InstanceType o2) {
            return o1.getPricePerHour() - o2.getPricePerHour();
        }
    });
    return instanceTypes.toArray(new InstanceType[0]);
}

Output:
     while (true) {
-        final String key = INSTANCE_TYPE_PREFIX_KEY + Integer.toString(count);
+        final String key = ConfigConstants.INSTANCE_MANAGER_INSTANCE_TYPE_PREFIX_KEY + Integer.toString(count);
         String descr = GlobalConfiguration.getString(key, null);


Input:
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    try {
        String objUserId = null;
        if (obj instanceof IAtsUser) {
            objUserId = ((IAtsUser) obj).getUserId();
        } else if (obj instanceof User) {
            objUserId = ((User) obj).getUserId();
        }
        if (!Strings.isValid(objUserId)) {
            return false;
        }
        if (getUserId() == null) {
            if (objUserId != null) {
                return false;
            }
        } else if (!getUserId().equals(objUserId)) {
            return false;
        }
    } catch (OseeCoreException ex) {
        OseeLog.log(Activator.class, Level.SEVERE, ex);
    }
    return true;
}

Output:
             objUserId = ((User) obj).getUserId();
-        }
-        if (!Strings.isValid(objUserId)) {
+        } else {
             return false;


Input:
public void actionPerformed(ActionEvent e) {
    Mondrian mondrian = monFrame.getController().getCurrent();
    mondrian.getSelector().checkHistoryBuffer();
    MDialog plotFrame = new MDialog(monFrame, mondrian);
    Font SF = new Font("String_Node_Str", Font.PLAIN, 11);
    plotFrame.setFont(SF);
    PlotPanel plotPanel = plotFactory.createPlotPanel(mondrian, plotFrame, mondrian.getDataSet(), mondrian.getSelector().getVarNames());
    if (plotPanel != null) {
        for (PlotPanel plot : plotPanel.getPlots()) {
            monFrame.getController().getCurrent().addPlot((DragBox) plot);
        }
        plotFrame.getContentPane().add(plotPanel);
        plotFrame.setTitle(plotPanel.getName() != null ? plotPanel.getName() : plotFactory.getPlotName());
        plotFrame.setVisible(true);
    }
}

Output:
         for (PlotPanel plot : plotPanel.getPlots()) {
-            monFrame.getController().getCurrent().addPlot((DragBox) plot);
+            mondrian.addPlot((DragBox) plot);
         }


Input:
public static Integer toInteger(Object source) throws BirtException {
    if (source == null)
        return null;
    if (source instanceof Integer) {
        return (Integer) source;
    } else if (source instanceof BigDecimal) {
        int intValue = ((BigDecimal) source).intValue();
        return new Integer(intValue);
    } else if (source instanceof Boolean) {
        if (true == ((Boolean) source).booleanValue())
            return new Integer(1);
        return new Integer(0);
    } else if (source instanceof Date) {
        long longValue = ((Date) source).getTime();
        return new Integer((int) longValue);
    } else if (source instanceof Double) {
        int intValue = ((Double) source).intValue();
        return new Integer(intValue);
    } else if (source instanceof String) {
        try {
            return Integer.valueOf((String) source);
        } catch (NumberFormatException e) {
            throw new BirtException(pluginId, ResourceConstants.CONVERT_FAILS, new Object[] { source.toString(), "String_Node_Str" }, resourceBundle);
        }
    } else {
        throw new BirtException(pluginId, ResourceConstants.CONVERT_FAILS, new Object[] { source.toString(), "String_Node_Str" }, resourceBundle);
    }
}

Output:
         try {
-            return Integer.valueOf((String) source);
+            return new Integer(Double.valueOf((String) source).intValue());
         } catch (NumberFormatException e) {


Input:
public void restoreSelection() {
    if (!lastSelectedItem.isPresent()) {
        if (!saveSelectionCalled) {
            throw new IllegalStateException("String_Node_Str");
        } else {
            saveSelectionCalled = false;
            return;
        }
    }
    saveSelectionCalled = false;
    int index = -1;
    int i = 0;
    for (T item : getItems()) {
        if (areItemsEqual(item, lastSelectedItem.get())) {
            index = i;
            break;
        }
        i++;
    }
    boolean itemFound = index > -1;
    if (itemFound) {
        getSelectionModel().clearAndSelect(index);
        selectedIndex = Optional.of(index);
    } else {
        if (getItems().size() == 0) {
            selectedIndex = Optional.empty();
        } else {
            int lastIndex = getItems().size() - 1;
            int nextIndex = Math.min(selectedIndex.get(), lastIndex);
            getSelectionModel().clearAndSelect(nextIndex);
            selectedIndex = Optional.of(nextIndex);
            triggerItemSelected(nextIndex);
        }
    }
}

Output:
     } else {
-        if (getItems().size() == 0) {
+        if (getItems().isEmpty()) {
             selectedIndex = Optional.empty();


Input:
public void fire(final VmRunResponseType reply) {
    Logs.extreme().error(reply);
    EntityTransaction db = Entities.get(VmInstance.class);
    try {
        this.token.redeem();
        for (final VmInfo vmInfo : reply.getVms()) {
            final VmInstance vm = VmInstances.lookup(vmInfo.getInstanceId());
            vm.updateAddresses(vmInfo.getNetParams().getIpAddress(), vmInfo.getNetParams().getIgnoredPublicIp());
        }
        db.commit();
    } catch (Exception ex) {
        Logs.exhaust().error(ex, ex);
        db.rollback();
        this.fireException(ex);
    }
}

Output:
         db.rollback();
-        this.fireException(ex);
+        throw new EucalyptusClusterException("String_Node_Str" + this.getRequest().getInstanceId() + "String_Node_Str" + ex.getMessage(), ex);
     }


Input:
public boolean removeMessageListener(MessageListener listener) {
    return listeners.remove(listener);
}

Output:
 public boolean removeMessageListener(MessageListener listener) {
-    return listeners.remove(listener);
+    return listeners.remove(listener) != null;
 }


Input:
public ByteArrayOutputStream serialize(String propName) {
    if (propName != null && propName.equalsIgnoreCase(ChartReportItemUtil.PROPERTY_XMLPRESENTATION)) {
        if (!hasHostChart) {
            try {
                return SerializerImpl.instance().asXml(cm, true);
            } catch (Exception e) {
                logger.log(e);
                return new ByteArrayOutputStream();
            }
        }
    }
    return null;
}

Output:
     if (propName != null && propName.equalsIgnoreCase(ChartReportItemUtil.PROPERTY_XMLPRESENTATION)) {
-        if (!hasHostChart) {
+        if (!hasHostChart()) {
             try {


Input:
public Long getLatestBandwidth(String device) {
    String query = null;
    try {
        String ipaddr = LeaseData.sharedData().lookup(device);
        if (ipaddr != null) {
            if (lastbwrequest > 0) {
                final String s = String.format("String_Node_Str", lastbwrequest * 1000000);
                query = String.format("String_Node_Str", s, ipaddr, ipaddr);
            } else {
                query = String.format("String_Node_Str", ipaddr, ipaddr);
            }
            return processbwidth(rpc.call(query), ipaddr);
        } else {
            Logger.info("String_Node_Str", device);
        }
    } catch (IOException e) {
        Logger.error(e, "String_Node_Str");
    }
    return 0L;
}

Output:
                 final String s = String.format("String_Node_Str", lastbwrequest * 1000000);
-                query = String.format("String_Node_Str", s, ipaddr, ipaddr);
+                sinceLastQuery = String.format("String_Node_Str", s, BandwidthQuery.subnet, BandwidthQuery.subnet);
             } else {


Input:
public IAgileTeam getAgileTeam(IAgileItem item) {
    ArtifactId itemArt = services.getArtifact(item);
    ArtifactId backlogArt = services.getRelationResolver().getRelatedOrNull(itemArt, AtsRelationTypes.Goal_Member);
    if (backlogArt != null) {
        ArtifactId teamArt = services.getRelationResolver().getRelatedOrNull(backlogArt, AtsRelationTypes.AgileTeamToBacklog_AgileTeam);
        if (teamArt != null) {
            return services.getConfigItemFactory().getAgileTeam(teamArt);
        }
    }
    ArtifactId sprintArt = services.getRelationResolver().getRelatedOrNull(itemArt, AtsRelationTypes.AgileSprintToItem_Sprint);
    if (sprintArt != null) {
        ArtifactId teamArt = services.getRelationResolver().getRelatedOrNull(sprintArt, AtsRelationTypes.AgileTeamToSprint_AgileTeam);
        if (teamArt != null) {
            return services.getConfigItemFactory().getAgileTeam(teamArt);
        }
    }
    return null;
}

Output:
         }
-    }
-    ArtifactId sprintArt = services.getRelationResolver().getRelatedOrNull(itemArt, AtsRelationTypes.AgileSprintToItem_Sprint);
-    if (sprintArt != null) {
-        ArtifactId teamArt = services.getRelationResolver().getRelatedOrNull(sprintArt, AtsRelationTypes.AgileTeamToSprint_AgileTeam);
-        if (teamArt != null) {
-            return services.getConfigItemFactory().getAgileTeam(teamArt);
+        if (agileTeam == null) {
+            ArtifactId sprintArt = services.getRelationResolver().getRelatedOrNull(workItem, AtsRelationTypes.AgileSprintToItem_Sprint);
+            if (sprintArt != null) {
+                IAgileSprint sprint = getAgileSprint(sprintArt);
+                if (sprint != null) {
+                    agileTeam = services.getAgileService().getAgileTeamFromSprint(sprint);
+                }
+            }
+        }
+        if (agileTeam == null) {
+            ArtifactId backlogArt = services.getRelationResolver().getRelatedOrNull(workItem, AtsRelationTypes.Goal_Goal);
+            if (backlogArt != null) {
+                IAgileBacklog backlog = getAgileBacklog(backlogArt);
+                if (backlog != null) {
+                    agileTeam = services.getAgileService().getAgileTeamFromBacklog(backlog);
+                }
+            }
         }


Input:
public void dump() {
    for (Iterator vIt = pag.getVarNodeNumberer().iterator(); vIt.hasNext(); ) {
        final VarNode v = (VarNode) vIt.next();
        mergedNodes.put(v.getReplacement(), v);
        if (v instanceof LocalVarNode) {
            methodToNodes.put(((LocalVarNode) v).getMethod(), v);
        }
    }
    try {
        JarOutputStream jarOut = new JarOutputStream(new FileOutputStream(new File(output_dir, "String_Node_Str")));
        for (Iterator vIt = mergedNodes.keySet().iterator(); vIt.hasNext(); ) {
            final VarNode v = (VarNode) vIt.next();
            dumpVarNode(v, jarOut);
        }
        for (Iterator mIt = methodToNodes.keySet().iterator(); mIt.hasNext(); ) {
            final SootMethod m = (SootMethod) mIt.next();
            dumpMethod(m, jarOut);
        }
        addSymLinks(pag.getVarNodeNumberer().iterator(), jarOut);
        jarOut.close();
    } catch (IOException e) {
        throw new RuntimeException("String_Node_Str" + e);
    }
}

Output:
         if (v instanceof LocalVarNode) {
-            methodToNodes.put(((LocalVarNode) v).getMethod(), v);
+            SootMethod m = ((LocalVarNode) v).getMethod();
+            if (m != null) {
+                methodToNodes.put(m, v);
+            }
         }


Input:
public boolean needFilter(HttpServletRequest req, HttpServletResponse res) {
    String uri = req.getRequestURI();
    if (FilterHelper.isUpdateUri(uri)) {
        return false;
    }
    return true;
}

Output:
 public boolean needFilter(HttpServletRequest req, HttpServletResponse res) {
-    String uri = req.getRequestURI();
-    if (FilterHelper.isUpdateUri(uri)) {
+    if (FilterHelper.isUpdateUri(req)) {
         return false;


Input:
public void run() {
    while (!canceled) {
        if (!positionsQueue.isEmpty()) {
            ISPosition2D position = positionsQueue.poll();
            byte player = grid.getPlayer(position.getX(), position.getY());
            boolean isBorder = false;
            for (EDirection currDir : EDirection.values()) {
                short currNeighborX = currDir.getNextTileX(position.getX());
                short currNeighborY = currDir.getNextTileY(position.getY());
                byte neighborPlayer = grid.getPlayer(currNeighborX, currNeighborY);
                boolean neighborIsBorder = false;
                if (neighborPlayer >= 0) {
                    if (neighborPlayer != player) {
                        isBorder = true;
                    }
                    for (EDirection currNeighborDir : EDirection.values()) {
                        if (grid.getPlayer(currNeighborDir.getNextTileX(currNeighborX), currNeighborDir.getNextTileY(currNeighborY)) != neighborPlayer) {
                            neighborIsBorder = true;
                            break;
                        }
                    }
                }
                grid.setBorder(currNeighborX, currNeighborY, neighborIsBorder);
            }
            grid.setBorder(position.getX(), position.getY(), isBorder && player >= 0);
        } else {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Output:
                     for (EDirection currNeighborDir : EDirection.values()) {
-                        if (grid.getPlayer(currNeighborDir.getNextTileX(currNeighborX), currNeighborDir.getNextTileY(currNeighborY)) != neighborPlayer) {
+                        short nextX = currNeighborDir.getNextTileX(currNeighborX);
+                        short nextY = currNeighborDir.getNextTileY(currNeighborY);
+                        if (grid.isInBounds(nextX, nextY) && grid.getPlayer(nextX, nextY) != neighborPlayer) {
                             neighborIsBorder = true;


Input:
private void executeBody(Query query) {
    cellValues = new HashMap();
    this.evaluator.cellReader = this.batchingReader;
    executeStripe(query.axes.length - 1);
    if (batchingReader.keys.isEmpty()) {
        return;
    }
    batchingReader.loadAggregations();
    batchingReader.clear();
    this.evaluator.cellReader = this.aggregatingReader;
    executeStripe(query.axes.length - 1);
}

Output:
 private void executeBody(Query query) {
-    cellValues = new HashMap();
-    this.evaluator.cellReader = this.batchingReader;
-    executeStripe(query.axes.length - 1);
-    if (batchingReader.keys.isEmpty()) {
-        return;
+    int count = 0;
+    while (true) {
+        cellValues = new HashMap();
+        this.evaluator.cellReader = this.batchingReader;
+        executeStripe(query.axes.length - 1);
+        if (batchingReader.keys.isEmpty()) {
+            return;
+        }
+        if (count++ > 3) {
+            throw Util.newInternal("String_Node_Str" + count + "String_Node_Str");
+        }
+        batchingReader.loadAggregations();
+        batchingReader.clear();
     }


Input:
public void commitClusterState(ClusterState newState, Address initiator, String txnId) {
    Preconditions.checkNotNull(newState);
    if (newState == ClusterState.IN_TRANSITION) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    clusterServiceLock.lock();
    try {
        final ClusterStateLock stateLock = getStateLock();
        if (!stateLock.allowsUnlock(txnId)) {
            throw new TransactionException("String_Node_Str" + state + "String_Node_Str" + newState + "String_Node_Str" + initiator + "String_Node_Str" + stateToString());
        }
        this.state = newState;
        stateLockRef.set(ClusterStateLock.NOT_LOCKED);
        changeNodeState(newState);
        node.getNodeExtension().onClusterStateChange(newState);
        if (newState == ClusterState.ACTIVE) {
            node.getClusterService().removeMembersDeadWhileClusterIsNotActive();
        }
    } finally {
        clusterServiceLock.unlock();
    }
}

Output:
         changeNodeState(newState);
-        node.getNodeExtension().onClusterStateChange(newState);
+        node.getNodeExtension().onClusterStateChange(newState, true);
         if (newState == ClusterState.ACTIVE) {


Input:
public Map<String, String> getHyperParametersOfModelAsMap(long modelId) throws DatabaseHandlerException {
    Map<String, String> hyperParams = new HashMap<String, String>();
    Connection connection = null;
    PreparedStatement getFeatues = null;
    ResultSet result = null;
    try {
        connection = dbh.getDataSource().getConnection();
        connection.setAutoCommit(true);
        getFeatues = connection.prepareStatement(SQLQueries.GET_HYPER_PARAMETERS_OF_MODEL);
        getFeatues.setLong(1, modelId);
        result = getFeatues.executeQuery();
        while (result.next()) {
            hyperParams.put(result.getString(1), result.getString(2));
        }
        return hyperParams;
    } catch (SQLException e) {
        throw new DatabaseHandlerException("String_Node_Str" + "String_Node_Str" + modelId + "String_Node_Str" + e.getMessage(), e);
    } finally {
        MLDatabaseUtils.closeDatabaseResources(connection, getFeatues, result);
    }
}

Output:
         connection.setAutoCommit(true);
-        getFeatues = connection.prepareStatement(SQLQueries.GET_HYPER_PARAMETERS_OF_MODEL);
-        getFeatues.setLong(1, modelId);
+        getFeatues = connection.prepareStatement(SQLQueries.GET_HYPER_PARAMETERS_OF_ANALYSIS);
+        getFeatues.setLong(1, analysisId);
         result = getFeatues.executeQuery();


Input:
private boolean checkAdminPerms(Player player2, String[] split) {
    if (player2.isOp()) {
        return true;
    }
    String check = split[0];
    if (check.equalsIgnoreCase("String_Node_Str"))
        check = "String_Node_Str";
    if (VaultHelper.checkPerm(player2, Settings.PERMPREFIX + "String_Node_Str" + split[0].toLowerCase())) {
        return true;
    }
    return false;
}

Output:
         check = "String_Node_Str";
-    if (VaultHelper.checkPerm(player2, Settings.PERMPREFIX + "String_Node_Str" + split[0].toLowerCase())) {
+    if (VaultHelper.checkPerm(player2, Settings.PERMPREFIX + "String_Node_Str" + check.toLowerCase())) {
         return true;


Input:
public static void load() {
    File databaseFile = ChestShop.loadFile("String_Node_Str");
    String uri = ConnectionManager.getURI(databaseFile);
    ConnectionSource connection;
    try {
        connection = new JdbcConnectionSource(uri);
        accounts = DaoManager.createDao(connection, Account.class);
        TableUtils.createTableIfNotExists(connection, Account.class);
        Account adminAccount = new Account(Properties.ADMIN_SHOP_NAME, Bukkit.getOfflinePlayer(Properties.ADMIN_SHOP_NAME).getUniqueId());
        accounts.createIfNotExists(adminAccount);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

Output:
         Account adminAccount = new Account(Properties.ADMIN_SHOP_NAME, Bukkit.getOfflinePlayer(Properties.ADMIN_SHOP_NAME).getUniqueId());
-        accounts.createIfNotExists(adminAccount);
+        accounts.createOrUpdate(adminAccount);
     } catch (SQLException e) {


Input:
public void refresh() {
    logger.info("String_Node_Str" + models.toModels().stream().map(Model::getRepoId).collect(Collectors.toList()));
    Utility.sequence(models.toModels().stream().map(repoIO::updateModel).collect(Collectors.toList())).thenAccept(models::replace).thenRun(this::updateUI);
}

Output:
     logger.info("String_Node_Str" + models.toModels().stream().map(Model::getRepoId).collect(Collectors.toList()));
-    Utility.sequence(models.toModels().stream().map(repoIO::updateModel).collect(Collectors.toList())).thenAccept(models::replace).thenRun(this::updateUI);
+    Utility.sequence(models.toModels().stream().map(repoIO::updateModel).collect(Collectors.toList())).thenApply(models::replace).thenAccept(this::updateUI).exceptionally(HTLog::log);
 }


Input:
protected void dfs(Path path, Set<Vertex> targets, Graph subgraph, Set<Vertex> stopVertices) {
    Deque<Path> stack = new ArrayDeque<>();
    stack.push(path);
    while (!stack.isEmpty()) {
        traversedNodes++;
        path = stack.pop();
        Vertex current = path.getLast();
        if (path.getEdges().size() > settings.maxDistance)
            continue;
        if (targets.contains(current))
            SubgraphConstructions.addPathToSubGraph(current, path, subgraph, settings.graphType);
        for (Edge edge : Graphs.connectedEdges(current, settings.graphType)) {
            Vertex child = Graphs.oppositeVertexUnsafe(edge, current);
            if (settings.graphType.equals(GraphType.UNDIRECTED_GRAPH) && !settings.explorationThreshold.isBelowThreshold(child, edge))
                continue;
            if (!path.getVertices().contains(child) && !stopVertices.contains(child)) {
                Path newPath = Path.newHop(path, edge, child);
                stack.push(newPath);
            }
        }
    }
}

Output:
             SubgraphConstructions.addPathToSubGraph(current, path, subgraph, settings.graphType);
-        for (Edge edge : Graphs.connectedEdges(current, settings.graphType)) {
+        for (Edge edge : current.getEdges(settings.graphType.getDirection())) {
             Vertex child = Graphs.oppositeVertexUnsafe(edge, current);


Input:
private File getCacheFile(int cacheIndex) {
    String tempDirStr = DataEngineContextExt.getInstance().getTmpdir() + File.separatorChar + this.fileNamePrefix;
    if (dir == null) {
        dir = new File(tempDirStr);
        dir.mkdir();
    }
    return new File(tempDirStr + File.separatorChar + cacheIndex + "String_Node_Str");
}

Output:
 private File getCacheFile(int cacheIndex) {
-    String tempDirStr = DataEngineContextExt.getInstance().getTmpdir() + File.separatorChar + this.fileNamePrefix;
+    String tempDirStr = tempDir + this.fileNamePrefix;
     if (dir == null) {


Input:
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType("String_Node_Str");
    PrintWriter out = response.getWriter();
    try {
        Connection connection = sarariman.openConnection();
        try {
            out.println("String_Node_Str");
            Map<Date, BigDecimal> billable = billable(connection);
            Map<Date, BigDecimal> overhead = overhead(connection);
            Map<Date, BigDecimal> pto = pto(connection);
            Set<Date> allDates = Utilities.<Date, BigDecimal>allKeys(ImmutableList.of(billable, overhead));
            for (Date date : allDates) {
                out.print(date);
                BigDecimal b = billable.get(date);
                if (b == null) {
                    b = BigDecimal.ZERO;
                }
                BigDecimal o = overhead.get(date);
                if (o == null) {
                    o = BigDecimal.ZERO;
                }
                BigDecimal p = pto.get(date);
                if (p == null) {
                    p = BigDecimal.ZERO;
                }
                out.println(String.format("String_Node_Str", date, b, o, p));
            }
            out.println("String_Node_Str");
        } finally {
            connection.close();
        }
    } catch (SQLException e) {
        throw new ServletException(e);
    } finally {
        out.close();
    }
}

Output:
             Map<Date, BigDecimal> pto = pto(connection);
-            Set<Date> allDates = Utilities.<Date, BigDecimal>allKeys(ImmutableList.of(billable, overhead));
+            Set<Date> allDates = new TreeSet<Date>(Utilities.<Date, BigDecimal>allKeys(ImmutableList.of(billable, overhead)));
             for (Date date : allDates) {


Input:
private void checkPrincipalPermission() throws AccessControlException {
    try {
        PlatypusPrincipal principal = _getPrincipal();
        if (functionAllowedRoles != null && functionAllowedRoles.get(name) != null && !functionAllowedRoles.get(name).isEmpty()) {
            if (principal != null && principal.hasAnyRole(functionAllowedRoles.get(name))) {
                return;
            }
            throw new AccessControlException(String.format("String_Node_Str", name, ScriptRunner.this.appElementId, principal != null ? principal.getName() : null));
        } else {
            ScriptRunner.this.checkPrincipalPermission();
        }
    } catch (Exception ex) {
        if (ex instanceof AccessControlException) {
            throw (AccessControlException) ex;
        } else {
            throw new AccessControlException(ex.getMessage());
        }
    }
}

Output:
         if (functionAllowedRoles != null && functionAllowedRoles.get(name) != null && !functionAllowedRoles.get(name).isEmpty()) {
-            if (principal != null && principal.hasAnyRole(functionAllowedRoles.get(name))) {
+            Set<String> filteredRoles = filterRoles(functionAllowedRoles.get(name), args);
+            if (principal != null && principal.hasAnyRole(filteredRoles)) {
                 return;


Input:
public Handler start() throws HttpApplicationException {
    return CrestHttp.newHttpHandler(connectionFactory, new IDMSecurityContextFactory(augmentSecurityScripts));
}

Output:
 public Handler start() throws HttpApplicationException {
-    return CrestHttp.newHttpHandler(connectionFactory, new IDMSecurityContextFactory(augmentSecurityScripts));
+    return handler;
 }


Input:
public String getID() {
    if (queryResultID == null)
        queryResultID = QueryResultIDUtil.nextID();
    return queryResultID;
}

Output:
     if (queryResultID == null)
-        queryResultID = QueryResultIDUtil.nextID();
+        queryResultID = session.getQueryResultIDUtil().nextID();
     return queryResultID;


Input:
private String generateJsCode(int depth, Writer writer) throws IOException {
    Log.getLogger().debug(getIndent(depth) + this);
    if (getData() != null) {
        writer.write(getData());
    } else {
        throw new RuntimeException("String_Node_Str" + getName());
    }
    Set<MemberUnit> notImplementedMethods = getNotImplementedMethods();
    if (interfaces.size() > 0) {
        String extendOperator = "String_Node_Str";
        if (isInterface)
            extendOperator = "String_Node_Str";
        writer.write(extendOperator + "String_Node_Str");
        int i = 0;
        for (ClassUnit interFace : interfaces) {
            if (i++ > 0)
                writer.write("String_Node_Str");
            writer.write(DragomeJavaScriptGenerator.normalizeExpression(interFace.getSignature().toString()));
        }
        writer.write("String_Node_Str");
    }
    writer.write("String_Node_Str");
    writer.write("String_Node_Str");
    MemberUnit clinitMethod = null;
    List<MemberUnit> staticMethods = new ArrayList<MemberUnit>();
    boolean first = true;
    for (MemberUnit member : getDeclaredMembers()) {
        if (member.getData() != null && member.getData().startsWith(STATIC_MEMBER)) {
            staticMethods.add(member);
        } else if (member.getData() != null && member.getData().contains("String_Node_Str")) {
            stringInits.add(member);
        } else {
            if (member.getData() != null && member.getData().trim().length() > 0) {
                if (!first)
                    writer.write("String_Node_Str");
                first = false;
                writeMethodAlternative(depth, writer, member);
                if (member instanceof ProcedureUnit) {
                    project.currentGeneratedMethods++;
                    writer.flush();
                }
            }
        }
        if (isClinit(member))
            clinitMethod = member;
    }
    for (MemberUnit member : notImplementedMethods) {
        if (!first)
            writer.write("String_Node_Str");
        first = false;
        String methodData = member.getData().replace(STATIC_MEMBER, "String_Node_Str");
        methodData = methodData.substring(0, methodData.indexOf("String_Node_Str"));
        writer.write(methodData);
        writer.write("String_Node_Str");
        writer.write(member.getDeclaringClass().toString().replace("String_Node_Str", "String_Node_Str"));
        writer.write("String_Node_Str");
        writer.write(methodData.replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str"));
        writer.write("String_Node_Str");
        if (member instanceof ProcedureUnit) {
            project.currentGeneratedMethods++;
            writer.flush();
        }
    }
    writer.write("String_Node_Str");
    writer.write("String_Node_Str");
    writer.write("String_Node_Str");
    if (clinitMethod != null) {
        String name = DragomeJavaScriptGenerator.normalizeExpression(clinitMethod.getDeclaringClass().getName());
        String replace = clinitMethod.getData().replace("String_Node_Str", name + "String_Node_Str");
        replace = replace.replace("String_Node_Str", "String_Node_Str");
        replace = replace.substring(0, replace.length() - 2) + "String_Node_Str";
        String memberData = clinitMethod.getData();
        clinitMethod.setData(replace.replace(STATIC_MEMBER, "String_Node_Str"));
        clinitMethod.write(depth, writer);
        clinitMethod.setData(memberData);
        String modifyMethodName = DragomeJavaScriptGenerator.normalizeExpression(clinitMethod.getSignature());
        project.getClinits().add("String_Node_Str" + name + "String_Node_Str");
    } else {
        String replace = "String_Node_Str";
        writer.write(replace);
    }
    boolean hasStaticMembers = staticMethods.size() > 0;
    if (hasStaticMembers)
        writer.write("String_Node_Str");
    writer.write("String_Node_Str");
    first = true;
    for (MemberUnit member : staticMethods) {
        if (member != clinitMethod) {
            if (!first)
                writer.write("String_Node_Str");
            first = false;
            String memberData = member.getData();
            member.setData(member.getData().replace(STATIC_MEMBER, "String_Node_Str"));
            writeMethodAlternative(depth, writer, member);
            member.setData(memberData);
            if (member instanceof ProcedureUnit || member instanceof FieldUnit) {
                if (member instanceof ProcedureUnit)
                    project.currentGeneratedMethods++;
                writer.flush();
            }
        }
    }
    first = addSuperStaticMethods(writer, !hasStaticMembers ^ first);
    writer.write("String_Node_Str");
    writer.write("String_Node_Str");
    writer.write("String_Node_Str");
    return writer.toString();
}

Output:
     writer.write("String_Node_Str");
-    if (clinitMethod != null) {
-        String name = DragomeJavaScriptGenerator.normalizeExpression(clinitMethod.getDeclaringClass().getName());
-        String replace = clinitMethod.getData().replace("String_Node_Str", name + "String_Node_Str");
-        replace = replace.replace("String_Node_Str", "String_Node_Str");
-        replace = replace.substring(0, replace.length() - 2) + "String_Node_Str";
-        String memberData = clinitMethod.getData();
-        clinitMethod.setData(replace.replace(STATIC_MEMBER, "String_Node_Str"));
-        clinitMethod.write(depth, writer);
-        clinitMethod.setData(memberData);
-        String modifyMethodName = DragomeJavaScriptGenerator.normalizeExpression(clinitMethod.getSignature());
-        project.getClinits().add("String_Node_Str" + name + "String_Node_Str");
-    } else {
-        String replace = "String_Node_Str";
-        writer.write(replace);
-    }
+    writeClinit(depth, writer, clinitMethod, staticMethods);
     boolean hasStaticMembers = staticMethods.size() > 0;


Input:
public WsnSession call() throws Exception {
    final ResourceAddress localAddress = resourceAddressFactory.newResourceAddress(wsnConnectAddress, BridgeSession.LOCAL_ADDRESS.get(httpSession));
    IoBufferAllocatorEx<?> parentAllocator = parent.getBufferAllocator();
    WsBufferAllocator wsAllocator = new WsBufferAllocator(parentAllocator);
    return new WsnSession(WsnConnector.this, getProcessor(), localAddress, wsnConnectAddress, parent, wsAllocator, httpSession.getRequestURI(), null, WebSocketWireProtocol.RFC_6455);
}

Output:
     WsBufferAllocator wsAllocator = new WsBufferAllocator(parentAllocator);
-    return new WsnSession(WsnConnector.this, getProcessor(), localAddress, wsnConnectAddress, parent, wsAllocator, httpSession.getRequestURI(), null, WebSocketWireProtocol.RFC_6455);
+    return new WsnSession(WsnConnector.this, getProcessor(), localAddress, wsnConnectAddress, parent, wsAllocator, httpSession.getRequestURI(), null, WebSocketWireProtocol.RFC_6455, null);
 }


Input:
synchronized void unparcel() {
    if (mParcelledData == null) {
        return;
    }
    mParcelledData.setDataPosition(0);
    Bundle b = mParcelledData.readBundleUnpacked(mClassLoader);
    mMap = b.mMap;
    mHasFds = mParcelledData.hasFileDescriptors();
    mFdsKnown = true;
    mParcelledData.recycle();
    mParcelledData = null;
}

Output:
     }
-    mParcelledData.setDataPosition(0);
-    Bundle b = mParcelledData.readBundleUnpacked(mClassLoader);
-    mMap = b.mMap;
-    mHasFds = mParcelledData.hasFileDescriptors();
-    mFdsKnown = true;
+    int N = mParcelledData.readInt();
+    if (N < 0) {
+        return;
+    }
+    if (mMap == null) {
+        mMap = new HashMap<String, Object>();
+    }
+    mParcelledData.readMapInternal(mMap, N, mClassLoader);
     mParcelledData.recycle();


Input:
private void displayProposalsForAllMethods(final IJavaElementSelection selection, final IField field) {
    try {
        final ITypeName fieldType = context.getVariable().type;
        for (final IMethod method : field.getDeclaringType().getMethods()) {
            if (false) {
                context = new MockedIntelligentCompletionContext(selection) {

                    public Variable getVariable() {
                        return Variable.create(field.getElementName(), fieldType, ElementResolver.toRecMethod(method));
                    }
                };
                displayProposalsForMethod(method);
            }
        }
    } catch (final JavaModelException e) {
        throw new IllegalStateException(e);
    }
}

Output:
         for (final IMethod method : field.getDeclaringType().getMethods()) {
-            if (false) {
-                context = new MockedIntelligentCompletionContext(selection) {
+            context = new MockedIntelligentCompletionContext(selection) {


Input:
public void loadDefaultConfiguration(final ConfigurationSection config) {
    if (config.contains("String_Node_Str")) {
        this.TERRAIN = config.getInt("String_Node_Str");
        this.TYPE = config.getInt("String_Node_Str");
    }
    this.MOB_SPAWNING = config.getBoolean("String_Node_Str");
    this.AUTO_MERGE = config.getBoolean("String_Node_Str");
    this.ALLOW_SIGNS = config.getBoolean("String_Node_Str");
    this.PLOT_BIOME = (String) Configuration.BIOME.parseString(config.getString("String_Node_Str"));
    this.SCHEMATIC_ON_CLAIM = config.getBoolean("String_Node_Str");
    this.SCHEMATIC_FILE = config.getString("String_Node_Str");
    this.SCHEMATIC_CLAIM_SPECIFY = config.getBoolean("String_Node_Str");
    this.SCHEMATICS = config.getStringList("String_Node_Str");
    this.USE_ECONOMY = config.getBoolean("String_Node_Str") && (PlotSquared.economy != null);
    this.PLOT_PRICE = config.getDouble("String_Node_Str");
    this.MERGE_PRICE = config.getDouble("String_Node_Str");
    this.SELL_PRICE = config.getDouble("String_Node_Str");
    this.PLOT_CHAT = config.getBoolean("String_Node_Str");
    this.WORLD_BORDER = config.getBoolean("String_Node_Str");
    this.HOME_ALLOW_NONMEMBER = config.getBoolean("String_Node_Str");
    String homeDefault = config.getString("String_Node_Str");
    if (homeDefault.equalsIgnoreCase("String_Node_Str")) {
        DEFAULT_HOME = null;
    } else if (homeDefault.equalsIgnoreCase("String_Node_Str")) {
        DEFAULT_HOME = new PlotLoc(Integer.MAX_VALUE, Integer.MAX_VALUE);
    } else {
        try {
            String[] split = homeDefault.split("String_Node_Str");
            DEFAULT_HOME = new PlotLoc(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
        } catch (Exception e) {
            DEFAULT_HOME = null;
        }
    }
    List<String> flags = config.getStringList("String_Node_Str");
    if (flags == null || flags.size() == 0) {
        flags = config.getStringList("String_Node_Str");
        if (flags == null || flags.size() == 0) {
            flags = new ArrayList<String>();
            ConfigurationSection section = config.getConfigurationSection("String_Node_Str");
            Set<String> keys = section.getKeys(false);
            for (String key : keys) {
                if (!key.equals("String_Node_Str")) {
                    flags.add(key + "String_Node_Str" + section.get(key));
                }
            }
        }
    }
    try {
        this.DEFAULT_FLAGS = FlagManager.parseFlags(flags);
    } catch (final Exception e) {
        e.printStackTrace();
        PlotSquared.log("String_Node_Str" + this.worldname + "String_Node_Str" + StringUtils.join(flags, "String_Node_Str"));
        this.DEFAULT_FLAGS = new Flag[] {};
    }
    this.PVP = config.getBoolean("String_Node_Str");
    this.PVE = config.getBoolean("String_Node_Str");
    this.SPAWN_EGGS = config.getBoolean("String_Node_Str");
    this.SPAWN_CUSTOM = config.getBoolean("String_Node_Str");
    this.SPAWN_BREEDING = config.getBoolean("String_Node_Str");
    loadConfiguration(config);
}

Output:
     this.SCHEMATICS = config.getStringList("String_Node_Str");
-    this.USE_ECONOMY = config.getBoolean("String_Node_Str") && (PlotSquared.economy != null);
+    this.USE_ECONOMY = config.getBoolean("String_Node_Str") && (EconHandler.manager != null);
     this.PLOT_PRICE = config.getDouble("String_Node_Str");


Input:
public void processPacket(Packet packet) {
    if (!(packet instanceof org.jivesoftware.smack.packet.Message))
        return;
    org.jivesoftware.smack.packet.Message msg = (org.jivesoftware.smack.packet.Message) packet;
    long timeStamp;
    DelayInformation delay = (DelayInformation) msg.getExtension("String_Node_Str", "String_Node_Str");
    if (delay != null) {
        timeStamp = delay.getStamp().getTime();
    } else {
        timeStamp = System.currentTimeMillis();
    }
    String msgBody = msg.getBody();
    if (msgBody == null)
        return;
    int messageReceivedEventType = ChatRoomMessageReceivedEvent.CONVERSATION_MESSAGE_RECEIVED;
    String msgFrom = msg.getFrom();
    ChatRoomMember member = null;
    String fromUserName = StringUtils.parseResource(msgFrom);
    if (nickname.equals(getNickName(fromUserName)))
        return;
    if (msgFrom.equals(getName())) {
        messageReceivedEventType = ChatRoomMessageReceivedEvent.SYSTEM_MESSAGE_RECEIVED;
        member = new ChatRoomMemberJabberImpl(ChatRoomJabberImpl.this, getName(), getName());
    } else {
        member = smackParticipantToScMember(msgFrom);
    }
    if (member == null) {
        member = new ChatRoomMemberJabberImpl(ChatRoomJabberImpl.this, fromUserName, msgFrom);
    }
    if (logger.isDebugEnabled()) {
        if (logger.isDebugEnabled())
            logger.debug("String_Node_Str" + fromUserName + "String_Node_Str" + msg.toXML());
    }
    Message newMessage = createMessage(msgBody);
    if (msg.getType() == org.jivesoftware.smack.packet.Message.Type.error) {
        if (logger.isInfoEnabled())
            logger.info("String_Node_Str" + fromUserName);
        XMPPError error = packet.getError();
        int errorCode = error.getCode();
        int errorResultCode = ChatRoomMessageDeliveryFailedEvent.UNKNOWN_ERROR;
        String errorReason = error.getMessage();
        if (errorCode == 503) {
            org.jivesoftware.smackx.packet.MessageEvent msgEvent = (org.jivesoftware.smackx.packet.MessageEvent) packet.getExtension("String_Node_Str", "String_Node_Str");
            if (msgEvent != null && msgEvent.isOffline()) {
                errorResultCode = ChatRoomMessageDeliveryFailedEvent.OFFLINE_MESSAGES_NOT_SUPPORTED;
            }
        }
        ChatRoomMessageDeliveryFailedEvent evt = new ChatRoomMessageDeliveryFailedEvent(ChatRoomJabberImpl.this, member, errorResultCode, errorReason, new Date(), newMessage);
        fireMessageEvent(evt);
        return;
    }
    ChatRoomMessageReceivedEvent msgReceivedEvt = new ChatRoomMessageReceivedEvent(ChatRoomJabberImpl.this, member, timeStamp, newMessage, messageReceivedEventType);
    if (delay != null)
        msgReceivedEvt.setHistoryMessage(true);
    fireMessageEvent(msgReceivedEvt);
}

Output:
     String fromUserName = StringUtils.parseResource(msgFrom);
-    if (nickname.equals(getNickName(fromUserName)))
+    if (getUserNickname().equals(fromUserName))
         return;


Input:
public boolean accept(WindupRuleProvider provider) {
    return (provider.getPhase() != ReportGeneration.class) && (provider.getPhase() != MigrationRules.class);
}

Output:
 public boolean accept(WindupRuleProvider provider) {
-    return (provider.getPhase() != ReportGeneration.class) && (provider.getPhase() != MigrationRules.class);
+    return (provider.getPhase() != ReportGenerationPhase.class) && (provider.getPhase() != MigrationRulesPhase.class);
 }


Input:
public void close() {
    long size = getAppendOffset();
    super.close();
    if (fd != -1) {
        try {
            if (ff.truncate(fd, size)) {
                LOG.info().$("String_Node_Str").$(fd).$(']').$();
            } else {
                if (!ff.supportsTruncateMappedFiles()) {
                    long n = size / getMapPageSize();
                    if (ff.truncate(fd, (n + 1) * getMapPageSize())) {
                        LOG.info().$("String_Node_Str").$(fd).$(']').$();
                        return;
                    }
                }
                LOG.info().$("String_Node_Str").$(fd).$("String_Node_Str").$(ff.errno()).$(']').$();
            }
        } finally {
            ff.close(fd);
            fd = -1;
        }
    }
}

Output:
             } else {
-                if (!ff.supportsTruncateMappedFiles()) {
+                if (ff.isRestrictedFileSystem()) {
                     long n = size / getMapPageSize();


Input:
public void writeData(OutputStream bos, IResultObject resultObject) throws IOException {
    byte[] rowsDataBytes;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    DataOutputStream dos = new DataOutputStream(baos);
    for (int j = 0; j < columnCount; j++) {
        Object fieldValue = null;
        try {
            fieldValue = resultObject.getFieldValue(j + 1);
        } catch (DataException e) {
        }
        if (fieldValue == null) {
            dos.writeByte(0);
            continue;
        } else {
            dos.writeByte(1);
        }
        Class fieldType = typeArray[j];
        if (fieldType.equals(Integer.class))
            dos.writeInt(((Integer) fieldValue).intValue());
        else if (fieldType.equals(Double.class))
            dos.writeDouble(((Double) fieldValue).doubleValue());
        else if (fieldType.equals(BigDecimal.class))
            dos.writeUTF(((BigDecimal) fieldValue).toString());
        else if (Date.class.isAssignableFrom(fieldType))
            dos.writeLong(((Date) fieldValue).getTime());
        else if (fieldType.equals(Boolean.class))
            dos.writeBoolean(((Boolean) fieldValue).booleanValue());
        else if (fieldType.equals(String.class))
            dos.writeUTF(fieldValue.toString());
        else if (fieldType.equals(IClob.class))
            dos.writeUTF(fieldValue.toString());
        else if (fieldType.equals(IBlob.class)) {
            byte[] bytes = (byte[]) fieldValue;
            if (bytes == null || bytes.length == 0) {
                IOUtil.writeInt(dos, 0);
            } else {
                IOUtil.writeInt(dos, bytes.length);
                dos.write((byte[]) fieldValue);
            }
        } else if (fieldType.equals(DataType.getClass(DataType.ANY_TYPE))) {
            if (!(fieldValue instanceof Serializable))
                fieldValue = fieldValue.toString();
            ObjectOutputStream oo = new ObjectOutputStream(dos);
            oo.writeObject(fieldValue);
            oo.close();
        }
    }
    dos.flush();
    rowsDataBytes = baos.toByteArray();
    IOUtil.writeInt(bos, rowsDataBytes.length);
    bos.write(rowsDataBytes);
    rowsDataBytes = null;
    dos = null;
    baos = null;
}

Output:
         else if (fieldType.equals(String.class))
-            dos.writeUTF(fieldValue.toString());
+            IOUtil.writeString(dos, fieldValue.toString());
         else if (fieldType.equals(IClob.class))


Input:
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    switch(requestCode) {
        case BARCODE_FETCH:
            if (resultCode == Activity.RESULT_OK) {
                String result = intent.getStringExtra("String_Node_Str");
                this.searchbox.setText(result);
            }
            break;
        case CALLOUT:
            if (resultCode == Activity.RESULT_OK) {
                String result = intent.getStringExtra("String_Node_Str");
                if (result != null) {
                    this.searchbox.setText(result);
                    break;
                }
                Callout callout = shortSelect.getCallout();
                for (String key : callout.getResponses()) {
                    result = intent.getStringExtra(key);
                    if (result != null) {
                        this.searchbox.setText(result);
                        break;
                    }
                }
            }
        case CONFIRM_SELECT:
            resuming = true;
            if (resultCode == RESULT_OK && !mViewMode) {
                returnWithResult(intent);
                return;
            } else {
                if (mResultIsMap) {
                    mResultIsMap = false;
                    Intent i = new Intent(this, EntityMapActivity.class);
                    this.startActivityForResult(i, MAP_SELECT);
                    return;
                }
                if (inAwesomeMode) {
                    TreeReference r = SerializationUtil.deserializeFromIntent(intent, EntityDetailActivity.CONTEXT_REFERENCE, TreeReference.class);
                    if (r != null && adapter != null) {
                        this.displayReferenceAwesome(r, adapter.getPosition(r));
                        updateSelectedItem(r, true);
                    }
                    releaseCurrentMediaEntity();
                }
                return;
            }
        case MAP_SELECT:
            if (resultCode == RESULT_OK) {
                TreeReference r = SerializationUtil.deserializeFromIntent(intent, EntityDetailActivity.CONTEXT_REFERENCE, TreeReference.class);
                if (inAwesomeMode) {
                    this.displayReferenceAwesome(r, adapter.getPosition(r));
                } else {
                    Intent i = this.getDetailIntent(r, null);
                    if (mNoDetailMode) {
                        returnWithResult(i);
                    } else {
                        mResultIsMap = true;
                        i.putExtra("String_Node_Str", adapter.getPosition(r));
                        startActivityForResult(i, CONFIRM_SELECT);
                    }
                    return;
                }
            } else {
                refreshView();
                return;
            }
        default:
            super.onActivityResult(requestCode, resultCode, intent);
    }
}

Output:
                 for (String key : callout.getResponses()) {
-                    result = intent.getStringExtra(key);
+                    result = intent.getExtras().getString(key);
                     if (result != null) {


Input:
private void onCallStatusUpdate(String newStatus) {
    mRemoteLogger.d(TAG + "String_Node_Str" + newStatus);
    switch(newStatus) {
        case CALL_MEDIA_AVAILABLE_MESSAGE:
            onCallStatusUpdate(CALL_STOP_RINGBACK_MESSAGE);
            break;
        case CALL_CONNECTED_MESSAGE:
            toggleCallStateButtonVisibility(TYPE_CONNECTED_CALL);
            mStateView.setText(R.string.call_connected);
            mCallStartTime = System.currentTimeMillis();
            mCallHandler.postDelayed(mCallDurationRunnable, 0);
            mConnected = true;
            mHasConnected = true;
            mIncomingCallIsRinging = false;
            mProximityHelper.updateWakeLock();
            break;
        case CALL_DISCONNECTED_MESSAGE:
            onCallStatusUpdate(CALL_STOP_RINGBACK_MESSAGE);
            if (!mHasConnected) {
                mStateView.setText(R.string.call_unreachable);
            } else {
                mStateView.setText(R.string.call_ended);
            }
            mAudioManager.setSpeakerphoneOn(false);
            mCallHandler.removeCallbacks(mCallDurationRunnable);
            mConnected = false;
            mIncomingCallIsRinging = false;
            playRingtone(false);
            vibrate(false);
            finishWithDelay();
            break;
        case CALL_PUT_ON_HOLD_ACTION:
            mCallHandler.removeCallbacks(mCallDurationRunnable);
            mCallDurationView.setVisibility(View.INVISIBLE);
            mStateView.setText(R.string.call_on_hold);
            break;
        case CALL_UNHOLD_ACTION:
            mCallHandler.postDelayed(mCallDurationRunnable, 0);
            mCallDurationView.setVisibility(View.VISIBLE);
            mStateView.setText(R.string.call_connected);
            break;
        case CALL_RINGING_OUT_MESSAGE:
            mStateView.setText(R.string.call_outgoing);
            findViewById(R.id.button_speaker).setEnabled(false);
            findViewById(R.id.button_microphone).setEnabled(false);
            break;
        case CALL_RINGING_IN_MESSAGE:
            mStateView.setText(R.string.call_incoming);
            break;
        case SERVICE_STOPPED:
            mConnected = false;
            mIncomingCallIsRinging = false;
            finishWithDelay();
            break;
    }
}

Output:
             onCallStatusUpdate(CALL_STOP_RINGBACK_MESSAGE);
-            if (!mHasConnected) {
+            if (!mHasConnected && !mSelfHangup) {
                 mStateView.setText(R.string.call_unreachable);


Input:
private MetadataSearchResponse search(Set<MetadataScope> scopes, String namespaceId, String searchQuery, Set<EntityTypeSimpleName> types, SortInfo sortInfo, int offset, int limit, int numCursors, String cursor, boolean showHidden, Set<EntityScope> entityScope) throws BadRequestException {
    if (offset < 0) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (limit < 0) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    List<MetadataEntry> results = new LinkedList<>();
    List<String> cursors = new LinkedList<>();
    List<MetadataEntry> allResults = new LinkedList<>();
    for (MetadataScope scope : scopes) {
        SearchResults searchResults = getSearchResults(scope, namespaceId, searchQuery, types, sortInfo, offset, limit, numCursors, cursor, showHidden, entityScope);
        results.addAll(searchResults.getResults());
        cursors.addAll(searchResults.getCursors());
        allResults.addAll(searchResults.getAllResults());
    }
    Set<NamespacedEntityId> sortedEntities = getSortedEntities(results, sortInfo);
    int total = getSortedEntities(allResults, sortInfo).size();
    if (SortInfo.DEFAULT.equals(sortInfo)) {
        int startIndex = Math.min(offset, sortedEntities.size());
        int endIndex = (int) Math.min(Integer.MAX_VALUE, (long) offset + limit);
        endIndex = Math.min(endIndex, sortedEntities.size());
        sortedEntities = new LinkedHashSet<>(ImmutableList.copyOf(sortedEntities).subList(startIndex, endIndex));
    }
    Map<NamespacedEntityId, Metadata> systemMetadata = fetchMetadata(sortedEntities, MetadataScope.SYSTEM);
    Map<NamespacedEntityId, Metadata> userMetadata = fetchMetadata(sortedEntities, MetadataScope.USER);
    return new MetadataSearchResponse(sortInfo.getSortBy() + "String_Node_Str" + sortInfo.getSortOrder(), offset, limit, numCursors, total, addMetadataToEntities(sortedEntities, systemMetadata, userMetadata), cursors, showHidden, entityScope);
}

Output:
     }
-    List<MetadataEntry> results = new LinkedList<>();
+    List<MetadataEntry> resultsFromOffset = new LinkedList<>();
     List<String> cursors = new LinkedList<>();


Input:
static Object wrap(Object object) {
    try {
        if (object == null) {
            return NULL;
        }
        if (object instanceof JSONObject || object instanceof JSONArray || object instanceof Byte || object instanceof Character || object instanceof Short || object instanceof Integer || object instanceof Long || object instanceof Boolean || object instanceof Float || object instanceof Double || object instanceof String || NULL.equals(object)) {
            return object;
        }
        if (object instanceof Collection) {
            return new JSONArray((Collection) object);
        }
        if (object.getClass().isArray()) {
            return new JSONArray(object);
        }
        if (object instanceof Map) {
            return new JSONObject((Map) object);
        }
        Package objectPackage = object.getClass().getPackage();
        String objectPackageName = (objectPackage != null ? objectPackage.getName() : "String_Node_Str");
        if (objectPackageName.startsWith("String_Node_Str") || objectPackageName.startsWith("String_Node_Str") || object.getClass().getClassLoader() == null) {
            return object.toString();
        }
        return new JSONObject(object);
    } catch (Exception exception) {
        return null;
    }
}

Output:
     try {
-        if (object == null) {
+        if (object == null || object instanceof org.dom4j.Document) {
             return NULL;


Input:
public ObservableSource<Recipes> apply(TextViewAfterTextChangeEvent textViewAfterTextChangeEvent) throws Exception {
    return getDataManager().searchRecipes(textViewAfterTextChangeEvent.editable().toString(), "String_Node_Str");
}

Output:
 public ObservableSource<Recipes> apply(TextViewAfterTextChangeEvent textViewAfterTextChangeEvent) throws Exception {
-    return getDataManager().searchRecipes(textViewAfterTextChangeEvent.editable().toString(), "String_Node_Str");
+    return getDataManager().searchRecipes(textViewAfterTextChangeEvent.editable().toString(), "String_Node_Str").onErrorResumeNext(Observable.<Recipes>empty());
 }


Input:
private void drawMarker(Canvas canvas, RectF rect) {
    rect.inset(columnWidth * 0.15f, columnWidth * 0.15f);
    pGraph.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
    canvas.drawOval(rect, pGraph);
    rect.inset(columnWidth * 0.1f, columnWidth * 0.1f);
    pGraph.setColor(primaryColor);
    pGraph.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
    canvas.drawOval(rect, pGraph);
    rect.inset(columnWidth * 0.1f, columnWidth * 0.1f);
    pGraph.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
    canvas.drawOval(rect, pGraph);
    pGraph.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
}

Output:
     rect.inset(columnWidth * 0.15f, columnWidth * 0.15f);
-    pGraph.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
+    setModeOrColor(pGraph, XFERMODE_CLEAR, Color.WHITE);
     canvas.drawOval(rect, pGraph);


Input:
public void setName(String name) {
    this.name = name;
}

Output:
 public void setName(String name) {
-    this.name = name;
+    this.name = JDUtilities.removeEndingPoints(name);
 }


Input:
public void insert(DataAccess data) throws DatabaseWriteException {
    if (doesEntryExist(data)) {
        return;
    }
    PreparedStatement ps = null;
    try {
        StringBuilder fields = new StringBuilder();
        StringBuilder values = new StringBuilder();
        HashMap<Column, Object> columns = data.toDatabaseEntryList();
        Iterator<Column> it = columns.keySet().iterator();
        Column column = null;
        while (it.hasNext()) {
            column = it.next();
            if (!column.autoIncrement()) {
                fields.append("String_Node_Str").append(column.columnName()).append("String_Node_Str").append("String_Node_Str");
                values.append("String_Node_Str").append("String_Node_Str");
            }
        }
        if (fields.length() > 0) {
            fields.deleteCharAt(fields.length() - 1);
        }
        if (values.length() > 0) {
            values.deleteCharAt(values.length() - 1);
        }
        String state = "String_Node_Str" + data.getName() + "String_Node_Str" + fields.toString() + "String_Node_Str" + values.toString() + "String_Node_Str";
        ps = conn.prepareStatement(state);
        int i = 1;
        for (Column c : columns.keySet()) {
            if (!c.autoIncrement()) {
                if (column.isList()) {
                    ps.setObject(i, getString((List<?>) columns.get(column)));
                }
                ps.setObject(i, convert(columns.get(c)));
                i++;
            }
        }
        if (ps.executeUpdate() == 0) {
            throw new DatabaseWriteException("String_Node_Str");
        }
    } catch (SQLException ex) {
        Canary.logStacktrace(ex.getMessage(), ex);
    } catch (DatabaseTableInconsistencyException dtie) {
        Canary.logStacktrace(dtie.getMessage(), dtie);
    } finally {
        closePS(ps);
    }
}

Output:
             if (!c.autoIncrement()) {
-                if (column.isList()) {
-                    ps.setObject(i, getString((List<?>) columns.get(column)));
+                if (c.isList()) {
+                    ps.setObject(i, getString((List<?>) columns.get(c)));
                 }


Input:
private List<Network> queryWithoutInnerObjectsForEntity(final Long outerObjectId) {
    final String sql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    List<Network> result = jdbcTemplate.query(new PreparedStatementCreator() {
        public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
            PreparedStatement ps = connection.prepareStatement(sql);
            ps.setLong(1, outerObjectId);
            ps.setString(2, ModelType.IP.getName());
            return ps;
        }
    }, new NetworkResultSetExtractor());
    return result;
}

Output:
         }
-    }, new NetworkResultSetExtractor());
+    }, new NetworkWithStatusResultSetExtractor());
     return result;


Input:
public static boolean isSubtypeOf(Type type1, Type type2) {
    if (type1 instanceof RefType && type2 instanceof RefType) {
        SootClass class1 = ((RefType) type1).getSootClass();
        SootClass class2 = ((RefType) type2).getSootClass();
        return derivesFrom(class1, class2);
    } else if (type1 instanceof Type && type2 instanceof RefType) {
        Type elementType1 = ((ArrayType) type1).baseType;
        Type elementType2 = ((ArrayType) type2).baseType;
        return isSubtypeOf(elementType1, elementType2);
    } else {
        return type1.equals(type2);
    }
}

Output:
         return derivesFrom(class1, class2);
-    } else if (type1 instanceof Type && type2 instanceof RefType) {
+    } else if (type2 instanceof RefType) {
         Type elementType1 = ((ArrayType) type1).baseType;


Input:
public void setActivateSubjob(Node node, boolean active, boolean oneComponent) {
    setActivate(false);
    setActivateSubjob(node, active, node, oneComponent);
    setActivate(true);
}

Output:
     setActivate(false);
-    setActivateSubjob(node, active, node, oneComponent);
+    List chekedNodes = new ArrayList();
+    setActivateSubjob(node, active, node, oneComponent, chekedNodes);
     setActivate(true);


Input:
public <T> VertexEntity<T> createVertex(String database, String graphName, String collectionName, String key, T vertex, Boolean waitForSync) throws ArangoException {
    JsonObject obj;
    if (vertex == null) {
        obj = new JsonObject();
    } else {
        JsonElement elem = EntityFactory.toJsonElement(vertex, false);
        if (elem.isJsonObject()) {
            obj = elem.getAsJsonObject();
        } else {
            throw new IllegalArgumentException("String_Node_Str");
        }
    }
    if (key != null) {
        obj.addProperty("String_Node_Str", key);
    }
    validateCollectionName(graphName);
    HttpResponseEntity res = httpManager.doPost(createGharialEndpointUrl(database, StringUtils.encodeUrl(graphName), VERTEX, StringUtils.encodeUrl(collectionName)), new MapBuilder().put(WAIT_FOR_SYNC, waitForSync).get(), EntityFactory.toJsonString(obj));
    if (wrongResult(res)) {
        throw new ArangoException(UNKNOWN_ERROR);
    }
    VertexEntity<T> result;
    if (isInBatchMode()) {
        result = new VertexEntity<T>();
        result.setEntity(vertex);
    } else {
        result = createEntity(res, VertexEntity.class, vertex.getClass());
        result.setEntity(vertex);
        annotationHandler.updateDocumentAttributes(result.getEntity(), result.getDocumentRevision(), result.getDocumentHandle(), result.getDocumentKey());
    }
    return result;
}

Output:
     } else {
-        result = createEntity(res, VertexEntity.class, vertex.getClass());
+        if (vertex != null) {
+            result = createEntity(res, VertexEntity.class, vertex.getClass());
+        } else {
+            result = createEntity(res, VertexEntity.class);
+        }
         result.setEntity(vertex);


Input:
public LocalDate findFourDayRecallDateForAnyWeek(String patientDocId, LocalDate week) {
    Patient patient = allPatients.get(patientDocId);
    LocalDate startDayOfWeek = getStartDateForAnyWeek(patientDocId, week);
    DayOfWeek preferredDayOfWeek = patient.getPatientPreferences().getDayOfWeeklyCall();
    while (true) {
        if (startDayOfWeek.getDayOfWeek() == preferredDayOfWeek.getValue()) {
            return startDayOfWeek;
        }
        startDayOfWeek = startDayOfWeek.plusDays(1);
    }
}

Output:
     while (true) {
-        if (startDayOfWeek.getDayOfWeek() == preferredDayOfWeek.getValue()) {
-            return startDayOfWeek;
+        if (iteratingDayOfWeek.getDayOfWeek() == preferredDayOfWeek.getValue()) {
+            if (isStartDayEqualToOrSufficientlyBehindFourDayRecallDate(startDayOfWeek, iteratingDayOfWeek)) {
+                return iteratingDayOfWeek;
+            } else {
+                return iteratingDayOfWeek.plusWeeks(1);
+            }
         }


Input:
protected Object deserializeSharedObjectMessage(byte[] bytes) throws IOException, ClassNotFoundException {
    ByteArrayInputStream bins = new ByteArrayInputStream(bytes);
    Object obj = null;
    try {
        ObjectInputStream oins = new ObjectInputStream(bins);
        obj = oins.readObject();
    } catch (ClassNotFoundException e) {
        dumpStack("String_Node_Str", e);
        IdentifiableObjectInputStream iins = new IdentifiableObjectInputStream(new IClassLoaderMapper() {
            public ClassLoader mapNameToClassLoader(String name) {
                ISharedObjectManager manager = getSharedObjectManager();
                ID[] ids = manager.getSharedObjectIDs();
                ID found = null;
                for (int i = 0; i < ids.length; i++) {
                    ID id = ids[i];
                    if (name.equals(id.getName())) {
                        found = id;
                        break;
                    }
                }
                if (found == null)
                    return null;
                ISharedObject obj = manager.getSharedObject(found);
                if (obj == null)
                    return null;
                return obj.getClass().getClassLoader();
            }
        }, bins);
        obj = iins.readObject();
    }
    return obj;
}

Output:
     } catch (ClassNotFoundException e) {
-        dumpStack("String_Node_Str", e);
+        bins.reset();
         IdentifiableObjectInputStream iins = new IdentifiableObjectInputStream(new IClassLoaderMapper() {


Input:
public void onLoadMore() {
    wallpapersModelArrayList.add(null);
    Log.i("String_Node_Str", "String_Node_Str");
    homeFragmentCustomAdapter.notifyItemInserted(wallpapersModelArrayList.size() - 1);
    handler.postDelayed(new Runnable() {
        public void run() {
            wallpapersModelArrayList.remove(wallpapersModelArrayList.size() - 1);
            homeFragmentCustomAdapter.notifyItemRemoved(wallpapersModelArrayList.size());
            Log.i("String_Node_Str", "String_Node_Str");
            Log.i("String_Node_Str", "String_Node_Str");
            new loadMore().execute("String_Node_Str" + pageCount);
            homeFragmentCustomAdapter.setLoaded();
            Log.i("String_Node_Str", "String_Node_Str");
        }
    }, 700);
}

Output:
         }
-    }, 700);
+    }, 900);
 }


Input:
public boolean apply(Game game, Ability source) {
    Spell spell = game.getStack().getSpell(targetPointer.getFirst(game, source));
    if (spell == null) {
        spell = (Spell) game.getLastKnownInformation(targetPointer.getFirst(game, source), Zone.STACK);
    }
    Player controller = game.getPlayer(source.getControllerId());
    if (spell != null && controller != null) {
        Target usedTarget = null;
        setUsedTarget: for (Mode mode : spell.getSpellAbility().getModes().getSelectedModes()) {
            for (Target target : mode.getTargets()) {
                if (target.getFirstTarget().equals(source.getSourceId())) {
                    usedTarget = target.copy();
                    usedTarget.clearChosen();
                    break setUsedTarget;
                }
            }
        }
        if (usedTarget == null) {
            return false;
        }
        for (Permanent creature : game.getState().getBattlefield().getAllActivePermanents(new FilterCreaturePermanent(), source.getControllerId(), game)) {
            if (!creature.getId().equals(source.getSourceId()) && usedTarget.canTarget(source.getControllerId(), creature.getId(), source, game)) {
                Spell copy = spell.copySpell();
                setTarget: for (Mode mode : spell.getSpellAbility().getModes().getSelectedModes()) {
                    for (Target target : mode.getTargets()) {
                        if (target.getClass().equals(usedTarget.getClass())) {
                            target.clearChosen();
                            if (target.getMessage().equals(usedTarget.getMessage())) {
                                target.add(creature.getId(), game);
                                break setTarget;
                            }
                        }
                    }
                }
                copy.setControllerId(source.getControllerId());
                copy.setCopiedSpell(true);
                game.getStack().push(copy);
                String activateMessage = copy.getActivatedMessage(game);
                if (activateMessage.startsWith("String_Node_Str")) {
                    activateMessage = activateMessage.substring(6);
                }
                if (!game.isSimulation()) {
                    game.informPlayers(controller.getLogName() + activateMessage);
                }
            }
        }
        return true;
    }
    return false;
}

Output:
         Target usedTarget = null;
-        setUsedTarget: for (Mode mode : spell.getSpellAbility().getModes().getSelectedModes()) {
-            for (Target target : mode.getTargets()) {
-                if (target.getFirstTarget().equals(source.getSourceId())) {
-                    usedTarget = target.copy();
-                    usedTarget.clearChosen();
-                    break setUsedTarget;
+        setUsedTarget: for (Ability ability : spell.getSpellAbilities()) {
+            for (Mode mode : ability.getModes().getSelectedModes()) {
+                for (Target target : mode.getTargets()) {
+                    if (!target.isNotTarget() && target.getFirstTarget().equals(source.getSourceId())) {
+                        usedTarget = target.copy();
+                        usedTarget.clearChosen();
+                        break setUsedTarget;
+                    }
                 }


Input:
void draw(Graphics2D g) {
    if (!visible && this != driver.selBlock) {
        showZones(g);
        return;
    }
    g.setColor(Color.LIGHT_GRAY);
    g.fillRect(cx - width / 2, cy - height / 2, width, height);
    g.setColor(Color.BLACK);
    g.drawOval(cx - 8, cy - height / 2 + 2, 16, 20);
    if (this == driver.selBlock)
        g.setColor(new Color(255, 255, 200));
    else
        g.setColor(new Color(200, 255, 255));
    g.fillOval(cx - 7, cy - height / 2 + 3, 14, 18);
    g.setColor(Color.BLACK);
    g.drawLine(cx, cy - height / 2 + 20, cx, cy + 4);
    g.drawLine(cx, cy + 4, cx - 12, cy + height / 2);
    g.drawLine(cx, cy + 4, cx + 12, cy + height / 2);
    g.drawLine(cx, cy - 2, cx - 14, cy + 5);
    g.drawLine(cx, cy - 2, cx + 14, cy + 5);
    calcDiagMaxAndMin(cx - width / 2, cx + width / 2, cy - height / 2, cy + height / 2);
    if (description != null) {
        centreDesc(g);
    }
}

Output:
     if (this == driver.selBlock)
-        g.setColor(new Color(255, 255, 200));
+        g.setColor(ly);
     else


Input:
public void setBackgroundColor(int color) {
    this.backgroundColor = color;
    if (isEnabled())
        beforeBackground = backgroundColor;
    LayerDrawable layer = (LayerDrawable) getBackground();
    GradientDrawable shape = (GradientDrawable) layer.findDrawableByLayerId(R.id.shape_bacground);
    shape.setColor(backgroundColor);
}

Output:
     this.backgroundColor = color;
-    if (isEnabled())
+    if (isEnabled()) {
         beforeBackground = backgroundColor;


Input:
private void addSelectedKeys() {
    List<String> selectedItems = s3List.getSelectedValuesList();
    for (String key : selectedItems) {
        selectedKeys.add(this.prefix + key);
    }
}

Output:
     for (String key : selectedItems) {
-        selectedKeys.add(this.prefix + key);
+        selectedKeys.add(S3FileChooserDialog.prefix + key);
     }


Input:
private void bindConfigurations() {
    editorConfigBean.showGutterProperty().addListener((observable, oldValue, newValue) -> {
        if (Objects.nonNull(newValue)) {
            current.currentEditor().setShowGutter(newValue);
        }
    });
    editorConfigBean.useWrapModeProperty().addListener((observable, oldValue, newValue) -> {
        if (Objects.nonNull(newValue)) {
            current.currentEditor().setUseWrapMode(newValue);
        }
    });
    editorConfigBean.wrapLimitProperty().addListener((observable, oldValue, newValue) -> {
        if (Objects.nonNull(newValue)) {
            current.currentEditor().setWrapLimitRange(newValue);
        }
    });
    editorConfigBean.directoryPanelProperty().addListener((observable, oldValue, newValue) -> {
        if (newValue) {
            showFileBrowser();
        } else {
            hideFileBrowser(null);
        }
    });
    ListChangeListener<String> themeChangeListener = c -> {
        c.next();
        if (c.wasReplaced()) {
            String theme = c.getList().get(0);
            current.currentEditor().setTheme(theme);
        }
    };
    editorConfigBean.editorThemeProperty().addListener((observable, oldValue, newValue) -> {
        if (Objects.nonNull(newValue)) {
            newValue.addListener(themeChangeListener);
        }
        if (Objects.nonNull(oldValue)) {
            oldValue.removeListener(themeChangeListener);
        }
    });
    editorConfigBean.fontSizeProperty().addListener((observable, oldValue, newValue) -> {
        current.currentEditor().setFontSize(newValue.intValue());
    });
}

Output:
         c.next();
-        if (c.wasReplaced()) {
+        if (c.wasAdded()) {
             String theme = c.getList().get(0);


Input:
protected Image createImage(byte[] data) {
    return null;
}

Output:
 protected Image createImage(byte[] data) {
-    return null;
+    return new SVGImage(super.createImage(data), null, data);
 }


Input:
public void calcMinMax(int start, int end) {
    if (mYVals == null)
        return;
    if (mYVals.size() == 0)
        return;
    int endValue;
    if (end == 0 || end >= mYVals.size())
        endValue = mYVals.size() - 1;
    else
        endValue = end;
    mYMin = yMin(mYVals.get(start));
    mYMax = yMax(mYVals.get(start));
    for (int i = start; i < endValue; i++) {
        final BubbleEntry entry = mYVals.get(i);
        final float ymin = yMin(entry);
        final float ymax = yMax(entry);
        if (ymin < mYMin) {
            mYMin = ymin;
        }
        if (ymax > mYMax) {
            mYMax = ymax;
        }
        final float xmin = xMin(entry);
        final float xmax = xMax(entry);
        if (xmin < mXMin) {
            mXMin = xmin;
        }
        if (xmax > mXMax) {
            mXMax = xmax;
        }
        final float size = largestSize(entry);
        if (size > mMaxSize) {
            mMaxSize = size;
        }
    }
}

Output:
     mYMax = yMax(mYVals.get(start));
-    for (int i = start; i < endValue; i++) {
+    for (int i = start; i <= endValue; i++) {
         final BubbleEntry entry = mYVals.get(i);


Input:
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    if (chapters != null && !chapters.isEmpty()) {
        outState.putParcelableArrayList(ARG_CHAPTERS, chapters);
    }
    if (mViewPagerAdapter != null) {
        outState.putString(ARG_SELECTED_CHAPTER, mViewPagerAdapter.getSelectedChapter());
    }
}

Output:
     super.onSaveInstanceState(outState);
-    if (chapters != null && !chapters.isEmpty()) {
+    if (!chapters.isEmpty()) {
         outState.putParcelableArrayList(ARG_CHAPTERS, chapters);


Input:
public void onProtocolSessionStarted(SessionType sessionType, byte sessionID, byte version, String correlationID) {
    for (SdlSession session : listenerList) {
        if (session.getSessionId() == 0 || sessionType == SessionType.NAV || sessionType == SessionType.PCM) {
            session.onProtocolSessionStarted(sessionType, sessionID, version, correlationID);
            break;
        }
    }
}

Output:
     for (SdlSession session : listenerList) {
-        if (session.getSessionId() == 0 || sessionType == SessionType.NAV || sessionType == SessionType.PCM) {
+        if (session.getSessionId() == 0) {
             session.onProtocolSessionStarted(sessionType, sessionID, version, correlationID);


Input:
public void finish(int source) {
    if (partialReceiver != null) {
        partialReceiver.onFinish(source * -1);
    }
}

Output:
     if (partialReceiver != null) {
-        partialReceiver.onFinish(source * -1);
+        partialReceiver.onFinish(source);
     }


Input:
private static ExprType findOperatorResultType(Context context, SwiftAST tree) throws TypeMismatchException, UserException {
    String opName = extractOpName(tree);
    ArrayList<SwiftType> argTypes = new ArrayList<SwiftType>();
    List<BuiltinOpcode> opcodes = getBuiltInFromOpTree(context, tree, argTypes);
    assert (opcodes != null);
    assert (opcodes.size() > 0);
    List<SwiftType> alternatives = new ArrayList<SwiftType>(opcodes.size());
    for (BuiltinOpcode opcode : opcodes) {
        OpType opType = Operators.getBuiltinOpType(opcode);
        assert (opType != null);
        checkOp(context, opName, opType, argTypes);
        alternatives.add(new ScalarFutureType(opType.out));
    }
    return new ExprType(UnionType.createUnionType(alternatives));
}

Output:
     }
-    return new ExprType(UnionType.createUnionType(alternatives));
+    return new ExprType(UnionType.makeUnion(alternatives));
 }


Input:
protected List<IRepositoryViewObject> loadRepViewObjectWithOtherTypes() throws PersistenceException {
    List<IRepositoryViewObject> list = new ArrayList<IRepositoryViewObject>();
    list.addAll(loadRepViewObjectWithOtherTypes(ERepositoryObjectType.PROCESS));
    ERepositoryObjectType mrRepObjType = ERepositoryObjectType.valueOf(ERepositoryObjectType.class, "String_Node_Str");
    list.addAll(loadRepViewObjectWithOtherTypes(mrRepObjType));
    list.addAll(loadRepViewObjectWithOtherTypes(ERepositoryObjectType.ROUTINES));
    return list;
}

Output:
     List<IRepositoryViewObject> list = new ArrayList<IRepositoryViewObject>();
-    list.addAll(loadRepViewObjectWithOtherTypes(ERepositoryObjectType.PROCESS));
-    ERepositoryObjectType mrRepObjType = ERepositoryObjectType.valueOf(ERepositoryObjectType.class, "String_Node_Str");
-    list.addAll(loadRepViewObjectWithOtherTypes(mrRepObjType));
+    List<IRepositoryViewObject> processList = getAllProcessTypeObjectsWithoutCurrentType();
+    if (processList != null && !processList.isEmpty()) {
+        list.addAll(processList);
+    }
     list.addAll(loadRepViewObjectWithOtherTypes(ERepositoryObjectType.ROUTINES));


Input:
public void initialize(BlurInputSplit blurInputSplit, Configuration configuration) throws IOException {
    if (_setup) {
        return;
    }
    _setup = true;
    _table = blurInputSplit.getTable();
    Path localCachePath = BlurInputFormat.getLocalCachePath(configuration);
    List<String> files = blurInputSplit.getDirectoryFiles();
    LOG.info("String_Node_Str", localCachePath);
    _directory = BlurInputFormat.getDirectory(configuration, _table.toString(), blurInputSplit.getDir(), files);
    SegmentInfos segmentInfos = new SegmentInfos();
    segmentInfos.read(_directory, blurInputSplit.getSegmentsName());
    SegmentInfoPerCommit commit = findSegmentInfoPerCommit(segmentInfos, blurInputSplit);
    SegmentInfo segmentInfo = commit.info;
    if (localCachePath != null) {
        _readingDirectory = copyFilesLocally(configuration, _directory, _table.toString(), blurInputSplit.getDir(), localCachePath, commit.files());
    } else {
        _readingDirectory = _directory;
    }
    Blur024Codec blur024Codec = new Blur024Codec();
    IOContext iocontext = IOContext.READ;
    String segmentName = segmentInfo.name;
    FieldInfos fieldInfos = blur024Codec.fieldInfosFormat().getFieldInfosReader().read(_readingDirectory, segmentName, iocontext);
    if (commit.getDelCount() > 0) {
        _liveDocs = blur024Codec.liveDocsFormat().readLiveDocs(_readingDirectory, commit, iocontext);
    }
    _fieldsReader = blur024Codec.storedFieldsFormat().fieldsReader(_readingDirectory, segmentInfo, fieldInfos, iocontext);
    _maxDoc = commit.info.getDocCount();
}

Output:
     _directory = BlurInputFormat.getDirectory(configuration, _table.toString(), blurInputSplit.getDir(), files);
-    SegmentInfos segmentInfos = new SegmentInfos();
-    segmentInfos.read(_directory, blurInputSplit.getSegmentsName());
-    SegmentInfoPerCommit commit = findSegmentInfoPerCommit(segmentInfos, blurInputSplit);
+    SegmentInfoPerCommit commit = segmentInfosRead(_directory, blurInputSplit.getSegmentsName(), blurInputSplit.getSegmentInfoName());
     SegmentInfo segmentInfo = commit.info;


Input:
private void onDownEventInternal(int x, int y, long eventTime) {
    int keyIndex = mKeyState.onDownKey(x, y, eventTime);
    mIsAllowedSlidingKeyInput = mConfigSlidingKeyInputEnabled || isModifierInternal(keyIndex) || mKeyDetector instanceof MiniKeyboardKeyDetector;
    mKeyAlreadyProcessed = false;
    mIsRepeatableKey = false;
    mIsInSlidingKeyInput = false;
    if (isValidKeyIndex(keyIndex)) {
        callListenerOnPress(mKeys[keyIndex].mCode);
        keyIndex = mKeyState.getKeyIndex();
    }
    if (isValidKeyIndex(keyIndex)) {
        if (mKeys[keyIndex].mRepeatable) {
            repeatKey(keyIndex);
            mHandler.startKeyRepeatTimer(mDelayBeforeKeyRepeatStart, keyIndex, this);
            mIsRepeatableKey = true;
        }
        startLongPressTimer(keyIndex);
    }
    showKeyPreviewAndUpdateKeyGraphics(keyIndex);
}

Output:
     if (isValidKeyIndex(keyIndex)) {
-        callListenerOnPress(mKeys[keyIndex].mCode);
-        keyIndex = mKeyState.getKeyIndex();
+        if (callListenerOnPressAndCheckKeyboardLayoutChange(mKeys[keyIndex].mCode))
+            keyIndex = mKeyState.onDownKey(x, y, eventTime);
     }


Input:
public AjBuildConfig genBuildConfig(String configFilePath) {
    init();
    File configFile = new File(configFilePath);
    if (!configFile.exists()) {
        signalError("String_Node_Str" + configFile + "String_Node_Str");
        return null;
    }
    String[] args = new String[] { "String_Node_Str" + configFile.getAbsolutePath() };
    CountingMessageHandler handler = CountingMessageHandler.makeCountingMessageHandler(messageHandler);
    BuildArgParser parser = new BuildArgParser();
    AjBuildConfig config = parser.genBuildConfig(args, handler, false, configFile);
    configureProjectOptions(config, Ajde.getDefault().getProjectProperties());
    AjBuildConfig global = new AjBuildConfig();
    BuildOptionsAdapter buildOptions = Ajde.getDefault().getBuildManager().getBuildOptions();
    if (!configureBuildOptions(global, buildOptions, handler)) {
        return null;
    }
    ProjectPropertiesAdapter projectOptions = Ajde.getDefault().getProjectProperties();
    configureProjectOptions(global, projectOptions);
    config.installGlobals(global);
    ISourceLocation location = null;
    if (config.getConfigFile() != null) {
        location = new SourceLocation(config.getConfigFile(), 0);
    }
    String message = parser.getOtherMessages(true);
    if (null != message) {
        IMessage m = new Message(message, IMessage.ERROR, null, location);
        handler.handleMessage(m);
    }
    config.setGenerateModelMode(true);
    if (Ajde.getDefault().getBuildManager().getBuildOptions().getJavaOptionsMap() != null) {
        config.getJavaOptions().putAll(Ajde.getDefault().getBuildManager().getBuildOptions().getJavaOptionsMap());
    }
    return config;
}

Output:
     if (!configFile.exists()) {
-        signalError("String_Node_Str" + configFile + "String_Node_Str");
+        Ajde.getDefault().getErrorHandler().handleError("String_Node_Str" + configFile + "String_Node_Str");
         return null;


Input:
public void playerInteractEntity(PlayerInteractEntityEvent event) {
    String determination;
    dNPC npc = null;
    dItem item = new dItem(event.getPlayer().getItemInHand());
    dMaterial itemMaterial = item.getMaterial();
    dEntity entity = new dEntity(event.getRightClicked());
    String entityType = entity.getEntityType().name();
    Map<String, dObject> context = new HashMap<String, dObject>();
    context.put("String_Node_Str", new dLocation(event.getRightClicked().getLocation()));
    context.put("String_Node_Str", entity.getDenizenObject());
    if (entity.isNPC()) {
        npc = entity.getDenizenNPC();
        entityType = "String_Node_Str";
    }
    List<String> events = new ArrayList<String>();
    events.add("String_Node_Str");
    events.add("String_Node_Str" + entityType);
    events.add("String_Node_Str" + item.identify());
    events.add("String_Node_Str" + entityType + "String_Node_Str" + item.identify());
    events.add("String_Node_Str" + itemMaterial.identify());
    events.add("String_Node_Str" + entityType + "String_Node_Str" + itemMaterial.identify());
    if (entity.getBukkitEntity() instanceof ItemFrame) {
        dItem itemFrame = new dItem(((ItemFrame) entity).getItem());
        dMaterial itemFrameMaterial = itemFrame.getMaterial();
        context.put("String_Node_Str", itemFrame);
        events.add("String_Node_Str" + entityType + "String_Node_Str" + itemFrame.identify());
        events.add("String_Node_Str" + entityType + "String_Node_Str" + itemFrameMaterial.identify());
    }
    determination = doEvents(events, npc, event.getPlayer(), context);
    if (determination.toUpperCase().startsWith("String_Node_Str"))
        event.setCancelled(true);
}

Output:
     if (entity.getBukkitEntity() instanceof ItemFrame) {
-        dItem itemFrame = new dItem(((ItemFrame) entity).getItem());
+        dItem itemFrame = new dItem(((ItemFrame) entity.getBukkitEntity()).getItem());
         dMaterial itemFrameMaterial = itemFrame.getMaterial();


Input:
public boolean checkYSpeed(Player player, double y) {
    if (player.getVehicle() == null && y > Y_SPEED_MAX && !isVelocity(player)) {
        return true;
    }
    return false;
}

Output:
 public boolean checkYSpeed(Player player, double y) {
-    if (player.getVehicle() == null && y > Y_SPEED_MAX && !isVelocity(player)) {
+    if (!player.isInsideVehicle() && y > Y_SPEED_MAX && !isVelocity(player)) {
         return true;


Input:
public static boolean isEventThread() {
    try {
        return (Boolean) isEventThreadMethod.invoke(null);
    } catch (Throwable e) {
        SystemTray.logger.error("String_Node_Str" + "String_Node_Str");
    }
    return false;
}

Output:
     try {
-        return (Boolean) isEventThreadMethod.invoke(null);
+        if (OS.javaVersion <= 7) {
+            return (Boolean) isEventThreadMethod.invoke(null);
+        } else {
+            return (Boolean) isEventThreadMethod.invoke(isEventThreadObject, null);
+        }
     } catch (Throwable e) {


Input:
public String generateTransfersCode() throws IllegalActionException {
    CodeStream codeStream = _templateParser.getCodeStream();
    codeStream.clear();
    ptolemy.actor.CompositeActor container = (ptolemy.actor.CompositeActor) getComponent();
    String sanitizedContainerName = CodeGeneratorAdapter.generateName(container);
    Director director = container.getDirector();
    ptolemy.cg.adapter.generic.adapters.ptolemy.actor.Director directorAdapter = (ptolemy.cg.adapter.generic.adapters.ptolemy.actor.Director) getAdapter(director);
    StringBuffer code = new StringBuffer();
    codeStream.append(_eol + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + _eol);
    Iterator<?> inputPorts = container.inputPortList().iterator();
    while (inputPorts.hasNext()) {
        TypedIOPort inputPort = (TypedIOPort) inputPorts.next();
        if (!inputPort.isInsideConnected())
            continue;
        if (container instanceof CompiledCompositeActor) {
            directorAdapter.generateTransferInputsCode(inputPort, code);
            codeStream.append(code.toString());
            code = new StringBuffer();
        } else {
            Receiver[][] receivers = inputPort.deepGetReceivers();
            for (int channel = 0; channel < inputPort.getWidth(); channel++) {
                String hasTokenString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + channel + "String_Node_Str" + _eol;
                String getString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + channel + "String_Node_Str";
                String putString = _eol + "String_Node_Str" + getString + "String_Node_Str";
                if (receivers[channel].length > 1) {
                    int foo = 0;
                    for (int cpt = 0; cpt < receivers[channel].length; cpt++) {
                        if (!(receivers[channel][cpt].getContainer().getContainer() instanceof ModalController)) {
                            putString += _eol + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + foo++ + "String_Node_Str";
                        }
                    }
                } else
                    putString += _eol + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + channel + "String_Node_Str" + _eol;
                if (container.getDirector() instanceof ptolemy.domains.modal.kernel.FSMDirector) {
                    List actorList = container.deepEntityList();
                    Iterator<?> actors = actorList.iterator();
                    while (actors.hasNext()) {
                        NamedObj actor = (NamedObj) actors.next();
                        if (actor instanceof ModalController) {
                            String actorName = CodeGeneratorAdapter.generateName(actor);
                            String type = inputPort.getType().toString().substring(0, 1).toUpperCase() + inputPort.getType().toString().substring(1);
                            putString += _eol + actorName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + type + "String_Node_Str" + _eol;
                        }
                    }
                }
                String fireAtString = "String_Node_Str";
                if (container.getDirector() instanceof DEDirector) {
                    NamedObj insideActor = inputPort.deepGetReceivers()[channel][0].getContainer().getContainer();
                    String sanitizedNameInsideActor = CodeGeneratorAdapter.generateName(insideActor);
                    if (insideActor instanceof CompositeActor)
                        sanitizedNameInsideActor = "String_Node_Str" + sanitizedNameInsideActor + "String_Node_Str";
                    fireAtString = _eol + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedNameInsideActor + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + _eol;
                }
                codeStream.append(_eol + hasTokenString + putString + fireAtString + _eol + "String_Node_Str" + _eol);
            }
        }
    }
    codeStream.append(_eol + "String_Node_Str" + _eol);
    codeStream.append(_eol + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + _eol);
    Iterator<?> outputPorts = container.outputPortList().iterator();
    while (outputPorts.hasNext()) {
        TypedIOPort outputPort = (TypedIOPort) outputPorts.next();
        if (!outputPort.isOutsideConnected())
            continue;
        if (container instanceof CompiledCompositeActor) {
            directorAdapter.generateTransferOutputsCode(outputPort, code);
            codeStream.append(code.toString());
            code = new StringBuffer();
        } else {
            for (int channel = 0; channel < outputPort.getWidth(); channel++) {
                String hasTokenString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + outputPort.getName() + "String_Node_Str" + channel + "String_Node_Str" + _eol;
                String getString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + outputPort.getName() + "String_Node_Str" + channel + "String_Node_Str";
                String putString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + outputPort.getName() + "String_Node_Str" + channel + "String_Node_Str" + getString + "String_Node_Str" + _eol;
                String fireAtString = "String_Node_Str";
                CompositeActor topContainer = ((CompositeActor) container.getContainer());
                String sanitizedTopContainerName = CodeGeneratorAdapter.generateName(topContainer);
                if (topContainer.getDirector() instanceof DEDirector) {
                    NamedObj outsideActor = outputPort.getRemoteReceivers()[channel][0].getContainer().getContainer();
                    String sanitizedNameOutsideActor = CodeGeneratorAdapter.generateName(outsideActor);
                    if (outsideActor instanceof CompositeActor)
                        sanitizedNameOutsideActor = "String_Node_Str" + sanitizedNameOutsideActor + "String_Node_Str";
                    fireAtString = _eol + "String_Node_Str" + sanitizedTopContainerName + "String_Node_Str" + sanitizedNameOutsideActor + "String_Node_Str" + sanitizedTopContainerName + "String_Node_Str" + sanitizedTopContainerName + "String_Node_Str" + _eol;
                }
                codeStream.append(_eol + hasTokenString + putString + fireAtString + _eol + "String_Node_Str" + _eol);
            }
        }
    }
    if (container.getDirector() instanceof ptolemy.domains.modal.kernel.FSMDirector) {
        inputPorts = container.inputPortList().iterator();
        while (inputPorts.hasNext()) {
            TypedIOPort inputPort = (TypedIOPort) inputPorts.next();
            if (!inputPort.isInsideConnected())
                continue;
            Receiver[][] receivers = inputPort.deepGetReceivers();
            for (int channel = 0; channel < inputPort.getWidth(); channel++) {
                int foo = 0;
                for (int cpt = 0; cpt < receivers[channel].length; cpt++) {
                    if (!(receivers[channel][cpt].getContainer().getContainer() instanceof ModalController)) {
                        String hasTokenString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + foo + "String_Node_Str" + _eol;
                        String putString = _eol + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + foo++ + "String_Node_Str";
                        codeStream.append(_eol + hasTokenString + putString + _eol + "String_Node_Str" + _eol);
                    }
                }
            }
        }
    }
    codeStream.append(_eol + "String_Node_Str" + _eol);
    return processCode(codeStream.toString());
}

Output:
                 String getString = "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + sanitizedContainerName + "String_Node_Str" + inputPort.getName() + "String_Node_Str" + channel + "String_Node_Str";
-                String putString = _eol + "String_Node_Str" + getString + "String_Node_Str";
+                StringBuffer putString = new StringBuffer(_eol + "String_Node_Str" + getString + "String_Node_Str");
                 if (receivers[channel].length > 1) {


Input:
private <T> void updateScenarioState(T t) {
    injector.updateValues(t);
}

Output:
 private <T> void updateScenarioState(T t) {
-    injector.updateValues(t);
+    try {
+        injector.updateValues(t);
+    } catch (JGivenMissingRequiredScenarioStateException e) {
+        if (!suppressExceptions) {
+            throw e;
+        }
+    }
 }