Input:
void connectNodes() {
    setupSearch();
    int indexCornerList = 0;
    for (int indexNode = 0; indexNode < nodes.size(); indexNode++) {
        SquareNode n = nodes.get(indexNode);
        for (int indexLocal = 0; indexLocal < n.corners.size(); indexLocal++) {
            if (n.touch.get(indexLocal))
                continue;
            double[] point = searchPoints.get(indexCornerList++);
            searchResults.reset();
            search.findNearest(point, maxCornerDistance * maxCornerDistance, maxNeighbors + 1, searchResults);
            for (int indexResults = 0; indexResults < searchResults.size(); indexResults++) {
                NnData<SquareNode> neighborData = searchResults.get(indexResults);
                SquareNode neighborNode = neighborData.data;
                if (neighborNode == n)
                    continue;
                int neighborCornerIndex = getCornerIndex(neighborNode, neighborData.point[0], neighborData.point[1]);
                if (candidateIsMuchCloser(n, neighborNode, neighborData.distance))
                    considerConnect(n, indexLocal, neighborNode, neighborCornerIndex, neighborData.distance);
            }
        }
    }
}

Output:
         for (int indexLocal = 0; indexLocal < n.corners.size(); indexLocal++) {
-            if (n.touch.get(indexLocal))
+            if (n.touch.size > 0 && n.touch.get(indexLocal))
                 continue;


Input:
public void run() {
    running = true;
    init();
    if (files != null) {
        for (File currentFile : files) {
            if (cancelled) {
                Log.v(TAG, "String_Node_Str");
                return;
            }
            progress++;
            updateProgress(progress, totalCount);
            if (currentFile.getName().equalsIgnoreCase(FileUtils.NOMEDIA_FILE_NAME))
                noMedia = true;
            if (!displayHidden && currentFile.isHidden()) {
                continue;
            }
            if (currentFile.isDirectory()) {
                if (currentFile.getAbsolutePath().equals(mSdCardPath)) {
                    listSdCard.add(new FileHolder(currentFile, mMimeTypes.getMimeType(currentFile.getName()), sdIcon, context));
                } else {
                    if (!mWriteableOnly || currentFile.canWrite())
                        listDir.add(new FileHolder(currentFile, mMimeTypes.getMimeType(currentFile.getName()), folderIcon, context));
                }
            } else {
                String fileName = currentFile.getName();
                String mimetype = mMimeTypes.getMimeType(fileName);
                String filetype = FileUtils.getExtension(fileName);
                boolean ext_allow = filetype.equalsIgnoreCase(mFilterFiletype) || mFilterFiletype == "String_Node_Str";
                boolean mime_allow = mFilterMimetype != null && (mimetype.contentEquals(mFilterMimetype) || mFilterMimetype.contentEquals("String_Node_Str") || mFilterFiletype == null);
                if (!mDirectoriesOnly && (ext_allow || mime_allow)) {
                    listFile.add(new FileHolder(currentFile, mimetype, context));
                }
            }
        }
    }
    Log.v(TAG, "String_Node_Str");
    int sortBy = PreferenceActivity.getSortBy(context);
    boolean ascending = PreferenceActivity.getAscending(context);
    Collections.sort(listSdCard);
    Collections.sort(listDir, Comparators.getForDirectory(sortBy, ascending));
    Collections.sort(listFile, Comparators.getForFile(sortBy, ascending));
    if (!cancelled) {
        Log.v(TAG, "String_Node_Str");
        DirectoryContents contents = new DirectoryContents();
        contents.listDir = listDir;
        contents.listFile = listFile;
        contents.listSdCard = listSdCard;
        contents.noMedia = noMedia;
        Message msg = handler.obtainMessage(MESSAGE_SHOW_DIRECTORY_CONTENTS);
        msg.obj = contents;
        msg.sendToTarget();
    }
    running = false;
}

Output:
     boolean ascending = PreferenceActivity.getAscending(context);
-    Collections.sort(listSdCard);
-    Collections.sort(listDir, Comparators.getForDirectory(sortBy, ascending));
-    Collections.sort(listFile, Comparators.getForFile(sortBy, ascending));
+    if (!cancelled) {
+        Collections.sort(listSdCard);
+        Collections.sort(listDir, Comparators.getForDirectory(sortBy, ascending));
+        Collections.sort(listFile, Comparators.getForFile(sortBy, ascending));
+    }
     if (!cancelled) {


Input:
private boolean sendBindingIntent() {
    if (this.routerPackage != null && this.routerClassName != null) {
        Log.d(TAG, "String_Node_Str" + this.routerPackage + "String_Node_Str" + this.routerClassName);
        Intent bindingIntent = new Intent();
        bindingIntent.setClassName(this.routerPackage, this.routerClassName);
        bindingIntent.putExtra(TransportConstants.ROUTER_BIND_REQUEST_TYPE_EXTRA, TransportConstants.BIND_REQUEST_TYPE_CLIENT);
        return getContext().bindService(bindingIntent, routerConnection, Context.BIND_AUTO_CREATE);
    } else {
        return false;
    }
}

Output:
         bindingIntent.putExtra(TransportConstants.ROUTER_BIND_REQUEST_TYPE_EXTRA, TransportConstants.BIND_REQUEST_TYPE_CLIENT);
-        return getContext().bindService(bindingIntent, routerConnection, Context.BIND_AUTO_CREATE);
+        return getContext().bindService(bindingIntent, routerConnection, Context.BIND_ABOVE_CLIENT);
     } else {


Input:
private Rectangle prepareStatus(Point nodeLocation, Dimension nodeSize) {
    Rectangle statusRectangle = null;
    Rectangle breakpointRectangle, warningRectangle, infoRectangle, parallelLocationRectangle, validationRuleRectangle, collapseRectangle;
    int status = node.getStatus();
    if ((status & Process.BREAKPOINT_STATUS) != 0) {
        breakpointLocation.x = nodeLocation.x - breakpointSize.width;
        breakpointLocation.y = nodeLocation.y - breakpointSize.height;
        breakpointRectangle = new Rectangle(breakpointLocation, breakpointSize);
        statusRectangle = breakpointRectangle;
    }
    if ((status & Process.ERROR_STATUS) != 0) {
        errorLocation.x = nodeLocation.x + nodeSize.width;
        errorLocation.y = nodeLocation.y - errorSize.height;
        errorRectangle = new Rectangle(errorLocation, errorSize);
        if (statusRectangle == null) {
            statusRectangle = errorRectangle;
        } else {
            statusRectangle.union(errorRectangle);
        }
    }
    if ((status & Process.WARNING_STATUS) != 0) {
        warningLocation.x = nodeLocation.x + nodeSize.width;
        warningLocation.y = nodeLocation.y - warningSize.height;
        warningRectangle = new Rectangle(warningLocation, warningSize);
        if (statusRectangle == null) {
            statusRectangle = warningRectangle;
        } else {
            statusRectangle.union(warningRectangle);
        }
    }
    if (this instanceof JobletContainer) {
        Dimension collapseSize = new Dimension(20, 20);
        collapseLocation.x = nodeLocation.x;
        collapseLocation.y = nodeLocation.y - collapseSize.height;
        collapseRectangle = new Rectangle(collapseLocation, collapseSize);
        if (statusRectangle == null) {
            statusRectangle = collapseRectangle;
        } else {
            statusRectangle.union(collapseRectangle);
        }
    }
    if ((status & Process.INFO_STATUS) != 0) {
        infoLocation.x = nodeLocation.x + nodeSize.width;
        infoLocation.y = nodeLocation.y - infoSize.height;
        infoRectangle = new Rectangle(infoLocation, infoSize);
        if (statusRectangle == null) {
            statusRectangle = infoRectangle;
        } else {
            statusRectangle.union(infoRectangle);
        }
    }
    if ((status & Process.VALIDATION_RULE_STATUS) != 0) {
        validationRuleLocation.x = nodeLocation.x + nodeSize.width / 2 + nodeSize.width / 4;
        validationRuleLocation.y = nodeLocation.y - validationRuleSize.height / 2;
        validationRuleRectangle = new Rectangle(validationRuleLocation, validationRuleSize);
        if (statusRectangle == null) {
            statusRectangle = validationRuleRectangle;
        } else {
            statusRectangle.union(validationRuleRectangle);
        }
    }
    if (node.isErrorFlag()) {
        if (statusRectangle != null) {
            markLocation.x = statusRectangle.x;
            markLocation.y = statusRectangle.y;
        } else {
            markLocation.x = nodeLocation.x;
            markLocation.y = nodeLocation.y;
        }
        errorMarkLocation.x = nodeLocation.x - (errorMarkSize.width - nodeSize.width) / 2;
        errorMarkLocation.y = markLocation.y - errorMarkSize.height;
        errorMarkRectangle = new Rectangle(errorMarkLocation, errorMarkSize);
        if (statusRectangle == null) {
            statusRectangle = errorMarkRectangle;
        } else {
            statusRectangle.union(errorMarkRectangle);
        }
    }
    boolean parallelize = false;
    IElementParameter enableParallelizeParameter = node.getElementParameter(EParameterName.PARALLELIZE.getName());
    if (enableParallelizeParameter != null) {
        parallelize = (Boolean) enableParallelizeParameter.getValue();
    }
    if (parallelize) {
        parallelLocation.x = nodeLocation.x - nodeSize.width / 2 - parallelSize.width;
        parallelLocation.y = nodeLocation.y - parallelSize.height;
        parallelLocationRectangle = new Rectangle(parallelLocation, parallelSize);
        if (statusRectangle == null) {
            statusRectangle = parallelLocationRectangle;
        } else {
            statusRectangle.union(parallelLocationRectangle);
        }
    }
    return statusRectangle;
}

Output:
     if (node.isErrorFlag()) {
-        if (statusRectangle != null) {
-            markLocation.x = statusRectangle.x;
-            markLocation.y = statusRectangle.y;
-        } else {
-            markLocation.x = nodeLocation.x;
-            markLocation.y = nodeLocation.y;
-        }
+        markLocation.x = nodeLocation.x - nodeSize.width / 2;
+        markLocation.y = nodeLocation.y;
         errorMarkLocation.x = nodeLocation.x - (errorMarkSize.width - nodeSize.width) / 2;


Input:
protected void beforeActivityLaunched() {
    SettingsUtils.markTosAccepted(InstrumentationRegistry.getTargetContext(), true);
    AccountUtils.setActiveAccount(InstrumentationRegistry.getTargetContext(), ACCOUNT_NAME);
    mStubLoginAndAuth = new StubLoginAndAuth(ACCOUNT_NAME, false, true);
    LoginAndAuthProvider.setStubLoginAndAuth(mStubLoginAndAuth);
}

Output:
     SettingsUtils.markTosAccepted(InstrumentationRegistry.getTargetContext(), true);
-    AccountUtils.setActiveAccount(InstrumentationRegistry.getTargetContext(), ACCOUNT_NAME);
-    mStubLoginAndAuth = new StubLoginAndAuth(ACCOUNT_NAME, false, true);
+    mAccountName = LoginUtils.setFirstAvailableAccountAsActive(InstrumentationRegistry.getTargetContext());
+    mStubLoginAndAuth = new StubLoginAndAuth(mAccountName, false, true);
     LoginAndAuthProvider.setStubLoginAndAuth(mStubLoginAndAuth);


Input:
public Object saveLaunchConfiguration() throws CoreException {
    ILaunchConfiguration config = null;
    ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager();
    String projectName = this.getCodeProject().getName();
    ILaunchConfigurationType type = launchManager.getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
    if (type != null) {
        ILaunchConfigurationWorkingCopy wc = type.newInstance(null, launchManager.generateUniqueLaunchConfigurationNameFrom(this.getCodePath().lastSegment()));
        wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, projectName);
        wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, this.getTypeName());
        wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_STOP_IN_MAIN, true);
        wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, CTX_ARG + context.getName());
        config = wc.doSave();
    }
    return config;
}

Output:
         wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, projectName);
-        wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, this.getTypeName());
+        wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, this.getMainClass());
         wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_STOP_IN_MAIN, true);


Input:
private void updatePreviews(boolean updateAll) {
    if (inputText == null) {
        return;
    }
    inputText.setStyleRanges(new StyleRange[] {});
    if (selectedElement == null) {
        return;
    }
    timeStampValue = null;
    timeStampFormat = null;
    logEntriesCount = 0;
    logEntryFound = false;
    selectedElement.updatePreview();
    if (timeStampValue != null && timeStampFormat != null) {
        try {
            SimpleDateFormat dateFormat = new SimpleDateFormat(timeStampFormat);
            Date date = dateFormat.parse(timeStampValue);
            dateFormat = new SimpleDateFormat(timeStampOutputFormatText.getText().trim());
            timeStampPreviewText.setText(dateFormat.format(date));
        } catch (ParseException e) {
            timeStampPreviewText.setText("String_Node_Str" + timeStampValue + "String_Node_Str" + timeStampFormat + "String_Node_Str");
        } catch (IllegalArgumentException e) {
            timeStampPreviewText.setText("String_Node_Str");
        }
    } else {
        timeStampPreviewText.setText("String_Node_Str");
    }
}

Output:
     }
-    timeStampValue = null;
-    timeStampFormat = null;
-    logEntriesCount = 0;
-    logEntryFound = false;
+    initValues();
     selectedElement.updatePreview();


Input:
public void prepareConfigObject(BuildConfiguration buildConfiguration) {
    String strHostName = buildConfiguration.getString(REPOSITORY_GERRIT_REPOSITORY_HOSTNAME, "String_Node_Str").trim();
    buildConfiguration.setProperty(REPOSITORY_GERRIT_REPOSITORY_HOSTNAME, strHostName);
    String strPort = buildConfiguration.getString(REPOSITORY_GERRIT_REPOSITORY_PORT, "String_Node_Str").trim();
    buildConfiguration.setProperty(REPOSITORY_GERRIT_REPOSITORY_PORT, strPort);
    String strProject = buildConfiguration.getString(REPOSITORY_GERRIT_PROJECT, "String_Node_Str").trim();
    buildConfiguration.setProperty(REPOSITORY_GERRIT_PROJECT, strProject);
    String strUserName = buildConfiguration.getString(REPOSITORY_GERRIT_USERNAME, "String_Node_Str").trim();
    buildConfiguration.setProperty(REPOSITORY_GERRIT_USERNAME, strUserName);
    String strPhrase = buildConfiguration.getString(TEMPORARY_GERRIT_SSH_PASSPHRASE);
    if (buildConfiguration.getBoolean(TEMPORARY_GERRIT_SSH_PASSPHRASE_CHANGE)) {
        buildConfiguration.setProperty(REPOSITORY_GERRIT_SSH_PASSPHRASE, encrypterRef.get().encrypt(strPhrase));
    } else if (strPhrase == null) {
        strPhrase = buildConfiguration.getString(REPOSITORY_GERRIT_SSH_PASSPHRASE, "String_Node_Str");
    }
    String key = "String_Node_Str";
    if (buildConfiguration.getBoolean(TEMPORARY_GERRIT_SSH_KEY_CHANGE)) {
        final Object o = buildConfiguration.getProperty(TEMPORARY_GERRIT_SSH_KEY_FROM_FILE);
        if (o instanceof File) {
            File f = (File) o;
            try {
                key = FileUtils.readFileToString(f);
            } catch (IOException e) {
                log.error(textProvider.getText("String_Node_Str"), e);
                return;
            }
            buildConfiguration.setProperty(REPOSITORY_GERRIT_SSH_KEY, encrypterRef.get().encrypt(key));
        } else {
            buildConfiguration.clearProperty(REPOSITORY_GERRIT_SSH_KEY);
        }
    } else if (key.isEmpty()) {
        key = encrypterRef.get().decrypt(buildConfiguration.getString(REPOSITORY_GERRIT_SSH_KEY, "String_Node_Str"));
    }
    File file = prepareSSHKeyFile(buildConfiguration, key);
    buildConfiguration.setProperty(REPOSITORY_GERRIT_SSH_KEY_FILE, file.getAbsolutePath());
}

Output:
     }
-    File file = prepareSSHKeyFile(buildConfiguration, key);
-    buildConfiguration.setProperty(REPOSITORY_GERRIT_SSH_KEY_FILE, file.getAbsolutePath());
+    relativeSSHKeyFilePath = getRelativeRepoPath(buildConfiguration);
+    File f = prepareSSHKeyFile(relativeSSHKeyFilePath, key);
+    if (f != null) {
+        buildConfiguration.setProperty(REPOSITORY_GERRIT_SSH_KEY_FILE, relativeSSHKeyFilePath);
+    }
 }


Input:
public static Scene getSceneForLayout(ViewGroup sceneRoot, int layoutId, Context context) {
    SparseArray<Scene> scenes = (SparseArray<Scene>) sceneRoot.getTag(com.android.internal.R.id.scene_layoutid_cache);
    if (scenes == null) {
        scenes = new SparseArray<Scene>();
        sceneRoot.setTag(com.android.internal.R.id.scene_layoutid_cache, scenes);
    }
    Scene scene = scenes.get(layoutId);
    if (scene != null) {
        return scene;
    } else {
        scene = new Scene(sceneRoot, layoutId, context);
        scenes.put(layoutId, scene);
        return scene;
    }
}

Output:
         scenes = new SparseArray<Scene>();
-        sceneRoot.setTag(com.android.internal.R.id.scene_layoutid_cache, scenes);
+        sceneRoot.setTagInternal(com.android.internal.R.id.scene_layoutid_cache, scenes);
     }


Input:
public MemberResolver.Method atMethodCallCore(CtClass targetClass, String mname, ASTList args) throws CompileError {
    int nargs = getMethodArgsLength(args);
    int[] types = new int[nargs];
    int[] dims = new int[nargs];
    String[] cnames = new String[nargs];
    atMethodArgs(args, types, dims, cnames);
    MemberResolver.Method found = resolver.lookupMethod(targetClass, thisMethod, mname, types, dims, cnames, false);
    if (found == null) {
        String msg;
        if (mname.equals(MethodInfo.nameInit))
            msg = "String_Node_Str";
        else
            msg = "String_Node_Str" + mname + "String_Node_Str" + targetClass.getName();
        throw new CompileError(msg);
    }
    String desc = found.info.getDescriptor();
    setReturnType(desc);
    return found;
}

Output:
     atMethodArgs(args, types, dims, cnames);
-    MemberResolver.Method found = resolver.lookupMethod(targetClass, thisMethod, mname, types, dims, cnames, false);
+    MemberResolver.Method found = resolver.lookupMethod(targetClass, thisClass, thisMethod, mname, types, dims, cnames);
     if (found == null) {


Input:
private List<Cluster> doPrivilegedLookup(String partitionName, String vmTypeName) throws NotEnoughResourcesException {
    if ("String_Node_Str".equals(partitionName)) {
        Iterable<Cluster> authorizedClusters = Iterables.filter(Clusters.getInstance().listValues(), RestrictedTypes.filterPrivileged());
        Multimap<VmTypeAvailability, Cluster> sorted = TreeMultimap.create();
        for (Cluster c : authorizedClusters) {
            sorted.put(c.getNodeState().getAvailability(vmTypeName), c);
        }
        if (sorted.isEmpty()) {
            throw new NotEnoughResourcesException("String_Node_Str");
        } else {
            return Lists.newArrayList(sorted.values());
        }
    } else {
        Cluster cluster = Clusters.getInstance().lookup(Partitions.lookupService(ClusterController.class, partitionName));
        if (cluster == null) {
            throw new NotEnoughResourcesException("String_Node_Str" + partitionName);
        }
        return Lists.newArrayList(cluster);
    }
}

Output:
     } else {
-        Cluster cluster = Clusters.getInstance().lookup(Partitions.lookupService(ClusterController.class, partitionName));
+        ServiceConfiguration ccConfig = Topology.lookup(ClusterController.class, Partitions.lookupByName(partitionName));
+        Cluster cluster = Clusters.lookup(ccConfig);
         if (cluster == null) {


Input:
public void testCopyFromFileWithEmptyLine() throws Exception {
    execute("String_Node_Str");
    ensureYellow();
    File newFile = folder.newFile();
    try (BufferedWriter writer = new BufferedWriter(new FileWriter(newFile))) {
        writer.write("String_Node_Str");
        writer.write("String_Node_Str");
        writer.write("String_Node_Str");
    }
    execute("String_Node_Str", new Object[] { newFile.getPath() });
    assertEquals(2L, response.rowCount());
    refresh();
    execute("String_Node_Str");
    assertThat((Integer) response.rows()[0][0], is(1));
    assertThat((Integer) response.rows()[1][0], is(2));
}

Output:
     }
-    execute("String_Node_Str", new Object[] { newFile.getPath() });
+    execute("String_Node_Str", new Object[] { Paths.get(newFile.toURI()).toUri().toString() });
     assertEquals(2L, response.rowCount());


Input:
public S checkOut(ServiceEndPoint endPoint) throws Exception {
    checkNotNull(endPoint);
    _requestCount.incrementAndGet();
    try {
        S service = _pool.borrowObject(endPoint);
        _checkOutRevisions.put(service, _revisionNumber.incrementAndGet());
        return service;
    } catch (NoSuchElementException e) {
        _missCount.incrementAndGet();
        throw new NoCachedInstancesAvailableException();
    }
}

Output:
         S service = _pool.borrowObject(endPoint);
-        _checkOutRevisions.put(service, _revisionNumber.incrementAndGet());
-        return service;
+        ServiceHandle<S> handle = new ServiceHandle<S>(service, endPoint);
+        _checkedOutRevisions.put(handle, revision);
+        return handle;
     } catch (NoSuchElementException e) {


Input:
public void focusGained(FocusEvent e) {
    mainFrame.setActiveTable(fileTable);
    if (e.getSource() == fileTable) {
        ((MutableLineBorder) scrollPane.getBorder()).setLineColor(borderColor);
        scrollPane.getViewport().setBackground(backgroundColor);
    }
}

Output:
     if (e.getSource() == fileTable) {
-        ((MutableLineBorder) scrollPane.getBorder()).setLineColor(borderColor);
+        setBorderColor(borderColor);
         scrollPane.getViewport().setBackground(backgroundColor);


Input:
public void showSearchResult(MasterDocumentDTO[] result) {
    inputPanel.clear();
    MDocTableModel source = new MDocTableModel(result, m_login, true);
    m_elementTable.setModel(source, m_tableProfiles.getProfile("String_Node_Str"));
    m_menuDocumentBarBottom.setStyleName("String_Node_Str");
    m_menuDocumentBarTop.setStyleName("String_Node_Str");
    elementTableDecPanel.addStyleName("String_Node_Str");
    showTablePanel(false);
}

Output:
     inputPanel.clear();
-    MDocTableModel source = new MDocTableModel(result, m_login, true);
-    m_elementTable.setModel(source, m_tableProfiles.getProfile("String_Node_Str"));
-    m_menuDocumentBarBottom.setStyleName("String_Node_Str");
-    m_menuDocumentBarTop.setStyleName("String_Node_Str");
+    desiredProfile = m_tableProfiles.getProfile("String_Node_Str");
     elementTableDecPanel.addStyleName("String_Node_Str");


Input:
public double evaluate(AnnoSentenceCollection predSents, AnnoSentenceCollection goldSents, String name) {
    int numTot = 0;
    int numIncorrect = 0;
    for (int i = 0; i < predSents.size(); i++) {
        AnnoSentence predSent = predSents.get(i);
        AnnoSentence goldSent = goldSents.get(i);
        for (int c = 0; c < goldSent.size(); c++) {
            if (skipPunctuation && DepParseAccuracy.isPunctuation(goldSent.getWord(c))) {
                continue;
            }
            int p = goldSent.getParent(c);
            if (predSent.getDepEdgeMask().isPruned(p, c)) {
                numIncorrect++;
                break;
            }
        }
        numTot++;
    }
    int numCorrect = numTot - numIncorrect;
    log.info(String.format("String_Node_Str", name, numCorrect, numTot, (double) numCorrect / numTot));
    return numTot - numCorrect;
}

Output:
             int p = goldSent.getParent(c);
-            if (predSent.getDepEdgeMask().isPruned(p, c)) {
+            DepEdgeMask predMask = predSent.getDepEdgeMask();
+            if (predMask != null && predMask.isPruned(p, c)) {
                 numIncorrect++;


Input:
private void updateSold(BigInteger projectId, BigDecimal ethNumber, BigDecimal balance) {
    Orders orders = new Orders();
    orders.setUserId(getUserId());
    Integer orderNum = orderMapper.selectCount(orders);
    Integer buyerNum = orderNum == 1 ? 1 : 0;
    ProjectSold projectSold = new ProjectSold();
    projectSold.setId(projectId);
    projectSold.setSoldEth(ethNumber);
    projectSold.setBuyerNum(buyerNum);
    projectMapper.updateSoldBalance(projectSold);
}

Output:
     Integer orderNum = orderMapper.selectCount(orders);
-    Integer buyerNum = orderNum == 1 ? 1 : 0;
+    Integer buyerNum = orderNum == 0 ? 1 : 0;
     ProjectSold projectSold = new ProjectSold();


Input:
void updatePartsData() {
    UUID uuid = this.mc.thePlayer.getPersistentID();
    PartEntry tailEntry = (PartEntry) partList.getListEntry(partList.getCurrrentIndex());
    partInfo.setTexture(null);
    if (currTintEdit > 0)
        partInfo.tints[currTintEdit - 1] = currTintColour | 0xFF << 24;
    partInfo = new PartInfo(uuid, tailEntry.partInfo.hasPart, tailEntry.partInfo.typeid, tailEntry.partInfo.subid, textureID, partInfo.tints, partType, null);
    partInfo.setTexture(TextureHelper.generateTexture(partInfo));
    partsData.setPartInfo(partType, partInfo);
    Tails.proxy.addPartsData(uuid, partsData);
}

Output:
     partInfo = new PartInfo(uuid, tailEntry.partInfo.hasPart, tailEntry.partInfo.typeid, tailEntry.partInfo.subid, textureID, partInfo.tints, partType, null);
-    partInfo.setTexture(TextureHelper.generateTexture(partInfo));
+    if (partInfo.hasPart)
+        partInfo.setTexture(TextureHelper.generateTexture(partInfo));
     partsData.setPartInfo(partType, partInfo);


Input:
public void removeChild() {
    for (int i = 0; i < this.wrappedTree.nbChildren(); i++) {
        this.wrappedTree.removeChild(i);
    }
}

Output:
 public void removeChild() {
-    for (int i = 0; i < this.wrappedTree.nbChildren(); i++) {
-        this.wrappedTree.removeChild(i);
+    int childCount = this.wrappedTree.nbChildren();
+    for (int i = 0; i < childCount; i++) {
+        this.wrappedTree.removeChild(0);
     }


Input:
public void onBlockSpread(BlockSpreadEvent event) {
    for (Arena a : pli.getArenas()) {
        if (Validator.isArenaValid(plugin, a) && a.getArenaType() == ArenaType.REGENERATION) {
            Cuboid c = a.getBoundaries();
            if (c != null) {
                if (a.getArenaState() == ArenaState.INGAME) {
                    a.getSmartReset().addChanged(event.getBlock().getLocation());
                } else if (a.getArenaState() == ArenaState.RESTARTING) {
                    event.setCancelled(true);
                }
            }
        }
    }
}

Output:
     for (Arena a : pli.getArenas()) {
-        if (Validator.isArenaValid(plugin, a) && a.getArenaType() == ArenaType.REGENERATION) {
+        if (a.getArenaType() == ArenaType.REGENERATION) {
             Cuboid c = a.getBoundaries();


Input:
public void onScanFailed(int errorCode) {
    m_manager.getLogger().e(Utils_String.concatStrings("String_Node_Str", String.valueOf(errorCode)));
    if (errorCode != SCAN_FAILED_ALREADY_STARTED) {
        fail();
    } else {
        tryClassicDiscovery(PA_StateTracker.E_Intent.UNINTENTIONAL, false);
        m_mode = Mode_CLASSIC;
    }
}

Output:
 public void onScanFailed(int errorCode) {
-    m_manager.getLogger().e(Utils_String.concatStrings("String_Node_Str", String.valueOf(errorCode)));
-    if (errorCode != SCAN_FAILED_ALREADY_STARTED) {
-        fail();
+    if (errorCode == SCAN_FAILED_ALREADY_STARTED) {
+        m_manager.ASSERT(false, "String_Node_Str");
     } else {


Input:
public static String getPaymentType(Operation op, String amount, ChatColor colour) {
    if (useEconomy) {
        if (useIconomy())
            return IconomyInterface.getCurrency(amount);
        else
            return ItemInterface.getCurrency(op, colour);
    } else
        return "String_Node_Str";
}

Output:
         if (useIconomy())
-            return IconomyInterface.getCurrency(amount);
+            return IconomyInterface.format(amount);
         else


Input:
public void run() {
    RelativeLayout filters = (RelativeLayout) findViewById(R.id.filters);
    filters.setVisibility(View.VISIBLE);
    TextView reportTitle = (TextView) findViewById(R.id.chartTitle);
    reportTitle.setVisibility(View.VISIBLE);
    ImageView iv = (ImageView) findViewById(R.id.chart);
    if (reportType.equals("String_Node_Str")) {
        if (intervalT != 1) {
            iv.setVisibility(View.VISIBLE);
        } else {
            iv.setVisibility(View.GONE);
        }
        reportTitle.setText(getResources().getText(R.string.report_views));
        String dataValues = "String_Node_Str", dateStrings = "String_Node_Str", xLabels = "String_Node_Str";
        Object[] key = numDataSet.toArray();
        Arrays.sort(key);
        TableLayout tl = (TableLayout) findViewById(R.id.dataTable);
        tl.removeAllViews();
        LayoutInflater inflater = getLayoutInflater();
        TableRow table_row = (TableRow) inflater.inflate(R.layout.table_row_header, tl, false);
        TextView col_1 = (TextView) table_row.findViewById(R.id.col1);
        col_1.setText(getResources().getText(R.string.date));
        col_1.setTypeface(Typeface.DEFAULT_BOLD);
        TextView col_2 = (TextView) table_row.findViewById(R.id.col2);
        col_2.setText(getResources().getText(R.string.report_views));
        col_2.setTypeface(Typeface.DEFAULT_BOLD);
        tl.addView(table_row);
        HashMap<?, ?> row;
        for (int i = 0; i < dataSet.size(); i++) {
            row = (HashMap<?, ?>) dataSet.get(i);
            String date;
            try {
                date = row.get("String_Node_Str").toString();
            } catch (Exception e) {
                return;
            }
            String value = numDataSet.get(i).toString();
            dateStrings += date + "String_Node_Str";
            dataValues += value + "String_Node_Str";
            if (i == 0)
                xLabels += date + "String_Node_Str";
            else if (i == (dataSet.size() - 1))
                xLabels += date;
            else
                xLabels += "String_Node_Str";
            TableRow tr = (TableRow) inflater.inflate(R.layout.table_row, tl, false);
            TextView col1 = (TextView) tr.findViewById(R.id.col1);
            col1.setText(date);
            TextView col2 = (TextView) tr.findViewById(R.id.col2);
            col2.setText(value);
            if (i % 2 == 0) {
                tr.setBackgroundColor(Color.parseColor("String_Node_Str"));
            }
            tl.addView(tr);
        }
        int maxValue = Integer.parseInt(key[key.length - 1].toString());
        int minValue = Integer.parseInt(key[0].toString());
        dataValues = dataValues.substring(0, dataValues.length() - 1);
        dateStrings = dateStrings.substring(0, dateStrings.length() - 1);
        long minBuffer = Math.round(minValue - (maxValue * .10));
        if (minBuffer < 0) {
            minBuffer = 0;
        }
        long maxBuffer = Math.round(maxValue + (maxValue * .10));
        for (int i = 0; i < 9; i++) {
            if (minBuffer % 10 == 0)
                break;
            else {
                minBuffer--;
            }
        }
        for (int i = 0; i < 9; i++) {
            if (maxBuffer % 10 == 0)
                break;
            else {
                maxBuffer++;
            }
        }
        long yInterval = maxBuffer / 10;
        for (int i = 0; i < 9; i++) {
            if (yInterval % 10 == 0)
                break;
            else {
                yInterval++;
            }
        }
        float xGrid = 100.00f / 6;
        if (yInterval == 0) {
            yInterval = 1;
        }
        long numRows = (maxBuffer - minBuffer) / yInterval;
        float yGrid = 100.00f / numRows;
        Display display = getWindowManager().getDefaultDisplay();
        int width = display.getWidth();
        int height = display.getHeight();
        String screenSize = "String_Node_Str";
        if (width > 480 || height > 480) {
            screenSize = "String_Node_Str";
        }
        final String chartViewURL = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + dataValues + "String_Node_Str" + screenSize + "String_Node_Str" + "String_Node_Str" + xLabels + "String_Node_Str" + minBuffer + "String_Node_Str" + maxBuffer + "String_Node_Str" + minBuffer + "String_Node_Str" + maxBuffer + "String_Node_Str" + yInterval + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + xGrid + "String_Node_Str" + yGrid + "String_Node_Str";
        new statsChartTask().execute(chartViewURL);
    } else if (reportType.equals("String_Node_Str")) {
        reportTitle.setText(getResources().getText(R.string.report_postviews));
        iv.setVisibility(View.GONE);
        Object[] key = numDataSet.toArray();
        Arrays.sort(key);
        TableLayout tl = (TableLayout) findViewById(R.id.dataTable);
        tl.removeAllViews();
        LayoutInflater inflater = getLayoutInflater();
        TableRow table_row = (TableRow) inflater.inflate(R.layout.table_row_header, tl, false);
        TextView col_1 = (TextView) table_row.findViewById(R.id.col1);
        col_1.setText(getResources().getText(R.string.report_post_title));
        col_1.setTypeface(Typeface.DEFAULT_BOLD);
        TextView col_2 = (TextView) table_row.findViewById(R.id.col2);
        col_2.setText(getResources().getText(R.string.report_views));
        col_2.setTypeface(Typeface.DEFAULT_BOLD);
        tl.addView(table_row);
        HashMap<?, ?> row;
        for (int i = 0; i < dataSet.size(); i++) {
            row = (HashMap<?, ?>) dataSet.get(i);
            String date = row.get("String_Node_Str").toString();
            String value = numDataSet.get(i).toString();
            TableRow tr = (TableRow) inflater.inflate(R.layout.table_row, tl, false);
            TextView col1 = (TextView) tr.findViewById(R.id.col1);
            col1.setText(date);
            TextView col2 = (TextView) tr.findViewById(R.id.col2);
            col2.setText(value);
            if (i % 2 == 0) {
                tr.setBackgroundColor(Color.parseColor("String_Node_Str"));
            }
            tl.addView(tr);
        }
    } else if (reportType.equals("String_Node_Str") || reportType.equals("String_Node_Str") || reportType.equals("String_Node_Str")) {
        iv.setVisibility(View.GONE);
        Object[] key = numDataSet.toArray();
        Arrays.sort(key);
        TableLayout tl = (TableLayout) findViewById(R.id.dataTable);
        tl.removeAllViews();
        LayoutInflater inflater = getLayoutInflater();
        TableRow table_row = (TableRow) inflater.inflate(R.layout.table_row_header, tl, false);
        TextView col_1 = (TextView) table_row.findViewById(R.id.col1);
        if (reportType.equals("String_Node_Str")) {
            col_1.setText(getResources().getText(R.string.report_referrers));
            reportTitle.setText(getResources().getText(R.string.report_referrers));
        } else if (reportType.equals("String_Node_Str")) {
            reportTitle.setText(getResources().getText(R.string.report_searchterms));
            col_1.setText(getResources().getText(R.string.report_searchterms));
        } else {
            reportTitle.setText(getResources().getText(R.string.report_clicks));
            col_1.setText(getResources().getText(R.string.report_clicks));
        }
        col_1.setTypeface(Typeface.DEFAULT_BOLD);
        TextView col_2 = (TextView) table_row.findViewById(R.id.col2);
        col_2.setText("String_Node_Str");
        col_2.setTypeface(Typeface.DEFAULT_BOLD);
        tl.addView(table_row);
        HashMap<?, ?> row;
        for (int i = 0; i < dataSet.size(); i++) {
            row = (HashMap<?, ?>) dataSet.get(i);
            String date = row.get("String_Node_Str").toString();
            String value = numDataSet.get(i).toString();
            TableRow tr = (TableRow) inflater.inflate(R.layout.table_row, tl, false);
            TextView col1 = (TextView) tr.findViewById(R.id.col1);
            col1.setText(date);
            Linkify.addLinks(col1, Linkify.WEB_URLS);
            TextView col2 = (TextView) tr.findViewById(R.id.col2);
            col2.setText(value);
            if (i % 2 == 0) {
                tr.setBackgroundColor(Color.parseColor("String_Node_Str"));
            }
            tl.addView(tr);
        }
    }
    if (!isFinishing())
        dismissDialog(ID_DIALOG_GET_STATS);
}

Output:
     if (!isFinishing())
-        dismissDialog(ID_DIALOG_GET_STATS);
+        titleBar.stopRotatingRefreshIcon();
 }


Input:
public void selectionChanged(SelectionChangedEvent event) {
    String sheetName = (String) ((IStructuredSelection) event.getSelection()).getFirstElement();
    String queryText = this.getInitializationDesign().getQueryText();
    if (sheetName.equalsIgnoreCase(currentSheetName) && isNewFile(queryText, getFileName(selectedFile))) {
        flag = false;
        return;
    } else if (flag) {
        flag = false;
        return;
    }
    if (currentSheetName != null && !MessageDialog.openConfirm(worksheetsCombo.getControl().getShell(), Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"))) {
        flag = true;
        worksheetsCombo.setSelection(new StructuredSelection(currentSheetName));
        return;
    }
    currentSheetName = sheetName;
    setPageComplete(false);
    selectedColumnsViewer.getTable().removeAll();
    savedSelectedColumnsInfoList.clear();
    availableList.removeAll();
    if (this.getShell() != null) {
        Cursor waitCursor = new Cursor(this.getShell().getDisplay(), SWT.CURSOR_WAIT);
        this.getControl().setCursor(waitCursor);
    }
    String fileName = getFileName(selectedFile);
    String[] columnNames = getFileColumnNames(selectedFile);
    if (columnNames != null && columnNames.length != 0) {
        enableListAndViewer();
        availableList.setItems(columnNames);
        availableList.select(0);
        btnAdd.setEnabled(true);
        btnRemove.setEnabled(false);
        btnMoveUp.setEnabled(false);
        btnMoveDown.setEnabled(false);
        if (!(fileName.endsWith(ExcelODAConstants.XLS_FORMAT) || fileName.endsWith(ExcelODAConstants.XLSX_FORMAT))) {
            setMessage(Messages.getString("String_Node_Str"), WARNING);
        } else {
            if (selectedColumnsViewer.getTable().getItemCount() == 0) {
                String errMsg = currentSheetName == null ? Messages.getString("String_Node_Str") : Messages.getString("String_Node_Str");
                setMessage(errMsg, ERROR);
            } else {
                setMessage(DEFAULT_MESSAGE);
            }
        }
    }
    if (this.getShell() != null) {
        Cursor normalCursor = new Cursor(this.getShell().getDisplay(), SWT.CURSOR_ARROW);
        this.getControl().setCursor(normalCursor);
    }
}

Output:
             if (selectedColumnsViewer.getTable().getItemCount() == 0) {
-                String errMsg = currentSheetName == null ? Messages.getString("String_Node_Str") : Messages.getString("String_Node_Str");
-                setMessage(errMsg, ERROR);
+                setMessage(getEmptyColumnErrMsg(), ERROR);
             } else {


Input:
private void insertTab(final int parentIdx, final Tab tab) {
    final Tab parentTab = (parentIdx >= 0 && parentIdx < tabs.size() - 1) ? tabs.get(parentIdx) : null;
    if (parentTab == null) {
        tabs.add(tab);
        return;
    } else {
        tabs.add(parentIdx + 1, tab);
    }
    for (final Tab t : tabs) {
        if (parentTab.getId().equals(t.getParentId())) {
            t.setParentId(tab.getId());
        }
    }
    tab.setParentId(parentTab.getId());
}

Output:
 private void insertTab(final int parentIdx, final Tab tab) {
-    final Tab parentTab = (parentIdx >= 0 && parentIdx < tabs.size() - 1) ? tabs.get(parentIdx) : null;
+    final Tab parentTab = (parentIdx >= 0 && parentIdx < tabs.size()) ? tabs.get(parentIdx) : null;
     if (parentTab == null) {


Input:
public Boolean create(CreateResourceRequest createResourceRequest, String region) throws Exception {
    AzureReservedIpCreateRequest azureReservedIpCreateRequest = (AzureReservedIpCreateRequest) createResourceRequest;
    HttpResponseDecorator serviceCertificate = (HttpResponseDecorator) azureReservedIpCreateRequest.getAzureClient().createReservedIP(azureReservedIpCreateRequest.getProps());
    AzureResourcePollerObject azureResourcePollerObject = new AzureResourcePollerObject(azureReservedIpCreateRequest.getAzureClient(), azureReservedIpCreateRequest.getStack(), serviceCertificate);
    azureResourcePollerObjectPollingService.pollWithTimeout(azureCreateResourceStatusCheckerTask, azureResourcePollerObject, POLLING_INTERVAL, MAX_POLLING_ATTEMPTS);
    return true;
}

Output:
     AzureReservedIpCreateRequest azureReservedIpCreateRequest = (AzureReservedIpCreateRequest) createResourceRequest;
-    HttpResponseDecorator serviceCertificate = (HttpResponseDecorator) azureReservedIpCreateRequest.getAzureClient().createReservedIP(azureReservedIpCreateRequest.getProps());
-    AzureResourcePollerObject azureResourcePollerObject = new AzureResourcePollerObject(azureReservedIpCreateRequest.getAzureClient(), azureReservedIpCreateRequest.getStack(), serviceCertificate);
-    azureResourcePollerObjectPollingService.pollWithTimeout(azureCreateResourceStatusCheckerTask, azureResourcePollerObject, POLLING_INTERVAL, MAX_POLLING_ATTEMPTS);
+    try {
+        HttpResponseDecorator serviceCertificate = (HttpResponseDecorator) azureReservedIpCreateRequest.getAzureClient().createReservedIP(azureReservedIpCreateRequest.getProps());
+        AzureResourcePollerObject azureResourcePollerObject = new AzureResourcePollerObject(azureReservedIpCreateRequest.getAzureClient(), azureReservedIpCreateRequest.getStack(), serviceCertificate);
+        azureResourcePollerObjectPollingService.pollWithTimeout(azureCreateResourceStatusCheckerTask, azureResourcePollerObject, POLLING_INTERVAL, MAX_POLLING_ATTEMPTS);
+    } catch (Exception ex) {
+        throw checkException(ex);
+    }
     return true;


Input:
public void setVisibility(int visibility) {
    if (mInflatedViewRef != null) {
        View view = mInflatedViewRef.get();
        if (view != null) {
            view.setVisibility(visibility);
        } else {
            throw new IllegalStateException("String_Node_Str");
        }
    } else if (visibility == VISIBLE || visibility == INVISIBLE) {
        super.setVisibility(visibility);
        inflate();
    }
}

Output:
         }
-    } else if (visibility == VISIBLE || visibility == INVISIBLE) {
+    } else {
         super.setVisibility(visibility);


Input:
private void onReceive_HandleAck(Packet packet) {
    Session current = getOutboundByNode(packet.getFrom());
    if (current != null && current.getConnectionId() == packet.getConnectionId()) {
        if (packet.getSequence() == 0 && current.getConnecting() && !current.getConnected()) {
            info(String.format("String_Node_Str", packet.getConnectionId(), packet.getFrom()));
            current.setConnected();
            while (current.getSendQueue().size() > 0) {
                Packet dataPacket;
                dataPacket = current.getSendQueue().remove();
                info("String_Node_Str" + dataPacket.stringize());
                current.addToWaitingForAckList(dataPacket.getSequence());
                this.internalSendPacket(dataPacket, TIMEOUT);
            }
        } else {
            info("String_Node_Str" + packet.getSequence());
        }
        current.removeFromWaitingForAckList(packet.getSequence());
    } else {
        info("String_Node_Str" + packet.stringizeHeader());
    }
}

Output:
                 current.addToWaitingForAckList(dataPacket.getSequence());
-                this.internalSendPacket(dataPacket, TIMEOUT);
+                this.internalSendPacket(current, dataPacket, TIMEOUT);
             }


Input:
public void getMoreTopic(int page) {
    NetworkTaskScheduler.getInstance().execute(new GetTopicListTask(UrlUtil.appendPage(mView.getUrl(), page), new OnResponseListener<List<Topic>>() {

        public void onSucceed(List<Topic> data) {
            mView.onGetMoreTopicSucceed(data);
        }
        public void onFailed(String msg) {
            mView.onGetMoreTopicFailed(msg);
        }
    }));
}

Output:
 public void getMoreTopic(int page) {
-    NetworkTaskScheduler.getInstance().execute(new GetTopicListTask(UrlUtil.appendPage(mView.getUrl(), page), new OnResponseListener<List<Topic>>() {
+    NetworkTaskScheduler.getInstance().execute(new GetTopicListTask(UrlUtil.appendPage(mView.getUrl(), page), new OnResponseListener<TopicList>() {


Input:
public void endDocument() throws SAXException {
    if (unmarshaller.getIDResolver() != null && parentRecord == null) {
        unmarshaller.getIDResolver().endDocument();
    }
    if (null != selfRecords) {
        for (int x = 0, selfRecordsSize = selfRecords.size(); x < selfRecordsSize; x++) {
            UnmarshalRecord selfRecord = selfRecords.get(x);
            if (selfRecord != null) {
                selfRecord.endDocument();
            }
        }
    }
    if (null != xPathNode.getSelfChildren()) {
        int selfChildrenSize = xPathNode.getSelfChildren().size();
        for (int x = 0; x < selfChildrenSize; x++) {
            XPathNode selfNode = xPathNode.getSelfChildren().get(x);
            if (null != selfNode.getNodeValue()) {
                selfNode.getNodeValue().endSelfNodeValue(this, selfRecords.get(x), attributes);
            }
        }
    }
    CoreDescriptor xmlDescriptor = (CoreDescriptor) treeObjectBuilder.getDescriptor();
    try {
        if (null != populatedContainerValues) {
            for (int populatedCVSize = populatedContainerValues.size(), i = populatedCVSize - 1; i >= 0; i--) {
                ContainerValue cv = ((ContainerValue) populatedContainerValues.get(i));
                cv.setContainerInstance(currentObject, getContainerInstance(cv, cv.isDefaultEmptyContainer()));
            }
        }
        if (null != defaultEmptyContainerValues) {
            for (int defaultEmptyCVSize = defaultEmptyContainerValues.size(), i = defaultEmptyCVSize - 1; i >= 0; i--) {
                ContainerValue cv = ((ContainerValue) defaultEmptyContainerValues.get(i));
                cv.setContainerInstance(currentObject, getContainerInstance(cv, cv.isDefaultEmptyContainer()));
            }
        }
        if (null != nullCapableValues) {
            for (int x = 0, nullValuesSize = nullCapableValues.size(); x < nullValuesSize; x++) {
                nullCapableValues.get(x).setNullValue(currentObject, session);
            }
        }
        List transformationMappings = treeObjectBuilder.getTransformationMappings();
        if (null != transformationMappings) {
            ReadObjectQuery query = new ReadObjectQuery();
            query.setSession((AbstractSession) session);
            for (int x = 0, transformationMappingsSize = transformationMappings.size(); x < transformationMappingsSize; x++) {
                AbstractTransformationMapping transformationMapping = (AbstractTransformationMapping) transformationMappings.get(x);
                transformationMapping.readFromRowIntoObject(transformationRecord, null, currentObject, null, query, (AbstractSession) session, true);
            }
        }
        XMLUnmarshalListener listener = unmarshaller.getUnmarshalListener();
        if (listener != null) {
            if (this.parentRecord != null) {
                listener.afterUnmarshal(currentObject, parentRecord.getCurrentObject());
            } else {
                listener.afterUnmarshal(currentObject, null);
            }
        }
        if (xmlDescriptor.hasEventManager()) {
            CoreDescriptorEventManager eventManager = xmlDescriptor.getEventManager();
            if (null != eventManager && eventManager.hasAnyEventListeners()) {
                DescriptorEvent event = new DescriptorEvent(currentObject);
                event.setSession((AbstractSession) session);
                event.setRecord(null);
                event.setEventCode(DescriptorEventManager.PostBuildEvent);
                eventManager.executeEvent(event);
            }
        }
    } catch (EclipseLinkException e) {
        if (null == xmlReader.getErrorHandler()) {
            throw e;
        } else {
            SAXParseException saxParseException = new SAXParseException(null, null, null, 0, 0, e);
            xmlReader.getErrorHandler().error(saxParseException);
        }
    }
    if (null != referenceResolver) {
        if (null != xmlDescriptor) {
            List primaryKeyFields = xmlDescriptor.getPrimaryKeyFields();
            if (null != primaryKeyFields) {
                int primaryKeyFieldsSize = primaryKeyFields.size();
                if (primaryKeyFieldsSize > 0) {
                    CacheId pk = (CacheId) treeObjectBuilder.extractPrimaryKeyFromObject(currentObject, session);
                    for (int x = 0; x < primaryKeyFieldsSize; x++) {
                        Object value = pk.getPrimaryKey()[x];
                        if (null == value) {
                            Field pkField = (Field) xmlDescriptor.getPrimaryKeyFields().get(x);
                            pk.set(x, unmarshaller.getContext().getValueByXPath(currentObject, pkField.getXPath(), pkField.getNamespaceResolver(), Object.class));
                        }
                    }
                    referenceResolver.putValue(xmlDescriptor.getJavaClass(), pk, currentObject);
                    if (unmarshaller.getIDResolver() != null) {
                        try {
                            if (primaryKeyFieldsSize > 1) {
                                Map<String, Object> idWrapper = new HashMap<String, Object>();
                                for (int x = 0; x < primaryKeyFieldsSize; x++) {
                                    String idName = (String) xmlDescriptor.getPrimaryKeyFieldNames().get(x);
                                    Object idValue = pk.getPrimaryKey()[x];
                                    idWrapper.put(idName, idValue);
                                }
                                unmarshaller.getIDResolver().bind(idWrapper, currentObject);
                            } else {
                                unmarshaller.getIDResolver().bind(pk.getPrimaryKey()[0], currentObject);
                            }
                        } catch (SAXException e) {
                            throw XMLMarshalException.unmarshalException(e);
                        }
                    }
                }
            }
        }
    }
    if (null != parentRecord) {
        reset();
    }
    if (xmlLocation != null && ((Descriptor) xmlDescriptor).getLocationAccessor() != null) {
        ((Descriptor) xmlDescriptor).getLocationAccessor().setAttributeValueInObject(getCurrentObject(), xmlLocation);
    }
}

Output:
         } else {
-            SAXParseException saxParseException = new SAXParseException(null, null, null, 0, 0, e);
+            SAXParseException saxParseException = new SAXParseException(null, getDocumentLocator(), e);
             xmlReader.getErrorHandler().error(saxParseException);


Input:
public String getValue(FacesContext facesContext, UIComponent component) throws IOException {
    AbstractInplaceInput inplaceInput = (AbstractInplaceInput) component;
    String value = getInputValue(facesContext, inplaceInput);
    if (value == null || "String_Node_Str".equals(value)) {
        value = inplaceInput.getDefaultLabel();
    }
    return value;
}

Output:
 public String getValue(FacesContext facesContext, UIComponent component) throws IOException {
-    AbstractInplaceInput inplaceInput = (AbstractInplaceInput) component;
-    String value = getInputValue(facesContext, inplaceInput);
+    String value = getInputValue(facesContext, component);
     if (value == null || "String_Node_Str".equals(value)) {


Input:
public Property getProperty() {
    exception = null;
    try {
        IProxyRepositoryFactory factory = null;
        if (!GlobalServiceRegister.getDefault().isServiceRegistered(IProxyRepositoryService.class)) {
            return null;
        }
        factory = ((IProxyRepositoryService) GlobalServiceRegister.getDefault().getService(IProxyRepositoryService.class)).getProxyRepositoryFactory();
        Project project = ProjectManager.getInstance().getProjectFromProjectLabel(this.projectLabel);
        IRepositoryViewObject object = factory.getLastVersion(project, id, this.path, this.type);
        if (object == null) {
            object = factory.getLastVersion(id);
        }
        if (object == null) {
            throw new PersistenceException("String_Node_Str" + label + "String_Node_Str" + id + "String_Node_Str");
        }
        this.customImage = null;
        Property property = object.getProperty();
        modified = factory.isModified(property);
        this.id = property.getId();
        this.author = property.getAuthor();
        this.creationDate = property.getCreationDate();
        this.description = property.getDescription();
        this.modificationDate = property.getModificationDate();
        this.label = property.getLabel();
        this.displayName = property.getDisplayName();
        this.purpose = property.getPurpose();
        this.statusCode = property.getStatusCode();
        this.version = property.getVersion();
        this.type = ERepositoryObjectType.getItemType(property.getItem());
        this.deleted = property.getItem().getState().isDeleted();
        this.path = property.getItem().getState().getPath();
        repositoryStatus = factory.getStatus(property.getItem());
        InformationLevel informationLevel = property.getMaxInformationLevel();
        informationStatus = factory.getStatus(informationLevel);
        if (type == ERepositoryObjectType.JOBLET) {
            JobletProcessItem item = (JobletProcessItem) property.getItem();
            if (item.getIcon() != null && item.getIcon().getInnerContent() != null && item.getIcon().getInnerContent().length != 0) {
                customImage = getJobletCustomIcon(property);
                customImage = ImageUtils.propertyLabelScale(property.getId(), customImage, ICON_SIZE.ICON_16);
            }
            IComponentsService service = (IComponentsService) GlobalServiceRegister.getDefault().getService(IComponentsService.class);
            IJobletProviderService jobletservice = (IJobletProviderService) GlobalServiceRegister.getDefault().getService(IJobletProviderService.class);
            if (service != null && jobletservice != null) {
                IComponentsFactory factorySingleton = service.getComponentsFactory();
                IComponent component = factorySingleton.get(property.getLabel(), DI);
                if (component != null) {
                    try {
                        Property tProperty = jobletservice.getJobletComponentItem(component);
                        if (!tProperty.getId().equals(this.id)) {
                            informationStatus = ERepositoryStatus.WARN;
                            property.setDescription(TIP);
                        }
                    } catch (Exception e) {
                    }
                }
            }
        } else if (type == ERepositoryObjectType.DOCUMENTATION) {
            this.customImage = ImageProvider.getImage(RepositoryImageProvider.getIcon(type));
            Item item = property.getItem();
            if (item instanceof DocumentationItem) {
                customImage = coreSerivce.getImageWithDocExt(((DocumentationItem) item).getExtension());
            } else if (item instanceof LinkDocumentationItem) {
                customImage = coreSerivce.getImageWithSpecial(customImage).createImage();
            }
        }
        return property;
    } catch (PersistenceException e) {
        exception = e;
    }
    return null;
}

Output:
         informationStatus = factory.getStatus(informationLevel);
-        if (type == ERepositoryObjectType.JOBLET) {
-            JobletProcessItem item = (JobletProcessItem) property.getItem();
-            if (item.getIcon() != null && item.getIcon().getInnerContent() != null && item.getIcon().getInnerContent().length != 0) {
-                customImage = getJobletCustomIcon(property);
-                customImage = ImageUtils.propertyLabelScale(property.getId(), customImage, ICON_SIZE.ICON_16);
-            }
-            IComponentsService service = (IComponentsService) GlobalServiceRegister.getDefault().getService(IComponentsService.class);
-            IJobletProviderService jobletservice = (IJobletProviderService) GlobalServiceRegister.getDefault().getService(IJobletProviderService.class);
-            if (service != null && jobletservice != null) {
-                IComponentsFactory factorySingleton = service.getComponentsFactory();
-                IComponent component = factorySingleton.get(property.getLabel(), DI);
-                if (component != null) {
-                    try {
-                        Property tProperty = jobletservice.getJobletComponentItem(component);
-                        if (!tProperty.getId().equals(this.id)) {
-                            informationStatus = ERepositoryStatus.WARN;
-                            property.setDescription(TIP);
+        if (!this.avoidGuiInfos) {
+            if (type == ERepositoryObjectType.JOBLET) {
+                JobletProcessItem item = (JobletProcessItem) property.getItem();
+                if (item.getIcon() != null && item.getIcon().getInnerContent() != null && item.getIcon().getInnerContent().length != 0) {
+                    customImage = getJobletCustomIcon(property);
+                    customImage = ImageUtils.propertyLabelScale(property.getId(), customImage, ICON_SIZE.ICON_16);
+                }
+                IComponentsService service = (IComponentsService) GlobalServiceRegister.getDefault().getService(IComponentsService.class);
+                IJobletProviderService jobletservice = (IJobletProviderService) GlobalServiceRegister.getDefault().getService(IJobletProviderService.class);
+                if (service != null && jobletservice != null) {
+                    IComponentsFactory factorySingleton = service.getComponentsFactory();
+                    IComponent component = factorySingleton.get(property.getLabel(), DI);
+                    if (component != null) {
+                        try {
+                            Property tProperty = jobletservice.getJobletComponentItem(component);
+                            if (!tProperty.getId().equals(this.id)) {
+                                informationStatus = ERepositoryStatus.WARN;
+                                property.setDescription(TIP);
+                            }
+                        } catch (Exception e) {
                         }


Input:
void updateExecutorStats(TopologyInfo info, MetricsState state, long now, boolean firstTime) {
    long overallTransferred = 0;
    long spoutTransferred = 0;
    long spoutAcked = 0;
    int executorsWithMetircs = 0;
    int spoutExecutors = 0;
    Map<String, List<Double>> comLat = new HashMap<String, List<Double>>();
    for (ExecutorSummary es : info.get_executors()) {
        String id = es.get_component_id();
        if (Utils.isSystemId(id)) {
            continue;
        }
        ExecutorStats exeStats = es.get_stats();
        if (exeStats != null) {
            ExecutorSpecificStats specs = exeStats.get_specific();
            ComponentCommon common = Utils.getComponentCommon(topology, id);
            for (String stream : common.get_streams().keySet()) {
                executorsWithMetircs++;
                long transferred = MetricsUtils.getTransferred(exeStats, ALL_TIME, stream);
                overallTransferred += transferred;
                if (isSpout(specs)) {
                    if (isDefaultStream(id) || isBatchStream(id)) {
                        spoutExecutors++;
                        spoutTransferred += transferred;
                        SpoutStats spStats = specs.get_spout();
                        spoutAcked += MetricsUtils.getSpoutAcked(spStats, ALL_TIME, stream);
                        if (firstTime) {
                            header.add(MetricsUtils.getSpoutAvgCompleteLatencyTitle(id));
                        }
                        double lat = MetricsUtils.getSpoutCompleteLatency(spStats, ALL_TIME, stream);
                        MetricsUtils.addLatency(comLat, id, lat);
                    }
                }
            }
        }
    }
    for (String id : comLat.keySet()) {
        List<Double> latList = comLat.get(id);
        double avg = null == latList ? 0.0 : BenchmarkUtils.avg(latList);
        double max = null == latList ? 0.0 : BenchmarkUtils.max(latList);
        metrics.put(MetricsUtils.getSpoutAvgCompleteLatencyTitle(id), String.format(SPOUT_AVG_LATENCY_FORMAT, avg));
        metrics.put(MetricsUtils.getSpoutMaxCompleteLatencyTitle(id), String.format(SPOUT_MAX_LATENCY_FORMAT, max));
    }
    metrics.put(EXECUTORS_METRICS, Integer.toString(executorsWithMetircs));
    metrics.put(SPOUT_EXECUTORS, Integer.toString(spoutExecutors));
    long timeDiff = now - state.lastTime;
    long overallDiff = overallTransferred - state.overallTransferred;
    long spoutDiff = spoutTransferred - state.spoutTransferred;
    long throughput = (long) MetricsUtils.getThroughput(overallDiff, timeDiff);
    double throughputMB = (long) MetricsUtils.getThroughputMB(overallDiff, timeDiff, msgSize);
    long spoutThroughput = (long) MetricsUtils.getThroughput(spoutDiff, timeDiff);
    double spoutThroughputMB = (long) MetricsUtils.getThroughputMB(spoutDiff, timeDiff, msgSize);
    metrics.put(TRANSFERRED, Long.toString(overallDiff));
    metrics.put(THROUGHPUT, Long.toString(throughput));
    metrics.put(THROUGHPUT_MB, String.format(THROUGHPUT_MB_FORMAT, throughputMB));
    metrics.put(SPOUT_TRANSFERRED, Long.toString(spoutDiff));
    metrics.put(SPOUT_ACKED, Long.toString(spoutAcked));
    metrics.put(SPOUT_THROUGHPUT, Long.toString(spoutThroughput));
    metrics.put(SPOUT_THROUGHPUT_MB, String.format(SPOUT_THROUGHPUT_MB_FORMAT, spoutThroughputMB));
    state.overallTransferred = overallTransferred;
    state.spoutTransferred = spoutTransferred;
}

Output:
                 if (isSpout(specs)) {
-                    if (isDefaultStream(id) || isBatchStream(id)) {
+                    if (isDefaultStream(stream) || isBatchStream(stream)) {
                         spoutExecutors++;


Input:
public int getHour() {
    return _hour;
}

Output:
 public int getHour() {
-    return _hour;
+    synchronized (this) {
+        return _hour;
+    }
 }


Input:
void checkFinished(Upload upload) {
    if (mDebug) {
        System.out.println("String_Node_Str" + mUpload);
    }
    if (upload.isHashInAccount()) {
        if (mDebug) {
            System.out.println("String_Node_Str" + mUpload);
        }
        Upload.Options.ActionOnInAccount actionOnInAccount = upload.getOptions().getActionOnInAccount();
        switch(actionOnInAccount) {
            case UPLOAD_ALWAYS:
                doInstantUpload(upload);
                break;
            case UPLOAD_IF_NOT_IN_FOLDER:
                if (upload.isHashInFolder()) {
                    doInstantUpload(upload);
                } else {
                    if (mListener != null) {
                        mListener.uploadFinished(upload, upload.getDuplicateQuickKey());
                    }
                }
                break;
            case DO_NOT_UPLOAD:
            default:
                if (mListener != null) {
                    mListener.uploadFinished(upload, upload.getDuplicateQuickKey());
                }
                break;
        }
        return;
    } else {
        if (mDebug) {
            System.out.println("String_Node_Str" + mUpload);
        }
    }
    if (upload.isHashInMediaFire()) {
        if (mDebug) {
            System.out.println("String_Node_Str" + mUpload);
        }
        doInstantUpload(upload);
    } else {
        if (mDebug) {
            System.out.println("String_Node_Str" + mUpload);
        }
        doResumableUpload(upload);
    }
}

Output:
             case UPLOAD_IF_NOT_IN_FOLDER:
-                if (upload.isHashInFolder()) {
+                if (!upload.isHashInFolder()) {
                     doInstantUpload(upload);


Input:
public Ref call() throws GitAPIException, CheckoutConflictException {
    checkCallable();
    try {
        RepositoryState state = repo.getRepositoryState();
        final boolean merging = state.equals(RepositoryState.MERGING) || state.equals(RepositoryState.MERGING_RESOLVED);
        final boolean cherryPicking = state.equals(RepositoryState.CHERRY_PICKING) || state.equals(RepositoryState.CHERRY_PICKING_RESOLVED);
        final boolean reverting = state.equals(RepositoryState.REVERTING) || state.equals(RepositoryState.REVERTING_RESOLVED);
        final ObjectId commitId = resolveRefToCommitId();
        if (ref != null && commitId == null) {
            throw new JGitInternalException("String_Node_Str" + ref + "String_Node_Str");
        }
        final ObjectId commitTree;
        if (commitId != null)
            commitTree = parseCommit(commitId).getTree();
        else
            commitTree = null;
        if (!filepaths.isEmpty()) {
            resetIndexForPaths(commitTree);
            setCallable(false);
            return repo.getRef(Constants.HEAD);
        }
        final Ref result;
        if (commitId != null) {
            final RefUpdate ru = repo.updateRef(Constants.HEAD);
            ru.setNewObjectId(commitId);
            String refName = Repository.shortenRefName(getRefOrHEAD());
            String message = refName + "String_Node_Str" + Constants.HEAD;
            ru.setRefLogMessage(message, false);
            if (ru.forceUpdate() == RefUpdate.Result.LOCK_FAILURE)
                throw new JGitInternalException(MessageFormat.format(JGitText.get().cannotLock, ru.getName()));
            ObjectId origHead = ru.getOldObjectId();
            if (origHead != null)
                repo.writeOrigHead(origHead);
            result = ru.getRef();
        } else {
            result = repo.getRef(Constants.HEAD);
        }
        if (mode == null)
            mode = ResetType.MIXED;
        switch(mode) {
            case HARD:
                checkoutIndex(commitTree);
                break;
            case MIXED:
                resetIndex(commitTree);
                break;
            case SOFT:
                break;
            case KEEP:
            case MERGE:
                throw new UnsupportedOperationException();
        }
        if (mode != ResetType.SOFT) {
            if (merging)
                resetMerge();
            else if (cherryPicking)
                resetCherryPick();
            else if (reverting)
                resetRevert();
            else if (repo.readSquashCommitMsg() != null)
                repo.writeSquashCommitMsg(null);
        }
        setCallable(false);
        return result;
    } catch (IOException e) {
        throw new JGitInternalException(JGitText.get().exceptionCaughtDuringExecutionOfResetCommand, e);
    }
}

Output:
     } catch (IOException e) {
-        throw new JGitInternalException(JGitText.get().exceptionCaughtDuringExecutionOfResetCommand, e);
+        throw new JGitInternalException(MessageFormat.format(JGitText.get().exceptionCaughtDuringExecutionOfResetCommand, e.getMessage()), e);
     }


Input:
public StatementProcessor getStatementProcessor() {
    return new StatementProcessor((StatementProcessor.ProcessorExecutionType) processorTypeComboBox.getSelectedItem(), processorTextField.getText());
}

Output:
 public StatementProcessor getStatementProcessor() {
-    return new StatementProcessor((StatementProcessor.ProcessorExecutionType) processorTypeComboBox.getSelectedItem(), processorTextField.getText());
+    StatementProcessor.ProcessorExecutionType type = (StatementProcessor.ProcessorExecutionType) processorTypeComboBox.getSelectedItem();
+    return new StatementProcessor(type, type == StatementProcessor.ProcessorExecutionType.STATIC ? processorStaticSQLTextArea.getText() : processorTextField.getText());
 }


Input:
public DeliverResults createNewDeliver(Deliver deliver, ActivityID activityID) throws AuthPelpException, InvalidActivityPelpException, ExecPelpException {
    if (!isUserAuthenticated()) {
        throw new AuthPelpException("String_Node_Str");
    }
    Activity activity = _activityManager.getActivity(activityID);
    if (activity == null) {
        throw new InvalidActivityPelpException("String_Node_Str");
    }
    if (!isStudent(activityID.subjectID)) {
        throw new AuthPelpException("String_Node_Str");
    }
    for (IClassroomID classroom : _campusConnection.getUserClassrooms(UserRoles.Student, activityID.subjectID)) {
        deliver.addMainClassroom(classroom);
    }
    ISubjectID[] labSubjects = _administrationManager.getLabSubjectOfMain(activityID.subjectID);
    if (labSubjects != null && labSubjects.length > 0) {
        boolean hasLab = false;
        for (ISubjectID labSubjectID : labSubjects) {
            if (hasLab) {
                break;
            }
            for (IClassroomID classroom : _campusConnection.getUserClassrooms(UserRoles.Student, labSubjectID)) {
                deliver.addLabClassroom(classroom);
                hasLab = true;
                break;
            }
        }
    }
    int numDelivers = _deliverManager.getNumUserDelivers(_campusConnection.getUserID(), activityID);
    if (activity.getMaxDelivers() != null) {
        if (numDelivers >= activity.getMaxDelivers()) {
            throw new InvalidActivityPelpException("String_Node_Str");
        }
    }
    DeliverID deliverID = _deliverManager.addDeliver(_campusConnection.getUserID(), activityID, deliver);
    if (deliverID == null) {
        throw new ExecPelpException("String_Node_Str");
    }
    Deliver newDeliver = _deliverManager.getDeliver(deliverID);
    if (newDeliver == null) {
        throw new ExecPelpException("String_Node_Str");
    }
    TestID[] testID = _activityManager.getActivityTests(activityID);
    ActivityTest[] tests = null;
    if (testID.length > 0) {
        tests = new ActivityTest[testID.length];
        for (int i = 0; i < testID.length; i++) {
            tests[i] = _activityManager.getTest(testID[i]);
        }
    }
    CodeProject project = newDeliver.getCodeProject();
    project.setLanguage(activity.getLanguage());
    AnalysisResults analysisResults = analyzeCode(project, tests);
    if (!_deliverManager.addResults(deliverID, analysisResults)) {
        throw new ExecPelpException("String_Node_Str");
    }
    return _deliverManager.getResults(deliverID);
}

Output:
     }
-    return _deliverManager.getResults(deliverID);
+    DeliverResults results = _deliverManager.getResults(deliverID);
+    removePrivateResultInformation(results);
+    return results;
 }


Input:
protected IStatus redo() {
    System.out.println(getText() + "String_Node_Str");
    String doc = redoActionTrack.get(getActionUndoPos());
    refresh(doc);
    return Status.OK_STATUS;
}

Output:
 protected IStatus redo() {
-    System.out.println(getText() + "String_Node_Str");
+    log.info(getText() + "String_Node_Str");
     String doc = redoActionTrack.get(getActionUndoPos());


Input:
public static RawFileBackendState getRawFileBackendState(SwordBookMetaData metadata) throws BookException {
    ensureNotShuttingDown();
    RawFileBackendState state = getInstance(metadata);
    if (state == null) {
        state = new RawFileBackendState(metadata);
    }
    return state;
}

Output:
     if (state == null) {
-        state = new RawFileBackendState(metadata);
+        LOGGER.trace("String_Node_Str", metadata.getInitials());
+        return new RawFileBackendState(metadata);
     }


Input:
public static void checkAndUpdateRepFolderName4Rename(String oldFolderName, TDQReportItem repItem) {
    String newFolderName = ReportUtils.getSimpleName(repItem.getProperty());
    if (!oldFolderName.equals(newFolderName)) {
        IContainer repItemParent = PropertyHelper.getItemFile(repItem.getProperty()).getParent();
        File oldFolder = WorkspaceUtils.ifolderToFile(repItemParent.getFolder(Path.fromPortableString(PluginConstant.DOT_STRING + oldFolderName)));
        File newFolder = WorkspaceUtils.ifolderToFile(repItemParent.getFolder(Path.fromPortableString(PluginConstant.DOT_STRING + newFolderName)));
        try {
            oldFolder.renameTo(newFolder);
            File file = new File(ReportHelper.getOutputFolderNameDefault((IFolder) repItemParent, newFolderName) + File.separator + REPORT_LIST);
            if (file.exists() && file.isFile()) {
                FilesUtils.replaceInFile(oldFolder.toString(), file.toString(), newFolder.toString());
            }
            repItemParent.refreshLocal(IResource.DEPTH_INFINITE, null);
        } catch (Exception e) {
            log.warn(e, e);
        }
    }
}

Output:
     if (!oldFolderName.equals(newFolderName)) {
-        IContainer repItemParent = PropertyHelper.getItemFile(repItem.getProperty()).getParent();
-        File oldFolder = WorkspaceUtils.ifolderToFile(repItemParent.getFolder(Path.fromPortableString(PluginConstant.DOT_STRING + oldFolderName)));
-        File newFolder = WorkspaceUtils.ifolderToFile(repItemParent.getFolder(Path.fromPortableString(PluginConstant.DOT_STRING + newFolderName)));
+        File oldFolder = WorkspaceUtils.ifolderToFile(parentFolder.getFolder(Path.fromPortableString(PluginConstant.DOT_STRING + oldFolderName)));
+        File newFolder = WorkspaceUtils.ifolderToFile(parentFolder.getFolder(Path.fromPortableString(PluginConstant.DOT_STRING + newFolderName)));
         try {


Input:
public void onPlayerTeleport(PlayerTeleportEvent event) {
    if (event.isCancelled())
        PortalManager.checkPlayerMove(event.getPlayer(), RegionManager.getRegion(event.getFrom()), RegionManager.getRegion(event.getTo()));
}

Output:
 public void onPlayerTeleport(PlayerTeleportEvent event) {
-    if (event.isCancelled())
-        PortalManager.checkPlayerMove(event.getPlayer(), RegionManager.getRegion(event.getFrom()), RegionManager.getRegion(event.getTo()));
+    PortalManager.checkPlayerMove(event.getPlayer(), RegionManager.getRegion(event.getFrom()), RegionManager.getRegion(event.getTo()));
 }


Input:
private void loadDteMetaInfo() {
    try {
        ObjectInputStream ois = new ObjectInputStream(reader.getStream(DATA_META_STREAM));
        mapQueryIDToResultSetIDs = (HashMap) ois.readObject();
        queryResultRelations = (ArrayList) ois.readObject();
        queryExpressionIDs = (ArrayList) ois.readObject();
        ois.close();
    } catch (IOException ioe) {
        context.addException(new EngineException("String_Node_Str", ioe));
        logger.log(Level.SEVERE, ioe.getMessage(), ioe);
    } catch (ClassNotFoundException cnfe) {
        context.addException(new EngineException("String_Node_Str", cnfe));
        logger.log(Level.SEVERE, cnfe.getMessage(), cnfe);
    }
}

Output:
     try {
-        ObjectInputStream ois = new ObjectInputStream(reader.getStream(DATA_META_STREAM));
-        mapQueryIDToResultSetIDs = (HashMap) ois.readObject();
-        queryResultRelations = (ArrayList) ois.readObject();
-        queryExpressionIDs = (ArrayList) ois.readObject();
-        ois.close();
+        DataInputStream dis = new DataInputStream(reader.getStream(DATA_META_STREAM));
+        mapQueryIDToResultSetIDs = new HashMap();
+        int size = IOUtil.readInt(dis);
+        for (int i = 0; i < size; i++) {
+            String queryId = IOUtil.readString(dis);
+            LinkedList ridList = new LinkedList();
+            readStringList(dis, ridList);
+            mapQueryIDToResultSetIDs.put(queryId, ridList);
+        }
+        size = IOUtil.readInt(dis);
+        queryResultRelations = new ArrayList();
+        for (int i = 0; i < size; i++) {
+            String parentRSID = IOUtil.readString(dis);
+            String resultSetID = IOUtil.readString(dis);
+            String rowid = IOUtil.readString(dis);
+            Key key = new Key(parentRSID, rowid, resultSetID);
+            queryResultRelations.add(key);
+        }
+        size = IOUtil.readInt(dis);
+        queryExpressionIDs = new ArrayList();
+        for (int i = 0; i < size; i++) {
+            QueryID queryId = new QueryID();
+            readQueryID(dis, queryId);
+            queryExpressionIDs.add(queryId);
+        }
+        dis.close();
     } catch (IOException ioe) {


Input:
public List getProperties() {
    return EMPTY_LIST;
}

Output:
 public List getProperties() {
-    return EMPTY_LIST;
+    return Collections.EMPTY_LIST;
 }


Input:
void connectMAVConnection(ConnectionParameter connParams) {
    AndroidMavLinkConnection conn = mavConnections.get(connParams);
    if (conn == null) {
        final int connectionType = connParams.getConnectionType();
        final Bundle paramsBundle = connParams.getParamsBundle();
        switch(connectionType) {
            case ConnectionType.TYPE_USB:
                final int baudRate = paramsBundle.getInt(ConnectionType.EXTRA_USB_BAUD_RATE, ConnectionType.DEFAULT_USB_BAUD_RATE);
                conn = new UsbConnection(getApplicationContext(), baudRate);
                Log.d(TAG, "String_Node_Str");
                break;
            case ConnectionType.TYPE_BLUETOOTH:
                final String bluetoothAddress = paramsBundle.getString(ConnectionType.EXTRA_BLUETOOTH_ADDRESS);
                conn = new BluetoothConnection(getApplicationContext(), bluetoothAddress);
                Log.d(TAG, "String_Node_Str");
                break;
            case ConnectionType.TYPE_TCP:
                final String tcpServerIp = paramsBundle.getString(ConnectionType.EXTRA_TCP_SERVER_IP);
                final int tcpServerPort = paramsBundle.getInt(ConnectionType.EXTRA_TCP_SERVER_PORT, ConnectionType.DEFAULT_TCP_SERVER_PORT);
                conn = new AndroidTcpConnection(getApplicationContext(), tcpServerIp, tcpServerPort);
                Log.d(TAG, "String_Node_Str");
                break;
            case ConnectionType.TYPE_UDP:
                final int udpServerPort = paramsBundle.getInt(ConnectionType.EXTRA_UDP_SERVER_PORT, ConnectionType.DEFAULT_UPD_SERVER_PORT);
                conn = new AndroidUdpConnection(getApplicationContext(), udpServerPort);
                Log.d(TAG, "String_Node_Str");
                break;
            default:
                Log.e(TAG, "String_Node_Str" + connectionType);
                return;
        }
        mavConnections.put(connParams, conn);
    }
    if (conn.getConnectionStatus() == MavLinkConnection.MAVLINK_DISCONNECTED) {
        conn.connect();
    }
    GAUtils.sendEvent(new HitBuilders.EventBuilder().setCategory(GAUtils.Category.MAVLINK_CONNECTION).setAction("String_Node_Str").setLabel(connParams.toString()));
}

Output:
     }
-    GAUtils.sendEvent(new HitBuilders.EventBuilder().setCategory(GAUtils.Category.MAVLINK_CONNECTION).setAction("String_Node_Str").setLabel(connParams.toString()));
+    conn.addMavLinkConnectionListener(listenerTag, listener);
 }


Input:
public synchronized void processImage(int sourceID, long frameID, final BufferedImage buffered, ImageBase input) {
    if (buffered != null) {
        original = ConvertBufferedImage.checkCopy(buffered, original);
        work = ConvertBufferedImage.checkDeclare(buffered.getWidth(), buffered.getHeight(), work, buffered.getType());
        binary.reshape(work.getWidth(), work.getHeight());
        inputPrev.setTo((T) input);
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                Dimension d = guiImage.getPreferredSize();
                if (d.getWidth() < buffered.getWidth() || d.getHeight() < buffered.getHeight()) {
                    guiImage.setPreferredSize(new Dimension(buffered.getWidth(), buffered.getHeight()));
                }
            }
        });
    } else {
        input = inputPrev;
    }
    inputToBinary.process((T) input, binary);
    detector.process((T) input, binary);
    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            viewUpdated();
        }
    });
}

Output:
         original = ConvertBufferedImage.checkCopy(buffered, original);
-        work = ConvertBufferedImage.checkDeclare(buffered.getWidth(), buffered.getHeight(), work, buffered.getType());
+        work = ConvertBufferedImage.checkDeclare(buffered, work);
         binary.reshape(work.getWidth(), work.getHeight());


Input:
public void testTrace() {
    BigMatrix m = new BigMatrixImpl(id);
    assertEquals("String_Node_Str", 3d, m.getTrace().doubleValue(), entryTolerance);
    m = new BigMatrixImpl(testData2);
    try {
        m.getTrace().doubleValue();
        fail("String_Node_Str");
    } catch (NonSquareMatrixException ex) {
    }
}

Output:
     try {
-        m.getTrace().doubleValue();
-        fail("String_Node_Str");
+        double t = m.getTrace().doubleValue();
+        fail("String_Node_Str" + t);
     } catch (NonSquareMatrixException ex) {


Input:
public LogBuffer put(char[] chars) throws IOException {
    if (mappedBuffer == null || (MAPPED_SIZE - mappedBuffer.position()) < (chars.length * 2)) {
        getNewMappedBuffer();
        if (mappedBuffer == null) {
            fallbackBuffer.clear();
            fallbackBuffer.asCharBuffer().put(chars);
            fallbackBuffer.limit(chars.length * 2);
            fileChannel.write(fallbackBuffer, mappedStartPosition);
            mappedStartPosition += (chars.length * 2);
            return this;
        }
    }
    int oldPos = mappedBuffer.position();
    mappedBuffer.asCharBuffer().put(chars);
    mappedBuffer.position(oldPos + chars.length * 2);
    return this;
}

Output:
         if (mappedBuffer == null) {
-            fallbackBuffer.clear();
-            fallbackBuffer.asCharBuffer().put(chars);
-            fallbackBuffer.limit(chars.length * 2);
-            fileChannel.write(fallbackBuffer, mappedStartPosition);
-            mappedStartPosition += (chars.length * 2);
-            return this;
+            int bytesToWrite = (chars.length - offset) * 2;
+            ByteBuffer buf = ByteBuffer.allocate(bytesToWrite);
+            buf.asCharBuffer().put(chars, offset, chars.length - offset);
+            buf.limit(chars.length * 2);
+            int count = fileChannel.write(buf, mappedStartPosition);
+            if (count != bytesToWrite) {
+                throw new UnderlyingStorageException("String_Node_Str" + offset + "String_Node_Str" + bytesToWrite + "String_Node_Str" + count);
+            }
+            mappedStartPosition += bytesToWrite;
+            return;
         }


Input:
protected void updateRowStates() {
    mKeyguardIconOverflowContainer.getIconsView().removeAllViews();
    ArrayList<Entry> activeNotifications = mNotificationData.getActiveNotifications();
    final int N = activeNotifications.size();
    int visibleNotifications = 0;
    boolean onKeyguard = mState == StatusBarState.KEYGUARD;
    int maxNotifications = 0;
    if (onKeyguard) {
        maxNotifications = getMaxKeyguardNotifications(true);
    }
    for (int i = 0; i < N; i++) {
        NotificationData.Entry entry = activeNotifications.get(i);
        boolean childNotification = mGroupManager.isChildInGroupWithSummary(entry.notification);
        if (onKeyguard) {
            entry.row.setOnKeyguard(true);
        } else {
            entry.row.setOnKeyguard(false);
            entry.row.setSystemExpanded(visibleNotifications == 0 && !childNotification);
        }
        boolean suppressedSummary = mGroupManager.isSummaryOfSuppressedGroup(entry.notification) && !entry.row.isRemoved();
        boolean childWithVisibleSummary = childNotification && mGroupManager.getGroupSummary(entry.notification).getVisibility() == View.VISIBLE;
        boolean showOnKeyguard = shouldShowOnKeyguard(entry.notification);
        if (suppressedSummary || (isLockscreenPublicMode() && !mShowLockscreenNotifications) || (onKeyguard && !childWithVisibleSummary && (visibleNotifications >= maxNotifications || !showOnKeyguard))) {
            entry.row.setVisibility(View.GONE);
            if (onKeyguard && showOnKeyguard && !childNotification && !suppressedSummary) {
                mKeyguardIconOverflowContainer.getIconsView().addNotification(entry);
            }
        } else {
            boolean wasGone = entry.row.getVisibility() == View.GONE;
            entry.row.setVisibility(View.VISIBLE);
            if (!childNotification) {
                if (wasGone) {
                    mStackScroller.generateAddAnimation(entry.row, !showOnKeyguard);
                }
                visibleNotifications++;
            }
        }
    }
    mStackScroller.updateOverflowContainerVisibility(onKeyguard && mKeyguardIconOverflowContainer.getIconsView().getChildCount() > 0);
    mStackScroller.changeViewPosition(mDismissView, mStackScroller.getChildCount() - 1);
    mStackScroller.changeViewPosition(mEmptyShadeView, mStackScroller.getChildCount() - 2);
    mStackScroller.changeViewPosition(mKeyguardIconOverflowContainer, mStackScroller.getChildCount() - 3);
}

Output:
             entry.row.setVisibility(View.VISIBLE);
-            if (!childNotification) {
+            if (!childNotification && !entry.row.isRemoved()) {
                 if (wasGone) {


Input:
public boolean selectCatalog(String catalogName) {
    if (connection == null) {
        return false;
    }
    try {
        connection.setCatalog(catalogName);
        return true;
    } catch (SQLException e) {
        return false;
    }
}

Output:
     try {
-        connection.setCatalog(catalogName);
+        if (!ConnectionUtils.isOdbcProgress(connection)) {
+            connection.setCatalog(catalogName);
+        }
         return true;


Input:
public Multimap<String, AttributeModifier> getAttributeModifiers(EntityEquipmentSlot equipmentSlot, ItemStack stack) {
    Multimap<String, AttributeModifier> multimap = super.getAttributeModifiers(equipmentSlot, stack);
    if (equipmentSlot == this.armorType) {
        TIER tier = getTier(stack);
        multimap.put(SharedMonsterAttributes.MOVEMENT_SPEED.getAttributeUnlocalizedName(), new AttributeModifier(ARMOR_MODIFIERS[equipmentSlot.getIndex()], "String_Node_Str", getSpeedBoost(tier), 2));
    }
    return multimap;
}

Output:
         TIER tier = getTier(stack);
-        multimap.put(SharedMonsterAttributes.MOVEMENT_SPEED.getAttributeUnlocalizedName(), new AttributeModifier(ARMOR_MODIFIERS[equipmentSlot.getIndex()], "String_Node_Str", getSpeedBoost(tier), 2));
+        multimap.put(SharedMonsterAttributes.MOVEMENT_SPEED.getAttributeUnlocalizedName(), new AttributeModifier(VAMIRISM_ARMOR_MODIFIER[equipmentSlot.getIndex()], "String_Node_Str", getSpeedBoost(tier), 2));
     }


Input:
public void testSerializationAndDeserialization() throws InterruptedException {
    c2.registerListener(listener);
    c1.sendPacket(NetworkConstants.ENetworkKey.TEST_PACKET, packet);
    Thread.sleep(150);
    List<? extends Packet> bufferedPackets = listener.popBufferedPackets();
    assertEquals(1, bufferedPackets.size());
    assertEquals(packet, bufferedPackets.get(0));
    assertEquals(packet.hashCode(), bufferedPackets.get(0).hashCode());
}

Output:
     c1.sendPacket(NetworkConstants.ENetworkKey.TEST_PACKET, packet);
-    Thread.sleep(150);
+    Thread.sleep(150L);
     List<? extends Packet> bufferedPackets = listener.popBufferedPackets();


Input:
public void visitTypeInsn(int opcode, String type) {
    super.visitTypeInsn(opcode, main.srg.getClassName(type));
}

Output:
 public void visitTypeInsn(int opcode, String type) {
-    super.visitTypeInsn(opcode, main.srg.getClassName(type));
+    String deobf = type.charAt(0) == '[' ? main.deobfTypeDescriptor(type) : main.srg.getClassName(type);
+    super.visitTypeInsn(opcode, deobf);
 }


Input:
protected void writeCell(DataOutputStream out, CellDesign cell) throws IOException {
    writeReportItem(out, cell);
    int column = cell.getColumn();
    if (column != -1) {
        IOUtil.writeShort(out, FIELD_COLUMN);
        IOUtil.writeInt(out, column);
    }
    int colSpan = cell.getColSpan();
    if (colSpan != 1) {
        IOUtil.writeShort(out, FIELD_COL_SPAN);
        IOUtil.writeInt(out, colSpan);
    }
    int rowSpan = cell.getRowSpan();
    if (rowSpan != 1) {
        IOUtil.writeShort(out, FIELD_ROW_SPAN);
        IOUtil.writeInt(out, rowSpan);
    }
    Expression<String> drop = cell.getDrop();
    if (drop != null) {
        IOUtil.writeShort(out, FIELD_DROP);
        write(out, drop);
    }
    boolean displayGroupIcon = cell.getDisplayGroupIcon();
    if (displayGroupIcon) {
        IOUtil.writeShort(out, FIELD_DISPLAY_GROUP_ICON);
        IOUtil.writeBool(out, displayGroupIcon);
    }
    if (cell.hasDiagonalLine()) {
        int diagonalNumber = cell.getDiagonalNumber();
        if (diagonalNumber > 0) {
            IOUtil.writeShort(out, FIELD_DIAGONAL_NUMBER);
            IOUtil.writeInt(out, diagonalNumber);
            String diagonalStyle = cell.getDiagonalStyle();
            if (diagonalStyle != null) {
                IOUtil.writeShort(out, FIELD_DIAGONAL_STYLE);
                IOUtil.writeString(out, diagonalStyle);
            }
            DimensionType diagonalWidth = cell.getDiagonalWidth();
            if (diagonalWidth != null) {
                IOUtil.writeShort(out, FIELD_DIAGONAL_WIDTH);
                writeDimension(out, diagonalWidth);
            }
        }
        int antidiagonalNumber = cell.getAntidiagonalNumber();
        if (antidiagonalNumber > 0) {
            IOUtil.writeShort(out, FIELD_ANTIDIAGONAL_NUMBER);
            IOUtil.writeInt(out, antidiagonalNumber);
            String antidiagonalStyle = cell.getAntidiagonalStyle();
            if (antidiagonalStyle != null) {
                IOUtil.writeShort(out, FIELD_ANTIDIAGONAL_STYLE);
                IOUtil.writeString(out, antidiagonalStyle);
            }
            DimensionType antidiagonalWidth = cell.getAntidiagonalWidth();
            if (antidiagonalWidth != null) {
                IOUtil.writeShort(out, FIELD_ANTIDIAGONAL_WIDTH);
                writeDimension(out, antidiagonalWidth);
            }
        }
    }
}

Output:
     }
-    Expression<String> drop = cell.getDrop();
+    String drop = cell.getDrop();
     if (drop != null) {


Input:
protected Map<String, ImageIcon> doInBackground() throws Exception {
    setCurrentWorker(this);
    view.getProgressBar().setIndeterminate(false);
    setProgress(0);
    final Map<String, ImageIcon> map = new HashMap<>();
    try {
        int i = 1;
        for (String skybox : data) {
            setProgress((int) (100 * ((double) i / data.size())));
            status.fine("String_Node_Str" + skybox);
            String img = "String_Node_Str" + skybox + "String_Node_Str";
            if (!Files.exists(Paths.get(img))) {
                String filename = skybox + "String_Node_Str";
                cl.extractIfNeeded(settings.getTfPath(), "String_Node_Str", Paths.get("String_Node_Str"), filename);
                cl.generatePreview(filename);
            }
            ImageIcon icon = createPreviewIcon(img);
            map.put(skybox, icon);
            i++;
        }
    } catch (Exception e) {
        log.log(Level.INFO, "String_Node_Str", e);
    }
    return map;
}

Output:
     try {
-        int i = 1;
-        for (String skybox : data) {
-            setProgress((int) (100 * ((double) i / data.size())));
-            status.fine("String_Node_Str" + skybox);
-            String img = "String_Node_Str" + skybox + "String_Node_Str";
-            if (!Files.exists(Paths.get(img))) {
-                String filename = skybox + "String_Node_Str";
-                cl.extractIfNeeded(settings.getTfPath(), "String_Node_Str", Paths.get("String_Node_Str"), filename);
-                cl.generatePreview(filename);
-            }
-            ImageIcon icon = createPreviewIcon(img);
-            map.put(skybox, icon);
-            i++;
-        }
+        configureSkyboxes(view.getCmbSkybox());
     } catch (Exception e) {


Input:
private void setupViewPager(ViewPager viewPager) {
    ViewPagerAdapter adapter = new ViewPagerAdapter(mainActivity.getSupportFragmentManager());
    SentRequestsFragment sentRequestsFragment = new SentRequestsFragment();
    ReceivedRequestsFragment receivedRequestsFragment = new ReceivedRequestsFragment();
    adapter.addFrag(sentRequestsFragment, "String_Node_Str");
    adapter.addFrag(receivedRequestsFragment, "String_Node_Str");
    viewPager.setAdapter(adapter);
    adapter.notifyDataSetChanged();
}

Output:
 private void setupViewPager(ViewPager viewPager) {
-    ViewPagerAdapter adapter = new ViewPagerAdapter(mainActivity.getSupportFragmentManager());
+    ViewPagerAdapter adapter = new ViewPagerAdapter(getChildFragmentManager());
     SentRequestsFragment sentRequestsFragment = new SentRequestsFragment();


Input:
public void fire() throws IllegalActionException {
    super.fire();
    if (input.hasToken(0)) {
        Time currentTime = getDirector().getModelTime();
        DoubleToken currentToken = (DoubleToken) input.get(0);
        _currentInput = new TimedEvent(currentTime, currentToken);
        DoubleToken currentOutput = (DoubleToken) currentToken.multiply(Kp.getToken());
        if (_lastInput != null) {
            DoubleToken lastToken = (DoubleToken) _lastInput.contents;
            Time lastTime = _lastInput.timeStamp;
            DoubleToken timeGap = new DoubleToken(currentTime.subtract(lastTime).getDoubleValue());
            if (timeGap.isCloseTo(DoubleToken.ZERO, Complex.EPSILON).booleanValue()) {
                if (!((DoubleToken) Kd.getToken()).isCloseTo(DoubleToken.ZERO, Complex.EPSILON).booleanValue() && !currentToken.equals(lastToken)) {
                    throw new IllegalActionException("String_Node_Str");
                }
            } else {
                if (!((DoubleToken) Ki.getToken()).isCloseTo(DoubleToken.ZERO, Complex.EPSILON).booleanValue()) {
                    _accumulated = (DoubleToken) _accumulated.add(currentToken.add(lastToken).multiply(timeGap).multiply(new DoubleToken(0.5)));
                    currentOutput = (DoubleToken) currentOutput.add(_accumulated.multiply(Ki.getToken()));
                }
                if (!Kd.equals(0)) {
                    currentOutput = (DoubleToken) currentOutput.add(currentToken.subtract(lastToken).divide(timeGap).multiply(Kd.getToken()));
                }
            }
        }
        output.broadcast(currentOutput);
    }
}

Output:
                 }
-                if (!Kd.equals(0)) {
+                if (!((DoubleToken) Kd.getToken()).isCloseTo(DoubleToken.ZERO, Complex.EPSILON).booleanValue()) {
                     currentOutput = (DoubleToken) currentOutput.add(currentToken.subtract(lastToken).divide(timeGap).multiply(Kd.getToken()));


Input:
public void dumpIdxRaf(RandomAccessFile raf) {
    long end = -1;
    try {
        end = raf.length();
    } catch (IOException e) {
        e.printStackTrace();
    }
    int blockNum = 0;
    StringBuilder buf = new StringBuilder();
    System.out.println("String_Node_Str");
    for (long offset = 0; offset < end; offset += IDX_ENTRY_SIZE) {
        byte[] temp = null;
        try {
            temp = SwordUtil.readRAF(raf, offset, IDX_ENTRY_SIZE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        int blockStart = -1;
        int blockSize = -1;
        int uncompressedSize = -1;
        if (temp != null && temp.length > 0) {
            blockStart = SwordUtil.decodeLittleEndian32(temp, 0);
            blockSize = SwordUtil.decodeLittleEndian32(temp, 4);
            uncompressedSize = SwordUtil.decodeLittleEndian32(temp, 8);
        }
        buf.setLength(0);
        buf.append(blockNum);
        buf.append('\t');
        buf.append(blockStart);
        buf.append('\t');
        buf.append(blockSize);
        buf.append('\t');
        buf.append(uncompressedSize);
        System.out.println(buf.toString());
    }
}

Output:
     }
-    int blockNum = 0;
+    int i = ordinalStart;
     StringBuilder buf = new StringBuilder();


Input:
public void migrationSuccessful(MigrationTask task, MigrationContext ctx) throws MigrationException {
    log.debug("String_Node_Str" + task.getName() + "String_Node_Str" + ctx + "String_Node_Str" + this);
    int patchLevel = task.getLevel().intValue();
    for (Iterator patchTableIter = contexts.entrySet().iterator(); patchTableIter.hasNext(); ) {
        PatchInfoStore store = (PatchInfoStore) ((Map.Entry) patchTableIter.next()).getValue();
        store.updatePatchLevel(patchLevel);
    }
}

Output:
         PatchInfoStore store = (PatchInfoStore) ((Map.Entry) patchTableIter.next()).getValue();
-        store.updatePatchLevel(patchLevel);
+        int storePatchLevel = store.getPatchLevel();
+        if (patchLevel > storePatchLevel) {
+            store.updatePatchLevel(patchLevel);
+        }
     }


Input:
private void radialRemoval(SnipeData v) {
    int cx = this.targetBlock.getChunkPosition().getX();
    int cz = this.targetBlock.getChunkPosition().getZ();
    int entityCount = 0;
    int chunkCount = 0;
    int radius = (int) Math.round(v.getBrushSize() / 16);
    int radiusSquared = radius * radius;
    for (int x = -radius; x <= radius; x++) {
        for (int z = -radius; z <= radius; z++) {
            if (x * x + z * z < radiusSquared) {
                Optional<Chunk> chunk = this.world.getChunk(x + cx, 0, z + cz);
                if (chunk.isPresent()) {
                    entityCount += removeEntities(chunk.get());
                    chunkCount++;
                }
            }
        }
    }
    v.sendMessage(TextColors.GREEN + "String_Node_Str" + TextColors.RED + entityCount + TextColors.GREEN + "String_Node_Str" + TextColors.BLUE + chunkCount + TextColors.GREEN + (chunkCount == 1 ? "String_Node_Str" : "String_Node_Str"));
}

Output:
     int chunkCount = 0;
-    int radius = (int) Math.round(v.getBrushSize() / 16);
-    int radiusSquared = radius * radius;
-    for (int x = -radius; x <= radius; x++) {
-        for (int z = -radius; z <= radius; z++) {
-            if (x * x + z * z < radiusSquared) {
-                Optional<Chunk> chunk = this.world.getChunk(x + cx, 0, z + cz);
-                if (chunk.isPresent()) {
-                    entityCount += removeEntities(chunk.get());
-                    chunkCount++;
+    if (v.getBrushSize() < 16) {
+        Optional<Chunk> chunk = this.world.getChunk(cx, 0, cz);
+        if (chunk.isPresent()) {
+            entityCount += removeEntities(chunk.get());
+            chunkCount++;
+        }
+    } else {
+        int radius = (int) Math.ceil(v.getBrushSize() / 16);
+        int radiusSquared = radius * radius;
+        for (int x = -radius; x <= radius; x++) {
+            for (int z = -radius; z <= radius; z++) {
+                if (x * x + z * z <= radiusSquared) {
+                    Optional<Chunk> chunk = this.world.getChunk(x + cx, 0, z + cz);
+                    if (chunk.isPresent()) {
+                        entityCount += removeEntities(chunk.get());
+                        chunkCount++;
+                    }
                 }