Input:
public static List<ElementParameter> getParametersFromForm(IElement element, EComponentCategory category, ComponentProperties compProperties, String parentPropertiesPath, Form form, Widget parentWidget, AtomicInteger lastRowNum) {
    List<ElementParameter> elementParameters = new ArrayList<>();
    EComponentCategory compCategory = category;
    if (compCategory == null) {
        compCategory = EComponentCategory.BASIC;
    }
    AtomicInteger lastRN = lastRowNum;
    if (lastRN == null) {
        lastRN = new AtomicInteger();
    }
    if (form == null) {
        return elementParameters;
    }
    ComponentProperties componentProperties = compProperties;
    if (componentProperties == null) {
        componentProperties = (ComponentProperties) form.getProperties();
    }
    if (element instanceof INode) {
        INode node = (INode) element;
        if (node.getComponentProperties() == null) {
            node.setComponentProperties(componentProperties);
        }
    }
    componentProperties.setValueEvaluator(null);
    List<Widget> formWidgets = form.getWidgets();
    for (Widget widget : formWidgets) {
        NamedThing widgetProperty = widget.getContent();
        String propertiesPath = getPropertiesPath(parentPropertiesPath, null);
        if (widgetProperty instanceof Form) {
            Form subForm = (Form) widgetProperty;
            ComponentProperties subProperties = (ComponentProperties) subForm.getProperties();
            if (!isSameComponentProperties(componentProperties, widgetProperty)) {
                propertiesPath = getPropertiesPath(parentPropertiesPath, subProperties.getName());
            }
            elementParameters.addAll(getParametersFromForm(element, compCategory, subProperties, propertiesPath, subForm, widget, lastRN));
            continue;
        }
        GenericElementParameter param = new GenericElementParameter(element, componentProperties, form, widget, getComponentService());
        String parameterName = propertiesPath.concat(param.getName());
        param.setName(parameterName);
        param.setCategory(compCategory);
        param.setShow(parentWidget == null ? widget.isVisible() : parentWidget.isVisible() && widget.isVisible());
        int rowNum = 0;
        if (widget.getOrder() != 1) {
            rowNum = lastRN.get();
        } else {
            rowNum = widget.getRow();
            if (parentWidget != null) {
                rowNum += parentWidget.getRow();
            }
            rowNum = rowNum + lastRN.get();
        }
        param.setNumRow(rowNum);
        lastRN.set(rowNum);
        EParameterFieldType fieldType = getFieldType(widget, widgetProperty);
        param.setFieldType(fieldType != null ? fieldType : EParameterFieldType.TEXT);
        if (widgetProperty instanceof PresentationItem) {
            param.setValue(widgetProperty.getDisplayName());
        } else {
            Property property = (Property) widgetProperty;
            param.setRequired(property.isRequired());
            param.setDefaultValue(property.getDefaultValue());
            param.setValue(property.getValue());
            param.setSupportContext(isSupportContext(property));
            param.setContext(EConnectionType.FLOW_MAIN.getName());
            List<?> values = property.getPossibleValues();
            if (values != null) {
                param.setPossibleValues(values);
                List<String> possVals = new ArrayList<>();
                List<String> possValsDisplay = new ArrayList<>();
                for (Object obj : values) {
                    if (obj instanceof NamedThing) {
                        NamedThing nal = (NamedThing) obj;
                        possVals.add(nal.getName());
                        possValsDisplay.add(nal.getDisplayName());
                    } else {
                        possVals.add(String.valueOf(obj));
                        possValsDisplay.add(String.valueOf(obj));
                    }
                }
                param.setListItemsDisplayName(possValsDisplay.toArray(new String[0]));
                param.setListItemsDisplayCodeName(possValsDisplay.toArray(new String[0]));
                param.setListItemsValue(possVals.toArray(new String[0]));
            }
        }
        param.setReadOnly(false);
        param.setSerialized(true);
        if (EParameterFieldType.SCHEMA_TYPE.equals(param.getFieldType())) {
            String propertyName = componentProperties.getName();
        }
        elementParameters.add(param);
    }
    return elementParameters;
}

Output:
             param.setRequired(property.isRequired());
-            param.setDefaultValue(property.getDefaultValue());
-            param.setValue(property.getValue());
+            if (property.getValue() != null) {
+                param.setValue(property.getValue());
+            } else {
+                if (property.getDefaultValue() != null) {
+                    if (SchemaElement.Type.STRING.equals(property.getType())) {
+                        param.setValue(TalendQuoteUtils.addQuotesIfNotExist(property.getDefaultValue()));
+                    } else {
+                        param.setValue(property.getDefaultValue());
+                    }
+                }
+            }
             param.setSupportContext(isSupportContext(property));


Input:
public void checkUtxoTimeLock(List<UtxoOutput> outputList) {
    long currentTime = TimeService.currentTimeMillis();
    long genesisTime = NulsContext.getInstance().getGenesisBlock().getHeader().getTime();
    long bestHeight = NulsContext.getInstance().getNetBestBlockHeight();
    for (UtxoOutput output : outputList) {
        if (output.isLocked()) {
            if (output.getLockTime() >= genesisTime && output.getLockTime() <= currentTime) {
                if (OutPutStatusEnum.UTXO_CONFIRM_TIME_LOCK.equals(output.getStatus())) {
                    output.setStatus(OutPutStatusEnum.UTXO_CONFIRM_UNSPEND);
                } else if (OutPutStatusEnum.UTXO_UNCONFIRM_TIME_LOCK.equals(output.getStatus())) {
                    output.setStatus(OutPutStatusEnum.UTXO_UNCONFIRM_UNSPEND);
                }
            } else if (output.getLockTime() < genesisTime && output.getLockTime() >= bestHeight) {
                if (OutPutStatusEnum.UTXO_CONFIRM_TIME_LOCK.equals(output.getStatus())) {
                    output.setStatus(OutPutStatusEnum.UTXO_CONFIRM_UNSPEND);
                } else if (OutPutStatusEnum.UTXO_UNCONFIRM_TIME_LOCK.equals(output.getStatus())) {
                    output.setStatus(OutPutStatusEnum.UTXO_UNCONFIRM_UNSPEND);
                }
            }
        }
    }
}

Output:
             if (output.getLockTime() >= genesisTime && output.getLockTime() <= currentTime) {
-                if (OutPutStatusEnum.UTXO_CONFIRM_TIME_LOCK.equals(output.getStatus())) {
-                    output.setStatus(OutPutStatusEnum.UTXO_CONFIRM_UNSPEND);
-                } else if (OutPutStatusEnum.UTXO_UNCONFIRM_TIME_LOCK.equals(output.getStatus())) {
-                    output.setStatus(OutPutStatusEnum.UTXO_UNCONFIRM_UNSPEND);
+                if (OutPutStatusEnum.UTXO_CONFIRMED_TIME_LOCK.equals(output.getStatus())) {
+                    output.setStatus(OutPutStatusEnum.UTXO_CONFIRMED_UNSPENT);
+                } else if (OutPutStatusEnum.UTXO_UNCONFIRMED_TIME_LOCK.equals(output.getStatus())) {
+                    output.setStatus(OutPutStatusEnum.UTXO_UNCONFIRMED_UNSPENT);
                 }


Input:
public PageWriteTrx<Long, Record, UnorderedKeyValuePage> createPageWriteTrx(final XdmResourceManager resourceManager, final UberPage uberPage, final Writer writer, final long trxId, final int representRev, final int lastStoredRev, final int lastCommitedRev, final BufferManager bufferManager) {
    final boolean usePathSummary = resourceManager.getResourceConfig().mPathSummary;
    final IndexController indexController = resourceManager.getWtxIndexController(representRev);
    final Path indexes = resourceManager.getResourceConfig().mPath.resolve(ResourceConfiguration.ResourcePaths.INDEXES.getFile()).resolve(String.valueOf(lastStoredRev) + "String_Node_Str");
    if (Files.exists(indexes)) {
        try (final InputStream in = new FileInputStream(indexes.toFile())) {
            indexController.getIndexes().init(IndexController.deserialize(in).getFirstChild());
        } catch (IOException | DocumentException | SirixException e) {
            throw new SirixIOException("String_Node_Str", e);
        }
    }
    final TreeModifierImpl treeModifier = new TreeModifierImpl();
    final TransactionIntentLogFactory logFactory = new TransactionIntentLogFactoryImpl();
    final TransactionIntentLog log = logFactory.createTrxIntentLog(resourceManager.getResourceConfig());
    if (uberPage.isBootstrap()) {
        uberPage.createRevisionTree(log);
    }
    final PageReadTrxImpl pageRtx = new PageReadTrxImpl(trxId, resourceManager, uberPage, representRev, writer, log, indexController, bufferManager);
    final RevisionRootPage lastCommitedRoot = pageRtx.loadRevRoot(lastCommitedRev);
    final RevisionRootPage newRevisionRootPage = treeModifier.preparePreviousRevisionRootPage(uberPage, pageRtx, log, representRev, lastStoredRev);
    newRevisionRootPage.setMaxNodeKey(lastCommitedRoot.getMaxNodeKey());
    newRevisionRootPage.createNodeTree(pageRtx, log);
    if (usePathSummary) {
        final PathSummaryPage page = pageRtx.getPathSummaryPage(newRevisionRootPage);
        page.createPathSummaryTree(pageRtx, 0, log);
        if (PageContainer.emptyInstance().equals(log.get(newRevisionRootPage.getPathSummaryPageReference(), pageRtx)))
            log.put(newRevisionRootPage.getPathSummaryPageReference(), new PageContainer(page, page));
    }
    if (!uberPage.isBootstrap()) {
        if (PageContainer.emptyInstance().equals(log.get(newRevisionRootPage.getNamePageReference(), pageRtx))) {
            final Page namePage = pageRtx.getNamePage(newRevisionRootPage);
            log.put(newRevisionRootPage.getNamePageReference(), new PageContainer(namePage, namePage));
        }
        if (PageContainer.emptyInstance().equals(log.get(newRevisionRootPage.getCASPageReference(), pageRtx))) {
            final Page casPage = pageRtx.getCASPage(newRevisionRootPage);
            log.put(newRevisionRootPage.getCASPageReference(), new PageContainer(casPage, casPage));
        }
        if (PageContainer.emptyInstance().equals(log.get(newRevisionRootPage.getPathPageReference(), pageRtx))) {
            final Page pathPage = pageRtx.getPathPage(newRevisionRootPage);
            log.put(newRevisionRootPage.getPathPageReference(), new PageContainer(pathPage, pathPage));
        }
        final Page indirectPage = pageRtx.dereferenceIndirectPageReference(newRevisionRootPage.getIndirectPageReference());
        log.put(newRevisionRootPage.getIndirectPageReference(), new PageContainer(indirectPage, indirectPage));
        final PageReference revisionRootPageReference = treeModifier.prepareLeafOfTree(pageRtx, log, uberPage.getPageCountExp(PageKind.UBERPAGE), uberPage.getIndirectPageReference(), uberPage.getRevisionNumber(), -1, PageKind.UBERPAGE);
        log.put(revisionRootPageReference, new PageContainer(newRevisionRootPage, newRevisionRootPage));
    }
    return new PageWriteTrxImpl(treeModifier, writer, log, newRevisionRootPage, pageRtx, indexController);
}

Output:
     final IndexController indexController = resourceManager.getWtxIndexController(representRev);
-    final Path indexes = resourceManager.getResourceConfig().mPath.resolve(ResourceConfiguration.ResourcePaths.INDEXES.getFile()).resolve(String.valueOf(lastStoredRev) + "String_Node_Str");
+    final Path indexes = resourceManager.getResourceConfig().mPath.resolve(ResourceConfiguration.ResourcePaths.INDEXES.getPath()).resolve(String.valueOf(lastStoredRev) + "String_Node_Str");
     if (Files.exists(indexes)) {


Input:
private void _showInDefaultEditor() {
    boolean modified = isModified();
    setModified(false);
    close();
    try {
        CompositeEntity currentModel = (CompositeEntity) getModel();
        CompositeEntity model = (CompositeEntity) GTTools.cleanupModel(currentModel);
        currentModel.workspace().remove(currentModel);
        Tableau tableau = getFrameController().getConfiguration().openModel(model);
        ((Effigy) tableau.getContainer()).uri.setURI(null);
        String name = model.getName();
        if (name.equals("String_Node_Str")) {
            name = "String_Node_Str";
        }
        tableau.setTitle(name);
        Frame frame = tableau.getFrame();
        if (modified && (frame instanceof TableauFrame)) {
            ((TableauFrame) tableau.getFrame()).setModified(true);
        }
    } catch (Exception e) {
        MessageHandler.error("String_Node_Str" + "String_Node_Str", e);
    }
}

Output:
         CompositeEntity currentModel = (CompositeEntity) getModel();
-        CompositeEntity model = (CompositeEntity) GTTools.cleanupModel(currentModel);
-        currentModel.workspace().remove(currentModel);
+        Workspace workspace = currentModel.workspace();
+        CompositeEntity model = (CompositeEntity) GTTools.cleanupModel(currentModel, workspace);
+        workspace.remove(currentModel);
         Tableau tableau = getFrameController().getConfiguration().openModel(model);


Input:
public static boolean containsIndex(final IndexType type, final ResourceManager resourceManager, final int revision) throws SirixIOException {
    final Indexes indexes = new Indexes();
    final java.nio.file.Path indexesFile = resourceManager.getResourceConfig().mPath.resolve(ResourceConfiguration.ResourcePaths.INDEXES.getFile()).resolve(String.valueOf(revision) + "String_Node_Str");
    try {
        if (Files.exists(indexesFile) && Files.size(indexesFile) > 0) {
            try (final InputStream in = new FileInputStream(indexesFile.toFile())) {
                indexes.init(deserialize(in).getFirstChild());
            }
        }
    } catch (IOException | DocumentException | SirixException e) {
        throw new SirixIOException("String_Node_Str", e);
    }
    for (final IndexDef indexDef : indexes.getIndexDefs()) {
        if (indexDef.getType() == type)
            return true;
    }
    return false;
}

Output:
     final Indexes indexes = new Indexes();
-    final java.nio.file.Path indexesFile = resourceManager.getResourceConfig().mPath.resolve(ResourceConfiguration.ResourcePaths.INDEXES.getFile()).resolve(String.valueOf(revision) + "String_Node_Str");
+    final java.nio.file.Path indexesFile = resourceManager.getResourceConfig().mPath.resolve(ResourceConfiguration.ResourcePaths.INDEXES.getPath()).resolve(String.valueOf(revision) + "String_Node_Str");
     try {


Input:
public static void main(String[] args) {
    try {
        final PathIF model = new PathIF();
        final Solver solver = new Solver();
        final Bounds b = model.bounds(10);
        final Formula f = model.empty();
        System.out.println(f);
        solver.options().setSolver(SATFactory.DefaultSAT4J);
        System.out.println(System.currentTimeMillis());
        Iterator iterSols = solver.solveAll(f, b);
        System.out.println(System.currentTimeMillis());
        while (iterSols.hasNext()) {
            final Solution s = (Solution) iterSols.next();
            if (s.outcome() == Solution.Outcome.SATISFIABLE || s.outcome() == Solution.Outcome.TRIVIALLY_SATISFIABLE) {
                System.out.println(s);
            }
        }
    } catch (NumberFormatException nfe) {
    }
}

Output:
     try {
-        final PathIF model = new PathIF();
+        final SchillerCoryIF model = new SchillerCoryIF();
         final Solver solver = new Solver();


Input:
protected Collection<Analysis> searchAllAnalysis(IFolder folder) {
    Collection<Analysis> analyses = new ArrayList<Analysis>();
    ResourceSet resoruceSet = new ResourceSetImpl();
    try {
        for (IResource resource : folder.members()) {
            if (resource.getType() == IResource.FOLDER) {
                analyses.addAll(searchAllAnalysis(folder.getFolder(resource.getName())));
                continue;
            }
            IFile file = (IFile) resource;
            if (file.getFileExtension().equals(FactoriesUtil.ANA)) {
                URI uri = URI.createPlatformResourceURI(file.getFullPath().toString(), false);
                Resource eResource = resoruceSet.getResource(uri, true);
                analyses.add((Analysis) eResource.getContents().get(0));
            }
        }
    } catch (Exception e) {
        log.error(e);
    }
    return analyses;
}

Output:
                 URI uri = URI.createPlatformResourceURI(file.getFullPath().toString(), false);
-                Resource eResource = resoruceSet.getResource(uri, true);
+                Resource eResource = EMFSharedResources.getInstance().getResource(uri, true);
                 analyses.add((Analysis) eResource.getContents().get(0));


Input:
public void handleNotification(Notification notification, java.lang.Object handback) {
    if (notification.getType().equals("String_Node_Str")) {
        ContainerBase container = ((ContainerBase) notification.getSource());
        if (container instanceof StandardHost) {
            try {
                registerHost((StandardHost) container);
            } catch (Exception e) {
                throw new RuntimeException("String_Node_Str" + container.getObjectName(), e);
            }
        } else if (container instanceof StandardContext) {
            try {
                registerContext((StandardContext) container);
            } catch (Throwable t) {
                throw new RuntimeException("String_Node_Str" + container.getObjectName(), t);
            }
        } else if (container instanceof StandardWrapper) {
            try {
                registerWrapper((StandardWrapper) container);
            } catch (Throwable t) {
                throw new RuntimeException("String_Node_Str" + container.getObjectName(), t);
            }
        }
    } else if (notification.getType().equals("String_Node_Str")) {
        ContainerBase container = ((ContainerBase) notification.getSource());
        if (container instanceof StandardHost) {
            try {
                unregisterHost(container.getJmxName());
            } catch (Exception e) {
                throw new RuntimeException("String_Node_Str" + "String_Node_Str" + container.getObjectName(), e);
            }
        } else if (container instanceof StandardContext) {
            try {
                unregisterContext(container.getJmxName());
            } catch (Throwable t) {
                throw new RuntimeException("String_Node_Str" + container.getObjectName(), t);
            }
        } else if (container instanceof StandardWrapper) {
            ObjectName objectName = container.getJmxName();
            String j2eeType = objectName.getKeyProperty("String_Node_Str");
            if (Boolean.parseBoolean(objectName.getKeyProperty("String_Node_Str")) && j2eeType.equals("String_Node_Str")) {
                try {
                    unregisterOSGiWrapper(objectName);
                } catch (Throwable t) {
                    throw new RuntimeException("String_Node_Str" + objectName, t);
                }
            }
        }
    }
}

Output:
             ObjectName objectName = container.getJmxName();
-            String j2eeType = objectName.getKeyProperty("String_Node_Str");
-            if (Boolean.parseBoolean(objectName.getKeyProperty("String_Node_Str")) && j2eeType.equals("String_Node_Str")) {
+            if (Boolean.parseBoolean(objectName.getKeyProperty("String_Node_Str")) && objectName.getKeyProperty("String_Node_Str").equals("String_Node_Str")) {
                 try {


Input:
public void breakBlock(World world, BlockPos pos, IBlockState state) {
    TileEntity tile = world.getTileEntity(pos);
    if (tile != null && tile instanceof TileTank) {
        TileTank tank = (TileTank) tile;
        tank.onBlockBreak();
    }
    TileEntity tileAbove = world.getTileEntity(x, y + 1, z);
    TileEntity tileBelow = world.getTileEntity(x, y - 1, z);
    super.breakBlock(world, pos, block, par6);
    if (tileAbove instanceof TileTank) {
        ((TileTank) tileAbove).updateComparators();
    }
    if (tileBelow instanceof TileTank) {
        ((TileTank) tileBelow).updateComparators();
    }
}

Output:
     }
-    TileEntity tileAbove = world.getTileEntity(x, y + 1, z);
-    TileEntity tileBelow = world.getTileEntity(x, y - 1, z);
-    super.breakBlock(world, pos, block, par6);
+    TileEntity tileAbove = world.getTileEntity(pos.up());
+    TileEntity tileBelow = world.getTileEntity(pos.down());
+    super.breakBlock(world, pos, state);
     if (tileAbove instanceof TileTank) {


Input:
public static boolean shouldRegenerate(RuleContext ruleContext, ResourceDependencies resourceDeps) {
    return Iterables.size(resourceDeps.getResources()) > 1 || ruleContext.attributes().isAttributeValueExplicitlySpecified("String_Node_Str") || ResourceConfigurationFilter.hasFilters(ruleContext) || ruleContext.attributes().isAttributeValueExplicitlySpecified("String_Node_Str");
}

Output:
 public static boolean shouldRegenerate(RuleContext ruleContext, ResourceDependencies resourceDeps) {
-    return Iterables.size(resourceDeps.getResources()) > 1 || ruleContext.attributes().isAttributeValueExplicitlySpecified("String_Node_Str") || ResourceConfigurationFilter.hasFilters(ruleContext) || ruleContext.attributes().isAttributeValueExplicitlySpecified("String_Node_Str");
+    return Iterables.size(resourceDeps.getResources()) > 1 || ResourceFilter.hasFilters(ruleContext) || ruleContext.attributes().isAttributeValueExplicitlySpecified("String_Node_Str");
 }


Input:
protected void setTableMAPPING() {
    if (getConnection() != null) {
        String componentName = node.getComponent().getName();
        for (IElementParameter parameter : node.getElementParameters()) {
            if (parameter.getFieldType() == EParameterFieldType.TABLE) {
                if (parameter.getRepositoryValue() != null && parameter.getRepositoryValue().equals("String_Node_Str")) {
                    List<Map<String, Object>> value2 = (List<Map<String, Object>>) parameter.getValue();
                    RepositoryToComponentProperty.getTableXMLMappingValue(getConnection(), value2, newOutputMetadata, getColumnRenameMap());
                    IElementParameter elementParameter = node.getElementParameter(EParameterName.PROPERTY_TYPE.getName());
                    if (elementParameter != null) {
                        if (EmfComponent.BUILTIN.equals(elementParameter.getValue())) {
                            parameter.setRepositoryValueUsed(false);
                        } else {
                            parameter.setRepositoryValueUsed(true);
                        }
                    }
                } else if (componentName != null && componentName.startsWith("String_Node_Str") && ("String_Node_Str".equals(parameter.getName()) || "String_Node_Str".equals(parameter.getName()))) {
                    Object value = RepositoryToComponentProperty.getColumnMappingValue(connection, newOutputMetadata);
                    if (value != null) {
                        parameter.setValue(value);
                    }
                }
            }
        }
    }
}

Output:
                     }
-                } else if (componentName != null && componentName.startsWith("String_Node_Str") && ("String_Node_Str".equals(parameter.getName()) || "String_Node_Str".equals(parameter.getName()))) {
+                } else if (componentName != null && (componentName.startsWith("String_Node_Str") || componentName.startsWith("String_Node_Str")) && ("String_Node_Str".equals(parameter.getName()) || "String_Node_Str".equals(parameter.getName()))) {
                     Object value = RepositoryToComponentProperty.getColumnMappingValue(connection, newOutputMetadata);


Input:
int getData1() {
    switch(type) {
        case X:
        case Both:
            return x;
    }
    return 0;
}

Output:
         case Both:
-            return x;
+            return ax;
     }


Input:
private static boolean termsMatch(ITerm t1, ITerm t2) {
    if (t1.equals(t2)) {
        return true;
    }
    switch(t1.getKind()) {
        case CONSTANT:
        case VARIABLE:
            return Wildcard.STAR.equals(t2);
        case FUNCTION:
            if (Wildcard.STAR.equals(t2)) {
                return true;
            } else {
                if (t2 instanceof FunctionTerm) {
                    FunctionTerm f1 = (FunctionTerm) t1;
                    FunctionTerm f2 = (FunctionTerm) t2;
                    if (f1.getFunction().equals(f2.getFunction())) {
                        for (int i = 0; i < f1.getParameters().size(); i++) {
                            ITerm x = f1.getParameters().get(i);
                            ITerm y = f2.getParameters().get(i);
                            if (!termsMatch(x, y)) {
                                return false;
                            }
                        }
                        return true;
                    }
                }
                return false;
            }
        default:
            Assertions.UNREACHABLE();
            return false;
    }
}

Output:
         case VARIABLE:
-            return Wildcard.STAR.equals(t2);
+            return false;
         case FUNCTION:


Input:
private void onMetricChanged(Number val) {
    if (LOG.isTraceEnabled())
        LOG.trace("String_Node_Str", new Object[] { this, poolEntity, val });
    double currentMetricD = val.doubleValue();
    double metricUpperBoundD = metricUpperBound.doubleValue();
    double metricLowerBoundD = metricLowerBound.doubleValue();
    int currentSize = currentSizeOperator.apply(entity);
    int desiredSize;
    if (currentMetricD > metricUpperBoundD) {
        desiredSize = currentSize + (int) Math.ceil(currentSize * ((currentMetricD - metricUpperBoundD) / metricUpperBoundD));
        desiredSize = toBoundedDesiredPoolSize(desiredSize);
        if (desiredSize > currentSize) {
            if (LOG.isTraceEnabled())
                LOG.trace("String_Node_Str", new Object[] { this, poolEntity, currentSize, desiredSize, currentMetricD, metricUpperBoundD });
            scheduleResize(desiredSize);
        }
    } else if (currentMetricD < metricLowerBoundD) {
        desiredSize = currentSize - (int) Math.floor(currentSize * ((metricLowerBoundD - currentMetricD) / metricLowerBoundD));
        desiredSize = toBoundedDesiredPoolSize(desiredSize);
        if (desiredSize < currentSize) {
            if (LOG.isTraceEnabled())
                LOG.trace("String_Node_Str", new Object[] { this, poolEntity, currentSize, desiredSize, currentMetricD, metricLowerBoundD });
            scheduleResize(desiredSize);
        }
    } else {
        if (LOG.isTraceEnabled())
            LOG.trace("String_Node_Str", new Object[] { this, poolEntity, currentSize, currentMetricD, metricLowerBoundD, metricUpperBoundD });
        abortResize(currentSize);
        return;
    }
}

Output:
     if (currentMetricD > metricUpperBoundD) {
-        desiredSize = currentSize + (int) Math.ceil(currentSize * ((currentMetricD - metricUpperBoundD) / metricUpperBoundD));
+        desiredSize = (int) Math.ceil(currentTotalActivity / metricUpperBoundD);
         desiredSize = toBoundedDesiredPoolSize(desiredSize);


Input:
private void expandAndSelect(Node node) {
    LinkedList<Node> parents = new LinkedList<Node>();
    while (viewer.testFindItem(node) == null) {
        node = node.getParent();
        if (node == null) {
            return;
        }
        parents.addFirst(node);
    }
    for (Node p : parents) {
        viewer.expandToLevel(p, 1);
    }
}

Output:
 private void expandAndSelect(Node node) {
-    LinkedList<Node> parents = new LinkedList<Node>();
-    while (viewer.testFindItem(node) == null) {
-        node = node.getParent();
-        if (node == null) {
-            return;
+    if (node != null) {
+        LinkedList<Node> parents = new LinkedList<Node>();
+        while (viewer.testFindItem(node) == null) {
+            node = node.getParent();
+            if (node == null) {
+                return;
+            }
+            parents.addFirst(node);
+        }
+        for (Node p : parents) {
+            viewer.expandToLevel(p, 1);
         }


Input:
private static void recordDependencies(ManipulationSession session, Project project, Set<ArtifactRef> deps, HashMap<ProjectVersionRef, Dependency> dependencies) throws ManipulationException {
    if (dependencies == null) {
        return;
    }
    for (ProjectVersionRef pvr : dependencies.keySet()) {
        Dependency d = dependencies.get(pvr);
        deps.add(new SimpleScopedArtifactRef(pvr, new SimpleTypeAndClassifier(d.getType(), d.getClassifier()), isEmpty(d.getScope()) ? DependencyScope.compile.realName() : PropertyResolver.resolveInheritedProperties(session, project, d.getScope())));
    }
}

Output:
     }
-    for (ProjectVersionRef pvr : dependencies.keySet()) {
+    for (ArtifactRef pvr : dependencies.keySet()) {
         Dependency d = dependencies.get(pvr);


Input:
public void updateProgressBar(int id, int state) {
    if (id == 0) {
        for (int i = 0; i < 8; i++) {
            triggerState[i] = ((state >> i) & 0x01) == 0x01;
        }
    }
}

Output:
         for (int i = 0; i < 8; i++) {
-            triggerState[i] = ((state >> i) & 0x01) == 0x01;
+            actionsState[i] = ActionState.values()[((state >> (i * 2)) & 0x03)];
         }


Input:
public void start(Context context) throws LifecycleException, InterruptedException {
    logger.info("String_Node_Str", Thread.currentThread().getId());
    synchronized (supervisedProcesses) {
        logger.debug("String_Node_Str");
        for (Entry<LifecycleAware, Supervisoree> entry : supervisedProcesses.entrySet()) {
            MonitorRunnable monitorCheckRunnable = new MonitorRunnable();
            monitorCheckRunnable.lifecycleAware = entry.getKey();
            monitorCheckRunnable.supervisoree = entry.getValue();
            monitorService.scheduleAtFixedRate(monitorCheckRunnable, 0, 3, TimeUnit.SECONDS);
        }
    }
    lifecycleState = LifecycleState.START;
    logger.debug("String_Node_Str");
}

Output:
     logger.info("String_Node_Str", Thread.currentThread().getId());
-    synchronized (supervisedProcesses) {
-        logger.debug("String_Node_Str");
-        for (Entry<LifecycleAware, Supervisoree> entry : supervisedProcesses.entrySet()) {
-            MonitorRunnable monitorCheckRunnable = new MonitorRunnable();
-            monitorCheckRunnable.lifecycleAware = entry.getKey();
-            monitorCheckRunnable.supervisoree = entry.getValue();
-            monitorService.scheduleAtFixedRate(monitorCheckRunnable, 0, 3, TimeUnit.SECONDS);
-        }
+    for (Entry<LifecycleAware, Supervisoree> entry : supervisedProcesses.entrySet()) {
+        MonitorRunnable monitorCheckRunnable = new MonitorRunnable();
+        monitorCheckRunnable.lifecycleAware = entry.getKey();
+        monitorCheckRunnable.supervisoree = entry.getValue();
+        monitorService.scheduleAtFixedRate(monitorCheckRunnable, 0, 3, TimeUnit.SECONDS);
     }


Input:
public void cancelRefresh() {
    for (RefreshListener listener : mRefreshListeners) {
        listener.onRefreshStop();
    }
    mRefreshInProgress = false;
    hideMenuProgressBar();
}

Output:
     mRefreshInProgress = false;
-    hideMenuProgressBar();
+    setMenuProgressBarVisible(false);
 }


Input:
public void testSupportsMultiValueInExpr() {
    String sql = dialectize("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    if (getDialect().supportsMultiValueInExpr()) {
        assertQuerySucceeds(sql);
    } else {
        String[] errs = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", INFOBRIGHT_UNSUPPORTED, NEOVIEW_SYNTAX_ERROR, "String_Node_Str", "String_Node_Str", "String_Node_Str" };
        assertQueryFails(sql, errs);
    }
}

Output:
     } else {
-        String[] errs = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", INFOBRIGHT_UNSUPPORTED, NEOVIEW_SYNTAX_ERROR, "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+        String[] errs = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", INFOBRIGHT_UNSUPPORTED, NEOVIEW_SYNTAX_ERROR, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
         assertQueryFails(sql, errs);


Input:
private static int runQueryOnRS(DataEngineImpl dataEngine, IQueryDefinition queryDefn) throws DataException {
    String queryResultID = queryDefn.getQueryResultsID();
    String rootQueryResultID = QueryResultIDUtil.get1PartID(queryResultID);
    String parentQueryResultID = null;
    if (rootQueryResultID != null)
        parentQueryResultID = QueryResultIDUtil.get2PartID(queryResultID);
    else
        rootQueryResultID = queryResultID;
    QueryResultInfo queryResultInfo = new QueryResultInfo(rootQueryResultID, parentQueryResultID, null, null, -1);
    RDLoad rdLoad = RDUtil.newLoad(dataEngine.getSession().getTempDir(), dataEngine.getContext(), queryResultInfo);
    IBaseQueryDefinition previousQueryDefn = rdLoad.loadQueryDefn(StreamManager.ROOT_STREAM, StreamManager.PARENT_SCOPE);
    if (QueryCompUtil.isIVQueryDefnEqual(previousQueryDefn, queryDefn)) {
        return BASED_ON_PRESENTATION;
    }
    if (previousQueryDefn.getSorts() != null && previousQueryDefn.getSorts().size() > 0 && (queryDefn.getSorts() == null || queryDefn.getSorts().size() == 0)) {
        return BASED_ON_DATASET;
    }
    if (!queryDefn.usesDetails()) {
        queryDefn.getSorts().clear();
    }
    boolean runningOnRS = GroupDefnUtil.isEqualGroups(queryDefn.getGroups(), rdLoad.loadGroupDefn(StreamManager.ROOT_STREAM, StreamManager.BASE_SCOPE));
    if (runningOnRS == false)
        return BASED_ON_DATASET;
    runningOnRS = !hasAggregationInFilter(queryDefn.getFilters());
    if (runningOnRS == false)
        return BASED_ON_DATASET;
    runningOnRS = isCompatibleRSMap(rdLoad.loadQueryDefn(StreamManager.ROOT_STREAM, StreamManager.BASE_SCOPE).getBindings(), queryDefn.getBindings());
    if (runningOnRS == false)
        return BASED_ON_DATASET;
    IBaseQueryDefinition qd = rdLoad.loadQueryDefn(StreamManager.ROOT_STREAM, StreamManager.BASE_SCOPE);
    runningOnRS = isCompatibleSubQuery(qd, queryDefn);
    if (runningOnRS == false)
        return BASED_ON_DATASET;
    List filters = qd.getFilters();
    if (FilterDefnUtil.isConflictFilter(filters, queryDefn.getFilters())) {
        runningOnRS = false;
        FilterDefnUtil.getRealFilterList(rdLoad.loadOriginalQueryDefn(StreamManager.ROOT_STREAM, StreamManager.BASE_SCOPE).getFilters(), queryDefn.getFilters());
    }
    if (runningOnRS == false)
        return BASED_ON_DATASET;
    if (!QueryCompUtil.isEqualSorts(queryDefn.getSorts(), qd.getSorts())) {
        Iterator bindings = queryDefn.getBindings().values().iterator();
        while (bindings.hasNext()) {
            IBinding binding = (IBinding) bindings.next();
            final String aggrName = binding.getAggrFunction();
            if (aggrName != null) {
                IAggrFunction aggrFunction = AggregationManager.getInstance().getAggregation(aggrName);
                if (aggrFunction.isDataOrderSensitive()) {
                    return BASED_ON_DATASET;
                }
            }
            if (binding.getExpression() != null && binding.getExpression() instanceof IScriptExpression) {
                IScriptExpression expr = (IScriptExpression) binding.getExpression();
                if (ExpressionUtil.hasAggregation(expr.getText())) {
                    if (expr.getText().matches("String_Node_Str") || expr.getText().matches("String_Node_Str")) {
                        return BASED_ON_DATASET;
                    }
                }
            }
        }
    }
    if (!isBindingReferenceSort(queryDefn.getSorts()))
        return BASED_ON_DATASET;
    if (hasSubquery(queryDefn)) {
        if (hasSubQueryInDetail(queryDefn.getSubqueries()))
            return BASED_ON_DATASET;
        if (!QueryCompUtil.isEqualSorts(queryDefn.getSorts(), qd.getSorts())) {
            runningOnRS = false;
        }
        Collection subqueries = queryDefn.getSubqueries();
        List gps = queryDefn.getGroups();
        if (gps != null && gps.size() > 0) {
            for (int i = 0; i < gps.size(); i++) {
                subqueries.addAll(((IGroupDefinition) gps.get(i)).getSubqueries());
            }
        }
        Iterator it = subqueries.iterator();
        while (it.hasNext()) {
            IBaseQueryDefinition query = (IBaseQueryDefinition) it.next();
            if (!query.usesDetails())
                query.getSorts().clear();
            if (query.getFilters() != null && query.getFilters().size() > 0) {
                runningOnRS = false;
                break;
            }
            List groups = query.getGroups();
            if (groups != null && !groups.isEmpty())
                runningOnRS = false;
            if (runningOnRS == false)
                break;
        }
    }
    if (runningOnRS == false)
        return BASED_ON_DATASET;
    if (queryDefn.getFilters() != null && queryDefn.getFilters().size() > 0) {
        if (!isFiltersEquals(filters, queryDefn.getFilters()))
            runningOnRS = queryDefn.getBindings().values() == null || !hasAggregationOnRowObjects(queryDefn.getBindings().values().iterator());
    }
    return runningOnRS ? BASED_ON_RESULTSET : BASED_ON_DATASET;
}

Output:
     IBaseQueryDefinition previousQueryDefn = rdLoad.loadQueryDefn(StreamManager.ROOT_STREAM, StreamManager.PARENT_SCOPE);
-    if (QueryCompUtil.isIVQueryDefnEqual(previousQueryDefn, queryDefn)) {
+    if (QueryCompUtil.isIVQueryDefnEqual(dataEngine.getContext().getMode(), previousQueryDefn, queryDefn)) {
         return BASED_ON_PRESENTATION;


Input:
private boolean updateChildStatus(String appId, String id, Map<String, Group> groups, Map<String, ClusterDataHolder> clusterData, ParentComponent parent) {
    boolean groupActive = false;
    boolean clustersActive;
    boolean groupsActive;
    boolean childFound = false;
    boolean clusterFound = false;
    for (ClusterDataHolder clusterDataHolder : clusterData.values()) {
        if (clusterDataHolder.getClusterId().equals(id)) {
            clusterFound = true;
        }
    }
    if (clusterFound || groups.containsKey(id)) {
        childFound = true;
        if (!clusterData.isEmpty() && !groups.isEmpty()) {
            clustersActive = getClusterStatus(clusterData);
            groupsActive = getGroupStatus(groups);
            groupActive = clustersActive && groupsActive;
        } else if (!groups.isEmpty()) {
            groupsActive = getGroupStatus(groups);
            groupActive = groupsActive;
        } else if (!clusterData.isEmpty()) {
            clustersActive = getClusterStatus(clusterData);
            groupActive = clustersActive;
        } else {
            log.warn("String_Node_Str" + appId);
        }
        if (parent instanceof Application && groupActive) {
            StatusEventPublisher.sendApplicationActivatedEvent(appId);
        } else if (parent instanceof Group && groupActive) {
            StatusEventPublisher.sendGroupActivatedEvent(appId, ((Group) parent).getAlias());
        }
        return childFound;
    } else {
        if (!groups.isEmpty()) {
            for (Group group : groups.values()) {
                return updateChildStatus(appId, id, group.getAliasToGroupMap(), group.getClusterDataMap(), group);
            }
        }
    }
    return childFound;
}

Output:
         } else if (parent instanceof Group && groupActive) {
-            StatusEventPublisher.sendGroupActivatedEvent(appId, ((Group) parent).getAlias());
+            log.info("String_Node_Str" + parent.getUniqueIdentifier());
+            StatusEventPublisher.sendGroupActivatedEvent(appId, parent.getUniqueIdentifier());
         }


Input:
private void createStatisticalSection(ScrolledForm form, Composite topComp) {
    Section statisticalSection = this.createSection(form, topComp, "String_Node_Str", false, null);
    Composite sectionClient = toolkit.createComposite(statisticalSection);
    sectionClient.setLayout(new GridLayout());
    TableViewer statisticalViewer = new TableViewer(sectionClient, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.FULL_SELECTION);
    Table table = statisticalViewer.getTable();
    table.setHeaderVisible(true);
    table.setBackgroundMode(SWT.INHERIT_FORCE);
    table.setLinesVisible(true);
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(table);
    List<? extends SchemaIndicator> indicatorList = null;
    if (this.connectionAnalysis.getResults().getIndicators().size() > 0) {
        ConnectionIndicator conIndicator = (ConnectionIndicator) connectionAnalysis.getResults().getIndicators().get(0);
        indicatorList = conIndicator.getCatalogIndicators();
    } else {
        indicatorList = new ArrayList<SchemaIndicator>();
    }
    List<TdCatalog> catalogs = DataProviderHelper.getTdCatalogs(tdDataProvider);
    AbstractStatisticalViewerProvider provider;
    if (catalogs.size() > 0) {
        createCatalogTableColumns(table);
        provider = new CatalogViewerProvier();
    } else {
        createSchemaTableColumns(table);
        provider = new SchemaViewerProvier();
    }
    statisticalViewer.setLabelProvider(provider);
    statisticalViewer.setContentProvider(provider);
    statisticalViewer.setInput(indicatorList);
    sectionClient.layout();
    statisticalSection.setClient(sectionClient);
}

Output:
     AbstractStatisticalViewerProvider provider;
-    if (catalogs.size() > 0) {
-        createCatalogTableColumns(table);
+    if (catalogs.size() > 0 && tdSchemas.size() > 0) {
+        createSchemaTableColumns(table);
         provider = new CatalogViewerProvier();


Input:
public String getAttribute(Attribute attribute) {
    if (attribute == null)
        return "String_Node_Str";
    if (attribute.startsWith("String_Node_Str")) {
        return new dItem(getPotion().getItem()).getAttribute(attribute.fulfill(2));
    }
    return null;
}

Output:
     if (attribute.startsWith("String_Node_Str")) {
-        return new dItem(getPotion().getItem()).getAttribute(attribute.fulfill(2));
+        return new dItem(getPotion().getItem()).getAttribute(attribute.fulfill(1));
     }


Input:
public Map<String, String> getEnvironmentVariables() {
    try {
        return nativeWindowsProcess.getEnvironmentVariables();
    } catch (WinpException exc) {
        throw new NativeAccessException(exc);
    }
}

Output:
     } catch (WinpException exc) {
-        throw new NativeAccessException(exc);
+        System.out.println(exc.getLocalizedMessage());
+        return new HashMap();
     }


Input:
private void register() {
    if (isVirtual()) {
        return;
    }
    List<Member> list = new ArrayList<Member>();
    List<Member> measures = getMeasures();
    for (Member measure : measures) {
        if (measure instanceof RolapBaseCubeMeasure) {
            list.add(measure);
        }
    }
    RolapBaseCubeMeasure[] storedMeasures = list.toArray(new RolapBaseCubeMeasure[list.size()]);
    RolapStar star = getStar();
    RolapStar.Table table = star.getFactTable();
    for (RolapBaseCubeMeasure storedMeasure : storedMeasures) {
        table.makeMeasure(storedMeasure);
    }
}

Output:
     }
-    List<Member> list = new ArrayList<Member>();
-    List<Member> measures = getMeasures();
-    for (Member measure : measures) {
+    List<RolapBaseCubeMeasure> storedMeasures = new ArrayList<RolapBaseCubeMeasure>();
+    for (Member measure : getMeasures()) {
         if (measure instanceof RolapBaseCubeMeasure) {


Input:
public void forceHardwareConnectEvent(TransportType type) {
    if (_transport != null && _transport.getTransportType() == TransportType.MULTIPLEX) {
        ((MultiplexTransport) _transport).forceHardwareConnectEvent(TransportType.BLUETOOTH);
    }
}

Output:
     if (_transport != null && _transport.getTransportType() == TransportType.MULTIPLEX) {
-        ((MultiplexTransport) _transport).forceHardwareConnectEvent(TransportType.BLUETOOTH);
+        MultiplexTransport multi = ((MultiplexTransport) _transport);
+        boolean forced = multi.forceHardwareConnectEvent(TransportType.BLUETOOTH);
+        if (!forced && multi.isDisconnecting()) {
+            MultiplexTransportConfig config = multi.getConfig();
+            _transport = new MultiplexTransport(config, this);
+        }
     }


Input:
public void onCreate() {
    super.onCreate();
    instance = this;
    mSettings = PreferenceManager.getDefaultSharedPreferences(this);
    String p = mSettings.getString("String_Node_Str", "String_Node_Str");
    if (!p.equals("String_Node_Str")) {
        Locale locale;
        if (p.equals("String_Node_Str")) {
            locale = Locale.TRADITIONAL_CHINESE;
        } else if (p.startsWith("String_Node_Str")) {
            locale = Locale.CHINA;
        } else if (p.equals("String_Node_Str")) {
            locale = new Locale("String_Node_Str", "String_Node_Str");
        } else if (p.equals("String_Node_Str") || p.startsWith("String_Node_Str")) {
            locale = new Locale("String_Node_Str", "String_Node_Str");
        } else {
            if (p.contains("String_Node_Str"))
                p = p.substring(0, p.indexOf('-'));
            locale = new Locale(p);
        }
        Locale.setDefault(locale);
        Configuration config = new Configuration();
        config.locale = locale;
        getResources().updateConfiguration(config, getResources().getDisplayMetrics());
    }
    runBackground(new Runnable() {
        public void run() {
            AudioUtil.prepareCacheFolder(instance);
            sTV = AndroidDevices.isAndroidTv() || !AndroidDevices.hasTsp();
            if (!VLCInstance.testCompatibleCPU(instance))
                return;
            Dialog.setCallbacks(VLCInstance.get(), mDialogCallbacks);
            if (!AndroidDevices.hasTsp())
                AndroidDevices.setRemoteControlReceiverEnabled(false);
        }
    });
}

Output:
     mSettings = PreferenceManager.getDefaultSharedPreferences(this);
-    String p = mSettings.getString("String_Node_Str", "String_Node_Str");
-    if (!p.equals("String_Node_Str")) {
-        Locale locale;
-        if (p.equals("String_Node_Str")) {
-            locale = Locale.TRADITIONAL_CHINESE;
-        } else if (p.startsWith("String_Node_Str")) {
-            locale = Locale.CHINA;
-        } else if (p.equals("String_Node_Str")) {
-            locale = new Locale("String_Node_Str", "String_Node_Str");
-        } else if (p.equals("String_Node_Str") || p.startsWith("String_Node_Str")) {
-            locale = new Locale("String_Node_Str", "String_Node_Str");
-        } else {
-            if (p.contains("String_Node_Str"))
-                p = p.substring(0, p.indexOf('-'));
-            locale = new Locale(p);
-        }
-        Locale.setDefault(locale);
-        Configuration config = new Configuration();
-        config.locale = locale;
-        getResources().updateConfiguration(config, getResources().getDisplayMetrics());
-    }
+    setLocale(this);
     runBackground(new Runnable() {


Input:
public TableDefinition updateDefinition(CratePersistentEntity<?> entity, TableMetadata tableMetadata) {
    List<Column> columns = entityColumnMapper.toColumns(entity);
    Map<String, Column> columnPaths = columnToDotPath(columns);
    Map<String, String> sqlPaths = sqlToDotPath(tableMetadata.getColumns());
    List<Column> additionalColumns = new LinkedList<Column>();
    Iterator<Entry<String, Column>> iterator = columnPaths.entrySet().iterator();
    while (iterator.hasNext()) {
        Entry<String, Column> columnPath = iterator.next();
        if (!sqlPaths.containsKey(columnPath.getKey())) {
            additionalColumns.add(columnPath.getValue());
            if (columnPath.getValue().isObjectColumn()) {
                removePropertyPaths(columnPath.getKey(), iterator);
            }
        }
    }
    return additionalColumns.isEmpty() ? null : new TableDefinition(entity.getTableName(), additionalColumns);
}

Output:
             additionalColumns.add(columnPath.getValue());
-            if (columnPath.getValue().isObjectColumn()) {
+            if (columnPath.getValue().isObjectColumn() || columnPath.getValue().isObjectArrayColumn()) {
                 removePropertyPaths(columnPath.getKey(), iterator);


Input:
private void initFields() {
    imageHelper = new ImageHelper(this);
    croppedImageBitmap = null;
    Uri originalUri = getIntent().getParcelableExtra(QBServiceConsts.EXTRA_FILE_PATH);
    defaultImageBitmap = imageHelper.getBitmap(originalUri);
    cropImageView.setImageBitmap(defaultImageBitmap);
    cropImageView.setAspectRatio(DEFAULT_ASPECT_RATIO_VALUES, DEFAULT_ASPECT_RATIO_VALUES);
}

Output:
 private void initFields() {
-    imageHelper = new ImageHelper(this);
+    imageUtils = new ImageUtils(this);
     croppedImageBitmap = null;


Input:
public static void main(String[] args) {
    Integrator.CoTrainingMethod coTrainingMethod;
    String workingDirectory;
    switch(args[0]) {
        case "String_Node_Str":
            coTrainingMethod = Integrator.CoTrainingMethod.CO_TRAINING;
            workingDirectory = integratorWorkingDirectory + "String_Node_Str";
            break;
        case "String_Node_Str":
            coTrainingMethod = Integrator.CoTrainingMethod.ROBUST_CO_TRAINING;
            workingDirectory = integratorWorkingDirectory + "String_Node_Str";
            break;
        case "String_Node_Str":
            coTrainingMethod = Integrator.CoTrainingMethod.ROBUST_CO_TRAINING_GM;
            workingDirectory = integratorWorkingDirectory + "String_Node_Str";
            break;
        default:
            coTrainingMethod = Integrator.CoTrainingMethod.CO_TRAINING;
            workingDirectory = integratorWorkingDirectory + "String_Node_Str";
    }
    initializeWorkingDirectory(workingDirectory);
    loadLabeledNPsData();
    double[] weightedMajorityAccuracy = new double[numberOfIterations];
    double[][] actualErrorRates = new double[numberOfIterations][numberOfViews];
    double[][] precision = new double[numberOfIterations][numberOfViews];
    double[][] recall = new double[numberOfIterations][numberOfViews];
    double[][] f1Score = new double[numberOfIterations][numberOfViews];
    double[][] estimatedErrorRates = new double[numberOfIterations][numberOfViews];
    Integrator.Builder<Vector, Double> integratorBuilder = new Integrator.Builder<Vector, Double>(integratorWorkingDirectory).labeledDataSet(labeledDataSet).unlabeledDataSet(unlabeledDataSet).completedIterationEventHandlers((completedIterationEvent, sequence, endOfBatch) -> {
        int iterationNumber = ((Integrator.CompletedIterationEvent) completedIterationEvent).getIterationNumber();
        List<TrainableClassifier<Vector, Double>> classifiers = ((Integrator.CompletedIterationEvent) completedIterationEvent).getClassifiers();
        estimatedErrorRates[iterationNumber] = ((Integrator.CompletedIterationEvent) completedIterationEvent).getErrorRates();
        for (int view = 0; view < numberOfViews; view++) {
            DataSet<PredictedDataInstance<Vector, Double>> predictedEvaluationDataSet = classifiers.get(view).predict((DataSet<PredictedDataInstance<Vector, Double>>) evaluationDataSet.getSingleViewDataSet(view));
            double precisionDenominator = 0;
            double recallDenominator = 0;
            for (PredictedDataInstance<Vector, Double> dataInstance : predictedEvaluationDataSet) {
                if (dataInstance.label() != (filteredLabeledData.get(category).get(dataInstance.name()) ? 1 : 0))
                    actualErrorRates[iterationNumber][view]++;
                if (dataInstance.label() == 1) {
                    precisionDenominator++;
                    if (filteredLabeledData.get(category).get(dataInstance.name()))
                        precision[iterationNumber][view]++;
                }
                if (filteredLabeledData.get(category).get(dataInstance.name())) {
                    recallDenominator++;
                    if (dataInstance.label() == 1)
                        recall[iterationNumber][view]++;
                }
            }
            if (precisionDenominator == 0)
                precisionDenominator = 1;
            if (recallDenominator == 0)
                recallDenominator = 1;
            actualErrorRates[iterationNumber][view] /= predictedEvaluationDataSet.size();
            precision[iterationNumber][view] /= precisionDenominator;
            recall[iterationNumber][view] /= recallDenominator;
            f1Score[iterationNumber][view] = 2 * (precision[iterationNumber][view] * recall[iterationNumber][view]) / (precision[iterationNumber][view] + recall[iterationNumber][view]);
            if (precision[iterationNumber][view] == 0 && recall[iterationNumber][view] == 0)
                f1Score[iterationNumber][view] = 0;
            logger.info("String_Node_Str" + (iterationNumber + 1) + "String_Node_Str" + (view + 1) + "String_Node_Str" + "String_Node_Str" + formatter.format(actualErrorRates[iterationNumber][view]) + "String_Node_Str" + "String_Node_Str" + formatter.format(estimatedErrorRates[iterationNumber][view]) + "String_Node_Str" + "String_Node_Str" + formatter.format(precision[iterationNumber][view]) + "String_Node_Str" + "String_Node_Str" + formatter.format(recall[iterationNumber][view]) + "String_Node_Str" + "String_Node_Str" + formatter.format(f1Score[iterationNumber][view]) + "String_Node_Str");
        }
        saveResultsForMATLAB(workingDirectory + "String_Node_Str", actualErrorRates, estimatedErrorRates, precision, recall, f1Score);
    }).coTrainingMethod(Integrator.CoTrainingMethod.ROBUST_CO_TRAINING_GM).dataSelectionMethod(Integrator.DataSelectionMethod.FIXED_PROPORTION).dataSelectionParameter(0.01).numberOfThreads(numberOfViews).saveModelsOnEveryIteration(true).useDifferentFilePerIteration(true);
    for (int view = 0; view < numberOfViews; view++) {
        LogisticRegressionAdaGrad classifier = new LogisticRegressionAdaGrad.Builder(unlabeledDataSet.get(0).getSingleViewDataInstance(view).features().size()).sparse(true).useBiasTerm(true).useL1Regularization(false).l1RegularizationWeight(0.0001).useL2Regularization(false).l2RegularizationWeight(0.1).loggingLevel(0).sampleWithReplacement(true).maximumNumberOfIterations(1000).maximumNumberOfIterationsWithNoPointChange(10).pointChangeTolerance(1e-5).checkForPointConvergence(true).batchSize(10000000).random(random).build();
        integratorBuilder.addClassifier(classifier);
    }
    Integrator<Vector, Double> integrator = integratorBuilder.build();
    for (int iteration = integrator.getIterationNumber(); iteration < numberOfIterations; iteration++) integrator.performSingleIteration();
}

Output:
         saveResultsForMATLAB(workingDirectory + "String_Node_Str", actualErrorRates, estimatedErrorRates, precision, recall, f1Score);
-    }).coTrainingMethod(Integrator.CoTrainingMethod.ROBUST_CO_TRAINING_GM).dataSelectionMethod(Integrator.DataSelectionMethod.FIXED_PROPORTION).dataSelectionParameter(0.01).numberOfThreads(numberOfViews).saveModelsOnEveryIteration(true).useDifferentFilePerIteration(true);
+    }).coTrainingMethod(coTrainingMethod).dataSelectionMethod(Integrator.DataSelectionMethod.FIXED_PROPORTION).dataSelectionParameter(0.01).numberOfThreads(numberOfViews).saveModelsOnEveryIteration(true).useDifferentFilePerIteration(true);
     for (int view = 0; view < numberOfViews; view++) {


Input:
private NSArray<UIGestureRecognizer> createGestureRecognizers() {
    UIGestureRecognizerDelegate gestureRecognizerDelegate = new UIGestureRecognizerDelegateAdapter() {
        public boolean shouldRecognizeSimultaneously(UIGestureRecognizer gestureRecognizer, UIGestureRecognizer otherGestureRecognizer) {
            if (gestureRecognizer.getView() != firstPieceView && gestureRecognizer.getView() != secondPieceView && gestureRecognizer.getView() != thirdPieceView) {
                return false;
            }
            if (gestureRecognizer.getView() != otherGestureRecognizer.getView()) {
                return false;
            }
            if (gestureRecognizer instanceof UILongPressGestureRecognizer || otherGestureRecognizer instanceof UILongPressGestureRecognizer) {
                return false;
            }
            return true;
        }
    };
    UIRotationGestureRecognizer rotationGestureRecognizer = new UIRotationGestureRecognizer(new UIGestureRecognizer.GestureListener() {
        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            rotatePiece((UIRotationGestureRecognizer) gestureRecognizer);
        }
    });
    UIPinchGestureRecognizer pinchGestureRecognizer = new UIPinchGestureRecognizer(new UIGestureRecognizer.GestureListener() {

        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            scalePiece((UIPinchGestureRecognizer) gestureRecognizer);
        }
    });
    UIPanGestureRecognizer panGestureRecognizer = new UIPanGestureRecognizer(new UIGestureRecognizer.GestureListener() {
        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            panPiece((UIPanGestureRecognizer) gestureRecognizer);
        }
    });
    UILongPressGestureRecognizer longPressGestureRecognizer = new UILongPressGestureRecognizer(new UIGestureRecognizer.GestureListener() {
        public void handleGesture(UIGestureRecognizer gestureRecognizer) {
            showResetMenu((UILongPressGestureRecognizer) gestureRecognizer);
        }
    });
    NSArray<UIGestureRecognizer> gestureRecognizers = new NSArray<>(rotationGestureRecognizer, pinchGestureRecognizer, panGestureRecognizer, longPressGestureRecognizer);
    for (UIGestureRecognizer gestureRecognizer : gestureRecognizers) {
        gestureRecognizer.setDelegate(gestureRecognizerDelegate);
    }
    return gestureRecognizers;
}

Output:
     });
-    UIPinchGestureRecognizer pinchGestureRecognizer = new UIPinchGestureRecognizer(new UIGestureRecognizer.GestureListener() {
+    UIPinchGestureRecognizer pinchGestureRecognizer = new UIPinchGestureRecognizer(new UIGestureRecognizer.OnGestureListener() {


Input:
public void testScannedPathsMultipleJarGlobOrder() throws Exception {
    ScannedPaths sc;
    Iterator<String> iter = null;
    String tempPath = "String_Node_Str";
    String filenameA = "String_Node_Str";
    String filenameB = "String_Node_Str";
    String filenameC = "String_Node_Str";
    String fileRegex1 = tempPath + "String_Node_Str";
    String fileRegex2 = tempPath + "String_Node_Str";
    try {
        createTempDirStructure1(tempPath);
        sc = new ScannedPaths(fileRegex1, "String_Node_Str");
        Assert.assertEquals(Iterators.size(sc.iterator()), 2, "String_Node_Str");
        iter = sc.iterator();
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameA));
        sc = new ScannedPaths(fileRegex2, "String_Node_Str");
        Assert.assertEquals(Iterators.size(sc.iterator()), 7, "String_Node_Str");
        iter = sc.iterator();
        Assert.assertTrue(iter.next().contains(filenameB));
        Assert.assertTrue(iter.next().contains(filenameA));
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameC + "String_Node_Str"));
        Assert.assertTrue(iter.next().contains(filenameA));
        Assert.assertTrue(iter.next().contains(filenameA));
        FileUtils.deleteQuietly(new File(tempPath + "String_Node_Str"));
        FileUtils.deleteQuietly(new File(tempPath + "String_Node_Str"));
        FileUtils.deleteQuietly(new File(tempPath + "String_Node_Str"));
        sc = new ScannedPaths(fileRegex1, "String_Node_Str");
        Assert.assertEquals(Iterators.size(sc.iterator()), 2, "String_Node_Str");
        iter = sc.iterator();
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameA));
        sc = new ScannedPaths(fileRegex2, "String_Node_Str");
        Assert.assertEquals(Iterators.size(sc.iterator()), 12, "String_Node_Str");
        iter = sc.iterator();
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameB));
        Assert.assertTrue(iter.next().contains(filenameA));
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameB));
        Assert.assertTrue(iter.next().contains(filenameA));
        Assert.assertTrue(iter.next().contains(filenameC));
        Assert.assertTrue(iter.next().contains(filenameC + "String_Node_Str"));
        Assert.assertTrue(iter.next().contains(filenameC + "String_Node_Str"));
        Assert.assertTrue(iter.next().contains(filenameC + "String_Node_Str"));
        Assert.assertTrue(iter.next().contains(filenameA));
    } catch (Exception e) {
        Assert.fail("String_Node_Str" + e.getMessage());
    } finally {
        FileUtils.deleteQuietly(new File(tempPath));
    }
}

Output:
     String tempPath = "String_Node_Str";
-    String filenameA = "String_Node_Str";
-    String filenameB = "String_Node_Str";
-    String filenameC = "String_Node_Str";
+    String filenameAJar = "String_Node_Str";
+    String filenameBJar = "String_Node_Str";
+    String filenameCJar = "String_Node_Str";
+    String filenameCDupJar = "String_Node_Str";
+    String filenameCDupJar2 = "String_Node_Str";
+    String filenameAData = "String_Node_Str";
+    String filenameBData = "String_Node_Str";
+    String filenameCData = "String_Node_Str";
     String fileRegex1 = tempPath + "String_Node_Str";


Input:
public int getNextDifferent(int index) {
    CharSequence first = array[index];
    for (int i = index + 1; i < array.length; i++) {
        if (first == null ? array[i] != null : !first.equals(array[i])) {
            return i;
        }
    }
    return array.length;
}

Output:
     for (int i = index + 1; i < array.length; i++) {
-        if (first == null ? array[i] != null : !first.equals(array[i])) {
+        if (first == null ? array[i] != null : !StringUtil.equals(first, array[i])) {
             return i;


Input:
public void handleData(ITmfEvent event) {
    super.handleData(event);
    if (event != null) {
        long timestamp = event.getTimestamp().getValue();
        fHistogram.countEvent(getNbRead(), timestamp);
    }
}

Output:
     if (event != null) {
-        long timestamp = event.getTimestamp().getValue();
+        long timestamp = event.getTimestamp().normalize(0, -9).getValue();
         fHistogram.countEvent(getNbRead(), timestamp);


Input:
public void testAssertThrowsNpe() {
    final SimpleEventBus eventBus = new SimpleEventBus();
    try {
        assertThrowsNpe(new Command() {
            public void execute() {
                FooEvent.register(eventBus, fooHandler1);
            }
        });
        fail("String_Node_Str");
    } catch (AssertionFailedError e) {
    }
}

Output:
         });
-        fail("String_Node_Str");
+        throw new Error("String_Node_Str");
     } catch (AssertionFailedError e) {


Input:
public boolean isStationary(int duration) {
    boolean result = false;
    double accelerometerActivityLevel = 9.1;
    if ((accelerometerActivityLevel > SensorConstants.MIN_ACCELEROMETER_STATIONARY_LEVEL && accelerometerActivityLevel < SensorConstants.MAX_ACCELEROMETER_STATIONARY_LEVEL) && isLocationChanged(duration)) {
        result = true;
    }
    return result;
}

Output:
     boolean result = false;
-    double accelerometerActivityLevel = 9.1;
-    if ((accelerometerActivityLevel > SensorConstants.MIN_ACCELEROMETER_STATIONARY_LEVEL && accelerometerActivityLevel < SensorConstants.MAX_ACCELEROMETER_STATIONARY_LEVEL) && isLocationChanged(duration)) {
+    double accelerometerActivityLevel = checkAccelerometerActivityLevel(duration);
+    if ((accelerometerActivityLevel > SensorConstants.MIN_ACCELEROMETER_STATIONARY_LEVEL && accelerometerActivityLevel < SensorConstants.MAX_ACCELEROMETER_STATIONARY_LEVEL) && !isLocationChanged(duration)) {
         result = true;


Input:
private static void jsLoadedCallback(ImageData pixels, int width, int height, OnComplete onComplete) {
    Image image = new Image(width, height);
    for (int x = 0; x < width; x++) {
        for (int y = 0; y < height; y++) image.setPixel(x, y, new Color(pixels.getRedAt(x, y) / 255f, pixels.getGreenAt(x, y) / 255f, pixels.getBlueAt(x, y) / 255f, pixels.getAlphaAt(x, y) / 255f));
    }
    onComplete.invoke(image);
}

Output:
     for (int x = 0; x < width; x++) {
-        for (int y = 0; y < height; y++) image.setPixel(x, y, new Color(pixels.getRedAt(x, y) / 255f, pixels.getGreenAt(x, y) / 255f, pixels.getBlueAt(x, y) / 255f, pixels.getAlphaAt(x, y) / 255f));
+        for (int y = 0; y < height; y++) image.setPixel(x, y, new Color(pixels.getRedAt(x, y) / 255f, pixels.getGreenAt(x, y) / 255f, pixels.getBlueAt(x, y) / 255f, 1 - (pixels.getAlphaAt(x, y) / 255f)));
     }


Input:
protected void addChildren(Folder folder) {
    if (folder.getParent() != null) {
        treeTable.setChildrenAllowed(folder.getParent(), true);
    }
    treeTable.addItem(folder);
    treeTable.setItemIcon(folder, FontAwesome.FOLDER);
    treeTable.setCollapsed(folder, true);
    treeTable.setChildrenAllowed(folder, false);
    if (folder.getParent() != null) {
        treeTable.setParent(folder, folder.getParent());
    }
    List<Folder> children = folder.getChildren();
    for (Folder child : children) {
        addChildren(child);
    }
    List<AgentName> agents = context.getOperationsSerivce().findAgentsInFolder(folder);
    for (AgentName agent : agents) {
        addAgent(folder, agent);
    }
}

Output:
     }
-    List<AgentName> agents = context.getOperationsSerivce().findAgentsInFolder(folder);
+    List<AgentName> agents = context.getOperationsService().findAgentsInFolder(folder);
     for (AgentName agent : agents) {


Input:
public void setCurrentEditorModel(Object current) {
    Object old = this.currentEditorModel;
    if (currentEditorModel == null || current instanceof LibraryHandle) {
        this.currentEditorModel = new LibRootModel(current);
    } else {
        this.currentEditorModel = current;
    }
    if (currentEditorModel == old) {
        return;
    }
    PropertyChangeEvent event = new PropertyChangeEvent(this, CURRENTMODEL, old, this.currentEditorModel);
    firePropertyChangeEvent(event);
}

Output:
     Object old = this.currentEditorModel;
-    if (currentEditorModel == null || current instanceof LibraryHandle) {
+    if (current == null || current instanceof LibraryHandle) {
         this.currentEditorModel = new LibRootModel(current);


Input:
public void onSlide(float slideOffset, Object... drawables) {
    int color = SliderUtils.calculateColor(slideOffset, mStartColor, mEndColor);
    for (Object drawable : drawables) {
        mPainter.paint(drawable, color);
    }
}

Output:
     for (Object drawable : drawables) {
-        mPainter.paint(drawable, color);
+        mPainter.paintColor(color, drawable);
     }


Input:
private void setMultiURLValuesAttributes(MultiURLValues muv, Element elm, StructureSource src, String scriptEvent, boolean bDblClick) {
    List<URLValue> validURLValues = MultiURLValuesScriptGenerator.getValidURLValues(muv);
    StringBuilder sb = new StringBuilder();
    sb.append("String_Node_Str");
    sb.append("String_Node_Str" + validURLValues.size() + "String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    for (URLValue uv : validURLValues) {
        sb.append("String_Node_Str");
        String url = uv.getBaseUrl();
        if (!(url.startsWith("String_Node_Str") || url.endsWith("String_Node_Str"))) {
            url = "String_Node_Str" + url + "String_Node_Str";
        }
        String text = uv.getLabel().getCaption().getValue();
        sb.append("String_Node_Str");
        sb.append("String_Node_Str" + text + "String_Node_Str");
        sb.append("String_Node_Str" + url + "String_Node_Str");
        sb.append("String_Node_Str" + uv.getTarget() + "String_Node_Str");
        if (uv.getTooltip() != null)
            sb.append("String_Node_Str" + uv.getTooltip() + "String_Node_Str");
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    EMap<String, String> stylesMap = muv.getPropertiesMap();
    String menuStyle = CSSHelper.getStylingHyphenFormat(stylesMap.get(MenuStylesKeyType.MENU.getName()));
    String textStyle = CSSHelper.getStylingHyphenFormat(stylesMap.get(MenuStylesKeyType.MENU_ITEM.getName()));
    String onmouseoverStyle = CSSHelper.getStylingHyphenFormat(stylesMap.get(MenuStylesKeyType.ON_MOUSE_OVER.getName()));
    String onmouseoutStyle = CSSHelper.getStylingHyphenFormat(stylesMap.get(MenuStylesKeyType.ON_MOUSE_OUT.getName()));
    sb.append("String_Node_Str");
    sb.append("String_Node_Str" + menuStyle + "String_Node_Str").append("String_Node_Str" + textStyle + "String_Node_Str").append("String_Node_Str" + onmouseoverStyle + "String_Node_Str").append("String_Node_Str" + onmouseoutStyle + "String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    String script = sb.toString();
    StringBuffer callbackFunction = new StringBuffer("String_Node_Str");
    callbackFunction.append(Math.abs(script.hashCode()));
    callbackFunction.append("String_Node_Str");
    callbackFunction.append(src.getSource().hashCode());
    if (StructureType.SERIES_DATA_POINT.equals(src.getType())) {
        final DataPointHints dph = (DataPointHints) src.getSource();
        ScriptUtil.script(callbackFunction, dph);
    }
    callbackFunction.append("String_Node_Str");
    elm.setAttribute(scriptEvent, wrapJS(bDblClick, callbackFunction.toString()));
    if (!(scripts.contains(script))) {
        svg_g2d.addScript("String_Node_Str" + Math.abs(script.hashCode()) + "String_Node_Str" + "String_Node_Str" + script + "String_Node_Str");
        scripts.add(script);
    }
}

Output:
     StringBuffer callbackFunction = new StringBuffer("String_Node_Str");
-    callbackFunction.append(Math.abs(script.hashCode()));
+    int hashCode = script.hashCode();
+    if (hashCode != Integer.MIN_VALUE) {
+        callbackFunction.append(Math.abs(hashCode));
+    } else {
+        callbackFunction.append(Integer.MAX_VALUE);
+    }
     callbackFunction.append("String_Node_Str");


Input:
public List<INodeConnector> createConnectors(INode parentNode) {
    List<INodeConnector> listConnector = new ArrayList<>();
    ComponentProperties componentProperties = ComponentsUtils.getComponentProperties(getName());
    Set<? extends Connector> inputConnectors = componentProperties.getPossibleConnectors(false);
    if (inputConnectors.isEmpty()) {
        INodeConnector connector = null;
        connector = addStandardType(listConnector, EConnectionType.FLOW_MAIN, parentNode);
        connector.setMaxLinkInput(0);
        connector.setMaxLinkOutput(0);
    } else {
        for (Connector connector : inputConnectors) {
            addGenericType(listConnector, EConnectionType.FLOW_MAIN, connector.getName(), parentNode, componentProperties, false);
        }
    }
    Set<? extends Connector> outputConnectors = componentProperties.getPossibleConnectors(true);
    List<? extends Connector> sortedOutputConnectors = new ArrayList<>(outputConnectors);
    sortedOutputConnectors.sort(new Comparator<Connector>() {
        public int compare(Connector o1, Connector o2) {
            if (Connector.MAIN_NAME.equals(o1.getName())) {
                return -1;
            }
            if (Connector.MAIN_NAME.equals(o2.getName())) {
                return 1;
            }
            return 0;
        }
    });
    for (Connector connector : sortedOutputConnectors) {
        EConnectionType type = EConnectionType.FLOW_MAIN;
        if (Connector.REJECT_NAME.equals(connector.getName())) {
            type = EConnectionType.REJECT;
        }
        addGenericType(listConnector, type, connector.getName(), parentNode, componentProperties, true);
    }
    addStandardType(listConnector, EConnectionType.RUN_IF, parentNode);
    addStandardType(listConnector, EConnectionType.ON_COMPONENT_OK, parentNode);
    addStandardType(listConnector, EConnectionType.ON_COMPONENT_ERROR, parentNode);
    addStandardType(listConnector, EConnectionType.ON_SUBJOB_OK, parentNode);
    addStandardType(listConnector, EConnectionType.ON_SUBJOB_ERROR, parentNode);
    Set<ConnectorTopology> topologies = componentDefinition.getSupportedConnectorTopologies();
    createIterateConnectors(topologies, listConnector, parentNode);
    for (int i = 0; i < EConnectionType.values().length; i++) {
        EConnectionType currentType = EConnectionType.values()[i];
        if ((currentType == EConnectionType.FLOW_REF) || (currentType == EConnectionType.FLOW_MERGE)) {
            continue;
        }
        boolean exists = false;
        for (INodeConnector curNodeConn : listConnector) {
            if (curNodeConn.getDefaultConnectionType().equals(currentType)) {
                exists = true;
                if (currentType == EConnectionType.FLOW_MAIN) {
                    curNodeConn.addConnectionProperty(EConnectionType.FLOW_REF, EConnectionType.FLOW_REF.getRGB(), EConnectionType.FLOW_REF.getDefaultLineStyle());
                    curNodeConn.addConnectionProperty(EConnectionType.FLOW_MERGE, EConnectionType.FLOW_MERGE.getRGB(), EConnectionType.FLOW_MERGE.getDefaultLineStyle());
                }
            }
        }
        if (!exists) {
            NodeConnector nodeConnector = new NodeConnector(parentNode);
            nodeConnector.setDefaultConnectionType(currentType);
            nodeConnector.setName(currentType.getName());
            nodeConnector.setBaseSchema(currentType.getName());
            nodeConnector.addConnectionProperty(currentType, currentType.getRGB(), currentType.getDefaultLineStyle());
            nodeConnector.setLinkName(currentType.getDefaultLinkName());
            nodeConnector.setMenuName(currentType.getDefaultMenuName());
            if ((currentType == EConnectionType.PARALLELIZE) || (currentType == EConnectionType.SYNCHRONIZE)) {
                nodeConnector.setMaxLinkInput(1);
            } else {
                nodeConnector.setMaxLinkInput(0);
            }
            nodeConnector.setMaxLinkOutput(0);
            nodeConnector.setMinLinkInput(0);
            nodeConnector.setMinLinkOutput(0);
            listConnector.add(nodeConnector);
        }
    }
    return listConnector;
}

Output:
     List<INodeConnector> listConnector = new ArrayList<>();
-    ComponentProperties componentProperties = ComponentsUtils.getComponentProperties(getName());
+    ComponentProperties componentProperties = parentNode.getComponentProperties();
+    if (componentProperties == null) {
+        parentNode.setComponentProperties(ComponentsUtils.getComponentProperties(getName()));
+        componentProperties = parentNode.getComponentProperties();
+    }
     Set<? extends Connector> inputConnectors = componentProperties.getPossibleConnectors(false);


Input:
public Long[] getIndexValues(Object value) {
    if (hasIndexedAttributes) {
        int indexCount = mapIndexes.size();
        Long[] newIndexes = new Long[indexCount];
        if (value instanceof Data) {
            value = toObject((Data) value);
        }
        Collection<Index> indexes = mapIndexes.values();
        for (Index index : indexes) {
            int attributedIndex = index.getAttributeIndex();
            newIndexes[attributedIndex] = index.extractLongValue(value);
        }
        if (indexTypes == null || indexTypes.length != indexCount) {
            synchronized (indexTypesLock) {
                if (indexTypes == null || indexTypes.length != indexCount) {
                    indexTypes = new byte[indexCount];
                    for (Index index : indexes) {
                        int attributedIndex = index.getAttributeIndex();
                        indexTypes[attributedIndex] = index.getIndexType();
                    }
                }
            }
        }
        return newIndexes;
    }
    return null;
}

Output:
         }
-        if (indexTypes == null || indexTypes.length != indexCount) {
+        byte[] _indexTypes = indexTypes;
+        if (_indexTypes == null || _indexTypes.length != indexCount) {
             synchronized (indexTypesLock) {


Input:
private void setStatus(String msg) {
    if (msg == null) {
        label.setImage(null);
        label.setText("String_Node_Str");
    } else {
        label.setText(msg);
        label.setImage(PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_ERROR_TSK));
    }
}

Output:
     if (msg == null) {
-        label.setImage(null);
-        label.setText("String_Node_Str");
+        status.setImage(null);
+        status.setText("String_Node_Str");
     } else {


Input:
public void execute() throws IOException {
    final String outputFilename = outputFile;
    final String[] basenames = AlignmentReader.getBasenames(inputFilenames);
    final boolean allSorted = ConcatenateAlignmentMode.isAllSorted(basenames);
    if (!allSorted) {
        System.out.println("String_Node_Str");
        System.exit(10);
    }
    if (readIndexStats != null) {
        int readerIndex = 0;
        for (String basename : basenames) {
            boolean found = false;
            for (ReadIndexStats stat : readIndexStats) {
                if (FilenameUtils.getBaseName(basename).equals(stat.basename)) {
                    stat.readerIndex = readerIndex;
                    found = true;
                }
            }
            if (!found) {
                System.err.printf("String_Node_Str", basename);
            }
            readerIndex++;
        }
        Collections.sort(readIndexStats, new Comparator<ReadIndexStats>() {
            public int compare(ReadIndexStats readIndexStats, ReadIndexStats readIndexStatsFirst) {
                return readIndexStats.readerIndex - readIndexStatsFirst.readerIndex;
            }
        });
        for (ReadIndexStats stat : readIndexStats) {
            for (int readIndex = 0; readIndex < numberOfReadIndices; readIndex++) {
                stat.countReferenceBases[readIndex] /= numberOfReadIndices;
            }
        }
    }
    ConcatSortedAlignmentReader sortedReaders = new ConcatSortedAlignmentReader(basenames);
    int lastPosition = -1;
    int lastTargetIndex = -1;
    ObjectArrayList<Alignments.AlignmentEntry> entriesAtPosition = new ObjectArrayList<Alignments.AlignmentEntry>();
    IntArrayList readerIndices = new IntArrayList();
    DoubleIndexedIdentifier targetIds = new DoubleIndexedIdentifier(sortedReaders.getTargetIdentifiers());
    outWriter.printf("String_Node_Str");
    if (deAnalyzer.eval("String_Node_Str")) {
        outWriter.printf("String_Node_Str", groups[0], groups[1], groups[0], groups[1]);
    }
    for (String group : groups) {
        outWriter.printf("String_Node_Str", group, group, group, group);
        if (deAnalyzer.eval("String_Node_Str")) {
            outWriter.printf("String_Node_Str", group);
        }
    }
    outWriter.printf("String_Node_Str");
    for (Alignments.AlignmentEntry entry : sortedReaders) {
        if (currentReferenceId == null) {
            currentReferenceId = targetIds.getId(entry.getTargetIndex());
            currentReferenceIndex = entry.getTargetIndex();
        }
        final int position = entry.getPosition();
        final int targetIndex = entry.getTargetIndex();
        if (targetIndex != lastTargetIndex || position != lastPosition) {
            if (entriesAtPosition.size() != 0) {
                pushVariations(entriesAtPosition, readerIndices);
            }
            processVariations(lastPosition);
            if (targetIndex != lastTargetIndex) {
                variationPool.reset();
                currentReferenceId = targetIds.getId(entry.getTargetIndex());
            }
            variationPool.removePosition(lastPosition);
            entriesAtPosition.clear();
            readerIndices.clear();
            lastPosition = position;
            lastTargetIndex = targetIndex;
        }
        entriesAtPosition.add(entry);
        readerIndices.add(sortedReaders.getReaderIndex());
    }
    outWriter.flush();
}

Output:
         for (ReadIndexStats stat : readIndexStats) {
-            for (int readIndex = 0; readIndex < numberOfReadIndices; readIndex++) {
-                stat.countReferenceBases[readIndex] /= numberOfReadIndices;
+            if (stat.readerIndex == -1) {
+                toRemove.add(stat);
+                continue;
+            }
+            numberOfReadIndices[stat.readerIndex] = Math.max(numberOfReadIndices[stat.readerIndex], stat.countReferenceBases.length);
+        }
+        readIndexStats.removeAll(toRemove);
+        for (ReadIndexStats stat : readIndexStats) {
+            for (int readIndex = 0; readIndex < numberOfReadIndices[stat.readerIndex]; readIndex++) {
+                stat.countReferenceBases[readIndex] /= numberOfReadIndices[stat.readerIndex];
             }


Input:
public void testGetRpcMethodMeta() {
    RpcClient rpcClient = new RpcClient();
    ProtobufRpcProxy<RpcServiceMetaService> pbrpcProxy = new ProtobufRpcProxy<RpcServiceMetaService>(rpcClient, RpcServiceMetaService.class);
    pbrpcProxy.setPort(PORT);
    RpcServiceMetaService proxy = pbrpcProxy.proxy();
    RpcServiceMetaList rpcServiceMetaInfo = proxy.getRpcServiceMetaInfo();
    Assert.assertEquals(4, rpcServiceMetaInfo.getRpcServiceMetas().size());
    List<RpcServiceMeta> rpcServiceMetas = rpcServiceMetaInfo.getRpcServiceMetas();
    for (RpcServiceMeta rpcServiceMeta : rpcServiceMetas) {
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str" + rpcServiceMeta.getServiceName());
        System.out.println("String_Node_Str" + rpcServiceMeta.getMethodName());
        System.out.println("String_Node_Str" + rpcServiceMeta.getInputProto());
        System.out.println("String_Node_Str" + rpcServiceMeta.getOutputProto());
    }
}

Output:
     RpcServiceMetaList rpcServiceMetaInfo = proxy.getRpcServiceMetaInfo();
-    Assert.assertEquals(4, rpcServiceMetaInfo.getRpcServiceMetas().size());
+    Assert.assertEquals(5, rpcServiceMetaInfo.getRpcServiceMetas().size());
     List<RpcServiceMeta> rpcServiceMetas = rpcServiceMetaInfo.getRpcServiceMetas();


Input:
protected void connectionErrorOccurred(ConnectionEvent connectionEvent) {
    final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();
    if (poolState.get() == 50) {
        if (isTracingEnabled && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "String_Node_Str" + this + "String_Node_Str" + "String_Node_Str");
        }
        do_not_reuse_mcw = true;
    } else {
        try {
            if (!stale) {
                if (connectionEvent.getId() != com.ibm.websphere.j2c.ConnectionEvent.SINGLE_CONNECTION_ERROR_OCCURRED) {
                    pm.fatalErrorNotification(_managedConnectionFactory, this, uowCoord);
                } else {
                    this.markStale();
                }
            }
        } catch (Exception e) {
            if (isTracingEnabled && tc.isDebugEnabled()) {
                String pmiName = "String_Node_Str";
                if (cm != null) {
                    pmiName = gConfigProps.cfName;
                }
                Tr.debug(this, tc, "String_Node_Str" + pmiName + "String_Node_Str", e);
            }
            com.ibm.ws.ffdc.FFDCFilter.processException(e, "String_Node_Str", "String_Node_Str", this);
        }
        if ((this.getTranWrapperId() == MCWrapper.NOTXWRAPPER) || (this.getTranWrapperId() == MCWrapper.RRSLOCALTXWRAPPER) || (this.getTranWrapperId() == MCWrapper.NONE) || (state != STATE_TRAN_WRAPPER_INUSE && state != STATE_INACTIVE)) {
            if (this.getTranWrapperId() == MCWrapper.NOTXWRAPPER || this.getTranWrapperId() == MCWrapper.RRSLOCALTXWRAPPER) {
                if (isTracingEnabled && tc.isDebugEnabled()) {
                    Tr.debug(this, tc, "String_Node_Str" + getTranWrapperString());
                }
                this.transactionComplete();
            }
            this.clearHandleList();
            try {
                this.releaseToPoolManager();
            } catch (Exception ex) {
                com.ibm.ws.ffdc.FFDCFilter.processException(ex, "String_Node_Str", "String_Node_Str", this);
                if (isTracingEnabled && tc.isDebugEnabled()) {
                    Tr.debug(this, tc, "String_Node_Str" + gConfigProps.cfName + "String_Node_Str", ex);
                }
            }
        } else {
            if (isTracingEnabled && tc.isDebugEnabled()) {
                Tr.debug(this, tc, "String_Node_Str");
            }
        }
    }
}

Output:
             try {
-                this.releaseToPoolManager();
+                if (state != STATE_INACTIVE) {
+                    this.releaseToPoolManager();
+                } else {
+                    if (isTracingEnabled && tc.isDebugEnabled()) {
+                        Tr.debug(tc, "String_Node_Str");
+                    }
+                }
             } catch (Exception ex) {


Input:
void add(String newcode) {
    maybeEndStatement();
    if (newcode.isEmpty()) {
        return;
    }
    char c = newcode.charAt(0);
    if ((isWordChar(c) || c == '\\') && isWordChar(getLastChar())) {
        append("String_Node_Str");
    } else if (c == '/' && getLastChar() == '/') {
        append("String_Node_Str");
    } else if (c == '"' && isWordChar(getLastChar())) {
        maybeInsertSpace();
    }
    append(newcode);
}

Output:
         append("String_Node_Str");
-    } else if (c == '"' && isWordChar(getLastChar())) {
+    } else if ((c == '"' || c == '\'') && isWordChar(getLastChar())) {
         maybeInsertSpace();


Input:
private void writeAudioDataToFile() throws IOException {
    final short[] sData = new short[AndroidRecorderThread.ARBITRARY_BUFFER];
    while (this.recording) {
        if (this.audioRecord.getRecordingState() != AudioRecord.STATE_UNINITIALIZED) {
            final int read = this.audioRecord.read(sData, 0, sData.length);
            if (read > 0) {
                this.baos.write(this.short2byte(sData), 0, read);
            } else if (read == 0) {
                this.recording = false;
            }
        }
    }
}

Output:
             if (read > 0) {
-                this.baos.write(this.short2byte(sData), 0, read);
+                this.baos.write(this.short2byte(sData), 0, read * AndroidRecorderThread.TWO);
             } else if (read == 0) {


Input:
private DerivedField createCategoricalDerivedField(ColumnConfig config, double cutoff) {
    InlineTable inlineTable = new InlineTable();
    for (int i = 0; i < config.getBinCategory().size(); i++) {
        String cval = config.getBinCategory().get(i);
        String dval = Normalizer.normalize(config, cval, cutoff).toString();
        Document document = null;
        try {
            document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        Element out = document.createElementNS(NAME_SPACE_URI, ELEMENT_OUT);
        out.setTextContent(dval);
        Element origin = document.createElementNS(NAME_SPACE_URI, ELEMENT_ORIGIN);
        origin.setTextContent(cval);
        inlineTable.withRows(new Row().withContent(origin).withContent(out));
    }
    MapValues mapValues = new MapValues("String_Node_Str").withDataType(DataType.DOUBLE).withDefaultValue("String_Node_Str").withFieldColumnPairs(new FieldColumnPair(new FieldName(config.getColumnName()), "String_Node_Str")).withInlineTable(inlineTable);
    mapValues.setMapMissingTo("String_Node_Str");
    return new DerivedField(OpType.CONTINUOUS, DataType.DOUBLE).withName(FieldName.create(config.getColumnName() + ZSCORE_POSTFIX)).withExpression(mapValues);
}

Output:
     }
-    MapValues mapValues = new MapValues("String_Node_Str").withDataType(DataType.DOUBLE).withDefaultValue("String_Node_Str").withFieldColumnPairs(new FieldColumnPair(new FieldName(config.getColumnName()), "String_Node_Str")).withInlineTable(inlineTable);
-    mapValues.setMapMissingTo("String_Node_Str");
+    MapValues mapValues = new MapValues("String_Node_Str").withDataType(DataType.DOUBLE).withDefaultValue(defaultValue).withFieldColumnPairs(new FieldColumnPair(new FieldName(config.getColumnName()), ELEMENT_ORIGIN)).withInlineTable(inlineTable).withMapMissingTo(missingValue);
     return new DerivedField(OpType.CONTINUOUS, DataType.DOUBLE).withName(FieldName.create(config.getColumnName() + ZSCORE_POSTFIX)).withExpression(mapValues);