Input:
public <T extends Document> List<T> query(Collection<T> collection, String fromKey, String toKey, String indexedProperty, long startValue, int limit) {
    Lock lock = rwLock.readLock();
    lock.lock();
    try {
        ConcurrentSkipListMap<String, T> map = getMap(collection);
        ConcurrentNavigableMap<String, T> sub = map.subMap(fromKey + "String_Node_Str", toKey);
        ArrayList<T> list = new ArrayList<T>();
        for (T doc : sub.values()) {
            if (indexedProperty != null) {
                Object value = doc.get(indexedProperty);
                if (value instanceof Boolean) {
                    long test = (value != null && ((Boolean) value).booleanValue()) ? 1 : 0;
                    if (test < startValue) {
                        continue;
                    }
                } else if (value instanceof Long) {
                    if (value == null || ((Long) value < startValue)) {
                        continue;
                    }
                } else if (value != null) {
                    throw new DocumentStoreException("String_Node_Str" + indexedProperty + "String_Node_Str" + value.getClass());
                }
            }
            list.add(doc);
            if (list.size() >= limit) {
                break;
            }
        }
        return list;
    } finally {
        lock.unlock();
    }
}

Output:
                 if (value instanceof Boolean) {
-                    long test = (value != null && ((Boolean) value).booleanValue()) ? 1 : 0;
+                    long test = ((Boolean) value) ? 1 : 0;
                     if (test < startValue) {


Input:
public void newClientData(Selector selector, SelectionKey sk) throws IOException {
    if (!connected) {
        ByteBuffer inbuf = ByteBuffer.allocate(512);
        if (client.read(inbuf) < 1)
            return;
        inbuf.flip();
        int ver = inbuf.get();
        if (ver != 4) {
            throw new IOException("String_Node_Str" + ver);
        }
        int cmd = inbuf.get();
        if (cmd != 1) {
            throw new IOException("String_Node_Str");
        }
        port = inbuf.getShort();
        final byte[] ip = new byte[4];
        inbuf.get(ip);
        remoteAddr = InetAddress.getByAddress(ip);
        while ((inbuf.get()) != 0) ;
        if (ip[0] == 0 && ip[1] == 0 && ip[2] == 0 && ip[3] != 0) {
            String host = "String_Node_Str";
            byte b;
            while ((b = inbuf.get()) != 0) {
                host += b;
            }
            remoteAddr = InetAddress.getByName(host);
            System.out.println(host + remoteAddr);
        }
        stream = circ.createStream(remoteAddr.getHostAddress(), port, this);
    } else {
        ByteBuffer buf = ByteBuffer.allocate(1024);
        if (client.read(buf) == -1)
            throw new IOException("String_Node_Str");
        lastData = System.currentTimeMillis();
        buf.flip();
        stream.send(buf.array());
    }
}

Output:
     } else {
-        ByteBuffer buf = ByteBuffer.allocate(1024);
-        if (client.read(buf) == -1)
+        ByteBuffer buf = ByteBuffer.allocate(4096);
+        int nlen = 0;
+        if ((nlen = client.read(buf)) == -1)
             throw new IOException("String_Node_Str");


Input:
public void showObject(KnowledgeObject<? extends IObjectHolder<?>> object) {
    if (currentObject != null) {
        currentObjectPages.clear();
        purchaseElements.clear();
        if (currentObject != object) {
            pageIndex = 0;
            btnHelp.forcedHover = false;
        }
    }
    if ((currentObject = object) == null)
        return;
    byte page = 0;
    int yy = 0, height = 0;
    boolean isUnlocked = false;
    Map<KnowledgeFragment, Boolean> pageMap = new LinkedHashMap<>();
    Iterator<KnowledgeFragment> iter = currentObject.getFragments().iterator();
    while (true) {
        KnowledgeFragment fragment = iter.hasNext() ? iter.next() : null;
        if (fragment == null || yy + (height = 8 + fragment.getHeight(this, isUnlocked = (object == KnowledgeRegistrations.HELP || compendiumFile.hasUnlockedFragment(fragment)))) > guiPageHeight) {
            currentObjectPages.put(page++, pageMap);
            if (fragment == null)
                break;
            else {
                pageMap = new LinkedHashMap<>();
                pageMap.put(fragment, isUnlocked);
                yy = height;
                continue;
            }
        }
        pageMap.put(fragment, isUnlocked);
        yy += height;
    }
    if (object == KnowledgeRegistrations.HELP) {
        btnHelp.forcedHover = true;
        if (!compendiumFile.seenHelp()) {
            PacketPipeline.sendToServer(new S03SimpleEvent(EventType.OPEN_COMPENDIUM_HELP));
            compendiumFile.setSeenHelp();
        }
        purchaseElements.clear();
        return;
    }
    updatePurchaseElements();
}

Output:
         KnowledgeFragment fragment = iter.hasNext() ? iter.next() : null;
-        if (fragment == null || yy + (height = 8 + fragment.getHeight(this, isUnlocked = (object == KnowledgeRegistrations.HELP || compendiumFile.hasUnlockedFragment(fragment)))) > guiPageHeight) {
+        if (fragment == null || yy + (height = 8 + fragment.getHeight(this, isUnlocked = compendiumFile.canSeeFragment(object, fragment))) > guiPageHeight) {
             currentObjectPages.put(page++, pageMap);


Input:
public static <C extends Sequence<D>, D extends Compound> DistanceMatrix dissimilarityScore(MultipleSequenceAlignment<C, D> msa, SubstitutionMatrix<D> M) {
    logger.info("String_Node_Str", "String_Node_Str", 0);
    int n = msa.getSize();
    String[] sequenceString = new String[n];
    for (int i = 0; i < n; i++) {
        sequenceString[i] = msa.getAlignedSequence(i + 1).getSequenceAsString();
    }
    List<C> seqs = msa.getAlignedSequences();
    DistanceMatrix DM = new BasicSymmetricalDistanceMatrix(n);
    int totalloopcount = (n / 2) * (n + 1);
    double maxscore = 0;
    int end = msa.getLength();
    int loopcount = 0;
    for (int i = 0; i < (n - 1); i++) {
        logger.info("String_Node_Str", "String_Node_Str", (loopcount * 100) / totalloopcount);
        for (int j = i; j < n; j++) {
            double score = 0;
            loopcount++;
            for (int k = 0; k < end; k++) {
                if (Comparison.isGap(sequenceString[i].charAt(k)) || Comparison.isGap(sequenceString[j].charAt(k)))
                    continue;
                score += M.getValue(seqs.get(i).getCompoundAt(k), seqs.get(j).getCompoundAt(k));
            }
            DM.setValue(i, j, score);
            if (score > maxscore) {
                maxscore = score;
            }
        }
    }
    for (int i = 0; i < n; i++) {
        DM.setIdentifier(i, msa.getAlignedSequence(i + 1).getAccession().getID());
        for (int j = i; j < n; j++) {
            if (i == j)
                DM.setValue(i, j, 0.0);
            else {
                double dS = maxscore - DM.getValue(i, j);
                DM.setValue(i, j, dS);
                DM.setValue(j, i, dS);
            }
        }
    }
    logger.info("String_Node_Str", "String_Node_Str", 100);
    return DM;
}

Output:
                     continue;
-                score += M.getValue(seqs.get(i).getCompoundAt(k), seqs.get(j).getCompoundAt(k));
+                score += M.getValue(seqs.get(i).getCompoundAt(k + 1), seqs.get(j).getCompoundAt(k + 1));
             }


Input:
private static Function<Object, Object> idGen(final Bucket bucket) {
    return entity -> {
        return IdGenerator.getOrGenId(entity, () -> bucket.counter(entity.getClass().getName(), 1, 1).content());
    };
}

Output:
 private static Function<Object, Object> idGen(final Bucket bucket) {
-    return entity -> {
-        return IdGenerator.getOrGenId(entity, () -> bucket.counter(entity.getClass().getName(), 1, 1).content());
-    };
+    return entity -> IdGenerator.getOrGenId(entity, () -> bucket.counter(entity.getClass().getName(), 1, 1).content());
 }


Input:
int computeTreeSTBipartitions(List<Tree> trees, TaxonNameMap taxonMap, Map<Integer, Set<Vertex>> clusters) {
    int sigmaN = 0;
    int k = trees.size();
    String[] leaves = stTaxa;
    int n = leaves.length;
    geneTreeSTBBySize = new ArrayList<Set<STBipartition>>(leaves.length);
    for (int i = 0; i <= leaves.length; i++) {
        geneTreeSTBBySize.add(new HashSet<STBipartition>());
        clusters.put(i, new HashSet<Vertex>());
    }
    STBCountInGeneTrees = new HashMap<STBipartition, Integer>(k * n);
    X = new HashMap<STITreeCluster, Set<STBipartition>>(k * n);
    STITreeCluster all = new STITreeCluster(stTaxa);
    String[] as;
    int j = (as = stTaxa).length;
    for (int i = 0; i < j; i++) {
        String t = as[i];
        all.addLeaf(t);
    }
    addToClusters(clusters, all, leaves.length);
    for (Tree tr : trees) {
        String[] treeLeaves = tr.getLeaves();
        STITreeCluster treeAll = new STITreeCluster(leaves);
        for (int i = 0; i < treeLeaves.length; i++) {
            treeAll.addLeaf(treeLeaves[i]);
        }
        sigmaN += tr.getLeafCount() - 1;
        Map<TNode, STITreeCluster> map = new HashMap<TNode, STITreeCluster>(n);
        for (Iterator<TNode> nodeIt = tr.postTraverse().iterator(); nodeIt.hasNext(); ) {
            TNode node = nodeIt.next();
            if (node.isLeaf()) {
                String nodeName = node.getName();
                if (taxonMap != null) {
                    nodeName = taxonMap.getTaxonName(nodeName);
                }
                STITreeCluster tb = new STITreeCluster(leaves);
                tb.addLeaf(nodeName);
                addToClusters(clusters, tb, 1);
                map.put(node, tb);
                if (!rooted) {
                    addSTB(clusters, tb, treeComplementary(treeAll, tb), null, node);
                }
            } else {
                int childCount = node.getChildCount();
                STITreeCluster[] childbslist = new STITreeCluster[childCount];
                BitSet bs = new BitSet(leaves.length);
                int index = 0;
                for (Iterator iterator3 = node.getChildren().iterator(); iterator3.hasNext(); ) {
                    TNode child = (TNode) iterator3.next();
                    childbslist[index++] = map.get(child);
                    bs.or(map.get(child).getCluster());
                }
                STITreeCluster cluster = new STITreeCluster(leaves);
                cluster.setCluster((BitSet) bs.clone());
                int size = cluster.getClusterSize();
                addToClusters(clusters, cluster, size);
                map.put(node, cluster);
                if (rooted) {
                    if (index > 2) {
                        throw new RuntimeException("String_Node_Str" + tr + "String_Node_Str" + node);
                    }
                    STITreeCluster l_cluster = childbslist[0];
                    STITreeCluster r_cluster = childbslist[1];
                    addSTB(clusters, l_cluster, r_cluster, cluster, node);
                } else {
                    if (childCount == 2) {
                        STITreeCluster l_cluster = childbslist[0];
                        STITreeCluster r_cluster = childbslist[1];
                        STITreeCluster allMinuslAndr_cluster = treeComplementary(treeAll, cluster);
                        STITreeCluster lAndr_cluster = cluster;
                        if (allMinuslAndr_cluster.getClusterSize() != 0) {
                            addSTB(clusters, l_cluster, r_cluster, cluster, node);
                            addSTB(clusters, r_cluster, allMinuslAndr_cluster, null, node);
                            addSTB(clusters, l_cluster, allMinuslAndr_cluster, null, node);
                            addSTB(clusters, lAndr_cluster, allMinuslAndr_cluster, all, node);
                        }
                    } else if (childCount == 3 && node.isRoot()) {
                        STITreeCluster l_cluster = childbslist[0];
                        STITreeCluster m_cluster = childbslist[1];
                        STITreeCluster r_cluster = childbslist[2];
                        addSTB(clusters, l_cluster, r_cluster, null, node);
                        addSTB(clusters, r_cluster, m_cluster, null, node);
                        addSTB(clusters, l_cluster, m_cluster, null, node);
                    } else {
                        throw new RuntimeException("String_Node_Str" + tr + "String_Node_Str" + node);
                    }
                }
            }
        }
    }
    System.out.println("String_Node_Str" + STBCountInGeneTrees.keySet().size());
    int s = 0;
    for (Integer c : clusters.keySet()) {
        s += clusters.get(c).size();
    }
    System.out.println("String_Node_Str" + s);
    weights = new HashMap<STBipartition, Integer>(STBCountInGeneTrees.size());
    return sigmaN;
}

Output:
     }
-    System.out.println("String_Node_Str" + STBCountInGeneTrees.keySet().size());
+    System.err.println("String_Node_Str" + STBCountInGeneTrees.keySet().size());
     int s = 0;


Input:
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float fX, float fY, float fZ) {
    if (world.isRemote) {
        return true;
    }
    TileEntity te = world.getTileEntity(x, y, z);
    if (te != null && te instanceof TileEntityCrop) {
        TileEntityCrop crop = (TileEntityCrop) te;
        if (ConfigurationHandler.enableHandRake && crop.hasWeed()) {
            return false;
        }
        ItemStack heldItem = player.getCurrentEquippedItem();
        if (player.isSneaking()) {
            this.harvest(world, x, y, z, player, crop);
        } else if (heldItem == null || heldItem.getItem() == null) {
            this.harvest(world, x, y, z, player, crop);
        } else if (heldItem.getItem() == net.minecraft.init.Items.reeds) {
            if (crop.hasPlant()) {
                this.harvest(world, x, y, z, player, crop);
            } else if (!crop.isCrossCrop() && !crop.hasWeed()) {
                CropPlant sugarcane = CropPlantHandler.getPlantFromStack(new ItemStack((ItemSeeds) Item.itemRegistry.getObject("String_Node_Str")));
                if (sugarcane != null && sugarcane.isFertile(world, x, y, z)) {
                    crop.setPlant(1, 1, 1, false, sugarcane);
                    if (!player.capabilities.isCreativeMode) {
                        heldItem.stackSize = heldItem.stackSize - 1;
                    }
                }
            }
        } else if (heldItem.getItem() == Items.crops) {
            this.setCrossCrop(world, x, y, z, player);
        } else if (heldItem.getItem() instanceof ITrowel) {
            crop.onTrowelUsed((ITrowel) heldItem.getItem(), heldItem);
        } else if (heldItem.getItem() instanceof IClipper) {
            this.onClipperUsed(world, x, y, z, crop);
            ((IClipper) heldItem.getItem()).onClipperUsed(world, x, y, z, player);
        } else if (heldItem.getItem() == net.minecraft.init.Items.dye && heldItem.getItemDamage() == 15) {
            return !crop.canBonemeal();
        } else if (heldItem.getItem() instanceof IFertiliser) {
            IFertiliser fertiliser = (IFertiliser) heldItem.getItem();
            if (crop.allowFertiliser(fertiliser)) {
                crop.applyFertiliser(fertiliser, world.rand);
                NetworkWrapperAgriCraft.wrapper.sendToAllAround(new MessageFertiliserApplied(heldItem, x, y, z), new NetworkRegistry.TargetPoint(world.provider.dimensionId, x, y, z, 32));
                if (!player.capabilities.isCreativeMode) {
                    heldItem.stackSize = heldItem.stackSize - 1;
                }
            }
            return false;
        } else if (heldItem.getItem() instanceof ItemDebugger) {
            return false;
        } else if (ModHelper.isRightClickHandled(heldItem.getItem())) {
            return ModHelper.handleRightClickOnCrop(world, x, y, z, player, heldItem, this, crop);
        } else {
            this.harvest(world, x, y, z, player, crop);
            if (CropPlantHandler.isValidSeed(heldItem)) {
                if (this.plantSeed(player.getCurrentEquippedItem(), world, x, y, z)) {
                    player.getCurrentEquippedItem().stackSize = player.capabilities.isCreativeMode ? player.getCurrentEquippedItem().stackSize : player.getCurrentEquippedItem().stackSize - 1;
                }
            }
        }
    }
    return true;
}

Output:
         TileEntityCrop crop = (TileEntityCrop) te;
-        if (ConfigurationHandler.enableHandRake && crop.hasWeed()) {
+        ItemStack heldItem = player.getCurrentEquippedItem();
+        if (ConfigurationHandler.enableHandRake && crop.hasWeed() && heldItem == null) {
             return false;


Input:
public boolean hasSpecialProperties() {
    return specialProperties != null && !specialProperties.isEmpty();
}

Output:
 public boolean hasSpecialProperties() {
-    return specialProperties != null && !specialProperties.isEmpty();
+    return !specialProperties.isEmpty();
 }


Input:
public PortalURL parse(HttpServletRequest request) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + request.getRequestURI());
    }
    String contextPath = request.getContextPath();
    String servletName = request.getServletPath();
    String urlBase = request.getScheme() + "String_Node_Str" + request.getServerName() + "String_Node_Str" + request.getServerPort();
    PortalURL portalURL = new RelativePortalURLImpl(urlBase, contextPath, servletName, this, request);
    String pathInfo = request.getPathInfo();
    if (pathInfo == null) {
        if (servletName.contains("String_Node_Str") && !servletName.endsWith("String_Node_Str")) {
            int idx = servletName.indexOf("String_Node_Str") + "String_Node_Str".length();
            pathInfo = servletName.substring(idx);
            servletName = servletName.substring(0, idx);
            portalURL = new RelativePortalURLImpl(urlBase, contextPath, servletName, this, request);
        } else {
            return portalURL;
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + pathInfo);
    }
    StringBuilder renderPath = new StringBuilder();
    if (pathInfo.charAt(0) != '/') {
        renderPath.append('/');
    }
    int ind = pathInfo.indexOf("String_Node_Str" + PREFIX);
    if (ind < 0) {
        renderPath.append(pathInfo);
        pathInfo = "String_Node_Str";
    } else {
        renderPath.append(pathInfo.substring(0, ind));
        pathInfo = pathInfo.substring(ind);
    }
    portalURL.setRenderPath(renderPath.toString());
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + renderPath.toString() + "String_Node_Str" + pathInfo);
    }
    ServletContext sc = request.getServletContext();
    DriverConfiguration dc = (DriverConfiguration) sc.getAttribute(AttributeKeys.DRIVER_CONFIG);
    PublicRenderParameterMapper prpm = dc.getPublicRenderParameterService().getPRPMapper(renderPath.toString());
    portalURL.setPublicRenderParameterMapper(prpm);
    Collection<String> pids = dc.getPageConfig(renderPath.toString()).getPortletIds();
    portalURL.setPortletIds(pids);
    StringBuilder vstr = new StringBuilder();
    if (LOG.isDebugEnabled()) {
        vstr.append("String_Node_Str");
    }
    for (String pid : pids) {
        String appName = PortletWindowConfig.fromId(pid).getContextPath();
        try {
            String pv = dc.getPortletRegistryService().getPortletApplication(appName).getVersion();
            portalURL.setVersion(pid, pv);
            if (LOG.isDebugEnabled()) {
                vstr.append(pid).append("String_Node_Str").append(pv).append("String_Node_Str");
            }
        } catch (Exception e) {
            LOG.error("String_Node_Str" + appName);
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug(vstr.toString());
    }
    ArrayList<String> portletIds = new ArrayList<String>();
    if (pathInfo.length() > 2) {
        String[] tokens = pathInfo.split("String_Node_Str" + PREFIX);
        for (String t : tokens) {
            String type, val;
            String[] vals;
            if (t.length() < 3) {
                continue;
            } else {
                type = t.substring(0, 2);
                val = t.substring(2);
                vals = val.split(DELIM);
            }
            int index = -1;
            String pid = null;
            if ((vals[0].length() > 0) && vals[0].matches("String_Node_Str")) {
                try {
                    index = Integer.parseInt(vals[0]);
                    if ((index >= 0) && (index < portletIds.size())) {
                        pid = portletIds.get(index);
                    }
                } catch (Exception e) {
                    LOG.error("String_Node_Str" + vals[0] + "String_Node_Str" + e.toString());
                }
            }
            if (type.equals(PORTLET_ID)) {
                portletIds.add(Integer.parseInt(vals[1]), urlDecode(vals[0]));
                continue;
            }
            if (type.equals(CACHE_LEVEL)) {
                portalURL.setCacheability(urlDecode(vals[0]));
                continue;
            }
            if (type.equals(RESOURCE_ID)) {
                portalURL.setResourceID(urlDecode(vals[0]));
                continue;
            }
            if (type.equals(RESOURCE)) {
                portalURL.setTargetWindow(pid);
                portalURL.setType(URLType.Resource);
                continue;
            }
            if (type.equals(RENDER)) {
                portalURL.setTargetWindow(pid);
                portalURL.setType(URLType.Render);
                continue;
            }
            if (type.equals(ACTION)) {
                portalURL.setTargetWindow(pid);
                portalURL.setType(URLType.Action);
                continue;
            }
            if (type.equals(AJAX_ACTION)) {
                portalURL.setTargetWindow(pid);
                portalURL.setType(URLType.AjaxAction);
                continue;
            }
            if (type.equals(PARTIAL_ACTION)) {
                portalURL.setTargetWindow(pid);
                portalURL.setType(URLType.PartialAction);
                continue;
            }
            if (type.equals(WINDOW_STATE)) {
                portalURL.setWindowState(pid, new WindowState(urlDecode(vals[1])));
                continue;
            }
            if (type.equals(PORTLET_MODE)) {
                portalURL.setPortletMode(pid, new PortletMode(urlDecode(vals[1])));
                continue;
            }
            StringBuilder dbgstr = new StringBuilder();
            if (LOG.isDebugEnabled()) {
                dbgstr.append("String_Node_Str").append(pid).append("String_Node_Str").append(vals[1]);
            }
            String values = vals[1];
            if (type.equals(PUBLIC_RENDER_PARAM)) {
                if (vals.length != 3) {
                    LOG.warn("String_Node_Str" + val);
                } else {
                    values = vals[2];
                }
            }
            String[] pVals = values.split(VALUE_DELIM);
            String[] paramValues = null;
            String paramName = null;
            if (pVals.length > 2) {
                for (int i = 0; i < pVals.length; i++) {
                    if (pVals[i].equals(VALUE_NULL)) {
                        pVals[i] = null;
                    } else {
                        pVals[i] = urlDecode(pVals[i]);
                    }
                }
                paramName = pVals[0];
                paramValues = Arrays.copyOfRange(pVals, 1, pVals.length);
            }
            if (LOG.isDebugEnabled()) {
                dbgstr.append("String_Node_Str").append(paramName);
                dbgstr.append("String_Node_Str").append(Arrays.toString(paramValues));
                LOG.debug(dbgstr.toString());
            }
            if (type.equals(RENDER_PARAM)) {
                portalURL.addParameter(new PortalURLParameter(pid, paramName, paramValues));
                continue;
            }
            if (type.equals(ACTION_PARAM)) {
                portalURL.addParameter(new PortalURLParameter(pid, paramName, paramValues, PortalURLParameter.PARAM_TYPE_ACTION));
                continue;
            }
            if (type.equals(RESOURCE_PARAM)) {
                portalURL.addParameter(new PortalURLParameter(pid, paramName, paramValues, PortalURLParameter.PARAM_TYPE_RESOURCE));
                continue;
            }
            if (type.equals(PUBLIC_RENDER_PARAM)) {
                PublicRenderParameterMapper mapper = portalURL.getPublicRenderParameterMapper();
                int prpGroup = mapper.getIndex(pid, paramName);
                if (prpGroup >= 0) {
                    mapper.setValues(prpGroup, paramValues);
                } else {
                    StringBuilder sb = new StringBuilder("String_Node_Str");
                    sb.append(pid).append("String_Node_Str").append(paramName);
                    LOG.warn(sb.toString());
                }
                continue;
            }
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + portletIds.size() + "String_Node_Str" + Arrays.toString(portletIds.toArray()));
    }
    return portalURL;
}

Output:
             String[] pVals = values.split(VALUE_DELIM);
-            String[] paramValues = null;
-            String paramName = null;
-            if (pVals.length > 2) {
+            String[] paramValues = new String[0];
+            String paramName = "String_Node_Str";
+            if (pVals.length > 1) {
                 for (int i = 0; i < pVals.length; i++) {


Input:
private static boolean isLib(URL jar) {
    URL[] jarURLs1 = { jar };
    URLClassLoader classLoader = new URLClassLoader(jarURLs1);
    Enumeration<URL> resources;
    try {
        resources = classLoader.getResources("String_Node_Str");
        return !resources.hasMoreElements();
    } catch (IOException e) {
        LOGGER.error("String_Node_Str", e);
    }
    return false;
}

Output:
 private static boolean isLib(URL jar) {
-    URL[] jarURLs1 = { jar };
-    URLClassLoader classLoader = new URLClassLoader(jarURLs1);
-    Enumeration<URL> resources;
-    try {
-        resources = classLoader.getResources("String_Node_Str");
-        return !resources.hasMoreElements();
-    } catch (IOException e) {
-        LOGGER.error("String_Node_Str", e);
-    }
-    return false;
+    return (getMainClass(jar) == null);
 }


Input:
public void cleanUp() {
    match.cleanUpOnMatchEnd(isTournament);
}

Output:
 public void cleanUp() {
-    match.cleanUpOnMatchEnd(isTournament);
+    if (match != null) {
+        match.cleanUpOnMatchEnd(isTournament);
+    }
 }


Input:
public void processTypeElement(final TypeElement annotation, final TypeElement element, final MessageInterface messageInterface) {
    if (generatedFilesPath != null) {
        if (element.getKind().isInterface()) {
            String packageName = elementUtils().getPackageOf(element).getQualifiedName().toString();
            String relativePath = packageName.replaceAll("String_Node_Str", FILE_SEPARATOR);
            String fileName = getPrimaryClassNamePrefix(element) + GENERATED_FILE_EXTENSION;
            this.generateSkeletalTranslationFile(relativePath, fileName, messageInterface);
        }
    }
}

Output:
             String packageName = elementUtils().getPackageOf(element).getQualifiedName().toString();
-            String relativePath = packageName.replaceAll("String_Node_Str", FILE_SEPARATOR);
+            String relativePath = packageName.replace('.', File.separatorChar);
             String fileName = getPrimaryClassNamePrefix(element) + GENERATED_FILE_EXTENSION;


Input:
public static StringBuffer advancedGenerateSMVDescription(CompositeActor model, String pattern, String choice, String span) throws IllegalActionException, NameDuplicationException {
    _globalSignalDistributionInfo = new HashMap<String, ArrayList<String>>();
    _globalSignalRetrivalInfo = new HashMap<String, HashSet<String>>();
    _globalSignalNestedRetrivalInfo = new HashMap<String, HashSet<String>>();
    _variableInfo = new HashMap<String, VariableInfo>();
    StringBuffer returnSMVFormat = new StringBuffer("String_Node_Str");
    _advancedSystemSignalPreScan(model, span);
    for (Iterator actors = (((CompositeActor) model).entityList()).iterator(); actors.hasNext(); ) {
        Entity innerEntity = (Entity) actors.next();
        if (innerEntity instanceof FSMActor) {
            returnSMVFormat.append(_translateSingleFSMActor((FSMActor) innerEntity, span, false, "String_Node_Str", "String_Node_Str"));
        } else if (innerEntity instanceof ModalModel) {
            ArrayList<StringBuffer> subSystemDescription = _generateSMVFormatModalModelWithRefinement((ModalModel) innerEntity, span, "String_Node_Str");
            for (int i = 0; i < subSystemDescription.size(); i++) {
                returnSMVFormat.append(subSystemDescription.get(i));
            }
        }
    }
    StringBuffer mainModuleDescription = new StringBuffer("String_Node_Str");
    mainModuleDescription.append("String_Node_Str");
    mainModuleDescription.append("String_Node_Str");
    for (Iterator actors = (((CompositeActor) model).entityList()).iterator(); actors.hasNext(); ) {
        Entity innerEntity = (Entity) actors.next();
        if ((innerEntity instanceof FSMActor) || (innerEntity instanceof ModalModel)) {
            mainModuleDescription.append("String_Node_Str" + innerEntity.getName() + "String_Node_Str" + innerEntity.getName() + "String_Node_Str");
            ArrayList<String> signalInfo = _globalSignalDistributionInfo.get(innerEntity.getName());
            if (signalInfo != null) {
                for (int i = 0; i < signalInfo.size(); i++) {
                    String signalName = signalInfo.get(i);
                    boolean contain = false;
                    String location = "String_Node_Str";
                    Iterator<String> it = _globalSignalRetrivalInfo.keySet().iterator();
                    while (it.hasNext()) {
                        String place = it.next();
                        if (_globalSignalRetrivalInfo.get(place).contains(signalName)) {
                            location = place;
                            contain = true;
                            break;
                        }
                    }
                    if (contain == true) {
                        if (i == signalInfo.size() - 1) {
                            mainModuleDescription.append(location.trim() + "String_Node_Str" + signalName + "String_Node_Str");
                        } else {
                            mainModuleDescription.append(location.trim() + "String_Node_Str" + signalName + "String_Node_Str");
                        }
                    } else {
                        if (i == signalInfo.size() - 1) {
                            mainModuleDescription.append("String_Node_Str");
                        } else {
                            mainModuleDescription.append("String_Node_Str");
                        }
                    }
                }
            }
            mainModuleDescription.append("String_Node_Str");
        }
    }
    if (choice.equalsIgnoreCase("String_Node_Str")) {
        mainModuleDescription.append("String_Node_Str");
        mainModuleDescription.append("String_Node_Str" + pattern + "String_Node_Str");
    } else if (choice.equalsIgnoreCase("String_Node_Str")) {
        mainModuleDescription.append("String_Node_Str");
        mainModuleDescription.append("String_Node_Str" + pattern + "String_Node_Str");
    }
    returnSMVFormat.append(mainModuleDescription);
    return returnSMVFormat;
}

Output:
                         String place = it.next();
-                        if (_globalSignalRetrivalInfo.get(place).contains(signalName)) {
-                            location = place;
-                            contain = true;
-                            break;
+                        if (_globalSignalRetrivalInfo.get(place) != null) {
+                            if (_globalSignalRetrivalInfo.get(place).contains(signalName)) {
+                                location = place;
+                                contain = true;
+                                break;
+                            }
                         }


Input:
private void onError(String description) {
    boolean isConnected;
    Log.d(LOG_TAG, "String_Node_Str" + description);
    synchronized (this) {
        isConnected = mbIsConnected;
    }
    if (!isConnected) {
        mIsNetworkSuspended = true;
    }
    latch.countDown();
}

Output:
     }
-    if (!isConnected) {
+    if (isConnected) {
+        new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
+            public void run() {
+                latch.countDown();
+            }
+        }, RETRY_WAIT_TIME_MS);
+    } else {
         mIsNetworkSuspended = true;


Input:
protected void parsePayload(ParsableByteArray data, long timeUs) {
    int packetType = data.readUnsignedByte();
    int compositionTime = data.readUnsignedInt24();
    if (compositionTime > 0) {
        timeUs += compositionTime * 1000;
    }
    if (packetType == AVC_PACKET_TYPE_SEQUENCE_HEADER && !hasOutputFormat) {
        ParsableByteArray videoSequence = new ParsableByteArray(new byte[data.bytesLeft()]);
        data.readBytes(videoSequence.data, 0, data.bytesLeft());
        AvcSequenceHeaderData avcData;
        try {
            avcData = parseAvcCodecPrivate(videoSequence);
            nalUnitsLength = avcData.nalUnitLengthFieldLength;
        } catch (ParserException e) {
            e.printStackTrace();
            return;
        }
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MimeTypes.VIDEO_H264, MediaFormat.NO_VALUE, MediaFormat.NO_VALUE, durationUs, avcData.width, avcData.height, avcData.initializationData, MediaFormat.NO_VALUE, avcData.pixelWidthAspectRatio);
        output.format(mediaFormat);
        hasOutputFormat = true;
    } else if (packetType == AVC_PACKET_TYPE_AVC_NALU) {
        byte[] nalLengthData = nalLength.data;
        nalLengthData[0] = 0;
        nalLengthData[1] = 0;
        nalLengthData[2] = 0;
        int nalUnitLengthFieldLength = nalUnitsLength;
        int nalUnitLengthFieldLengthDiff = 4 - nalUnitsLength;
        int bytesWritten = 0;
        int bytesToWrite;
        while (data.bytesLeft() > 0) {
            data.readBytes(nalLength.data, nalUnitLengthFieldLengthDiff, nalUnitLengthFieldLength);
            nalLength.setPosition(0);
            bytesToWrite = nalLength.readUnsignedIntToInt();
            nalStartCode.setPosition(0);
            output.sampleData(nalStartCode, 4);
            bytesWritten += 4;
            output.sampleData(data, bytesToWrite);
            bytesWritten += bytesToWrite;
        }
        output.sampleMetadata(timeUs, frameType == VIDEO_FRAME_KEYFRAME ? C.SAMPLE_FLAG_SYNC : 0, bytesWritten, 0, null);
    } else if (packetType == AVC_PACKET_TYPE_AVC_END_OF_SEQUENCE) {
        Log.d(TAG, "String_Node_Str");
    }
}

Output:
         }
-        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MimeTypes.VIDEO_H264, MediaFormat.NO_VALUE, MediaFormat.NO_VALUE, durationUs, avcData.width, avcData.height, avcData.initializationData, MediaFormat.NO_VALUE, avcData.pixelWidthAspectRatio);
+        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.NO_VALUE, MimeTypes.VIDEO_H264, MediaFormat.NO_VALUE, MediaFormat.NO_VALUE, durationUs, avcData.width, avcData.height, avcData.initializationData, MediaFormat.NO_VALUE, avcData.pixelWidthAspectRatio);
         output.format(mediaFormat);


Input:
private Record getRecordInternal(Data dataKey, boolean enableIndex) {
    Record record = null;
    if (mapContainer.getStore() != null) {
        final Object value = mapContainer.getStore().load(mapService.toObject(dataKey));
        if (value != null) {
            record = mapService.createRecord(name, dataKey, value, DEFAULT_TTL, getNow());
            records.put(dataKey, record);
            if (enableIndex) {
                saveIndex(record);
            }
            updateSizeEstimator(calculateRecordSize(record));
        }
    }
    return record;
}

Output:
     if (mapContainer.getStore() != null) {
-        final Object value = mapContainer.getStore().load(mapService.toObject(dataKey));
+        final Object value = loadFromStoreOrStagingArea(key);
         if (value != null) {


Input:
protected int executeCommand() throws CommandException {
    RemoteAdminCommand rac = new RemoteAdminCommand(name, programOpts.getHost(), programOpts.getPort(), programOpts.isSecure(), programOpts.getUser(), programOpts.getPassword(), logger);
    rac.executeCommand(params);
    return SUCCESS;
}

Output:
 protected int executeCommand() throws CommandException {
-    RemoteAdminCommand rac = new RemoteAdminCommand(name, programOpts.getHost(), programOpts.getPort(), programOpts.isSecure(), programOpts.getUser(), programOpts.getPassword(), logger);
-    rac.executeCommand(params);
-    return SUCCESS;
+    if (ok(domainDirParam) || ok(userArgDomainName)) {
+        String domainDir = (ok(domainDirParam)) ? domainDirParam : getDomainsDir().getPath();
+        String domainName = (ok(userArgDomainName)) ? userArgDomainName : getDomainName();
+        return changeAdminPasswordLocally(domainDir, domainName);
+    } else {
+        try {
+            RemoteAdminCommand rac = new RemoteAdminCommand(name, programOpts.getHost(), programOpts.getPort(), programOpts.isSecure(), programOpts.getUser(), programOpts.getPassword(), logger);
+            rac.executeCommand(params);
+            return SUCCESS;
+        } catch (CommandException ce) {
+            if (ce.getCause() instanceof ConnectException) {
+                if (!isLocalHost(programOpts.getHost())) {
+                    throw ce;
+                }
+                return changeAdminPasswordLocally(getDomainsDir().getPath(), getDomainName());
+            } else {
+                throw ce;
+            }
+        }
+    }
 }


Input:
protected void processHits(final GL gl, int iHitCount, int[] iArPickingBuffer) {
    IPathwayVertexRep refPickedVertexRep;
    int iPtr = 0;
    int i = 0;
    int iPickedObjectId = 0;
    iPtr++;
    iPtr++;
    iPtr++;
    iPickedObjectId = iArPickingBuffer[iPtr];
    System.out.println("String_Node_Str" + iPickedObjectId);
    if (iPickedObjectId <= 100) {
        int iPathwayId = refHashPoolLinePickId2PathwayId.get(iPickedObjectId);
        System.out.println("String_Node_Str" + iPathwayId);
        if (bIsMouseOverPickingEvent) {
            if (iMouseOverPickedPathwayId != iPathwayId) {
                iMouseOverPickedPathwayId = iPathwayId;
                playPathwayPoolTickSound();
            }
            return;
        }
        if (iSlerpFactor > 0 && iSlerpFactor < 1000)
            return;
        arSlerpActions.clear();
        if (!pathwayUnderInteractionLayer.getElementList().isEmpty()) {
            SlerpAction reverseSlerpAction = new SlerpAction(pathwayUnderInteractionLayer.getElementIdByPositionIndex(0), pathwayUnderInteractionLayer, true, true, 0);
            arSlerpActions.add(reverseSlerpAction);
        }
        SlerpAction slerpAction = new SlerpAction(iPathwayId, pathwayPoolLayer, false, false, pathwayLayeredLayer.getElementList().size());
        arSlerpActions.add(slerpAction);
        iSlerpFactor = 0;
        return;
    } else if (iPickedObjectId == 101) {
        return;
    }
    refPickedVertexRep = refPathwayManager.getVertexRepByPickID(iPickedObjectId);
    iMouseOverPickedPathwayId = -1;
    if (refPickedVertexRep == null)
        return;
    System.out.println("String_Node_Str" + refPickedVertexRep.getName());
    loadNodeInformationInBrowser(refPickedVertexRep.getVertex().getVertexLink());
    if (refPickedVertexRep.getVertex().getVertexType().equals(PathwayVertexType.map)) {
        if (iSlerpFactor > 0 && iSlerpFactor < 1000)
            return;
        String strTmp = "String_Node_Str";
        strTmp = refPickedVertexRep.getVertex().getElementTitle();
        arSlerpActions.clear();
        int iPathwayId = -1;
        try {
            iPathwayId = Integer.parseInt(strTmp.substring(strTmp.length() - 4));
        } catch (NumberFormatException e) {
            return;
        }
        if (!refGeneralManager.getSingelton().getPathwayManager().hasItem(iPathwayId))
            return;
        System.out.println("String_Node_Str" + iPathwayId);
        if (!pathwayUnderInteractionLayer.getElementList().isEmpty()) {
            SlerpAction reverseSlerpAction = new SlerpAction(pathwayUnderInteractionLayer.getElementIdByPositionIndex(0), pathwayUnderInteractionLayer, true, true, 0);
            arSlerpActions.add(reverseSlerpAction);
        }
        SlerpAction slerpAction = null;
        if (pathwayLayeredLayer.containsElement(iPathwayId)) {
            slerpAction = new SlerpAction(iPathwayId, pathwayLayeredLayer, false, false, 0);
        } else {
            slerpAction = new SlerpAction(iPathwayId, pathwayPoolLayer, false, false, pathwayLayeredLayer.getElementList().size());
        }
        arSlerpActions.add(slerpAction);
        iSlerpFactor = 0;
    }
}

Output:
     System.out.println("String_Node_Str" + iPickedObjectId);
-    if (iPickedObjectId <= 100) {
+    if (iPickedObjectId < 101) {
         int iPathwayId = refHashPoolLinePickId2PathwayId.get(iPickedObjectId);


Input:
protected boolean checkSendfile(HttpServletRequest request, HttpServletResponse response, CacheEntry entry, long length, Range range) {
    if ((sendfileSize > 0) && (entry.resource != null) && ((length > sendfileSize) || (entry.resource.getContent() == null)) && (entry.attributes.getCanonicalPath() != null) && (Boolean.TRUE == request.getAttribute("String_Node_Str")) && (request.getClass().getName().equals("String_Node_Str")) && (response.getClass().getName().equals("String_Node_Str"))) {
        request.setAttribute("String_Node_Str", entry.attributes.getCanonicalPath());
        if (range == null) {
            request.setAttribute("String_Node_Str", Long.valueOf(0L));
            request.setAttribute("String_Node_Str", Long.valueOf(length));
        } else {
            request.setAttribute("String_Node_Str", Long.valueOf(range.start));
            request.setAttribute("String_Node_Str", Long.valueOf(range.end + 1));
        }
        request.setAttribute("String_Node_Str", this);
        return true;
    } else {
        return false;
    }
}

Output:
 protected boolean checkSendfile(HttpServletRequest request, HttpServletResponse response, CacheEntry entry, long length, Range range) {
-    if ((sendfileSize > 0) && (entry.resource != null) && ((length > sendfileSize) || (entry.resource.getContent() == null)) && (entry.attributes.getCanonicalPath() != null) && (Boolean.TRUE == request.getAttribute("String_Node_Str")) && (request.getClass().getName().equals("String_Node_Str")) && (response.getClass().getName().equals("String_Node_Str"))) {
+    if ((sendfileSize > 0) && (entry.resource != null) && ((length > sendfileSize) || (entry.resource.getContent() == null)) && (entry.attributes.getCanonicalPath() != null) && (Boolean.TRUE.equals(request.getAttribute("String_Node_Str"))) && (request.getClass().getName().equals("String_Node_Str")) && (response.getClass().getName().equals("String_Node_Str"))) {
         request.setAttribute("String_Node_Str", entry.attributes.getCanonicalPath());


Input:
public void afterTextChanged(Editable incomingEditable) {
    final String incomingString = incomingEditable.toString();
    final String currentSearchText = getSearchText().toString();
    if (!"String_Node_Str".equals(currentSearchText) && incomingString.equals(currentSearchText)) {
        filterString = currentSearchText;
        if (adapter != null) {
            adapter.filterByString(filterString);
        }
    }
    if (!isUsingActionBar()) {
        lastQueryString = filterString;
    }
}

Output:
     final String currentSearchText = getSearchText().toString();
-    if (!"String_Node_Str".equals(currentSearchText) && incomingString.equals(currentSearchText)) {
+    if (incomingString.equals(currentSearchText)) {
         filterString = currentSearchText;


Input:
public SearchResults search(String namespaceId, String searchQuery, Set<EntityTypeSimpleName> types, SortInfo sortInfo, int offset, int limit, int numCursors, String cursor, boolean showHidden) {
    return SortInfo.DEFAULT.equals(sortInfo) ? searchByDefaultIndex(namespaceId, searchQuery, types, showHidden) : searchByCustomIndex(namespaceId, types, sortInfo, offset, limit, numCursors, cursor, showHidden);
}

Output:
 public SearchResults search(String namespaceId, String searchQuery, Set<EntityTypeSimpleName> types, SortInfo sortInfo, int offset, int limit, int numCursors, String cursor, boolean showHidden) {
-    return SortInfo.DEFAULT.equals(sortInfo) ? searchByDefaultIndex(namespaceId, searchQuery, types, showHidden) : searchByCustomIndex(namespaceId, types, sortInfo, offset, limit, numCursors, cursor, showHidden);
+    if (!SortInfo.DEFAULT.equals(sortInfo)) {
+        if (!"String_Node_Str".equals(searchQuery)) {
+            throw new IllegalArgumentException("String_Node_Str");
+        }
+        return searchByCustomIndex(namespaceId, types, sortInfo, offset, limit, numCursors, cursor, showHidden);
+    }
+    return searchByDefaultIndex(namespaceId, searchQuery, types, showHidden);
 }


Input:
public boolean createVcVms(List<NetworkAdd> networkAdds, List<BaseNode> vNodes, Map<String, Set<String>> occupiedIpSets, boolean reserveRawDisks, StatusUpdater statusUpdator) {
    if (vNodes.isEmpty()) {
        logger.info("String_Node_Str");
        return true;
    }
    updateNicLabels(vNodes);
    allocateStaticIp(vNodes, networkAdds, occupiedIpSets);
    Map<String, Folder> folders = createVcFolders(vNodes.get(0).getCluster());
    String clusterRpName = createVcResourcePools(vNodes);
    logger.info("String_Node_Str");
    VcVmUtil.updateVm(templateVm.getId());
    VmCreateSpec sourceSpec = new VmCreateSpec();
    sourceSpec.setVmId(templateVm.getId());
    sourceSpec.setVmName(templateVm.getName());
    sourceSpec.setTargetHost(templateVm.getHost());
    List<VmCreateSpec> specs = new ArrayList<VmCreateSpec>();
    Map<String, BaseNode> nodeMap = new HashMap<String, BaseNode>();
    for (BaseNode vNode : vNodes) {
        nodeMap.put(vNode.getVmName(), vNode);
        vNode.setSuccess(false);
        vNode.setFinished(false);
        VmCreateSpec spec = new VmCreateSpec();
        VmSchema createSchema = getVmSchema(vNode);
        spec.setSchema(createSchema);
        String defaultPgName = null;
        GuestMachineIdSpec machineIdSpec = new GuestMachineIdSpec(networkAdds, vNode.fetchPortGroupToIpV4Map(), vNode.getPrimaryMgtPgName());
        logger.info("String_Node_Str" + vNode.getVmName() + "String_Node_Str" + machineIdSpec.toString());
        spec.setBootupConfigs(machineIdSpec.toGuestVariable());
        StartVmPostPowerOn query = new StartVmPostPowerOn(vNode.getNics().keySet(), Constants.VM_POWER_ON_WAITING_SEC);
        spec.setPostPowerOn(query);
        spec.setPrePowerOn(getPrePowerOnFunc(vNode, reserveRawDisks));
        spec.setLinkedClone(false);
        spec.setTargetDs(getVcDatastore(vNode));
        spec.setTargetFolder(folders.get(vNode.getGroupName()));
        spec.setTargetHost(VcResourceUtils.findHost(vNode.getTargetHost()));
        spec.setTargetRp(getVcResourcePool(vNode, clusterRpName));
        spec.setVmName(vNode.getVmName());
        specs.add(spec);
    }
    UpdateVmProgressCallback callback = new UpdateVmProgressCallback(getLockClusterEntityMgr(), statusUpdator, vNodes.get(0).getClusterName());
    logger.info("String_Node_Str");
    AuAssert.check(specs.size() > 0);
    VmSchema vmSchema = specs.get(0).getSchema();
    VcVmUtil.checkAndCreateSnapshot(vmSchema);
    List<VmCreateResult<?>> results = cloneService.createCopies(sourceSpec, cloneConcurrency, specs, callback);
    if (results == null || results.isEmpty()) {
        for (VmCreateSpec spec : specs) {
            BaseNode node = nodeMap.get(spec.getVmName());
            node.setFinished(true);
            node.setSuccess(false);
        }
        return false;
    }
    boolean success = true;
    int total = 0;
    for (VmCreateResult<?> result : results) {
        VmCreateSpec spec = (VmCreateSpec) result.getSpec();
        BaseNode node = nodeMap.get(spec.getVmName());
        node.setVmMobId(spec.getVmId());
        node.setSuccess(true);
        node.setFinished(true);
        boolean vmSucc = VcVmUtil.setBaseNodeForVm(node, spec.getVmId());
        if (!vmSucc || !result.isSuccess()) {
            success = false;
            node.setSuccess(false);
            if (result.getErrMessage() != null) {
                node.setErrMessage(result.getErrTimestamp() + "String_Node_Str" + result.getErrMessage());
            } else {
                node.setErrMessage(result.getErrTimestamp() + "String_Node_Str" + node.getNodeAction());
            }
        } else {
            total++;
        }
    }
    logger.info(total + "String_Node_Str");
    return success;
}

Output:
                 node.setErrMessage(result.getErrTimestamp() + "String_Node_Str" + result.getErrMessage());
-            } else {
-                node.setErrMessage(result.getErrTimestamp() + "String_Node_Str" + node.getNodeAction());
+            } else if (!node.getErrMessage().isEmpty()) {
+                node.setErrMessage(CommonUtil.getCurrentTimestamp() + "String_Node_Str" + node.getNodeAction());
             }


Input:
public static String buildArtUrl(String host, Song song) {
    String artist = song.albumArtistName != null ? song.albumArtistName : song.artistName;
    return "String_Node_Str" + host + "String_Node_Str" + CastWebServer.PORT + "String_Node_Str" + artist + "String_Node_Str" + song.albumName;
}

Output:
     String artist = song.albumArtistName != null ? song.albumArtistName : song.artistName;
-    return "String_Node_Str" + host + "String_Node_Str" + CastWebServer.PORT + "String_Node_Str" + artist + "String_Node_Str" + song.albumName;
+    String album = song.albumName;
+    if (artist == null || album == null) {
+        return null;
+    }
+    return "String_Node_Str" + host + "String_Node_Str" + CastWebServer.PORT + "String_Node_Str" + artist + "String_Node_Str" + album;
 }


Input:
public Data calculateScores(List<? extends Scoreable> scoreableList) {
    frontEnd = getFrontEnd((List<ParallelToken>) scoreableList);
    return super.calculateScores(scoreableList);
}

Output:
 public Data calculateScores(List<? extends Scoreable> scoreableList) {
-    frontEnd = getFrontEnd((List<ParallelToken>) scoreableList);
+    frontEnd = getFrontEnd(scoreableList);
     return super.calculateScores(scoreableList);


Input:
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    if (!placedBall)
        placeBall();
    Bitmap bitmap = Bitmap.createBitmap(canvas.getWidth(), canvas.getHeight(), Bitmap.Config.ARGB_8888);
    Canvas temp = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setColor((check) ? backgroundColor : Color.parseColor("String_Node_Str"));
    paint.setStrokeWidth(Utils.dpToPx(2, getResources()));
    temp.drawLine(getHeight() / 2, getHeight() / 2, getWidth() - getHeight() / 2, getHeight() / 2, paint);
    Paint transparentPaint = new Paint();
    transparentPaint.setAntiAlias(true);
    transparentPaint.setColor(getResources().getColor(android.R.color.transparent));
    transparentPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
    temp.drawCircle(ViewHelper.getX(ball) + ball.getWidth() / 2, ViewHelper.getY(ball) + ball.getHeight() / 2, ball.getWidth() / 2, transparentPaint);
    canvas.drawBitmap(bitmap, 0, 0, new Paint());
    if (press) {
        paint.setColor((check) ? makePressColor() : Color.parseColor("String_Node_Str"));
        canvas.drawCircle(ViewHelper.getX(ball) + ball.getWidth() / 2, getHeight() / 2, getHeight() / 2, paint);
    }
    invalidate();
}

Output:
     paint.setAntiAlias(true);
-    paint.setColor((check) ? backgroundColor : Color.parseColor("String_Node_Str"));
+    paint.setColor((eventCheck) ? backgroundColor : Color.parseColor("String_Node_Str"));
     paint.setStrokeWidth(Utils.dpToPx(2, getResources()));


Input:
public void testSetScopeToResourceTestCase() throws Exception {
    userManagementClient1 = new UserManagementClient(keyManagerContext.getContextUrls().getBackEndUrl(), keyManagerContext.getContextTenant().getContextUser().getUserName(), keyManagerContext.getContextTenant().getContextUser().getPassword());
    userManagementClient1.addRole(SUBSCRIBER_ROLE, new String[] {}, new String[] { "String_Node_Str", "String_Node_Str" });
    String userJohn;
    String gatewayUrl;
    if (keyManagerContext.getContextTenant().getDomain().equals("String_Node_Str")) {
        gatewayUrl = gatewayUrlsWrk.getWebAppURLNhttp();
        userJohn = USER_JOHN;
    } else {
        gatewayUrl = gatewayUrlsWrk.getWebAppURLNhttp() + "String_Node_Str" + keyManagerContext.getContextTenant().getDomain() + "String_Node_Str";
        userJohn = USER_JOHN + "String_Node_Str" + keyManagerContext.getContextTenant().getDomain();
    }
    userManagementClient1.addUser(USER_JOHN, "String_Node_Str", new String[] { SUBSCRIBER_ROLE }, USER_JOHN);
    String apiContext = "String_Node_Str";
    String tags = "String_Node_Str";
    String url = getGatewayURLNhttp() + "String_Node_Str";
    String description = "String_Node_Str";
    apiPublisher.login(user.getUserName(), user.getPassword());
    APIRequest apiRequest = new APIRequest(API_NAME, apiContext, new URL(url));
    apiRequest.setTags(tags);
    apiRequest.setDescription(description);
    apiRequest.setVersion(API_VERSION);
    apiRequest.setProvider(user.getUserName());
    apiPublisher.addAPI(apiRequest);
    APILifeCycleStateRequest updateRequest = new APILifeCycleStateRequest(API_NAME, user.getUserName(), APILifeCycleState.PUBLISHED);
    apiPublisher.changeAPILifeCycleStatus(updateRequest);
    String modifiedResource = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    apiPublisher.updateResourceOfAPI(user.getUserName(), API_NAME, API_VERSION, modifiedResource);
    apiStore.login(user.getUserName(), user.getPassword());
    apiStore.addApplication(APP_NAME, APIMIntegrationConstants.APPLICATION_TIER.UNLIMITED, "String_Node_Str", "String_Node_Str");
    SubscriptionRequest subscriptionRequest = new SubscriptionRequest(API_NAME, user.getUserName());
    subscriptionRequest.setApplicationName(APP_NAME);
    apiStore.subscribe(subscriptionRequest);
    APPKeyRequestGenerator generateAppKeyRequest = new APPKeyRequestGenerator(APP_NAME);
    String responseString = apiStore.generateApplicationKey(generateAppKeyRequest).getData();
    JSONObject jsonResponse = new JSONObject(responseString);
    String consumerKey = jsonResponse.getJSONObject("String_Node_Str").getJSONObject("String_Node_Str").getString("String_Node_Str");
    String consumerSecret = jsonResponse.getJSONObject("String_Node_Str").getJSONObject("String_Node_Str").getString("String_Node_Str");
    URL tokenEndpointURL = new URL(gatewayUrlsWrk.getWebAppURLNhttp() + "String_Node_Str");
    String accessToken;
    Map<String, String> requestHeaders;
    HttpResponse response;
    URL endPointURL;
    String requestBody;
    JSONObject accessTokenGenerationResponse;
    requestBody = "String_Node_Str" + user.getUserName() + "String_Node_Str" + user.getPassword() + "String_Node_Str";
    waitForAPIDeploymentSync(user.getUserName(), API_NAME, API_VERSION, APIMIntegrationConstants.IS_API_EXISTS);
    response = apiStore.generateUserAccessKey(consumerKey, consumerSecret, requestBody, tokenEndpointURL);
    accessTokenGenerationResponse = new JSONObject(response.getData());
    accessToken = accessTokenGenerationResponse.getString("String_Node_Str");
    requestHeaders = new HashMap<String, String>();
    requestHeaders.put("String_Node_Str", "String_Node_Str" + accessToken);
    Thread.sleep(5000);
    response = HttpRequestUtil.doGet(gatewayUrl + "String_Node_Str", requestHeaders);
    assertEquals(response.getResponseCode(), Response.Status.OK.getStatusCode(), "String_Node_Str");
    endPointURL = new URL(gatewayUrl + "String_Node_Str");
    response = HttpRequestUtil.doPost(endPointURL, "String_Node_Str", requestHeaders);
    assertEquals(response.getResponseCode(), Response.Status.OK.getStatusCode(), "String_Node_Str");
    requestBody = "String_Node_Str" + userJohn + "String_Node_Str";
    accessTokenGenerationResponse = new JSONObject(apiStore.generateUserAccessKey(consumerKey, consumerSecret, requestBody, tokenEndpointURL).getData());
    accessToken = accessTokenGenerationResponse.getString("String_Node_Str");
    requestHeaders = new HashMap<String, String>();
    requestHeaders.put("String_Node_Str", "String_Node_Str" + accessToken);
    response = HttpRequestUtil.doGet(gatewayUrl + "String_Node_Str", requestHeaders);
    assertEquals(response.getResponseCode(), Response.Status.OK.getStatusCode(), "String_Node_Str");
    try {
        endPointURL = new URL(gatewayUrl + "String_Node_Str");
        response = HttpRequestUtil.doPost(endPointURL, "String_Node_Str", requestHeaders);
        assertTrue(response.getResponseCode() != Response.Status.OK.getStatusCode(), "String_Node_Str");
    } catch (Exception e) {
        log.error("String_Node_Str");
        assertTrue(true, "String_Node_Str");
    }
}

Output:
     String consumerSecret = jsonResponse.getJSONObject("String_Node_Str").getJSONObject("String_Node_Str").getString("String_Node_Str");
-    URL tokenEndpointURL = new URL(gatewayUrlsWrk.getWebAppURLNhttp() + "String_Node_Str");
+    URL tokenEndpointURL = new URL(gatewayUrlsWrk.getWebAppURLNhttp() + "String_Node_Str" + user.getUserDomain());
     String accessToken;


Input:
private boolean isSoldierAt(short x, short y, ESearchType searchType) {
    IMovable movable = movableGrid.getMovableAt(x, y);
    if (movable == null) {
        return false;
    } else {
        EMovableType type = movable.getMovableType();
        switch(searchType) {
            case SOLDIER_BOWMAN:
                return type == EMovableType.BOWMAN_L1 || type == EMovableType.BOWMAN_L2 || type == EMovableType.BOWMAN_L3;
            case SOLDIER_SWORDSMAN:
                return type == EMovableType.SWORDSMAN_L1 || type == EMovableType.SWORDSMAN_L2 || type == EMovableType.SWORDSMAN_L3;
            case SOLDIER_PIKEMAN:
                return type == EMovableType.PIKEMAN_L1 || type == EMovableType.PIKEMAN_L2 || type == EMovableType.PIKEMAN_L3;
            default:
                return false;
        }
    }
}

Output:
     } else {
-        EMovableType type = movable.getMovableType();
-        switch(searchType) {
-            case SOLDIER_BOWMAN:
-                return type == EMovableType.BOWMAN_L1 || type == EMovableType.BOWMAN_L2 || type == EMovableType.BOWMAN_L3;
-            case SOLDIER_SWORDSMAN:
-                return type == EMovableType.SWORDSMAN_L1 || type == EMovableType.SWORDSMAN_L2 || type == EMovableType.SWORDSMAN_L3;
-            case SOLDIER_PIKEMAN:
-                return type == EMovableType.PIKEMAN_L1 || type == EMovableType.PIKEMAN_L2 || type == EMovableType.PIKEMAN_L3;
-            default:
-                return false;
+        if (movable.getPlayer() == player && movable.canOccupyBuilding()) {
+            EMovableType type = movable.getMovableType();
+            switch(searchType) {
+                case SOLDIER_BOWMAN:
+                    return type == EMovableType.BOWMAN_L1 || type == EMovableType.BOWMAN_L2 || type == EMovableType.BOWMAN_L3;
+                case SOLDIER_SWORDSMAN:
+                    return type == EMovableType.SWORDSMAN_L1 || type == EMovableType.SWORDSMAN_L2 || type == EMovableType.SWORDSMAN_L3;
+                case SOLDIER_PIKEMAN:
+                    return type == EMovableType.PIKEMAN_L1 || type == EMovableType.PIKEMAN_L2 || type == EMovableType.PIKEMAN_L3;
+                default:
+                    return false;
+            }
+        } else {
+            return false;
         }


Input:
private SootMethod checkStatic(SootMethod ret) {
    if (ret.isStatic() != isStatic()) {
        if (Options.v().wrong_staticness() != Options.wrong_staticness_ignore && Options.v().wrong_staticness() != Options.wrong_staticness_fixstrict) {
            throw new ResolutionFailedException("String_Node_Str" + this + "String_Node_Str" + ret + "String_Node_Str");
        }
    }
    return ret;
}

Output:
 private SootMethod checkStatic(SootMethod ret) {
-    if (ret.isStatic() != isStatic()) {
-        if (Options.v().wrong_staticness() != Options.wrong_staticness_ignore && Options.v().wrong_staticness() != Options.wrong_staticness_fixstrict) {
-            throw new ResolutionFailedException("String_Node_Str" + this + "String_Node_Str" + ret + "String_Node_Str");
-        }
+    if ((Options.v().wrong_staticness() == Options.wrong_staticness_fail || Options.v().wrong_staticness() == Options.wrong_staticness_fixstrict) && ret.isStatic() != isStatic() && !ret.isPhantom()) {
+        throw new ResolutionFailedException("String_Node_Str" + this + "String_Node_Str" + ret + "String_Node_Str");
     }


Input:
private boolean mergeTransmutedItemStack(EntityPlayer entityPlayer, Slot transmutationOutputSlot, ItemStack itemStack, int slotMin, int slotMax, boolean ascending) {
    int numCanTransmute = MathHelper.floor(this.transmutationTablet.getAvailableEnergy().getValue() / EnergyValueRegistryProxy.getEnergyValue(itemStack).getValue());
    int numTransmuted = 0;
    ItemStack itemStack1 = itemStack.copy();
    itemStack1.stackSize = Math.min(numCanTransmute, itemStack1.getMaxStackSize());
    if (numCanTransmute <= 0) {
        return false;
    }
    int currentSlotIndex = ascending ? slotMax - 1 : slotMin;
    Slot slot;
    ItemStack stackInSlot;
    while (itemStack1.stackSize > 0 && (!ascending && currentSlotIndex < slotMax || ascending && currentSlotIndex >= slotMin)) {
        slot = (Slot) this.inventorySlots.get(currentSlotIndex);
        stackInSlot = slot.getStack();
        if (stackInSlot == null) {
            stackInSlot = itemStack1.copy();
            stackInSlot.stackSize = itemStack1.stackSize;
            slot.putStack(stackInSlot);
            numTransmuted = itemStack1.stackSize;
            itemStack1.stackSize = 0;
            slot.onSlotChanged();
        } else if (slot.isItemValid(itemStack1) && ItemStackUtils.equalsIgnoreStackSize(itemStack1, stackInSlot)) {
            int slotStackSizeLimit = Math.min(stackInSlot.getMaxStackSize(), slot.getSlotStackLimit());
            int combinedStackSize = stackInSlot.stackSize + itemStack1.stackSize;
            if (combinedStackSize <= slotStackSizeLimit) {
                stackInSlot.stackSize = combinedStackSize;
                numTransmuted = itemStack1.stackSize;
                itemStack1.stackSize = 0;
                slot.onSlotChanged();
            } else if (stackInSlot.stackSize < slotStackSizeLimit) {
                itemStack1.stackSize -= slotStackSizeLimit - stackInSlot.stackSize;
                stackInSlot.stackSize = slotStackSizeLimit;
                numTransmuted = itemStack1.stackSize;
                itemStack1.stackSize = 0;
                slot.onSlotChanged();
            }
        }
        currentSlotIndex += ascending ? -1 : 1;
    }
    ((SlotTabletOutput) transmutationOutputSlot).onShiftPickupFromSlot(entityPlayer, ItemStackUtils.clone(itemStack, numTransmuted));
    return false;
}

Output:
             } else if (stackInSlot.stackSize < slotStackSizeLimit) {
-                itemStack1.stackSize -= slotStackSizeLimit - stackInSlot.stackSize;
+                itemStack1.stackSize = slotStackSizeLimit - stackInSlot.stackSize;
                 stackInSlot.stackSize = slotStackSizeLimit;


Input:
public static Node lookupTopologyNode(ServiceFunctionForwarder serviceFunctionForwarder) {
    List<SffDataPlaneLocator> sffDplList = serviceFunctionForwarder.getSffDataPlaneLocator();
    IpAddress ip = null;
    if (sffDplList == null) {
        LOG.debug("String_Node_Str", serviceFunctionForwarder);
        return null;
    }
    for (SffDataPlaneLocator sffDpl : sffDplList) {
        if (sffDpl.getDataPlaneLocator() != null && sffDpl.getDataPlaneLocator().getLocatorType() != null) {
            Class<? extends DataContainer> locatorType = sffDpl.getDataPlaneLocator().getLocatorType().getImplementedInterface();
            if (locatorType.isAssignableFrom(Ip.class)) {
                Ip ipPortLocator = (Ip) sffDpl.getDataPlaneLocator().getLocatorType();
                IpAddress ipAddress = new IpAddress(ipPortLocator.getIp().getValue());
                ip = ipAddress;
            }
        }
    }
    if (ip == null) {
        LOG.debug("String_Node_Str", serviceFunctionForwarder);
        return null;
    }
    return SfcOvsUtil.getManagerNodeByIp(ip);
}

Output:
                 Ip ipPortLocator = (Ip) sffDpl.getDataPlaneLocator().getLocatorType();
-                IpAddress ipAddress = new IpAddress(ipPortLocator.getIp().getValue());
-                ip = ipAddress;
+                ip = new IpAddress(ipPortLocator.getIp().getValue());
             }


Input:
protected static List<IComponent> getRelatedComponents(final IComponentsFactory compFac, String keyword, boolean needCheckVisible) {
    Set<IComponent> componentSet = null;
    IComponentsHandler componentsHandler = compFac.getComponentsHandler();
    if (compFac != null && keyword != null && 0 < keyword.trim().length()) {
        Map<String, Map<String, Set<IComponent>>> componentNameMap = compFac.getComponentNameMap();
        String filterString = keyword.trim();
        if (componentNameMap != null) {
            Map<String, Set<IComponent>> map = componentNameMap.get(filterString.toLowerCase());
            if (map != null) {
                Collection<Set<IComponent>> componentSets = map.values();
                Iterator<Set<IComponent>> componentSetIter = componentSets.iterator();
                List<IComponent> filteredComponent = new ArrayList<IComponent>();
                while (componentSetIter.hasNext()) {
                    filteredComponent.addAll(componentSetIter.next());
                }
                if (componentsHandler != null) {
                    filteredComponent = componentsHandler.filterComponents(filteredComponent);
                }
                Iterator<IComponent> componentIter = filteredComponent.iterator();
                while (componentIter.hasNext()) {
                    if (!ComponentUtilities.isComponentVisible(componentIter.next())) {
                        componentIter.remove();
                    }
                }
                componentSet = new HashSet<IComponent>(filteredComponent);
            }
        }
        if ((componentSet == null || componentSet.isEmpty()) && componentNameMap != null) {
            componentSet = new HashSet<IComponent>();
            addComponentsByNameFilter(compFac, componentSet, keyword);
            boolean shouldSearchFromHelpAPI = PaletteSettingsPreferencePage.isPaletteSearchFromHelp();
            if (shouldSearchFromHelpAPI) {
                Set<String> componentNames = getRelatedComponentNamesFromHelp(filterString);
                if (componentNames != null && 0 < componentNames.size()) {
                    int limit = PaletteSettingsPreferencePage.getPaletteSearchResultLimitFromHelp();
                    int i = 0;
                    Iterator<String> nameIter = componentNames.iterator();
                    while (nameIter.hasNext()) {
                        if (limit <= i) {
                            break;
                        }
                        String componentName = nameIter.next();
                        Map<String, Set<IComponent>> map = componentNameMap.get(componentName.toLowerCase());
                        if (map == null) {
                            continue;
                        }
                        Set<IComponent> findedComponents = map.get(componentName);
                        if (findedComponents != null && !findedComponents.isEmpty()) {
                            for (IComponent iComponent : findedComponents) {
                                if (limit <= i) {
                                    break;
                                }
                                if (ComponentUtilities.isComponentVisible(iComponent) && !iComponent.isTechnical() && filterComponent(iComponent, componentsHandler)) {
                                    componentSet.add(iComponent);
                                    i++;
                                }
                            }
                        }
                    }
                }
            }
        }
    } else if (compFac != null) {
        componentSet = compFac.getComponents();
    }
    List<IComponent> relatedComponents = null;
    if (componentSet == null || componentSet.isEmpty()) {
        relatedComponents = new LinkedList<IComponent>();
    } else {
        relatedComponents = new LinkedList<IComponent>(componentSet);
    }
    if (compFac != null && componentsHandler != null && !relatedComponents.isEmpty()) {
        relatedComponents = componentsHandler.filterComponents(relatedComponents);
    }
    if (needCheckVisible && relatedComponents != null && !relatedComponents.isEmpty()) {
        Iterator<IComponent> iter = relatedComponents.iterator();
        while (iter.hasNext()) {
            IComponent component = iter.next();
            if (component == null || !ComponentUtilities.isComponentVisible(component) || component.isTechnical()) {
                iter.remove();
            }
        }
    }
    return relatedComponents;
}

Output:
     IComponentsHandler componentsHandler = compFac.getComponentsHandler();
-    if (compFac != null && keyword != null && 0 < keyword.trim().length()) {
+    String lowerCasedKeyword = null;
+    if (keyword != null) {
+        lowerCasedKeyword = keyword.toLowerCase().trim();
+    }
+    if (compFac != null && lowerCasedKeyword != null && 0 < lowerCasedKeyword.length()) {
         Map<String, Map<String, Set<IComponent>>> componentNameMap = compFac.getComponentNameMap();


Input:
public void download(File saveFile, boolean overwrite) throws SaveLocationException {
    downloadManager.downloadTorrent(saveFile, overwrite);
}

Output:
 public void download(File saveFile, boolean overwrite) throws SaveLocationException {
-    downloadManager.downloadTorrent(saveFile, overwrite);
+    downloadManager.downloadTorrent(torrentFile, overwrite);
 }


Input:
public void startDeployingWebAPPs() throws Exception {
    super.init();
    String testArtifactPath = TestConfigurationProvider.getResourceLocation() + File.separator + "String_Node_Str" + File.separator + "String_Node_Str" + File.separator;
    String testArtifactWarFilePath = testArtifactPath + "String_Node_Str" + File.separator;
    String APIStatusMonitorWebAppSourcePath = testArtifactPath + "String_Node_Str" + File.separator + APIMIntegrationConstants.AM_MONITORING_WEB_APP_NAME + "String_Node_Str";
    String APIImportExportWebAppSourcePath = testArtifactPath + "String_Node_Str" + File.separator + APIMIntegrationConstants.AM_IMPORT_EXPORT_WEB_APP_NAME + "String_Node_Str";
    String gatewayMgtSessionId = createSession(gatewayContextMgt);
    String publisherSessionId = createSession(publisherContext);
    WebAppAdminClient webAppAdminClient = new WebAppAdminClient(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId);
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.JAXRS_BASIC_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.PRODEP1_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.PRODEP2_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.PRODEP3_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.SANDBOXEP1_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.SANDBOXEP2_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(testArtifactWarFilePath + APIMIntegrationConstants.SANDBOXEP3_WEB_APP_NAME + "String_Node_Str");
    webAppAdminClient.uploadWarFile(APIStatusMonitorWebAppSourcePath);
    WebAppAdminClient webAppAdminClientForPublisher = new WebAppAdminClient(getPublisherURLHttps(), publisherSessionId);
    webAppAdminClientForPublisher.uploadWarFile(APIImportExportWebAppSourcePath);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.JAXRS_BASIC_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.PRODEP1_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.PRODEP2_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.PRODEP3_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.SANDBOXEP1_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.SANDBOXEP2_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.SANDBOXEP3_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(gatewayContextMgt.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.AM_MONITORING_WEB_APP_NAME);
    WebAppDeploymentUtil.isWebApplicationDeployed(publisherContext.getContextUrls().getBackEndUrl(), gatewayMgtSessionId, APIMIntegrationConstants.AM_IMPORT_EXPORT_WEB_APP_NAME);
    WebAppDeploymentUtil.isMonitoringAppDeployed(gatewayContextWrk.getContextUrls().getWebAppURL());
}

Output:
     webAppAdminClient.uploadWarFile(APIStatusMonitorWebAppSourcePath);
-    WebAppAdminClient webAppAdminClientForPublisher = new WebAppAdminClient(getPublisherURLHttps(), publisherSessionId);
+    WebAppAdminClient webAppAdminClientForPublisher = new WebAppAdminClient(publisherContext.getContextUrls().getBackEndUrl(), publisherSessionId);
     webAppAdminClientForPublisher.uploadWarFile(APIImportExportWebAppSourcePath);


Input:
public static void read(List<DLNAResource> playlist, File f) throws IOException {
    if (!f.exists()) {
        return;
    }
    try (BufferedReader in = new BufferedReader(new FileReader(f))) {
        String str;
        while ((str = in.readLine()) != null) {
            if (org.apache.commons.lang.StringUtils.isEmpty(str)) {
                continue;
            }
            if (str.startsWith("String_Node_Str")) {
                continue;
            }
            str = str.trim();
            if (!str.startsWith("String_Node_Str")) {
                continue;
            }
            str = str.substring(7);
            int pos = str.indexOf(';');
            if (pos == -1) {
                continue;
            }
            String master = str.substring(0, pos);
            str = str.substring(pos + 1);
            pos = str.indexOf(';');
            String subData = null;
            String resData = null;
            DLNAResource res = null;
            Player player = null;
            while (pos != -1) {
                if (str.startsWith("String_Node_Str")) {
                    player = findPlayer(str.substring(7, pos));
                }
                if (str.startsWith("String_Node_Str")) {
                    resData = str.substring(6, pos);
                }
                if (str.startsWith("String_Node_Str")) {
                    subData = str.substring(3, pos);
                }
                str = str.substring(pos + 1);
                pos = str.indexOf(';');
            }
            LOGGER.debug("String_Node_Str" + master + "String_Node_Str" + str);
            ExternalListener external;
            if (master.startsWith("String_Node_Str")) {
                res = parse(master.substring(9), str);
            } else {
                external = findMasterParent(master);
                if (external != null) {
                    res = resolveCreateMethod(external, str);
                    if (res != null) {
                        LOGGER.debug("String_Node_Str" + res + "String_Node_Str" + external);
                        res.setMasterParent(external);
                    }
                }
            }
            if (res != null) {
                if (resData != null) {
                    ResumeObj r = new ResumeObj(new File(resData));
                    if (!r.isDone()) {
                        r.read();
                        res.setResume(r);
                    }
                }
                res.setPlayer(player);
                if (subData != null) {
                    DLNAMediaSubtitle s = res.getMediaSubtitle();
                    if (s == null) {
                        s = new DLNAMediaSubtitle();
                        res.setMediaSubtitle(s);
                    }
                    String[] tmp = subData.split("String_Node_Str");
                    s.setLang(tmp[0]);
                    subData = tmp[1];
                    if (subData.startsWith("String_Node_Str")) {
                        String sFile = subData.substring(5);
                        s.setExternalFile(new File(sFile));
                        s.setId(100);
                        SubtitleType t = SubtitleType.valueOfFileExtension(FileUtil.getExtension(sFile));
                        s.setType(t);
                    } else if (subData.startsWith("String_Node_Str")) {
                        s.setId(Integer.parseInt(subData.substring(3)));
                    }
                }
                playlist.add(res);
            }
        }
    }
}

Output:
                         String sFile = subData.substring(5);
-                        s.setExternalFile(new File(sFile));
+                        s.setExternalFile(new File(sFile), null);
                         s.setId(100);


Input:
private ServiceDocumentImpl readServiceDocument(final JsonReader reader) throws EntityProviderException {
    try {
        reader.beginObject();
        currentHandledObjectName = reader.nextName();
        if (FormatJson.D.equals(currentHandledObjectName)) {
            reader.beginObject();
            readContent(reader);
            reader.endObject();
        }
        reader.endObject();
        reader.peek();
        reader.close();
    } catch (final IOException e) {
        throw new EntityProviderException(EntityProviderException.COMMON, e);
    } catch (final IllegalStateException e) {
        throw new EntityProviderException(EntityProviderException.COMMON.addContent("String_Node_Str"));
    } catch (final EdmException e) {
        throw new EntityProviderException(EntityProviderException.COMMON, e);
    } catch (final ODataException e) {
        throw new EntityProviderException(EntityProviderException.COMMON, e);
    }
    return new ServiceDocumentImpl().setEntitySetsInfo(entitySets);
}

Output:
     } catch (final IllegalStateException e) {
-        throw new EntityProviderException(EntityProviderException.COMMON.addContent("String_Node_Str"));
+        throw new EntityProviderException(EntityProviderException.COMMON.addContent("String_Node_Str"), e);
     } catch (final EdmException e) {


Input:
protected void updateCacheListenerConfigOnOtherNodes(CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration, boolean isRegister) {
    final Collection<Member> members = clientContext.getClusterService().getMemberList();
    final HazelcastClientInstanceImpl client = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
    final Collection<Future> futures = new ArrayList<Future>();
    for (Member member : members) {
        try {
            final Address address = member.getAddress();
            Data configData = toData(cacheEntryListenerConfiguration);
            final ClientMessage request = CacheListenerRegistrationCodec.encodeRequest(nameWithPrefix, configData, isRegister, address);
            final ClientInvocation invocation = new ClientInvocation(client, request, address);
            final Future future = invocation.invoke();
            futures.add(future);
        } catch (Exception e) {
            ExceptionUtil.sneakyThrow(e);
        }
    }
}

Output:
             final ClientInvocation invocation = new ClientInvocation(client, request, address);
-            final Future future = invocation.invoke();
-            futures.add(future);
+            invocation.invoke();
         } catch (Exception e) {


Input:
Object fromSuperColumnThriftRow(Class clazz, EntityMetadata m, ThriftRow tr, List<String> relationNames, boolean isWrapReq) throws Exception {
    Object entity = null;
    Map<String, Set<String>> foreignKeysMap = new HashMap<String, Set<String>>();
    Map<String, Field> columnNameToFieldMap = new HashMap<String, Field>();
    Map<String, Field> superColumnNameToFieldMap = new HashMap<String, Field>();
    MetadataUtils.populateColumnAndSuperColumnMaps(m, columnNameToFieldMap, superColumnNameToFieldMap);
    Collection embeddedCollection = null;
    Field embeddedCollectionField = null;
    Map<String, Object> relations = new HashMap<String, Object>();
    for (SuperColumn sc : tr.getSuperColumns()) {
        if (entity == null) {
            entity = clazz.newInstance();
            PropertyAccessorHelper.setId(entity, m, tr.getId());
        }
        String scName = PropertyAccessorFactory.STRING.fromBytes(String.class, sc.getName());
        String scNamePrefix = null;
        if (scName.indexOf(Constants.EMBEDDED_COLUMN_NAME_DELIMITER) != -1) {
            scNamePrefix = MetadataUtils.getEmbeddedCollectionPrefix(scName);
            embeddedCollectionField = superColumnNameToFieldMap.get(scNamePrefix);
            if (embeddedCollection == null) {
                embeddedCollection = MetadataUtils.getEmbeddedCollectionInstance(embeddedCollectionField);
            }
            Object embeddedObject = MetadataUtils.getEmbeddedGenericObjectInstance(embeddedCollectionField);
            for (Column column : sc.getColumns()) {
                String name = PropertyAccessorFactory.STRING.fromBytes(String.class, column.getName());
                byte[] value = column.getValue();
                if (value == null) {
                    continue;
                }
                Field columnField = columnNameToFieldMap.get(name);
                if (columnField != null) {
                    PropertyAccessorHelper.set(embeddedObject, columnField, value);
                } else if (relationNames != null && !relationNames.isEmpty() && relationNames.contains(name)) {
                    String valueAsStr = PropertyAccessorFactory.STRING.fromBytes(String.class, value);
                    relations.put(name, valueAsStr);
                }
            }
            embeddedCollection.add(embeddedObject);
            ElementCollectionCacheManager.getInstance().addElementCollectionCacheMapping(tr.getId(), embeddedObject, scName);
        } else {
            Field superColumnField = superColumnNameToFieldMap.get(scName);
            Object superColumnObj = null;
            if (superColumnField != null || (relationNames != null && !relationNames.isEmpty() && relationNames.contains(scName))) {
                Class superColumnClass = superColumnField != null ? superColumnField.getType() : null;
                superColumnObj = superColumnClass != null ? superColumnClass.newInstance() : null;
                for (Column column : sc.getColumns()) {
                    String name = PropertyAccessorFactory.STRING.fromBytes(String.class, column.getName());
                    byte[] value = column.getValue();
                    Field columnField = columnNameToFieldMap.get(name);
                    if (columnField != null) {
                        try {
                            PropertyAccessorHelper.set(superColumnObj, columnField, value);
                        } catch (PropertyAccessException e) {
                            log.debug(e.getMessage() + "String_Node_Str");
                            superColumnObj = Bytes.toUTF8(value);
                        }
                    } else {
                        String valueAsStr = PropertyAccessorFactory.STRING.fromBytes(String.class, value);
                        relations.put(name, valueAsStr);
                    }
                }
            }
            if (superColumnField != null) {
                PropertyAccessorHelper.set(entity, superColumnField, superColumnObj);
            }
        }
    }
    if (embeddedCollection != null && !embeddedCollection.isEmpty()) {
        PropertyAccessorHelper.set(entity, embeddedCollectionField, embeddedCollection);
    }
    return isWrapReq && relations != null && !relations.isEmpty() ? new EnhanceEntity(entity, tr.getId(), relations) : entity;
}

Output:
                             log.debug(e.getMessage() + "String_Node_Str");
-                            superColumnObj = Bytes.toUTF8(value);
+                            com.impetus.kundera.metadata.model.Column col = m.getColumn(name);
+                            if (col != null) {
+                                superColumnObj = Bytes.toUTF8(value);
+                            }
                         }


Input:
public void removeEntity(Entity e) {
    Vector3 pos = e.getPosition().floor();
    if (blockControllers.containsKey(pos)) {
        blockControllers.remove(pos);
    }
    if (removeQueue.contains(e)) {
        return;
    }
    if (spawnQueue.contains(e)) {
        spawnQueue.remove(e);
        return;
    }
    removeQueue.add(e);
}

Output:
     }
-    if (removeQueue.contains(e)) {
-        return;
-    }
-    if (spawnQueue.contains(e)) {
-        spawnQueue.remove(e);
-        return;
-    }
-    removeQueue.add(e);
+    this.deallocate((SpoutEntity) e);
 }


Input:
public void registerEntitys() {
    BiomeGenBase[] allBiomes = BiomeGenBase.getBiomeGenArray();
    allBiomes = allBiomes.clone();
    allBiomes[9] = null;
    allBiomes[8] = null;
    BiomeGenBase[] allBiomesNoVampire = allBiomes.clone();
    int vId = ModBiomes.biomeVampireForest.biomeID;
    if (vId > 0 && vId < allBiomes.length) {
        allBiomesNoVampire[vId] = null;
    }
    BiomeGenBase[] biomes = Iterators.toArray(Iterators.filter(Iterators.forArray(allBiomes), Predicates.notNull()), BiomeGenBase.class);
    allBiomesNoVampire = Iterators.toArray(Iterators.filter(Iterators.forArray(allBiomesNoVampire), Predicates.notNull()), BiomeGenBase.class);
    registerEntity(EntityVampireHunter.class, REFERENCE.ENTITY.VAMPIRE_HUNTER_NAME, BALANCE.VAMPIRE_HUNTER_SPAWN_PROBE, 1, 2, EnumCreatureType.creature, allBiomesNoVampire);
    registerEntity(EntityVampire.class, REFERENCE.ENTITY.VAMPIRE_NAME, BALANCE.VAMPIRE_SPAWN_PROBE, 1, 3, EnumCreatureType.monster, allBiomesNoVampire);
    registerEntity(EntityVampireBaron.class, REFERENCE.ENTITY.VAMPIRE_BARON, true);
    EntityList.stringToClassMapping.put("String_Node_Str", EntityVampireBaron.class);
    registerEntity(EntitySaveableVampireMinion.class, REFERENCE.ENTITY.VAMPIRE_MINION_SAVEABLE_NAME, false);
    registerEntity(EntityRemoteVampireMinion.class, REFERENCE.ENTITY.VAMPIRE_MINION_REMOTE_NAME, false);
    registerEntity(EntityDeadMob.class, REFERENCE.ENTITY.DEAD_MOB_NAME, false);
    registerEntity(EntityDracula.class, REFERENCE.ENTITY.DRACULA_NAME, false);
    registerEntity(EntityGhost.class, REFERENCE.ENTITY.GHOST_NAME, true);
    registerEntity(EntityBlindingBat.class, REFERENCE.ENTITY.BLINDING_BAT_NAME, false);
    registerEntity(EntityDummyBittenAnimal.class, REFERENCE.ENTITY.DUMMY_CREATURE, false);
    registerEntity(EntityPortalGuard.class, REFERENCE.ENTITY.PORTAL_GUARD, true);
    Item item = new ItemSpawnEgg(spawnableEntityNames);
    GameRegistry.registerItem(item, ItemSpawnEgg.name);
    OreDictionary.registerOre("String_Node_Str", item);
}

Output:
     BiomeGenBase[] allBiomes = BiomeGenBase.getBiomeGenArray();
-    allBiomes = allBiomes.clone();
+    allBiomes = Arrays.copyOf(allBiomes, allBiomes.length);
     allBiomes[9] = null;


Input:
public CacheManager getCacheManager() {
    return Caching.getCacheManager(cacheManagerName);
}

Output:
 public CacheManager getCacheManager() {
-    return Caching.getCacheManager(cacheManagerName);
+    return Caching.getCacheManager(classLoader, cacheManagerName);
 }


Input:
public void onTrackStart(AudioPlayer player, AudioTrack track) {
    current = track;
    if (track.getUserData() != null) {
        AudioTrackInfo info = track.getInfo();
        track.getUserData(ExtraTrackInfo.class).textChannel.sendMessage("String_Node_Str" + mentionClean(info.title) + "String_Node_Str" + Bot.formatDuration(info.length / 1000L) + "String_Node_Str").queue();
    }
}

Output:
 public void onTrackStart(AudioPlayer player, AudioTrack track) {
-    current = track;
-    if (track.getUserData() != null) {
-        AudioTrackInfo info = track.getInfo();
-        track.getUserData(ExtraTrackInfo.class).textChannel.sendMessage("String_Node_Str" + mentionClean(info.title) + "String_Node_Str" + Bot.formatDuration(info.length / 1000L) + "String_Node_Str").queue();
+    try {
+        current = track;
+        if (track.getUserData() != null) {
+            AudioTrackInfo info = track.getInfo();
+            track.getUserData(ExtraTrackInfo.class).textChannel.sendMessage("String_Node_Str" + mentionClean(info.title) + "String_Node_Str" + Bot.formatDuration(info.length / 1000L) + "String_Node_Str").queue();
+        }
+    } catch (PermissionException ignored) {
     }


Input:
protected void handleAttributes(Attributes atts) {
    for (int i = 0; i < atts.getLength(); i++) {
        if ((atts.getQName(i) != null && atts.getQName(i).startsWith(XMLConstants.XMLNS + "String_Node_Str"))) {
            continue;
        }
        attribute(atts.getURI(i), atts.getLocalName(i), atts.getQName(i), atts.getValue(i));
    }
}

Output:
     for (int i = 0; i < atts.getLength(); i++) {
-        if ((atts.getQName(i) != null && atts.getQName(i).startsWith(XMLConstants.XMLNS + "String_Node_Str"))) {
+        if ((atts.getQName(i) != null && (atts.getQName(i).startsWith(XMLConstants.XMLNS + "String_Node_Str") || atts.getQName(i).equals(XMLConstants.XMLNS)))) {
             continue;


Input:
public void run() {
    if (!connectionManager.isLive()) {
        String message = "String_Node_Str" + address + "String_Node_Str";
        log(Level.FINEST, message);
        return;
    }
    try {
        connectionManager.ioService.onIOThreadStart();
        log(Level.FINEST, "String_Node_Str" + address);
        final Address thisAddress = connectionManager.ioService.getThisAddress();
        if (address.isIPv4()) {
            tryToConnect(address.getInetSocketAddress(), 0);
        } else if (thisAddress.isIPv6() && thisAddress.getScopeId() != null) {
            final Inet6Address inetAddress = AddressUtil.getInetAddressFor((Inet6Address) address.getInetAddress(), thisAddress.getScopeId());
            tryToConnect(new InetSocketAddress(inetAddress, address.getPort()), 0);
        } else {
            final Collection<Inet6Address> possibleInetAddresses = AddressUtil.getPossibleInetAddressesFor((Inet6Address) address.getInetAddress());
            log(Level.INFO, "String_Node_Str" + possibleInetAddresses);
            boolean connected = false;
            Exception error = null;
            for (Inet6Address inetAddress : possibleInetAddresses) {
                try {
                    tryToConnect(new InetSocketAddress(inetAddress, address.getPort()), 3000);
                    connected = true;
                    break;
                } catch (Exception e) {
                    error = e;
                }
            }
            if (!connected) {
                throw error;
            }
        }
    } catch (Throwable e) {
        logger.log(Level.FINEST, e.getMessage(), e);
        connectionManager.failedConnection(address, e, silent);
    }
}

Output:
             final Collection<Inet6Address> possibleInetAddresses = AddressUtil.getPossibleInetAddressesFor((Inet6Address) address.getInetAddress());
-            log(Level.INFO, "String_Node_Str" + possibleInetAddresses);
+            final Level level = silent ? Level.FINEST : Level.INFO;
+            log(level, "String_Node_Str" + possibleInetAddresses);
             boolean connected = false;


Input:
public void noValueException() {
    final Integer key = 123;
    final String setValue = "String_Node_Str";
    Cache.EntryProcessor<Integer, String, Void> processor = new MockEntryProcessor<Integer, String, Void>() {
        public Void process(Cache.MutableEntry<Integer, String> entry, Object... arguments) {
            assertFalse(entry.exists());
            entry.setValue(setValue);
            assertTrue(entry.exists());
            throw new IllegalAccessError();
        }
    };
    try {
        cache.invokeEntryProcessor(key, processor);
        fail();
    } catch (IllegalAccessError e) {
    }
    assertFalse(cache.containsKey(key));
}

Output:
         fail();
-    } catch (IllegalAccessError e) {
+    } catch (CacheException e) {
+        assertTrue(e.getCause() instanceof IllegalAccessError);
     }


Input:
public void addEdge(T src, T dst) {
    delegate.addEdge(src, dst);
    SimpleVector<T> s = successorEdges.get(src);
    if (s == null) {
        s = new SimpleVector<T>();
        successorEdges.put(src, s);
    }
    s.set(s.getMaxIndex() + 1, dst);
}

Output:
     }
-    s.set(s.getMaxIndex() + 1, dst);
+    s.set(i, dst);
 }


Input:
public static String buildEqualsWhere(Entity entity, List<Object> paramValues) {
    if (null == entity || entity.isEmpty()) {
        return StrUtil.EMPTY;
    }
    final StringBuilder sb = new StringBuilder("String_Node_Str");
    for (Entry<String, Object> entry : entity.entrySet()) {
        if (paramValues.size() > 0) {
            sb.append("String_Node_Str");
        }
        sb.append("String_Node_Str").append(entry.getKey()).append("String_Node_Str").append("String_Node_Str");
        paramValues.add(entry.getValue());
    }
    return sb.toString();
}

Output:
     for (Entry<String, Object> entry : entity.entrySet()) {
-        if (paramValues.size() > 0) {
+        if (isNotFirst) {
             sb.append("String_Node_Str");


Input:
public Map<Partner, List<SalesOrderLine>> splitBySupplierPartner(List<SalesOrderLine> salesOrderLineList) {
    Map<Partner, List<SalesOrderLine>> salesOrderLinesBySupplierPartner = new HashMap<Partner, List<SalesOrderLine>>();
    for (SalesOrderLine salesOrderLine : salesOrderLineList) {
        Partner supplierPartner = salesOrderLine.getSupplierPartner();
        if (!salesOrderLinesBySupplierPartner.containsKey(supplierPartner)) {
            salesOrderLinesBySupplierPartner.put(supplierPartner, new ArrayList<SalesOrderLine>());
        }
        salesOrderLinesBySupplierPartner.get(supplierPartner).add(salesOrderLine);
    }
    return salesOrderLinesBySupplierPartner;
}

Output:
     for (SalesOrderLine salesOrderLine : salesOrderLineList) {
-        Partner supplierPartner = salesOrderLine.getSupplierPartner();
-        if (!salesOrderLinesBySupplierPartner.containsKey(supplierPartner)) {
-            salesOrderLinesBySupplierPartner.put(supplierPartner, new ArrayList<SalesOrderLine>());
+        if (salesOrderLine.getSaleSupplySelect() == IProduct.SALE_SUPPLY_PURCHASE) {
+            Partner supplierPartner = salesOrderLine.getSupplierPartner();
+            if (!salesOrderLinesBySupplierPartner.containsKey(supplierPartner)) {
+                salesOrderLinesBySupplierPartner.put(supplierPartner, new ArrayList<SalesOrderLine>());
+            }
+            salesOrderLinesBySupplierPartner.get(supplierPartner).add(salesOrderLine);
         }


Input:
public void hostedVirtLimitSubUpdatesUnlimitedBonusVirtOnlyPool() {
    when(configMock.getBoolean(ConfigProperties.STANDALONE)).thenReturn(false);
    Pool p = createVirtLimitPool("String_Node_Str", 10, 10);
    p.getProduct().setAttribute("String_Node_Str", "String_Node_Str");
    List<Pool> pools = poolRules.createAndEnrichPools(p, new LinkedList<Pool>());
    assertEquals(2, pools.size());
    Pool virtBonusPool = pools.get(1);
    assertEquals(new Long(-1), virtBonusPool.getQuantity());
    p.getProduct().setAttribute("String_Node_Str", "String_Node_Str");
    List<PoolUpdate> updates = poolRules.updatePools(p, pools, TestUtil.stubChangedProducts(p.getProduct()));
    assertEquals(2, updates.size());
    PoolUpdate virtUpdate = updates.get(1);
    assertEquals(new Long(100), virtUpdate.getPool().getQuantity());
}

Output:
     p.getProduct().setAttribute("String_Node_Str", "String_Node_Str");
-    List<PoolUpdate> updates = poolRules.updatePools(p, pools, TestUtil.stubChangedProducts(p.getProduct()));
+    List<PoolUpdate> updates = poolRules.updatePools(p, pools, p.getQuantity(), TestUtil.stubChangedProducts(p.getProduct()));
     assertEquals(2, updates.size());


Input:
public ArrayList<DownloadLink> decryptIt(CryptedLink param, ProgressController progress) throws Exception {
    ArrayList<DownloadLink> ar = decryptItMain(param);
    if (ar.size() > 1) {
        SJTable sjt = new SJTable(SimpleGUI.CURRENTGUI.getFrame(), ar);
        ar = sjt.dls;
    }
    ArrayList<DownloadLink> decryptedLinks = new ArrayList<DownloadLink>();
    SerienjunkiesThread[] threads = new SerienjunkiesThread[ar.size()];
    this.progress = progress;
    for (int i = 0; i < threads.length; i++) {
        DownloadLink downloadLink = ar.get(i);
        threads[i] = new SerienjunkiesThread(downloadLink, param);
        threads[i].start();
    }
    for (int i = 0; i < threads.length; i++) {
        if (ar.get(i) != null) {
            while (threads[i].isAlive()) {
                synchronized (threads[i]) {
                    threads[i].wait();
                }
            }
            if (threads[i].result != null)
                decryptedLinks.addAll(threads[i].result);
        }
    }
    return decryptedLinks;
}

Output:
     if (ar.size() > 1) {
-        SJTable sjt = new SJTable(SimpleGUI.CURRENTGUI.getFrame(), ar);
+        SerienjunkiesSJTable sjt = new SerienjunkiesSJTable(SimpleGUI.CURRENTGUI.getFrame(), ar);
         ar = sjt.dls;