Input:
public void convert(boolean askPath, Consumer<String>... nextStep) {
    final Path currentTabPath = current.currentPath().get();
    final Path currentTabPathDir = currentTabPath.getParent();
    final Path configPath = asciiDocController.getConfigPath();
    final String tabText = current.getCurrentTabText().replace("String_Node_Str", "String_Node_Str").trim();
    threadService.runActionLater(() -> {
        final Path pdfPath = directoryService.getSaveOutputPath(ExtensionFilters.PDF, askPath);
        docBookConverter.convert(false, docbook -> {
            indikatorService.startProgressBar();
            logger.debug("String_Node_Str");
            final Path docbookTempfile = IOHelper.createTempFile(currentTabPathDir, "String_Node_Str");
            IOHelper.writeToFile(docbookTempfile, docbook, CREATE, WRITE, TRUNCATE_EXISTING);
            try (OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(pdfPath.toFile()))) {
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer transformer = factory.newTransformer(new StreamSource(configPath.resolve("String_Node_Str").toFile()));
                transformer.setParameter("String_Node_Str", configPath.resolve("String_Node_Str").toUri().toASCIIString());
                transformer.setParameter("String_Node_Str", configPath.resolve("String_Node_Str").toUri().toASCIIString());
                transformer.setParameter("String_Node_Str", configPath.resolve("String_Node_Str").toUri().toASCIIString());
                try (BufferedInputStream configStream = new BufferedInputStream(new FileInputStream(configPath.resolve("String_Node_Str").toFile()))) {
                    FopFactory fopFactory = FopFactory.newInstance(docbookTempfile.getParent().toUri(), configStream);
                    FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
                    Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, outputStream);
                    try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(docbookTempfile.toFile()))) {
                        Source src = new StreamSource(inputStream);
                        Result res = new SAXResult(fop.getDefaultHandler());
                        transformer.transform(src, res);
                        Files.deleteIfExists(docbookTempfile);
                        FormattingResults foResults = fop.getResults();
                        logger.info("String_Node_Str", foResults.getPageCount());
                    }
                }
            } catch (Exception e) {
                logger.error("String_Node_Str", e);
            } finally {
                indikatorService.stopProgressBar();
                logger.debug("String_Node_Str");
                asciiDocController.addRemoveRecentList(pdfPath);
            }
        });
    });
}

Output:
                 transformer.setParameter("String_Node_Str", configPath.resolve("String_Node_Str").toUri().toASCIIString());
-                try (BufferedInputStream configStream = new BufferedInputStream(new FileInputStream(configPath.resolve("String_Node_Str").toFile()))) {
-                    FopFactory fopFactory = FopFactory.newInstance(docbookTempfile.getParent().toUri(), configStream);
-                    FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
-                    Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, outputStream);
-                    try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(docbookTempfile.toFile()))) {
-                        Source src = new StreamSource(inputStream);
-                        Result res = new SAXResult(fop.getDefaultHandler());
-                        transformer.transform(src, res);
-                        Files.deleteIfExists(docbookTempfile);
-                        FormattingResults foResults = fop.getResults();
-                        logger.info("String_Node_Str", foResults.getPageCount());
-                    }
+                if (Objects.isNull(fopFactory)) {
+                    fopFactory = FopFactory.newInstance(configPath.resolve("String_Node_Str").toFile());
                 }


Input:
protected void paintComponent(Graphics g) {
    GUIUtil.makeTextLookLessRubbish(g);
    super.paintComponent(g);
}

Output:
 protected void paintComponent(Graphics g) {
-    GUIUtil.makeTextLookLessRubbish(g);
+    GuiUtil.makeTextLookLessRubbish(g);
     super.paintComponent(g);


Input:
public boolean postfire() throws IllegalActionException {
    int numberOfIterations = ((IntToken) (iterations.getToken())).intValue();
    if (_debugging) {
        _debug("String_Node_Str" + _iterationCount);
    }
    _expectedNextIterationTime += _unitTimeIncrement;
    if (_debugging) {
        _debug("String_Node_Str" + _expectedNextIterationTime);
    }
    if ((numberOfIterations > 0) && (_iterationCount > numberOfIterations)) {
        _iterationCount = 0;
        _transferOutputsOnly = false;
        if (_isEmbedded()) {
            return true;
        } else {
            return false;
        }
    } else {
        if ((numberOfIterations > 0) && (_iterationCount == numberOfIterations)) {
            _transferOutputsOnly = true;
        }
        if (_isEmbedded()) {
            _requestFiring();
        } else {
            setCurrentTime(_expectedNextIterationTime);
        }
    }
    return true;
}

Output:
 public boolean postfire() throws IllegalActionException {
-    int numberOfIterations = ((IntToken) (iterations.getToken())).intValue();
-    if (_debugging) {
-        _debug("String_Node_Str" + _iterationCount);
+    _unitIndex++;
+    if (_unitIndex >= _schedule.size()) {
+        _unitIndex = 0;
+        if (_debugging) {
+            _debug("String_Node_Str" + _iterationCount);
+        }
+        _iterationCount++;
     }


Input:
public static boolean isAnnotatedWithProducer(PsiMethod method) {
    for (SubscriberMetadata info : subscribers) {
        if (info.getProducerClassName() == null)
            continue;
        PsiAnnotation annotation = PsiConsultantImpl.findAnnotationOnMethod(method, info.getProducerClassName());
        if (annotation != null)
            return true;
    }
    return false;
}

Output:
     for (SubscriberMetadata info : subscribers) {
-        if (info.getProducerClassName() == null)
+        if (info.getProducerClassName() == null) {
             continue;


Input:
public void visitParameter(String name, IType type, int index) {
    this.locals.add(type.getFrameType());
    this.mv.visitParameter(name, index);
}

Output:
 public void visitParameter(String name, IType type, int index) {
-    this.locals.add(type.getFrameType());
+    this.addLocal(index, type.getFrameType());
     this.mv.visitParameter(name, index);


Input:
protected Response handleGenericError(Throwable exception) {
    NlsRuntimeException userError = TechnicalErrorUserException.getOrCreateUserException(exception);
    if (userError.isTechnical()) {
        LOG.error("String_Node_Str", exception);
    } else {
        LOG.warn("String_Node_Str", exception.getMessage());
    }
    return createResponse(userError);
}

Output:
     if (userError.isTechnical()) {
-        LOG.error("String_Node_Str", exception);
+        LOG.error("String_Node_Str", userError);
     } else {


Input:
protected void drawBackgroundImage(float x, float y, float width, float height, float iWidth, float iHeight, int repeat, String imageUrl, float absPosX, float absPosY) throws IOException {
    y = transformY(y);
    contentByte.saveState();
    try {
        Image img = null;
        try {
            img = Image.getInstance(new URL(imageUrl));
        } catch (IOException e) {
            if (SvgFile.isSvg(imageUrl)) {
                try {
                    img = Image.getInstance(SvgFile.transSvgToArray(imageUrl));
                } catch (IOException ex) {
                    throw ex;
                }
            } else {
                throw e;
            }
        }
        float imageWidth = iWidth;
        float imageHeight = iHeight;
        if (imageHeight == 0 || imageWidth == 0) {
            int resolutionX = img.getDpiX();
            int resolutionY = img.getDpiY();
            if (0 == resolutionX || 0 == resolutionY) {
                resolutionX = 96;
                resolutionY = 96;
            }
            imageWidth = img.plainWidth() / resolutionX * 72;
            imageHeight = img.plainHeight() / resolutionY * 72;
        }
        if (BackgroundImageInfo.NO_REPEAT == repeat) {
            TplValueTriple triple = computeTplHorizontalValPair(absPosX, x, width, imageWidth);
            float tplOriginX = triple.getTplOrigin();
            float tplWidth = triple.getTplSize();
            float translationX = triple.getTranslation();
            triple = computeTplVerticalValTriple(absPosY, y, height, imageHeight);
            float tplOrininY = triple.getTplOrigin();
            float tplHeight = triple.getTplSize();
            float translationY = triple.getTranslation();
            PdfTemplate templateWhole = contentByte.createTemplate(tplWidth, tplHeight);
            templateWhole.addImage(img, imageWidth, 0, 0, imageHeight, translationX, translationY);
            contentByte.addTemplate(templateWhole, tplOriginX, tplOrininY);
        } else if (BackgroundImageInfo.REPEAT_X == repeat) {
            float remainX = width;
            PdfTemplate template = null;
            if (width > imageWidth) {
                if (height - absPosY > imageHeight) {
                    template = contentByte.createTemplate(imageWidth, imageHeight);
                    template.addImage(img, imageWidth, 0, 0, imageHeight, 0, 0);
                } else {
                    template = contentByte.createTemplate(imageWidth, height);
                    template.addImage(img, imageWidth, 0, 0, imageHeight, 0, -imageHeight + height);
                }
            }
            while (remainX > 0) {
                if (remainX < imageWidth) {
                    if (height - absPosY > imageHeight) {
                        PdfTemplate templateX = contentByte.createTemplate(remainX, imageHeight);
                        templateX.addImage(img, imageWidth, 0, 0, imageHeight, 0, 0);
                        contentByte.addTemplate(templateX, x + width - remainX, y - absPosY - imageHeight);
                    } else {
                        PdfTemplate templateX = contentByte.createTemplate(remainX, height);
                        templateX.addImage(img, imageWidth, 0, 0, imageHeight, 0, -imageHeight + height - absPosY);
                        contentByte.addTemplate(templateX, x + width - remainX, y - absPosY - height);
                    }
                    remainX = 0;
                } else {
                    if (height - absPosY > imageHeight)
                        contentByte.addTemplate(template, x + width - remainX, y - absPosY - imageHeight);
                    else
                        contentByte.addTemplate(template, x + width - remainX, y - absPosY - height);
                    remainX -= imageWidth;
                }
            }
        } else if (BackgroundImageInfo.REPEAT_Y == repeat) {
            float remainY = height;
            PdfTemplate template = null;
            if (height > imageHeight) {
                template = contentByte.createTemplate(width - absPosX > imageWidth ? imageWidth : width - absPosX, imageHeight);
                template.addImage(img, imageWidth, 0, 0, imageHeight, 0, 0);
            }
            while (remainY > 0) {
                if (remainY < imageHeight) {
                    PdfTemplate templateY = contentByte.createTemplate(width - absPosX > imageWidth ? imageWidth : width - absPosX, remainY);
                    templateY.addImage(img, width > imageWidth ? imageWidth : width - absPosX, 0, 0, imageHeight, 0, -(imageHeight - remainY));
                    contentByte.addTemplate(templateY, x + absPosX, y - height);
                    remainY = 0;
                } else {
                    contentByte.addTemplate(template, x + absPosX, y - height + remainY - imageHeight);
                    remainY -= imageHeight;
                }
            }
        } else if (BackgroundImageInfo.REPEAT == repeat) {
            float remainX = width;
            float remainY = height;
            PdfTemplate template = null;
            if (width >= imageWidth && height >= imageHeight) {
                template = contentByte.createTemplate(imageWidth, imageHeight);
                template.addImage(img, imageWidth, 0, 0, imageHeight, 0, 0);
            }
            while (remainY > 0) {
                remainX = width;
                if (remainY < imageHeight) {
                    while (remainX > 0) {
                        if (remainX < imageWidth) {
                            PdfTemplate templateXY = contentByte.createTemplate(remainX, remainY);
                            templateXY.addImage(img, imageWidth, 0, 0, imageHeight, 0, -imageHeight + remainY);
                            contentByte.addTemplate(templateXY, x + width - remainX, y - height);
                            remainX = 0;
                        } else {
                            PdfTemplate templateY = contentByte.createTemplate(imageWidth, remainY);
                            templateY.addImage(img, imageWidth, 0, 0, imageHeight, 0, -imageHeight + remainY);
                            contentByte.addTemplate(templateY, x + width - remainX, y - height);
                            remainX -= imageWidth;
                        }
                    }
                    remainY = 0;
                } else {
                    while (remainX > 0) {
                        if (remainX < imageWidth) {
                            PdfTemplate templateX = contentByte.createTemplate(remainX, imageHeight);
                            templateX.addImage(img, imageWidth, 0, 0, imageHeight, 0, 0);
                            contentByte.addTemplate(templateX, x + width - remainX, y - height + remainY - imageHeight);
                            remainX = 0;
                        } else {
                            contentByte.addTemplate(template, x + width - remainX, y - height + remainY - imageHeight);
                            remainX -= imageWidth;
                        }
                    }
                    remainY -= imageHeight;
                }
            }
        }
    } catch (IOException ioe) {
        logger.log(Level.WARNING, ioe.getMessage(), ioe);
    } catch (BadElementException bee) {
        logger.log(Level.WARNING, bee.getMessage(), bee);
    } catch (DocumentException de) {
        logger.log(Level.WARNING, de.getMessage(), de);
    } catch (RuntimeException re) {
        logger.log(Level.WARNING, re.getMessage(), re);
    }
    contentByte.restoreState();
}

Output:
             while (remainX > 0) {
-                if (remainX < imageWidth) {
-                    if (height - absPosY > imageHeight) {
+                if (remainX <= imageWidth) {
+                    if (height - absPosY >= imageHeight) {
                         PdfTemplate templateX = contentByte.createTemplate(remainX, imageHeight);


Input:
public void makeUniqueName(String prefix) {
    if (focus instanceof GroupElement) {
        makeUniqueGroupName((GroupElement) focus, prefix);
        return;
    }
    if (nameHelper != null) {
        nameHelper.makeUniqueName(namespaceId, focus);
    }
}

Output:
     if (nameHelper != null) {
-        nameHelper.makeUniqueName(namespaceId, focus);
+        nameHelper.makeUniqueName(namespaceId, focus, prefix);
     }


Input:
public org.jboss.forge.addon.dependencies.DependencyNode resolveDependencyHierarchy(final DependencyQuery query) {
    try {
        RepositorySystem system = container.getRepositorySystem();
        Settings settings = container.getSettings();
        MavenRepositorySystemSession session = container.setupRepoSession(system, settings);
        session.setTransferListener(new LogTransferListener());
        session.setDependencyTraverser(new DependencyTraverser() {
            public boolean traverseDependency(org.sonatype.aether.graph.Dependency dependency) {
                if (query.getScopeType() != null)
                    return query.getScopeType().equals(dependency.getScope());
                else
                    return !"String_Node_Str".equals(dependency.getScope());
            }
            public DependencyTraverser deriveChildTraverser(DependencyCollectionContext context) {
                return this;
            }
        });
        session.setDependencySelector(new ScopeDependencySelector("String_Node_Str"));
        final CoordinateBuilder coord = CoordinateBuilder.create(query.getCoordinate());
        Artifact queryArtifact = coordinateToMavenArtifact(coord);
        List<RemoteRepository> remoteRepos = getRemoteRepositories(query, settings);
        CollectRequest collectRequest = new CollectRequest(new org.sonatype.aether.graph.Dependency(queryArtifact, null), remoteRepos);
        DependencyRequest dr = new DependencyRequest(collectRequest, null);
        DependencyResult result = system.resolveDependencies(session, dr);
        DependencyNodeBuilder hierarchy = MavenConvertUtils.toDependencyNode(factory, null, result.getRoot());
        return hierarchy;
    } catch (Exception e) {
        throw new DependencyException("String_Node_Str" + query.getCoordinate() + "String_Node_Str", e);
    }
}

Output:
         final CoordinateBuilder coord = CoordinateBuilder.create(query.getCoordinate());
-        Artifact queryArtifact = coordinateToMavenArtifact(coord);
-        List<RemoteRepository> remoteRepos = getRemoteRepositories(query, settings);
+        Artifact queryArtifact = MavenConvertUtils.coordinateToMavenArtifact(coord);
+        List<RemoteRepository> remoteRepos = MavenRepositories.getRemoteRepositories(container, settings, query);
         CollectRequest collectRequest = new CollectRequest(new org.sonatype.aether.graph.Dependency(queryArtifact, null), remoteRepos);


Input:
private void triggerErase(int newmode) {
    current_erase = getEraseMode(newmode);
}

Output:
 private void triggerErase(int newmode) {
-    current_erase = getEraseMode(newmode);
+    currentWriteMode = getEraseMode(newmode);
 }


Input:
final public int getValueBytesFromId(int id, byte[] returnValue, int offset) {
    if (isNullId(id))
        return 0;
    else
        return getValueBytesFromIdImpl(id, returnValue, offset);
}

Output:
     if (isNullId(id))
-        return 0;
+        return -1;
     else


Input:
public void testThatSecuritiesAreGroupedIntoClassifications() {
    Client client = new Client();
    Taxonomy taxonomy = new TaxonomyBuilder().addClassification("String_Node_Str").addClassification("String_Node_Str").addClassification("String_Node_Str").addTo(client);
    Security a = new SecurityBuilder().addPrice("String_Node_Str", 1000).assign(taxonomy, "String_Node_Str").addTo(client);
    Security c = new SecurityBuilder().addPrice("String_Node_Str", 1200).assign(taxonomy, "String_Node_Str").addTo(client);
    Security d = new SecurityBuilder().addPrice("String_Node_Str", 1200).assign(taxonomy, "String_Node_Str").addTo(client);
    Portfolio portfolio = new PortfolioBuilder().inbound_delivery(a, "String_Node_Str", 1000000, 10000).inbound_delivery(c, "String_Node_Str", 1000000, 12000).inbound_delivery(d, "String_Node_Str", 1000000, 12000).addTo(client);
    PortfolioSnapshot snapshot = PortfolioSnapshot.create(portfolio, new DateTime("String_Node_Str").toDate());
    assertNotNull(snapshot);
    GroupByTaxonomy grouping = snapshot.groupByTaxonomy(taxonomy);
    AssetCategory debt = grouping.byClassification(taxonomy.getClassificationById("String_Node_Str"));
    assertThat(debt.getValuation(), is(10000L));
    assertThat(debt.getPositions().size(), is(1));
    AssetCategory stocks = grouping.byClassification(taxonomy.getClassificationById("String_Node_Str"));
    assertThat(stocks.getValuation(), is(24000L));
    assertThat(stocks.getPositions().size(), is(2));
    AssetCategory realEstate = grouping.byClassification(taxonomy.getClassificationById("String_Node_Str"));
    assertThat(realEstate, nullValue());
}

Output:
     Security d = new SecurityBuilder().addPrice("String_Node_Str", 1200).assign(taxonomy, "String_Node_Str").addTo(client);
-    Portfolio portfolio = new PortfolioBuilder().inbound_delivery(a, "String_Node_Str", 1000000, 10000).inbound_delivery(c, "String_Node_Str", 1000000, 12000).inbound_delivery(d, "String_Node_Str", 1000000, 12000).addTo(client);
+    Portfolio portfolio = new PortfolioBuilder().inbound_delivery(a, "String_Node_Str", Values.Share.factorize(10), 10000).inbound_delivery(c, "String_Node_Str", Values.Share.factorize(10), 12000).inbound_delivery(d, "String_Node_Str", Values.Share.factorize(10), 12000).addTo(client);
     PortfolioSnapshot snapshot = PortfolioSnapshot.create(portfolio, new DateTime("String_Node_Str").toDate());


Input:
private String parseHyperLink(IContent content) {
    IHyperlinkAction linkaction = content.getHyperlinkAction();
    if (linkaction != null) {
        if (linkaction.getType() == IHyperlinkAction.ACTION_BOOKMARK) {
            return linkaction.getBookmark().replaceAll("String_Node_Str", "String_Node_Str");
        } else if (linkaction.getType() == IHyperlinkAction.ACTION_HYPERLINK) {
            return linkaction.getHyperlink();
        } else if (linkaction.getType() == IHyperlinkAction.ACTION_DRILLTHROUGH) {
            Action act = new Action(linkaction);
            IHTMLActionHandler actionHandler = null;
            Object ac = eservice.getOption(RenderOptionBase.ACTION_HANDLER);
            if (ac != null && ac instanceof IHTMLActionHandler) {
                actionHandler = (IHTMLActionHandler) ac;
                actionHandler.getURL(act, null);
                return actionHandler.getURL(act, eservice.getReportContext());
            }
        }
    }
    return null;
}

Output:
         if (linkaction.getType() == IHyperlinkAction.ACTION_BOOKMARK) {
-            return linkaction.getBookmark().replaceAll("String_Node_Str", "String_Node_Str");
+            return new HyperlinkDef(linkaction.getBookmark().replaceAll("String_Node_Str", "String_Node_Str"), IHyperlinkAction.ACTION_BOOKMARK, null);
         } else if (linkaction.getType() == IHyperlinkAction.ACTION_HYPERLINK) {


Input:
public void componentEvent(Event e) {
    IConfigurationService configurationService = context.getConfigurationService();
    if (e instanceof NodeSelectedEvent) {
        NodeSelectedEvent event = (NodeSelectedEvent) e;
        Node node = event.getNode();
        FlowStep flowStep = flow.findFlowStepWithId(node.getId());
        selected = flowStep;
        propertySheet.valueChange(flowStep);
        delButton.setEnabled(true);
    } else if (e instanceof NodeDoubleClickedEvent) {
        NodeDoubleClickedEvent event = (NodeDoubleClickedEvent) e;
        Node node = event.getNode();
        FlowStep flowStep = flow.findFlowStepWithId(node.getId());
        projectNavigator.open(flowStep, flow, propertySheet);
    } else if (e instanceof NodeMovedEvent) {
        NodeMovedEvent event = (NodeMovedEvent) e;
        Node node = event.getNode();
        FlowStep flowStep = flow.findFlowStepWithId(node.getId());
        if (flowStep != null) {
            flowStep.setX(node.getX());
            flowStep.setY(node.getY());
        }
        configurationService.save(flow);
    } else if (e instanceof LinkEvent) {
        LinkEvent event = (LinkEvent) e;
        if (!event.isRemoved()) {
            flow.getFlowStepLinks().add(new FlowStepLink(event.getSourceNodeId(), event.getTargetNodeId()));
            configurationService.save(flow);
        } else {
            FlowStepLink link = flow.removeFlowStepLink(event.getSourceNodeId(), event.getTargetNodeId());
            if (link != null) {
                configurationService.delete(link);
                redrawFlow();
            }
        }
    } else if (e instanceof LinkSelectedEvent) {
        LinkSelectedEvent event = (LinkSelectedEvent) e;
        selected = flow.findFlowStepLink(event.getSourceNodeId(), event.getTargetNodeId());
        delButton.setEnabled(true);
    }
}

Output:
             if (link != null) {
-                configurationService.delete(link);
-                redrawFlow();
+                if (configurationService.delete(link)) {
+                    redrawFlow();
+                }
             }


Input:
private void showOnScreenSettings() {
    if (mSettings == null) {
        mSettings = new OnScreenSettings(findViewById(R.id.camera_preview));
        CameraSettings helper = new CameraSettings(this, mParameters);
        mSettings.setPreferenceScreen(helper.getPreferenceScreen(R.xml.camera_preferences));
        mSettings.setOnVisibilityChangedListener(this);
    }
    mSettings.expandPanel();
}

Output:
         CameraSettings helper = new CameraSettings(this, mParameters);
-        mSettings.setPreferenceScreen(helper.getPreferenceScreen(R.xml.camera_preferences));
+        mSettings.setPreferenceScreen(helper.getPreferenceScreen(R.xml.video_preferences));
         mSettings.setOnVisibilityChangedListener(this);


Input:
public void updateSalePrice(Product product) throws AxelorException {
    BigDecimal costPrice = product.getCostPrice();
    BigDecimal managePriceCoef = product.getManagPriceCoef();
    if (costPrice != null && managePriceCoef != null) {
        product.setSalePrice(costPrice.multiply(managePriceCoef));
    }
}

Output:
     if (costPrice != null && managePriceCoef != null) {
-        product.setSalePrice(costPrice.multiply(managePriceCoef));
+        product.setSalePrice((costPrice.multiply(managePriceCoef)).setScale(5, BigDecimal.ROUND_HALF_UP));
+        LOG.debug("String_Node_Str", product.getSalePrice());
     }


Input:
protected Map<String, Set<Permission>> getAuthorizationInfo(final OAuthorizationCredentials credentials, final String targetClientId) {
    Map<String, Set<Permission>> authorizationInfo = null;
    try {
        CacheKey key = new CacheKey(targetClientId, credentials);
        if (cachingEnabled)
            authorizationInfo = cacheManager.get(key);
        if (authorizationInfo == null) {
            authorizationInfo = getAuthorizationInfoInternal(credentials, targetClientId);
            if (cachingEnabled)
                cacheManager.put(key, authorizationInfo);
        }
    } catch (AccessTokenExpiredException e) {
        accessTokenExpired = true;
        clearCache(null);
    }
    return authorizationInfo;
}

Output:
     Map<String, Set<Permission>> authorizationInfo = null;
-    try {
-        CacheKey key = new CacheKey(targetClientId, credentials);
+    CacheKey key = new CacheKey(targetClientId, credentials);
+    if (cachingEnabled)
+        authorizationInfo = cacheManager.get(key);
+    if (authorizationInfo == null) {
+        authorizationInfo = getAuthorizationInfoInternal(credentials, targetClientId);
         if (cachingEnabled)


Input:
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    canPerformLogout.set(true);
    if (isGalleryCalled(requestCode) && resultCode == RESULT_OK) {
        isNeedToScrollMessages = true;
        onFileSelected(data.getData());
    }
    super.onActivityResult(requestCode, resultCode, data);
}

Output:
     canPerformLogout.set(true);
-    if (isGalleryCalled(requestCode) && resultCode == RESULT_OK) {
+    if ((isGalleryCalled(requestCode) || isCaptureCalled(requestCode)) && resultCode == RESULT_OK) {
         isNeedToScrollMessages = true;


Input:
public List<OFFlowMod> managedFlowActions(OFFlowMod flowMod) {
    List<OFFlowMod> newFlows = new ArrayList<OFFlowMod>();
    List<OFAction> actions = flowMod.getActions();
    List<OFAction> newActions = new ArrayList<OFAction>();
    short additional_length = 0;
    for (OFAction act : actions) {
        switch(act.getType()) {
            case OUTPUT:
                OFActionOutput out = (OFActionOutput) act;
                short vlanTag = (short) this.getPortConfig(out.getPort()).getVlanRange().getAvailableTags()[0];
                if (vlanTag == -1) {
                    OFActionStripVirtualLan strip_vlan_vid = new OFActionStripVirtualLan();
                    newActions.add(strip_vlan_vid);
                    additional_length += strip_vlan_vid.getLength();
                } else {
                    OFActionVirtualLanIdentifier set_vlan_vid = new OFActionVirtualLanIdentifier();
                    set_vlan_vid.setVirtualLanIdentifier(vlanTag);
                    newActions.add(set_vlan_vid);
                    additional_length += set_vlan_vid.getLength();
                }
                newActions.add(out);
                break;
            case SET_VLAN_ID:
                return newFlows;
            case STRIP_VLAN:
                return newFlows;
            default:
                newActions.add(act);
                break;
        }
    }
    OFFlowMod newFlow = new OFFlowMod();
    newFlow.setMatch(flowMod.getMatch());
    newFlow.setActions(newActions);
    newFlow.setLength((short) (flowMod.getLength() + additional_length));
    newFlows.add(newFlow);
    return newFlows;
}

Output:
                 OFActionOutput out = (OFActionOutput) act;
-                short vlanTag = (short) this.getPortConfig(out.getPort()).getVlanRange().getAvailableTags()[0];
+                short vlanTag;
+                PortConfig pConfig = this.getPortConfig(out.getPort());
+                if (pConfig == null) {
+                    return newFlows;
+                } else {
+                    vlanTag = (short) pConfig.getVlanRange().getAvailableTags()[0];
+                }
                 if (vlanTag == -1) {


Input:
public void initialize() throws IllegalActionException {
    super.initialize();
    Effigy parentEffigy = Configuration.findEffigy(toplevel());
    try {
        _wrapperEffigy = new PtolemyEffigy(parentEffigy, parentEffigy.uniqueName("String_Node_Str"));
    } catch (NameDuplicationException e) {
        throw new IllegalActionException(this, e, "String_Node_Str" + "String_Node_Str");
    }
}

Output:
     super.initialize();
-    Effigy parentEffigy = Configuration.findEffigy(toplevel());
+    Effigy parentEffigy = GTEntityUtils.findToplevelEffigy(this);
     try {


Input:
public void comment(char[] ch, int start, int length) throws SAXException {
    try {
        if (isStartElementOpen) {
            outputStream.write(CLOSE_ELEMENT);
            outputStream.write(CR);
            isStartElementOpen = false;
        }
        writeComment(ch, start, length);
        complexType = false;
    } catch (IOException e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
 public void comment(char[] ch, int start, int length) throws SAXException {
-    try {
-        if (isStartElementOpen) {
-            outputStream.write(CLOSE_ELEMENT);
-            outputStream.write(CR);
-            isStartElementOpen = false;
-        }
-        writeComment(ch, start, length);
-        complexType = false;
-    } catch (IOException e) {
-        throw XMLMarshalException.marshalException(e);
+    if (isStartElementOpen) {
+        outputStreamWrite(CLOSE_ELEMENT);
+        outputStreamWrite(CR);
+        isStartElementOpen = false;
     }


Input:
public boolean isItemValid(ItemStack stack) {
    if (isServer()) {
        RemoteStorageTileEntity storage = getRemoteStorage();
        int si = -1;
        if (storage != null) {
            si = storage.findRemoteIndex(getStorageID());
        }
        if (si != -1) {
            entityPlayer.getHeldItem(EnumHand.MAIN_HAND).getTagCompound().setInteger("String_Node_Str", storage.getMaxStacks(si));
            return storage.isItemValidForSlot(getSlotIndex(), stack);
        } else {
            entityPlayer.getHeldItem(EnumHand.MAIN_HAND).getTagCompound().setInteger("String_Node_Str", 0);
            return false;
        }
    } else {
        int maxSize = entityPlayer.getHeldItem(EnumHand.MAIN_HAND).getTagCompound().getInteger("String_Node_Str");
        if (getSlotIndex() >= maxSize) {
            return false;
        }
        return super.isItemValid(stack);
    }
}

Output:
             entityPlayer.getHeldItem(EnumHand.MAIN_HAND).getTagCompound().setInteger("String_Node_Str", storage.getMaxStacks(si));
-            return storage.isItemValidForSlot(getSlotIndex(), stack);
+            return true;
         } else {


Input:
public void startRPCServer() {
    if (!isRunning) {
        log.info("String_Node_Str");
        startServer();
        isRunning = true;
    }
}

Output:
 public void startRPCServer() {
-    if (!isRunning) {
-        log.info("String_Node_Str");
-        startServer();
-        isRunning = true;
+    synchronized (this) {
+        if (!isRunning) {
+            log.info("String_Node_Str");
+            server = new ThriftServer(listenAddr, listenPort);
+            server.start();
+            isRunning = true;
+        }
     }


Input:
protected void endPrefixMappings(Element elem) throws SAXException {
    NamedNodeMap attrs = elem.getAttributes();
    for (int i = 0; i < attrs.getLength(); i++) {
        Attr next = (Attr) attrs.item(i);
        String attrPrefix = next.getPrefix();
        if (attrPrefix != null && attrPrefix.equals(XMLConstants.XMLNS)) {
            getContentHandler().endPrefixMapping(next.getLocalName());
        } else if (attrPrefix == null) {
            String name = next.getLocalName();
            if (name == null) {
                name = next.getNodeName();
            }
            if (name != null) {
                getContentHandler().endPrefixMapping("String_Node_Str");
            }
        }
    }
}

Output:
     NamedNodeMap attrs = elem.getAttributes();
-    for (int i = 0; i < attrs.getLength(); i++) {
+    int numOfAtts = attrs.getLength();
+    for (int i = 0; i < numOfAtts; i++) {
         Attr next = (Attr) attrs.item(i);


Input:
private void updateConfigurationFromDialog() {
    this.exporterConfiguration.setSplitTracksByFlightMode(this.splitTrackByFlightCheckBox.isSelected());
    if (this.exportFormat.getSelectedIndex() > 0) {
        FormatItem item = (FormatItem) this.exportFormat.getSelectedItem();
        this.exporterConfiguration.setExportFormatType(ExportFormatFactory.ExportFormatType.valueOf(item.name));
    }
    this.readerConfiguration.setSamplesPerSecond(getSamplesPerSecond());
}

Output:
     this.exporterConfiguration.setSplitTracksByFlightMode(this.splitTrackByFlightCheckBox.isSelected());
-    if (this.exportFormat.getSelectedIndex() > 0) {
-        FormatItem item = (FormatItem) this.exportFormat.getSelectedItem();
-        this.exporterConfiguration.setExportFormatType(ExportFormatFactory.ExportFormatType.valueOf(item.name));
-    }
+    FormatItem item = (FormatItem) this.exportFormat.getSelectedItem();
+    this.exporterConfiguration.setExportFormatType(ExportFormatFactory.ExportFormatType.valueOf(item.name));
     this.readerConfiguration.setSamplesPerSecond(getSamplesPerSecond());


Input:
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    return capability == CAP ? (T) (inst) : null;
}

Output:
 public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
-    return capability == CAP ? (T) (inst) : null;
+    return capability == CAP ? CAP.<T>cast(inst) : null;
 }


Input:
protected static String clean(String id) {
    return id.replace("String_Node_Str", "String_Node_Str");
}

Output:
 protected static String clean(String id) {
-    return id.replace("String_Node_Str", "String_Node_Str");
+    return id == null ? null : id.replace("String_Node_Str", "String_Node_Str");
 }


Input:
private NbtType getNbtType(Object nms) {
    int type = (Byte) invokeMethod(NBT_GET_TYPE, nms);
    return NBT_ENUM.get(type);
}

Output:
 private NbtType getNbtType(Object nms) {
-    int type = (Byte) invokeMethod(NBT_GET_TYPE, nms);
+    int type = (int) invokeMethod(NBT_GET_TYPE, nms);
     return NBT_ENUM.get(type);


Input:
public boolean appendBulk(int opID, String key, ByteBuffer value) {
    if (!keyMap.containsKey(opID)) {
        registerKey(opID, key, MemoryManagerContext.BULK_MM_STEP_SIZE);
    }
    int step = keyMap.get(opID).get(key);
    int currentCount = keyMapCurrent.get(opID).get(key);
    if ((currentCount + 1) % step == 0) {
        flush(opID, key, value);
        keyMapCurrent.get(opID).put(key, currentCount + 1);
    } else {
        keyMapCurrent.get(opID).put(key, currentCount + 1);
        keyMapBuffers.get(opID).get(key).add(value);
        keyBufferSizes.get(opID).put(key, keyBufferSizes.get(opID).get(key) + value.limit());
    }
    return true;
}

Output:
 public boolean appendBulk(int opID, String key, ByteBuffer value) {
-    if (!keyMap.containsKey(opID)) {
+    if (value.position() != 0) {
+        value.flip();
+    }
+    if (!keyMap.get(opID).containsKey(key)) {
         registerKey(opID, key, MemoryManagerContext.BULK_MM_STEP_SIZE);


Input:
protected void populateInternalDataStructure(DataSet dataSet) {
    dataDeque.addAll(dataSet.getRows());
}

Output:
 protected void populateInternalDataStructure(DataSet dataSet) {
-    dataDeque.addAll(dataSet.getRows());
+    this.dataSet = dataSet;
 }


Input:
public void validate() {
    page.validate();
}

Output:
 public void validate() {
-    page.validate();
+    page.validatePage(false);
 }


Input:
protected void handleUpdateState(BooleanState state, Object arg) {
    state.visible = !(mKeyguard.isSecure() && mKeyguard.isShowing() && !mKeyguard.isTrusted());
    state.label = mContext.getString(R.string.quick_settings_cast_title);
    state.value = false;
    state.autoMirrorDrawable = false;
    final Set<CastDevice> devices = mController.getCastDevices();
    boolean connecting = false;
    for (CastDevice device : devices) {
        if (device.state == CastDevice.STATE_CONNECTED) {
            state.value = true;
            state.label = getDeviceName(device);
        } else if (device.state == CastDevice.STATE_CONNECTING) {
            connecting = true;
        }
    }
    if (!state.value && connecting) {
        state.label = mContext.getString(R.string.quick_settings_connecting);
    }
    state.icon = ResourceIcon.get(state.value ? R.drawable.ic_qs_cast_on : R.drawable.ic_qs_cast_off);
    mDetailAdapter.updateItems(devices);
}

Output:
 protected void handleUpdateState(BooleanState state, Object arg) {
-    state.visible = !(mKeyguard.isSecure() && mKeyguard.isShowing() && !mKeyguard.isTrusted());
+    state.visible = !mKeyguard.isSecure() || !mKeyguard.isShowing() || mKeyguard.canSkipBouncer();
     state.label = mContext.getString(R.string.quick_settings_cast_title);


Input:
public void testGetGroups_withAllParams() {
    responseHeaders.setContentType(MediaType.APPLICATION_JSON);
    mockServer.expect(requestTo("String_Node_Str")).andExpect(method(GET)).andRespond(withResponse(jsonResource("String_Node_Str"), responseHeaders));
    List<Group> groups = yammerTemplate.groupOperations().getGroups(1, 'A', GroupOperations.SORT_BY_PRIVACY, true);
    assertThat(groups.get(0).getFullName(), equalTo("String_Node_Str"));
}

Output:
 public void testGetGroups_withAllParams() {
-    responseHeaders.setContentType(MediaType.APPLICATION_JSON);
-    mockServer.expect(requestTo("String_Node_Str")).andExpect(method(GET)).andRespond(withResponse(jsonResource("String_Node_Str"), responseHeaders));
+    mockServer.expect(requestTo("String_Node_Str")).andExpect(method(GET)).andRespond(withSuccess(jsonResource("String_Node_Str"), APPLICATION_JSON));
     List<Group> groups = yammerTemplate.groupOperations().getGroups(1, 'A', GroupOperations.SORT_BY_PRIVACY, true);


Input:
public void changed(File changedFile) {
    synchronized (gfHandlers) {
        try {
            Map<String, String> props = getLoggingProperties();
            loggerReference = new Vector<Logger>();
            if (props == null)
                return;
            Set<String> keys = props.keySet();
            for (String a : keys) {
                if (a.endsWith("String_Node_Str")) {
                    String n = a.substring(0, a.lastIndexOf("String_Node_Str"));
                    Level l = Level.parse(props.get(a));
                    Logger appLogger = logMgr.getLogger(n);
                    if (appLogger != null) {
                        appLogger.setLevel(l);
                        loggerReference.add(appLogger);
                    } else if (gfHandlers.containsKey(n)) {
                        Handler h = (Handler) gfHandlers.get(n);
                        h.setLevel(l);
                    } else if (n.equals("String_Node_Str")) {
                        Logger logger = Logger.global.getParent();
                        Handler[] h = logger.getHandlers();
                        for (int i = 0; i < h.length; i++) {
                            String name = h[i].toString();
                            if (name.contains("String_Node_Str"))
                                h[i].setLevel(l);
                        }
                    }
                } else if (a.equals(SERVER_LOG_FILE_PROPERTY)) {
                    if (!props.get(a).equals(serverLogFileDetail)) {
                        PropertyChangeEvent pce = new PropertyChangeEvent(this, a, serverLogFileDetail, props.get(a));
                        UnprocessedChangeEvents ucel = new UnprocessedChangeEvents(new UnprocessedChangeEvent(pce, "String_Node_Str"));
                        List<UnprocessedChangeEvents> b = new ArrayList();
                        b.add(ucel);
                        ucl.unprocessedTransactedEvents(b);
                    }
                } else if (a.equals(HANDLER_PROPERTY)) {
                    if (!props.get(a).equals(handlerDetail)) {
                        generateAttributeChangeEvent(HANDLER_PROPERTY, handlerDetail, props);
                    }
                } else if (a.equals(CONSOLEHANDLER_FORMATTER_PROPERTY)) {
                    if (!props.get(a).equals(consoleHandlerFormatterDetail)) {
                        generateAttributeChangeEvent(CONSOLEHANDLER_FORMATTER_PROPERTY, consoleHandlerFormatterDetail, props);
                    }
                } else if (a.equals(GFFILEHANDLER_FORMATTER_PROPERTY)) {
                    if (!props.get(a).equals(gffileHandlerFormatterDetail)) {
                        generateAttributeChangeEvent(GFFILEHANDLER_FORMATTER_PROPERTY, gffileHandlerFormatterDetail, props);
                    }
                } else if (a.equals(ROTATIONTIMELIMITINMINUTES_PROPERTY)) {
                    if (!props.get(a).equals(rotationOnTimeLimitInMinutesDetail)) {
                        generateAttributeChangeEvent(ROTATIONTIMELIMITINMINUTES_PROPERTY, rotationOnTimeLimitInMinutesDetail, props);
                    }
                } else if (a.equals(FLUSHFREQUENCY_PROPERTY)) {
                    if (!props.get(a).equals(flushFrequencyDetail)) {
                        generateAttributeChangeEvent(FLUSHFREQUENCY_PROPERTY, flushFrequencyDetail, props);
                    }
                } else if (a.equals(FILEHANDLER_LIMIT_PROPERTY)) {
                    if (!props.get(a).equals(filterHandlerDetails)) {
                        generateAttributeChangeEvent(FILEHANDLER_LIMIT_PROPERTY, filterHandlerDetails, props);
                    }
                } else if (a.equals(LOGTOCONSOLE_PROPERTY)) {
                    if (!props.get(a).equals(logToConsoleDetail)) {
                        generateAttributeChangeEvent(LOGTOCONSOLE_PROPERTY, logToConsoleDetail, props);
                    }
                } else if (a.equals(ROTATIONLIMITINBYTES_PROPERTY)) {
                    if (!props.get(a).equals(rotationInTimeLimitInBytesDetail)) {
                        generateAttributeChangeEvent(ROTATIONLIMITINBYTES_PROPERTY, rotationInTimeLimitInBytesDetail, props);
                    }
                } else if (a.equals(USESYSTEMLOGGING_PROPERTY)) {
                    if (!props.get(a).equals(useSystemLoggingDetail)) {
                        generateAttributeChangeEvent(USESYSTEMLOGGING_PROPERTY, useSystemLoggingDetail, props);
                    }
                } else if (a.equals(FILEHANDLER_COUNT_PROPERTY)) {
                    if (!props.get(a).equals(fileHandlerCountDetail)) {
                        generateAttributeChangeEvent(FILEHANDLER_COUNT_PROPERTY, fileHandlerCountDetail, props);
                    }
                } else if (a.equals(RETAINERRORSSTATICTICS_PROPERTY)) {
                    if (!props.get(a).equals(retainErrorsStaticticsDetail)) {
                        generateAttributeChangeEvent(RETAINERRORSSTATICTICS_PROPERTY, retainErrorsStaticticsDetail, props);
                    }
                } else if (a.equals(LOG4J_VERSION_PROPERTY)) {
                    if (!props.get(a).equals(log4jVersionDetail)) {
                        generateAttributeChangeEvent(LOG4J_VERSION_PROPERTY, log4jVersionDetail, props);
                    }
                } else if (a.equals(MAXHISTORY_FILES_PROPERTY)) {
                    if (!props.get(a).equals(maxHistoryFilesDetail)) {
                        generateAttributeChangeEvent(MAXHISTORY_FILES_PROPERTY, maxHistoryFilesDetail, props);
                    }
                } else if (a.equals(ROTATIONONDATECHANGE_PROPERTY)) {
                    if (!props.get(a).equals(rotationOnDateChangeDetail)) {
                        generateAttributeChangeEvent(ROTATIONONDATECHANGE_PROPERTY, rotationOnDateChangeDetail, props);
                    }
                } else if (a.equals(FILEHANDLER_PATTERN_PROPERTY)) {
                    if (!props.get(a).equals(fileHandlerPatternDetail)) {
                        generateAttributeChangeEvent(FILEHANDLER_PATTERN_PROPERTY, fileHandlerPatternDetail, props);
                    }
                } else if (a.equals(FILEHANDLER_FORMATTER_PROPERTY)) {
                    if (!props.get(a).equals(fileHandlerFormatterDetail)) {
                        generateAttributeChangeEvent(FILEHANDLER_FORMATTER_PROPERTY, fileHandlerFormatterDetail, props);
                    }
                } else if (a.equals(LOGFORMAT_DATEFORMAT_PROPERTY)) {
                    if (!props.get(a).equals(logFormatDateFormatDetail)) {
                        generateAttributeChangeEvent(LOGFORMAT_DATEFORMAT_PROPERTY, logFormatDateFormatDetail, props);
                    }
                }
            }
            logger.log(Level.INFO, "String_Node_Str");
        } catch (Exception e) {
            logger.log(Level.SEVERE, "String_Node_Str", e);
        }
    }
}

Output:
                 return;
-            Set<String> keys = props.keySet();
-            for (String a : keys) {
+            for (Map.Entry<String, String> entry : props.entrySet()) {
+                String a = entry.getKey();
+                String val = entry.getValue();
                 if (a.endsWith("String_Node_Str")) {


Input:
public void onNewLine(String line) {
    if (libcFingerprint == null) {
        if (!line.contains("String_Node_Str")) {
            return;
        }
        libcFingerprint = line.substring(0, line.indexOf(':' + 1));
    } else if (!line.startsWith(libcFingerprint)) {
        return;
    }
    super.onNewLine(line);
}

Output:
         }
-        libcFingerprint = line.substring(0, line.indexOf(':' + 1));
+        libcFingerprint = line.substring(0, line.indexOf(':') + 1);
     } else if (!line.startsWith(libcFingerprint)) {


Input:
public void onTouchModeChanged(boolean isInTouchMode) {
    if (isInTouchMode) {
        hideSelector();
        if (getHeight() > 0 && getChildCount() > 0) {
            layoutChildren();
        }
    } else {
        int touchMode = mTouchMode;
        if (touchMode == TOUCH_MODE_OVERSCROLL || touchMode == TOUCH_MODE_OVERFLING) {
            if (mFlingRunnable != null) {
                mFlingRunnable.endFling();
                if (mScrollY != 0) {
                    mScrollY = 0;
                    invalidate();
                }
            }
        }
    }
    mLastTouchMode = isInTouchMode ? TOUCH_MODE_ON : TOUCH_MODE_OFF;
}

Output:
                 mFlingRunnable.endFling();
-                if (mScrollY != 0) {
-                    mScrollY = 0;
-                    invalidate();
-                }
+            }
+            if (mScrollY != 0) {
+                mScrollY = 0;
+                invalidate();
             }


Input:
public String viewFreightList() {
    List<Orders> fclOrders = new ArrayList<Orders>();
    if (originCity != null && destinationCity != null) {
        fclOrders = operationsService.findOrdersByOriginDestinationFCL(originCity, destinationCity);
    } else {
        fclOrders = operationsService.findOrdersByFCL();
    }
    for (Orders orderElem : fclOrders) {
        fclTable.add(transformToOrderFormBean(orderElem));
    }
    List<Orders> lclOrders = new ArrayList<Orders>();
    if (originCity != null && destinationCity != null) {
        lclOrders = operationsService.findOrdersByOriginDestinationLCL(originCity, destinationCity);
    } else {
        lclOrders = operationsService.findOrdersByLCL();
    }
    for (Orders orderElem : lclOrders) {
        lclTable.add(transformToOrderFormBean(orderElem));
    }
    List<Orders> lcuOrders = new ArrayList<Orders>();
    if (originCity != null && destinationCity != null) {
        lcuOrders = operationsService.findOrdersByOriginDestinationLCU(originCity, destinationCity);
    } else {
        lcuOrders = operationsService.findOrdersByLCU();
    }
    for (Orders orderElem : lcuOrders) {
        lcuTable.add(transformToOrderFormBean(orderElem));
    }
    List<Orders> rcuOrders = new ArrayList<Orders>();
    if (originCity != null && destinationCity != null) {
        rcuOrders = operationsService.findOrdersByOriginDestinationRCU(originCity, destinationCity);
    } else {
        rcuOrders = operationsService.findOrdersByRCU();
    }
    for (Orders orderElem : rcuOrders) {
        rcuTable.add(transformToOrderFormBean(orderElem));
    }
    List<Orders> fclTrucksOrders = new ArrayList<Orders>();
    if (originCityTruck != null) {
        fclTrucksOrders = operationsService.findOrdersByFCLTrucksOrigin(originCityTruck);
    } else {
        fclTrucksOrders = operationsService.findOrdersByFCLTrucks();
    }
    for (Orders orderElem : fclTrucksOrders) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            fclTruckTable.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> lclTrucksOrders = new ArrayList<Orders>();
    if (originCityTruck != null) {
        lclTrucksOrders = operationsService.findOrdersByLCLTrucksOrigin(originCityTruck);
    } else {
        lclTrucksOrders = operationsService.findOrdersByLCLTrucks();
    }
    for (Orders orderElem : lclTrucksOrders) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            lclTruckTable.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> lcuTrucksOrders = new ArrayList<Orders>();
    if (originCityTruck != null) {
        lcuTrucksOrders = operationsService.findOrdersByLCUTrucksOrigin(originCityTruck);
    } else {
        lcuTrucksOrders = operationsService.findOrdersByLCUTrucks();
    }
    for (Orders orderElem : lcuTrucksOrders) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            lcuTruckTable.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> rcuTrucksOrders = new ArrayList<Orders>();
    if (originCityTruck != null) {
        rcuTrucksOrders = operationsService.findOrdersByRCUTrucksOrigin(originCityTruck);
    } else {
        rcuTrucksOrders = operationsService.findOrdersByRCUTrucks();
    }
    for (Orders orderElem : rcuTrucksOrders) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            rcuTruckTable.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> ftlOrders = new ArrayList<Orders>();
    System.out.println("String_Node_Str" + originCityTruck);
    if (originCityTruck != null) {
        ftlOrders = operationsService.findOrdersByOriginFTL(originCityTruck);
    } else {
        ftlOrders = operationsService.findOrdersByFTL();
    }
    for (Orders orderElem : ftlOrders) {
        ftlTable.add(transformToOrderFormBean(orderElem));
    }
    List<Orders> ltlOrders = new ArrayList<Orders>();
    if (originCityTruck != null) {
        ltlOrders = operationsService.findOrdersByOriginLTL(originCityTruck);
    } else {
        ltlOrders = operationsService.findOrdersByLTL();
    }
    for (Orders orderElem : ltlOrders) {
        ltlTable.add(transformToOrderFormBean(orderElem));
    }
    List<Orders> fclTrucksOrdersDes = new ArrayList<Orders>();
    if (destinationCityTruck != null) {
        fclTrucksOrdersDes = operationsService.findOrdersByFCLTrucksDestination(destinationCityTruck);
    } else {
        fclTrucksOrdersDes = operationsService.findOrdersByFCLTrucks();
    }
    for (Orders orderElem : fclTrucksOrdersDes) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            fclTruckTableDes.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> lclTrucksOrdersDes = new ArrayList<Orders>();
    if (destinationCityTruck != null) {
        lclTrucksOrdersDes = operationsService.findOrdersByLCLTrucksDestination(destinationCityTruck);
    } else {
        lclTrucksOrdersDes = operationsService.findOrdersByLCLTrucks();
    }
    for (Orders orderElem : lclTrucksOrdersDes) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            lclTruckTableDes.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> lcuTrucksOrdersDes = new ArrayList<Orders>();
    if (destinationCityTruck != null) {
        lcuTrucksOrdersDes = operationsService.findOrdersByLCUTrucksDestination(destinationCityTruck);
    } else {
        lcuTrucksOrdersDes = operationsService.findOrdersByLCUTrucks();
    }
    for (Orders orderElem : lcuTrucksOrdersDes) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            lcuTruckTableDes.add(transformToOrderFormBean(orderElem));
        }
    }
    List<Orders> rcuTrucksOrdersDes = new ArrayList<Orders>();
    if (destinationCityTruck != null) {
        rcuTrucksOrdersDes = operationsService.findOrdersByRCUTrucksDestination(destinationCityTruck);
    } else {
        rcuTrucksOrdersDes = operationsService.findOrdersByRCUTrucks();
    }
    for (Orders orderElem : rcuTrucksOrdersDes) {
        if (orderElem.getServiceMode().equals("String_Node_Str") || orderElem.getServiceMode().equals("String_Node_Str")) {
            rcuTruckTableDes.add(transformToOrderFormBean(orderElem));
        }
    }
    List<VesselSchedules> vesselSchedulesList = operationsService.findAllVesselSchedule();
    if (vesselSchedulesList != null) {
        for (VesselSchedules vesselScheduleElem : vesselSchedulesList) {
            vesselSchedules.add(transformToFormBeanVesselSchedule(vesselScheduleElem));
        }
    }
    return SUCCESS;
}

Output:
     List<Orders> fclOrders = new ArrayList<Orders>();
-    if (originCity != null && destinationCity != null) {
-        fclOrders = operationsService.findOrdersByOriginDestinationFCL(originCity, destinationCity);
+    if (StringUtils.isNotBlank(column)) {
+        if (originCity != null && destinationCity != null) {
+            fclOrders = operationsService.findOrdersByOriginDestinationFCL(originCity, destinationCity);
+        }
+        fclOrders = orderService.findOrdersByBookingNumber(column, order.getOrderKeyword(), getClientId());
     } else {


Input:
public void processResult(Request request, List<ResultFile> resultFiles) {
    File resultsDir = new File(outputDirectory, String.valueOf(request.getId()));
    if (!resultsDir.mkdir()) {
        throw new RuntimeException("String_Node_Str" + resultsDir.getAbsolutePath());
    }
    try {
        for (ResultFile resultFile : resultFiles) {
            writeFile(resultsDir, resultFile);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Output:
     File resultsDir = new File(outputDirectory, String.valueOf(request.getId()));
-    if (!resultsDir.mkdir()) {
+    if (!resultsDir.mkdirs()) {
         throw new RuntimeException("String_Node_Str" + resultsDir.getAbsolutePath());


Input:
private BuildRule generateDebugLauncherRule() {
    BuildRuleParams debugParams = params.copyWithChanges(addDebugFlavor(params.getBuildTarget()), Suppliers.ofInstance(ImmutableSortedSet.of()), Suppliers.ofInstance(ImmutableSortedSet.of()));
    OcamlDebugLauncher debugLauncher = new OcamlDebugLauncher(debugParams, pathResolver, new OcamlDebugLauncherStep.Args(ocamlContext.getOcamlDebug().get(), ocamlContext.getBytecodeOutput(), ocamlContext.getOcamlInput(), ocamlContext.getBytecodeIncludeFlags()));
    resolver.addToIndex(debugLauncher);
    return debugLauncher;
}

Output:
     BuildRuleParams debugParams = params.copyWithChanges(addDebugFlavor(params.getBuildTarget()), Suppliers.ofInstance(ImmutableSortedSet.of()), Suppliers.ofInstance(ImmutableSortedSet.of()));
-    OcamlDebugLauncher debugLauncher = new OcamlDebugLauncher(debugParams, pathResolver, new OcamlDebugLauncherStep.Args(ocamlContext.getOcamlDebug().get(), ocamlContext.getBytecodeOutput(), ocamlContext.getOcamlInput(), ocamlContext.getBytecodeIncludeFlags()));
+    OcamlDebugLauncher debugLauncher = new OcamlDebugLauncher(debugParams, new OcamlDebugLauncherStep.Args(ocamlContext.getOcamlDebug().get(), ocamlContext.getBytecodeOutput(), ocamlContext.getOcamlInput(), ocamlContext.getBytecodeIncludeFlags()));
     resolver.addToIndex(debugLauncher);


Input:
private void optionRandomize(RandomizeNetworkDialog dialog) {
    Randomizer r = null;
    switch(dialog.getType().getSelectedIndex()) {
        case 0:
            r = new RangeRandomizer(dialog.getLow().getValue(), dialog.getHigh().getValue());
            break;
        case 1:
            r = new NguyenWidrowRandomizer(dialog.getLow().getValue(), dialog.getHigh().getValue());
            break;
        case 2:
            r = new FanInRandomizer(dialog.getLow().getValue(), dialog.getHigh().getValue(), false);
            break;
    }
    if (r != null) {
        r.randomize((BasicNetwork) this.method);
        setDirty(true);
    }
}

Output:
     Randomizer r = null;
-    switch(dialog.getType().getSelectedIndex()) {
+    switch(dialog.getTheType().getSelectedIndex()) {
         case 0:


Input:
protected void configureDisplay(CellTable<Notification> display) {
    fromUser = new TextColumn<Notification>() {
        public String getValue(Notification notification) {
            return notification != null ? notification.getFromUser() : null;
        }
    };
    recipientUsers = new TextColumn<Notification>() {
        public String getValue(Notification notification) {
            return notification != null ? StringUtils.prettyPrint(notification.getRecipientUsers()) : null;
        }
    };
    sentOn = new Column<Notification, Date>(new DateCell(DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_MEDIUM))) {

        public Date getValue(Notification notification) {
            return notification != null ? notification.getSentOn() : null;
        }
    };
    subject = new TextColumn<Notification>() {
        public String getValue(Notification notification) {
            return notification != null ? notification.getSubject() : null;
        }
    };
    acknowledged = new Column<Notification, SafeHtml>(new SafeHtmlCell()) {
        public SafeHtml getValue(Notification notification) {
            SafeHtml ret = null;
            if (notification != null) {
                if (notification.isAcknowledged()) {
                    ret = SafeHtmlUtils.fromSafeConstant("String_Node_Str" + messages.showMessageAcknowledged() + "String_Node_Str");
                } else {
                    ret = SafeHtmlUtils.fromSafeConstant("String_Node_Str" + messages.showMessageNotAcknowledged() + "String_Node_Str");
                }
            }
            return ret;
        }
    };
    state = new Column<Notification, SafeHtml>(new SafeHtmlCell()) {
        public SafeHtml getValue(Notification notification) {
            SafeHtml ret = null;
            if (notification != null) {
                ret = HtmlSnippetUtils.getNotificationStateHTML(notification.getState());
            }
            return ret;
        }
    };
    fromUser.setSortable(true);
    sentOn.setSortable(true);
    subject.setSortable(true);
    acknowledged.setSortable(true);
    state.setSortable(true);
    addColumn(fromUser, messages.notificationFrom(), true, false);
    addColumn(recipientUsers, messages.notificationTo(), true, false);
    addColumn(sentOn, messages.notificationSentOn(), true, false, 13);
    addColumn(subject, messages.notificationSubject(), true, false);
    addColumn(state, messages.notificationState(), true, false, 7);
    addColumn(acknowledged, messages.notificationAck(), true, false, 7);
    display.getColumnSortList().push(new ColumnSortInfo(sentOn, false));
    addStyleName("String_Node_Str");
}

Output:
     };
-    sentOn = new Column<Notification, Date>(new DateCell(DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_MEDIUM))) {
+    sentOn = new Column<Notification, Date>(new DateCell(DateTimeFormat.getFormat(RodaConstants.DEFAULT_DATETIME_FORMAT))) {


Input:
public String toString() {
    return "String_Node_Str" + getJmxUri() + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + getJmxUri() + "String_Node_Str";
+    return "String_Node_Str" + (getManagementContext() != null && getManagementContext().isRunning() ? getJmxUri() : "String_Node_Str") + "String_Node_Str";
 }


Input:
public static boolean hasSameNameButDifferentCase(FileName fileName) {
    return !fileName.getResourceLabel().equals(fileName.getLastVersionProperty().getLabel()) && fileName.getResourceLabel().equalsIgnoreCase(fileName.getLastVersionProperty().getLabel());
}

Output:
 public static boolean hasSameNameButDifferentCase(FileName fileName) {
-    return !fileName.getResourceLabel().equals(fileName.getLastVersionProperty().getLabel()) && fileName.getResourceLabel().equalsIgnoreCase(fileName.getLastVersionProperty().getLabel());
+    return !fileName.getResourceLabel().equals(fileName.getLastVersionProperty().getLabel().replace('#', '$')) && fileName.getResourceLabel().equalsIgnoreCase(fileName.getLastVersionProperty().getLabel().replace('#', '$'));
 }


Input:
public Partner save(Partner partner) {
    try {
        if (partner.getId() == null) {
            return super.save(partner);
        }
        if (!partner.getIsContact()) {
            List<AccountingSituation> accountingSituationList = Beans.get(AccountingSituationService.class).createAccountingSituation(Beans.get(PartnerRepository.class).find(partner.getId()));
            if (accountingSituationList != null) {
                partner.setAccountingSituationList(accountingSituationList);
            }
        }
        return super.save(partner);
    } catch (Exception e) {
        throw new PersistenceException(e.getLocalizedMessage());
    }
}

Output:
         }
-        if (!partner.getIsContact()) {
+        if (!partner.getIsContact() && appService.isApp("String_Node_Str")) {
             List<AccountingSituation> accountingSituationList = Beans.get(AccountingSituationService.class).createAccountingSituation(Beans.get(PartnerRepository.class).find(partner.getId()));


Input:
private void addRepositoryTreeViewer(Composite leftComposite) {
    GridData gridData = new GridData(GridData.FILL_BOTH);
    gridData.widthHint = 210;
    leftComposite.setLayoutData(gridData);
    RepositoryViewerProvider provider = RepositoryViewerProvider.ALL_CHECKBOX;
    treeViewer = (CheckboxRepositoryTreeViewer) provider.createViewer(leftComposite);
    IProjectRepositoryNode projectRepositoryNode = provider.getProjectRepositoryNode();
    processItems(versionObjects, (RepositoryNode) projectRepositoryNode);
    treeViewer.addFilter(new ViewerFilter() {
        public boolean select(Viewer viewer, Object parentElement, Object element) {
            RepositoryNode node = (RepositoryNode) element;
            return filterRepositoryNode(node);
        }
    });
    treeViewer.addCheckStateListener(new ICheckStateListener() {
        public void checkStateChanged(CheckStateChangedEvent event) {
            RepositoryNode node = (RepositoryNode) event.getElement();
            List<ItemVersionObject> objects = new ArrayList<ItemVersionObject>();
            processItems(objects, node);
            if (!objects.isEmpty()) {
                if (event.getChecked()) {
                    checkedObjects.addAll(objects);
                } else {
                    checkedObjects.removeAll(objects);
                    removeItemElements(objects);
                }
                researchMaxVersion();
                refreshTableItems();
            }
        }
    });
    treeViewer.addTreeListener(new ITreeViewerListener() {
        public void treeCollapsed(TreeExpansionEvent event) {
        }
        public void treeExpanded(TreeExpansionEvent event) {
            refreshCheckedTreeView();
        }
    });
    expandSomeNodes(projectRepositoryNode);
}

Output:
     leftComposite.setLayoutData(gridData);
-    RepositoryViewerProvider provider = RepositoryViewerProvider.ALL_CHECKBOX;
+    RepositoryViewerProvider provider = RepoCommonViewerProvider.CHECKBOX;
     treeViewer = (CheckboxRepositoryTreeViewer) provider.createViewer(leftComposite);


Input:
public static void reportCapabilityStatus(String name, int status) {
    if (logger.isDebugEnabled()) {
        CapabilityReport capability = getCapabilityReport(name);
        capability.status = translate(status);
    }
}

Output:
 public static void reportCapabilityStatus(String name, int status) {
-    if (logger.isDebugEnabled()) {
+    if (LOGGER.isDebugEnabled()) {
         CapabilityReport capability = getCapabilityReport(name);


Input:
private static void NewDate(Calendar n) {
    nowDate = n;
    if (fw != null) {
        try {
            fw.close();
            out.close();
        } catch (IOException e) {
            System.err.println("String_Node_Str");
        }
    }
    try {
        fw = new FileWriter(path + "String_Node_Str" + logformat.format(nowDate.getTime()) + "String_Node_Str", append);
    } catch (IOException e) {
        System.err.println("String_Node_Str" + path + "String_Node_Str");
        path = "String_Node_Str";
        try {
            fw = new FileWriter(path + "String_Node_Str" + logformat.format(nowDate.getTime()) + "String_Node_Str", append);
        } catch (IOException e1) {
            System.err.println("String_Node_Str");
            System.exit(1);
        }
    }
    out = new BufferedWriter(fw);
}

Output:
     try {
-        fw = new FileWriter(path + "String_Node_Str" + logformat.format(nowDate.getTime()) + "String_Node_Str", append);
+        file = "String_Node_Str" + logformat.format(nowDate.getTime()) + "String_Node_Str";
+        fw = new FileWriter(path + file, append);
     } catch (IOException e) {