Input:
public PortletRequestDispatcher getRequestDispatcher(String path) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + path);
    }
    if (path == null || !path.startsWith("String_Node_Str")) {
        if (LOG.isInfoEnabled()) {
            LOG.info("String_Node_Str" + "String_Node_Str");
        }
        return null;
    }
    String dispatchingPath = null;
    Map params = null;
    int index = path.indexOf("String_Node_Str");
    if (index > 0) {
        dispatchingPath = path.substring(0, index);
        if (index < path.length() - 1) {
            params = parseQueryParams(path.substring(index + 1));
        }
    } else {
        dispatchingPath = path;
    }
    PortletRequestDispatcher portletRequestDispatcher = null;
    try {
        RequestDispatcher servletRequestDispatcher = servletContext.getRequestDispatcher(dispatchingPath);
        if (servletRequestDispatcher != null) {
            portletRequestDispatcher = new PortletRequestDispatcherImpl(servletRequestDispatcher, params);
        } else {
            if (LOG.isInfoEnabled()) {
                LOG.info("String_Node_Str" + dispatchingPath);
            }
        }
    } catch (Exception ex) {
        if (LOG.isInfoEnabled()) {
            LOG.info("String_Node_Str" + ex.getMessage());
        }
        portletRequestDispatcher = null;
    }
    return portletRequestDispatcher;
}

Output:
     }
-    String dispatchingPath = null;
-    Map params = null;
+    Map appendedParameters = null;
     int index = path.indexOf("String_Node_Str");


Input:
public UserTO create(final HttpServletResponse response, final UserTO userTO) throws PropagationException, UnauthorizedRoleException, WorkflowException, NotFoundException {
    LOG.debug("String_Node_Str", userTO);
    Set<Long> requestRoleIds = new HashSet<Long>(userTO.getMemberships().size());
    for (MembershipTO membership : userTO.getMemberships()) {
        requestRoleIds.add(membership.getRoleId());
    }
    Set<Long> adminRoleIds = EntitlementUtil.getRoleIds(EntitlementUtil.getOwnedEntitlementNames());
    requestRoleIds.removeAll(adminRoleIds);
    if (!requestRoleIds.isEmpty()) {
        throw new UnauthorizedRoleException(requestRoleIds);
    }
    WorkflowResult<Map.Entry<Long, Boolean>> created = wfAdapter.create(userTO);
    List<PropagationTask> tasks = propagationManager.getCreateTaskIds(created.getResult().getKey(), userTO.getPassword(), userTO.getVirtualAttributes(), created.getResult().getValue());
    propagationManager.execute(tasks);
    notificationManager.createTasks(new WorkflowResult<Long>(created.getResult().getKey(), created.getPerformedTasks()));
    final UserTO savedTO = dataBinder.getUserTO(created.getResult().getKey());
    LOG.debug("String_Node_Str", savedTO);
    response.setStatus(HttpServletResponse.SC_CREATED);
    return savedTO;
}

Output:
     WorkflowResult<Map.Entry<Long, Boolean>> created = wfAdapter.create(userTO);
-    List<PropagationTask> tasks = propagationManager.getCreateTaskIds(created.getResult().getKey(), userTO.getPassword(), userTO.getVirtualAttributes(), created.getResult().getValue());
+    List<PropagationTask> tasks = propagationManager.getCreateTaskIds(created, userTO.getPassword(), userTO.getVirtualAttributes());
     propagationManager.execute(tasks);


Input:
private float getBigramProbability(WordSequence wordSequence) {
    String firstWord = wordSequence.getWord(0);
    String secondWord = wordSequence.getWord(1);
    if (loader.getNumberBigrams() <= 0 || firstWord == null) {
        return getUnigramProbability(wordSequence.getNewest());
    }
    if (!hasUnigram(secondWord)) {
        secondWord = "String_Node_Str";
    }
    int firstWordID = getWordID(firstWord);
    int secondWordID = getWordID(secondWord);
    BigramProbability bigram = findBigram(firstWordID, secondWordID);
    if (bigram != null) {
        return bigramProbTable[bigram.getProbabilityID()];
    } else {
        return (unigrams[firstWordID].getLogBackoff() + unigrams[secondWordID].getLogProbability());
    }
}

Output:
     }
-    if (!hasUnigram(secondWord)) {
-        secondWord = "String_Node_Str";
+    if (getUnigram(secondWord) == null) {
+        throw new Error("String_Node_Str" + secondWord);
     }


Input:
public void afterInvocation(IInvokedMethod method, ITestResult testResult) {
    logger.entering(new Object[] { method, testResult });
    if (ListenerManager.executeCurrentMethod(this) == false) {
        logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
        return;
    }
    if (!method.isTestMethod()) {
        return;
    }
    boolean isWebTestClass = method.getTestMethod().getInstance().getClass().getAnnotation(WebTest.class) != null;
    boolean isMobileTestClass = method.getTestMethod().getInstance().getClass().getAnnotation(MobileTest.class) != null;
    if ((isWebTestClass || isMobileTestClass) && !isHighPriority(method)) {
        return;
    }
    AbstractTestSession testSession = Grid.getTestSession();
    testSession.closeSession();
    logger.exiting();
}

Output:
     logger.entering(new Object[] { method, testResult });
-    if (ListenerManager.executeCurrentMethod(this) == false) {
-        logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
-        return;
+    try {
+        if (ListenerManager.executeCurrentMethod(this) == false) {
+            logger.exiting(ListenerManager.THREAD_EXCLUSION_MSG);
+            return;
+        }
+        if (!method.isTestMethod()) {
+            return;
+        }
+        Class<?> cls = method.getTestMethod().getInstance().getClass();
+        boolean isWebTestClass = cls.getAnnotation(WebTest.class) != null;
+        boolean isMobileTestClass = cls.getAnnotation(MobileTest.class) != null;
+        if ((isWebTestClass || isMobileTestClass) && !isHighPriority(method)) {
+            return;
+        }
+        AbstractTestSession testSession = Grid.getTestSession();
+        testSession.closeSession();
+    } catch (Exception e) {
+        logger.log(Level.WARNING, "String_Node_Str" + e.getMessage(), e);
     }


Input:
public static RelaxStatus get(Status status) {
    if (status == Status.Infeasible || status == Status.InfeasibleOrUnbounded || status == Status.Unbounded) {
        return Infeasible;
    } else {
        return Feasible;
    }
}

Output:
 public static RelaxStatus get(Status status) {
-    if (status == Status.Infeasible || status == Status.InfeasibleOrUnbounded || status == Status.Unbounded) {
+    if (status == Status.Infeasible || status == Status.InfeasibleOrUnbounded || status == Status.Unbounded || status == Status.Bounded) {
         return Infeasible;


Input:
private void selectDrawerItem(int position, long feedId) {
    Fragment fragment = new EntryListFragment();
    Bundle args = new Bundle();
    args.putParcelable(EntryListFragment.ARG_ENTRIES_URI, Uris.newFeedEntriesUri(feedId));
    fragment.setArguments(args);
    getFragmentManager().beginTransaction().replace(R.id.content, fragment).commit();
    if (drawerListAdapter.getCursor() != null) {
        drawerListView.setItemChecked(position, true);
    }
    drawerLayout.closeDrawer(drawerListView);
    syncLogFragment.setSyncLogUri(Uris.newFeedSyncLogUri(feedId));
}

Output:
 private void selectDrawerItem(int position, long feedId) {
-    Fragment fragment = new EntryListFragment();
-    Bundle args = new Bundle();
-    args.putParcelable(EntryListFragment.ARG_ENTRIES_URI, Uris.newFeedEntriesUri(feedId));
-    fragment.setArguments(args);
-    getFragmentManager().beginTransaction().replace(R.id.content, fragment).commit();
+    EntryListFragment entryListFragment = new EntryListFragment();
+    Bundle entryListFragmentArgs = new Bundle();
+    entryListFragmentArgs.putParcelable(EntryListFragment.ARG_ENTRIES_URI, Uris.newFeedEntriesUri(feedId));
+    entryListFragment.setArguments(entryListFragmentArgs);
+    syncLogFragment = new SyncLogFragment();
+    Bundle syncLogFragmentArgs = new Bundle();
+    syncLogFragmentArgs.putParcelable(SyncLogFragment.ARG_SYNC_LOG_URI, Uris.newFeedSyncLogUri(feedId));
+    syncLogFragment.setArguments(syncLogFragmentArgs);
+    getFragmentManager().beginTransaction().replace(R.id.content, entryListFragment).replace(R.id.sync_log, syncLogFragment).commit();
     if (drawerListAdapter.getCursor() != null) {


Input:
static AwtPath getAwtPath(Path path) {
    return ((AwtPath) path);
}

Output:
 static AwtPath getAwtPath(Path path) {
-    return ((AwtPath) path);
+    return (AwtPath) path;
 }


Input:
public static void setupVolleyQueue() {
    requestQueue = Volley.newRequestQueue(mContext, VolleyUtils.getHTTPClientStack(mContext));
    imageLoader = new ImageLoader(requestQueue, getBitmapCache());
    VolleyLog.setTag(TAG);
    imageLoader.setBatchedResponseDelay(0);
}

Output:
     imageLoader = new ImageLoader(requestQueue, getBitmapCache());
-    VolleyLog.setTag(TAG);
+    VolleyLog.setTag(AppLog.TAG);
     imageLoader.setBatchedResponseDelay(0);


Input:
private void sizeToScreen() {
    Rectangle rect = this.getBounds();
    if (rect.height < 650) {
        if (smallMode == false) {
            smallMode = true;
            Dimension bbDimension = new Dimension(128, 184);
            bigCard.setMaximumSize(bbDimension);
            bigCard.setMinimumSize(bbDimension);
            bigCard.setPreferredSize(bbDimension);
            pnlGameInfo.revalidate();
            pnlGameInfo.repaint();
            this.handContainer.sizeHand(0.8, smallMode);
            for (PlayAreaPanel p : players.values()) {
                p.sizePlayer(smallMode);
            }
        }
    } else {
        if (smallMode == true) {
            smallMode = false;
            Dimension bbDimension = new Dimension(256, 367);
            bigCard.setMaximumSize(bbDimension);
            bigCard.setMinimumSize(bbDimension);
            bigCard.setPreferredSize(bbDimension);
            pnlGameInfo.revalidate();
            pnlGameInfo.repaint();
            this.handContainer.sizeHand(1, smallMode);
            for (PlayAreaPanel p : players.values()) {
                p.sizePlayer(smallMode);
            }
        }
    }
    int height = pnlBattlefield.getHeight();
    phasesContainer.setPreferredSize(new Dimension(X_PHASE_WIDTH, height));
    DialogManager.getManager().setScreenWidth(rect.width);
    DialogManager.getManager().setScreenHeight(rect.height);
    DialogManager.getManager().setBounds(0, 0, rect.width, rect.height);
}

Output:
     phasesContainer.setPreferredSize(new Dimension(X_PHASE_WIDTH, height));
-    DialogManager.getManager().setScreenWidth(rect.width);
-    DialogManager.getManager().setScreenHeight(rect.height);
-    DialogManager.getManager().setBounds(0, 0, rect.width, rect.height);
+    DialogManager.getManager(gameId).setScreenWidth(rect.width);
+    DialogManager.getManager(gameId).setScreenHeight(rect.height);
+    DialogManager.getManager(gameId).setBounds(0, 0, rect.width, rect.height);
 }


Input:
static public void crop(File file, int x, int y, int width, int height) throws FileOperationException {
    BufferedImage image;
    try {
        image = ImageIO.read(file);
        image = Scalr.crop(image, x, y, width, height);
        ImageIO.write(image, "String_Node_Str", file);
        image.flush();
    } catch (IOException | IllegalArgumentException e) {
        logger.error(e.getMessage(), e);
        throw new FileOperationException("String_Node_Str");
    }
}

Output:
         image = Scalr.crop(image, x, y, width, height);
-        ImageIO.write(image, "String_Node_Str", file);
+        saveToJPG(image, file);
         image.flush();


Input:
public void write(byte[] b, int off, int len) throws IOException {
    int pageIndex = (int) (pos >> PAGE_SHIFT);
    int offset = (int) (pos & PAGE_MASK);
    int endPageOne = Math.min(b.length + offset, PAGE_SIZE);
    byte[] page = getPage(pageIndex);
    int j = 0;
    for (int i = offset; i < endPageOne; i++) {
        page[i] = b[off + (j++)];
    }
    while (b.length > j) {
        pageIndex++;
        page = getPage(pageIndex);
        if (b.length - j > PAGE_SIZE) {
            for (int i = 0; i < PAGE_SIZE; i++) {
                page[i] = b[off + (j++)];
            }
        } else {
            for (int i = 0; j < b.length; i++) {
                page[i] = b[off + (j++)];
            }
        }
    }
    file.seek(pos);
    file.write(b, off, len);
    pos += b.length;
}

Output:
 public void write(byte[] b, int off, int len) throws IOException {
-    int pageIndex = (int) (pos >> PAGE_SHIFT);
-    int offset = (int) (pos & PAGE_MASK);
-    int endPageOne = Math.min(b.length + offset, PAGE_SIZE);
-    byte[] page = getPage(pageIndex);
-    int j = 0;
-    for (int i = offset; i < endPageOne; i++) {
-        page[i] = b[off + (j++)];
-    }
-    while (b.length > j) {
-        pageIndex++;
-        page = getPage(pageIndex);
-        if (b.length - j > PAGE_SIZE) {
-            for (int i = 0; i < PAGE_SIZE; i++) {
-                page[i] = b[off + (j++)];
-            }
-        } else {
-            for (int i = 0; j < b.length; i++) {
-                page[i] = b[off + (j++)];
+    timeStart();
+    try {
+        int pageIndex = (int) (pos >> PAGE_SHIFT);
+        int offset = (int) (pos & PAGE_MASK);
+        int endPageOne = Math.min(len + offset, PAGE_SIZE);
+        byte[] page = getPage(pageIndex);
+        int j = 0;
+        for (int i = offset; i < endPageOne; i++) {
+            page[i] = b[off + (j++)];
+        }
+        while (len > j) {
+            pageIndex++;
+            page = getPage(pageIndex);
+            if (len - j > PAGE_SIZE) {
+                for (int i = 0; i < PAGE_SIZE; i++) {
+                    page[i] = b[off + (j++)];
+                }
+            } else {
+                for (int i = 0; j < len; i++) {
+                    page[i] = b[off + (j++)];
+                }
             }


Input:
public static String decodeComponent(String encodedURLComponent) {
    StringValidator.throwIfEmptyOrNull("String_Node_Str", encodedURLComponent);
    return decodeComponentImpl(encodedURLComponent);
}

Output:
 public static String decodeComponent(String encodedURLComponent) {
-    StringValidator.throwIfEmptyOrNull("String_Node_Str", encodedURLComponent);
+    StringValidator.throwIfNull("String_Node_Str", encodedURLComponent);
     return decodeComponentImpl(encodedURLComponent);


Input:
public String toStringLong(final int minLevel) {
    StringBuilder buf = new StringBuilder(32).append("String_Node_Str").append(getClass().getSimpleName()).append("String_Node_Str").append(showSizes());
    for (int i = levels; i >= minLevel; i--) {
        if (!levelEmpty[i - 1]) {
            buf = buf.append("String_Node_Str").append(i).append("String_Node_Str");
            for (final E e : level[i - 1]) {
                buf = buf.append(e.toStringLong()).append('\n');
            }
        }
    }
    buf.append("String_Node_Str").append(getClass().getSimpleName());
    return buf.toString();
}

Output:
     for (int i = levels; i >= minLevel; i--) {
-        if (!levelEmpty[i - 1]) {
+        if (!levelEmpty(i - 1)) {
             buf = buf.append("String_Node_Str").append(i).append("String_Node_Str");


Input:
public static void showEditHeaderDialog(Fragment fragment, final String uuid, final String title, final int position, final boolean expanded) {
    final HeaderPresenter presenter = instantiatePresenterWith(fragment);
    BaseDialogs.InputDialogCallback callback = new BaseDialogs.InputDialogCallback() {
        public void update(String title) {
            presenter.editHeader(uuid, title, position, expanded);
        }
    };
    showTextInputDialog(fragment, getString(fragment, R.string.edit_category), callback, title);
}

Output:
     };
-    showTextInputDialog(fragment, getString(fragment, R.string.edit_category), callback, title);
+    showTextInputDialog(fragment, getString(fragment, R.string.edit_category), callback, oldTitle);
 }


Input:
public void onResults(final Bundle results) {
    if (recognitionActive) {
        recognitionActive = false;
        final ArrayList<String> recognitionResults = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
        float[] rates = null;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
            rates = results.getFloatArray(SpeechRecognizer.CONFIDENCE_SCORES);
        }
        if (recognitionResults == null || recognitionResults.size() == 0) {
            GoogleRecognitionServiceImpl.this.onResult(new AIResponse());
        } else {
            final AIRequest aiRequest = new AIRequest();
            if (rates != null) {
                aiRequest.setQuery(recognitionResults.toArray(new String[recognitionResults.size()]), rates);
            } else {
                aiRequest.setQuery(recognitionResults.get(0));
            }
            if (contexts != null) {
                aiRequest.setContexts(contexts);
            }
            GoogleRecognitionServiceImpl.this.sendRequest(aiRequest);
            clearRecognizer();
        }
    }
}

Output:
         }
-        if (recognitionResults == null || recognitionResults.size() == 0) {
+        if (recognitionResults == null || recognitionResults.isEmpty()) {
             GoogleRecognitionServiceImpl.this.onResult(new AIResponse());


Input:
public void run(ProgressStatus progressStatus) {
    BranchInfoImpl branchInfoImpl = toBranchInfoImpl(branchInfo);
    if (branchInfoImpl == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    ProjectDescriptor projectDescriptor = ProjectDescriptorsFactory.createAnyRemoteProjectDescriptor(project);
    ProjectDescriptor branchDescriptor = EsiUtils.getDescriptorByBranchID(projectDescriptor, branchInfoImpl.getID());
    List<CommitInfoImpl> branchCommits = toCommitInfoImpls(EsiUtils.getVersions(branchDescriptor));
    long startRevisionCommitId = branchInfoImpl.getStartRevision();
    CommitInfoImpl startRevisionCommitInfo = branchCommits.stream().filter(version -> startRevisionCommitId == version.getID()).findAny().orElse(null);
    if (startRevisionCommitInfo == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    UUID parentBranchUuid = startRevisionCommitInfo.getBranchID();
    EsiUtils.EsiBranchInfo parentBranchInfo = EsiUtils.getBranches(projectDescriptor).stream().filter(branch -> branch.getID().equals(parentBranchUuid)).findAny().orElse(null);
    if (parentBranchInfo == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    String parentBranchId = parentBranchUuid.toString();
    String parentBranchName = parentBranchInfo.getName();
    if (parentBranchInfo.getName().equals("String_Node_Str")) {
        parentBranchId = "String_Node_Str";
        parentBranchName = "String_Node_Str";
    }
    int parentCommitsBehind = 0;
    long latestRevisionCommitId = branchInfoImpl.getLatestRevision();
    CommitInfoImpl latestRevisionCommitInfo = branchCommits.stream().filter(version -> latestRevisionCommitId == version.getID()).findAny().orElse(null);
    if (latestRevisionCommitInfo == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    CommitInfoImpl commit = latestRevisionCommitInfo;
    while (commit != null && commit.getID() != startRevisionCommitId) {
        parentCommitsBehind++;
        long directParent = commit.getDirectParent();
        commit = branchCommits.stream().filter(version -> directParent == version.getID()).findAny().orElse(null);
    }
    parentCommitsBehind--;
    int parentCommitsAhead = 0;
    ProjectDescriptor parentBranchDescriptor = EsiUtils.getDescriptorByBranchID(projectDescriptor, parentBranchUuid);
    List<CommitInfoImpl> parentBranchCommits = toCommitInfoImpls(EsiUtils.getVersions(parentBranchDescriptor));
    BranchInfoImpl parentBranchInfoImpl = toBranchInfoImpl(parentBranchInfo);
    if (parentBranchInfoImpl == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
    }
    long parentLatestRevisionCommitId = parentBranchInfoImpl.getLatestRevision();
    CommitInfoImpl parentLatestRevisionCommitInfo = parentBranchCommits.stream().filter(version -> parentLatestRevisionCommitId == version.getID()).findAny().orElse(null);
    if (parentLatestRevisionCommitInfo == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    commit = parentLatestRevisionCommitInfo;
    while (commit != null && commit.getID() != startRevisionCommitId) {
        parentCommitsAhead++;
        long directParent = commit.getDirectParent();
        commit = parentBranchCommits.stream().filter(version -> directParent == version.getID()).findAny().orElse(null);
    }
    JsonNode parentBranchJsonNode = null;
    URIBuilder requestUri = MMSUtils.getServiceProjectsRefsUri(project);
    if (requestUri == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    requestUri.setPath(requestUri.getPath() + "String_Node_Str" + parentBranchId);
    try {
        HttpRequestBase request = MMSUtils.buildRequest(MMSUtils.HttpRequestType.GET, requestUri);
        File responseFile = MMSUtils.sendMMSRequest(project, request);
        ObjectNode response;
        try (JsonParser jsonParser = JacksonUtils.getJsonFactory().createParser(responseFile)) {
            response = JacksonUtils.parseJsonObject(jsonParser);
        }
        JsonNode refsArray, value;
        if ((refsArray = response.get("String_Node_Str")) != null && refsArray.isArray()) {
            for (JsonNode refJson : refsArray) {
                if (refJson.isObject()) {
                    ObjectNode refObjectNode = (ObjectNode) refJson;
                    refObjectNode.remove(MDKConstants.PARENT_REF_ID_KEY);
                    String entryKey;
                    if ((value = refObjectNode.get(MDKConstants.ID_KEY)) != null && value.isTextual()) {
                        entryKey = refObjectNode.get(MDKConstants.ID_KEY).asText();
                        if (entryKey.equals(parentBranchId)) {
                            parentBranchJsonNode = refObjectNode;
                        }
                    }
                }
            }
        }
    } catch (IOException | URISyntaxException | ServerException e) {
        e.printStackTrace();
        Application.getInstance().getGUILog().log("String_Node_Str" + e.getMessage());
        return;
    }
    if (parentBranchJsonNode == null) {
        Application.getInstance().getGUILog().log("String_Node_Str" + parentBranchName + "String_Node_Str");
        return;
    }
    requestUri = MMSUtils.getServiceProjectsRefsUri(project);
    if (requestUri == null) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    Collection<ObjectNode> refsNodes = new LinkedList<>();
    ObjectNode branchNode = BranchValidator.getRefObjectNode(project, branchInfo, parentBranchId);
    refsNodes.add(branchNode);
    if (parentCommitsBehind > 0 || parentCommitsAhead > 0) {
        Application.getInstance().getGUILog().log("String_Node_Str" + parentBranchName + "String_Node_Str" + (parentCommitsBehind > 0 ? NumberFormat.getInstance().format(parentCommitsBehind) + "String_Node_Str" + (parentCommitsBehind != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" : "String_Node_Str") + (parentCommitsBehind > 0 && parentCommitsAhead > 0 ? "String_Node_Str" : "String_Node_Str") + (parentCommitsAhead > 0 ? NumberFormat.getInstance().format(parentCommitsAhead) + "String_Node_Str" + (parentCommitsAhead != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + branchInfo.getName() + "String_Node_Str" + "String_Node_Str");
    }
    try {
        File sendFile = MMSUtils.createEntityFile(this.getClass(), ContentType.APPLICATION_JSON, refsNodes, MMSUtils.JsonBlobType.REF);
        HttpRequestBase request = MMSUtils.buildRequest(MMSUtils.HttpRequestType.POST, requestUri, sendFile, ContentType.APPLICATION_JSON);
        MMSUtils.sendMMSRequest(project, request);
    } catch (IOException | URISyntaxException | ServerException e) {
        Application.getInstance().getGUILog().log("String_Node_Str" + e.getMessage());
        e.printStackTrace();
        return;
    }
    Application.getInstance().getGUILog().log("String_Node_Str" + branchInfo.getName() + "String_Node_Str");
    if (validateModel) {
        RunnableWithProgress temp = new ManualSyncRunner(Collections.singletonList(project.getPrimaryModel()), project, -1);
        ProgressStatusRunner.runWithProgressStatus(temp, "String_Node_Str", true, 0);
    }
}

Output:
     Collection<ObjectNode> refsNodes = new LinkedList<>();
-    ObjectNode branchNode = BranchValidator.getRefObjectNode(project, branchInfo, parentBranchId);
+    ObjectNode branchNode = BranchValidator.generateRefObjectNode(project, branchInfo, parentBranchId);
     refsNodes.add(branchNode);


Input:
public static void testInfOnSimpleGraph(FactorGraph fg, FgInferencer bp) {
    bp.run();
    VarTensor marg;
    double[] goldMarg;
    assertEquals("String_Node_Str", fg.getVar(0).getName());
    marg = bp.getMarginals(fg.getVar(0));
    goldMarg = new double[] { 0.5, 0.5 };
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-2);
    marg = bp.getLogMarginals(fg.getVar(0));
    goldMarg = DoubleArrays.getLog(goldMarg);
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-2);
    assertEquals("String_Node_Str", fg.getVar(1).getName());
    marg = bp.getMarginals(fg.getVar(1));
    goldMarg = new double[] { 0.375, 0.625 };
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);
    marg = bp.getLogMarginals(fg.getVar(1));
    goldMarg = DoubleArrays.getLog(goldMarg);
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);
    assertEquals("String_Node_Str", fg.getVar(2).getName());
    marg = bp.getMarginals(fg.getVar(2));
    goldMarg = new double[] { 0.4275, 0.5725 };
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);
    marg = bp.getLogMarginals(fg.getVar(2));
    goldMarg = DoubleArrays.getLog(goldMarg);
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);
    assertEquals(new VarSet(fg.getVar(0), fg.getVar(1)), fg.getFactor(1).getVars());
    marg = bp.getMarginals(fg.getFactor(1));
    goldMarg = new double[] { 0.3, 0.075, 0.2, 0.425 };
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);
    marg = bp.getLogMarginals(fg.getFactor(1));
    goldMarg = DoubleArrays.getLog(goldMarg);
    JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);
    double goldPartition = 2.00;
    assertEquals(goldPartition, bp.getPartition(), 1e-2);
    assertEquals(FastMath.log(goldPartition), bp.getLogPartition(), 1e-2);
}

Output:
     marg = bp.getMarginals(fg.getFactor(1));
-    goldMarg = new double[] { 0.3, 0.075, 0.2, 0.425 };
+    goldMarg = new double[] { 0.3, 0.2, 0.075, 0.425 };
     JUnitUtils.assertArrayEquals(goldMarg, marg.getValues(), 1e-3);


Input:
public void setDimension(ParserContext parserContext, float dimension, T view, String key, JsonElement value, ProteusView proteusView, JsonObject layout, int index) {
    view.setTextSize(dimension);
}

Output:
 public void setDimension(ParserContext parserContext, float dimension, T view, String key, JsonElement value, ProteusView proteusView, JsonObject layout, int index) {
-    view.setTextSize(dimension);
+    view.setTextSize(TypedValue.COMPLEX_UNIT_PX, dimension);
 }


Input:
public float getProgress() {
    if (start == end) {
        return 0.0f;
    } else {
        return Math.min(1.0f, ((consumedSplitSize + (pos - start)) * 1f) / (this.wholeSize * 1f));
    }
}

Output:
     } else {
-        return Math.min(1.0f, ((consumedSplitSize + (pos - start)) * 1f) / (this.wholeSize * 1f));
+        return Math.min(1.0f, ((consumedSplitSize + (getFilePosition() - start)) * 1f) / (this.wholeSize * 1f));
     }


Input:
public void addTowerAndOccupyArea(byte playerId, MapCircle influencingArea) {
    IMapArea filteredArea = new FilteredMapArea(influencingArea, new ISerializablePredicate<ShortPoint2D>() {
        private static final long serialVersionUID = -6460916149912865762L;
        public boolean evaluate(ShortPoint2D pos) {
            return 0 <= pos.x && pos.x < width && 0 <= pos.y && pos.y < height;
        }
    });
    occupyArea(playerId, filteredArea, influencingArea.getBorders());
    occupyingTowers.add(new PartitionOccupyingTower(playerId, influencingArea.getCenter(), filteredArea, influencingArea.getBorders(), (int) influencingArea.getRadius()));
}

Output:
     });
-    occupyArea(playerId, filteredArea, influencingArea.getBorders());
-    occupyingTowers.add(new PartitionOccupyingTower(playerId, influencingArea.getCenter(), filteredArea, influencingArea.getBorders(), (int) influencingArea.getRadius()));
+    PartitionOccupyingTower tower = new PartitionOccupyingTower(playerId, influencingArea.getCenter(), filteredArea, influencingArea.getBorders(), (int) influencingArea.getRadius());
+    occupyAreaOfTower(groundArea, tower);
 }


Input:
public static String encodeString(String str) {
    sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
    return new String(encoder.encodeBuffer(str.getBytes())).trim();
}

Output:
     sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
-    return new String(encoder.encodeBuffer(str.getBytes())).trim();
+    return encoder.encodeBuffer(str.getBytes()).trim();
 }


Input:
public double similarity(double dots, double normA, double normB, int numberOfColumns) {
    double euclideanDistance = Math.sqrt(normA - 2 * dots + normB);
    return 1.0 / (1.0 + euclideanDistance);
}

Output:
 public double similarity(double dots, double normA, double normB, int numberOfColumns) {
-    double euclideanDistance = Math.sqrt(normA - 2 * dots + normB);
+    double euclideanDistance = Math.sqrt(Math.max(0.0, normA - 2 * dots + normB));
     return 1.0 / (1.0 + euclideanDistance);


Input:
public void sourceActive(ChannelHandlerContext ctx) {
    if (sourceSites.get(ctx) == null) {
        sourceSites.put(ctx, ctx);
        if (sourcePaused) {
            StreamValve.pipelinePause(ctx.pipeline());
        }
    }
}

Output:
 public void sourceActive(ChannelHandlerContext ctx) {
-    if (sourceSites.get(ctx) == null) {
-        sourceSites.put(ctx, ctx);
-        if (sourcePaused) {
-            StreamValve.pipelinePause(ctx.pipeline());
-        }
-    }
+    upstreamSet.register(ctx);
 }


Input:
private void onRegistrationResult(final ProviderRegistrationResult e) {
    if (e.getErrorCode() == OpenPushConstants.NO_ERROR) {
        mRetryNumber = 0;
        mCurrentProvider = getProviderByName(e.getProviderName());
        saveProvider(mCurrentProvider);
    } else {
        final PushProvider lastProvider = getProviderByName(e.getProviderName());
        if (mOptions.getRetryPolice() != null && mRetryNumber < mOptions.getRetryPolice().tryCount()) {
            sHandler.postDelayed(new RetryRegistrationRunnable(lastProvider), mOptions.getRetryPolice().getDelay(mRetryNumber));
            mRetryNumber++;
        } else {
            PushProvider provider = getNextCandidate(lastProvider);
            if (provider != null) {
                provider.register();
            } else {
                mInitStatus = INIT_ERROR;
            }
        }
    }
}

Output:
         mRetryNumber = 0;
-        mCurrentProvider = getProviderByName(e.getProviderName());
+        mCurrentProvider = provider;
         saveProvider(mCurrentProvider);


Input:
private void runDataSetTest(DataSetCache cache) {
    DataSet dataSet = new DataSet(Nd4j.ones(500, 100), Nd4j.zeros(500, 2));
    DataSetIterator it = new SamplingDataSetIterator(dataSet, 10, 50);
    DataSetIterator cachedIt = new CachingDataSetIterator(it, cache);
    while (cachedIt.hasNext()) {
        cachedIt.next();
    }
    cachedIt.reset();
    it.reset();
    dataSet.setFeatures(Nd4j.zeros(500, 100));
    dataSet.setLabels(Nd4j.ones(500, 2));
    while (it.hasNext()) {
        assertTrue(cachedIt.hasNext());
        DataSet cachedDs = cachedIt.next();
        assertEquals(1000.0, cachedDs.getFeatureMatrix().sumNumber());
        assertEquals(0.0, cachedDs.getLabels().sumNumber());
        DataSet ds = it.next();
        assertEquals(0.0, ds.getFeatureMatrix().sumNumber());
        assertEquals(20.0, ds.getLabels().sumNumber());
    }
}

Output:
     DataSetIterator it = new SamplingDataSetIterator(dataSet, 10, 50);
-    DataSetIterator cachedIt = new CachingDataSetIterator(it, cache);
+    String namespace = "String_Node_Str";
+    DataSetIterator cachedIt = new CachingDataSetIterator(it, cache, namespace);
     while (cachedIt.hasNext()) {


Input:
public void handleCommand(ICommandSender sender, String[] arguments) {
    switch(arguments.length) {
        case 0:
        case 1:
            sender.addChatMessage(new ChatComponentText("String_Node_Str" + StringHelper.PINK + "String_Node_Str" + StringHelper.YELLOW + "String_Node_Str"));
            break;
        case 2:
            EntityPlayerMP playerSender = CommandBase.getCommandSenderAsPlayer(sender);
            try {
                EntityPlayerMP player = CommandBase.getPlayer(sender, arguments[1]);
                if (!player.equals(playerSender)) {
                    player.mountEntity((Entity) null);
                    if (playerSender.dimension == player.dimension) {
                        player.setPositionAndUpdate(playerSender.posX, playerSender.posY, playerSender.posZ);
                    } else {
                        playerSender.mcServer.getConfigurationManager().transferPlayerToDimension(player, playerSender.dimension);
                        player.setPositionAndUpdate(playerSender.posX, playerSender.posY, playerSender.posZ);
                    }
                } else {
                    sender.addChatMessage(new ChatComponentText("String_Node_Str"));
                }
                break;
            } catch (Throwable t) {
                int dimension;
                try {
                    dimension = Integer.parseInt(arguments[1]);
                } catch (Throwable p) {
                    if (t instanceof RuntimeException)
                        throw (RuntimeException) t;
                    throw new RuntimeException(t);
                }
                if (!DimensionManager.isDimensionRegistered(dimension)) {
                    sender.addChatMessage(new ChatComponentText(StringHelper.RED + "String_Node_Str"));
                    break;
                }
                DimensionManager.initDimension(dimension);
                double f = DimensionManager.getProvider(playerSender.dimension).getMovementFactor();
                f /= DimensionManager.getProvider(dimension).getMovementFactor();
                playerSender.mountEntity((Entity) null);
                if (playerSender.dimension != dimension) {
                    playerSender.mcServer.getConfigurationManager().transferPlayerToDimension(playerSender, dimension);
                }
                playerSender.setPositionAndUpdate(playerSender.posX * f, playerSender.posY, playerSender.posZ * f);
            }
            break;
        case 3:
            EntityPlayerMP player = CommandBase.getPlayer(sender, arguments[1]);
            try {
                EntityPlayerMP otherPlayer = CommandBase.getPlayer(sender, arguments[1]);
                if (!player.equals(otherPlayer)) {
                    player.mountEntity((Entity) null);
                    if (otherPlayer.dimension == player.dimension) {
                        player.setPositionAndUpdate(otherPlayer.posX, otherPlayer.posY, otherPlayer.posZ);
                    } else {
                        otherPlayer.mcServer.getConfigurationManager().transferPlayerToDimension(player, otherPlayer.dimension);
                        player.setPositionAndUpdate(otherPlayer.posX, otherPlayer.posY, otherPlayer.posZ);
                    }
                } else {
                    sender.addChatMessage(new ChatComponentText("String_Node_Str" + arguments[1] + "String_Node_Str"));
                }
                break;
            } catch (Throwable t) {
                int dimension;
                try {
                    dimension = Integer.parseInt(arguments[1]);
                } catch (Throwable p) {
                    if (t instanceof RuntimeException)
                        throw (RuntimeException) t;
                    throw new RuntimeException(t);
                }
                if (!DimensionManager.isDimensionRegistered(dimension)) {
                    sender.addChatMessage(new ChatComponentText(StringHelper.RED + "String_Node_Str"));
                    break;
                }
                DimensionManager.initDimension(dimension);
                double f = DimensionManager.getProvider(player.dimension).getMovementFactor();
                f /= DimensionManager.getProvider(dimension).getMovementFactor();
                player.mountEntity((Entity) null);
                if (player.dimension != dimension) {
                    player.mcServer.getConfigurationManager().transferPlayerToDimension(player, dimension);
                }
                player.setPositionAndUpdate(player.posX * f, player.posY, player.posZ * f);
            }
            break;
        case 4:
            playerSender = CommandBase.getCommandSenderAsPlayer(sender);
            playerSender.setPositionAndUpdate(CommandBase.func_110666_a(playerSender, playerSender.posX, arguments[2]), CommandBase.func_110666_a(playerSender, playerSender.posY, arguments[3]), CommandBase.func_110666_a(playerSender, playerSender.posZ, arguments[4]));
            break;
        case 5:
            player = CommandBase.getPlayer(sender, arguments[1]);
            player.mountEntity((Entity) null);
            player.setPositionAndUpdate(CommandBase.func_110666_a(player, player.posX, arguments[2]), CommandBase.func_110666_a(player, player.posY, arguments[3]), CommandBase.func_110666_a(player, player.posZ, arguments[4]));
            break;
        case 6:
        default:
            player = CommandBase.getPlayer(sender, arguments[1]);
            int dimension = CommandBase.parseInt(sender, arguments[5]);
            if (!DimensionManager.isDimensionRegistered(dimension)) {
                sender.addChatMessage(new ChatComponentText(StringHelper.RED + "String_Node_Str"));
                break;
            }
            player.mountEntity((Entity) null);
            if (player.dimension != dimension) {
                player.mcServer.getConfigurationManager().transferPlayerToDimension(player, dimension);
            }
            player.setPositionAndUpdate(CommandBase.func_110666_a(player, player.posX, arguments[2]), CommandBase.func_110666_a(player, player.posY, arguments[3]), CommandBase.func_110666_a(player, player.posZ, arguments[4]));
            break;
    }
}

Output:
                     } else {
-                        playerSender.mcServer.getConfigurationManager().transferPlayerToDimension(player, playerSender.dimension);
+                        EntityHelper.transferPlayerToDimension(player, playerSender.dimension, playerSender.mcServer.getConfigurationManager());
                         player.setPositionAndUpdate(playerSender.posX, playerSender.posY, playerSender.posZ);


Input:
private void setDetailsText(boolean showPoints, String domain, int downs, int ups) {
    Resources r = getResources();
    if (showPoints) {
        longDetailsText.clear();
        longDetailsText.append(r.getQuantityString(R.plurals.votes_up, ups, ups)).append("String_Node_Str");
        longDetailsText.append(r.getQuantityString(R.plurals.votes_down, downs, downs)).append("String_Node_Str");
    }
    if (!TextUtils.isEmpty(domain)) {
        longDetailsText.append(domain);
        shortDetailsText = domain;
    } else {
        shortDetailsText = "String_Node_Str";
    }
}

Output:
     Resources r = getResources();
-    if (showPoints) {
-        longDetailsText.clear();
+    longDetailsText.clear();
+    if (showUpsDowns) {
         longDetailsText.append(r.getQuantityString(R.plurals.votes_up, ups, ups)).append("String_Node_Str");


Input:
public static final BaseRenderer[] instances(Chart cm, RunTimeContext rtc, PlotComputation oComputations) throws ChartException {
    final PluginSettings ps = PluginSettings.instance();
    BaseRenderer[] brna = null;
    final boolean bPaletteByCategory = (cm.getLegend().getItemType().getValue() == LegendItemType.CATEGORIES);
    if (cm instanceof ChartWithAxes) {
        final ChartWithAxes cwa = (ChartWithAxes) cm;
        final Axis[] axa = cwa.getPrimaryBaseAxes();
        Axis axPrimaryBase = axa[0];
        Series se;
        AxesRenderer ar = null;
        List<AxesRenderer> al = new ArrayList<AxesRenderer>();
        List<Series> alRunTimeSeries;
        EList<SeriesDefinition> elBase, elOrthogonal;
        SeriesDefinition sd = null;
        elBase = axPrimaryBase.getSeriesDefinitions();
        if (elBase.isEmpty()) {
            return createEmptyInstance(cm, rtc, oComputations);
        } else {
            final SeriesDefinition sdBase = elBase.get(0);
            alRunTimeSeries = sdBase.getRunTimeSeries();
            if (alRunTimeSeries.isEmpty()) {
                return createEmptyInstance(cm, rtc, oComputations);
            }
            se = alRunTimeSeries.get(0);
            ar = (se.getClass() == SeriesImpl.class) ? new EmptyWithAxes() : (AxesRenderer) ps.getRenderer(se.getClass());
            ar.set(cm, oComputations, se, axPrimaryBase, sdBase);
            ar.set(rtc);
            al.add(ar);
            final Axis[] axaOrthogonal = cwa.getOrthogonalAxes(axPrimaryBase, true);
            for (int i = 0; i < axaOrthogonal.length; i++) {
                elOrthogonal = axaOrthogonal[i].getSeriesDefinitions();
                for (int j = 0; j < elOrthogonal.size(); j++) {
                    sd = elOrthogonal.get(j);
                    alRunTimeSeries = sd.getRunTimeSeries();
                    for (int k = 0; k < alRunTimeSeries.size(); k++) {
                        se = alRunTimeSeries.get(k);
                        ar = (se.getClass() == SeriesImpl.class) ? new EmptyWithAxes() : (AxesRenderer) ps.getRenderer(se.getClass());
                        ar.set(cm, oComputations, se, axaOrthogonal[i], bPaletteByCategory ? sdBase : sd);
                        al.add(ar);
                    }
                }
            }
            Collections.sort(al, zOrderComparator);
            brna = new BaseRenderer[al.size()];
            for (int i = 0; i < brna.length; i++) {
                ar = al.get(i);
                ar.iSeriesIndex = i;
                ar.iSeriesCount = brna.length;
                brna[i] = ar;
            }
        }
    } else if (cm instanceof ChartWithoutAxes) {
        final ChartWithoutAxes cwoa = (ChartWithoutAxes) cm;
        EList<SeriesDefinition> elBase = cwoa.getSeriesDefinitions();
        EList<SeriesDefinition> elOrthogonal;
        SeriesDefinition sd, sdBase;
        List<Series> alRuntimeSeries;
        final Series[] sea = cwoa.getRunTimeSeries();
        Series se;
        final int iSeriesCount = sea.length;
        brna = new BaseRenderer[iSeriesCount];
        int iSI = 0;
        for (int i = 0; i < elBase.size(); i++) {
            sdBase = elBase.get(i);
            alRuntimeSeries = sdBase.getRunTimeSeries();
            if (ChartUtil.isDataEmpty(rtc)) {
                brna = new BaseRenderer[1];
                brna[0] = new EmptyWithoutAxes();
                brna[0].set(cm, oComputations, sdBase.getSeries().get(0), sdBase);
                brna[0].set(rtc);
                brna[0].iSeriesIndex = 0;
                brna[0].iSeriesCount = 1;
                return brna;
            }
            if (alRuntimeSeries.size() != 1) {
                throw new ChartException(ChartEnginePlugin.ID, ChartException.PLUGIN, "String_Node_Str", new Object[] { Integer.valueOf(alRuntimeSeries.size()) }, Messages.getResourceBundle(rtc.getULocale()));
            }
            se = alRuntimeSeries.get(0);
            brna[iSI] = (se.getClass() == SeriesImpl.class) ? new EmptyWithoutAxes() : ps.getRenderer(se.getClass());
            brna[iSI].set(cm, oComputations, se, sdBase);
            brna[iSI].set(rtc);
            brna[iSI].iSeriesIndex = iSI++;
            elOrthogonal = elBase.get(i).getSeriesDefinitions();
            for (int j = 0; j < elOrthogonal.size(); j++) {
                sd = elOrthogonal.get(j);
                alRuntimeSeries = sd.getRunTimeSeries();
                for (int k = 0; k < alRuntimeSeries.size(); k++) {
                    se = alRuntimeSeries.get(k);
                    brna[iSI] = (se.getClass() == SeriesImpl.class) ? new EmptyWithoutAxes() : ps.getRenderer(se.getClass());
                    brna[iSI].set(cm, oComputations, se, bPaletteByCategory ? sdBase : sd);
                    brna[iSI].iSeriesIndex = iSI++;
                }
            }
        }
        for (int k = 0; k < iSI; k++) {
            brna[k].iSeriesCount = iSI;
        }
    }
    return brna;
}

Output:
             }
-            Collections.sort(al, zOrderComparator);
+            if (cm.getDimension() == ChartDimension.TWO_DIMENSIONAL_LITERAL) {
+                Collections.sort(al, zOrderComparator);
+            }
             brna = new BaseRenderer[al.size()];


Input:
public void onLinkTap(View view, String url) {
    if (!TextUtils.isEmpty(url)) {
        LinkUtils.LinkMatch match = LinkUtils.findImgurLinkMatch(url);
        switch(match) {
            case GALLERY:
            case ALBUM:
                Intent intent = ViewActivity.createIntent(getApplicationContext(), url, match == LinkUtils.LinkMatch.ALBUM).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(intent);
                break;
            case IMAGE_URL:
                PopupImageDialogFragment.getInstance(url, url.endsWith("String_Node_Str"), true, false).show(getFragmentManager(), "String_Node_Str");
                break;
            case VIDEO_URL:
                PopupImageDialogFragment.getInstance(url, true, true, true).show(getFragmentManager(), "String_Node_Str");
                break;
            case IMAGE:
                String[] split = url.split("String_Node_Str");
                PopupImageDialogFragment.getInstance(split[split.length - 1], false, false, false).show(getFragmentManager(), "String_Node_Str");
                break;
            case NONE:
            default:
                Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
                if (browserIntent.resolveActivity(getPackageManager()) != null) {
                    startActivity(browserIntent);
                } else {
                    SnackBar.show(ViewActivity.this, R.string.cant_launch_intent);
                }
                break;
        }
    } else {
        onListItemClick(mCommentList.getPositionForView(view) - mCommentList.getHeaderViewsCount());
    }
}

Output:
 public void onLinkTap(View view, String url) {
-    if (!TextUtils.isEmpty(url)) {
+    if (!TextUtils.isEmpty(url) && !isFinishing()) {
         LinkUtils.LinkMatch match = LinkUtils.findImgurLinkMatch(url);


Input:
public static void switchLevel(final Level level, int pos) {
    if (pos < 0 || pos >= level.length()) {
        pos = level.exit;
    }
    PathFinder.setMapSize(level.width(), level.height());
    Dungeon.level = level;
    DriedRose.restoreGhostHero(level, pos + PathFinder.NEIGHBOURS8[Random.Int(8)]);
    Actor.init();
    visible = new boolean[level.length()];
    Actor respawner = level.respawner();
    if (respawner != null) {
        Actor.add(level.respawner());
    }
    hero.pos = pos;
    Light light = hero.buff(Light.class);
    hero.viewDistance = light == null ? level.viewDistance : Math.max(Light.DISTANCE, level.viewDistance);
    hero.curAction = hero.lastAction = null;
    observe();
    try {
        saveAll();
    } catch (IOException e) {
        ShatteredPixelDungeon.reportException(e);
    }
}

Output:
     Dungeon.level = level;
-    DriedRose.restoreGhostHero(level, pos + PathFinder.NEIGHBOURS8[Random.Int(8)]);
+    DriedRose.restoreGhostHero(level, pos);
     Actor.init();


Input:
public javax.ws.rs.core.Response getBitstreamData(Integer bitstreamId, String user_ip, String user_agent, String xforwarderfor, HttpHeaders headers, HttpServletRequest request) throws WebApplicationException {
    log.info("String_Node_Str" + bitstreamId + "String_Node_Str");
    org.dspace.core.Context context = null;
    InputStream inputStream = null;
    String type = null;
    try {
        context = createContext(getUser(headers));
        org.dspace.content.Bitstream dspaceBitstream = findBitstream(context, bitstreamId, org.dspace.core.Constants.READ);
        writeStats(dspaceBitstream, UsageEvent.Action.VIEW, user_ip, user_agent, xforwarderfor, headers, request);
        log.trace("String_Node_Str" + bitstreamId + "String_Node_Str");
        inputStream = dspaceBitstream.retrieve();
        type = dspaceBitstream.getFormat().getMIMEType();
        context.complete();
    } catch (IOException e) {
        processException("String_Node_Str" + bitstreamId + "String_Node_Str" + e, context);
    } catch (SQLException e) {
        processException("String_Node_Str" + bitstreamId + "String_Node_Str" + e, context);
    } catch (AuthorizeException e) {
        processException("String_Node_Str" + bitstreamId + "String_Node_Str" + e, context);
    } catch (ContextException e) {
        processException("String_Node_Str" + bitstreamId + "String_Node_Str" + e.getMessage(), context);
    } finally {
        processFinally(context);
    }
    return Response.ok(inputStream).type(type).build();
}

Output:
         org.dspace.content.Bitstream dspaceBitstream = findBitstream(context, bitstreamId, org.dspace.core.Constants.READ);
-        writeStats(dspaceBitstream, UsageEvent.Action.VIEW, user_ip, user_agent, xforwarderfor, headers, request);
+        writeStats(dspaceBitstream, UsageEvent.Action.VIEW, user_ip, user_agent, xforwarderfor, headers, request, context);
         log.trace("String_Node_Str" + bitstreamId + "String_Node_Str");


Input:
protected Object decode(Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
    ChannelBuffer buf = (ChannelBuffer) msg;
    if (buf.readUnsignedByte() != 0xF8) {
        return null;
    }
    buf.readUnsignedByte();
    buf.readUnsignedByte();
    Position position = new Position();
    position.setProtocol(getProtocolName());
    String imei = ChannelBuffers.hexDump(buf.readBytes(8)).substring(1);
    DeviceSession deviceSession = getDeviceSession(channel, remoteAddress, imei);
    if (deviceSession == null) {
        return null;
    }
    position.setDeviceId(deviceSession.getDeviceId());
    long seconds = buf.readUnsignedInt() & 0x7fffffffL;
    seconds += 946684800L;
    seconds -= timeZone;
    Date time = new Date(seconds * 1000);
    boolean hasLocation = false;
    while (buf.readableBytes() > 3) {
        short type = buf.readUnsignedByte();
        short length = buf.readUnsignedByte();
        switch(type) {
            case DATA_GPS:
                hasLocation = true;
                position.setValid(true);
                position.setLatitude(buf.readInt() / 1000000.0);
                position.setLongitude(buf.readInt() / 1000000.0);
                position.setSpeed(UnitsConverter.knotsFromKph(buf.readUnsignedShort()));
                position.setCourse(buf.readUnsignedShort());
                position.set(Position.KEY_HDOP, buf.readUnsignedShort());
                break;
            case DATA_LBS:
                position.set(Position.KEY_MCC, buf.readUnsignedShort());
                position.set(Position.KEY_MNC, buf.readUnsignedShort());
                position.set(Position.KEY_LAC, buf.readUnsignedShort());
                if (length == 11) {
                    position.set(Position.KEY_CID, buf.readUnsignedInt());
                } else {
                    position.set(Position.KEY_CID, buf.readUnsignedShort());
                }
                position.set(Position.KEY_GSM, -buf.readUnsignedByte());
                if (length > 9 && length != 11) {
                    buf.skipBytes(length - 9);
                }
                break;
            case DATA_STATUS:
                int status = buf.readUnsignedShort();
                position.set(Position.KEY_IGNITION, BitUtil.check(status, 9));
                position.set(Position.KEY_STATUS, status);
                position.set(Position.KEY_ALARM, decodeAlarm(buf.readUnsignedShort()));
                break;
            case DATA_ODOMETER:
                position.set(Position.KEY_ODOMETER, buf.readUnsignedInt());
                break;
            case DATA_ADC:
                for (int i = 0; i < length / 2; i++) {
                    int value = buf.readUnsignedShort();
                    position.set(Position.PREFIX_ADC + BitUtil.from(value, 12), BitUtil.to(value, 12));
                }
                break;
            case DATA_GEOFENCE:
                position.set("String_Node_Str", buf.readUnsignedInt());
                position.set("String_Node_Str", buf.readUnsignedInt());
                break;
            case DATA_OBD2:
                decodeObd(position, buf, length);
                break;
            case DATA_FUEL:
                position.set("String_Node_Str", buf.readUnsignedInt() / 10000.0);
                break;
            case DATA_OBD2_ALARM:
                decodeObd(position, buf, length);
                break;
            case DATA_HARSH_DRIVER:
                decodeDriverBehavior(position, buf);
                break;
            case DATA_CANBUS:
                position.set("String_Node_Str", ChannelBuffers.hexDump(buf.readBytes(length)));
                break;
            case DATA_J1708:
                decodeJ1708(position, buf, length);
                break;
            case DATA_VIN:
                position.set(Position.KEY_VIN, buf.readBytes(length).toString(StandardCharsets.US_ASCII));
                break;
            case DATA_RFID:
                position.set(Position.KEY_RFID, buf.readBytes(length - 1).toString(StandardCharsets.US_ASCII));
                position.set("String_Node_Str", buf.readUnsignedByte() != 0);
                break;
            case DATA_EVENT:
                position.set(Position.KEY_EVENT, buf.readUnsignedByte());
                if (length > 1) {
                    position.set("String_Node_Str", buf.readUnsignedInt());
                }
                break;
            default:
                buf.skipBytes(length);
                break;
        }
    }
    if (!hasLocation) {
        getLastLocation(position, time);
    } else {
        position.setTime(time);
    }
    return position;
}

Output:
     while (buf.readableBytes() > 3) {
-        short type = buf.readUnsignedByte();
-        short length = buf.readUnsignedByte();
+        int type = buf.readUnsignedByte();
+        int length = type == DATA_CANBUS ? buf.readUnsignedShort() : buf.readUnsignedByte();
         switch(type) {


Input:
private boolean createNoneODASelectedDataSource() {
    DataSourceHandle dsHandle = null;
    if (helper.SCRIPT_DATA_SOURCE_DISPLAY_NAME.equals(prevSelectedDataSourceType.toString())) {
        String driverName = DataUIConstants.DATA_SOURCE_SCRIPT;
        Class classType = ScriptDataSourceHandle.class;
        dsHandle = helper.createDataSource(classType, dataSourceName.getText(), driverName);
    } else {
        dsHandle = helper.createNoneOdaDataSourceHandle(dataSourceName.getText(), prevSelectedDataSourceType);
    }
    if (dsHandle == null)
        return false;
    try {
        slotHandle.add(dsHandle);
    } catch (ContentException e) {
        ExceptionHandler.handle(e);
    } catch (NameException e) {
        ExceptionHandler.handle(e);
    }
    if (dsHandle instanceof ScriptDataSourceHandle) {
        Utility.setScriptActivityEditor();
    }
    createSelectedDataSourceTearDown();
    return true;
}

Output:
         Class classType = ScriptDataSourceHandle.class;
-        dsHandle = helper.createDataSource(classType, dataSourceName.getText(), driverName);
+        dsHandle = helper.createDataSource(classType, dsName, driverName);
     } else {


Input:
SearchRow remove(SearchRow row) throws SQLException {
    int at = find(row, false, false, true);
    SearchRow delete = getRow(at);
    if (index.compareRows(row, delete) != 0 || delete.getKey() != row.getKey()) {
        throw Message.getSQLException(ErrorCode.ROW_NOT_FOUND_WHEN_DELETING_1, index.getSQL() + "String_Node_Str" + row);
    }
    if (entryCount == 1) {
        return row;
    }
    removeRow(at);
    index.getPageStore().updateRecord(this, true, data);
    if (at == entryCount) {
        return getRow(at - 1);
    }
    return null;
}

Output:
     removeRow(at);
-    index.getPageStore().updateRecord(this, true, data);
+    index.getPageStore().updateRecord(this);
     if (at == entryCount) {


Input:
protected void initialize() {
    File file = MDMUtil.getTempTemplateXSDFile();
    xsdFilePath = file.getParentFile().getAbsolutePath();
    if (!file.exists()) {
        try {
            super.initialize();
        } catch (Exception e) {
            isTemplateExist = false;
        }
    } else {
        xsdFilePath = file.getAbsolutePath();
    }
    isTemplateExist = true;
    this.treePopulator = new TreePopulator(availableXmlTree);
    checkFieldsValue();
    if (concept == null) {
        IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
        concept = ConnectionFactory.eINSTANCE.createConcept();
        getConnection().getSchemas().add(concept);
    }
    loopModel.setConcept(concept);
    if (concept.getLoopLimit() == null) {
        concept.setLoopLimit(-1);
        XmlArray.setLimitToDefault();
        concept.setLoopLimit(XmlArray.getRowLimit());
    }
    fieldsModel.setConcept(concept.getConceptTargets());
    fieldsTableEditorView.getTableViewerCreator().layout();
    if (concept.getXPathPrefix() == null || "String_Node_Str".equals(concept.getXPathPrefix())) {
        xPathPrefixCombo.select(0);
    } else {
        final XPathPrefix xPathPrefix = getXPathPrefix(concept.getXPathPrefix());
        xPathPrefixCombo.setText(xPathPrefix.getDisplayName());
    }
    if (isContextMode()) {
        adaptFormToEditable();
    }
}

Output:
     if (concept.getXPathPrefix() == null || "String_Node_Str".equals(concept.getXPathPrefix())) {
-        xPathPrefixCombo.select(0);
+        prefixCombo.select(1);
+        concept.setXPathPrefix(XPathPrefix.NONE_ITEM.getPrefix());
     } else {


Input:
private void featureChoose(String msg, Player playerMain) {
    MsgDecisionFeature decisionFeature = GodHelper.getDecisionFeature(msg);
    int decision = playerMain.stratDecision;
    if (decision == GambleChecker.MOVE)
        playerMain.moveDirection = decisionFeature.moveDirection();
    else if (decision == GambleChecker.FIRE)
        playerMain.fireTarget = decisionFeature.fireTarget();
}

Output:
     int decision = playerMain.stratDecision;
-    if (decision == GambleChecker.MOVE)
+    if (decision == GambleChecker.MOVE) {
         playerMain.moveDirection = decisionFeature.moveDirection();


Input:
public long get_Type_for_Tx_in_A(AT_Machine_State state) {
    long txid = AT_API_Helper.getLong(state.get_A1());
    Transaction tx = Nxt.getBlockchain().getTransaction(txid);
    if (tx != null) {
        if (tx.getType().getType() == 1) {
            return 1;
        } else {
            return 0;
        }
    }
    return -1;
}

Output:
     if (tx != null) {
-        if (tx.getType().getType() == 1) {
+        if (tx.getMessage() != null) {
             return 1;


Input:
public Object executeTransform(final Object input) {
    if (graph == null) {
        graph = pipeline.getGraphDatabase();
        final OClass cls = graph.getEdgeType(edgeClass);
        if (cls == null)
            graph.createEdgeType(edgeClass);
    }
    final OrientVertex vertex;
    if (input instanceof OIdentifiable)
        vertex = graph.getVertex(input);
    else if (input instanceof OrientVertex)
        vertex = (OrientVertex) input;
    else
        throw new OTransformException("String_Node_Str" + input + "String_Node_Str");
    Object joinValue = vertex.getProperty(joinFieldName);
    if (joinValue != null) {
        Object result = null;
        if (sqlQuery == null && index == null) {
            if (lookup.toUpperCase().startsWith("String_Node_Str"))
                sqlQuery = new OSQLSynchQuery<OrientVertex>(lookup);
            else
                index = pipeline.getDocumentDatabase().getMetadata().getIndexManager().getIndex(lookup);
        }
        if (sqlQuery != null)
            result = graph.command(sqlQuery).execute(joinValue);
        else {
            final OType idxFieldType = index.getDefinition().getTypes()[0];
            joinValue = idxFieldType.convert(joinValue, idxFieldType.getDefaultJavaType());
            result = index.get(joinValue);
        }
        if (result != null) {
            if (result instanceof Collection<?>) {
                if (!((Collection) result).isEmpty())
                    result = ((Collection) result).iterator().next();
                else
                    result = null;
            }
            if (result != null) {
                final OrientVertex targetVertex = graph.getVertex(result);
                vertex.addEdge(edgeClass, targetVertex);
            }
        }
        if (result == null) {
            switch(unresolvedLinkAction) {
                case CREATE:
                    if (lookup != null) {
                        final String[] lookupParts = lookup.split("String_Node_Str");
                        final OrientVertex linkedV = graph.addTemporaryVertex(lookupParts[0]);
                        linkedV.setProperty(lookupParts[1], joinValue);
                        linkedV.save();
                        result = linkedV;
                    } else
                        throw new OConfigurationException("String_Node_Str");
                    break;
                case ERROR:
                    processor.getStats().incrementErrors();
                    log("String_Node_Str", getName(), joinValue);
                    break;
                case WARNING:
                    processor.getStats().incrementWarnings();
                    log("String_Node_Str", getName(), joinValue);
                    break;
                case SKIP:
                    return null;
                case HALT:
                    throw new OETLProcessHaltedException("String_Node_Str" + joinValue + "String_Node_Str");
            }
        }
    }
    return input;
}

Output:
     Object joinValue = vertex.getProperty(joinFieldName);
-    if (joinValue != null) {
-        Object result = null;
-        if (sqlQuery == null && index == null) {
-            if (lookup.toUpperCase().startsWith("String_Node_Str"))
-                sqlQuery = new OSQLSynchQuery<OrientVertex>(lookup);
-            else
-                index = pipeline.getDocumentDatabase().getMetadata().getIndexManager().getIndex(lookup);
-        }
-        if (sqlQuery != null)
-            result = graph.command(sqlQuery).execute(joinValue);
-        else {
-            final OType idxFieldType = index.getDefinition().getTypes()[0];
-            joinValue = idxFieldType.convert(joinValue, idxFieldType.getDefaultJavaType());
-            result = index.get(joinValue);
+    Object result = lookup(joinValue);
+    if (result == null) {
+        switch(unresolvedLinkAction) {
+            case CREATE:
+                if (lookup != null) {
+                    final String[] lookupParts = lookup.split("String_Node_Str");
+                    final OrientVertex linkedV = graph.addTemporaryVertex(lookupParts[0]);
+                    linkedV.setProperty(lookupParts[1], joinValue);
+                    linkedV.save();
+                    result = linkedV;
+                } else
+                    throw new OConfigurationException("String_Node_Str");
+                break;
+            case ERROR:
+                processor.getStats().incrementErrors();
+                log("String_Node_Str", getName(), joinValue);
+                break;
+            case WARNING:
+                processor.getStats().incrementWarnings();
+                log("String_Node_Str", getName(), joinValue);
+                break;
+            case SKIP:
+                return null;
+            case HALT:
+                throw new OETLProcessHaltedException("String_Node_Str" + joinValue + "String_Node_Str");
         }


Input:
public void rebuildIndex(String key, Class<? extends Element> elementClass) {
    ElementTableWrapper wrapper = globals.getElementWrapper(elementClass);
    if (wrapper instanceof VertexTableWrapper) {
        for (Vertex v : ((VertexTableWrapper) wrapper).getVertices()) {
            rebuild(wrapper, v, key);
        }
    } else if (wrapper instanceof EdgeTableWrapper) {
        for (Edge e : ((EdgeTableWrapper) wrapper).getEdges()) {
            rebuild(wrapper, e, key);
        }
    } else {
        throw new AccumuloGraphException("String_Node_Str" + wrapper.getClass());
    }
    globals.checkedFlush();
}

Output:
     if (wrapper instanceof VertexTableWrapper) {
-        for (Vertex v : ((VertexTableWrapper) wrapper).getVertices()) {
+        CloseableIterable<Vertex> iter = ((VertexTableWrapper) wrapper).getVertices();
+        for (Vertex v : iter) {
             rebuild(wrapper, v, key);


Input:
public void startMonitoringBeaconsInRegion(Region region) throws RemoteException {
    if (android.os.Build.VERSION.SDK_INT < 18) {
        LogManager.w(TAG, "String_Node_Str");
        return;
    }
    if (serviceMessenger == null) {
        throw new RemoteException("String_Node_Str");
    }
    LogManager.d(TAG, "String_Node_Str" + region + "String_Node_Str" + region.getUniqueId());
    Message msg = Message.obtain(null, BeaconService.MSG_START_MONITORING, 0, 0);
    StartRMData obj = new StartRMData(region, callbackPackageName(), this.getScanPeriod(), this.getBetweenScanPeriod(), this.mBackgroundMode);
    msg.obj = obj;
    serviceMessenger.send(msg);
    synchronized (monitoredRegions) {
        this.requestStateForRegion(region);
        monitoredRegions.add(region);
    }
}

Output:
     serviceMessenger.send(msg);
-    synchronized (monitoredRegions) {
-        this.requestStateForRegion(region);
-        monitoredRegions.add(region);
-    }
+    this.requestStateForRegion(region);
 }


Input:
public final void setPaint(short paintType, String uri, String rgbColor, String iccColor) throws JavaScriptException {
    if (((paintType == SVG_PAINTTYPE_RGBCOLOR && uri == null) || (paintType == SVG_PAINTTYPE_URI_RGBCOLOR && uri != null)) && iccColor == null) {
        setRGBColor(rgbColor);
    } else if ((paintType == SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR && uri == null) || (paintType == SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR && uri != null)) {
        setRGBColorICCColor(rgbColor, iccColor);
    } else if ((paintType == SVG_PAINTTYPE_NONE && uri == null) || (paintType == SVG_PAINTTYPE_URI_NONE && uri != null)) {
        setColor(SVG_COLORTYPE_UNKNOWN, rgbColor, iccColor);
    } else if ((paintType == SVG_PAINTTYPE_CURRENTCOLOR && uri == null) || (paintType == SVG_PAINTTYPE_URI_CURRENTCOLOR && uri != null)) {
        setColor(SVG_COLORTYPE_CURRENTCOLOR, rgbColor, iccColor);
    } else if (paintType == SVG_PAINTTYPE_URI) {
        this.rgbColor = null;
        this.iccColor = null;
    } else {
        throw new JavaScriptException("String_Node_Str");
    }
    this.paintType = paintType;
    this.uri = uri;
    if (cssText != null && uri != null) {
        cssText = uri + "String_Node_Str" + cssText;
    }
}

Output:
     this.uri = uri;
-    if (cssText != null && uri != null) {
-        cssText = uri + "String_Node_Str" + cssText;
+    if (paintType != SVG_PAINTTYPE_URI && cssText != null && uri != null) {
+        cssText = "String_Node_Str" + uri + "String_Node_Str" + cssText;
     }


Input:
public static Map getAppContext(HttpServletRequest request) {
    HashMap context = new HashMap();
    Boolean isDesigner = Boolean.valueOf(ParameterAccessor.isDesigner(request));
    context.put("String_Node_Str", isDesigner);
    context.put(EngineConstants.APPCONTEXT_BIRT_VIEWER_HTTPSERVET_REQUEST, request);
    context.put(EngineConstants.APPCONTEXT_CHART_RESOLUTION, ParameterAccessor.getDpi(request));
    int maxCubeRowLevels = ParameterAccessor.getMaxCubeRowLevels(request);
    if (maxCubeRowLevels >= 0)
        context.put(DataEngine.CUBECUSROR_FETCH_LIMIT_ON_ROW_EDGE, new Integer(maxCubeRowLevels));
    int maxCubeColumnLevels = ParameterAccessor.getMaxCubeColumnLevels(request);
    if (maxCubeColumnLevels >= 0)
        context.put(DataEngine.CUBECURSOR_FETCH_LIMIT_ON_COLUMN_EDGE, new Integer(maxCubeColumnLevels));
    int cubeMemorySize = ParameterAccessor.getCubeMemorySize(request);
    if (cubeMemorySize >= 0)
        context.put(DataEngine.IN_MEMORY_CUBE_SIZE, new Integer(cubeMemorySize));
    context.put(IBirtConstants.APPCONTEXT_BIRT_RESOURCE_PATH, ParameterAccessor.getResourceFolder(request));
    ParameterAccessor.pushAppContext(context, request);
    if (isDesigner) {
        String appContextName = ParameterAccessor.getAppContextName(request);
        getAppContextFromExtension(appContextName, context);
    }
    return context;
}

Output:
     ParameterAccessor.pushAppContext(context, request);
-    if (isDesigner) {
+    if (isDesigner.booleanValue()) {
         String appContextName = ParameterAccessor.getAppContextName(request);


Input:
protected Map getProperties() {
    InputStream inputStream = ClassLoader.getSystemResourceAsStream(BINDINGS);
    HashMap<String, Source> metadataSourceMap = new HashMap<String, Source>();
    metadataSourceMap.put("String_Node_Str", new StreamSource(inputStream));
    Map<String, Map<String, Source>> properties = new HashMap<String, Map<String, Source>>();
    properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, metadataSourceMap);
    return properties;
}

Output:
     Map<String, Map<String, Source>> properties = new HashMap<String, Map<String, Source>>();
-    properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, metadataSourceMap);
+    properties.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, new HashMap<String, Source>());
+    properties.put(JAXBContextProperties.OXM_METADATA_SOURCE, metadataSourceMap);
     return properties;


Input:
protected void onConfigure() {
    super.onConfigure();
    ITab tab = AccordionPanel.this.getModelObject().get(index);
    setVisible(tab.isVisible());
}

Output:
     ITab tab = AccordionPanel.this.getModelObject().get(index);
-    setVisible(tab.isVisible());
+    this.setVisible(tab.isVisible());
 }


Input:
public static void main(String[] argv) throws Exception {
    System.setProperty("String_Node_Str", "String_Node_Str");
    CommandLineParser parser = new PosixParser();
    int status = 0;
    Options options = new Options();
    options.addOption("String_Node_Str", "String_Node_Str", false, "String_Node_Str");
    options.addOption("String_Node_Str", "String_Node_Str", false, "String_Node_Str");
    options.addOption("String_Node_Str", "String_Node_Str", false, "String_Node_Str");
    options.addOption("String_Node_Str", "String_Node_Str", true, "String_Node_Str");
    options.addOption("String_Node_Str", "String_Node_Str", true, "String_Node_Str");
    options.addOption("String_Node_Str", "String_Node_Str", false, "String_Node_Str");
    OptionBuilder.withLongOpt("String_Node_Str");
    OptionBuilder.withValueSeparator(',');
    OptionBuilder.withDescription("String_Node_Str" + "String_Node_Str" + MEDIA_FILTER_PLUGINS_KEY + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    Option pluginOption = OptionBuilder.create('p');
    pluginOption.setArgs(Option.UNLIMITED_VALUES);
    options.addOption(pluginOption);
    CommandLine line = null;
    try {
        line = parser.parse(options, argv);
    } catch (MissingArgumentException e) {
        System.out.println("String_Node_Str" + e.getMessage());
        HelpFormatter myhelp = new HelpFormatter();
        myhelp.printHelp("String_Node_Str", options);
        System.exit(1);
    }
    if (line.hasOption('h')) {
        HelpFormatter myhelp = new HelpFormatter();
        myhelp.printHelp("String_Node_Str", options);
        System.exit(0);
    }
    if (line.hasOption('v')) {
        isVerbose = true;
    }
    if (line.hasOption('n')) {
        updateIndex = false;
    }
    if (line.hasOption('f')) {
        isForce = true;
    }
    if (line.hasOption('i')) {
        identifier = line.getOptionValue('i');
    }
    if (line.hasOption('m')) {
        max2Process = Integer.parseInt(line.getOptionValue('m'));
        if (max2Process <= 1) {
            System.out.println("String_Node_Str" + line.getOptionValue('m') + "String_Node_Str");
            max2Process = Integer.MAX_VALUE;
        }
    }
    String[] filterNames = null;
    if (line.hasOption('p')) {
        filterNames = line.getOptionValues('p');
        if (filterNames == null || filterNames.length == 0) {
            System.err.println("String_Node_Str" + "String_Node_Str");
            HelpFormatter myhelp = new HelpFormatter();
            myhelp.printHelp("String_Node_Str", options);
            System.exit(1);
        }
    } else {
        String enabledPlugins = ConfigurationManager.getProperty(MEDIA_FILTER_PLUGINS_KEY);
        filterNames = enabledPlugins.split("String_Node_Str");
    }
    List filterList = new ArrayList();
    for (int i = 0; i < filterNames.length; i++) {
        FormatFilter filter = (FormatFilter) PluginManager.getNamedPlugin(FormatFilter.class, filterNames[i]);
        if (filter == null) {
            System.err.println("String_Node_Str" + filterNames[i] + "String_Node_Str");
            System.exit(1);
        } else {
            filterList.add(filter);
            String filterClassName = filter.getClass().getName();
            String pluginName = null;
            if (SelfNamedPlugin.class.isAssignableFrom(filter.getClass())) {
                pluginName = ((SelfNamedPlugin) filter).getPluginInstanceName();
            }
            String formats = ConfigurationManager.getProperty(FILTER_PREFIX + "String_Node_Str" + filterClassName + (pluginName != null ? "String_Node_Str" + pluginName : "String_Node_Str") + "String_Node_Str" + INPUT_FORMATS_SUFFIX);
            if (formats != null) {
                filterFormats.put(filterClassName + (pluginName != null ? FILTER_PLUGIN_SEPARATOR + pluginName : "String_Node_Str"), Arrays.asList(formats.split("String_Node_Str")));
            }
        }
    }
    if (isVerbose) {
        System.out.println("String_Node_Str");
        java.util.Iterator i = filterFormats.keySet().iterator();
        while (i.hasNext()) {
            String filterName = (String) i.next();
            System.out.println("String_Node_Str" + filterName);
            String pluginName = null;
            if (filterName.contains(FILTER_PLUGIN_SEPARATOR)) {
                String[] fields = filterName.split(FILTER_PLUGIN_SEPARATOR);
                filterName = fields[0];
                pluginName = fields[1];
            }
            System.out.println(filterName + (pluginName != null ? "String_Node_Str" + pluginName + "String_Node_Str" : "String_Node_Str"));
        }
    }
    filterClasses = (MediaFilter[]) filterList.toArray(new MediaFilter[filterList.size()]);
    Context c = null;
    try {
        c = new Context();
        c.setIgnoreAuthorization(true);
        if (identifier == null) {
            applyFiltersAllItems(c);
        } else {
            DSpaceObject dso = HandleManager.resolveToObject(c, identifier);
            if (dso == null) {
                throw new IllegalArgumentException("String_Node_Str" + identifier + "String_Node_Str");
            }
            switch(dso.getType()) {
                case Constants.COMMUNITY:
                    applyFiltersCommunity(c, (Community) dso);
                    break;
                case Constants.COLLECTION:
                    applyFiltersCollection(c, (Collection) dso);
                    break;
                case Constants.ITEM:
                    applyFiltersItem(c, (Item) dso);
                    break;
            }
        }
        if (updateIndex) {
            System.out.println("String_Node_Str");
            DSIndexer.updateIndex(c);
        }
        c.complete();
        c = null;
    } catch (Exception e) {
        status = 1;
    } finally {
        if (c != null) {
            c.abort();
        }
    }
    System.exit(status);
}

Output:
     }
-    filterClasses = (MediaFilter[]) filterList.toArray(new MediaFilter[filterList.size()]);
+    filterClasses = (FormatFilter[]) filterList.toArray(new FormatFilter[filterList.size()]);
     Context c = null;


Input:
public void writeRecord(PactRecord record) throws IOException {
    int numFields = record.getNumFields();
    for (int i = 0; i < numFields; i++) {
        buffer.append(record.getField(0, PactString.class).getValue());
        char delim = (i == numFields - 1) ? '\n' : '|';
        buffer.append(delim);
    }
    byte[] bytes = this.buffer.toString().getBytes();
    this.stream.write(bytes);
}

Output:
 public void writeRecord(PactRecord record) throws IOException {
-    int numFields = record.getNumFields();
-    for (int i = 0; i < numFields; i++) {
-        buffer.append(record.getField(0, PactString.class).getValue());
-        char delim = (i == numFields - 1) ? '\n' : '|';
-        buffer.append(delim);
-    }
+    buffer.setLength(0);
+    buffer.append(record.getField(1, PactInteger.class).toString());
+    buffer.append('|');
+    buffer.append(record.getField(0, PactString.class).toString());
+    buffer.append('|');
+    buffer.append(record.getField(2, PactInteger.class).toString());
+    buffer.append('|');
+    buffer.append('\n');
     byte[] bytes = this.buffer.toString().getBytes();


Input:
public static void addRecipes() {
    ItemStack thermalMonitor = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_THERMAL_MONITOR);
    Recipes.advRecipes.addRecipe(thermalMonitor, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'L', "String_Node_Str", 'R', "String_Node_Str", 'C', "String_Node_Str" });
    ItemStack lampWhite = new ItemStack(IC2NuclearControl.blockNuclearControlLight, 1, LightDamages.DAMAGE_WHITE_OFF);
    Recipes.advRecipes.addRecipe(lampWhite, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'G', "String_Node_Str", 'W', "String_Node_Str", 'L', Blocks.redstone_lamp });
    ItemStack lampOrange = new ItemStack(IC2NuclearControl.blockNuclearControlLight, 1, LightDamages.DAMAGE_ORANGE_OFF);
    Recipes.advRecipes.addRecipe(lampOrange, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'G', "String_Node_Str", 'W', "String_Node_Str", 'L', Blocks.redstone_lamp });
    ItemStack howler = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_HOWLER_ALARM);
    Recipes.advRecipes.addRecipe(howler, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'I', "String_Node_Str", 'M', IC2Items.getItem("String_Node_Str"), 'N', Blocks.noteblock, 'C', "String_Node_Str" });
    ItemStack industrialAlarm = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_INDUSTRIAL_ALARM);
    Recipes.advRecipes.addRecipe(industrialAlarm, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'B', "String_Node_Str", 'L', lampOrange, 'H', howler });
    ItemStack remoteThermo = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_REMOTE_THERMO);
    Recipes.advRecipes.addRecipe(remoteThermo, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'T', thermalMonitor, 'M', IC2Items.getItem("String_Node_Str"), 'F', IC2Items.getItem("String_Node_Str"), 'I', "String_Node_Str" });
    ItemStack infoPanel = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_INFO_PANEL);
    Recipes.advRecipes.addRecipe(infoPanel, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'P', "String_Node_Str", 'C', "String_Node_Str", 'I', "String_Node_Str", 'R', "String_Node_Str", 'M', IC2Items.getItem("String_Node_Str") });
    ItemStack infoPanelExtender = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_INFO_PANEL_EXTENDER);
    Recipes.advRecipes.addRecipe(infoPanelExtender, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'P', "String_Node_Str", 'R', "String_Node_Str", 'W', "String_Node_Str" });
    ItemStack infoPanelAdvanced = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_ADVANCED_PANEL);
    Recipes.advRecipes.addRecipe(infoPanelAdvanced, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'P', "String_Node_Str", 'I', infoPanel, '1', new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_COLOR), '2', new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_RANGE), 'A', "String_Node_Str", 'C', IC2Items.getItem("String_Node_Str") });
    ItemStack infoPanelExtenderAdvanced = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_ADVANCED_EXTENDER);
    Recipes.advRecipes.addRecipe(infoPanelExtenderAdvanced, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'P', "String_Node_Str", 'M', IC2Items.getItem("String_Node_Str"), 'E', infoPanelExtender, 'C', IC2Items.getItem("String_Node_Str") });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemToolThermometer), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'G', "String_Node_Str", 'I', "String_Node_Str", 'W', IC2Items.getItem("String_Node_Str") });
    ItemStack digitalThermometer = new ItemStack(IC2NuclearControl.itemToolDigitalThermometer);
    Recipes.advRecipes.addRecipe(digitalThermometer, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'R', "String_Node_Str", 'T', IC2NuclearControl.itemToolThermometer, 'I', "String_Node_Str", 'P', IC2Items.getItem("String_Node_Str") });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemRemoteSensorKit), new Object[] { "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'D', StackUtil.copyWithWildCard(digitalThermometer), 'F', IC2Items.getItem("String_Node_Str"), 'W', "String_Node_Str" });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemEnergySensorKit), new Object[] { "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'R', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str"), 'O', "String_Node_Str" });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_RANGE), new Object[] { "String_Node_Str", "String_Node_Str", 'I', IC2Items.getItem("String_Node_Str"), 'F', IC2Items.getItem("String_Node_Str"), 'C', IC2Items.getItem("String_Node_Str") });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_COLOR), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'R', "String_Node_Str", 'Y', "String_Node_Str", 'G', "String_Node_Str", 'W', "String_Node_Str", 'C', "String_Node_Str", 'M', "String_Node_Str", 'I', "String_Node_Str", 'A', "String_Node_Str", 'B', "String_Node_Str" });
    ItemStack energyCounter = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_ENERGY_COUNTER);
    Recipes.advRecipes.addRecipe(energyCounter, new Object[] { "String_Node_Str", "String_Node_Str", 'A', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str"), 'T', IC2Items.getItem("String_Node_Str"), 'I', "String_Node_Str" });
    ItemStack averageCounter = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_AVERAGE_COUNTER);
    Recipes.advRecipes.addRecipe(averageCounter, new Object[] { "String_Node_Str", "String_Node_Str", 'A', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str"), 'T', IC2Items.getItem("String_Node_Str"), 'L', "String_Node_Str" });
    ItemStack rangeTrigger = new ItemStack(IC2NuclearControl.blockNuclearControlMain, 1, BlockDamages.DAMAGE_RANGE_TRIGGER);
    Recipes.advRecipes.addRecipe(rangeTrigger, new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'P', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str"), 'A', "String_Node_Str", 'M', IC2Items.getItem("String_Node_Str"), 'R', "String_Node_Str" });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemMultipleSensorKit, 1, ItemKitMultipleSensor.TYPE_COUNTER), new Object[] { "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'C', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str"), 'R', "String_Node_Str" });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemMultipleSensorKit, 1, ItemKitMultipleSensor.TYPE_LIQUID), new Object[] { "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'C', Items.bucket, 'F', IC2Items.getItem("String_Node_Str"), 'B', "String_Node_Str" });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemTextCard), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'C', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str") });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemTimeCard), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'C', Items.clock, 'P', Items.paper, 'W', IC2Items.getItem("String_Node_Str") });
    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemMultipleSensorKit, 1, ItemKitMultipleSensor.TYPE_GENERATOR), new Object[] { "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'C', IC2Items.getItem("String_Node_Str"), 'F', IC2Items.getItem("String_Node_Str"), 'L', "String_Node_Str" });
    Recipes.advRecipes.addShapelessRecipe(IC2Items.getItem("String_Node_Str"), IC2NuclearControl.itemSensorLocationCard);
    Recipes.advRecipes.addShapelessRecipe(IC2Items.getItem("String_Node_Str"), IC2NuclearControl.item55ReactorCard);
    Recipes.advRecipes.addShapelessRecipe(IC2Items.getItem("String_Node_Str"), IC2NuclearControl.itemEnergySensorLocationCard);
    Recipes.advRecipes.addShapelessRecipe(IC2Items.getItem("String_Node_Str"), IC2NuclearControl.itemTextCard);
    Recipes.advRecipes.addShapelessRecipe(IC2Items.getItem("String_Node_Str"), IC2NuclearControl.itemTimeCard);
    Recipes.advRecipes.addShapelessRecipe(IC2Items.getItem("String_Node_Str"), IC2NuclearControl.itemMultipleSensorLocationCard);
    CraftingManager.getInstance().getRecipeList().add(new StorageArrayRecipe());
}

Output:
     Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemEnergySensorKit), new Object[] { "String_Node_Str", "String_Node_Str", 'P', Items.paper, 'R', "String_Node_Str", 'F', IC2Items.getItem("String_Node_Str"), 'O', "String_Node_Str" });
-    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_RANGE), new Object[] { "String_Node_Str", "String_Node_Str", 'I', IC2Items.getItem("String_Node_Str"), 'F', IC2Items.getItem("String_Node_Str"), 'C', IC2Items.getItem("String_Node_Str") });
+    Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_RANGE), new Object[] { "String_Node_Str", "String_Node_Str", 'I', IC2Items.getItem("String_Node_Str"), 'F', IC2Items.getItem("String_Node_Str"), 'C', new ItemStack(IC2Items.getItem("String_Node_Str").getItem(), 1, 1) });
     Recipes.advRecipes.addRecipe(new ItemStack(IC2NuclearControl.itemUpgrade, 1, ItemUpgrade.DAMAGE_COLOR), new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", 'R', "String_Node_Str", 'Y', "String_Node_Str", 'G', "String_Node_Str", 'W', "String_Node_Str", 'C', "String_Node_Str", 'M', "String_Node_Str", 'I', "String_Node_Str", 'A', "String_Node_Str", 'B', "String_Node_Str" });


Input:
public void validate(ValidationHandler handler) {
    if (!superTypes.isEmpty()) {
        List<TypeMetadata> thisSuperTypes = new LinkedList<TypeMetadata>(superTypes);
        for (TypeMetadata superType : thisSuperTypes) {
            if (isInstantiable() == superType.isInstantiable()) {
                if (superType instanceof ComplexTypeMetadata) {
                    Collection<FieldMetadata> thisTypeKeyFields = getKeyFields();
                    for (FieldMetadata thisTypeKeyField : thisTypeKeyFields) {
                        if (!((ComplexTypeMetadata) superType).hasField(thisTypeKeyField.getName())) {
                            handler.error(superType, "String_Node_Str" + name + "String_Node_Str" + "String_Node_Str" + superType.getName() + "String_Node_Str", superType.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), superType.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), superType.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_CANNOT_OVERRIDE_SUPER_TYPE_KEY);
                        }
                    }
                }
            }
        }
    }
    for (FieldMetadata value : fieldMetadata.values()) {
        value.validate(handler);
    }
    for (FieldMetadata keyField : keyFields.values()) {
        keyField.validate(handler);
        FieldMetadata frozenField = keyField.freeze(handler);
        if (frozenField.isMany()) {
            handler.error(frozenField, "String_Node_Str", frozenField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), frozenField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), frozenField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.FIELD_KEY_CANNOT_BE_REPEATABLE);
        }
        if (!frozenField.isMandatory()) {
            handler.error(frozenField, "String_Node_Str", frozenField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), frozenField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), frozenField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.FIELD_KEY_MUST_BE_MANDATORY);
        }
    }
    for (FieldMetadata pkInfo : primaryKeyInfo) {
        if (!this.equals(pkInfo.getContainingType())) {
            handler.error(this, "String_Node_Str", pkInfo.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), pkInfo.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), pkInfo.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.PRIMARY_KEY_INFO_NOT_IN_ENTITY);
            continue;
        }
        int previousErrorCount = handler.getErrorCount();
        pkInfo.validate(handler);
        if (handler.getErrorCount() == previousErrorCount) {
            if (pkInfo.isMany()) {
                handler.error(this, "String_Node_Str", pkInfo.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), pkInfo.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), pkInfo.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.PRIMARY_KEY_INFO_CANNOT_BE_REPEATABLE);
                continue;
            }
            if (!isPrimitiveTypeField(pkInfo)) {
                handler.warning(this, "String_Node_Str", pkInfo.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), pkInfo.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), pkInfo.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.PRIMARY_KEY_INFO_TYPE_NOT_PRIMITIVE);
            }
        }
    }
    for (FieldMetadata lookupField : lookupFields) {
        int errorCount = handler.getErrorCount();
        lookupField.validate(handler);
        if (handler.getErrorCount() > errorCount) {
            continue;
        }
        if (!this.equals(lookupField.getContainingType())) {
            handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_NOT_IN_ENTITY);
            continue;
        }
        lookupField.getContainingType().freeze(handler);
        if (lookupField.isKey()) {
            handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_CANNOT_BE_KEY);
            continue;
        }
        lookupField.validate(handler);
        if (!isPrimitiveTypeField(lookupField)) {
            handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_MUST_BE_SIMPLE_TYPE);
        }
    }
}

Output:
         }
-        lookupField.getContainingType().freeze(handler);
-        if (lookupField.isKey()) {
-            handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_CANNOT_BE_KEY);
-            continue;
-        }
-        lookupField.validate(handler);
-        if (!isPrimitiveTypeField(lookupField)) {
-            handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_MUST_BE_SIMPLE_TYPE);
+        if (handler.getErrorCount() == originalErrorCount) {
+            lookupField.getContainingType().freeze(handler);
+            if (lookupField.isKey()) {
+                handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_CANNOT_BE_KEY);
+                continue;
+            }
+            lookupField.validate(handler);
+            if (!isPrimitiveTypeField(lookupField)) {
+                handler.error(this, "String_Node_Str", lookupField.<Element>getData(MetadataRepository.XSD_DOM_ELEMENT), lookupField.<Integer>getData(MetadataRepository.XSD_LINE_NUMBER), lookupField.<Integer>getData(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.LOOKUP_FIELD_MUST_BE_SIMPLE_TYPE);
+            }
         }


Input:
public synchronized void print(String str) {
    synchronized (this.getClass()) {
        ToolIO.nextMessage = ToolIO.nextMessage + "String_Node_Str";
        try {
            Class.forName("String_Node_Str").notifyAll();
        } catch (Exception e) {
        }
        ;
    }
}

Output:
 public synchronized void print(String str) {
-    synchronized (this.getClass()) {
-        ToolIO.nextMessage = ToolIO.nextMessage + "String_Node_Str";
-        try {
-            Class.forName("String_Node_Str").notifyAll();
-        } catch (Exception e) {
-        }
-        ;
+    synchronized (ToolPrintStream.class) {
+        ToolIO.nextMessage += str;
+        ToolPrintStream.class.notifyAll();
     }


Input:
public void toString(String prefix, StringBuilder buffer) {
    if (this.instance != null) {
        this.instance.toString("String_Node_Str", buffer);
        buffer.append('.');
    }
    buffer.append(this.name);
    if (this.value != null) {
        buffer.append(Formatting.Field.keyValueSeperator);
        Formatting.appendValue(this.value, prefix, buffer);
    }
}

Output:
         buffer.append(Formatting.Field.keyValueSeperator);
-        Formatting.appendValue(this.value, prefix, buffer);
+        this.value.toString(prefix, buffer);
     }


Input:
public boolean canBlockStay(World world, BlockPos pos) {
    return (world.getBlockState(pos.add(0, 1, 0)).getBlock() instanceof IAgriFluidComponent);
}

Output:
 public boolean canBlockStay(World world, BlockPos pos) {
-    return (world.getBlockState(pos.add(0, 1, 0)).getBlock() instanceof IAgriFluidComponent);
+    return WorldHelper.getTile(world, pos, TileEntitySprinkler.class).filter(TileEntitySprinkler::isConnected).isPresent();
 }


Input:
private void appendDate() {
    sb.append(calendar.get(DAY_OF_MONTH));
    sb.append('-');
    sb.append(calendar.get(MONTH));
    sb.append('-');
    sb.append(calendar.get(YEAR));
}

Output:
 private void appendDate() {
-    sb.append(calendar.get(DAY_OF_MONTH));
-    sb.append('-');
-    sb.append(calendar.get(MONTH));
-    sb.append('-');
-    sb.append(calendar.get(YEAR));
+    write(calendar.get(DAY_OF_MONTH));
+    write('-');
+    write(calendar.get(MONTH));
+    write('-');
+    write(calendar.get(YEAR));
 }


Input:
public int getVersion() {
    int version = getLatestVersion();
    if (dataEngineContext.hasInStream(null, null, DataEngineContext.VERSION_INFO_STREAM) == false) {
        version = VERSION_2_0;
        return version;
    }
    try {
        DataInputStream is = new DataInputStream(dataEngineContext.getInputStream(null, null, DataEngineContext.VERSION_INFO_STREAM));
        version = IOUtil.readInt(is);
        is.close();
    } catch (DataException e) {
        logger.log(Level.FINE, e.getMessage(), e);
    } catch (IOException e) {
        logger.log(Level.FINE, e.getMessage(), e);
    }
    return version;
}

Output:
     }
-    try {
-        DataInputStream is = new DataInputStream(dataEngineContext.getInputStream(null, null, DataEngineContext.VERSION_INFO_STREAM));
-        version = IOUtil.readInt(is);
-        is.close();
-    } catch (DataException e) {
-        logger.log(Level.FINE, e.getMessage(), e);
-    } catch (IOException e) {
-        logger.log(Level.FINE, e.getMessage(), e);
-    }
-    return version;
+    return this.getVersion();
 }


Input:
public void post(Runnable action) {
    if (action == null)
        return;
    handler.post(action);
}

Output:
 public void post(Runnable action) {
-    if (action == null)
+    if (handler == null || action == null)
         return;