Input:
public void dialogResult(AbstractGuiDialog dialog, DialogResult result) {
    if (result == DialogResult.OK) {
        if (dialog instanceof GuiDialogNewFolder) {
            GuiDialogNewFolder newFolderDialog = (GuiDialogNewFolder) dialog;
            if (fileSwitchType == LibraryFileType.LOCAL) {
                File dir = new File(SkinIOUtils.getSkinLibraryDirectory(), currentFolder);
                dir = new File(dir, newFolderDialog.getFolderName());
                if (!dir.exists()) {
                    dir.mkdir();
                }
                reloadLocalLibrary();
                ModLogger.log(String.format("String_Node_Str", newFolderDialog.getFolderName(), currentFolder));
                ModLogger.log("String_Node_Str" + dir.getAbsolutePath());
            } else {
            }
        }
        if (dialog instanceof GuiDialogDelete) {
            GuiDialogDelete deleteDialog = (GuiDialogDelete) dialog;
            if (fileSwitchType == LibraryFileType.LOCAL) {
                boolean isFolder = deleteDialog.isFolder();
                String name = deleteDialog.getName();
                File dir = new File(SkinIOUtils.getSkinLibraryDirectory(), currentFolder);
                if (deleteDialog.isFolder()) {
                    dir = new File(dir, name + "String_Node_Str");
                } else {
                    dir = new File(dir, name + SkinIOUtils.SKIN_FILE_EXTENSION);
                }
                if (dir.isDirectory() == isFolder) {
                    ModLogger.log("String_Node_Str" + dir.getAbsolutePath());
                    if (dir.exists()) {
                        ModLogger.log("String_Node_Str" + dir.getAbsolutePath());
                        try {
                            FileUtils.deleteDirectory(dir);
                            reloadLocalLibrary();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } else {
            }
        }
        if (dialog instanceof GuiDialogOverwrite) {
            GuiDialogOverwrite overwriteDialog = (GuiDialogOverwrite) dialog;
            MessageClientGuiLoadSaveArmour message;
            boolean clientLoad = false;
            boolean publicList = true;
            if (fileSwitchType == LibraryFileType.LOCAL && !mc.isIntegratedServerRunning()) {
                clientLoad = true;
            }
            if (fileSwitchType == LibraryFileType.SERVER_PRIVATE) {
                publicList = false;
            }
            if (clientLoad) {
                message = new MessageClientGuiLoadSaveArmour(overwriteDialog.getFileName(), currentFolder, LibraryPacketType.CLIENT_SAVE, false);
                PacketHandler.networkWrapper.sendToServer(message);
            } else {
                message = new MessageClientGuiLoadSaveArmour(overwriteDialog.getFileName(), currentFolder, LibraryPacketType.SERVER_SAVE, publicList);
                PacketHandler.networkWrapper.sendToServer(message);
            }
        }
    }
    super.dialogResult(dialog, result);
}

Output:
                     if (dir.exists()) {
-                        ModLogger.log("String_Node_Str" + dir.getAbsolutePath());
-                        try {
-                            FileUtils.deleteDirectory(dir);
+                        if (isFolder) {
+                            try {
+                                FileUtils.deleteDirectory(dir);
+                                reloadLocalLibrary();
+                            } catch (IOException e) {
+                                e.printStackTrace();
+                            }
+                        } else {
+                            ClientSkinCache.INSTANCE.clearIdForFileName(currentFolder + deleteDialog.getName());
+                            dir.delete();
                             reloadLocalLibrary();


Input:
public void next() {
    do {
        doNext();
    } while (doc != Integer.MAX_VALUE && num < 0);
}

Output:
 public void next() {
-    do {
-        doNext();
-    } while (doc != Integer.MAX_VALUE && num < 0);
+    doNext();
 }


Input:
private void levelUp(Player player, HumanNPC npc) {
    if (EconomyHandler.useEconomy()) {
        int level = HealerPropertyPool.getLevel(npc.getUID());
        int paid = EconomyHandler.pay(Operation.HEALER_LEVEL_UP, player);
        if (paid > 0) {
            if (level < 10) {
                HealerPropertyPool.saveLevel(npc.getUID(), level + 1);
                plugin.scheduleHealTask();
                player.sendMessage(getLevelUpPaidMessage(Operation.HEALER_LEVEL_UP, npc, paid, level + 1));
            } else {
                player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
            }
        }
    } else {
        player.sendMessage(ChatColor.GRAY + "String_Node_Str");
    }
}

Output:
         int level = HealerPropertyPool.getLevel(npc.getUID());
-        int paid = EconomyHandler.pay(Operation.HEALER_LEVEL_UP, player);
+        int paid = EconomyHandler.pay(Operation.HEALER_LEVEL_UP, player, multiple);
         if (paid > 0) {


Input:
public Map<String, String> getQueryMap() {
    Map<String, String> map = new HashMap<String, String>();
    if (ColumnsetPackage.eINSTANCE.getAllMatchIndicator().isSuperTypeOf(indicator.eClass())) {
        return map;
    }
    boolean isSqlEngine = ExecutionLanguage.SQL.equals(this.analysis.getParameters().getExecutionLanguage());
    EList<Expression> instantiatedExpressions = this.indicator.getInstantiatedExpressions();
    if (instantiatedExpressions.size() > 0) {
        Expression expression = instantiatedExpressions.get(0);
        String regularExpressionFunctionName = dbmsLanguage.extractRegularExpressionFunction(expression);
        dbmsLanguage.setRegularExpressionFunction(regularExpressionFunctionName);
        dbmsLanguage.setFunctionReturnValue(expression);
    }
    map.put(MENU_VIEW_INVALID_VALUES, isSqlEngine ? getComment(MENU_VIEW_INVALID_VALUES) + getInvalidValuesStatement() : null);
    map.put(MENU_VIEW_VALID_VALUES, isSqlEngine ? getComment(MENU_VIEW_VALID_VALUES) + getValidValuesStatement() : null);
    map.put(MENU_VIEW_INVALID_ROWS, isSqlEngine ? getComment(MENU_VIEW_INVALID_ROWS) + getInvalidRowsStatement() : null);
    map.put(MENU_VIEW_VALID_ROWS, isSqlEngine ? getComment(MENU_VIEW_VALID_ROWS) + getValidRowsStatement() : null);
    return map;
}

Output:
     }
-    boolean isSqlEngine = ExecutionLanguage.SQL.equals(this.analysis.getParameters().getExecutionLanguage());
-    EList<Expression> instantiatedExpressions = this.indicator.getInstantiatedExpressions();
+    boolean isSqlEngine = ExecutionLanguage.SQL.equals(analysis.getParameters().getExecutionLanguage());
+    EList<Expression> instantiatedExpressions = indicator.getInstantiatedExpressions();
     if (instantiatedExpressions.size() > 0) {


Input:
public MWSimpleTypeDefinition simpleType(String namespaceUrl, String simpleTypeName) {
    if (namespaceUrl == null) {
        namespaceUrl = "String_Node_Str";
    }
    return this.namespaceForUrl(namespaceUrl).simpleType(simpleTypeName);
}

Output:
 public MWSimpleTypeDefinition simpleType(String namespaceUrl, String simpleTypeName) {
-    if (namespaceUrl == null) {
-        namespaceUrl = "String_Node_Str";
+    if (namespaceUrl == null || "String_Node_Str".equals(namespaceUrl)) {
+        namespaceUrl = targetNamespaceUrl();
     }


Input:
public void update(float deltaTime) {
    List<TouchEvent> touchEvents = game.getInput().getTouchEvents();
    game.getInput().getKeyEvents();
    if (state == GameState.Ready)
        updateReady(touchEvents);
    if (state == GameState.Running)
        updateRunning(touchEvents, deltaTime);
    if (state == GameState.Paused)
        updatePaused(touchEvents);
    if (state == GameState.GameOver)
        updateGameOver(touchEvents);
}

Output:
     List<TouchEvent> touchEvents = game.getInput().getTouchEvents();
-    game.getInput().getKeyEvents();
+    List<KeyEvent> keyEvents = game.getInput().getKeyEvents();
     if (state == GameState.Ready)


Input:
protected void retrieveDataContainers() {
    dataContainers = new ArrayList<DataContainer>();
    List<DataContainer> containers = ((IDataContainerBasedView) representedView).getDataContainers();
    if (containers == null)
        return;
    Set<IDataDomain> dataDomains = new HashSet<IDataDomain>();
    for (DataContainer container : containers) {
        if (container instanceof PathwayDataContainer) {
            dataDomains.add(((PathwayDataContainer) container).getPathwayDataDomain());
        } else {
            dataDomains.add(container.getDataDomain());
        }
    }
    List<Pair<Float, ADataNode>> sortedDataNodes = new ArrayList<Pair<Float, ADataNode>>();
    for (IDataDomain dataDomain : dataDomains) {
        ADataNode dataNode = view.getDataNode(dataDomain);
        if (dataNode != null) {
            sortedDataNodes.add(new Pair<Float, ADataNode>((float) dataNode.getPosition().getX(), dataNode));
        }
    }
    Collections.sort(sortedDataNodes);
    for (Pair<Float, ADataNode> dataNodePair : sortedDataNodes) {
        ADataNode dataNode = dataNodePair.getSecond();
        List<DataContainer> sortedNodeDataContainers = dataNode.getDataContainers();
        for (DataContainer nodeContainer : sortedNodeDataContainers) {
            for (DataContainer container : containers) {
                if (nodeContainer == container) {
                    dataContainers.add(container);
                    break;
                }
            }
        }
    }
}

Output:
 protected void retrieveDataContainers() {
-    dataContainers = new ArrayList<DataContainer>();
-    List<DataContainer> containers = ((IDataContainerBasedView) representedView).getDataContainers();
-    if (containers == null)
+    dataContainers = new ArrayList<DataContainer>(((IDataContainerBasedView) representedView).getDataContainers());
+    if (dataContainers == null) {
+        dataContainers = new ArrayList<DataContainer>();
         return;


Input:
private void writeClinit(int depth, Writer writer, MemberUnit clinitMethod, List<MemberUnit> staticMethods) throws IOException {
    String superStaticFields = createSuperStaticFieldsReferences(depth, clinitMethod, staticMethods);
    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" + superStaticFields);
        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" + superStaticFields + "String_Node_Str";
        writer.write(replace);
    }
}

Output:
         String replace = clinitMethod.getData().replace("String_Node_Str", name + "String_Node_Str");
-        replace = replace.replace("String_Node_Str", "String_Node_Str" + superStaticFields);
+        replace = replace.replaceFirst("String_Node_Str", "String_Node_Str" + superStaticFields.replace("String_Node_Str", "String_Node_Str"));
         replace = replace.substring(0, replace.length() - 2) + "String_Node_Str";


Input:
public void onTick() {
    if (config == null || onTickBusy == true)
        return;
    if (Mouse.isButtonDown(2) && config.isMiddleClickEnabled())
        onSortingKeyPressed();
    synchronized (this) {
        onTickBusy = true;
        ItemStack currentStack = getFocusedStack();
        int currentStackId = (currentStack == null) ? 0 : getItemID(currentStack);
        int currentStackDamage = (currentStack == null) ? 0 : getItemDamage(currentStack);
        int focusedSlot = getFocusedSlot();
        if (currentStackId != storedStackId || currentStackDamage != storedStackDamage) {
            if (storedFocusedSlot != focusedSlot) {
                storedFocusedSlot = focusedSlot;
            } else if ((currentStack == null || getItemID(currentStack) == 281 && storedStackId == 282) && (getCurrentScreen() == null || getCurrentScreen() instanceof GuiEditSign)) {
                sortingAlgorithm.autoReplaceSlot(focusedSlot, storedStackId, storedStackDamage);
            }
        }
        storedStackId = currentStackId;
        storedStackDamage = currentStackDamage;
    }
}

Output:
 public void onTick() {
-    if (config == null || onTickBusy == true)
+    if (config == null)
         return;


Input:
private void loadCategories(CategoryGraph graph, LocalPageDao lpDao) throws DaoException {
    LOG.info("String_Node_Str");
    graph.catIndexes = new TIntIntHashMap();
    List<String> catList = new ArrayList<String>();
    Iterable<LocalPage> catIter = lpDao.get(new DaoFilter().setNameSpaces(NameSpace.CATEGORY).setLanguages(graph.language));
    for (LocalPage cat : catIter) {
        if (cat != null) {
            catList.add(cat.getTitle().getCanonicalTitle());
            graph.catIndexes.put(cat.getLocalId(), graph.catIndexes.size());
        }
    }
    graph.cats = catList.toArray(new String[0]);
    LOG.info("String_Node_Str" + graph.cats.length + "String_Node_Str");
}

Output:
     List<String> catList = new ArrayList<String>();
-    Iterable<LocalPage> catIter = lpDao.get(new DaoFilter().setNameSpaces(NameSpace.CATEGORY).setLanguages(graph.language));
+    Iterable<LocalPage> catIter = pageDao.get(new DaoFilter().setNameSpaces(NameSpace.CATEGORY).setLanguages(graph.language));
+    TIntList catIds = new TIntArrayList();
     for (LocalPage cat : catIter) {


Input:
private void changeForMultipleMergeComponents(INode graphicalNode) {
    String hashMergeOutput = "String_Node_Str";
    String hashMergeInput = "String_Node_Str";
    INode mergeDataNode = buildCheckMap.get(graphicalNode);
    IComponent hashMergeOutputComponent = ComponentsFactoryProvider.getInstance().get(hashMergeOutput);
    IComponent hashMergeInputComponent = ComponentsFactoryProvider.getInstance().get(hashMergeInput);
    if (hashMergeOutputComponent == null || hashMergeInputComponent == null) {
        return;
    }
    String hashOutputUniqueName = hashMergeOutput + "String_Node_Str" + mergeDataNode.getUniqueName();
    List mergeOutputConnections = NodeUtil.getOutgoingConnections(mergeDataNode, IConnectionCategory.MAIN);
    if (mergeOutputConnections.size() == 0) {
        return;
    }
    IConnection mergeOutputConnection = ((List<IConnection>) mergeOutputConnections).get(0);
    DataNode hashNode = new DataNode(hashMergeOutputComponent, hashOutputUniqueName);
    hashNode.setActivate(mergeDataNode.isActivate());
    hashNode.setStart(false);
    hashNode.setDesignSubjobStartNode(null);
    hashNode.getMetadataList().remove(0);
    IMetadataTable newMetadata = mergeDataNode.getMetadataList().get(0).clone();
    newMetadata.setTableName(hashOutputUniqueName);
    hashNode.getMetadataList().add(newMetadata);
    hashNode.setSubProcessStart(false);
    hashNode.setProcess(graphicalNode.getProcess());
    List<IConnection> outgoingConnections = new ArrayList<IConnection>();
    List<IConnection> incomingConnections = new ArrayList<IConnection>();
    hashNode.setIncomingConnections(incomingConnections);
    hashNode.setOutgoingConnections(outgoingConnections);
    hashNode.setVirtualGenerateNode(false);
    addDataNode(hashNode);
    incomingConnections.add(mergeOutputConnection);
    INode oldNodeTarget = ((DataConnection) mergeOutputConnection).getTarget();
    Map<String, Integer> map = new HashMap<String, Integer>();
    List<? extends IConnection> incomingConns = oldNodeTarget.getIncomingConnections();
    for (IConnection list : incomingConns) {
        String name = list.getUniqueName();
        if (name != null) {
            map.put(name, incomingConns.indexOf(list));
        }
    }
    ((DataConnection) mergeOutputConnection).setTarget(hashNode);
    oldNodeTarget.getIncomingConnections().remove(mergeOutputConnection);
    String hashInputUniqueName = hashMergeInput + "String_Node_Str" + mergeDataNode.getUniqueName();
    hashNode = new DataNode(hashMergeInputComponent, hashInputUniqueName);
    hashNode.setActivate(mergeDataNode.isActivate());
    hashNode.setStart(false);
    hashNode.setDesignSubjobStartNode(null);
    newMetadata = mergeDataNode.getMetadataList().get(0).clone();
    newMetadata.setTableName(hashInputUniqueName);
    hashNode.getMetadataList().remove(0);
    hashNode.getMetadataList().add(newMetadata);
    hashNode.setSubProcessStart(true);
    hashNode.setProcess(graphicalNode.getProcess());
    outgoingConnections = new ArrayList<IConnection>();
    incomingConnections = new ArrayList<IConnection>();
    hashNode.setIncomingConnections(incomingConnections);
    hashNode.setOutgoingConnections(outgoingConnections);
    hashNode.setVirtualGenerateNode(false);
    hashNode.getElementParameter("String_Node_Str").setValue(Boolean.TRUE);
    hashNode.getElementParameter("String_Node_Str").setValue(hashOutputUniqueName);
    DataConnection dataConnec = new DataConnection();
    dataConnec.setActivate(mergeOutputConnection.isActivate());
    dataConnec.setLineStyle(mergeOutputConnection.getLineStyle());
    dataConnec.setConnectorName(mergeOutputConnection.getConnectorName());
    dataConnec.setMetadataTable(newMetadata);
    dataConnec.setTraceConnection(mergeOutputConnection.isTraceConnection());
    dataConnec.setMonitorConnection(mergeOutputConnection.isMonitorConnection());
    dataConnec.setTracesCondition(mergeOutputConnection.getTracesCondition());
    dataConnec.setEnabledTraceColumns(mergeOutputConnection.getEnabledTraceColumns());
    dataConnec.setName(mergeOutputConnection.getName());
    dataConnec.setSource(hashNode);
    dataConnec.setLinkNodeForHash(((DataConnection) mergeOutputConnection).getLinkNodeForHash());
    dataConnec.setElementParameters(mergeOutputConnection.getElementParameters());
    dataConnec.setUniqueName(mergeOutputConnection.getUniqueName());
    mergeOutputConnection.setElementParameters(new ArrayList<IElementParameter>());
    dataConnec.setTarget(oldNodeTarget);
    ((DataConnection) mergeOutputConnection).setName(hashNode.getUniqueName() + "String_Node_Str" + mergeOutputConnection.getName());
    ((DataConnection) mergeOutputConnection).setUniqueName(hashNode.getUniqueName() + "String_Node_Str" + mergeOutputConnection.getName());
    int inputId = mergeOutputConnection.getInputId();
    if (inputId == 0) {
        List refOutputConnections = NodeUtil.getOutgoingConnections(mergeDataNode, EConnectionType.FLOW_REF);
        if (refOutputConnections.size() != 0) {
            IConnection refConnection = ((List<IConnection>) refOutputConnections).get(0);
            inputId = refConnection.getInputId();
            mergeDataNode.getOutgoingConnections().remove(refConnection);
            ((DataConnection) refConnection).setSource(hashNode);
            ((List<IConnection>) hashNode.getOutgoingConnections()).add(refConnection);
        }
    }
    dataConnec.setInputId(inputId);
    outgoingConnections.add(dataConnec);
    Set<Map.Entry<String, Integer>> set = map.entrySet();
    for (Entry<String, Integer> entry2 : set) {
        Map.Entry<String, Integer> entry = entry2;
        if (entry.getKey().equals(dataConnec.getUniqueName())) {
            ((List<IConnection>) oldNodeTarget.getIncomingConnections()).add(entry.getValue(), dataConnec);
        }
    }
    ((DataConnection) mergeOutputConnection).setLineStyle(EConnectionType.FLOW_MAIN);
    ((DataConnection) mergeOutputConnection).setConnectorName(EConnectionType.FLOW_MAIN.getName());
    addDataNode(hashNode);
    INode afterMergeStart = hashNode.getSubProcessStartNode(false);
    INode mergeSubNodeStart = mergeDataNode.getSubProcessStartNode(false);
    boolean changeStartNode = false;
    if (mergeDataNode.getLinkedMergeInfo() == null || mergeDataNode.getLinkedMergeInfo().isEmpty()) {
        changeStartNode = true;
    } else {
        Map<INode, Integer> nextMergeNodes = mergeDataNode.getLinkedMergeInfo();
        if (nextMergeNodes.size() == 1) {
            INode followMergeNode = nextMergeNodes.keySet().iterator().next();
            List nextMergeOutputConnections = NodeUtil.getOutgoingConnections(followMergeNode, IConnectionCategory.DATA);
            if (nextMergeOutputConnections == null || nextMergeOutputConnections.isEmpty()) {
                changeStartNode = true;
            }
        }
    }
    if (changeStartNode) {
        INode oldStartNode = null;
        if (mergeDataNode.isThereLinkWithHash()) {
            oldStartNode = (mergeDataNode.getSubProcessStartNode(false));
        } else {
            oldStartNode = (mergeDataNode.getDesignSubjobStartNode());
        }
        ((AbstractNode) afterMergeStart).setStart(oldStartNode.isStart());
        ((AbstractNode) oldStartNode).setStart(false);
        for (INode curNode : dataNodeList) {
            if (curNode instanceof AbstractNode) {
                if (curNode.getDesignSubjobStartNode().equals(oldStartNode)) {
                    ((AbstractNode) curNode).setDesignSubjobStartNode(afterMergeStart);
                }
            }
        }
        List<IConnection> depConnections = (List<IConnection>) NodeUtil.getOutgoingConnections(oldStartNode, IConnectionCategory.EXECUTION_ORDER);
        oldStartNode.getOutgoingConnections().removeAll(depConnections);
        ((List<IConnection>) afterMergeStart.getOutgoingConnections()).addAll(depConnections);
        for (IConnection curDepConnection : depConnections) {
            ((AbstractConnection) curDepConnection).setSource(afterMergeStart);
        }
        depConnections = (List<IConnection>) NodeUtil.getIncomingConnections(oldStartNode, IConnectionCategory.DEPENDENCY);
        for (IConnection connection : connectionsToIgnoreInMerge) {
            if (depConnections.contains(connection)) {
                depConnections.remove(connection);
            }
        }
        oldStartNode.getIncomingConnections().removeAll(depConnections);
        ((List<IConnection>) afterMergeStart.getIncomingConnections()).addAll(depConnections);
        for (IConnection curDepConnection : depConnections) {
            ((AbstractConnection) curDepConnection).setTarget(afterMergeStart);
        }
    }
    dataConnec = new DataConnection();
    dataConnec.setActivate(mergeOutputConnection.isActivate());
    dataConnec.setLineStyle(EConnectionType.RUN_AFTER);
    dataConnec.setConnectorName(EConnectionType.RUN_AFTER.getName());
    dataConnec.setTraceConnection(false);
    dataConnec.setName(hashNode.getUniqueName() + "String_Node_Str" + EConnectionType.RUN_AFTER.getDefaultLinkName());
    dataConnec.setSource(afterMergeStart);
    dataConnec.setTarget(mergeSubNodeStart);
    connectionsToIgnoreInMerge.add(dataConnec);
    ((List<IConnection>) mergeSubNodeStart.getIncomingConnections()).add(dataConnec);
    ((List<IConnection>) afterMergeStart.getOutgoingConnections()).add(dataConnec);
}

Output:
     outgoingConnections.add(dataConnec);
-    Set<Map.Entry<String, Integer>> set = map.entrySet();
-    for (Entry<String, Integer> entry2 : set) {
-        Map.Entry<String, Integer> entry = entry2;
-        if (entry.getKey().equals(dataConnec.getUniqueName())) {
-            ((List<IConnection>) oldNodeTarget.getIncomingConnections()).add(entry.getValue(), dataConnec);
-        }
+    if (inputId == 1) {
+        ((List<IConnection>) oldNodeTarget.getIncomingConnections()).add(0, dataConnec);
+    } else {
+        ((List<IConnection>) oldNodeTarget.getIncomingConnections()).add(dataConnec);
     }


Input:
public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) arg0;
    HttpServletResponse response = (HttpServletResponse) arg1;
    String tempPass = null;
    tempPass = request.getHeader("String_Node_Str");
    Principal principal = Principal.getAnonymousPrincipal();
    if (tempPass != null) {
        tempPass = tempPass.substring(6, tempPass.length());
        String tempPassdeCode = "String_Node_Str";
        BASE64Decoder decoder = new BASE64Decoder();
        try {
            byte[] b = decoder.decodeBuffer(tempPass);
            tempPassdeCode = new String(b);
        } catch (Exception e) {
            return;
        }
        String userReqId = "String_Node_Str";
        String userReqPwd = "String_Node_Str";
        userReqId = tempPassdeCode.substring(0, tempPassdeCode.indexOf("String_Node_Str"));
        userReqPwd = tempPassdeCode.substring(tempPassdeCode.indexOf("String_Node_Str") + 1);
        User user = null;
        IdentityCheckService idcService = ServiceBeanUtil.getIdentityCheckService();
        user = idcService.IdentityCheckService(userReqId, userReqPwd);
        if (null == user) {
            request.getSession().removeAttribute("String_Node_Str");
            writeError401Response(response);
            return;
        } else {
            principal = new Principal(user.getUserId());
        }
    }
    PrincipalHolder.setPrincipal(principal);
    chain.doFilter(request, response);
    PrincipalHolder.remove();
}

Output:
     Principal principal = Principal.getAnonymousPrincipal();
-    if (tempPass != null) {
-        tempPass = tempPass.substring(6, tempPass.length());
+    if (StringUtils.isNotBlank(tempPass)) {
+        String AUTH_BASIC_PREFIX = "String_Node_Str";
+        if (!StringUtils.startsWith(tempPass, AUTH_BASIC_PREFIX)) {
+            writeError401Response(response);
+            return;
+        }
+        tempPass = tempPass.substring(AUTH_BASIC_PREFIX.length(), tempPass.length());
         String tempPassdeCode = "String_Node_Str";


Input:
public void onEntityDamage(EntityDamageEvent event) {
    if (event instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
        HumanNPC npc = NPCManager.getNPC(e.getEntity());
        if (e.getEntity() instanceof Player && e.getDamager() instanceof Player && npc != null) {
            e.setCancelled(true);
        }
        if (e.getEntity() instanceof Player && e.getDamager() instanceof Monster) {
            return;
        }
        if (npc.isHealer()) {
            Entity entity = e.getDamager();
            if (entity instanceof Player) {
                Player player = (Player) entity;
                int playerHealth = player.getHealth();
                int healerHealth = HealerPropertyPool.getStrength(npc.getUID());
                if (player.getItemInHand().getTypeId() == Citizens.healerTakeHealthItem) {
                    if (playerHealth <= 19) {
                        if (healerHealth >= 1) {
                            player.setHealth(playerHealth + 1);
                            HealerPropertyPool.saveStrength(npc.getUID(), healerHealth - 1);
                            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                        } else {
                            player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                        }
                    } else {
                        player.sendMessage(ChatColor.GREEN + "String_Node_Str");
                    }
                } else if (player.getItemInHand().getTypeId() == Citizens.healerGiveHealthItem) {
                    if (playerHealth >= 1) {
                        if (healerHealth < HealerPropertyPool.getMaxStrength(npc.getUID())) {
                            player.setHealth(playerHealth - 1);
                            HealerPropertyPool.saveStrength(npc.getUID(), healerHealth + 1);
                            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                        } else {
                            player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                        }
                    } else {
                        player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()));
                    }
                } else if (player.getItemInHand().getType() == Material.DIAMOND_BLOCK) {
                    if (healerHealth != HealerPropertyPool.getMaxStrength(npc.getUID())) {
                        HealerPropertyPool.saveStrength(npc.getUID(), HealerPropertyPool.getMaxStrength(npc.getUID()));
                        player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                        player.setItemInHand(null);
                    } else {
                        player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                    }
                }
            }
        }
    }
}

Output:
             e.setCancelled(true);
-        }
-        if (e.getEntity() instanceof Player && e.getDamager() instanceof Monster) {
-            return;
-        }
-        if (npc.isHealer()) {
-            Entity entity = e.getDamager();
-            if (entity instanceof Player) {
-                Player player = (Player) entity;
-                int playerHealth = player.getHealth();
-                int healerHealth = HealerPropertyPool.getStrength(npc.getUID());
-                if (player.getItemInHand().getTypeId() == Citizens.healerTakeHealthItem) {
-                    if (playerHealth <= 19) {
-                        if (healerHealth >= 1) {
-                            player.setHealth(playerHealth + 1);
-                            HealerPropertyPool.saveStrength(npc.getUID(), healerHealth - 1);
-                            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
+            if (npc.isHealer()) {
+                Entity entity = e.getDamager();
+                if (entity instanceof Player) {
+                    Player player = (Player) entity;
+                    int playerHealth = player.getHealth();
+                    int healerHealth = HealerPropertyPool.getStrength(npc.getUID());
+                    if (player.getItemInHand().getTypeId() == Citizens.healerTakeHealthItem) {
+                        if (playerHealth <= 19) {
+                            if (healerHealth >= 1) {
+                                player.setHealth(playerHealth + 1);
+                                HealerPropertyPool.saveStrength(npc.getUID(), healerHealth - 1);
+                                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
+                            } else {
+                                player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
+                            }
                         } else {


Input:
public WaitStatement clone() {
    return new WaitStatement(procName, this.block.clone(), waitVars, passedInVars, keepOpenVars, mode, recursive, target);
}

Output:
 public WaitStatement clone() {
-    return new WaitStatement(procName, this.block.clone(), waitVars, passedInVars, keepOpenVars, mode, recursive, target);
+    return new WaitStatement(procName, this.block.clone(), waitVars, passedInVars, keepOpenVars, priority, mode, recursive, target);
 }


Input:
public boolean equals(Object o) {
    if (this == o) {
        return true;
    }
    if (o == null || getClass() != o.getClass()) {
        return false;
    }
    Network that = (Network) o;
    return Objects.equals(this.name, that.name) && Objects.equals(this.id, that.id) && Objects.equals(this.scope, that.scope) && Objects.equals(this.driver, that.driver) && Objects.equals(this.options, that.options);
}

Output:
     }
-    Network that = (Network) o;
+    final Network that = (Network) o;
     return Objects.equals(this.name, that.name) && Objects.equals(this.id, that.id) && Objects.equals(this.scope, that.scope) && Objects.equals(this.driver, that.driver) && Objects.equals(this.options, that.options);


Input:
public void run() {
    CheatSheetView view = ViewUtilities.showCheatSheetView();
    IWorkbenchPart activePart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
    if (null != view) {
        if (null != cheetSheetID) {
            view.setInput(cheetSheetID);
        } else {
            view.setInput(DQ_CHEATSHEET_START_ID);
        }
        CheatSheetUtils.getInstance().maxDisplayCheatSheetView(view);
    }
    if (null != activePart) {
        activePart.setFocus();
    }
}

Output:
         }
-        CheatSheetUtils.getInstance().maxDisplayCheatSheetView(view);
+        if (CheatSheetUtils.getInstance().isFirstTime()) {
+            CheatSheetUtils.getInstance().maxDisplayCheatSheetView(view);
+        }
     }


Input:
public Bitmap miniThumbBitmap() {
    return fullSizeBitmap(IImage.MINI_THUMB_TARGET_SIZE, IImage.UNCONSTRAINED);
}

Output:
 public Bitmap miniThumbBitmap() {
-    return fullSizeBitmap(IImage.MINI_THUMB_TARGET_SIZE, IImage.UNCONSTRAINED);
+    return fullSizeBitmap(IImage.MINI_THUMB_TARGET_SIZE, IImage.MINI_THUMB_MAX_NUM_PIXELS);
 }


Input:
public String toString() {
    return null;
}

Output:
 public String toString() {
-    return null;
+    return (new Gson()).toJson(this);
 }


Input:
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    if (!mActualHeightInitialized && mActualHeight == 0) {
        setActualHeight(getInitialHeight());
    }
}

Output:
     if (!mActualHeightInitialized && mActualHeight == 0) {
-        setActualHeight(getInitialHeight());
+        int initialHeight = getInitialHeight();
+        if (initialHeight != 0) {
+            setActualHeight(initialHeight);
+        }
     }


Input:
public void sendKeys(int... keys) {
    final int count = keys.length;
    final Instrumentation instrumentation = getInstrumentation();
    for (int i = 0; i < count; i++) {
        instrumentation.sendKeyDownUpSync(keys[i]);
    }
    instrumentation.waitForIdleSync();
}

Output:
     for (int i = 0; i < count; i++) {
-        instrumentation.sendKeyDownUpSync(keys[i]);
+        try {
+            instrumentation.sendKeyDownUpSync(keys[i]);
+        } catch (SecurityException e) {
+        }
     }


Input:
public Bundle getAssistContextExtras(int requestType) {
    PendingAssistExtras pae = enqueueAssistContext(requestType, null, null, null, null, UserHandle.getCallingUserId(), null, PENDING_ASSIST_EXTRAS_TIMEOUT);
    if (pae == null) {
        return null;
    }
    synchronized (pae) {
        while (!pae.haveResult) {
            try {
                pae.wait();
            } catch (InterruptedException e) {
            }
        }
    }
    synchronized (this) {
        buildAssistBundleLocked(pae, pae.result);
        mPendingAssistExtras.remove(pae);
        mHandler.removeCallbacks(pae);
    }
    return pae.extras;
}

Output:
         mPendingAssistExtras.remove(pae);
-        mHandler.removeCallbacks(pae);
+        mUiHandler.removeCallbacks(pae);
     }


Input:
public DSSDocument signDocument(byte[] signatureValue, Collection<DataFile> dataFiles) {
    logger.debug("String_Node_Str");
    SignatureValue dssSignatureValue = new SignatureValue(xAdESSignatureParameters.getSignatureAlgorithm(), signatureValue);
    DetachedContentCreator detachedContentCreator = new DetachedContentCreator().populate(dataFiles);
    DSSDocument dssDocument = detachedContentCreator.getFirstDetachedContent();
    logger.debug("String_Node_Str" + xAdESSignatureParameters.toString());
    DSSDocument signedDocument = service.signDocument(dssDocument, xAdESSignatureParameters, dssSignatureValue);
    logger.debug("String_Node_Str");
    DSSDocument correctedSignedDocument = surroundWithXadesXmlTag(signedDocument);
    return correctedSignedDocument;
}

Output:
     logger.debug("String_Node_Str" + xAdESSignatureParameters.toString());
-    DSSDocument signedDocument = service.signDocument(dssDocument, xAdESSignatureParameters, dssSignatureValue);
+    xAdESSignatureParameters.setDetachedContents(detachedContentCreator.getDetachedContentList());
+    DSSDocument signedDocument = xAdESService.signDocument(detachedContentList, xAdESSignatureParameters, dssSignatureValue);
     logger.debug("String_Node_Str");


Input:
public void testExecute_whenTaskNull() {
    IExecutorService service = client.getExecutorService(randomString());
    service.execute(null);
}

Output:
 public void testExecute_whenTaskNull() {
-    IExecutorService service = client.getExecutorService(randomString());
+    final IExecutorService service = client.getExecutorService(randomString());
     service.execute(null);


Input:
public List<NotificationAppView> getOverviewWeek(Date date) throws SQLException {
    DateFormat df = new SimpleDateFormat("String_Node_Str");
    String dateString = df.format(date);
    String rawQuery = "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME + "String_Node_Str" + NotificationItem.FIELD_TABLE_NAME + "String_Node_Str" + NotificationItem.FIELD_DATE + "String_Node_Str" + dateString + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME + "String_Node_Str" + "String_Node_Str" + Application.FIELD_PACKAGE_NAME + "String_Node_Str" + Application.FIELD_TABLE_NAME + "String_Node_Str" + Application.FIELD_IGNORE + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME;
    return this.getOverviewGeneric(rawQuery);
}

Output:
     DateFormat df = new SimpleDateFormat("String_Node_Str");
-    String dateString = df.format(date);
-    String rawQuery = "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME + "String_Node_Str" + NotificationItem.FIELD_TABLE_NAME + "String_Node_Str" + NotificationItem.FIELD_DATE + "String_Node_Str" + dateString + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME + "String_Node_Str" + "String_Node_Str" + Application.FIELD_PACKAGE_NAME + "String_Node_Str" + Application.FIELD_TABLE_NAME + "String_Node_Str" + Application.FIELD_IGNORE + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME;
+    String dateStringFirstDay = df.format(firstDayOfWeek);
+    String dateStringLastDay = df.format(lastDayOfWeek);
+    String rawQuery = "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME + "String_Node_Str" + NotificationItem.FIELD_TABLE_NAME + "String_Node_Str" + NotificationItem.FIELD_DATE + "String_Node_Str" + dateStringFirstDay + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_DATE + "String_Node_Str" + dateStringLastDay + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME + "String_Node_Str" + "String_Node_Str" + Application.FIELD_PACKAGE_NAME + "String_Node_Str" + Application.FIELD_TABLE_NAME + "String_Node_Str" + Application.FIELD_IGNORE + "String_Node_Str" + "String_Node_Str" + NotificationItem.FIELD_PACKAGE_NAME;
     return this.getOverviewGeneric(rawQuery);


Input:
public static void handleOnPageBreak(ITableContent content, ExecutionContext context) {
    ReportItemDesign gridDesign = (ReportItemDesign) content.getGenerateBy();
    if (!needOnPageBreak(gridDesign)) {
        return;
    }
    try {
        IGridInstance grid = new GridInstance(content, context);
        if (handleJS(grid, gridDesign.getOnPageBreak(), context).didRun())
            return;
        IGridEventHandler eh = getEventHandler(gridDesign, context);
        if (eh != null)
            eh.onPageBreak(grid, context.getReportContext());
    } catch (Exception e) {
        addException(context, e, gridDesign.getHandle());
    }
}

Output:
     try {
-        IGridInstance grid = new GridInstance(content, context);
+        IGridInstance grid = new GridInstance(content, context, RunningState.PAGEBREAK);
         if (handleJS(grid, gridDesign.getOnPageBreak(), context).didRun())


Input:
public void testGetChampionBasicData() throws Exception {
    try {
        handler.getBasicChampData(1).get(1, MINUTES);
    } catch (RequestException ex) {
        if (ex.getErrorType().code < 500 || ex.getErrorType().code > 599)
            throw ex;
    }
}

Output:
     } catch (RequestException ex) {
-        if (ex.getErrorType().code < 500 || ex.getErrorType().code > 599)
+        if (isNotServerside(ex))
             throw ex;


Input:
public long getDelay(TimeUnit unit) {
    if (executing) {
        return Long.MAX_VALUE;
    } else {
        return TimeUnit.MILLISECONDS.convert(nextRunTime - ClockWrapper.getAccurateTime(), unit);
    }
}

Output:
     } else {
-        return TimeUnit.MILLISECONDS.convert(nextRunTime - ClockWrapper.getAccurateTime(), unit);
+        return TimeUnit.MILLISECONDS.convert(getNextDelayInMillis(), unit);
     }


Input:
private <T> T parseArray(Mirror<T> me, ParameterizedType type) throws Exception {
    Type tt = null;
    boolean reurnAsList = true;
    List list = null;
    if (null == me) {
        list = new LinkedList();
    } else if (me.getType().isArray()) {
        list = new LinkedList();
        reurnAsList = false;
        tt = me.getType().getComponentType();
    } else if (List.class.isAssignableFrom(me.getType())) {
        reurnAsList = true;
        if (me.is(List.class))
            list = new LinkedList();
        else
            list = (List) me.born();
        tt = type.getActualTypeArguments()[0];
    } else {
        throw makeError(String.format("String_Node_Str", me.getType().getName()));
    }
    nextChar();
    skipCommentsAndBlank();
    while (cursor != -1 && cursor != ']') {
        Object o = parseFromCurrentLocation(tt);
        list.add(o);
        skipCommentsAndBlank();
        if (cursor == ']')
            break;
        if (cursor != ',')
            throw makeError("String_Node_Str");
        nextChar();
        skipCommentsAndBlank();
    }
    nextChar();
    if (reurnAsList)
        return (T) list;
    Object ary = Array.newInstance((Class<?>) tt, list.size());
    int i = 0;
    for (Iterator it = list.iterator(); it.hasNext(); ) Array.set(ary, i++, Castors.me().castTo(it.next(), (Class<?>) tt));
    return (T) ary;
}

Output:
             list = (List) me.born();
-        tt = type.getActualTypeArguments()[0];
+        if (type != null && type.getActualTypeArguments() != null)
+            tt = type.getActualTypeArguments()[0];
     } else {


Input:
public void mouseClicked(MouseEvent me) {
    int clickNum = me.getClickCount();
    GroupList list = (GroupList) me.getSource();
    if (me.getButton() == MouseEvent.BUTTON1) {
        if (2 == clickNum) {
            String groupName = "String_Node_Str";
            if (list.getSelectedIndex() != 0) {
                groupName = list.getSelectedValue().toString();
                if (groupName.indexOf("String_Node_Str") != -1) {
                    groupName = groupName.substring(groupName.indexOf("String_Node_Str") + 1, groupName.length()).trim();
                }
            }
            if (mainWindow != null && groupName.equals(ComponentConst.groupName)) {
                window.dispose();
                return;
            }
            if (mainWindow != null) {
                mainWindow.saveTaskGroupData();
                mainWindow.dispose();
            }
            ComponentConst.groupName = groupName;
            ComponentConst.changeDataPath(groupName);
            ComponentConst.changeDataXmlPath();
            window.dispose();
            if (mainWindow != null) {
                SettingDom4jDbTemplate.updateDom();
                TaskDom4jDbTemplate.updateDom();
                PictureDom4jDbTemplate.updateDom();
            }
            new InitWindow();
        }
    } else if (me.getButton() == MouseEvent.BUTTON3) {
        int rowIndex = list.locationToIndex(me.getPoint());
        list.getSelectionModel().setSelectionInterval(rowIndex, rowIndex);
        if (popupMenu == null) {
            popupMenu = new AJPopupMenu(deleteMenu);
        }
        popupMenu.show(list, me.getPoint().x, me.getPoint().y);
    }
}

Output:
             }
-            new InitWindow();
+            SwingUtilities.invokeLater(new Runnable() {
+                public void run() {
+                    new InitWindow();
+                }
+            });
         }


Input:
public ListenableFuture<O> deploy(Id.Namespace id, String appId, I input) throws Exception {
    Pipeline<O> pipeline = pipelineFactory.getPipeline();
    pipeline.addLast(new LocalArchiveLoaderStage(store, configuration, id, appId));
    pipeline.addLast(new VerificationStage(store, datasetFramework, adapterService));
    pipeline.addLast(new DeployDatasetModulesStage(configuration, datasetFramework, inMemoryDatasetFramework));
    pipeline.addLast(new CreateDatasetInstancesStage(configuration, datasetFramework));
    pipeline.addLast(new CreateStreamsStage(id, streamAdmin, exploreFacade, exploreEnabled));
    pipeline.addLast(new DeletedProgramHandlerStage(store, programTerminator, streamConsumerFactory, queueAdmin, discoveryServiceClient));
    pipeline.addLast(new ProgramGenerationStage(configuration, locationFactory));
    pipeline.addLast(new ApplicationRegistrationStage(store));
    pipeline.addLast(new CreateSchedulesStage(scheduler));
    pipeline.setFinally(new DeployCleanupStage());
    return pipeline.execute(input);
}

Output:
     pipeline.addLast(new DeletedProgramHandlerStage(store, programTerminator, streamConsumerFactory, queueAdmin, discoveryServiceClient));
-    pipeline.addLast(new ProgramGenerationStage(configuration, locationFactory));
+    pipeline.addLast(new ProgramGenerationStage(configuration, namespacedLocationFactory));
     pipeline.addLast(new ApplicationRegistrationStage(store));


Input:
public SortedSet<OWLIndividual> getIndividualsImplFast(OWLClassExpression description) throws ReasoningMethodUnsupportedException {
    if (description.isOWLThing()) {
        return (TreeSet<OWLIndividual>) individuals.clone();
    } else if (description.isOWLNothing()) {
        return new TreeSet<>();
    } else if (!description.isAnonymous()) {
        if (classInstancesPos.containsKey(description.asOWLClass())) {
            return (TreeSet<OWLIndividual>) classInstancesPos.get(description).clone();
        } else {
            return new TreeSet<>();
        }
    } else if (description instanceof OWLObjectComplementOf) {
        OWLClassExpression operand = ((OWLObjectComplementOf) description).getOperand();
        if (!operand.isAnonymous()) {
            if (isDefaultNegation()) {
                if (precomputeNegations) {
                    return (TreeSet<OWLIndividual>) classInstancesNeg.get(operand).clone();
                }
                SetView<OWLIndividual> diff = Sets.difference(individuals, classInstancesPos.get(operand));
                return new TreeSet<>(diff);
            } else {
                return (TreeSet<OWLIndividual>) classInstancesNeg.get(operand).clone();
            }
        }
        return new TreeSet<>(Sets.difference(individuals, getIndividualsImpl(operand)));
    } else if (description instanceof OWLObjectUnionOf) {
        SortedSet<OWLIndividual> ret = new TreeSet<>();
        for (OWLClassExpression operand : ((OWLObjectUnionOf) description).getOperands()) {
            ret.addAll(getIndividualsImpl(operand));
        }
        return ret;
    } else if (description instanceof OWLObjectIntersectionOf) {
        Iterator<OWLClassExpression> iterator = ((OWLObjectIntersectionOf) description).getOperands().iterator();
        SortedSet<OWLIndividual> ret = getIndividualsImpl(iterator.next());
        while (iterator.hasNext()) {
            ret.retainAll(getIndividualsImpl(iterator.next()));
        }
        return ret;
    } else if (description instanceof OWLObjectSomeValuesFrom) {
        OWLObjectPropertyExpression property = ((OWLObjectSomeValuesFrom) description).getProperty();
        OWLClassExpression filler = ((OWLObjectSomeValuesFrom) description).getFiller();
        SortedSet<OWLIndividual> targetSet = getIndividualsImpl(filler);
        Map<OWLIndividual, ? extends Collection<OWLIndividual>> mapping = getTargetIndividuals(property);
        return mapping.entrySet().stream().filter(e -> e.getValue().stream().anyMatch(targetSet::contains)).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
    } else if (description instanceof OWLObjectAllValuesFrom) {
        OWLObjectPropertyExpression property = ((OWLObjectAllValuesFrom) description).getProperty();
        OWLClassExpression filler = ((OWLObjectAllValuesFrom) description).getFiller();
        SortedSet<OWLIndividual> targetSet = getIndividualsImpl(filler);
        Map<OWLIndividual, ? extends Collection<OWLIndividual>> mapping = getTargetIndividuals(property);
        SortedSet<OWLIndividual> returnSet = (SortedSet<OWLIndividual>) individuals.clone();
        mapping.entrySet().stream().filter(e -> e.getValue().stream().anyMatch(ind -> !targetSet.contains(ind))).forEach(e -> returnSet.remove(e.getKey()));
        return returnSet;
    } else if (description instanceof OWLObjectMinCardinality) {
        OWLObjectPropertyExpression property = ((OWLObjectMinCardinality) description).getProperty();
        OWLClassExpression filler = ((OWLObjectMinCardinality) description).getFiller();
        SortedSet<OWLIndividual> targetSet = getIndividualsImpl(filler);
        Map<OWLIndividual, ? extends Collection<OWLIndividual>> mapping = getTargetIndividuals(property);
        SortedSet<OWLIndividual> returnSet = new TreeSet<>();
        int number = ((OWLObjectMinCardinality) description).getCardinality();
        for (Entry<OWLIndividual, ? extends Collection<OWLIndividual>> entry : mapping.entrySet()) {
            int nrOfFillers = 0;
            int index = 0;
            Collection<OWLIndividual> inds = entry.getValue();
            if (inds.size() < number) {
                continue;
            }
            for (OWLIndividual ind : inds) {
                if (nrOfFillers >= number) {
                    returnSet.add(entry.getKey());
                    break;
                }
                if (inds.size() - index < number) {
                    break;
                }
                if (targetSet.contains(ind)) {
                    nrOfFillers++;
                }
                index++;
            }
        }
        return returnSet;
    } else if (description instanceof OWLObjectMaxCardinality) {
        OWLObjectPropertyExpression property = ((OWLObjectMaxCardinality) description).getProperty();
        OWLClassExpression filler = ((OWLObjectMaxCardinality) description).getFiller();
        int number = ((OWLObjectMaxCardinality) description).getCardinality();
        SortedSet<OWLIndividual> targetSet = getIndividualsImpl(filler);
        Map<OWLIndividual, ? extends Collection<OWLIndividual>> mapping = getTargetIndividuals(property);
        SortedSet<OWLIndividual> returnSet = (SortedSet<OWLIndividual>) individuals.clone();
        for (Entry<OWLIndividual, ? extends Collection<OWLIndividual>> entry : mapping.entrySet()) {
            int nrOfFillers = 0;
            int index = 0;
            Collection<OWLIndividual> inds = entry.getValue();
            if (number < inds.size()) {
                returnSet.add(entry.getKey());
                continue;
            }
            for (OWLIndividual ind : inds) {
                if (nrOfFillers >= number) {
                    break;
                }
                if (inds.size() - index < number) {
                    returnSet.add(entry.getKey());
                    break;
                }
                if (targetSet.contains(ind)) {
                    nrOfFillers++;
                }
                index++;
            }
        }
        return returnSet;
    } else if (description instanceof OWLObjectHasValue) {
        OWLObjectPropertyExpression property = ((OWLObjectHasValue) description).getProperty();
        OWLIndividual value = ((OWLObjectHasValue) description).getFiller();
        Map<OWLIndividual, ? extends Collection<OWLIndividual>> mapping = property.isAnonymous() ? Multimaps.invertFrom(MapUtils.createSortedMultiMap(opPos.get(property.getNamedProperty())), TreeMultimap.create()).asMap() : opPos.get(property.getNamedProperty());
        return mapping.entrySet().stream().filter(e -> e.getValue().contains(value)).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
    } else if (description instanceof OWLDataSomeValuesFrom) {
        OWLDataPropertyExpression property = ((OWLDataSomeValuesFrom) description).getProperty();
        OWLDataRange filler = ((OWLDataSomeValuesFrom) description).getFiller();
        if (filler.isDatatype()) {
            return new TreeSet<>(dpPos.get(property).keySet());
        } else if (filler instanceof OWLDataIntersectionOf) {
            return ((OWLDataIntersectionOf) filler).getOperands().stream().map(dr -> getIndividuals(df.getOWLDataSomeValuesFrom(property, dr))).reduce((s1, s2) -> {
                s1.retainAll(s2);
                return s1;
            }).orElse(new TreeSet<>());
        } else if (filler instanceof OWLDataUnionOf) {
            return ((OWLDataUnionOf) filler).getOperands().stream().map(dr -> getIndividuals(df.getOWLDataSomeValuesFrom(property, dr))).reduce((s1, s2) -> {
                s1.addAll(s2);
                return s1;
            }).orElse(new TreeSet<>());
        } else if (filler instanceof OWLDataComplementOf) {
            return new TreeSet<>(Sets.difference(individuals, getIndividualsImpl(df.getOWLDataSomeValuesFrom(property, ((OWLDataComplementOf) filler).getDataRange()))));
        } else if (filler instanceof OWLDatatypeRestriction) {
            OWLDatatype datatype = ((OWLDatatypeRestriction) filler).getDatatype();
            Set<OWLFacetRestriction> facetRestrictions = ((OWLDatatypeRestriction) filler).getFacetRestrictions();
            if (OWLAPIUtils.floatDatatypes.contains(datatype)) {
                double min = facetRestrictions.stream().filter(fr -> fr.getFacet() == OWLFacet.MIN_INCLUSIVE).map(fr -> fr.getFacetValue().isDouble() ? fr.getFacetValue().parseDouble() : (double) fr.getFacetValue().parseFloat()).findAny().orElse(-Double.MAX_VALUE);
                double max = facetRestrictions.stream().filter(fr -> fr.getFacet() == OWLFacet.MAX_INCLUSIVE).map(fr -> fr.getFacetValue().isDouble() ? fr.getFacetValue().parseDouble() : (double) fr.getFacetValue().parseFloat()).findAny().orElse(Double.MAX_VALUE);
                return dd.getOrDefault(property, new HashMap<>()).entrySet().stream().filter(e -> {
                    SortedSet<Double> values = e.getValue();
                    if (values.last() < min || values.first() > max) {
                        return false;
                    }
                    return values.stream().anyMatch(val -> val >= min && val <= max);
                }).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
            } else if (OWLAPIUtils.intDatatypes.contains(datatype)) {
                int min = facetRestrictions.stream().filter(fr -> fr.getFacet() == OWLFacet.MIN_INCLUSIVE).map(fr -> fr.getFacetValue().parseInteger()).findAny().orElse(-Integer.MAX_VALUE);
                int max = facetRestrictions.stream().filter(fr -> fr.getFacet() == OWLFacet.MAX_INCLUSIVE).map(fr -> fr.getFacetValue().parseInteger()).findAny().orElse(Integer.MAX_VALUE);
                return id.getOrDefault(property, new HashMap<>()).entrySet().stream().filter(e -> {
                    SortedSet<Integer> values = e.getValue();
                    if (values.last() < min || values.first() > max) {
                        return false;
                    }
                    return values.stream().anyMatch(val -> val >= min && val <= max);
                }).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
            } else if (OWLAPIUtils.dtDatatypes.contains(datatype)) {
                OWLLiteral min = facetRestrictions.stream().filter(fr -> fr.getFacet() == OWLFacet.MIN_INCLUSIVE).map(OWLFacetRestriction::getFacetValue).findAny().orElse(null);
                OWLLiteral max = facetRestrictions.stream().filter(fr -> fr.getFacet() == OWLFacet.MAX_INCLUSIVE).map(OWLFacetRestriction::getFacetValue).findAny().orElse(null);
                return dpPos.getOrDefault(property, new HashMap<>()).entrySet().stream().filter(e -> e.getValue().stream().anyMatch(val -> OWLAPIUtils.inRange(val, min, max))).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
            }
        } else if (filler.getDataRangeType() == DataRangeType.DATA_ONE_OF) {
            OWLDataOneOf dataOneOf = (OWLDataOneOf) filler;
            Set<OWLLiteral> values = dataOneOf.getValues();
            return dpPos.getOrDefault(property, new HashMap<>()).entrySet().stream().filter(e -> !Sets.intersection(e.getValue(), values).isEmpty()).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
        }
    } else if (description instanceof OWLDataHasValue) {
        OWLDataPropertyExpression property = ((OWLDataHasValue) description).getProperty();
        OWLLiteral value = ((OWLDataHasValue) description).getFiller();
        return dpPos.getOrDefault(property, new HashMap<>()).entrySet().stream().filter(e -> e.getValue().contains(value)).map(Entry::getKey).collect(Collectors.toCollection(TreeSet::new));
    } else if (description instanceof OWLObjectOneOf) {
        return new TreeSet(((OWLObjectOneOf) description).getIndividuals());
    }
    throw new ReasoningMethodUnsupportedException("String_Node_Str" + description + "String_Node_Str");
}

Output:
             int index = 0;
-            Collection<OWLIndividual> inds = entry.getValue();
-            if (number < inds.size()) {
-                returnSet.add(entry.getKey());
+            Collection<OWLIndividual> fillers = entry.getValue();
+            if (fillers.size() <= number) {
                 continue;


Input:
private String getSheetDefaultRules() {
    Sheet sheet = getSelectedSheet();
    HeaderPositionHelper colHelper = this.getColumnPositionHelper(sheet);
    HeaderPositionHelper rowHelper = this.getRowPositionHelper(sheet);
    MergeMatrixHelper mmhelper = this.getMergeMatrixHelper(sheet);
    boolean hiderow = isHiderowhead();
    boolean hidecol = isHidecolumnhead();
    boolean showgrid = sheet.isDisplayGridlines();
    int th = hidecol ? 1 : this.getTopheadheight();
    int lw = hiderow ? 1 : this.getLeftheadwidth();
    int cp = this._cellpadding;
    int rh = this.getRowheight();
    int cw = this.getColumnwidth();
    int lh = 20;
    if (lh > rh) {
        lh = rh;
    }
    String sheetid = getUuid();
    String name = "String_Node_Str" + sheetid;
    int cellwidth;
    int cellheight;
    Execution exe = Executions.getCurrent();
    boolean isGecko = exe.isGecko();
    boolean isIE = exe.isExplorer();
    if (isGecko) {
        cellwidth = cw;
        cellheight = rh;
    } else {
        cellwidth = cw - 2 * cp - 1;
        cellheight = rh - 1;
    }
    int celltextwidth = cw - 2 * cp - 1;
    StringBuffer sb = new StringBuffer();
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(th).append("String_Node_Str");
    sb.append("String_Node_Str").append(lw).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(rh).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append("String_Node_Str" + cp + "String_Node_Str" + cp + "String_Node_Str");
    sb.append("String_Node_Str").append(cellheight).append("String_Node_Str");
    sb.append("String_Node_Str").append(cellwidth).append("String_Node_Str");
    if (!showgrid) {
        sb.append("String_Node_Str").append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(celltextwidth).append("String_Node_Str");
    sb.append("String_Node_Str").append(cellheight).append("String_Node_Str");
    sb.append("String_Node_Str");
    int toph = th - 1;
    int topheadh = (isGecko) ? toph : toph - 1;
    int cornertoph = th - 1;
    int fzr = getRowfreeze();
    int fzc = getColumnfreeze();
    if (fzr > -1) {
        toph = toph + rowHelper.getStartPixel(fzr + 1);
    }
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(lw).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzr > -1 ? toph - 1 : toph).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(toph).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(topheadh).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(lw).append("String_Node_Str");
    sb.append("String_Node_Str").append(cornertoph).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append("String_Node_Str" + cp + "String_Node_Str" + cp + "String_Node_Str");
    sb.append("String_Node_Str").append(topheadh).append("String_Node_Str");
    sb.append("String_Node_Str").append(cellwidth).append("String_Node_Str");
    sb.append("String_Node_Str").append(topheadh).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(celltextwidth).append("String_Node_Str");
    sb.append("String_Node_Str");
    int leftw = lw - 1;
    int leftheadw = leftw;
    int leftblockleft = leftw;
    if (fzc > -1) {
        leftw = leftw + colHelper.getStartPixel(fzc + 1);
    }
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(th).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzc > -1 ? leftw - 1 : leftw).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(leftw).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(leftheadw).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(leftblockleft).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(th).append("String_Node_Str");
    sb.append("String_Node_Str").append(leftheadw).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(rh - 1).append("String_Node_Str");
    sb.append("String_Node_Str").append(rh - 1).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzc > -1 ? leftw : leftw + 1).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzr > -1 ? toph : toph + 1).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(lw - 2).append("String_Node_Str");
    sb.append("String_Node_Str").append(th - 2).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(lw).append("String_Node_Str");
    sb.append("String_Node_Str").append(th).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(th).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(th).append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzr > -1 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzr > -1 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzc > -1 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(name).append("String_Node_Str");
    sb.append("String_Node_Str").append(fzc > -1 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str");
    sb.append("String_Node_Str");
    boolean transparentBorder = false;
    if (transparentBorder) {
        sb.append(name).append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        if (isIE) {
            String color_to_transparent = "String_Node_Str";
            sb.append("String_Node_Str" + color_to_transparent + "String_Node_Str");
            sb.append("String_Node_Str" + color_to_transparent + "String_Node_Str");
        }
        sb.append("String_Node_Str");
    }
    List<HeaderPositionInfo> infos = colHelper.getInfos();
    for (HeaderPositionInfo info : infos) {
        boolean hidden = info.hidden;
        int index = info.index;
        int width = hidden ? 0 : info.size;
        int cid = info.id;
        celltextwidth = width - 2 * cp - 1;
        if (celltextwidth < 0)
            celltextwidth = 0;
        if (!isGecko) {
            cellwidth = celltextwidth;
        } else {
            cellwidth = width;
        }
        if (width <= 0) {
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        } else {
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str").append(cellwidth).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str").append(celltextwidth).append("String_Node_Str");
            sb.append("String_Node_Str");
        }
    }
    infos = rowHelper.getInfos();
    for (HeaderPositionInfo info : infos) {
        boolean hidden = info.hidden;
        int index = info.index;
        int height = hidden ? 0 : info.size;
        int cid = info.id;
        cellheight = height;
        if (!isGecko) {
            cellheight = height - 1;
        }
        if (height <= 0) {
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        } else {
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str").append(height).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str").append(cellheight).append("String_Node_Str");
            sb.append("String_Node_Str");
            int h2 = (height < 1) ? 0 : height - 1;
            sb.append(name).append("String_Node_Str").append(cid).append("String_Node_Str");
            sb.append("String_Node_Str").append(h2).append("String_Node_Str");
            sb.append("String_Node_Str").append(h2).append("String_Node_Str");
            sb.append("String_Node_Str");
        }
    }
    sb.append("String_Node_Str");
    List ranges = mmhelper.getRanges();
    Iterator iter = ranges.iterator();
    while (iter.hasNext()) {
        MergedRect block = (MergedRect) iter.next();
        int left = block.getLeft();
        int right = block.getRight();
        int width = 0;
        for (int i = left; i <= right; i++) {
            final HeaderPositionInfo info = colHelper.getInfo(i);
            final boolean hidden = info.hidden;
            final int colSize = hidden ? 0 : info.size;
            width += colSize;
        }
        if (width <= 0) {
            sb.append(name).append("String_Node_Str").append(block.getId()).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(name).append("String_Node_Str").append(block.getId());
            sb.append("String_Node_Str").append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        } else {
            celltextwidth = width - 2 * cp - 1;
            if (!isGecko) {
                cellwidth = celltextwidth;
            } else {
                cellwidth = width;
            }
            sb.append(name).append("String_Node_Str").append(block.getId()).append("String_Node_Str");
            sb.append("String_Node_Str").append(cellwidth).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(name).append("String_Node_Str").append(block.getId());
            sb.append("String_Node_Str").append("String_Node_Str");
            sb.append("String_Node_Str").append(celltextwidth).append("String_Node_Str");
            sb.append("String_Node_Str");
        }
    }
    sb.append("String_Node_Str");
    return sb.toString();
}

Output:
             final HeaderPositionInfo info = colHelper.getInfo(i);
-            final boolean hidden = info.hidden;
-            final int colSize = hidden ? 0 : info.size;
-            width += colSize;
+            if (info != null) {
+                final boolean hidden = info.hidden;
+                final int colSize = hidden ? 0 : info.size;
+                width += colSize;
+            } else {
+                width += defaultSize;
+            }
         }


Input:
protected void setupRenderOption() {
    String format = RenderOption.OUTPUT_FORMAT_HTML;
    ;
    if (renderOptions != null) {
        format = renderOptions.getOutputFormat();
        if (format == null || format.length() == 0) {
            format = RenderOption.OUTPUT_FORMAT_HTML;
            renderOptions.setOutputFormat(format);
        }
    }
    Map appContext = executionContext.getAppContext();
    if (IRenderOption.OUTPUT_FORMAT_PDF.equals(format)) {
        Object renderContext = appContext.get(EngineConstants.APPCONTEXT_PDF_RENDER_CONTEXT);
        if (renderContext instanceof PDFRenderContext) {
            PDFRenderContext pdfContext = (PDFRenderContext) renderContext;
            mergeOption(renderOptions, PDFRenderOption.BASE_URL, pdfContext.getBaseURL());
            mergeOption(renderOptions, PDFRenderOption.FONT_DIRECTORY, pdfContext.getFontDirectory());
            mergeOption(renderOptions, PDFRenderOption.SUPPORTED_IMAGE_FORMATS, pdfContext.getSupportedImageFormats());
            mergeOption(renderOptions, PDFRenderOption.IS_EMBEDDED_FONT, new Boolean(pdfContext.isEmbededFont()));
        }
    } else {
        Object renderContext = appContext.get(EngineConstants.APPCONTEXT_HTML_RENDER_CONTEXT);
        if (renderContext instanceof HTMLRenderContext) {
            HTMLRenderContext htmlContext = (HTMLRenderContext) renderContext;
            mergeOption(renderOptions, HTMLRenderOption.BASE_IMAGE_URL, htmlContext.getBaseImageURL());
            mergeOption(renderOptions, HTMLRenderOption.BASE_URL, htmlContext.getBaseURL());
            mergeOption(renderOptions, HTMLRenderOption.IMAGE_DIRECTROY, htmlContext.getImageDirectory());
            mergeOption(renderOptions, HTMLRenderOption.SUPPORTED_IMAGE_FORMATS, htmlContext.getSupportedImageFormats());
        }
    }
    HashMap options = new HashMap();
    HashMap configs = engine.getConfig().getEmitterConfigs();
    IRenderOption defaultOptions = (IRenderOption) configs.get(IEngineConfig.DEFAULT_RENDER_OPTION);
    if (defaultOptions == null) {
        defaultOptions = (IRenderOption) configs.get(IRenderOption.OUTPUT_FORMAT_HTML);
    }
    if (defaultOptions != null) {
        options.putAll(defaultOptions.getOptions());
    }
    IRenderOption formatOptions = (IRenderOption) configs.get(format);
    if (formatOptions != null) {
        options.putAll(formatOptions.getOptions());
    }
    if (emitterID != null) {
        IRenderOption emitterOptions = (IRenderOption) configs.get(emitterID);
        if (emitterOptions != null) {
            options.putAll(emitterOptions.getOptions());
        }
    }
    if (renderOptions != null) {
        options.putAll(renderOptions.getOptions());
    }
    IRenderOption allOptions = new RenderOption(options);
    executionContext.setRenderOption(allOptions);
    if (IRenderOption.OUTPUT_FORMAT_PDF.equals(format)) {
        Object renderContext = appContext.get(EngineConstants.APPCONTEXT_PDF_RENDER_CONTEXT);
        if (renderContext == null) {
            PDFRenderOption pdfOptions = new PDFRenderOption(allOptions);
            PDFRenderContext pdfContext = new PDFRenderContext();
            pdfContext.setBaseURL(pdfOptions.getBaseURL());
            pdfContext.setEmbededFont(pdfOptions.isEmbededFont());
            pdfContext.setFontDirectory(pdfOptions.getFontDirectory());
            pdfContext.setSupportedImageFormats(pdfOptions.getSupportedImageFormats());
            appContext.put(EngineConstants.APPCONTEXT_PDF_RENDER_CONTEXT, pdfContext);
        }
    } else {
        Object renderContext = appContext.get(EngineConstants.APPCONTEXT_HTML_RENDER_CONTEXT);
        if (renderContext == null) {
            HTMLRenderContext htmlContext = new HTMLRenderContext();
            HTMLRenderOption htmlOptions = new HTMLRenderOption(allOptions);
            htmlContext.setBaseImageURL(htmlOptions.getBaseImageURL());
            htmlContext.setBaseURL(htmlOptions.getBaseURL());
            htmlContext.setImageDirectory(htmlOptions.getImageDirectory());
            htmlContext.setSupportedImageFormats(htmlOptions.getSupportedImageFormats());
            htmlContext.SetRenderOption(allOptions);
            appContext.put(EngineConstants.APPCONTEXT_HTML_RENDER_CONTEXT, htmlContext);
        }
    }
}

Output:
         format = renderOptions.getOutputFormat();
-        if (format == null || format.length() == 0) {
-            format = RenderOption.OUTPUT_FORMAT_HTML;
-            renderOptions.setOutputFormat(format);
+        emitterID = renderOptions.getEmitterID();
+        if (emitterID != null) {
+            boolean invalidEmitterID = extManager.isInvalidEmitterID(emitterID);
+            if (!invalidEmitterID) {
+                log.log(Level.SEVERE, MessageConstants.INVALID_EMITTER_ID, emitterID);
+                throw new EngineException(MessageConstants.INVALID_EMITTER_ID, emitterID);
+            }
+        } else {
+            if (format == null) {
+                format = RenderOption.OUTPUT_FORMAT_HTML;
+                emitterID = RenderOption.OUTPUT_EMITTERID_HTML;
+            } else {
+                boolean supportedFormat = extManager.isSupportedFormat(format);
+                if (!supportedFormat) {
+                    log.log(Level.SEVERE, MessageConstants.FORMAT_NOT_SUPPORTED_EXCEPTION, format);
+                    throw new UnsupportedFormatException(MessageConstants.FORMAT_NOT_SUPPORTED_EXCEPTION, format);
+                } else {
+                    emitterID = extManager.getEmitterID(format);
+                }
+            }
         }


Input:
public void saveChunkData(TridentChunk chunk) throws IOException, NBTException {
    ByteArrayOutputStream nbtStream = new ByteArrayOutputStream();
    new NBTEncoder(new DataOutputStream(nbtStream)).encode(chunk.asNbt());
    byte[] uncompressed = nbtStream.toByteArray();
    Deflater deflater = new Deflater();
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    deflater.setInput(uncompressed);
    deflater.finish();
    while (!deflater.finished()) {
        int bytes = deflater.deflate(buffer);
        os.write(buffer, 0, bytes);
    }
    byte[] compressed = os.toByteArray();
    int actualLength = compressed.length + 1;
    int sectorLength = IntMath.divide(actualLength, SectorStorage.SECTOR_LENGTH, RoundingMode.CEILING);
    int oldSectorLength = this.sectors.dataSectors(chunk);
    if (sectorLength < oldSectorLength) {
        this.sectors.setDataSectors(chunk, sectors.rawOffset(chunk) | sectorLength);
        this.sectors.freeSectors(this.sectors.sectorOffset(chunk) + sectorLength - 1, oldSectorLength - sectorLength);
    } else if (sectorLength > oldSectorLength) {
        this.sectors.setDataSectors(chunk, sectors.rawOffset(chunk) | sectorLength);
        this.sectors.freeSectors(this.sectors.sectorOffset(chunk), oldSectorLength);
        this.sectors.setSectorOffset(chunk, this.sectors.findFreeSectors(sectorLength));
    }
    this.sectors.addSectors(this.sectors.sectorOffset(chunk), this.sectors.dataSectors(chunk));
    synchronized (this.readWriteLock) {
        RandomAccessFile access = new RandomAccessFile(this.path.toFile(), "String_Node_Str");
        long dataLoc = (long) this.sectors.dataLoc(chunk);
        access.seek(dataLoc);
        access.writeInt(actualLength);
        access.write((int) (byte) 2);
        access.write(compressed);
        int paddingNeeded = actualLength % SectorStorage.SECTOR_LENGTH;
        if (paddingNeeded != 0) {
            byte[] padding = new byte[paddingNeeded];
            access.write(padding);
        }
        access.seek((long) (this.sectors.offsetLoc(chunk)));
        access.write(this.sectors.rawOffset(chunk));
        this.packFile(access);
        access.close();
    }
}

Output:
     ByteArrayOutputStream nbtStream = new ByteArrayOutputStream();
-    new NBTEncoder(new DataOutputStream(nbtStream)).encode(chunk.asNbt());
+    new NBTEncoder(new DataOutputStream(nbtStream)).encode(tag);
     byte[] uncompressed = nbtStream.toByteArray();


Input:
private int deleteN(String kind, Key rootJobKey, int n) {
    if (n < 1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    logger.info("String_Node_Str" + n + "String_Node_Str" + kind + "String_Node_Str" + rootJobKey);
    List<Key> keyList = new LinkedList<>();
    FetchOptions fetchOptions = FetchOptions.Builder.withLimit(n).chunkSize(500);
    for (Entity entity : queryAll(kind, rootJobKey, true, fetchOptions)) {
        keyList.add(entity.getKey());
    }
    dataStore.delete(keyList);
    return keyList.size();
}

Output:
     }
-    dataStore.delete(keyList);
+    if (!keyList.isEmpty()) {
+        dataStore.delete(keyList);
+    }
     return keyList.size();


Input:
protected TextTemplate parseTemplate(String text) throws BirtException {
    SoftReference templateRef = (SoftReference) templates.get(text);
    TextTemplate template = null;
    if (templateRef != null) {
        template = (TextTemplate) templateRef.get();
        if (template != null) {
            return template;
        }
    }
    try {
        template = new org.eclipse.birt.core.template.TemplateParser().parse(text);
        templateRef = new SoftReference(template);
        templates.put(text, templateRef);
    } catch (Exception ex) {
        throw new EngineException(ex.getLocalizedMessage(), ex);
    }
    return template;
}

Output:
         templates.put(text, templateRef);
-    } catch (Exception ex) {
+    } catch (Throwable ex) {
         throw new EngineException(ex.getLocalizedMessage(), ex);


Input:
public static void main(String[] argv) throws ConnectionError, ContentError, RuntimeError, ParseError, ParseException, BuildException, XMLException {
    if (argv.length == 0) {
        System.err.println("String_Node_Str");
        showUsage();
        System.exit(1);
    }
    if (argv.length == 1 && (argv[0].equals("String_Node_Str") || argv[0].equals("String_Node_Str") || argv[0].equals("String_Node_Str"))) {
        showUsage();
        System.exit(0);
    }
    HashMap<String, String> argMap = parseArguments(argv);
    String typePath = null;
    String modelName = null;
    boolean verbose = false;
    if (argMap.containsKey("String_Node_Str")) {
        typePath = argMap.get("String_Node_Str");
        argMap.remove("String_Node_Str");
    }
    if (argMap.containsKey("String_Node_Str")) {
        modelName = argMap.get("String_Node_Str");
        argMap.remove("String_Node_Str");
    }
    if (modelName == null) {
        showUsage();
        System.exit(1);
    }
    File simFile = new File(modelName);
    if (!simFile.exists()) {
        E.error("String_Node_Str" + simFile.getAbsolutePath());
        System.exit(1);
    }
    FileInclusionReader fir = new FileInclusionReader(simFile);
    if (typePath != null) {
        fir.addSearchPaths(typePath);
    }
    Sim sim = new Sim(fir.read());
    sim.readModel();
    sim.build();
    ControlPanel.getInstance().registerSimulation(sim, simFile);
    StateInstance si = sim.getRootState(false);
    StateType st = sim.getTargetBehavior();
    if (verbose) {
        System.out.println("String_Node_Str");
        System.out.println(st.getSummary("String_Node_Str", "String_Node_Str") + "String_Node_Str");
        System.out.println("String_Node_Str");
        System.out.println(si.getSummary("String_Node_Str", "String_Node_Str") + "String_Node_Str");
    }
    boolean doRun = true;
    if (doRun) {
        sim.run();
        E.info("String_Node_Str");
    }
    IOUtil.saveReportAndTimesFile(sim);
}

Output:
     File simFile = new File(modelName);
-    if (!simFile.exists()) {
-        E.error("String_Node_Str" + simFile.getAbsolutePath());
-        System.exit(1);
-    }
-    FileInclusionReader fir = new FileInclusionReader(simFile);
-    if (typePath != null) {
-        fir.addSearchPaths(typePath);
-    }
-    Sim sim = new Sim(fir.read());
-    sim.readModel();
-    sim.build();
-    ControlPanel.getInstance().registerSimulation(sim, simFile);
+    Sim sim = cp.initialise(simFile);
     StateInstance si = sim.getRootState(false);


Input:
public boolean containsPlainVariable(PlainVariable variable) {
    if (this.name.equals(variable.name))
        return true;
    return rightPart.containsPlainVariable(variable);
}

Output:
 public boolean containsPlainVariable(PlainVariable variable) {
-    if (this.name.equals(variable.name))
+    if (this.name.equals(variable.name) || this.name.resolveBinding().isEqualTo(variable.name.resolveBinding()))
         return true;


Input:
public void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    if (debug)
        Log.d(TAG, "String_Node_Str");
    if (!CategoryList.isSignedIn()) {
        finish();
    }
    restartTimerIntent = new Intent(CryptoIntents.ACTION_RESTART_TIMER);
    setContentView(R.layout.pass_list);
    CategoryId = icicle != null ? icicle.getLong(CategoryList.KEY_ID) : null;
    if (CategoryId == null) {
        Bundle extras = getIntent().getExtras();
        CategoryId = extras != null ? extras.getLong(CategoryList.KEY_ID) : null;
    }
    if (CategoryId < 1) {
        finish();
    }
    String categoryName = Passwords.getCategoryEntry(CategoryId).plainName;
    String title = getResources().getString(R.string.app_name) + "String_Node_Str" + getResources().getString(R.string.passwords) + "String_Node_Str" + categoryName;
    setTitle(title);
    fillData();
    final ListView list = getListView();
    list.setFocusable(true);
    list.setOnCreateContextMenuListener(this);
    registerForContextMenu(list);
    sendBroadcast(restartTimerIntent);
}

Output:
         Log.d(TAG, "String_Node_Str");
-    if (!CategoryList.isSignedIn()) {
+    if (CategoryList.isSignedIn() == false) {
         finish();


Input:
public Object get(Data dataKey) {
    checkIfLoaded();
    Record record = records.get(dataKey);
    Object value = null;
    if (record == null) {
        if (mapContainer.getStore() != null) {
            value = mapContainer.getStore().load(mapService.toObject(dataKey));
            if (value != null) {
                record = mapService.createRecord(name, dataKey, value, -1);
                records.put(dataKey, record);
                saveIndex(record);
                updateSizeEstimator(calculateRecordSize(record));
            }
        }
    } else {
        accessRecord(record);
        value = record.getValue();
    }
    value = mapService.interceptGet(name, value);
    return value;
}

Output:
             if (value != null) {
-                record = mapService.createRecord(name, dataKey, value, -1);
+                record = mapService.createRecord(name, dataKey, value, DEFAULT_TTL);
                 records.put(dataKey, record);


Input:
public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append("String_Node_Str" + molId + "String_Node_Str" + molName + "String_Node_Str");
    try {
        Class c = Class.forName("String_Node_Str");
        Method[] methods = c.getMethods();
        for (int i = 0; i < methods.length; i++) {
            Method m = methods[i];
            String name = m.getName();
            if (name.substring(0, 3).equals("String_Node_Str")) {
                if (name.equals("String_Node_Str"))
                    continue;
                if (name.equals("String_Node_Str"))
                    continue;
                Object o = m.invoke(this, new Object[] {});
                if (o instanceof String) {
                    if (o != null)
                        buf.append(name.substring(3, name.length()) + "String_Node_Str" + o + "String_Node_Str");
                }
                if (o instanceof List) {
                    if (o != null)
                        buf.append(name.substring(3, name.length())).append("String_Node_Str");
                    List<Object> lst = (List<Object>) o;
                    for (Object obj : lst) {
                        if (obj instanceof Chain) {
                            continue;
                        }
                        buf.append(obj).append("String_Node_Str");
                    }
                }
            }
        }
    } catch (ClassNotFoundException e) {
        logger.error("String_Node_Str", e);
    } catch (InvocationTargetException e) {
        logger.error("String_Node_Str", e);
    } catch (IllegalAccessException e) {
        logger.error("String_Node_Str", e);
    }
    return buf.toString();
}

Output:
 public String toString() {
-    StringBuffer buf = new StringBuffer();
-    buf.append("String_Node_Str" + molId + "String_Node_Str" + molName + "String_Node_Str");
-    try {
-        Class c = Class.forName("String_Node_Str");
-        Method[] methods = c.getMethods();
-        for (int i = 0; i < methods.length; i++) {
-            Method m = methods[i];
-            String name = m.getName();
-            if (name.substring(0, 3).equals("String_Node_Str")) {
-                if (name.equals("String_Node_Str"))
-                    continue;
-                if (name.equals("String_Node_Str"))
-                    continue;
-                Object o = m.invoke(this, new Object[] {});
-                if (o instanceof String) {
-                    if (o != null)
-                        buf.append(name.substring(3, name.length()) + "String_Node_Str" + o + "String_Node_Str");
-                }
-                if (o instanceof List) {
-                    if (o != null)
-                        buf.append(name.substring(3, name.length())).append("String_Node_Str");
-                    List<Object> lst = (List<Object>) o;
-                    for (Object obj : lst) {
-                        if (obj instanceof Chain) {
-                            continue;
-                        }
-                        buf.append(obj).append("String_Node_Str");
-                    }
-                }
-            }
+    StringBuilder buf = new StringBuilder();
+    buf.append("String_Node_Str" + molId + "String_Node_Str");
+    buf.append(molName == null ? "String_Node_Str" : "String_Node_Str" + molName + "String_Node_Str");
+    buf.append("String_Node_Str");
+    if (chainIds != null) {
+        for (int i = 0; i < chainIds.size(); i++) {
+            buf.append(chainIds.get(i));
+            if (i != chainIds.size() - 1)
+                buf.append("String_Node_Str");
         }


Input:
private static OutputStreamManager getManager(Target target) {
    String type = target.name();
    OutputStream os = target == Target.SYSTEM_OUT ? System.out : System.err;
    OutputStreamManager manager = OutputStreamManager.getManager(target.name(), factory, new FactoryData(os, type));
    return manager;
}

Output:
     OutputStream os = target == Target.SYSTEM_OUT ? System.out : System.err;
-    OutputStreamManager manager = OutputStreamManager.getManager(target.name(), factory, new FactoryData(os, type));
+    OutputStreamManager manager = OutputStreamManager.getManager(target.name(), new FactoryData(os, type), factory);
     return manager;


Input:
public void testSrlLogLikelihood() throws Exception {
    List<CoNLL09Token> tokens = new ArrayList<CoNLL09Token>();
    tokens.add(new CoNLL09Token(1, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", getList("String_Node_Str"), getList("String_Node_Str"), 2, 2, "String_Node_Str", "String_Node_Str", false, "String_Node_Str", getList("String_Node_Str")));
    tokens.add(new CoNLL09Token(2, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", getList("String_Node_Str"), getList("String_Node_Str"), 2, 2, "String_Node_Str", "String_Node_Str", false, "String_Node_Str", getList("String_Node_Str")));
    tokens.add(new CoNLL09Token(3, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", getList("String_Node_Str"), getList("String_Node_Str"), 2, 2, "String_Node_Str", "String_Node_Str", true, "String_Node_Str", getList("String_Node_Str")));
    CoNLL09Sentence sent = new CoNLL09Sentence(tokens);
    List<CoNLL09Sentence> sents = getList(sent);
    System.out.println("String_Node_Str");
    Alphabet<Feature> alphabet = new Alphabet<Feature>();
    SrlFgExampleBuilderPrm prm = new SrlFgExampleBuilderPrm();
    prm.fgPrm.roleStructure = RoleStructure.PREDS_GIVEN;
    prm.fgPrm.useProjDepTreeFactor = true;
    prm.fePrm.biasOnly = true;
    SrlFgExamplesBuilder builder = new SrlFgExamplesBuilder(prm, alphabet);
    FgExamples data = builder.getData(sents);
    System.out.println("String_Node_Str" + alphabet.size());
    FgModel model = new FgModel(alphabet);
    CrfObjective obj = new CrfObjective(model.getNumParams(), data, getInfFactory(true));
    double ll = obj.getValue(model.getParams());
    assertEquals(0.0, ll, 1e-13);
}

Output:
     tokens.add(new CoNLL09Token(2, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", getList("String_Node_Str"), getList("String_Node_Str"), 2, 2, "String_Node_Str", "String_Node_Str", false, "String_Node_Str", getList("String_Node_Str")));
-    tokens.add(new CoNLL09Token(3, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", getList("String_Node_Str"), getList("String_Node_Str"), 2, 2, "String_Node_Str", "String_Node_Str", true, "String_Node_Str", getList("String_Node_Str")));
+    tokens.add(new CoNLL09Token(3, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", getList("String_Node_Str"), getList("String_Node_Str"), 0, 0, "String_Node_Str", "String_Node_Str", true, "String_Node_Str", getList("String_Node_Str")));
     CoNLL09Sentence sent = new CoNLL09Sentence(tokens);


Input:
private static String asKey(ItemStack itemstack) {
    return itemstack.getUnlocalizedName() + "String_Node_Str" + GameData.getItemRegistry().getId(itemstack.getItem());
}

Output:
 private static String asKey(ItemStack itemstack) {
-    return itemstack.getUnlocalizedName() + "String_Node_Str" + GameData.getItemRegistry().getId(itemstack.getItem());
+    return itemstack.getUnlocalizedName() + "String_Node_Str" + itemstack.getItemDamage();
 }


Input:
public String getId() {
    return name;
}

Output:
 public String getId() {
-    return name;
+    return this.name;
 }


Input:
private HyperlinkDef parseHyperLink(IContent content) {
    IHyperlinkAction linkaction = content.getHyperlinkAction();
    if (linkaction != null) {
        if (linkaction.getType() == IHyperlinkAction.ACTION_BOOKMARK) {
            String bookmark = linkaction.getBookmark();
            if (ExcelUtil.isValidBookmarkName(bookmark)) {
                return new HyperlinkDef(linkaction.getBookmark(), IHyperlinkAction.ACTION_BOOKMARK, null);
            } else {
                return null;
            }
        } else if (linkaction.getType() == IHyperlinkAction.ACTION_HYPERLINK) {
            return new HyperlinkDef(linkaction.getHyperlink(), IHyperlinkAction.ACTION_HYPERLINK, null);
        } else if (linkaction.getType() == IHyperlinkAction.ACTION_DRILLTHROUGH) {
            Action act = new Action(linkaction);
            IHTMLActionHandler actionHandler = null;
            Object ac = service.getOption(IRenderOption.ACTION_HANDLER);
            if (ac != null && ac instanceof IHTMLActionHandler) {
                actionHandler = (IHTMLActionHandler) ac;
                return new HyperlinkDef(actionHandler.getURL(act, service.getReportContext()), IHyperlinkAction.ACTION_DRILLTHROUGH, null);
            }
        }
    }
    return null;
}

Output:
             if (ExcelUtil.isValidBookmarkName(bookmark)) {
-                return new HyperlinkDef(linkaction.getBookmark(), IHyperlinkAction.ACTION_BOOKMARK, null);
+                return new HyperlinkDef(linkaction.getBookmark(), IHyperlinkAction.ACTION_BOOKMARK, null, toolTip);
             } else {


Input:
public void collect(int i) {
    Document d;
    try {
        d = reader.document(this.baseDoc + i, fieldsToLoad);
        for (String f : fieldsToLoad) {
            String[] vals = d.getValues(f);
            for (String s : vals) {
                TokenStream ts = analyzer.tokenStream(targetAnalyzer, new StringReader(s));
                ts.reset();
                while (ts.incrementToken()) {
                }
            }
        }
    } catch (IOException e) {
    }
}

Output:
     try {
-        d = reader.document(this.baseDoc + i, fieldsToLoad);
+        d = reader.document(i, fieldsToLoad);
         for (String f : fieldsToLoad) {


Input:
public synchronized void removeMediaItem(String path) {
    mDb.delete(MEDIA_TABLE_NAME, MEDIA_PATH + "String_Node_Str" + path + "String_Node_Str", null);
}

Output:
 public synchronized void removeMediaItem(String path) {
-    mDb.delete(MEDIA_TABLE_NAME, MEDIA_PATH + "String_Node_Str" + path + "String_Node_Str", null);
+    mDb.delete(MEDIA_TABLE_NAME, MEDIA_PATH + "String_Node_Str", new String[] { path });
 }


Input:
private static MultipleAlignment fakeMultipleAlignment(String family, List<Atom[]> atomArrays) throws StructureException, StructureAlignmentException {
    MultipleAlignmentEnsemble ensemble = new MultipleAlignmentEnsembleImpl();
    ensemble.setAtomArrays(atomArrays);
    ensemble.setAlgorithmName("String_Node_Str");
    MultipleAlignment fakeMultAln = new MultipleAlignmentImpl(ensemble);
    if (family == "String_Node_Str") {
        BlockSet blockSet1 = new BlockSetImpl(fakeMultAln);
        BlockSet blockSet2 = new BlockSetImpl(fakeMultAln);
        Block block1 = new BlockImpl(blockSet1);
        Block block2 = new BlockImpl(blockSet1);
        Block block3 = new BlockImpl(blockSet2);
        List<Integer> aligned11 = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
        List<Integer> aligned12 = Arrays.asList(29, 30, 31, 32, 33, 34, 35, 36, 37, 38);
        List<Integer> aligned13 = Arrays.asList(123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134);
        List<Integer> aligned21 = Arrays.asList(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, null, 27, 28, 29, 30, 31);
        List<Integer> aligned22 = Arrays.asList(39, 40, 41, 42, 43, 44, 45, 46, 47, 48);
        List<Integer> aligned23 = Arrays.asList(133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144);
        List<Integer> aligned31 = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
        List<Integer> aligned32 = Arrays.asList(29, 30, 31, 32, 33, 34, 35, 36, 37, 38);
        List<Integer> aligned33 = Arrays.asList(117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128);
        List<Integer> aligned41 = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, null, 17, 18, 19, 20, 21);
        List<Integer> aligned42 = Arrays.asList(30, 31, 32, 33, 34, 35, 36, 37, 38, 39);
        List<Integer> aligned43 = Arrays.asList(121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132);
        block1.getAlignRes().add(aligned11);
        block1.getAlignRes().add(aligned21);
        block1.getAlignRes().add(aligned31);
        block1.getAlignRes().add(aligned41);
        block2.getAlignRes().add(aligned12);
        block2.getAlignRes().add(aligned22);
        block2.getAlignRes().add(aligned32);
        block2.getAlignRes().add(aligned42);
        block3.getAlignRes().add(aligned13);
        block3.getAlignRes().add(aligned23);
        block3.getAlignRes().add(aligned33);
        block3.getAlignRes().add(aligned43);
        fakeMultAln.updateCache(PoseMethod.REFERENCE);
    }
    return fakeMultAln;
}

Output:
         block3.getAlignRes().add(aligned43);
-        fakeMultAln.updateCache(PoseMethod.REFERENCE);
+        MultipleSuperimposer imposer = new ReferenceSuperimposer();
+        imposer.superimpose(fakeMultAln);
     }


Input:
public void registerEventListeners() {
    super.registerEventListeners();
    addTablePerspectivesListener = new AddTablePerspectivesListener();
    addTablePerspectivesListener.setHandler(this);
    eventPublisher.addListener(AddTablePerspectivesEvent.class, addTablePerspectivesListener);
}

Output:
     super.registerEventListeners();
-    addTablePerspectivesListener = new AddTablePerspectivesListener();
-    addTablePerspectivesListener.setHandler(this);
-    eventPublisher.addListener(AddTablePerspectivesEvent.class, addTablePerspectivesListener);
+    eventListeners.register(AddTablePerspectivesEvent.class, new AddTablePerspectivesListener().setHandler(this));
 }