Input:
public List<WindupRuleProvider> getProviders(GraphContext context) {
    List<WindupRuleProvider> providers = new ArrayList<>();
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
    dbFactory.setNamespaceAware(true);
    DocumentBuilder dBuilder = null;
    try {
        dBuilder = dbFactory.newDocumentBuilder();
    } catch (Exception e) {
        throw new WindupException("String_Node_Str" + e.getMessage(), e);
    }
    for (Map.Entry<Addon, List<URL>> addonFiles : getAddonWindupXmlFiles().entrySet()) {
        Addon addon = addonFiles.getKey();
        List<URL> urls = addonFiles.getValue();
        for (URL resource : urls) {
            try {
                Document doc = dBuilder.parse(resource.toURI().toString());
                ParserContext parser = new ParserContext(furnace);
                parser.setAddonContainingInputXML(addon);
                parser.processElement(doc.getDocumentElement());
                List<WindupRuleProvider> parsedProviders = parser.getRuleProviders();
                setOrigin(parsedProviders, resource);
                providers.addAll(parsedProviders);
            } catch (Exception e) {
                throw new WindupException("String_Node_Str" + resource.toString() + "String_Node_Str" + e.getMessage(), e);
            }
        }
    }
    WindupConfigurationModel cfg = WindupConfigurationService.getConfigurationModel(context);
    for (FileModel userRulesFileModel : cfg.getUserRulesPaths()) {
        for (URL resource : getWindupUserDirectoryXmlFiles(userRulesFileModel)) {
            try {
                Document doc = dBuilder.parse(resource.toURI().toString());
                ParserContext parser = new ParserContext(furnace);
                String userRulesPath = userRulesFileModel.getFilePath();
                parser.setXmlInputPath(Paths.get(userRulesPath));
                parser.processElement(doc.getDocumentElement());
                List<WindupRuleProvider> parsedProviders = parser.getRuleProviders();
                setOrigin(parsedProviders, resource);
                providers.addAll(parsedProviders);
            } catch (Exception e) {
                throw new WindupException("String_Node_Str" + resource.toString() + "String_Node_Str" + e.getMessage(), e);
            }
        }
    }
    return providers;
}

Output:
                 String userRulesPath = userRulesFileModel.getFilePath();
-                parser.setXmlInputPath(Paths.get(userRulesPath));
+                parser.setXmlInputPath(Paths.get(resource.toURI()));
+                parser.setXmlInputRootPath(Paths.get(userRulesPath));
                 parser.processElement(doc.getDocumentElement());


Input:
public void filesDropped(java.io.File[] files) {
    for (File file : files) {
        try {
            openGrid(file.getCanonicalPath());
        } catch (IOException ex) {
            ErrorDialog.showErrorDialog(OPEN_ERROR_MESSAGE, "String_Node_Str", ex, navigableImagePanel.getParent());
        }
    }
}

Output:
 public void filesDropped(java.io.File[] files) {
-    for (File file : files) {
-        try {
-            openGrid(file.getCanonicalPath());
-        } catch (IOException ex) {
-            ErrorDialog.showErrorDialog(OPEN_ERROR_MESSAGE, "String_Node_Str", ex, navigableImagePanel.getParent());
+    try {
+        int maxNbrFilesToScan = Math.min(files.length, 100);
+        for (int i = 0; i < maxNbrFilesToScan; i++) {
+            String filePath = files[i].getCanonicalPath();
+            if (EsriASCIIGridReader.canRead(filePath)) {
+                openGrid(filePath);
+            }
         }


Input:
public IPage newPage(int width, int height, Color backgroundColor) {
    currentPage = new PDFPage(width, height, doc, writer);
    currentPage.drawBackgroundColor(backgroundColor, 0, 0, width, height);
    return currentPage;
}

Output:
 public IPage newPage(int width, int height, Color backgroundColor) {
-    currentPage = new PDFPage(width, height, doc, writer);
+    currentPage = new PDFPage(width, height, doc, writer, this);
     currentPage.drawBackgroundColor(backgroundColor, 0, 0, width, height);


Input:
static JUnitModel getJUnitModel() {
    if (junitModel == null) {
        Exception cause = null;
        try {
            Class<?> clazz;
            try {
                clazz = Class.forName("String_Node_Str");
            } catch (ClassNotFoundException e) {
                clazz = Class.forName("String_Node_Str");
            }
            Method method = clazz.getDeclaredMethod("String_Node_Str");
            junitModel = (JUnitModel) method.invoke(null);
        } catch (Exception e) {
            NoClassDefFoundError error = new NoClassDefFoundError("String_Node_Str");
            error.initCause(cause);
            throw error;
        }
    }
    return junitModel;
}

Output:
             NoClassDefFoundError error = new NoClassDefFoundError("String_Node_Str");
-            error.initCause(cause);
+            error.initCause(e);
             throw error;


Input:
public OverlayEdgeWrapper<V, E> refTo(final OverlayEdgeWrapper<V, E> obj) {
    we = wrapper.idmap.getEdge(obj.getInternalPoolIndex(), we);
    return this;
}

Output:
 public OverlayEdgeWrapper<V, E> refTo(final OverlayEdgeWrapper<V, E> obj) {
-    we = wrapper.idmap.getEdge(obj.getInternalPoolIndex(), we);
+    we = wrapper.idmap.getEdge(obj.getInternalPoolIndex(), ref);
     return this;


Input:
public boolean compile(String configFile, BuildProgressMonitor progressMonitor, boolean buildModel) {
    if (configFile == null) {
        Ajde.getDefault().getErrorHandler().handleError("String_Node_Str");
    }
    init();
    try {
        AjBuildConfig buildConfig = genBuildConfig(configFile);
        buildConfig.setGenerateModelMode(buildModel);
        if (null == buildConfig) {
            return false;
        }
        currNotifier = new BuildNotifierAdapter(progressMonitor, buildManager);
        buildManager.setProgressListener(currNotifier);
        messageHandler.setBuildNotifierAdapter(currNotifier);
        String rtInfo = buildManager.checkRtJar(buildConfig);
        if (rtInfo != null) {
            Ajde.getDefault().getErrorHandler().handleWarning("String_Node_Str" + rtInfo + "String_Node_Str");
            return false;
        }
        boolean incrementalEnabled = buildConfig.isIncrementalMode() || buildConfig.isIncrementalFileMode();
        if (incrementalEnabled && nextBuild) {
            return buildManager.incrementalBuild(buildConfig, messageHandler);
        } else {
            if (incrementalEnabled) {
                nextBuild = incrementalEnabled;
            }
            return buildManager.batchBuild(buildConfig, messageHandler);
        }
    } catch (AbortException e) {
        final IMessage message = e.getIMessage();
        if (null == message) {
            signalThrown(e);
        } else if (null != message.getMessage()) {
            Ajde.getDefault().getErrorHandler().handleWarning(message.getMessage());
        } else if (null != message.getThrown()) {
            signalThrown(message.getThrown());
        } else {
            signalThrown(e);
        }
        return false;
    } catch (Throwable t) {
        signalThrown(t);
        return false;
    }
}

Output:
         AjBuildConfig buildConfig = genBuildConfig(configFile);
-        buildConfig.setGenerateModelMode(buildModel);
-        if (null == buildConfig) {
+        if (buildConfig == null) {
             return false;


Input:
public final ApplicabilityGrammarParser.multiple_compounds_return multiple_compounds() throws RecognitionException {
    ApplicabilityGrammarParser.multiple_compounds_return retval = new ApplicabilityGrammarParser.multiple_compounds_return();
    retval.start = input.LT(1);
    CommonTree root_0 = null;
    ApplicabilityGrammarParser.start_compound_return start_compound24 = null;
    ApplicabilityGrammarParser.operator_return operator25 = null;
    ApplicabilityGrammarParser.compound_value_return compound_value26 = null;
    try {
        {
            root_0 = (CommonTree) adaptor.nil();
            pushFollow(FOLLOW_start_compound_in_multiple_compounds314);
            start_compound24 = start_compound();
            state._fsp--;
            adaptor.addChild(root_0, start_compound24.getTree());
            pushFollow(FOLLOW_operator_in_multiple_compounds326);
            operator25 = operator();
            state._fsp--;
            adaptor.addChild(root_0, operator25.getTree());
            featureId_values_map.get(featureId).add((operator25 != null ? input.toString(operator25.start, operator25.stop) : null));
            pushFollow(FOLLOW_compound_value_in_multiple_compounds340);
            compound_value26 = compound_value();
            state._fsp--;
            adaptor.addChild(root_0, compound_value26.getTree());
        }
        retval.stop = input.LT(-1);
        retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
        adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    } catch (RecognitionException re) {
        reportError(re);
        recover(input, re);
        retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);
    } finally {
    }
    return retval;
}

Output:
             adaptor.addChild(root_0, operator25.getTree());
-            featureId_values_map.get(featureId).add((operator25 != null ? input.toString(operator25.start, operator25.stop) : null));
+            featureId_values_map.get(featureId).add((input.toString(operator25.start, operator25.stop)));
             pushFollow(FOLLOW_compound_value_in_multiple_compounds340);


Input:
public boolean isBluetoothLowEnergySupported() {
    return bluetoothAdapter != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2 && context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
}

Output:
 public boolean isBluetoothLowEnergySupported() {
-    return bluetoothAdapter != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2 && context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
+    return bluetoothAdapter != null && crashCallBackWrapper != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2 && context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
 }


Input:
public StorageFacade getStorageFacade() {
    return recordCursor.getStorageFacade();
}

Output:
 public StorageFacade getStorageFacade() {
-    return recordCursor.getStorageFacade();
+    return storageFacade;
 }


Input:
public void setUp() {
    root = Root.create(new ChangeReporterImpl());
    manager = new ManagerImpl(root, MANAGER_ID);
    item = new AbstractItemImpl(root, ITEM_ID);
    anotherItem = new AbstractItemImpl(manager, ANOTHER_ID);
}

Output:
 public void setUp() {
-    root = Root.create(new ChangeReporterImpl());
+    root = Root.create();
     manager = new ManagerImpl(root, MANAGER_ID);


Input:
public void handlePremium(DownloadLink downloadLink, Account account) throws Exception {
    requestFileInformation(downloadLink);
    login(account);
    br.setFollowRedirects(true);
    dl = jd.plugins.BrowserAdapter.openDownload(br, downloadLink, downloadLink.getDownloadURL(), true, 0);
    if (!dl.getConnection().isContentDisposition()) {
        br.followConnection();
        throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFECT);
    }
    dl.startDownload();
}

Output:
     login(account);
-    br.setFollowRedirects(true);
-    dl = jd.plugins.BrowserAdapter.openDownload(br, downloadLink, downloadLink.getDownloadURL(), true, 0);
+    br.getPage("String_Node_Str");
+    br.setFollowRedirects(false);
+    br.getPage(downloadLink.getDownloadURL());
+    String url = null;
+    if (br.getRedirectLocation() == null) {
+        throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFECT);
+    } else {
+        url = br.getRedirectLocation();
+    }
+    if (url == null)
+        throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFECT);
+    dl = jd.plugins.BrowserAdapter.openDownload(br, downloadLink, url, true, 0);
     if (!dl.getConnection().isContentDisposition()) {


Input:
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float sx, float sy, float sz) {
    WrenchUsage wrenchUsed = testWrenchUsage(x, y, z, player);
    if (wrenchUsed == WrenchUsage.NORMAL) {
        if (world.isRemote) {
            MatterBeamerTileEntity matterBeamerTileEntity = (MatterBeamerTileEntity) world.getTileEntity(x, y, z);
            world.playSound(x, y, z, "String_Node_Str", 1.0f, 1.0f, false);
            matterBeamerTileEntity.useWrench(player);
        }
        return true;
    } else if (wrenchUsed == WrenchUsage.SNEAKING) {
        breakAndRemember(world, x, y, z);
        return true;
    } else {
        return openGui(world, x, y, z, player);
    }
}

Output:
     } else if (wrenchUsed == WrenchUsage.SNEAKING) {
-        breakAndRemember(world, x, y, z);
+        breakAndRemember(world, player, x, y, z);
         return true;


Input:
public XMLRecord buildRow(XMLRecord record, Object object, CoreAbstractSession session, Marshaller marshaller, XPathFragment rootFragment) {
    lazyInitialize();
    XPathNode textNode = rootXPathNode.getTextNode();
    List<XPathNode> nonAttributeChildren = rootXPathNode.getNonAttributeChildren();
    if (null == textNode && null == nonAttributeChildren) {
        return record;
    }
    Descriptor xmlDescriptor = (Descriptor) descriptor;
    XPathNode node = rootXPathNode;
    MarshalRecord marshalRecord = (MarshalRecord) record;
    QName schemaType = null;
    if (marshalRecord.getCycleDetectionStack().contains(object, marshaller.isEqualUsingIdenity())) {
        if (cycleRecoverableClass == null) {
            initCycleRecoverableClasses();
        }
        if (cycleRecoverableClass != null && cycleRecoverableClass.isAssignableFrom(object.getClass())) {
            try {
                Object jaxbMarshaller = marshaller.getProperty(Constants.JAXB_MARSHALLER);
                Object contextProxy = CycleRecoverableContextProxy.getProxy(cycleRecoverableContextClass, jaxbMarshaller);
                Method onCycleDetectedMethod = object.getClass().getMethod(ON_CYCLE_DETECTED, new Class[] { cycleRecoverableContextClass });
                object = PrivilegedAccessHelper.invokeMethod(onCycleDetectedMethod, object, new Object[] { contextProxy });
            } catch (Exception e) {
                throw XMLMarshalException.marshalException(e);
            }
            xmlDescriptor = (Descriptor) session.getDescriptor(object.getClass());
            if (xmlDescriptor != null) {
                node = ((TreeObjectBuilder) xmlDescriptor.getObjectBuilder()).getRootXPathNode();
            } else {
                node = null;
            }
            marshalRecord.getCycleDetectionStack().push(object);
            if (xmlDescriptor != descriptor) {
                if (xmlDescriptor == null) {
                    schemaType = (QName) XMLConversionManager.getDefaultJavaTypes().get(object.getClass());
                } else {
                    schemaType = xmlDescriptor.getSchemaReference().getSchemaContextAsQName();
                }
                marshalRecord.writeXsiTypeAttribute(xmlDescriptor, schemaType.getNamespaceURI(), schemaType.getLocalPart(), schemaType.getPrefix(), false);
            }
        } else {
            marshalRecord.getCycleDetectionStack().push(object);
            throw XMLMarshalException.objectCycleDetected(marshalRecord.getCycleDetectionStack().getCycleString());
        }
    } else {
        marshalRecord.getCycleDetectionStack().push(object);
    }
    NamespaceResolver namespaceResolver = null;
    if (xmlDescriptor != null) {
        namespaceResolver = xmlDescriptor.getNamespaceResolver();
    }
    MarshalContext marshalContext = null;
    if (xmlDescriptor != null && xmlDescriptor.isSequencedObject()) {
        SequencedObject sequencedObject = (SequencedObject) object;
        marshalContext = new SequencedMarshalContext(sequencedObject.getSettings());
    } else {
        marshalContext = ObjectMarshalContext.getInstance();
    }
    if (null == nonAttributeChildren) {
        textNode.marshal((MarshalRecord) record, object, session, namespaceResolver, marshaller, marshalContext, rootFragment);
    } else {
        if (node == null) {
            XPathNode n = new XPathNode();
            CompositeObjectMapping m = new XMLCompositeObjectMapping();
            m.setXPath("String_Node_Str");
            XMLCompositeObjectMappingNodeValue nv = new XMLCompositeObjectMappingNodeValue(m);
            n.setMarshalNodeValue(nv);
            nv.marshalSingleValue(new XPathFragment("String_Node_Str"), marshalRecord, null, object, session, namespaceResolver, marshalContext);
        } else {
            for (int x = 0, size = marshalContext.getNonAttributeChildrenSize(node); x < size; x++) {
                XPathNode xPathNode = (XPathNode) marshalContext.getNonAttributeChild(x, node);
                xPathNode.marshal((MarshalRecord) record, object, session, namespaceResolver, marshaller, marshalContext.getMarshalContext(x), rootFragment);
            }
        }
    }
    marshalRecord.getCycleDetectionStack().pop();
    return record;
}

Output:
             if (xmlDescriptor != null) {
-                node = ((TreeObjectBuilder) xmlDescriptor.getObjectBuilder()).getRootXPathNode();
+                node = ((ObjectBuilder) xmlDescriptor.getObjectBuilder()).getRootXPathNode();
             } else {


Input:
public static String encodeComponent(String decodedURLComponent) {
    StringValidator.throwIfEmptyOrNull("String_Node_Str", decodedURLComponent);
    return encodeComponentImpl(decodedURLComponent);
}

Output:
 public static String encodeComponent(String decodedURLComponent) {
-    StringValidator.throwIfEmptyOrNull("String_Node_Str", decodedURLComponent);
+    StringValidator.throwIfNull("String_Node_Str", decodedURLComponent);
     return encodeComponentImpl(decodedURLComponent);


Input:
private void solveNonCalligReferences(List<ASTCssNode> childs, IteratedScope iteratedScope) {
    IScopeAwareExpressionsEvaluator cssGuardsValidator = new IScopeAwareExpressionsEvaluator(iteratedScope.getScope(), problemsHandler, configuration);
    for (ASTCssNode kid : childs) {
        if (isMixinReference(kid) || isDetachedRulesetReference(kid))
            continue;
        if (isRuleset(kid)) {
            RuleSet ruleSet = (RuleSet) kid;
            if (cssGuardsValidator.guardsSatisfied(ruleSet)) {
                ruleSet.removeGuards();
            } else {
                manipulator.removeFromClosestBody(ruleSet);
                iteratedScope.getNextChild();
                continue;
            }
        }
        if (AstLogic.isQuotelessUrlFunction(kid)) {
            continue;
        }
        if (AstLogic.hasOwnScope(kid)) {
            IteratedScope scope = iteratedScope.getNextChild();
            doSolveReferences(kid, scope);
        } else {
            boolean finishedNode = solveIfVariableReference(kid, iteratedScope.getScope());
            if (!finishedNode)
                unsafeDoSolveReferences(kid, iteratedScope);
        }
    }
}

Output:
 private void solveNonCalligReferences(List<ASTCssNode> childs, IteratedScope iteratedScope) {
-    IScopeAwareExpressionsEvaluator cssGuardsValidator = new IScopeAwareExpressionsEvaluator(iteratedScope.getScope(), problemsHandler, configuration);
+    ExpressionsEvaluator cssGuardsValidator = new ExpressionsEvaluator(iteratedScope.getScope(), problemsHandler, configuration);
     for (ASTCssNode kid : childs) {


Input:
public void handleEvent(BMIModuleEvent event) {
    if (!modletFactories.containsKey(event.getModuleId())) {
        logService.log(LogService.LOG_ERROR, "String_Node_Str" + event.getModuleId());
        return;
    }
    try {
        List<IModlet> ml;
        switch(event.getType()) {
            case INSERT:
                for (IModletFactory mf : modletFactories.get(event.getModuleId())) {
                    IModlet m = mf.createModlet(context, event.getSlot(), event.getBMIDevice());
                    try {
                        m.setup();
                    } catch (Exception e) {
                        logService.log(LogService.LOG_ERROR, "String_Node_Str" + mf.getName() + "String_Node_Str" + e.getMessage());
                        continue;
                    }
                    m.start();
                    logService.log(LogService.LOG_INFO, "String_Node_Str" + mf.getName() + "String_Node_Str");
                    if (!activeModlets.containsKey(m.getModuleId())) {
                        activeModlets.put(m.getModuleId(), new ArrayList<IModlet>());
                    }
                    List<IModlet> am = activeModlets.get(m.getModuleId());
                    if (!am.contains(m)) {
                        am.add(m);
                    }
                }
                break;
            case REMOVE:
                List<IModlet> removalList = new ArrayList<IModlet>();
                ml = activeModlets.get(event.getModuleId());
                for (IModlet m : ml) {
                    if (m.getSlotId() == event.getSlot()) {
                        logService.log(LogService.LOG_INFO, "String_Node_Str" + m.getModuleId() + "String_Node_Str");
                        m.stop();
                        removalList.add(m);
                    }
                }
                for (IModlet m : ml) ml.remove(m);
                removalList.clear();
                logService.log(LogService.LOG_INFO, "String_Node_Str");
                break;
        }
    } catch (BundleException e) {
        logService.log(LogService.LOG_ERROR, "String_Node_Str" + e.getClass().getName() + "String_Node_Str" + e.getMessage());
        StringWriter sw = new StringWriter();
        e.printStackTrace(new PrintWriter(sw));
        logService.log(LogService.LOG_ERROR, sw.getBuffer().toString());
        if (e.getNestedException() != null) {
            logService.log(LogService.LOG_ERROR, "String_Node_Str" + e.getNestedException().getClass().getName() + "String_Node_Str" + e.getNestedException().getMessage());
        }
        e.printStackTrace();
    } catch (Exception e) {
        logService.log(LogService.LOG_ERROR, "String_Node_Str" + e.getClass().getName() + "String_Node_Str" + e.getMessage());
        StringWriter sw = new StringWriter();
        e.printStackTrace(new PrintWriter(sw));
        logService.log(LogService.LOG_ERROR, sw.getBuffer().toString());
    }
}

Output:
                     } catch (Exception e) {
-                        logService.log(LogService.LOG_ERROR, "String_Node_Str" + mf.getName() + "String_Node_Str" + e.getMessage());
+                        logService.log(LogService.LOG_ERROR, "String_Node_Str" + mf.getName() + "String_Node_Str" + e.getMessage(), e);
                         continue;


Input:
private Tile[] loadTiles(ListComponent<String[]> lines) {
    Tile[] tiles = new Tile[lines.size() - 1];
    for (int i = 1; i < lines.size(); i++) {
        String[] line = lines.get(i);
        Tile tile = new Tile();
        tile.scatteringLength = Double.valueOf(line[0]);
        tile.trueAbsLength = Double.valueOf(line[1]);
        tile.incAbsLength = Double.valueOf(line[2]);
        tile.thickness = Double.valueOf(line[3]);
        tiles[i - 1] = tile;
    }
    return tiles;
}

Output:
 private Tile[] loadTiles(ListComponent<String[]> lines) {
-    Tile[] tiles = new Tile[lines.size() - 1];
-    for (int i = 1; i < lines.size(); i++) {
+    Tile[] tiles = new Tile[lines.size() - 2];
+    for (int i = 2; i < lines.size(); i++) {
         String[] line = lines.get(i);


Input:
public String getQuery() {
    QueryBuilder queryBuilder = new QueryBuilder(mUpdate.getQuery()).append("String_Node_Str").append(mConditionQueryBuilder.getQuery());
    return queryBuilder.getQuery();
}

Output:
 public String getQuery() {
-    QueryBuilder queryBuilder = new QueryBuilder(mUpdate.getQuery()).append("String_Node_Str").append(mConditionQueryBuilder.getQuery());
+    QueryBuilder queryBuilder = new QueryBuilder(mUpdate.getQuery()).append("String_Node_Str").append(mConditionQueryBuilder.getQuery()).appendSpace();
     return queryBuilder.getQuery();


Input:
public Enumeration<String> getParameterNames() {
    return new Vector<String>(parameterMap.keySet()).elements();
}

Output:
 public Enumeration<String> getParameterNames() {
-    return new Vector<String>(parameterMap.keySet()).elements();
+    return new Vector<String>(params.keySet()).elements();
 }


Input:
protected void addLevelMemberSql(SqlQuery sqlQuery, RolapLevel level, RolapCube baseCube, WhichSelect whichSelect, AggStar aggStar) {
    RolapHierarchy hierarchy = level.getHierarchy();
    if (hierarchy instanceof RolapCubeHierarchy) {
        RolapCubeHierarchy cubeHierarchy = (RolapCubeHierarchy) hierarchy;
        if (baseCube != null && !cubeHierarchy.getCube().equals(baseCube)) {
            hierarchy = baseCube.findBaseCubeHierarchy(hierarchy);
        }
    }
    RolapLevel[] levels = (RolapLevel[]) hierarchy.getLevels();
    int levelDepth = level.getDepth();
    boolean needsGroupBy = isGroupByNeeded(sqlQuery, hierarchy, levels, levelDepth);
    for (int i = 0; i <= levelDepth; i++) {
        RolapLevel currLevel = levels[i];
        if (currLevel.isAll()) {
            continue;
        }
        boolean levelCollapsed = (aggStar != null) && SqlMemberSource.isLevelCollapsed(aggStar, (RolapCubeLevel) currLevel);
        boolean multipleCols = SqlMemberSource.levelContainsMultipleColumns(currLevel);
        if (levelCollapsed && !multipleCols) {
            RolapStar.Column starColumn = ((RolapCubeLevel) currLevel).getStarKeyColumn();
            int bitPos = starColumn.getBitPosition();
            AggStar.Table.Column aggColumn = aggStar.lookupColumn(bitPos);
            String q = aggColumn.generateExprString(sqlQuery);
            sqlQuery.addSelectGroupBy(q, starColumn.getInternalType());
            if (whichSelect == WhichSelect.ONLY) {
                sqlQuery.addOrderBy(q, true, false, true);
            }
            aggColumn.getTable().addToFrom(sqlQuery, false, true);
            continue;
        }
        MondrianDef.Expression keyExp = currLevel.getKeyExp();
        MondrianDef.Expression ordinalExp = currLevel.getOrdinalExp();
        MondrianDef.Expression captionExp = currLevel.getCaptionExp();
        MondrianDef.Expression parentExp = currLevel.getParentExp();
        if (parentExp != null) {
            if (!levelCollapsed) {
                hierarchy.addToFrom(sqlQuery, parentExp);
            }
            String parentSql = parentExp.getExpression(sqlQuery);
            sqlQuery.addSelectGroupBy(parentSql, currLevel.getInternalType());
            if (whichSelect == WhichSelect.LAST || whichSelect == WhichSelect.ONLY) {
                sqlQuery.addOrderBy(parentSql, true, false, true, false);
            }
        }
        String keySql = keyExp.getExpression(sqlQuery);
        String ordinalSql = ordinalExp.getExpression(sqlQuery);
        if (!levelCollapsed) {
            hierarchy.addToFrom(sqlQuery, keyExp);
            hierarchy.addToFrom(sqlQuery, ordinalExp);
        }
        String captionSql = null;
        if (captionExp != null) {
            captionSql = captionExp.getExpression(sqlQuery);
            if (!levelCollapsed) {
                hierarchy.addToFrom(sqlQuery, captionExp);
            }
        }
        String alias = sqlQuery.addSelect(keySql, currLevel.getInternalType());
        if (needsGroupBy) {
            sqlQuery.addGroupBy(keySql, alias);
        }
        if (captionSql != null) {
            alias = sqlQuery.addSelect(captionSql, null);
            if (needsGroupBy) {
                sqlQuery.addGroupBy(captionSql, alias);
            }
        }
        if (!ordinalSql.equals(keySql)) {
            alias = sqlQuery.addSelect(ordinalSql, null);
            if (needsGroupBy) {
                sqlQuery.addGroupBy(ordinalSql, alias);
            }
        }
        constraint.addLevelConstraint(sqlQuery, baseCube, aggStar, currLevel);
        if (levelCollapsed) {
            hierarchy.addToFromInverse(sqlQuery, keyExp);
            RolapStar.Column starColumn = ((RolapCubeLevel) currLevel).getStarKeyColumn();
            int bitPos = starColumn.getBitPosition();
            AggStar.Table.Column aggColumn = aggStar.lookupColumn(bitPos);
            RolapStar.Condition condition = new RolapStar.Condition(keyExp, aggColumn.getExpression());
            sqlQuery.addWhere(condition.toString(sqlQuery));
        }
        if (whichSelect == WhichSelect.ONLY) {
            sqlQuery.addOrderBy(ordinalSql, true, false, true);
        }
        RolapProperty[] properties = currLevel.getProperties();
        for (RolapProperty property : properties) {
            final MondrianDef.Expression propExp = property.getExp();
            final String propSql;
            if (propExp instanceof MondrianDef.Column) {
                propSql = sqlQuery.getDialect().quoteIdentifier(currLevel.getTableAlias(), ((MondrianDef.Column) propExp).name);
            } else {
                propSql = property.getExp().getExpression(sqlQuery);
            }
            alias = sqlQuery.addSelect(propSql, null);
            if (needsGroupBy) {
                if (!sqlQuery.getDialect().allowsSelectNotInGroupBy() || !property.dependsOnLevelValue()) {
                    sqlQuery.addGroupBy(propSql, alias);
                }
            }
        }
    }
}

Output:
             String q = aggColumn.generateExprString(sqlQuery);
-            sqlQuery.addSelectGroupBy(q, starColumn.getInternalType());
+            final String qAlias = sqlQuery.addSelectGroupBy(q, starColumn.getInternalType());
             if (whichSelect == WhichSelect.ONLY) {


Input:
public void validateIfHostCanSatisfied(int instanceNum) {
    if (getInstancePerHost() != null) {
        int requiredHostNum = instanceNum / getInstancePerHost();
        if (getGroupRacks() != null) {
            GroupRacks groupRacks = (GroupRacks) new Gson().fromJson(getGroupRacks(), GroupRacks.class);
            GroupRacksType rackType = groupRacks.getType();
            List<RackInfo> racksInfo = new RackInfoManager().exportRackInfo();
            Set<String> specifiedRacks = new HashSet<String>(Arrays.asList(groupRacks.getRacks()));
            List<String> IntersecRacks = new ArrayList<String>();
            Integer IntersecHostNum = 0;
            Integer maxIntersecHostNum = 0;
            for (RackInfo rackInfo : racksInfo) {
                if (specifiedRacks.isEmpty() || specifiedRacks.size() == 0 || specifiedRacks.contains(rackInfo.getName())) {
                    IntersecHostNum += rackInfo.getHosts().size();
                    IntersecRacks.add(rackInfo.getName());
                    if (rackInfo.getHosts().size() > maxIntersecHostNum) {
                        maxIntersecHostNum = rackInfo.getHosts().size();
                    }
                }
            }
            if (rackType.equals(GroupRacksType.ROUNDROBIN) && IntersecHostNum < requiredHostNum) {
                throw ClusterConfigException.LACK_PHYSICAL_HOSTS(this.name, requiredHostNum, IntersecHostNum);
            } else if (rackType.equals(GroupRacksType.SAMERACK) && requiredHostNum > maxIntersecHostNum) {
                throw ClusterConfigException.LACK_PHYSICAL_HOSTS(this.name, requiredHostNum, maxIntersecHostNum);
            }
            groupRacks.setRacks(IntersecRacks.toArray(new String[IntersecRacks.size()]));
            setGroupRacks((new Gson()).toJson(groupRacks));
        }
    }
}

Output:
             }
-            groupRacks.setRacks(IntersecRacks.toArray(new String[IntersecRacks.size()]));
+            if (specifiedRacks.isEmpty()) {
+                groupRacks.setRacks(new String[0]);
+            } else {
+                groupRacks.setRacks(IntersecRacks.toArray(new String[IntersecRacks.size()]));
+            }
             setGroupRacks((new Gson()).toJson(groupRacks));


Input:
protected void buildAggregateModifyQuery(ObjectLevelModifyQuery sourceQuery, ObjectLevelModifyQuery aggregateQuery, Object sourceAttributeValue) {
    if (sourceQuery.getSession().isUnitOfWork()) {
        Object backupAttributeValue = getAttributeValueFromBackupClone(sourceQuery.getBackupClone());
        if (backupAttributeValue == null) {
            backupAttributeValue = getObjectBuilder(sourceAttributeValue, sourceQuery.getSession()).buildNewInstance();
        }
        aggregateQuery.setBackupClone(backupAttributeValue);
    }
    aggregateQuery.setCascadePolicy(sourceQuery.getCascadePolicy());
    aggregateQuery.setObject(sourceAttributeValue);
    aggregateQuery.setTranslationRow(sourceQuery.getTranslationRow());
    aggregateQuery.setSession(sourceQuery.getSession());
    aggregateQuery.setProperties(sourceQuery.getProperties());
}

Output:
 protected void buildAggregateModifyQuery(ObjectLevelModifyQuery sourceQuery, ObjectLevelModifyQuery aggregateQuery, Object sourceAttributeValue) {
-    if (sourceQuery.getSession().isUnitOfWork()) {
+    if (sourceQuery.getSession().isUnitOfWork() && !isMapKeyMapping()) {
         Object backupAttributeValue = getAttributeValueFromBackupClone(sourceQuery.getBackupClone());


Input:
public PipelineSpec build() {
    return new PipelineSpec(stages, connections, resources, stageLoggingEnabled, numOfRecordsPreview);
}

Output:
 public PipelineSpec build() {
-    return new PipelineSpec(stages, connections, resources, stageLoggingEnabled, numOfRecordsPreview);
+    return new PipelineSpec(stages, connections, resources, driverResources, clientResources, stageLoggingEnabled, numOfRecordsPreview);
 }


Input:
public void beforeNewForm(HttpServletRequest req) throws TransactionException {
    this.req = req;
    Object ob = req.getSession().getAttribute("String_Node_Str");
    Object ob2 = req.getAttribute("String_Node_Str");
    if (!(ob instanceof RIS || ob2 instanceof RIS)) {
        req.getSession().removeAttribute("String_Node_Str");
        req.removeAttribute("String_Node_Str");
    }
    req.setAttribute("String_Node_Str", im.getAllItems());
    req.setAttribute("String_Node_Str", dom.getAllDivisionOffice());
    req.setAttribute("String_Node_Str", pm.getAllEmployee());
}

Output:
     if (!(ob instanceof RIS || ob2 instanceof RIS)) {
-        req.getSession().removeAttribute("String_Node_Str");
-        req.removeAttribute("String_Node_Str");
+        String retain = (String) req.getParameter("String_Node_Str");
+        if (retain == null) {
+            req.getSession().removeAttribute("String_Node_Str");
+            req.removeAttribute("String_Node_Str");
+        }
     }


Input:
public boolean imageUpdate(Image image, int infoflags, int x, int y, int width, int height) {
    if ((infoflags & (ImageObserver.HEIGHT | ImageObserver.WIDTH)) != 0) {
        _height = height;
        _width = width;
        _image.getWidth(this);
        _image.getHeight(this);
        return true;
    }
    if ((infoflags & ImageObserver.ALLBITS) != 0) {
        scaleImage(_scalePercentage);
        Runnable doRepaint = new Runnable() {
            public void run() {
                Iterator figures = _liveFigureIterator();
                while (figures.hasNext()) {
                    Object figure = figures.next();
                    ((ImageFigure) figure).repaint();
                }
            }
        };
        SwingUtilities.invokeLater(doRepaint);
        return false;
    }
    if ((infoflags & (ImageObserver.ERROR | ImageObserver.ABORT)) != 0) {
        return false;
    }
    _image.getWidth(this);
    _image.getHeight(this);
    return true;
}

Output:
     if ((infoflags & ImageObserver.ALLBITS) != 0) {
-        scaleImage(_scalePercentage);
-        Runnable doRepaint = new Runnable() {
-            public void run() {
-                Iterator figures = _liveFigureIterator();
-                while (figures.hasNext()) {
-                    Object figure = figures.next();
-                    ((ImageFigure) figure).repaint();
-                }
-            }
-        };
-        SwingUtilities.invokeLater(doRepaint);
+        if (_scalePercentage != 0.0 && _scalePercentage != _scalePercentageImplemented) {
+            scaleImage(_scalePercentage);
+            return true;
+        }
+        _updateFigures();
         return false;


Input:
public static Set<String> getDerivedMeasureNames(List<IBinding> bindings) throws DataException {
    Set<String> directRef = new HashSet<String>();
    Set<String> all = new HashSet<String>();
    for (IBinding binding : bindings) {
        all.add(binding.getBindingName());
        if (isDirectRerenrence(binding.getExpression(), bindings)) {
            directRef.add(binding.getBindingName());
        }
    }
    all.removeAll(directRef);
    return all;
}

Output:
     for (IBinding binding : bindings) {
-        all.add(binding.getBindingName());
+        if (isReferenceToLevelOrMeasure(binding.getExpression(), bindings))
+            all.add(binding.getBindingName());
         if (isDirectRerenrence(binding.getExpression(), bindings)) {


Input:
public void logout() {
    synchronized (this) {
        if (connection != null) {
            if (LOG.isInfoEnabled())
                LOG.info("String_Node_Str" + configuration.getServiceName() + "String_Node_Str" + configuration.getHost() + "String_Node_Str" + configuration.getPort() + "String_Node_Str");
            try {
                connection.disconnect();
            } catch (NullPointerException npe) {
            }
            addressIQListener.dispose();
            authTokenIQListener.dispose();
            addressIQListener = null;
            fileTransferIQListener = null;
            authTokenIQListener = null;
            synchronized (users) {
                users.clear();
            }
            LOG.info("String_Node_Str");
        }
    }
}

Output:
     synchronized (this) {
-        if (connection != null) {
-            if (LOG.isInfoEnabled())
-                LOG.info("String_Node_Str" + configuration.getServiceName() + "String_Node_Str" + configuration.getHost() + "String_Node_Str" + configuration.getPort() + "String_Node_Str");
-            try {
-                connection.disconnect();
-            } catch (NullPointerException npe) {
-            }
-            addressIQListener.dispose();
-            authTokenIQListener.dispose();
-            addressIQListener = null;
-            fileTransferIQListener = null;
-            authTokenIQListener = null;
+        if (connection != null && connection.isAuthenticated()) {
+            LOG.infof("String_Node_Str", configuration.getServiceName(), configuration.getHost(), configuration.getPort());
+            connection.disconnect();
             synchronized (users) {


Input:
public Iterator iterator() {
    return widgetMap.values().iterator();
}

Output:
 public Iterator iterator() {
-    return widgetMap.values().iterator();
+    return widgetMap.widgetIterator();
 }


Input:
private void runExperiment(String methodName, boolean detailedLog) {
    Integrator integrator;
    int experimentRepetitions = 1;
    Matcher patternMatcher = Pattern.compile("String_Node_Str").matcher(methodName);
    if (patternMatcher.find()) {
        methodName = patternMatcher.group(1);
        if (patternMatcher.group(2) != null)
            experimentRepetitions = Integer.parseInt(patternMatcher.group(2));
    }
    List<Results> results = new ArrayList<>();
    for (int repetition = 0; repetition < experimentRepetitions; repetition++) {
        if (methodName.equals("String_Node_Str")) {
            integrator = new MajorityVoteIntegrator.Builder(predictedData).build();
        } else if (methodName.startsWith("String_Node_Str")) {
            String[] methodNameParts = methodName.split("String_Node_Str");
            if (methodNameParts.length == 1)
                integrator = new AgreementIntegrator.Builder(predictedData).highestOrder(-1).build();
            else
                integrator = new AgreementIntegrator.Builder(predictedData).highestOrder(Integer.parseInt(methodNameParts[1])).build();
        } else if (methodName.startsWith("String_Node_Str")) {
            String[] methodNameParts = methodName.split("String_Node_Str");
            if (methodNameParts.length == 1)
                integrator = new BayesianIntegrator.Builder(predictedData).build();
            else
                integrator = new BayesianIntegrator.Builder(predictedData).numberOfBurnInSamples(Integer.parseInt(methodNameParts[1])).numberOfThinningSamples(Integer.parseInt(methodNameParts[2])).numberOfSamples(Integer.parseInt(methodNameParts[3])).build();
        } else if (methodName.startsWith("String_Node_Str")) {
            String[] methodNameParts = methodName.split("String_Node_Str");
            if (methodNameParts.length == 1)
                integrator = new CoupledBayesianIntegrator.Builder(predictedData).build();
            else
                integrator = new CoupledBayesianIntegrator.Builder(predictedData).numberOfBurnInSamples(Integer.parseInt(methodNameParts[1])).numberOfThinningSamples(Integer.parseInt(methodNameParts[2])).numberOfSamples(Integer.parseInt(methodNameParts[3])).build();
        } else if (methodName.startsWith("String_Node_Str")) {
            String[] methodNameParts = methodName.split("String_Node_Str");
            if (methodNameParts.length == 1)
                integrator = new HierarchicalCoupledBayesianIntegrator.Builder(predictedData).build();
            else
                integrator = new HierarchicalCoupledBayesianIntegrator.Builder(predictedData).numberOfBurnInSamples(Integer.parseInt(methodNameParts[1])).numberOfThinningSamples(Integer.parseInt(methodNameParts[2])).numberOfSamples(Integer.parseInt(methodNameParts[3])).build();
        } else if (methodName.startsWith("String_Node_Str")) {
            integrator = new TuffyLogicIntegrator.Builder(predictedData).addConstraints(constraints).workingDirectory("String_Node_Str").logProgress(detailedLog).build();
        } else if (methodName.startsWith("String_Node_Str")) {
            String[] methodNameParts = methodName.split("String_Node_Str");
            if (methodNameParts.length == 1) {
                integrator = new LogicIntegrator.Builder(predictedData).addConstraints(constraints).logProgress(detailedLog).build();
            } else {
                boolean sampleEstimates = methodNameParts[methodNameParts.length - 1].equals("String_Node_Str");
                integrator = new LogicIntegrator.Builder(predictedData).addConstraints(constraints).sampleErrorRatesEstimates(sampleEstimates).logProgress(detailedLog).build();
            }
        } else {
            throw new IllegalArgumentException("String_Node_Str" + methodName + "String_Node_Str");
        }
        Integrator.ErrorRates errorRates = integrator.errorRates();
        Integrator.Data<Integrator.Data.PredictedInstance> integratedData = integrator.integratedData();
        Results result = evaluate(errorRates, integratedData, methodName);
        results.add(result);
        if (detailedLog)
            logResults(result, true);
    }
    logResults(new Results.Statistics(results), detailedLog);
}

Output:
     Integrator integrator;
-    int experimentRepetitions = 1;
+    int experimentRepetitions = 2;
     Matcher patternMatcher = Pattern.compile("String_Node_Str").matcher(methodName);


Input:
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    if (HttpMessageNotReadableException.class.isAssignableFrom(ex.getClass())) {
        if (ex.getCause() != null && InvalidFormatException.class.isAssignableFrom(ex.getCause().getClass())) {
            Writer outputWriter;
            try {
                outputWriter = response.getWriter();
            } catch (IOException e) {
                throw new IllegalStateException("String_Node_Str");
            }
            response.setStatus(HttpStatus.BAD_REQUEST.value());
            response.setHeader("String_Node_Str", MediaType.APPLICATION_JSON_VALUE);
            writeExceptionAsJsonToOutput((InvalidFormatException) ex.getCause(), outputWriter);
            try {
                outputWriter.flush();
                outputWriter.close();
            } catch (IOException e) {
                throw new IllegalStateException("String_Node_Str");
            }
            return new ModelAndView();
        }
    }
    return null;
}

Output:
             } catch (IOException e) {
-                throw new IllegalStateException("String_Node_Str");
+                throw new IllegalStateException("String_Node_Str", e);
             }


Input:
public GiraphScenarioWrapper<I, V, E, M1, M2> load(String fileName) throws ClassNotFoundException, IOException {
    GiraphScenario giraphScenario = GiraphScenario.parseFrom(new FileInputStream(fileName));
    Class<?> clazz = Class.forName(giraphScenario.getClassUnderTest());
    Class<? extends Computation<I, V, E, M1, M2>> classUnderTest = (Class<? extends Computation<I, V, E, M1, M2>>) castClassToUpperBound(clazz, Computation.class);
    Class<I> vertexIdClass = (Class<I>) castClassToUpperBound(Class.forName(giraphScenario.getVertexIdClass()), WritableComparable.class);
    Class<V> vertexValueClass = (Class<V>) castClassToUpperBound(Class.forName(giraphScenario.getVertexValueClass()), Writable.class);
    Class<E> edgeValueClass = (Class<E>) castClassToUpperBound(Class.forName(giraphScenario.getEdgeValueClass()), Writable.class);
    Class<M1> incomingMessageClass = (Class<M1>) castClassToUpperBound(Class.forName(giraphScenario.getIncomingMessageClass()), Writable.class);
    Class<M2> outgoingMessageClass = (Class<M2>) castClassToUpperBound(Class.forName(giraphScenario.getOutgoingMessageClass()), Writable.class);
    GiraphScenarioWrapper<I, V, E, M1, M2> giraphScenarioWrapper = new GiraphScenarioWrapper(classUnderTest, vertexIdClass, vertexValueClass, edgeValueClass, incomingMessageClass, outgoingMessageClass);
    ContextOrBuilder context = giraphScenario.getContextOrBuilder();
    GiraphScenarioWrapper<I, V, E, M1, M2>.ContextWrapper contextWrapper = giraphScenarioWrapper.new ContextWrapper();
    I vertexId = newInstance(vertexIdClass);
    fromByteString(context.getVertexId(), vertexId);
    contextWrapper.setVertexIdWrapper(vertexId);
    V vertexValue = newInstance(vertexValueClass);
    fromByteString(context.getVertexValueBefore(), vertexValue);
    contextWrapper.setVertexValueBeforeWrapper(vertexValue);
    fromByteString(context.getVertexValueAfter(), vertexValue);
    contextWrapper.setVertexValueAfterWrapper(vertexValue);
    for (Neighbor neighbor : context.getNeighborList()) {
        I neighborId = newInstance(vertexIdClass);
        fromByteString(neighbor.getNeighborId(), neighborId);
        E edgeValue;
        if (neighbor.hasEdgeValue()) {
            edgeValue = newInstance(edgeValueClass);
            fromByteString(neighbor.getEdgeValue(), edgeValue);
        } else {
            edgeValue = null;
        }
        contextWrapper.addNeighborWrapper(neighborId, edgeValue);
    }
    for (int i = 0; i < context.getInMessageCount(); i++) {
        M1 msg = newInstance(incomingMessageClass);
        fromByteString(context.getInMessage(i), msg);
        contextWrapper.addIncomingMessageWrapper(msg);
    }
    for (OutMsg outmsg : context.getOutMessageList()) {
        I destinationId = newInstance(vertexIdClass);
        fromByteString(outmsg.getDestinationId(), destinationId);
        M2 msg = newInstance(outgoingMessageClass);
        fromByteString(outmsg.getMsgData(), msg);
        contextWrapper.addOutgoingMessageWrapper(destinationId, msg);
    }
    giraphScenarioWrapper.setContextWrapper(contextWrapper);
    return giraphScenarioWrapper;
}

Output:
     GiraphScenario giraphScenario = GiraphScenario.parseFrom(new FileInputStream(fileName));
-    Class<?> clazz = Class.forName(giraphScenario.getClassUnderTest());
-    Class<? extends Computation<I, V, E, M1, M2>> classUnderTest = (Class<? extends Computation<I, V, E, M1, M2>>) castClassToUpperBound(clazz, Computation.class);
-    Class<I> vertexIdClass = (Class<I>) castClassToUpperBound(Class.forName(giraphScenario.getVertexIdClass()), WritableComparable.class);
-    Class<V> vertexValueClass = (Class<V>) castClassToUpperBound(Class.forName(giraphScenario.getVertexValueClass()), Writable.class);
-    Class<E> edgeValueClass = (Class<E>) castClassToUpperBound(Class.forName(giraphScenario.getEdgeValueClass()), Writable.class);
-    Class<M1> incomingMessageClass = (Class<M1>) castClassToUpperBound(Class.forName(giraphScenario.getIncomingMessageClass()), Writable.class);
-    Class<M2> outgoingMessageClass = (Class<M2>) castClassToUpperBound(Class.forName(giraphScenario.getOutgoingMessageClass()), Writable.class);
-    GiraphScenarioWrapper<I, V, E, M1, M2> giraphScenarioWrapper = new GiraphScenarioWrapper(classUnderTest, vertexIdClass, vertexValueClass, edgeValueClass, incomingMessageClass, outgoingMessageClass);
-    ContextOrBuilder context = giraphScenario.getContextOrBuilder();
-    GiraphScenarioWrapper<I, V, E, M1, M2>.ContextWrapper contextWrapper = giraphScenarioWrapper.new ContextWrapper();
-    I vertexId = newInstance(vertexIdClass);
-    fromByteString(context.getVertexId(), vertexId);
-    contextWrapper.setVertexIdWrapper(vertexId);
-    V vertexValue = newInstance(vertexValueClass);
-    fromByteString(context.getVertexValueBefore(), vertexValue);
-    contextWrapper.setVertexValueBeforeWrapper(vertexValue);
-    fromByteString(context.getVertexValueAfter(), vertexValue);
-    contextWrapper.setVertexValueAfterWrapper(vertexValue);
-    for (Neighbor neighbor : context.getNeighborList()) {
-        I neighborId = newInstance(vertexIdClass);
-        fromByteString(neighbor.getNeighborId(), neighborId);
-        E edgeValue;
-        if (neighbor.hasEdgeValue()) {
-            edgeValue = newInstance(edgeValueClass);
-            fromByteString(neighbor.getEdgeValue(), edgeValue);
-        } else {
-            edgeValue = null;
-        }
-        contextWrapper.addNeighborWrapper(neighborId, edgeValue);
-    }
-    for (int i = 0; i < context.getInMessageCount(); i++) {
-        M1 msg = newInstance(incomingMessageClass);
-        fromByteString(context.getInMessage(i), msg);
-        contextWrapper.addIncomingMessageWrapper(msg);
-    }
-    for (OutMsg outmsg : context.getOutMessageList()) {
-        I destinationId = newInstance(vertexIdClass);
-        fromByteString(outmsg.getDestinationId(), destinationId);
-        M2 msg = newInstance(outgoingMessageClass);
-        fromByteString(outmsg.getMsgData(), msg);
-        contextWrapper.addOutgoingMessageWrapper(destinationId, msg);
-    }
-    giraphScenarioWrapper.setContextWrapper(contextWrapper);
-    return giraphScenarioWrapper;
+    return loadGiraphScneario(giraphScenario);
 }


Input:
private String getSourceCode(String href, String syntax) {
    SSLCertificate.setCertificate();
    String source = "String_Node_Str";
    URL url;
    try {
        url = new URL(href);
        URLConnection connection = url.openConnection();
        connection.setRequestProperty("String_Node_Str", UserAgentContext.DEFAULT_USER_AGENT);
        connection.setRequestProperty("String_Node_Str", "String_Node_Str");
        InputStream in = connection.getInputStream();
        byte[] content;
        try {
            content = IORoutines.load(in, 8192);
            source = new String(content, "String_Node_Str");
            if (SyntaxConstants.SYNTAX_STYLE_CSS.equals(syntax)) {
                source = source.replace("String_Node_Str", "String_Node_Str");
            }
        } finally {
            in.close();
        }
    } catch (Exception e) {
        logger.error(e);
    }
    return source;
}

Output:
     } catch (Exception e) {
-        logger.error(e);
+        logger.error("String_Node_Str", e);
     }


Input:
protected Command createButtonCommand(Button button) {
    IElementParameter switchParam = elem.getElementParameter(EParameterName.REPOSITORY_ALLOW_AUTO_SWITCH.getName());
    String paramName = (String) button.getData(PARAMETER_NAME);
    IElementParameter param = elem.getElementParameter(paramName);
    Object data = button.getData(NAME);
    if (data != null && data.equals(REPOSITORY_CHOICE)) {
        String propertyType = (String) elem.getPropertyValue(EParameterName.SCHEMA_TYPE.getName());
        if (EmfComponent.BUILTIN.equals(propertyType)) {
            MessageDialog.openWarning(button.getShell(), "String_Node_Str", "String_Node_Str");
            return null;
        }
        ERepositoryObjectType type = ERepositoryObjectType.METADATA_VALIDATION_RULES;
        RepositoryReviewDialog dialog = new RepositoryReviewDialog(button.getShell(), type, param.getRepositoryValue(), new ViewerFilter[] { new ValidationRuleFilter() });
        if (dialog.open() == RepositoryReviewDialog.OK) {
            RepositoryNode node = dialog.getResult();
            while (node.getObject().getProperty().getItem() == null || (!(node.getObject().getProperty().getItem() instanceof ConnectionItem))) {
                node = node.getParent();
            }
            if (switchParam != null) {
                switchParam.setValue(Boolean.FALSE);
            }
            String id = dialog.getResult().getObject().getProperty().getId();
            if (id.equals(elem.getPropertyValue(paramName))) {
                return null;
            }
            return new PropertyChangeCommand(elem, EParameterName.REPOSITORY_VALIDATION_RULE_TYPE.getName(), id);
        }
    }
    return null;
}

Output:
         ERepositoryObjectType type = ERepositoryObjectType.METADATA_VALIDATION_RULES;
-        RepositoryReviewDialog dialog = new RepositoryReviewDialog(button.getShell(), type, param.getRepositoryValue(), new ViewerFilter[] { new ValidationRuleFilter() });
+        RepositoryReviewDialog dialog = new RepositoryReviewDialog(button.getShell(), type, param.getRepositoryValue(), new ViewerFilter[] { new ValidationRuleFilter() }, elem);
         if (dialog.open() == RepositoryReviewDialog.OK) {


Input:
protected void _apply() {
    Iterator portIterator;
    TypedIOPort actualPort;
    String[] portNameInTable = new String[_portTableModel.getRowCount()];
    for (int i = 0; i < _portTableModel.getRowCount(); i++) {
        portNameInTable[i] = (String) (_portTableModel.getValueAt(i, PortTableModel.COL_NAME));
    }
    for (int i = 0; i < _portTableModel.getRowCount(); i++) {
        if (portNameInTable[i].equals("String_Node_Str")) {
            JOptionPane.showMessageDialog(this, "String_Node_Str");
            return;
        }
    }
    for (int i = 0; i < _portTableModel.getRowCount(); i++) {
        for (int j = i + 1; j < _portTableModel.getRowCount(); j++) {
            if (portNameInTable[i].equals(portNameInTable[j])) {
                JOptionPane.showMessageDialog(this, portNameInTable[i] + "String_Node_Str" + "String_Node_Str");
                return;
            }
        }
    }
    Vector portsToBeRemoved = new Vector();
    portIterator = getTarget().portList().iterator();
    actualPort = null;
    while (portIterator.hasNext()) {
        Object candidate = portIterator.next();
        if (candidate instanceof TypedIOPort) {
            boolean foundPort = false;
            actualPort = ((TypedIOPort) candidate);
            for (int i = 0; i < _ports.size(); i++) {
                Object[] portInfo = (Object[]) (_ports.elementAt(i));
                if (actualPort == ((TypedIOPort) portInfo[PortTableModel.COL_ACTUAL_PORT])) {
                    foundPort = true;
                    break;
                }
            }
            if (!foundPort) {
                portsToBeRemoved.add(actualPort);
            }
        }
    }
    Iterator actualPorts = portsToBeRemoved.iterator();
    while (actualPorts.hasNext()) {
        StringBuffer moml = new StringBuffer();
        actualPort = (TypedIOPort) (actualPorts.next());
        NamedObj container = (NamedObj) actualPort.getContainer();
        NamedObj composite = (NamedObj) container.getContainer();
        if (composite != null) {
            moml.append("String_Node_Str" + actualPort.getName() + "String_Node_Str" + container.getName() + "String_Node_Str");
        } else {
            moml.append("String_Node_Str" + actualPort.getName(container) + "String_Node_Str");
        }
        MoMLChangeRequest request = null;
        if (composite != null) {
            request = new MoMLChangeRequest(this, composite, moml.toString());
        } else {
            request = new MoMLChangeRequest(this, container, moml.toString());
        }
        request.setUndoable(true);
        container.addChangeListener(this);
        if (_debug)
            System.out.println("String_Node_Str" + container.toString() + "String_Node_Str" + moml);
        container.requestChange(request);
    }
    StringBuffer moml = new StringBuffer("String_Node_Str");
    boolean haveSomeUpdate = false;
    for (int i = 0; i < _ports.size(); i++) {
        Object[] portInfo = (Object[]) (_ports.elementAt(i));
        portIterator = getTarget().portList().iterator();
        actualPort = (TypedIOPort) (portInfo[PortTableModel.COL_ACTUAL_PORT]);
        boolean[] updates = new boolean[_portTableModel.getColumnCount()];
        if (actualPort != null) {
            for (int updateNum = 0; updateNum < 7; updateNum++) {
                updates[updateNum] = false;
            }
            boolean havePortUpdate = false;
            if (!(actualPort.getName().equals((String) (portInfo[PortTableModel.COL_NAME])))) {
                havePortUpdate = true;
                updates[PortTableModel.COL_NAME] = true;
            }
            if (actualPort.isInput() != (((Boolean) (portInfo[PortTableModel.COL_INPUT])).booleanValue())) {
                havePortUpdate = true;
                updates[PortTableModel.COL_INPUT] = true;
            }
            if (actualPort.isOutput() != (((Boolean) (portInfo[PortTableModel.COL_OUTPUT])).booleanValue())) {
                havePortUpdate = true;
                updates[PortTableModel.COL_OUTPUT] = true;
            }
            if (actualPort.isMultiport() != (((Boolean) (portInfo[PortTableModel.COL_MULTIPORT])).booleanValue())) {
                havePortUpdate = true;
                updates[PortTableModel.COL_MULTIPORT] = true;
            }
            Attribute _show = (Attribute) (actualPort.getAttribute("String_Node_Str"));
            if ((_show == null) == (((Boolean) (portInfo[PortTableModel.COL_SHOW_NAME])).booleanValue())) {
                havePortUpdate = true;
                updates[PortTableModel.COL_SHOW_NAME] = true;
            }
            Attribute hide = actualPort.getAttribute("String_Node_Str");
            if ((hide == null) == (((Boolean) (portInfo[PortTableModel.COL_HIDE])).booleanValue())) {
                havePortUpdate = true;
                updates[PortTableModel.COL_HIDE] = true;
            }
            String _type = null;
            UnitAttribute _typeAttribute = (UnitAttribute) actualPort.getAttribute("String_Node_Str");
            if (_typeAttribute != null) {
                _type = _typeAttribute.getExpression();
            }
            if ((_type == null && (!((String) (portInfo[PortTableModel.COL_TYPE])).equals("String_Node_Str"))) || ((_type != null) && (!((String) (portInfo[PortTableModel.COL_TYPE])).equals(_type)))) {
                havePortUpdate = true;
                updates[PortTableModel.COL_TYPE] = true;
            }
            String _direction = null;
            String direction = (String) (portInfo[PortTableModel.COL_DIRECTION]);
            StringAttribute _cardinal = (StringAttribute) (actualPort.getAttribute("String_Node_Str"));
            if (_cardinal != null)
                _direction = _cardinal.getExpression().toUpperCase();
            if (((_direction == null) && !direction.equals("String_Node_Str")) || ((_direction != null) && (!direction.equals(_direction)))) {
                havePortUpdate = true;
                updates[PortTableModel.COL_DIRECTION] = true;
            }
            String _units = null;
            UnitAttribute _unitsAttribute = (UnitAttribute) actualPort.getAttribute("String_Node_Str");
            if (_unitsAttribute != null) {
                _units = _unitsAttribute.getExpression();
            }
            if ((_units == null && (!((String) (portInfo[PortTableModel.COL_UNITS])).equals("String_Node_Str"))) || ((_units != null) && (!((String) (portInfo[PortTableModel.COL_UNITS])).equals(_units)))) {
                havePortUpdate = true;
                updates[PortTableModel.COL_UNITS] = true;
            }
            if (havePortUpdate) {
                NamedObj parent = (NamedObj) actualPort.getContainer();
                moml.append(_createMoMLUpdate(updates, portInfo, (String) (((TypedIOPort) (portInfo[PortTableModel.COL_ACTUAL_PORT])).getName()), (String) (portInfo[PortTableModel.COL_NAME])));
                haveSomeUpdate = true;
            }
        } else {
            for (int updateNum = 0; updateNum < 7; updateNum++) {
                updates[updateNum] = true;
            }
            updates[PortTableModel.COL_NAME] = false;
            updates[PortTableModel.COL_SHOW_NAME] = ((Boolean) (portInfo[PortTableModel.COL_SHOW_NAME])).booleanValue();
            updates[PortTableModel.COL_HIDE] = ((Boolean) (portInfo[PortTableModel.COL_HIDE])).booleanValue();
            String _type = (String) (portInfo[PortTableModel.COL_TYPE]);
            if (!_type.equals("String_Node_Str")) {
                updates[PortTableModel.COL_TYPE] = true;
                _portTableModel.fireTableDataChanged();
            } else {
                updates[PortTableModel.COL_TYPE] = false;
            }
            String direction = (String) (portInfo[PortTableModel.COL_DIRECTION]);
            if (!direction.equals("String_Node_Str")) {
                updates[PortTableModel.COL_DIRECTION] = true;
                _portTableModel.fireTableDataChanged();
            } else {
                updates[PortTableModel.COL_DIRECTION] = false;
            }
            moml.append(_createMoMLUpdate(updates, portInfo, (String) (portInfo[PortTableModel.COL_NAME]), null));
            haveSomeUpdate = true;
        }
    }
    if (haveSomeUpdate) {
        moml.append("String_Node_Str");
        if (_debug)
            System.out.println("String_Node_Str" + getTarget().toString() + "String_Node_Str" + moml);
        MoMLChangeRequest request = new MoMLChangeRequest(this, getTarget(), moml.toString(), null);
        request.setUndoable(true);
        getTarget().requestChange(request);
        _populateActualPorts();
    }
    _setDirty(false);
    _enableApplyButton(false);
}

Output:
             String _type = null;
-            UnitAttribute _typeAttribute = (UnitAttribute) actualPort.getAttribute("String_Node_Str");
+            TypeAttribute _typeAttribute = (TypeAttribute) actualPort.getAttribute("String_Node_Str");
             if (_typeAttribute != null) {


Input:
private double[] computeLCC(NodeImpl[] nodes, HashMap<String, Edge> map) {
    double[] lcc = new double[nodes.length];
    for (int i = 0; i < nodes.length; i++) {
        Node[] neighborhood = this.neighborhood(nodes[i]);
        if (neighborhood.length == 1) {
            lcc[i] = 0;
        } else {
            int edges = this.edgesInNeighborhood_NEW(neighborhood, nodes[i], nodes.length, map);
            lcc[i] = edges / (double) (neighborhood.length * (neighborhood.length - 1));
        }
    }
    return lcc;
}

Output:
     for (int i = 0; i < nodes.length; i++) {
-        Node[] neighborhood = this.neighborhood(nodes[i]);
-        if (neighborhood.length == 1) {
+        Set<NodeImpl> n = this.neighborhood(nodes[i], onlyOut);
+        if (n.size() <= 1) {
             lcc[i] = 0;


Input:
public List<BlockPos> getPath(ItemStack item) {
    NBTTagCompound cpt = NBTUtils.getItemData(item);
    if (cpt.hasKey("String_Node_Str") && cpt.getByte("String_Node_Str") == 2) {
        List<BlockPos> indexList = new ArrayList<BlockPos>();
        NBTTagList pathNBT = cpt.getTagList("String_Node_Str", Constants.NBT.TAG_COMPOUND);
        for (int i = 0; i < pathNBT.tagCount(); i++) {
            indexList.add(new BlockPos(pathNBT.getCompoundTagAt(i)));
        }
        return indexList;
    } else if (cpt.hasKey("String_Node_Str") && cpt.getByte("String_Node_Str") == 0) {
        List<BlockPos> indexList = new ArrayList<BlockPos>();
        indexList.add(new BlockPos(cpt.getInteger("String_Node_Str"), cpt.getInteger("String_Node_Str"), cpt.getInteger("String_Node_Str")));
        return indexList;
    } else {
        return null;
    }
}

Output:
         for (int i = 0; i < pathNBT.tagCount(); i++) {
-            indexList.add(new BlockPos(pathNBT.getCompoundTagAt(i)));
+            indexList.add(NBTUtils.readBlockPos(pathNBT.getCompoundTagAt(i)));
         }


Input:
public boolean addPackage(String pkg, ProcessStatsService tracker) {
    if (!pkgList.containsKey(pkg)) {
        pkgList.put(pkg, tracker.getProcessStateLocked(pkg, info.uid, processName));
        return true;
    }
    return false;
}

Output:
     if (!pkgList.containsKey(pkg)) {
-        pkgList.put(pkg, tracker.getProcessStateLocked(pkg, info.uid, processName));
+        pkgList.put(pkg, baseProcessTracker != null ? tracker.getProcessStateLocked(pkg, info.uid, processName) : null);
         return true;


Input:
private void analyzeWithEarlyAbort() {
    kAnonymous = (currentOutliers <= absoluteMaxOutliers);
    if (classBasedCriteria.length == 0) {
        anonymous = kAnonymous;
        return;
    }
    if (k != Integer.MAX_VALUE && !kAnonymous) {
        anonymous = false;
        return;
    }
    currentOutliers = 0;
    HashGroupifyEntry entry = firstEntry;
    while (entry != null) {
        int anonymous = isAnonymous(entry);
        if (anonymous != -1) {
            if (dpresence && entry.count == 0 && anonymous == 1) {
                this.anonymous = false;
                return;
            }
            currentOutliers += entry.count;
            if (currentOutliers > absoluteMaxOutliers) {
                this.anonymous = false;
                return;
            }
        }
        entry.isNotOutlier = entry.count != 0 ? (anonymous == -1) : true;
        entry = entry.nextOrdered;
    }
    this.analyzeSampleBasedCriteria(true);
    this.anonymous = (currentOutliers <= absoluteMaxOutliers);
}

Output:
     kAnonymous = (currentOutliers <= absoluteMaxOutliers);
-    if (classBasedCriteria.length == 0) {
+    if (classBasedCriteria.length == 0 && sampleBasedCriteria.length == 0) {
         anonymous = kAnonymous;


Input:
private void maybeRemovePreviousPeriod(CharSequence text) {
    final InputConnection ic = getCurrentInputConnection();
    if (ic == null)
        return;
    CharSequence lastOne = ic.getTextBeforeCursor(1, 0);
    if (lastOne != null && lastOne.length() == 1 && lastOne.charAt(0) == '.' && text.charAt(0) == '.') {
        ic.deleteSurroundingText(1, 0);
    }
}

Output:
     CharSequence lastOne = ic.getTextBeforeCursor(1, 0);
-    if (lastOne != null && lastOne.length() == 1 && lastOne.charAt(0) == '.' && text.charAt(0) == '.') {
+    if (lastOne != null && lastOne.length() == 1 && lastOne.charAt(0) == KEYCODE_PERIOD && text.charAt(0) == KEYCODE_PERIOD) {
         ic.deleteSurroundingText(1, 0);


Input:
public void updateEntries() {
    ArrayList<FolderWatchHistoryEntry> entries = this;
    boolean value;
    for (FolderWatchHistoryEntry entry : entries) {
        value = isFileExisting(entry.getAbsolutePath());
        entry.setPhysical(value);
    }
}

Output:
     for (FolderWatchHistoryEntry entry : entries) {
-        value = isFileExisting(entry.getAbsolutePath());
-        entry.setPhysical(value);
+        if (entry.isPhysical()) {
+            value = isFileExisting(entry.getAbsolutePath());
+            entry.setPhysical(value);
+        }
     }


Input:
public Future<ServiceConfiguration> apply(final ServiceConfiguration input) {
    final Callable<ServiceConfiguration> call = Topology.callable(input, Topology.get(toState));
    final Queue workQueue = (this.serializedStates.contains(toState) ? Queue.INTERNAL : Queue.EXTERNAL);
    return workQueue.enqueue(call);
}

Output:
     final Callable<ServiceConfiguration> call = Topology.callable(input, Topology.get(toState));
-    final Queue workQueue = (this.serializedStates.contains(toState) ? Queue.INTERNAL : Queue.EXTERNAL);
-    return workQueue.enqueue(call);
+    if (Bootstrap.isOperational()) {
+        final Queue workQueue = (this.serializedStates.contains(toState) ? Queue.INTERNAL : Queue.EXTERNAL);
+        return workQueue.enqueue(call);
+    } else {
+        try {
+            return Futures.predestinedFuture(call.call());
+        } catch (Exception ex) {
+            return Futures.predestinedFuture(input);
+        }
+    }
 }


Input:
public boolean process(UserActionContext ctx) {
    doExportBook();
    return true;
}

Output:
 public boolean process(UserActionContext ctx) {
-    doExportBook();
+    doExportPdf();
     return true;


Input:
public void runRealignerTargetCreator(String input, String targets, String ref, String region) throws InterruptedException {
    String[] command = { java, mem, "String_Node_Str", gatk, "String_Node_Str", "String_Node_Str", multiThreadingTypes[0], "String_Node_Str" + threads, "String_Node_Str", ref, "String_Node_Str", input, "String_Node_Str", targets, "String_Node_Str", region };
    String customArgs = HalvadeConf.getCustomArgs(context.getConfiguration(), "String_Node_Str", "String_Node_Str");
    long estimatedTime = runProcessAndWait("String_Node_Str", AddCustomArguments(command, customArgs));
    if (context != null)
        context.getCounter(HalvadeCounters.TIME_GATK_TARGET_CREATOR).increment(estimatedTime);
}

Output:
 public void runRealignerTargetCreator(String input, String targets, String ref, String region) throws InterruptedException {
-    String[] command = { java, mem, "String_Node_Str", gatk, "String_Node_Str", "String_Node_Str", multiThreadingTypes[0], "String_Node_Str" + threads, "String_Node_Str", ref, "String_Node_Str", input, "String_Node_Str", targets, "String_Node_Str", region };
+    String[] command = { mem, "String_Node_Str", gatk, "String_Node_Str", "String_Node_Str", multiThreadingTypes[0], "String_Node_Str" + threads, "String_Node_Str", ref, "String_Node_Str", input, "String_Node_Str", targets, "String_Node_Str", region };
     String customArgs = HalvadeConf.getCustomArgs(context.getConfiguration(), "String_Node_Str", "String_Node_Str");


Input:
protected void doStop(final WhyStop why, final Exception cause) throws JMException, IOException {
    onStop(why);
    notificationProcessor.shutdownNow();
    notificationProcessor = null;
    if (why != WhyStop.HEARTBEAT_FAILURE) {
        serverStoppedListener.remove();
        if (cntor != null) {
            cntor.close();
        }
    }
    stateHandler.waitToWhen(new IsStoppable(), new Runnable() {
        public void run() {
            switch(why) {
                case HEARTBEAT_FAILURE:
                    getStateChanger().setStateException(cause);
                    logger().error("String_Node_Str", cause);
                    break;
                case SERVER_STOPPED:
                    getStateChanger().setStateException(new Exception("String_Node_Str"));
                    logger().info("String_Node_Str");
                    break;
                default:
                    getStateChanger().setState(ServiceState.COMPLETE);
                    logger().info("String_Node_Str");
            }
        }
    });
}

Output:
     notificationProcessor = null;
-    if (why != WhyStop.HEARTBEAT_FAILURE) {
-        serverStoppedListener.remove();
-        if (cntor != null) {
+    if (why == WhyStop.STOP_REQUEST && cntor != null) {
+        try {
             cntor.close();


Input:
private static int getNotchDirection(Direction dir) {
    switch(dir) {
        case DOWN:
            return 0;
        case UP:
            return 1;
        case NORTH:
            return 2;
        case SOUTH:
            return 3;
        case WEST:
            return 4;
        case EAST:
            return 5;
        default:
            return 7;
    }
}

Output:
         case DOWN:
-            return 0;
+            return EnumFacing.DOWN;
         case UP:


Input:
public void testPutNullSignature() throws Exception {
    invocationsCollector.put(jvmUuid1, null, 100L, 100L, null);
}

Output:
 public void testPutNullSignature() throws Exception {
-    invocationsCollector.put(jvmUuid1, null, 100L, 100L, null);
+    invocationsCollector.put(jvmUuid1, now - 100L, null, 0, null);
 }


Input:
public void onPlayerDeath(PlayerDeathEvent event) {
    if (pli.containsGlobalPlayer(event.getEntity().getName())) {
        event.setDeathMessage(null);
        event.getEntity().setHealth(20D);
        final Player p = event.getEntity();
        final Arena arena = pli.global_players.get(p.getName());
        if (arena.getArenaState() == ArenaState.JOIN || (arena.getArenaState() == ArenaState.STARTING && !arena.startedIngameCountdown)) {
            Util.teleportPlayerFixed(p, arena.getWaitingLobbyTemp());
            return;
        }
        arena.global_drops.addAll(event.getDrops());
        arena.spectate(p.getName());
        pli.global_lost.put(p.getName(), arena);
        int count = 0;
        for (String p_ : pli.global_players.keySet()) {
            if (Validator.isPlayerOnline(p_)) {
                if (pli.global_players.get(p_).getInternalName().equalsIgnoreCase(arena.getInternalName())) {
                    if (!pli.containsGlobalLost(p_)) {
                        count++;
                    }
                }
            }
        }
        final int count_ = count;
        Bukkit.getScheduler().runTaskLater(MinigamesAPI.getAPI(), new Runnable() {
            public void run() {
                try {
                    if (pli.containsGlobalPlayer(p.getName()) && count_ > 1) {
                        arena.spectate(p.getName());
                    }
                    for (String p_ : arena.getAllPlayers()) {
                        if (Validator.isPlayerOnline(p_)) {
                            Player p__ = Bukkit.getPlayer(p_);
                            Util.sendMessage(plugin, p__, pli.getMessagesConfig().broadcast_players_left.replaceAll("String_Node_Str", arena.getPlayerCount()));
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 5);
        if (plugin.getConfig().getBoolean("String_Node_Str")) {
            if (count < 2) {
                arena.stop();
            }
        }
    }
}

Output:
         if (arena.getArenaState() == ArenaState.JOIN || (arena.getArenaState() == ArenaState.STARTING && !arena.startedIngameCountdown)) {
-            Util.teleportPlayerFixed(p, arena.getWaitingLobbyTemp());
+            if (arena.isArcadeMain()) {
+                Util.teleportPlayerFixed(p, arena.getWaitingLobbyTemp());
+            }
             return;


Input:
private Object[] createWorkspaceRootChildren(Object element, String projectTechnicalLabel) throws CoreException {
    Project inWhichProject = ProxyRepositoryManager.getInstance().getProjectFromProjectTechnicalLabel(projectTechnicalLabel);
    Object currentOpenProject = null;
    for (Object child : super.getChildren(element)) {
        if (child instanceof IProject) {
            if (((IProject) child).getName().equals(projectTechnicalLabel)) {
                currentOpenProject = child;
                break;
            }
        }
    }
    List<Object> folders = new ArrayList<Object>();
    Object[] rootFolders = new Object[0];
    if (currentOpenProject != null) {
        rootFolders = ((IProject) currentOpenProject).members(false);
        for (Object folder : rootFolders) {
            IRepositoryNode node = null;
            if (folder instanceof IFolder && ((IFolder) folder).getName().startsWith(RepositoryNodeHelper.PREFIX_TDQ)) {
                IFolder iFolder = (IFolder) folder;
                if (((IFolder) folder).getName().trim().equals("String_Node_Str")) {
                    continue;
                }
                IPath relativePath = iFolder.getFullPath().makeRelativeTo(((IProject) currentOpenProject).getFullPath());
                ERepositoryObjectType respositoryObjectType = RepositoryNodeBuilder.getInstance().retrieveRepObjectTypeByPath(relativePath.toOSString());
                node = createNewRepNode(respositoryObjectType, inWhichProject);
            }
            if (folder instanceof IFolder) {
                String folderName = ((IFolder) folder).getName();
                if (EResourceConstant.METADATA.getName().equals(folderName)) {
                    node = createNewRepNode(ERepositoryObjectType.METADATA, inWhichProject);
                } else if (PluginChecker.isTDQLoaded() && EResourceConstant.CONTEXT.getName().equals(folderName)) {
                    node = createNewRepNode(ERepositoryObjectType.CONTEXT, inWhichProject);
                }
            }
            if (node != null) {
                folders.add(node);
            }
        }
    }
    if (inWhichProject.isMainProject()) {
        RecycleBinRepNode recycleBin = new RecycleBinRepNode(DefaultMessagesImpl.getString("String_Node_Str"), inWhichProject);
        folders.add(recycleBin);
    }
    if (org.talend.core.PluginChecker.isRefProjectLoaded() && inWhichProject.getEmfProject() != null && inWhichProject.getEmfProject().getReferencedProjects().size() > 0) {
        if (!ProxyRepositoryManager.getInstance().isMergeRefProject()) {
            DQRepositoryNode refProjectNode = createNewRepNode(ERepositoryObjectType.REFERENCED_PROJECTS, inWhichProject);
            refProjectNode.setProperties(EProperties.LABEL, ERepositoryObjectType.REFERENCED_PROJECTS.getLabel());
            refProjectNode.setProperties(EProperties.CONTENT_TYPE, ERepositoryObjectType.REFERENCED_PROJECTS);
            folders.add(refProjectNode);
            handleReferenced(refProjectNode);
        }
    }
    return sortRepositoryNode(folders.toArray(), ComparatorsFactory.ROOT_NODES_COMPARATOR_ID);
}

Output:
     }
-    if (org.talend.core.PluginChecker.isRefProjectLoaded() && inWhichProject.getEmfProject() != null && inWhichProject.getEmfProject().getReferencedProjects().size() > 0) {
+    if (org.talend.core.PluginChecker.isRefProjectLoaded() && inWhichProject.getEmfProject() != null && inWhichProject.getProjectReferenceList().size() > 0) {
         if (!ProxyRepositoryManager.getInstance().isMergeRefProject()) {


Input:
public void testSingleMessage() throws Exception {
    TopicId topicId = NamespaceId.DEFAULT.topic("String_Node_Str");
    TopicMetadata metadata = new TopicMetadata(topicId, DEFAULT_PROPERTY);
    String payload = "String_Node_Str";
    long txWritePtr = 123L;
    try (MetadataTable metadataTable = getMetadataTable();
        PayloadTable table = getPayloadTable()) {
        metadataTable.createTopic(metadata);
        List<PayloadTable.Entry> entryList = new ArrayList<>();
        entryList.add(new TestPayloadEntry(topicId, GENERATION, txWritePtr, 0L, (short) 0, Bytes.toBytes(payload)));
        table.store(entryList.iterator());
        byte[] messageId = new byte[MessageId.RAW_ID_SIZE];
        MessageId.putRawId(0L, (short) 0, 0L, (short) 0, messageId, 0);
        try (CloseableIterator<PayloadTable.Entry> iterator = table.fetch(metadata, txWritePtr, new MessageId(messageId), false, Integer.MAX_VALUE)) {
            Assert.assertFalse(iterator.hasNext());
        }
        try (CloseableIterator<PayloadTable.Entry> iterator = table.fetch(metadata, txWritePtr, new MessageId(messageId), true, Integer.MAX_VALUE)) {
            Assert.assertTrue(iterator.hasNext());
            PayloadTable.Entry entry = iterator.next();
            Assert.assertArrayEquals(Bytes.toBytes(payload), entry.getPayload());
            Assert.assertEquals(txWritePtr, entry.getTransactionWritePointer());
            Assert.assertFalse(iterator.hasNext());
        }
    }
}

Output:
         List<PayloadTable.Entry> entryList = new ArrayList<>();
-        entryList.add(new TestPayloadEntry(topicId, GENERATION, txWritePtr, 0L, (short) 0, Bytes.toBytes(payload)));
+        entryList.add(new TestPayloadEntry(topicId, GENERATION, txWritePtr, 1L, (short) 1, Bytes.toBytes(payload)));
         table.store(entryList.iterator());


Input:
protected void bindTexture(ResourceLocation texturePath) {
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    Proxies.render.bindTexture(texturePath);
}

Output:
 protected void bindTexture(ResourceLocation texturePath) {
-    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+    GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
     Proxies.render.bindTexture(texturePath);


Input:
public MessageInfo buildMessageInfo(NotificationMessage message) {
    MessageInfo messageInfo = new MessageInfo();
    messageInfo.setFrom(getFrom(message)).setTo(getTo(message));
    ProviderData provider = providerService.getProvider(message.getProviderType());
    String language = getLanguage(message);
    String body = getTemplate(provider, language);
    String subject = getSubject(provider, language);
    PROVIDER_TYPE type = PROVIDER_TYPE.valueOf(message.getProviderType());
    try {
        switch(type) {
            case ActivityMentionProvider:
                {
                    String activityId = message.getOwnerParameter().get(ACTIVITY_ID);
                    ExoSocialActivity activity = activityManager.getActivity(activityId);
                    Identity identity = identityManager.getIdentity(activity.getPosterId(), true);
                    messageInfo.setSubject(subject.replace("String_Node_Str", identity.getProfile().getFullName())).setBody(body.replace("String_Node_Str", identity.getProfile().getFullName()).replace("String_Node_Str", activity.getTitle()).replace("String_Node_Str", LinkProviderUtils.getReplyActivityUrl(activity.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getViewFullDiscussionUrl(activity.getId(), message.getSendToUserIds().get(0))));
                    break;
                }
            case ActivityCommentProvider:
                {
                    String activityId = message.getOwnerParameter().get(ACTIVITY_ID);
                    ExoSocialActivity activity = activityManager.getActivity(activityId);
                    ExoSocialActivity parentActivity = activityManager.getParentActivity(activity);
                    Identity identity = identityManager.getIdentity(activity.getPosterId(), true);
                    messageInfo.setSubject(subject.replace("String_Node_Str", identity.getProfile().getFullName())).setBody(body.replace("String_Node_Str", identity.getProfile().getFullName()).replace("String_Node_Str", activity.getTitle()).replace("String_Node_Str", parentActivity.getTitle()).replace("String_Node_Str", LinkProviderUtils.getReplyActivityUrl(activity.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getViewFullDiscussionUrl(activity.getId(), message.getSendToUserIds().get(0))));
                    break;
                }
            case ActivityLikeProvider:
                {
                    String activityId = message.getOwnerParameter().get(ACTIVITY_ID);
                    ExoSocialActivity activity = activityManager.getActivity(activityId);
                    Identity identity = identityManager.getIdentity(message.getFrom(), true);
                    messageInfo.setSubject(subject.replace("String_Node_Str", identity.getProfile().getFullName())).setBody(body.replace("String_Node_Str", identity.getProfile().getFullName()).replace("String_Node_Str", activity.getTitle()).replace("String_Node_Str", LinkProviderUtils.getReplyActivityUrl(activity.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getViewFullDiscussionUrl(activity.getId(), message.getSendToUserIds().get(0))));
                    break;
                }
            case ActivityPostProvider:
                {
                    String activityId = message.getOwnerParameter().get(ACTIVITY_ID);
                    ExoSocialActivity activity = activityManager.getActivity(activityId);
                    Identity identity = identityManager.getIdentity(activity.getPosterId(), true);
                    messageInfo.setSubject(subject.replace("String_Node_Str", identity.getProfile().getFullName())).setBody(body.replace("String_Node_Str", identity.getProfile().getFullName()).replace("String_Node_Str", activity.getTitle()).replace("String_Node_Str", LinkProviderUtils.getReplyActivityUrl(activity.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getViewFullDiscussionUrl(activity.getId(), message.getSendToUserIds().get(0))));
                    break;
                }
            case ActivityPostSpaceProvider:
                {
                    String activityId = message.getOwnerParameter().get(ACTIVITY_ID);
                    ExoSocialActivity activity = activityManager.getActivity(activityId);
                    Identity identity = identityManager.getIdentity(activity.getPosterId(), true);
                    Identity spaceIdentity = identityManager.getOrCreateIdentity(SpaceIdentityProvider.NAME, activity.getStreamOwner(), true);
                    messageInfo.setSubject(subject.replace("String_Node_Str", identity.getProfile().getFullName()).replace("String_Node_Str", spaceIdentity.getProfile().getFullName())).setBody(body.replace("String_Node_Str", identity.getProfile().getFullName()).replace("String_Node_Str", activity.getTitle()).replace("String_Node_Str", spaceIdentity.getProfile().getFullName()).replace("String_Node_Str", LinkProviderUtils.getReplyActivityUrl(activity.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getViewFullDiscussionUrl(activity.getId(), message.getSendToUserIds().get(0))));
                    break;
                }
            case InvitedJoinSpace:
                {
                    String spaceId = message.getOwnerParameter().get(SPACE_ID);
                    Space space = spaceService.getSpaceById(spaceId);
                    messageInfo.setSubject(subject.replace("String_Node_Str", space.getPrettyName())).setBody(body.replace("String_Node_Str", space.getPrettyName()).replace("String_Node_Str", space.getAvatarUrl()).replace("String_Node_Str", LinkProviderUtils.getAcceptInvitationToJoinSpaceUrl(space.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getIgnoreInvitationToJoinSpaceUrl(space.getId(), message.getSendToUserIds().get(0))));
                    break;
                }
            case RequestJoinSpace:
                {
                    String spaceId = message.getOwnerParameter().get(SPACE_ID);
                    Space space = spaceService.getSpaceById(spaceId);
                    Identity identity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, message.getFrom(), true);
                    Profile userProfile = identity.getProfile();
                    messageInfo.setSubject(subject.replace("String_Node_Str", space.getPrettyName()).replace("String_Node_Str", userProfile.getFullName())).setBody(body.replace("String_Node_Str", space.getPrettyName()).replace("String_Node_Str", userProfile.getFullName()).replace("String_Node_Str", userProfile.getAvatarUrl()).replace("String_Node_Str", LinkProviderUtils.getValidateRequestToJoinSpaceUrl(space.getId(), identity.getRemoteId())));
                    break;
                }
            case NewUserJoinSocialIntranet:
                {
                    break;
                }
            case ReceiceConnectionRequest:
                {
                    Identity identity = identityManager.getOrCreateIdentity(OrganizationIdentityProvider.NAME, message.getFrom(), true);
                    Profile userProfile = identity.getProfile();
                    messageInfo.setSubject(subject.replace("String_Node_Str", userProfile.getFullName())).setBody(body.replace("String_Node_Str", userProfile.getFullName()).replace("String_Node_Str", userProfile.getAvatarUrl()).replace("String_Node_Str", LinkProviderUtils.getConfirmInvitationToConnectUrl(message.getFrom(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getIgnoreInvitationToConnectUrl(message.getFrom(), message.getSendToUserIds().get(0))));
                    break;
                }
        }
    } catch (Exception e) {
        LOG.error("String_Node_Str" + provider.getType(), e);
        return null;
    }
    return messageInfo;
}

Output:
                     Space space = spaceService.getSpaceById(spaceId);
-                    messageInfo.setSubject(subject.replace("String_Node_Str", space.getPrettyName())).setBody(body.replace("String_Node_Str", space.getPrettyName()).replace("String_Node_Str", space.getAvatarUrl()).replace("String_Node_Str", LinkProviderUtils.getAcceptInvitationToJoinSpaceUrl(space.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getIgnoreInvitationToJoinSpaceUrl(space.getId(), message.getSendToUserIds().get(0))));
+                    messageInfo.setSubject(subject.replace("String_Node_Str", space.getPrettyName())).setBody(body.replace("String_Node_Str", space.getPrettyName()).replace("String_Node_Str", LinkProviderUtils.getSpaceAvatarUrl(space)).replace("String_Node_Str", LinkProviderUtils.getAcceptInvitationToJoinSpaceUrl(space.getId(), message.getSendToUserIds().get(0))).replace("String_Node_Str", LinkProviderUtils.getIgnoreInvitationToJoinSpaceUrl(space.getId(), message.getSendToUserIds().get(0))));
                     break;


Input:
public static void clearRegistrar() {
    DetectorRunner.clearRegistrar();
}

Output:
 public static void clearRegistrar() {
-    DetectorRunner.clearRegistrar();
+    detectorRunner.clearRegistrar();
 }


Input:
protected Dimension getIntrinsicDimension(IImageContent content, Image image) {
    if (image != null) {
        int contentResolution = content.getResolution();
        if (contentResolution != 0) {
            resolutionX = contentResolution;
            resolutionY = contentResolution;
        } else {
            resolutionX = image.getDpiX();
            resolutionY = image.getDpiY();
            if (0 == resolutionX || 0 == resolutionY) {
                ReportDesignHandle designHandle = content.getReportContent().getDesign().getReportDesign();
                resolutionX = designHandle.getImageDPI();
                resolutionY = designHandle.getImageDPI();
            }
            if (0 == resolutionX || 0 == resolutionY) {
                resolutionX = context.getDpi();
                resolutionY = context.getDpi();
            }
            if (0 == resolutionX || 0 == resolutionY) {
                resolutionX = 96;
                resolutionY = 96;
            }
        }
        return new Dimension((int) (image.plainWidth() * 1000 / resolutionX * 72), (int) (image.plainHeight() * 1000 / resolutionY * 72));
    }
    return null;
}

Output:
     if (image != null) {
-        int contentResolution = content.getResolution();
-        if (contentResolution != 0) {
-            resolutionX = contentResolution;
-            resolutionY = contentResolution;
-        } else {
-            resolutionX = image.getDpiX();
-            resolutionY = image.getDpiY();
-            if (0 == resolutionX || 0 == resolutionY) {
-                ReportDesignHandle designHandle = content.getReportContent().getDesign().getReportDesign();
-                resolutionX = designHandle.getImageDPI();
-                resolutionY = designHandle.getImageDPI();
-            }
-            if (0 == resolutionX || 0 == resolutionY) {
-                resolutionX = context.getDpi();
-                resolutionY = context.getDpi();
-            }
-            if (0 == resolutionX || 0 == resolutionY) {
-                resolutionX = 96;
-                resolutionY = 96;
-            }
+        int resolutionX = image.getDpiX();
+        int resolutionY = image.getDpiY();
+        if (0 == resolutionX || 0 == resolutionY) {
+            ReportDesignHandle designHandle = content.getReportContent().getDesign().getReportDesign();
+            resolutionX = designHandle.getImageDPI();
+            resolutionY = designHandle.getImageDPI();
+        }
+        if (0 == resolutionX || 0 == resolutionY) {
+            resolutionX = context.getDpi();
+            resolutionY = context.getDpi();
+        }
+        if (0 == resolutionX || 0 == resolutionY) {
+            resolutionX = 96;
+            resolutionY = 96;
         }


Input:
public void checkIbanValidity(ActionRequest request, ActionResponse response) throws AxelorException {
    List<BankDetails> bankDetailsList = request.getContext().asType(Partner.class).getBankDetailsList();
    List<String> ibanInError = Lists.newArrayList();
    for (BankDetails bankDetails : bankDetailsList) {
        if (bankDetails.getIban() != null) {
            LOG.debug("String_Node_Str", bankDetails.getIban());
            if (!IBANCheckDigit.IBAN_CHECK_DIGIT.isValid(bankDetails.getIban())) {
                ibanInError.add(bankDetails.getIban());
            }
        }
    }
    if (!ibanInError.isEmpty()) {
        Function<String, String> addLi = new Function<String, String>() {
            public String apply(String s) {
                return "String_Node_Str".concat(s).concat("String_Node_Str").toString();
            }
        };
        response.setAlert(String.format(IExceptionMessage.BANK_DETAILS_2, "String_Node_Str" + Joiner.on("String_Node_Str").join(Iterables.transform(ibanInError, addLi)) + "String_Node_Str"));
    }
}

Output:
     List<String> ibanInError = Lists.newArrayList();
-    for (BankDetails bankDetails : bankDetailsList) {
-        if (bankDetails.getIban() != null) {
-            LOG.debug("String_Node_Str", bankDetails.getIban());
-            if (!IBANCheckDigit.IBAN_CHECK_DIGIT.isValid(bankDetails.getIban())) {
-                ibanInError.add(bankDetails.getIban());
+    if (bankDetailsList != null && !bankDetailsList.isEmpty()) {
+        for (BankDetails bankDetails : bankDetailsList) {
+            if (bankDetails.getIban() != null) {
+                LOG.debug("String_Node_Str", bankDetails.getIban());
+                if (!IBANCheckDigit.IBAN_CHECK_DIGIT.isValid(bankDetails.getIban())) {
+                    ibanInError.add(bankDetails.getIban());
+                }
             }


Input:
public boolean loadData(String conf) {
    boolean loaded = false;
    if (!isEvicted(_rootModuleConf) && (hasConfigurationsToLoad() || !isRootModuleConfLoaded()) && !hasProblem()) {
        markRootModuleConfLoaded();
        if (_md == null) {
            DependencyResolver resolver = _data.getIvy().getResolver(getModuleId());
            try {
                Message.debug("String_Node_Str" + resolver + "String_Node_Str" + getId());
                _module = resolver.getDependency(_dd, _data);
                if (_module != null) {
                    _data.getIvy().saveResolver(_data.getCache(), _module.getDescriptor(), resolver.getName());
                    if (_data.getIvy().logModuleWhenFound()) {
                        Message.info("String_Node_Str" + _module.getId() + "String_Node_Str" + _module.getResolver().getName());
                    }
                    if (!getId().isExactRevision()) {
                        if (!_module.getId().isExactRevision()) {
                            Message.error("String_Node_Str" + getId() + "String_Node_Str");
                            _problem = new RuntimeException("String_Node_Str");
                            _data.getReport().addDependency(this);
                            return false;
                        }
                        IvyNode resolved = _data.getNode(_module.getId());
                        if (resolved != null) {
                            resolved._downloaded |= _module.isDownloaded();
                            resolved._searched |= _module.isSearched();
                            resolved.markSelected(_rootModuleConf);
                            resolved.updateDataFrom(this, _rootModuleConf);
                            resolved.loadData(conf);
                            if (_dd != null) {
                                resolved.addDependencyArtifactsIncludes(_rootModuleConf, _dd.getDependencyArtifactsIncludes(getParentConf()));
                            }
                            _data.register(getId(), resolved);
                            return true;
                        }
                    }
                    _downloaded = _module.isDownloaded();
                    _searched = _module.isSearched();
                } else {
                    Message.warn("String_Node_Str" + getId());
                    resolver.reportFailure();
                    _problem = new RuntimeException("String_Node_Str");
                }
            } catch (ParseException e) {
                _problem = e;
            }
            if (_module == null) {
                _data.getReport().addDependency(this);
                return false;
            } else {
                loaded = true;
                if (!getId().isExactRevision()) {
                    Message.info("String_Node_Str" + _module.getId().getRevision() + "String_Node_Str" + getId());
                }
                _md = _module.getDescriptor();
                if (!getId().isExactRevision()) {
                    _data.register(_module.getId(), this);
                }
                _confsToFetch.remove("String_Node_Str");
                updateConfsToFetch(Arrays.asList(resolveSpecialConfigurations(getRequiredConfigurations(getParent(), getParentConf()), this)));
            }
        } else {
            loaded = true;
        }
    }
    if (hasProblem()) {
        _data.getReport().addDependency(this);
        return handleConfiguration(loaded, conf) && loaded;
    }
    if (!handleConfiguration(loaded, conf)) {
        return false;
    }
    if (_dd != null) {
        addDependencyArtifactsIncludes(_rootModuleConf, _dd.getDependencyArtifactsIncludes(getParentConf()));
    }
    return loaded;
}

Output:
                 loaded = true;
-                if (!getId().isExactRevision()) {
+                if (!getId().isExactRevision() && _data.getIvy().logResolvedRevision()) {
                     Message.info("String_Node_Str" + _module.getId().getRevision() + "String_Node_Str" + getId());