Input:
protected List<DerivedField> createCategoricalDerivedField(ColumnConfig config, double cutoff, ModelNormalizeConf.NormType normType) {
    Document document = null;
    try {
        document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
    } catch (ParserConfigurationException e) {
        LOG.error("String_Node_Str", e);
        throw new RuntimeException("String_Node_Str", e);
    }
    String defaultValue = Normalizer.normalize(config, "String_Node_Str", cutoff, normType).toString();
    String missingValue = Normalizer.normalize(config, null, cutoff, normType).toString();
    InlineTable inlineTable = new InlineTable();
    for (int i = 0; i < config.getBinCategory().size(); i++) {
        List<String> catVals = CommonUtils.flattenCatValGrp(config.getBinCategory().get(i));
        for (String cval : catVals) {
            String dval = Normalizer.normalize(config, cval, cutoff, normType).toString();
            Element out = document.createElementNS(NAME_SPACE_URI, ELEMENT_OUT);
            out.setTextContent(dval);
            Element origin = document.createElementNS(NAME_SPACE_URI, ELEMENT_ORIGIN);
            origin.setTextContent(cval);
            inlineTable.withRows(new Row().withContent(origin).withContent(out));
        }
    }
    MapValues mapValues = new MapValues("String_Node_Str").withDataType(DataType.DOUBLE).withDefaultValue(defaultValue).withFieldColumnPairs(new FieldColumnPair(new FieldName(CommonUtils.getSimpleColumnName(config)), ELEMENT_ORIGIN)).withInlineTable(inlineTable).withMapMissingTo(missingValue);
    List<DerivedField> derivedFields = new ArrayList<DerivedField>();
    derivedFields.add(new DerivedField(OpType.CONTINUOUS, DataType.DOUBLE).withName(FieldName.create(genPmmlColumnName(CommonUtils.getSimpleColumnName(config), normType))).withExpression(mapValues));
    return derivedFields;
}

Output:
     }
-    String defaultValue = Normalizer.normalize(config, "String_Node_Str", cutoff, normType).toString();
-    String missingValue = Normalizer.normalize(config, null, cutoff, normType).toString();
+    String defaultValue = Normalizer.normalize(config, "String_Node_Str", cutoff, normType).get(0).toString();
+    String missingValue = Normalizer.normalize(config, null, cutoff, normType).get(0).toString();
     InlineTable inlineTable = new InlineTable();


Input:
private void testCreateAddAlterDrop(String dbName, String tableName) throws Exception {
    DatasetId datasetInstanceId = NAMESPACE_ID.dataset("String_Node_Str");
    String hiveTableName = getDatasetHiveName(datasetInstanceId);
    String showTablesCommand = "String_Node_Str";
    FileSetProperties.Builder props = FileSetProperties.builder().setBasePath("String_Node_Str").setEnableExploreOnCreate(true).setSerDe("String_Node_Str").setExploreInputFormat("String_Node_Str").setExploreOutputFormat("String_Node_Str").setTableProperty("String_Node_Str", SCHEMA.toString());
    if (tableName != null) {
        props.setExploreTableName(tableName);
        hiveTableName = tableName;
    }
    String queryTableName = hiveTableName;
    if (dbName != null) {
        props.setExploreDatabaseName(dbName);
        runCommand(NAMESPACE_ID, "String_Node_Str" + dbName, false, null, null);
        showTablesCommand += "String_Node_Str" + dbName;
        queryTableName = dbName + "String_Node_Str" + queryTableName;
    }
    datasetFramework.addInstance("String_Node_Str", datasetInstanceId, props.build());
    runCommand(NAMESPACE_ID, showTablesCommand, true, null, Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList(hiveTableName))));
    FileSet fileSet = datasetFramework.getDataset(datasetInstanceId, DatasetDefinition.NO_ARGUMENTS, null);
    Assert.assertNotNull(fileSet);
    FileWriterHelper.generateAvroFile(fileSet.getLocation("String_Node_Str").getOutputStream(), "String_Node_Str", 0, 3);
    runCommand(NAMESPACE_ID, "String_Node_Str" + queryTableName, true, Lists.newArrayList(new ColumnDesc(hiveTableName + "String_Node_Str", "String_Node_Str", 1, null), new ColumnDesc(hiveTableName + "String_Node_Str", "String_Node_Str", 2, null)), Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList("String_Node_Str", "String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str", "String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str", "String_Node_Str"))));
    FileWriterHelper.generateAvroFile(fileSet.getLocation("String_Node_Str").getOutputStream(), "String_Node_Str", 3, 5);
    runCommand(NAMESPACE_ID, "String_Node_Str" + queryTableName, true, Lists.newArrayList(new ColumnDesc("String_Node_Str", "String_Node_Str", 1, null)), Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList(5L))));
    datasetFramework.updateInstance(datasetInstanceId, props.setEnableExploreOnCreate(false).build());
    runCommand(NAMESPACE_ID, showTablesCommand, false, null, Collections.<QueryResult>emptyList());
    datasetFramework.updateInstance(datasetInstanceId, props.setEnableExploreOnCreate(true).build());
    runCommand(NAMESPACE_ID, "String_Node_Str" + queryTableName, true, Lists.newArrayList(new ColumnDesc("String_Node_Str", "String_Node_Str", 1, null)), Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList(5L))));
    datasetFramework.updateInstance(datasetInstanceId, props.setTableProperty("String_Node_Str", K_SCHEMA.toString()).build());
    runCommand(NAMESPACE_ID, "String_Node_Str" + queryTableName, true, Lists.newArrayList(new ColumnDesc(hiveTableName + "String_Node_Str", "String_Node_Str", 1, null)), Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str"))));
    datasetFramework.deleteInstance(datasetInstanceId);
    runCommand(NAMESPACE_ID, showTablesCommand, false, null, Collections.<QueryResult>emptyList());
    if (dbName != null) {
        runCommand(NAMESPACE_ID, "String_Node_Str" + dbName, false, null, null);
    }
}

Output:
     datasetFramework.updateInstance(datasetInstanceId, props.setTableProperty("String_Node_Str", K_SCHEMA.toString()).build());
-    runCommand(NAMESPACE_ID, "String_Node_Str" + queryTableName, true, Lists.newArrayList(new ColumnDesc(hiveTableName + "String_Node_Str", "String_Node_Str", 1, null)), Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str"))));
+    runCommand(NAMESPACE_ID, "String_Node_Str" + queryTableName + "String_Node_Str", true, Lists.newArrayList(new ColumnDesc(hiveTableName + "String_Node_Str", "String_Node_Str", 1, null)), Lists.newArrayList(new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str")), new QueryResult(Lists.<Object>newArrayList("String_Node_Str"))));
     datasetFramework.deleteInstance(datasetInstanceId);


Input:
public static void checkJavaProjectLib(Collection<String> jarsNeeded) {
    File libDir = getJavaProjectLibFolder();
    if ((libDir != null) && (libDir.isDirectory())) {
        Set<String> jarsNeededOnlyIncludeName = ModuleNameExtractor.extractFileName(jarsNeeded);
        Set<String> jarsNeedRetrieve = new HashSet<String>(jarsNeededOnlyIncludeName);
        for (File externalLib : libDir.listFiles(FilesUtils.getAcceptJARFilesFilter())) {
            jarsNeedRetrieve.remove(externalLib.getName());
        }
        if (!jarsNeedRetrieve.isEmpty()) {
            ILibraryManagerService repositoryBundleService = CorePlugin.getDefault().getRepositoryBundleService();
            repositoryBundleService.retrieve(jarsNeedRetrieve, libDir.getAbsolutePath(), false);
        }
    }
}

Output:
     if ((libDir != null) && (libDir.isDirectory())) {
-        Set<String> jarsNeededOnlyIncludeName = ModuleNameExtractor.extractFileName(jarsNeeded);
-        Set<String> jarsNeedRetrieve = new HashSet<String>(jarsNeededOnlyIncludeName);
+        Set<String> jarsNeedRetrieve = new HashSet<String>();
+        for (ModuleNeeded moduleNeeded : jarsNeeded) {
+            jarsNeedRetrieve.add(moduleNeeded.getModuleName());
+        }
         for (File externalLib : libDir.listFiles(FilesUtils.getAcceptJARFilesFilter())) {


Input:
public void addingSubsetDoesNothing() {
    addTwoElements(testSet);
    final IntHashSet subset = new IntHashSet(100, -1);
    subset.add(1);
    HashSet subSetCollection = new HashSet<>(subset);
    assertFalse(testSet.addAll(subset));
    assertFalse(testSet.addAll(subSetCollection));
    assertContainsElements(testSet);
}

Output:
     subset.add(1);
-    HashSet subSetCollection = new HashSet<>(subset);
+    final HashSet<Integer> subSetCollection = new HashSet<>(subset);
     assertFalse(testSet.addAll(subset));


Input:
public static void main(String[] args) throws Exception {
    Args arguments = new Args(args);
    String storeDir = arguments.get("String_Node_Str", !arguments.orphans().isEmpty() ? arguments.orphans().get(0) : null);
    ClusterManager cluster = new ClusterManager(arguments.get(HighlyAvailableGraphDatabase.CONFIG_KEY_HA_ZOO_KEEPER_SERVERS, null));
    cluster.waitForSyncConnected();
    final Machine master = cluster.getCachedMaster().other();
    System.out.println("String_Node_Str" + master);
    Map<String, String> config = MapUtil.stringMap(HighlyAvailableGraphDatabase.CONFIG_KEY_HA_MACHINE_ID, String.valueOf(master.getMachineId()));
    DelegatingResponseReceiver receiver = new DelegatingResponseReceiver();
    HighlyAvailableGraphDatabase db = new HighlyAvailableGraphDatabase(storeDir, config, AbstractBroker.wrapSingleBroker(new BackupBroker(new MasterClient(master.getServer().first(), master.getServer().other(), storeDir, receiver), storeDir)));
    receiver.setTarget(db);
    System.out.println("String_Node_Str" + master);
    try {
        db.pullUpdates();
        System.out.println("String_Node_Str");
    } finally {
        db.shutdown();
        cluster.shutdown();
    }
}

Output:
     Map<String, String> config = MapUtil.stringMap(HighlyAvailableGraphDatabase.CONFIG_KEY_HA_MACHINE_ID, String.valueOf(master.getMachineId()));
-    DelegatingResponseReceiver receiver = new DelegatingResponseReceiver();
-    HighlyAvailableGraphDatabase db = new HighlyAvailableGraphDatabase(storeDir, config, AbstractBroker.wrapSingleBroker(new BackupBroker(new MasterClient(master.getServer().first(), master.getServer().other(), storeDir, receiver), storeDir)));
-    receiver.setTarget(db);
+    HighlyAvailableGraphDatabase db = new HighlyAvailableGraphDatabase(storeDir, config, AbstractBroker.wrapSingleBroker(new BackupBroker(new MasterClient(master.getServer().first(), master.getServer().other(), storeDir), storeDir)));
     System.out.println("String_Node_Str" + master);


Input:
public ChannelPipeline getPipeline() throws Exception {
    ChannelPipeline pipeline = Channels.pipeline();
    pipeline.addLast("String_Node_Str", new LengthFieldBasedFrameDecoder(MAX_FRAME_LENGTH, 0, 4, 0, 4));
    pipeline.addLast("String_Node_Str", new LengthFieldPrepender(4));
    pipeline.addLast("String_Node_Str", new BlockingReadHandler<ChannelBuffer>());
    return pipeline;
}

Output:
     pipeline.addLast("String_Node_Str", new LengthFieldPrepender(4));
-    pipeline.addLast("String_Node_Str", new BlockingReadHandler<ChannelBuffer>());
+    BlockingReadHandler<ChannelBuffer> reader = new BlockingReadHandler<ChannelBuffer>();
+    pipeline.addLast("String_Node_Str", reader);
     return pipeline;


Input:
public boolean isMandatory() {
    List<Validator> validators = this.getValidators();
    if (validators == null)
        return false;
    for (Validator validator : validators) if (validator instanceof MandatoryValidator)
        return true;
    return false;
}

Output:
         return false;
-    for (Validator validator : validators) if (validator instanceof MandatoryValidator)
-        return true;
+    for (Validator validator : validators) {
+        if (validator instanceof MandatoryValidator)
+            return true;
+    }
     return false;


Input:
public synchronized void setTimeOffset(long pos) {
    seekOffset = (long) (pos / playbackSpeed);
    long minJumpForwardOffset = timeOffset + (long) (10000 / playbackSpeed);
    if (seekOffset < timeOffset || seekOffset > minJumpForwardOffset) {
        farSeeking = true;
    }
    notify();
}

Output:
     seekOffset = (long) (pos / playbackSpeed);
-    long minJumpForwardOffset = timeOffset + (long) (10000 / playbackSpeed);
-    if (seekOffset < timeOffset || seekOffset > minJumpForwardOffset) {
-        farSeeking = true;
+    if (allowJump) {
+        long minJumpForwardOffset = timeOffset + (long) (10000 / playbackSpeed);
+        if (seekOffset < timeOffset || seekOffset > minJumpForwardOffset) {
+            farSeeking = true;
+        }
     }


Input:
public void executeCommand(String commandId) throws ExecutionException, NotDefinedException, NotEnabledException, NotHandledException {
    IHandlerService handlerService = (IHandlerService) fControlView.getSite().getService(IHandlerService.class);
    handlerService.executeCommand(COMMAND_CATEGORY_PREFIX + commandId, null);
    waitForJobs();
}

Output:
 public void executeCommand(String commandId) throws ExecutionException, NotDefinedException, NotEnabledException, NotHandledException {
-    IHandlerService handlerService = (IHandlerService) fControlView.getSite().getService(IHandlerService.class);
+    Object handlerServiceObject = fControlView.getSite().getService(IHandlerService.class);
+    IHandlerService handlerService = (IHandlerService) handlerServiceObject;
     handlerService.executeCommand(COMMAND_CATEGORY_PREFIX + commandId, null);


Input:
public void testSort3() throws Exception {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    ILevelDefinition level11 = hier1.createLevel("String_Node_Str");
    ILevelDefinition level12 = hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    ILevelDefinition level21 = hier2.createLevel("String_Node_Str");
    cqd.createMeasure("String_Node_Str");
    IBinding binding1 = new Binding("String_Node_Str");
    binding1.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding1);
    IBinding binding2 = new Binding("String_Node_Str");
    binding2.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding2);
    IBinding binding4 = new Binding("String_Node_Str");
    binding4.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding4);
    IBinding binding5 = new Binding("String_Node_Str");
    binding5.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding5);
    CubeSortDefinition sorter1 = new CubeSortDefinition();
    sorter1.setExpression("String_Node_Str");
    sorter1.setSortDirection(ISortDefinition.SORT_DESC);
    sorter1.setTargetLevel(level21);
    CubeSortDefinition sorter2 = new CubeSortDefinition();
    sorter2.setExpression("String_Node_Str");
    sorter2.setSortDirection(ISortDefinition.SORT_DESC);
    sorter2.setTargetLevel(level11);
    CubeSortDefinition sorter3 = new CubeSortDefinition();
    sorter3.setExpression("String_Node_Str");
    sorter3.setSortDirection(ISortDefinition.SORT_DESC);
    sorter3.setTargetLevel(level12);
    cqd.addSort(sorter1);
    cqd.addSort(sorter2);
    cqd.addSort(sorter3);
    DataEngineImpl engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
    this.createCube(engine);
    IPreparedCubeQuery pcq = engine.prepare(cqd, null);
    ICubeQueryResults queryResults = pcq.execute(null);
    CubeCursor cursor = queryResults.getCubeCursor();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    this.printCube(cursor, columnEdgeBindingNames, "String_Node_Str", "String_Node_Str");
}

Output:
     columnEdgeBindingNames.add("String_Node_Str");
-    this.printCube(cursor, columnEdgeBindingNames, "String_Node_Str", "String_Node_Str");
+    List rowEdgeBindingNames = new ArrayList();
+    rowEdgeBindingNames.add("String_Node_Str");
+    this.printCube(cursor, columnEdgeBindingNames, rowEdgeBindingNames, "String_Node_Str");
 }


Input:
public static void launchVideoLibrary(Fragment fragment) {
    Intent videoPickerIntent = new Intent(Intent.ACTION_PICK);
    videoPickerIntent.setType("String_Node_Str");
    fragment.startActivityForResult(videoPickerIntent, RequestCode.ACTIVITY_REQUEST_CODE_VIDEO_LIBRARY);
}

Output:
 public static void launchVideoLibrary(Fragment fragment) {
-    Intent videoPickerIntent = new Intent(Intent.ACTION_PICK);
-    videoPickerIntent.setType("String_Node_Str");
-    fragment.startActivityForResult(videoPickerIntent, RequestCode.ACTIVITY_REQUEST_CODE_VIDEO_LIBRARY);
+    Intent intent = new Intent(Intent.ACTION_PICK);
+    intent.setType("String_Node_Str");
+    intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
+    fragment.startActivityForResult(intent, RequestCode.ACTIVITY_REQUEST_CODE_VIDEO_LIBRARY);
 }


Input:
public Record get(Record master) {
    MapValues values = getByMaster(master);
    if (values == null || values.getByte(1) == 1) {
        return null;
    }
    values.putByte(1, (byte) 1);
    return slaveCursor.recordAt(values.getLong(0));
}

Output:
     MapValues values = getByMaster(master);
-    if (values == null || values.getByte(1) == 1) {
+    if (values == null || values.get(1) == 1) {
         return null;


Input:
public String getItemCode(ItemStack item) {
    try {
        ItemStack clone = item.clone();
        clone.setAmount(1);
        String code = Base64.encodeObject(yaml.dump(clone));
        table.insertRow("String_Node_Str" + code + '\'');
        int id = Integer.parseInt(table.getRow("String_Node_Str" + code + '\'').get("String_Node_Str"));
        return Base62.encode(id);
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    } catch (SQLException e) {
        e.printStackTrace();
        return null;
    }
}

Output:
     try {
-        ItemStack clone = item.clone();
+        ItemStack clone = new ItemStack(item);
         clone.setAmount(1);


Input:
public void update(Observable sender, Object data) {
    if (sender instanceof LoginManager) {
        sender.deleteObserver(this);
        if (((LoginManager) sender).isLoggedIn()) {
            Intent returnIntent = new Intent();
            returnIntent.putExtra("String_Node_Str", true);
            setResult(RESULT_OK, returnIntent);
            finish();
        } else {
            mHiddenWebView.loadUrl(this.mJson.optString("String_Node_Str", "String_Node_Str"));
            mLoginStatusView.setVisibility(View.GONE);
            mLoginFormView.setVisibility(View.VISIBLE);
        }
    }
}

Output:
 public void update(Observable sender, Object data) {
-    if (sender instanceof LoginManager) {
+    if (sender instanceof LoginManager && mIsLogin) {
         sender.deleteObserver(this);


Input:
public void startContainer(IContainerContent container) {
    IStyle mergedStyle = container.getStyle();
    push(mergedStyle);
    if (isHidden()) {
        return;
    }
    logger.log(Level.FINE, "String_Node_Str");
    String tagName;
    StringBuffer styleBuffer = new StringBuffer();
    DimensionType x = container.getX();
    DimensionType y = container.getY();
    DimensionType width = container.getWidth();
    DimensionType height = container.getHeight();
    int display = checkElementType(x, y, width, height, mergedStyle, styleBuffer);
    tagName = openTagByType(display, DISPLAY_FLAG_ALL);
    tagStack.push(tagName);
    setStyleName(container.getStyleClass());
    String bookmark = container.getBookmark();
    if (bookmark == null) {
        bookmark = generateUniqueID();
    }
    setBookmark(tagName, bookmark);
    exportElementID(container, bookmark);
    setDisplayProperty(display, DISPLAY_INLINE_BLOCK, styleBuffer);
    handleShrink(display, mergedStyle, height, width, styleBuffer);
    handleStyle(container, styleBuffer);
}

Output:
     setBookmark(tagName, bookmark);
-    exportElementID(container, bookmark);
+    exportElementID(container, bookmark, "String_Node_Str");
     setDisplayProperty(display, DISPLAY_INLINE_BLOCK, styleBuffer);


Input:
protected ParamInjector evalInjectorBy(Type type, Param param) {
    Class<?> clazz = Lang.getTypeClass(type);
    if (clazz == null) {
        if (log.isWarnEnabled())
            log.warnf("String_Node_Str", type, param);
        return null;
    }
    Type[] paramTypes = null;
    if (type instanceof ParameterizedType)
        paramTypes = ((ParameterizedType) type).getActualTypeArguments();
    if (null == param)
        return null;
    String pm = param.value();
    if ("String_Node_Str".equals(pm)) {
        if (clazz.isAssignableFrom(Map.class))
            return new MapPairInjector();
        return new ObjectPairInjector(null, type);
    } else if (pm.startsWith("String_Node_Str") && pm.length() > 2) {
        return new ObjectNavlPairInjector(pm.substring(2), type);
    } else if (clazz.isArray())
        return new ArrayInjector(pm, clazz, paramTypes);
    return new NameInjector(pm, clazz, paramTypes);
}

Output:
         return new ArrayInjector(pm, clazz, paramTypes);
-    return new NameInjector(pm, clazz, paramTypes);
+    return new NameInjector(pm, datefmt, clazz, paramTypes);
 }


Input:
public void endElement(XPathFragment xPathFragment, UnmarshalRecord unmarshalRecord) {
    Object collection = unmarshalRecord.getContainerInstance(this);
    if (null != unmarshalRecord.getChildRecord()) {
        if (!xmlAnyCollectionMapping.usesXMLRoot()) {
            Object objectValue = unmarshalRecord.getChildRecord().getCurrentObject();
            if (xmlAnyCollectionMapping.getConverter() != null) {
                objectValue = xmlAnyCollectionMapping.getConverter().convertDataValueToObjectValue(objectValue, unmarshalRecord.getSession(), unmarshalRecord.getUnmarshaller());
            }
            unmarshalRecord.addAttributeValue(this, objectValue);
        }
        if (xmlAnyCollectionMapping.usesXMLRoot()) {
            Object childObject = unmarshalRecord.getChildRecord().getCurrentObject();
            if (workingDescriptor != null) {
                String prefix = xPathFragment.getPrefix();
                if ((prefix == null) && (xPathFragment.getNamespaceURI() != null)) {
                    prefix = unmarshalRecord.resolveNamespaceUri(xPathFragment.getNamespaceURI());
                }
                childObject = workingDescriptor.wrapObjectInXMLRoot(childObject, xPathFragment.getNamespaceURI(), xPathFragment.getLocalName(), prefix, false);
                if (xmlAnyCollectionMapping.getConverter() != null) {
                    childObject = xmlAnyCollectionMapping.getConverter().convertDataValueToObjectValue(childObject, unmarshalRecord.getSession(), unmarshalRecord.getUnmarshaller());
                }
                unmarshalRecord.addAttributeValue(this, childObject);
            }
        }
        unmarshalRecord.setChildRecord(null);
        workingDescriptor = null;
    } else {
        SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();
        UnmarshalKeepAsElementPolicy keepAsElementPolicy = xmlAnyCollectionMapping.getKeepAsElementPolicy();
        if ((((keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) || (keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT))) && (builder.getNodes().size() != 0)) {
            setOrAddAttributeValueForKeepAsElement(builder, xmlAnyCollectionMapping, xmlAnyCollectionMapping.getConverter(), unmarshalRecord, true, null);
        } else {
            endElementProcessText(unmarshalRecord, xmlAnyCollectionMapping.getConverter(), xPathFragment, null);
        }
    }
}

Output:
         UnmarshalKeepAsElementPolicy keepAsElementPolicy = xmlAnyCollectionMapping.getKeepAsElementPolicy();
-        if ((((keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) || (keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT))) && (builder.getNodes().size() != 0)) {
+        if ((((keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) || (keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT))) && (builder.getNodes().size() > 1)) {
             setOrAddAttributeValueForKeepAsElement(builder, xmlAnyCollectionMapping, xmlAnyCollectionMapping.getConverter(), unmarshalRecord, true, null);


Input:
protected Boolean doInBackground(Post... posts) {
    post = posts[0];
    nm = (NotificationManager) context.getSystemService("String_Node_Str");
    String postOrPage = (String) (post.isPage() ? context.getResources().getText(R.string.page_id) : context.getResources().getText(R.string.post_id));
    String message = context.getResources().getText(R.string.uploading) + "String_Node_Str" + postOrPage;
    n = new Notification(R.drawable.notification_icon, message, System.currentTimeMillis());
    Intent notificationIntent = new Intent(context, Posts.class);
    notificationIntent.setData((Uri.parse("String_Node_Str" + post.blogID)));
    notificationIntent.putExtra("String_Node_Str", true);
    PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, notificationIntent, Intent.FLAG_ACTIVITY_CLEAR_TOP);
    n.setLatestEventInfo(context, message, message, pendingIntent);
    notificationID = 22 + Integer.valueOf(post.blogID);
    nm.notify(notificationID, n);
    if (post.post_status == null) {
        post.post_status = "String_Node_Str";
    }
    Boolean publishThis = false;
    Spannable s;
    String descriptionContent = "String_Node_Str", moreContent = "String_Node_Str";
    int moreCount = 1;
    if (post.getMt_text_more() != null)
        moreCount++;
    String imgTags = "String_Node_Str";
    Pattern pattern = Pattern.compile(imgTags);
    for (int x = 0; x < moreCount; x++) {
        if (post.isLocalDraft()) {
            if (x == 0)
                s = (Spannable) WPHtml.fromHtml(post.getDescription(), context, post);
            else
                s = (Spannable) WPHtml.fromHtml(post.getMt_text_more(), context, post);
            WPImageSpan[] click_spans = s.getSpans(0, s.length(), WPImageSpan.class);
            if (click_spans.length != 0) {
                for (int i = 0; i < click_spans.length; i++) {
                    String prompt = context.getResources().getText(R.string.uploading_media_item) + String.valueOf(i + 1);
                    n.setLatestEventInfo(context, context.getResources().getText(R.string.uploading) + "String_Node_Str" + postOrPage, prompt, n.contentIntent);
                    nm.notify(notificationID, n);
                    WPImageSpan wpIS = click_spans[i];
                    int start = s.getSpanStart(wpIS);
                    int end = s.getSpanEnd(wpIS);
                    MediaFile mf = new MediaFile();
                    mf.setPostID(post.getId());
                    mf.setTitle(wpIS.getTitle());
                    mf.setCaption(wpIS.getCaption());
                    mf.setDescription(wpIS.getDescription());
                    mf.setFeatured(wpIS.isFeatured());
                    mf.setFileName(wpIS.getImageSource().toString());
                    mf.setHorizontalAlignment(wpIS.getHorizontalAlignment());
                    mf.setWidth(wpIS.getWidth());
                    String imgHTML = uploadImage(mf);
                    if (imgHTML != null) {
                        SpannableString ss = new SpannableString(imgHTML);
                        s.setSpan(ss, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                        s.removeSpan(wpIS);
                    } else {
                        s.removeSpan(wpIS);
                        mediaError = true;
                    }
                }
            }
            if (x == 0)
                descriptionContent = WPHtml.toHtml(s);
            else
                moreContent = WPHtml.toHtml(s);
        } else {
            Matcher matcher;
            if (x == 0) {
                descriptionContent = post.getDescription();
                matcher = pattern.matcher(descriptionContent);
            } else {
                moreContent = post.getMt_text_more();
                matcher = pattern.matcher(moreContent);
            }
            while (matcher.find()) {
                String tag = "String_Node_Str";
                if (x == 0)
                    tag = descriptionContent.substring(matcher.start(), matcher.end());
                else
                    tag = moreContent.substring(matcher.start(), matcher.end());
                Pattern p = Pattern.compile("String_Node_Str");
                Matcher m = p.matcher(tag);
                String imgPath = "String_Node_Str";
                if (m.find()) {
                    imgPath = m.group(1);
                    if (!imgPath.equals("String_Node_Str")) {
                        MediaFile mf = WordPress.wpDB.getMediaFile(imgPath, post);
                        if (mf != null) {
                            String imgHTML = uploadImage(mf);
                            if (imgHTML != null) {
                                if (x == 0)
                                    descriptionContent = descriptionContent.replace(tag, imgHTML);
                                else
                                    moreContent = moreContent.replace(tag, imgHTML);
                            } else {
                                if (x == 0)
                                    descriptionContent = descriptionContent.replace(tag, "String_Node_Str");
                                else
                                    moreContent = moreContent.replace(tag, "String_Node_Str");
                                mediaError = true;
                            }
                        }
                    }
                }
            }
        }
    }
    JSONArray categories = post.getCategories();
    String[] theCategories = null;
    if (categories != null) {
        theCategories = new String[categories.length()];
        for (int i = 0; i < categories.length(); i++) {
            try {
                theCategories[i] = categories.getString(i);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }
    Map<String, Object> contentStruct = new HashMap<String, Object>();
    if (!post.isPage && post.isLocalDraft()) {
        HashMap<?, ?> globalSettings = WordPress.wpDB.getNotificationOptions(context);
        boolean taglineValue = false;
        String tagline = "String_Node_Str";
        if (globalSettings != null) {
            if (globalSettings.get("String_Node_Str").toString().equals("String_Node_Str")) {
                taglineValue = true;
            }
            if (taglineValue) {
                tagline = globalSettings.get("String_Node_Str").toString();
                if (tagline != null) {
                    String tag = "String_Node_Str" + tagline + "String_Node_Str";
                    if (moreContent == "String_Node_Str")
                        descriptionContent += tag;
                    else
                        moreContent += tag;
                }
            }
        }
        if (!post.getWP_post_format().equals("String_Node_Str")) {
            if (!post.getWP_post_format().equals("String_Node_Str"))
                contentStruct.put("String_Node_Str", post.getWP_post_format());
        }
    }
    contentStruct.put("String_Node_Str", (post.isPage) ? "String_Node_Str" : "String_Node_Str");
    contentStruct.put("String_Node_Str", post.title);
    long pubDate = post.date_created_gmt;
    if (pubDate != 0) {
        Date date_created_gmt = new Date(pubDate);
        contentStruct.put("String_Node_Str", date_created_gmt);
        Date dateCreated = new Date(pubDate + (date_created_gmt.getTimezoneOffset() * 60000));
        contentStruct.put("String_Node_Str", dateCreated);
    }
    if (!moreContent.equals("String_Node_Str")) {
        descriptionContent = descriptionContent + "String_Node_Str" + moreContent;
        post.mt_text_more = "String_Node_Str";
    }
    if (post.isLocalDraft()) {
        descriptionContent = descriptionContent.replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str");
    }
    descriptionContent = descriptionContent.replaceAll("String_Node_Str", "String_Node_Str");
    contentStruct.put("String_Node_Str", descriptionContent);
    if (!post.isPage) {
        if (post.mt_keywords != "String_Node_Str") {
            contentStruct.put("String_Node_Str", post.mt_keywords);
        }
        if (theCategories != null) {
            if (theCategories.length > 0)
                contentStruct.put("String_Node_Str", theCategories);
        }
    }
    if (post.getMt_excerpt() != null)
        contentStruct.put("String_Node_Str", post.getMt_excerpt());
    contentStruct.put((post.isPage) ? "String_Node_Str" : "String_Node_Str", post.post_status);
    Double latitude = 0.0;
    Double longitude = 0.0;
    if (!post.isPage) {
        latitude = (Double) post.getLatitude();
        longitude = (Double) post.getLongitude();
        if (latitude > 0) {
            HashMap<Object, Object> hLatitude = new HashMap<Object, Object>();
            hLatitude.put("String_Node_Str", "String_Node_Str");
            hLatitude.put("String_Node_Str", latitude);
            HashMap<Object, Object> hLongitude = new HashMap<Object, Object>();
            hLongitude.put("String_Node_Str", "String_Node_Str");
            hLongitude.put("String_Node_Str", longitude);
            HashMap<Object, Object> hPublic = new HashMap<Object, Object>();
            hPublic.put("String_Node_Str", "String_Node_Str");
            hPublic.put("String_Node_Str", 1);
            Object[] geo = { hLatitude, hLongitude, hPublic };
            contentStruct.put("String_Node_Str", geo);
        }
    }
    XMLRPCClient client = new XMLRPCClient(post.blog.getUrl(), post.blog.getHttpuser(), post.blog.getHttppassword());
    if (post.quickPostType != null)
        client.addQuickPostHeader(post.quickPostType);
    n.setLatestEventInfo(context, message, message, n.contentIntent);
    nm.notify(notificationID, n);
    if (post.wp_password != null) {
        contentStruct.put("String_Node_Str", post.wp_password);
    }
    Object[] params;
    if (post.isLocalDraft() && !post.uploaded)
        params = new Object[] { post.blog.getBlogId(), post.blog.getUsername(), post.blog.getPassword(), contentStruct, publishThis };
    else
        params = new Object[] { post.getPostid(), post.blog.getUsername(), post.blog.getPassword(), contentStruct, publishThis };
    try {
        client.call((post.isLocalDraft() && !post.uploaded) ? "String_Node_Str" : "String_Node_Str", params);
        post.setUploaded(true);
        post.setLocalChange(false);
        post.update();
        return true;
    } catch (final XMLRPCException e) {
        error = e.getLocalizedMessage();
        mediaError = false;
        Log.i("String_Node_Str", error);
    }
    return false;
}

Output:
                             if (imgHTML != null) {
-                                if (x == 0)
+                                if (x == 0) {
                                     descriptionContent = descriptionContent.replace(tag, imgHTML);


Input:
protected void installPackage(Uri uri, Uri originatingUri, String packageName) {
    sendBroadcastInstall(uri, originatingUri, Installer.ACTION_INSTALL_STARTED);
    Utils.debugLog(TAG, "String_Node_Str" + uri + "String_Node_Str" + new File(uri.getPath()));
    Uri sanitizedUri;
    try {
        sanitizedUri = Installer.prepareApkFile(mContext, uri, packageName);
    } catch (Installer.InstallFailedException e) {
        Log.e(TAG, "String_Node_Str", e);
        sendBroadcastInstall(uri, originatingUri, Installer.ACTION_INSTALL_INTERRUPTED, e.getMessage());
        return;
    }
    Intent installIntent = new Intent(mContext, DefaultInstallerActivity.class);
    installIntent.setAction(DefaultInstallerActivity.ACTION_INSTALL_PACKAGE);
    installIntent.putExtra(DefaultInstallerActivity.EXTRA_ORIGINATING_URI, originatingUri);
    installIntent.setData(sanitizedUri);
    PendingIntent installPendingIntent = PendingIntent.getActivity(mContext.getApplicationContext(), uri.hashCode(), installIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    sendBroadcastInstall(uri, originatingUri, Installer.ACTION_INSTALL_USER_INTERACTION, installPendingIntent);
}

Output:
     try {
-        sanitizedUri = Installer.prepareApkFile(mContext, uri, packageName);
+        sanitizedUri = Installer.prepareApkFile(context, uri, packageName);
     } catch (Installer.InstallFailedException e) {


Input:
private boolean inBounds(final Cell cell) {
    final MultiDimensionalCoordinates coordinates = indexStrategy.getCoordinatesPerDimension(new ByteArrayId(new GeowaveRowId(cell.getRowArray(), cell.getRowLength()).getInsertionId()));
    return rangeCache.inBounds(coordinates);
}

Output:
 private boolean inBounds(final Cell cell) {
-    final MultiDimensionalCoordinates coordinates = indexStrategy.getCoordinatesPerDimension(new ByteArrayId(new GeowaveRowId(cell.getRowArray(), cell.getRowLength()).getInsertionId()));
+    final MultiDimensionalCoordinates coordinates = indexStrategy.getCoordinatesPerDimension(new ByteArrayId(new GeowaveRowId(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength()).getInsertionId()));
     return rangeCache.inBounds(coordinates);


Input:
public Set<HttpRoute> get() {
    rootRouter.route("String_Node_Str").authenticateWith(ssoToken().exceptActions("String_Node_Str")).auditAs(OAUTH).toCollection(TokenResource.class);
    rootRouter.route("String_Node_Str").authenticateWith(ssoToken()).auditAs(OAUTH).authorizeWith(AdminOnlyAuthzModule.class).toCollection(ClientResource.class);
    return Collections.singleton(HttpRoute.newHttpRoute(STARTS_WITH, "String_Node_Str", newHttpHandler(rootRouter.getRouter())));
}

Output:
     rootRouter.route("String_Node_Str").authenticateWith(ssoToken()).auditAs(OAUTH).authorizeWith(AdminOnlyAuthzModule.class).toCollection(ClientResource.class);
-    return Collections.singleton(HttpRoute.newHttpRoute(STARTS_WITH, "String_Node_Str", newHttpHandler(rootRouter.getRouter())));
+    return Collections.singleton(HttpRoute.newHttpRoute(STARTS_WITH, "String_Node_Str", Handlers.chainOf(newHttpHandler(rootRouter.getRouter()), authenticationFilter)));
 }


Input:
protected void initialize() {
    super.initialize();
    for (Iterator itr = getMarkers().iterator(); itr.hasNext(); ) {
        Marker mk = (Marker) itr.next();
        mk.setVisible(false);
    }
}

Output:
     super.initialize();
-    for (Iterator itr = getMarkers().iterator(); itr.hasNext(); ) {
-        Marker mk = (Marker) itr.next();
+    for (Iterator<Marker> itr = getMarkers().iterator(); itr.hasNext(); ) {
+        Marker mk = itr.next();
         mk.setVisible(false);


Input:
public List<String> getPermissions(String worldName) {
    List<String> result = this.node.getStringList(formatPath(worldName, "String_Node_Str"));
    return result == null ? new LinkedList<String>() : result;
}

Output:
     List<String> result = this.node.getStringList(formatPath(worldName, "String_Node_Str"));
-    return result == null ? new LinkedList<String>() : result;
+    return result == null ? Collections.<String>emptyList() : Collections.unmodifiableList(result);
 }


Input:
private boolean checkAccessForGroups(Set<String> groups, Set<AtlasResourceTypes> resourceType, String resource, Map<String, Map<AtlasResourceTypes, List<String>>> map) {
    boolean isAccessAllowed = false;
    if (isDebugEnabled) {
        LOG.debug("String_Node_Str");
    }
    for (String group : groups) {
        isAccessAllowed = checkAccess(group, resourceType, resource, map);
        if (isAccessAllowed) {
            break;
        }
    }
    if (isDebugEnabled) {
        LOG.debug("String_Node_Str");
    }
    return isAccessAllowed;
}

Output:
     }
-    for (String group : groups) {
-        isAccessAllowed = checkAccess(group, resourceType, resource, map);
-        if (isAccessAllowed) {
-            break;
+    if (CollectionUtils.isNotEmpty(groups)) {
+        for (String group : groups) {
+            isAccessAllowed = checkAccess(group, resourceType, resource, map);
+            if (isAccessAllowed) {
+                break;
+            }
         }


Input:
public SQLMapperResultRequest newInstance() {
    return new SQLMapperResultRequest(reduceJobStatusContext, cacheRecycler);
}

Output:
 public SQLMapperResultRequest newInstance() {
-    return new SQLMapperResultRequest(reduceJobStatusContext, cacheRecycler);
+    return new SQLMapperResultRequest(reduceJobStatusContext);
 }


Input:
public void run(OCMind mind) {
    for (Atom a : mind.getAtoms()) {
        final int sti = mind.getSTI(a);
        int avgSurroundingSTI = 0;
        int count = 0;
        final Collection<Atom> ie = mind.getIncidentEdges(a);
        if (ie != null) {
            for (Atom e : ie) {
                avgSurroundingSTI += mind.getSTI(e);
                count++;
            }
        }
        final Collection<Atom> iv = mind.getIncidentVertices(a);
        if (iv != null) {
            for (Atom e : iv) {
                avgSurroundingSTI += mind.getSTI(e);
                count++;
            }
        }
        if (count != 0) {
            avgSurroundingSTI /= count;
        } else {
            continue;
        }
        final int diffusion_momentum = 60;
        short difference = (short) (sti - avgSurroundingSTI);
        if (avgSurroundingSTI < sti) {
            difference /= diffusion_momentum;
            if (difference < 1)
                difference = 1;
            addStimulus(a, (short) -difference);
            totalSurplus += difference;
        } else if (avgSurroundingSTI > sti) {
            difference = (short) (avgSurroundingSTI - sti);
            difference /= diffusion_momentum;
            if (difference < 1)
                difference = 1;
            difference = (short) Math.min(difference, totalSurplus);
            if (totalSurplus >= difference) {
                addStimulus(a, (short) difference);
                totalSurplus -= difference;
            }
        }
    }
}

Output:
 public void run(OCMind mind) {
-    for (Atom a : mind.getAtoms()) {
+    Iterator<Atom> ia = mind.iterateAtoms();
+    while (ia.hasNext()) {
+        Atom a = ia.next();
         final int sti = mind.getSTI(a);


Input:
public boolean keyDown(int code) {
    Keyboard.Log k = keyboard.codeToLog.get(code);
    k.hit = Keyboard.t + 1;
    return true;
}

Output:
     Keyboard.Log k = keyboard.codeToLog.get(code);
-    k.hit = Keyboard.t + 1;
+    if (k != null)
+        k.hit = Keyboard.t + 1;
     return true;


Input:
public SignatureKeyPair generateKeyPair() {
    int processors = Runtime.getRuntime().availableProcessors();
    SignaturePrivateKey priv = new SignaturePrivateKey();
    if (processors == 1)
        for (int k = params.B; k >= 0; k--) priv.add(generateBoundedBasis());
    else {
        List<Future<Basis>> bases = new ArrayList<Future<Basis>>();
        int numThreads = Math.min(params.B, processors - 1);
        if (numThreads > 0) {
            ExecutorService executor = Executors.newFixedThreadPool(numThreads);
            for (int k = params.B - 1; k >= 0; k--) bases.add(executor.submit(new BasisGenerationTask()));
            executor.shutdown();
        }
        Basis basis0 = generateBoundedBasis();
        priv.add(basis0);
        for (Future<Basis> basis : bases) try {
            priv.add(basis.get());
        } catch (Exception e) {
            throw new NtruException(e);
        }
    }
    SignaturePublicKey pub = new SignaturePublicKey(priv.getBasis(0).h, params);
    SignatureKeyPair kp = new SignatureKeyPair(priv, pub);
    return kp;
}

Output:
     }
-    SignaturePublicKey pub = new SignaturePublicKey(priv.getBasis(0).h, params);
+    SignaturePublicKey pub = new SignaturePublicKey(priv.getBasis(params.B).h, params);
     SignatureKeyPair kp = new SignatureKeyPair(priv, pub);


Input:
private List<E> populateEntities(EntityMetadata m, Client client) throws Exception {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str", ((QueryImpl) query).getJPAQuery());
    }
    List<E> result = new ArrayList<E>();
    ApplicationMetadata appMetadata = KunderaMetadata.INSTANCE.getApplicationMetadata();
    externalProperties = ((CassandraClientBase) client).getExternalProperties();
    MetamodelImpl metaModel = (MetamodelImpl) KunderaMetadata.INSTANCE.getApplicationMetadata().getMetamodel(m.getPersistenceUnit());
    if (!appMetadata.isNative(((QueryImpl) query).getJPAQuery()) && ((CassandraClientBase) client).isCql3Enabled(m)) {
        String parsedQuery = query.onQueryOverCQL3(m, client, metaModel, null);
        parsedQuery = appendWhereClauseWithScroll(parsedQuery);
        results = parsedQuery != null ? ((CassandraClientBase) client).executeQuery(parsedQuery, m.getEntityClazz(), m.getRelationNames()) : null;
    } else {
        if (appMetadata.isNative(((QueryImpl) query).getJPAQuery())) {
            final String nativeQuery = appendWhereClauseWithScroll(((QueryImpl) query).getJPAQuery());
            results = nativeQuery != null ? ((CassandraClientBase) client).executeQuery(nativeQuery, m.getEntityClazz(), null) : null;
        } else {
            boolean useInvertedIndex = CassandraIndexHelper.isInvertedIndexingApplicable(m, MetadataUtils.useSecondryIndex(((ClientBase) client).getClientMetadata()));
            Map<Boolean, List<IndexClause>> ixClause = query.prepareIndexClause(m, useInvertedIndex);
            if (useInvertedIndex && !((QueryImpl) query).getKunderaQuery().getFilterClauseQueue().isEmpty()) {
                result = (List) ((CassandraEntityReader) this.reader).readFromIndexTable(m, client, ixClause);
            } else {
                boolean isRowKeyQuery = ixClause.keySet().iterator().next();
                List<IndexExpression> expressions = !ixClause.get(isRowKeyQuery).isEmpty() ? ixClause.get(isRowKeyQuery).get(0).getExpressions() : null;
                Map<String, byte[]> rowKeys = ((CassandraEntityReader) this.reader).getRowKeyValue(expressions, ((AbstractAttribute) m.getIdAttribute()).getJPAColumnName());
                byte[] minValue = start == null ? rowKeys.get(MIN_) : start;
                byte[] maxVal = rowKeys.get(MAX_);
                results = ((CassandraClientBase) client).findByRange(minValue, maxVal, m, m.getRelationNames() != null && !m.getRelationNames().isEmpty(), m.getRelationNames(), query.getColumnList(m, ((QueryImpl) query).getKunderaQuery().getResult(), null), expressions, maxResult);
                if (maxResult == 1) {
                    maxResult++;
                } else if (maxResult > 1 && checkOnEmptyResult() && maxResult != results.size()) {
                    results = null;
                }
            }
        }
    }
    return results;
}

Output:
     MetamodelImpl metaModel = (MetamodelImpl) KunderaMetadata.INSTANCE.getApplicationMetadata().getMetamodel(m.getPersistenceUnit());
-    if (!appMetadata.isNative(((QueryImpl) query).getJPAQuery()) && ((CassandraClientBase) client).isCql3Enabled(m)) {
+    String queryString = appMetadata.getQuery(((QueryImpl) query).getJPAQuery());
+    boolean isNative = ((CassQuery) query).isNative();
+    if (!isNative && ((CassandraClientBase) client).isCql3Enabled(m)) {
         String parsedQuery = query.onQueryOverCQL3(m, client, metaModel, null);


Input:
public IValue withType(IType type, ITypeContext typeContext, MarkerList markers, IContext context) {
    if (type.isArrayType()) {
        return this;
    }
    IAnnotation annotation = type.getTheClass().getAnnotation(Types.NIL_CONVERTIBLE_CLASS);
    if (annotation != null) {
        this.methodName = LiteralConversion.getMethodName(annotation);
        this.requiredType = type;
        return this;
    }
    markers.add(I18n.createMarker(this.position, "String_Node_Str", type));
    return this;
}

Output:
     }
-    markers.add(I18n.createMarker(this.position, "String_Node_Str", type));
+    if (type != dyvil.tools.compiler.ast.type.Types.UNKNOWN) {
+        markers.add(I18n.createMarker(this.position, "String_Node_Str", type));
+    } else {
+        markers.add(I18n.createMarker(this.position, "String_Node_Str", type));
+    }
     return this;


Input:
private void createButtonListener() {
    tabFactory.getTabbedPropertyComposite().getCompactButton().setVisible(true);
    tabFactory.getTabbedPropertyComposite().getTableButton().setVisible(true);
    tabFactory.getTabbedPropertyComposite().getCompactButton().addSelectionListener(new SelectionListener() {

        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            tabFactory.getTabbedPropertyComposite().setCompactView(true);
            getPreference().setValue(TalendDesignerPrefConstants.VIEW_OPTIONS, ComponentSettingsView.DEFAULT);
            tabFactory.getTabbedPropertyComposite().getCompactButton().setImage(ImageProvider.getImage(EImage.COMPACT_VIEW));
            tabFactory.getTabbedPropertyComposite().getTableButton().setImage(ImageProvider.getImage(EImage.NO_TABLE_VIEW));
            if (getDc() != null) {
                getDc().dispose();
                if (getParentMap().get(ComponentSettingsView.PARENT) != null && getCategoryMap().get(ComponentSettingsView.CATEGORY) != null) {
                    dc = new MultipleThreadDynamicComposite(getParentMap().get(ComponentSettingsView.PARENT), SWT.H_SCROLL | SWT.V_SCROLL | SWT.NO_FOCUS, getCategoryMap().get(ComponentSettingsView.CATEGORY), element, true);
                    dc.refresh();
                }
            }
        }
    });
    tabFactory.getTabbedPropertyComposite().getTableButton().addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            tabFactory.getTabbedPropertyComposite().setCompactView(false);
            getPreference().setValue(TalendDesignerPrefConstants.VIEW_OPTIONS, ComponentSettingsView.TABLEVIEW);
            tabFactory.getTabbedPropertyComposite().getCompactButton().setImage(ImageProvider.getImage(EImage.NO_COMPACT_VIEW));
            tabFactory.getTabbedPropertyComposite().getTableButton().setImage(ImageProvider.getImage(EImage.TABLE_VIEW));
            if (getDc() != null) {
                getDc().dispose();
                if (getParentMap().get(ComponentSettingsView.PARENT) != null && getCategoryMap().get(ComponentSettingsView.CATEGORY) != null) {
                    dc = new MultipleThreadDynamicComposite(getParentMap().get(ComponentSettingsView.PARENT), SWT.H_SCROLL | SWT.V_SCROLL | SWT.NO_FOCUS, getCategoryMap().get(ComponentSettingsView.CATEGORY), element, false);
                    dc.refresh();
                }
            }
        }
    });
}

Output:
     tabFactory.getTabbedPropertyComposite().getTableButton().setVisible(true);
-    tabFactory.getTabbedPropertyComposite().getCompactButton().addSelectionListener(new SelectionListener() {
+    if (compactListener == null) {
+        compactListener = new SelectionListener() {


Input:
public void setUp() throws Exception {
    super.setUp();
    resource1.getContents().add(createBasicModel(FILE1_SUFFIX));
    resource2.getContents().add(createBasicModel(FILE2_SUFFIX));
    makeCrossReference(resource1, resource2, CLASS1_NAME_PREFIX, CLASS1_NAME_PREFIX);
    makeCrossReference(resource2, resource1, CLASS2_NAME_PREFIX, CLASS2_NAME_PREFIX);
    save(resource1, resource2);
    commits[0] = repository.addAndCommit(project, "String_Node_Str", file1, file2);
    EPackage packFile2 = (EPackage) findObject(resource2, PACKAGE_NAME_PREFIX);
    final EClass newClassFile2 = createClass(packFile2, CLASS3_NAME_PREFIX + FILE2_SUFFIX);
    save(resource2);
    commits[1] = repository.addAndCommit(project, "String_Node_Str", file2);
    newClassFile2.setName(CLASS4_NAME_PREFIX + FILE2_SUFFIX);
    save(resource2);
    commits[2] = repository.addAndCommit(project, "String_Node_Str", file2);
    repository.createBranch(MASTER, BRANCH);
    packFile2.getEClassifiers().remove(newClassFile2);
    save(resource2);
    commits[3] = repository.addAndCommit(project, "String_Node_Str", file2);
    final EClass classBFile1 = (EClass) findObject(resource1, CLASS2_NAME_PREFIX);
    final EClass classBFile2 = (EClass) findObject(resource2, CLASS2_NAME_PREFIX);
    classBFile1.setName(CLASS3_NAME_PREFIX + FILE1_SUFFIX);
    classBFile2.setName(CLASS3_NAME_PREFIX + FILE2_SUFFIX);
    save(resource1, resource2);
    commits[4] = repository.addAndCommit(project, "String_Node_Str", file1, file2);
    repository.checkoutBranch(BRANCH);
    reload(resource1, resource2);
    final EClass classAFile1 = (EClass) findObject(resource1, CLASS1_NAME_PREFIX);
    final EClass classAFile2 = (EClass) findObject(resource2, CLASS1_NAME_PREFIX);
    classAFile1.setName(CLASS3_NAME_PREFIX + FILE1_SUFFIX);
    classAFile2.setName(CLASS3_NAME_PREFIX + FILE2_SUFFIX);
    save(resource1, resource2);
    commits[5] = repository.addAndCommit(project, "String_Node_Str", file1, file2);
    EcoreUtil.remove(findObject(resource2, CLASS4_NAME_PREFIX));
    save(resource2);
    commits[6] = repository.addAndCommit(project, "String_Node_Str", file2);
    masterTipSynonyms = new String[] { MASTER, commits[4].getName() };
    branchTipSynonyms = new String[] { BRANCH, commits[6].getName(), Constants.HEAD };
}

Output:
     masterTipSynonyms = new String[] { MASTER, commits[4].getName() };
-    branchTipSynonyms = new String[] { BRANCH, commits[6].getName(), Constants.HEAD };
+    branchTipSynonyms = new String[] { BRANCH, commits[6].getName() };
 }


Input:
protected void setupPageBreak(PolicyNode node) {
    ReportItemDesign item = node.design;
    String styleClass = item.getStyleName();
    if (styleClass != null) {
        IStyle style = report.findStyle(styleClass);
        CSSValue masterPage = style.getProperty(IStyle.STYLE_MASTER_PAGE);
        CSSValue pageBreakBefore = style.getProperty(IStyle.STYLE_PAGE_BREAK_BEFORE);
        CSSValue pageBreakAfter = style.getProperty(IStyle.STYLE_PAGE_BREAK_AFTER);
        if (masterPage != null || pageBreakBefore != null) {
            node.breakBefore = true;
            node.execute = true;
        } else if (pageBreakAfter != null) {
            node.breakAfter = true;
            node.execute = true;
        }
    }
    if (item.getJavaClass() != null || item.getOnCreate() != null || item.getOnPageBreak() != null) {
        node.breakBefore = true;
        node.breakAfter = true;
        node.execute = true;
    }
    if (node.breakBefore || node.breakAfter) {
        Iterator iter = rows.iterator();
        while (iter.hasNext()) {
            PolicyNode row = (PolicyNode) iter.next();
            row.executeAll = true;
        }
        return;
    }
    if (item.getHighlight() != null || item.getMap() != null) {
        node.execute = true;
    }
    if (item.getTOC() != null || item.getBookmark() != null || item.getAction() != null) {
        node.execute = true;
    }
    if (item.getQueries() != null) {
        node.execute = true;
    }
    if (item.getVisibility() != null) {
        node.execute = true;
    }
}

Output:
             node.execute = true;
-        } else if (pageBreakAfter != null) {
+        }
+        if (pageBreakAfter != null) {
             node.breakAfter = true;


Input:
private String getLatestIndexedHash(Client client) {
    try {
        String hash = client.prepareGet(ES_UPDATEALIAS, "String_Node_Str", toString()).get().getSourceAsMap().get("String_Node_Str").toString();
        if (hash != null && hash.length() == 40) {
            return hash;
        }
    } catch (Exception e) {
        log.info("String_Node_Str", toString(), e);
    }
    return EMPTY_TREE;
}

Output:
     try {
-        String hash = client.prepareGet(ES_UPDATEALIAS, "String_Node_Str", toString()).get().getSourceAsMap().get("String_Node_Str").toString();
+        String hash = client.prepareGet(ES_UPDATEALIAS, "String_Node_Str", toString()).setRouting(getRepoDesc()).get().getSourceAsMap().get("String_Node_Str").toString();
         if (hash != null && hash.length() == 40) {


Input:
private void doTestSuite() {
    while (m_job.getTestSuite() != null && !m_stopProcessing) {
        while (m_idle && !m_stopProcessing) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
            }
        }
        if (m_job.getTestSuite() != null && !m_stopProcessing && !m_idle && !m_isFirstAutStart) {
            m_idle = true;
            AbstractCmdlineClient.printConsoleLn(StringConstants.TAB + NLS.bind(Messages.ExecutionControllerTestSuiteBegin, m_job.getTestSuite().getName()), true);
            ClientTestFactory.getClientTest().startTestSuite(m_job.getTestSuite(), m_job.getLanguage(), m_startedAutId != null ? m_startedAutId : m_job.getAutId(), m_job.isAutoScreenshot());
        }
    }
}

Output:
 private void doTestSuite() {
-    while (m_job.getTestSuite() != null && !m_stopProcessing) {
+    while (m_job.getActualTestSuite() != null && !m_stopProcessing) {
         while (m_idle && !m_stopProcessing) {


Input:
protected void setPropValue(String newValue) {
    if (UIUtil.needAddQuote(ReportDesignConstants.STYLE_ELEMENT, StyleHandle.FONT_FAMILY_PROP, newValue)) {
        super.setPropValue(DEUtil.AddQuote(newValue));
    } else {
        super.setPropValue(newValue);
    }
}

Output:
 protected void setPropValue(String newValue) {
-    if (UIUtil.needAddQuote(ReportDesignConstants.STYLE_ELEMENT, StyleHandle.FONT_FAMILY_PROP, newValue)) {
-        super.setPropValue(DEUtil.AddQuote(newValue));
-    } else {
-        super.setPropValue(newValue);
-    }
+    super.setPropValue(newValue);
 }


Input:
public boolean select(Viewer viewer, Object parentElement, Object element) {
    if (element instanceof IFolder) {
        IFolder folder = (IFolder) element;
        if (SOURCE_FILES.equals(folder.getName()) || TDQ_LIBRARIES.equals(folder.getName())) {
            return true;
        } else {
            return defaultValidFolder.getFullPath().isPrefixOf(folder.getFullPath()) && !FilesUtils.isSVNFolder(folder.getName());
        }
    }
    return false;
}

Output:
         IFolder folder = (IFolder) element;
-        if (SOURCE_FILES.equals(folder.getName()) || TDQ_LIBRARIES.equals(folder.getName())) {
+        if (SOURCE_FILES.equals(folder.getName())) {
             return true;


Input:
public Object clone() {
    GroupsModelArray clone = (GroupsModelArray) super.clone();
    if (_nativedata != null)
        clone._nativedata = ArraysX.clone(_nativedata);
    if (_data != null)
        clone._data = ArraysX.clone(_data);
    if (_heads != null)
        clone._heads = ArraysX.clone(_heads);
    if (_foots != null)
        clone._foots = ArraysX.clone(_foots);
    if (_closes != null)
        clone._closes = (boolean[]) ArraysX.clone(_closes);
    return clone;
}

Output:
     if (_nativedata != null)
-        clone._nativedata = ArraysX.clone(_nativedata);
+        clone._nativedata = ArraysX.duplicate(_nativedata);
     if (_data != null)


Input:
public void setSaveDirectory(File saveDir) throws IOException {
    if (saveDir == null)
        throw new NullPointerException();
    String parentDir = saveDir.getParent();
    File incDir = new File(parentDir, "String_Node_Str");
    if (!saveDir.isDirectory()) {
        if (!saveDir.mkdirs())
            throw new IOException();
    }
    if (!incDir.isDirectory()) {
        if (!incDir.mkdirs())
            throw new IOException();
    }
    _saveDirectory = saveDir;
    _incompleteDirectory = incDir;
    _props.put(SAVE_DIRECTORY, saveDir);
}

Output:
     _incompleteDirectory = incDir;
-    _props.put(SAVE_DIRECTORY, saveDir);
+    _props.put(SAVE_DIRECTORY, saveDir.getAbsolutePath());
 }


Input:
public ISVNAuthenticationProvider createAuthenticationProvider() {
    return new SVNAuthenticationProviderImpl(remotableProvider);
}

Output:
 public ISVNAuthenticationProvider createAuthenticationProvider() {
-    return new SVNAuthenticationProviderImpl(remotableProvider);
+    return new SVNAuthenticationProviderImpl(remotableProvider.get());
 }


Input:
public static void main(String[] args) {
    final int WINDOW_WIDTH = 320;
    final int WINDOW_HEIGHT = 240;
    final String WINDOW_TITLE = "String_Node_Str";
    JFrame frame = new JFrame();
    final cubeTriangle joglMain = new cubeTriangle();
    frame.setContentPane(joglMain);
    frame.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
            new Thread() {
                public void run() {
                    joglMain.animator.stop();
                    System.exit(0);
                }
            }.start();
        }
    });
    frame.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    frame.setTitle(WINDOW_TITLE);
    frame.setVisible(true);
    joglMain.animator.start();
}

Output:
                 }
-            }.start();
-        }
-    });
-    frame.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
-    frame.setTitle(WINDOW_TITLE);
-    frame.setVisible(true);
-    joglMain.animator.start();
+            }
+        };
+        SwingUtilities.invokeAndWait(doActions);
+    } catch (Exception ex) {
+        System.err.println(ex.toString());
+        ex.printStackTrace();
+    }
 }


Input:
private static int vn(byte[] x, final int xoff, final int xlen, byte[] y, final int yoff, final int ylen, int n) {
    int i, d = 0;
    for (i = 0; i < n; i++) d |= x[i + xoff] ^ y[i + yoff];
    return (1 & ((d - 1) >>> 8)) - 1;
}

Output:
     int i, d = 0;
-    for (i = 0; i < n; i++) d |= x[i + xoff] ^ y[i + yoff];
+    for (i = 0; i < n; i++) d |= (x[i + xoff] ^ y[i + yoff]) & 0xff;
     return (1 & ((d - 1) >>> 8)) - 1;


Input:
protected void createFormContent(IManagedForm managedForm) {
    this.form = managedForm.getForm();
    Composite body = form.getBody();
    body.setLayout(new GridLayout());
    SashForm sForm = new SashForm(body, SWT.NULL);
    sForm.setLayoutData(new GridData(GridData.FILL_BOTH));
    topComp = toolkit.createComposite(sForm);
    topComp.setLayoutData(new GridData(GridData.FILL_BOTH));
    topComp.setLayout(new GridLayout());
    metadataSection = creatMetadataSection(form, topComp);
    form.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    metadataSection.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    metadataSection.setDescription(DefaultMessagesImpl.getString("String_Node_Str"));
    createAnalysisColumnsSection(form, topComp);
    createDataFilterSection(form, topComp);
    Composite previewComp = toolkit.createComposite(sForm);
    previewComp.setLayoutData(new GridData(GridData.FILL_BOTH));
    previewComp.setLayout(new GridLayout());
    createPreviewSection(form, previewComp);
    GridData gdBtn = new GridData();
    gdBtn.horizontalAlignment = SWT.CENTER;
    gdBtn.horizontalSpan = 2;
    gdBtn.widthHint = 120;
    runBtn = toolkit.createButton(form.getBody(), DefaultMessagesImpl.getString("String_Node_Str"), SWT.NONE);
    runBtn.setLayoutData(gdBtn);
    runBtn.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            new RunAnalysisAction(ColumnMasterDetailsPage.this).run();
        }
    });
}

Output:
     createPreviewSection(form, previewComp);
-    GridData gdBtn = new GridData();
-    gdBtn.horizontalAlignment = SWT.CENTER;
-    gdBtn.horizontalSpan = 2;
-    gdBtn.widthHint = 120;
-    runBtn = toolkit.createButton(form.getBody(), DefaultMessagesImpl.getString("String_Node_Str"), SWT.NONE);
-    runBtn.setLayoutData(gdBtn);
-    runBtn.addSelectionListener(new SelectionAdapter() {
-        public void widgetSelected(SelectionEvent e) {
-            new RunAnalysisAction(ColumnMasterDetailsPage.this).run();
-        }
-    });
+    runButton = createRunButton(form);
 }


Input:
public void update2ndStep() {
    super.update2ndStep();
    synchronized (context.get(Context.KEY_TAB_LIST)) {
        if (activeComponent == -1) {
            activeComponent = 0;
            Component.Instance component = frames.get(0);
            component.activate();
            component.update1stStep();
            component.setPosition(row, column, size);
            component.update2ndStep();
        } else {
            Component.Instance component = frames.get(activeComponent);
            component.update1stStep();
            component.setPosition(row, column, size);
            component.update2ndStep();
        }
    }
}

Output:
             component.update1stStep();
-            component.setPosition(row, column, size);
+            component.setPosition(leftMostColumn, row, column, size);
             component.update2ndStep();


Input:
public void run() throws Exception {
    final ICacheService service = getService();
    final CacheConfig cacheConfig = service.getCacheConfig(name);
    if (cacheConfig == null) {
        CacheSimpleConfig simpleConfig = service.findCacheConfig(simpleName);
        if (simpleConfig != null) {
            try {
                CacheConfig cacheConfigFromSimpleConfig = new CacheConfig(simpleConfig);
                cacheConfigFromSimpleConfig.setName(simpleName);
                cacheConfigFromSimpleConfig.setManagerPrefix(name.substring(0, name.lastIndexOf(simpleName)));
                if (service.putCacheConfigIfAbsent(cacheConfigFromSimpleConfig) == null) {
                    response = cacheConfigFromSimpleConfig;
                    return;
                }
            } catch (Exception e) {
                throw new CacheException(e);
            }
        }
    }
    response = cacheConfig;
}

Output:
     final ICacheService service = getService();
-    final CacheConfig cacheConfig = service.getCacheConfig(name);
+    CacheConfig cacheConfig = service.getCacheConfig(name);
     if (cacheConfig == null) {


Input:
public void encodeEnd(FacesContext context, UIComponent component) throws IOException {
    if (!component.isRendered()) {
        return;
    }
    ScrollSpy scrollSpy = (ScrollSpy) component;
    ResponseWriter rw = context.getResponseWriter();
    String clientId = scrollSpy.getClientId();
    String container = scrollSpy.getContainer();
    if (!BsfUtils.StringIsValued(container)) {
        container = "String_Node_Str";
    } else
        container = "String_Node_Str" + BsfUtils.EscapeJQuerySpecialCharsInSelector(container);
    String target = scrollSpy.getTarget();
    if (!BsfUtils.StringIsValued(target)) {
        target = "String_Node_Str";
    } else
        target = "String_Node_Str" + BsfUtils.EscapeJQuerySpecialCharsInSelector(target);
    int offset = scrollSpy.getOffset();
    if (!BsfUtils.StringIsValued(target)) {
        offset = 20;
    }
    boolean smooth = scrollSpy.isSmooth();
    boolean hasListeners = (scrollSpy.getSelectionListener() != null);
    String updateItems = BsfUtils.GetOrDefault("String_Node_Str" + scrollSpy.getUpdate() + "String_Node_Str", "String_Node_Str");
    if (hasListeners) {
        final UIForm form = BsfUtils.getClosestForm(scrollSpy);
        if (form == null) {
            throw new FacesException("String_Node_Str", null);
        }
    }
    rw.startElement("String_Node_Str", component);
    rw.writeText("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + container + "String_Node_Str" + target + "String_Node_Str" + offset + "String_Node_Str", null);
    if (smooth) {
        rw.writeText("String_Node_Str" + "String_Node_Str" + target + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", null);
    }
    if (hasListeners) {
        rw.writeText("String_Node_Str" + "String_Node_Str" + target + "String_Node_Str" + "String_Node_Str" + target + "String_Node_Str" + "String_Node_Str" + updateItems + "String_Node_Str" + clientId + "String_Node_Str" + "String_Node_Str", null);
    }
    rw.writeText("String_Node_Str", null);
    rw.endElement("String_Node_Str");
}

Output:
     } else
-        container = "String_Node_Str" + BsfUtils.EscapeJQuerySpecialCharsInSelector(container);
+        container = "String_Node_Str" + decodeAndEscapeSelectors(context, component, container);
     String target = scrollSpy.getTarget();


Input:
public String getBootArgs() {
    String eth2Ip = router.getPublicIpAddress() == null ? "String_Node_Str" : router.getPublicIpAddress();
    String basic = "String_Node_Str" + router.getGuestIpAddress() + "String_Node_Str" + router.getGuestNetmask() + "String_Node_Str" + router.getPrivateIpAddress() + "String_Node_Str" + router.getPrivateNetmask() + "String_Node_Str" + router.getGateway() + "String_Node_Str" + router.getDns1() + "String_Node_Str" + router.getHostName() + "String_Node_Str" + mgmt_host;
    if (!router.getPublicMacAddress().equalsIgnoreCase("String_Node_Str")) {
        basic = basic + "String_Node_Str" + eth2Ip + "String_Node_Str" + router.getPublicNetmask();
    }
    if (router.getDns2() != null) {
        basic = basic + "String_Node_Str" + router.getDns2();
    }
    if (getDhcpRange() != null) {
        basic = basic + "String_Node_Str" + getDhcpRange();
    }
    if (router.getRole() == Role.DHCP_FIREWALL_LB_PASSWD_USERDATA) {
        basic = basic + "String_Node_Str";
    } else if (router.getRole() == Role.DHCP_USERDATA) {
        basic = basic + "String_Node_Str";
    }
    if (router.getDomain() != null) {
        basic += "String_Node_Str" + router.getDomain();
    }
    return basic;
}

Output:
     String eth2Ip = router.getPublicIpAddress() == null ? "String_Node_Str" : router.getPublicIpAddress();
-    String basic = "String_Node_Str" + router.getGuestIpAddress() + "String_Node_Str" + router.getGuestNetmask() + "String_Node_Str" + router.getPrivateIpAddress() + "String_Node_Str" + router.getPrivateNetmask() + "String_Node_Str" + router.getGateway() + "String_Node_Str" + router.getDns1() + "String_Node_Str" + router.getHostName() + "String_Node_Str" + mgmt_host;
+    String basic = "String_Node_Str" + router.getGuestIpAddress() + "String_Node_Str" + router.getGuestNetmask() + "String_Node_Str" + router.getPrivateIpAddress() + "String_Node_Str" + router.getPrivateNetmask() + "String_Node_Str" + router.getGateway() + "String_Node_Str" + router.getDns1() + "String_Node_Str" + router.getName() + "String_Node_Str" + mgmt_host;
     if (!router.getPublicMacAddress().equalsIgnoreCase("String_Node_Str")) {


Input:
public List<TableName> getTableNames() {
    return new ArrayList<TableName>(backupTableInfoMap.keySet());
}

Output:
 public List<TableName> getTableNames() {
-    return new ArrayList<TableName>(backupTableInfoMap.keySet());
+    return new ArrayList<>(backupTableInfoMap.keySet());
 }


Input:
private void markAsDeleted(String path, Commit commit, boolean subTreeAlso) {
    Revision rev = commit.getRevision();
    commit.removeNode(path);
    if (subTreeAlso) {
        Node n = getNode(path, rev);
        nodeCache.remove(path + "String_Node_Str" + rev);
        Node.Children c = readChildren(path, n.getId(), rev, Integer.MAX_VALUE);
        for (String childPath : c.children) {
            markAsDeleted(childPath, commit, true);
        }
    }
    nodeCache.remove(path + "String_Node_Str" + rev);
}

Output:
         nodeCache.remove(path + "String_Node_Str" + rev);
-        Node.Children c = readChildren(path, n.getId(), rev, Integer.MAX_VALUE);
-        for (String childPath : c.children) {
-            markAsDeleted(childPath, commit, true);
+        if (n != null) {
+            Node.Children c = readChildren(path, n.getId(), rev, Integer.MAX_VALUE);
+            for (String childPath : c.children) {
+                markAsDeleted(childPath, commit, true);
+            }
         }


Input:
public boolean sellTransaction(Player pSelling, double price) {
    return transaction(pSelling.getName(), owner, price);
}

Output:
 public boolean sellTransaction(Player pSelling, double price) {
-    return transaction(pSelling.getName(), owner, price);
+    return transaction(pSelling.getName(), owner, true, price);
 }


Input:
public void testTopoSortWithInputs2() {
    List<String> valid = Arrays.asList(new String[] { "String_Node_Str" });
    Deps<String> deps = new DiamondGraph();
    List<String> sort = Toposort.toposort(QLists.getList("String_Node_Str"), "String_Node_Str", deps);
    System.out.println(sort);
    assertTrue(valid.contains(sort.toString()));
}

Output:
     Deps<String> deps = new DiamondGraph();
-    List<String> sort = Toposort.toposort(QLists.getList("String_Node_Str"), "String_Node_Str", deps);
+    List<String> sort = Toposort.toposort(QLists.getList("String_Node_Str"), "String_Node_Str", deps, true);
     System.out.println(sort);


Input:
protected String getArtifactUrl(Artifact artifact) throws ArchivaRestServiceException {
    try {
        if (httpServletRequest == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder(getBaseUrl());
        sb.append("String_Node_Str");
        sb.append('/').append(artifact.getContext());
        sb.append('/').append(StringUtils.replaceChars(artifact.getGroupId(), '.', '/'));
        sb.append('/').append(artifact.getArtifactId());
        if (VersionUtil.isSnapshot(artifact.getVersion())) {
            sb.append('/').append(VersionUtil.getBaseVersion(artifact.getVersion()));
        } else {
            sb.append('/').append(artifact.getVersion());
        }
        sb.append('/').append(artifact.getArtifactId());
        sb.append('-').append(artifact.getVersion());
        if (StringUtils.isNotBlank(artifact.getClassifier())) {
            sb.append('-').append(artifact.getClassifier());
        }
        if (StringUtils.equals("String_Node_Str", artifact.getPackaging())) {
            sb.append("String_Node_Str");
        } else {
            sb.append('.').append(artifact.getPackaging());
        }
        return sb.toString();
    } catch (RepositoryAdminException e) {
        throw new ArchivaRestServiceException(e.getMessage(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e);
    }
}

Output:
         } else {
-            sb.append('.').append(artifact.getPackaging());
+            sb.append('.').append(artifact.getFileExtension());
         }


Input:
public StreamConfig create(final StreamId streamId, final Properties props) throws Exception {
    NamespaceId streamNamespace = streamId.getParent();
    ensureAccess(streamNamespace, Action.WRITE);
    privilegesManager.revoke(streamId);
    final Properties properties = (props == null) ? new Properties() : props;
    try {
        privilegesManager.grant(streamId, authenticationContext.getPrincipal(), EnumSet.allOf(Action.class));
        String ownerPrincipal = properties.containsKey(Constants.Security.PRINCIPAL) ? properties.getProperty(Constants.Security.PRINCIPAL) : null;
        if (exists(streamId)) {
            verifyOwner(streamId, ownerPrincipal);
        } else {
            if (ownerPrincipal != null) {
                ownerAdmin.add(streamId, new KerberosPrincipalId(ownerPrincipal));
            }
        }
        final Location streamLocation = impersonator.doAs(streamId, new Callable<Location>() {
            public Location call() throws Exception {
                assertNamespaceHomeExists(streamId.getParent());
                Location streamLocation = getStreamLocation(streamId);
                Locations.mkdirsIfNotExists(streamLocation);
                return streamLocation;
            }
        });
        return streamCoordinatorClient.createStream(streamId, new Callable<StreamConfig>() {

            public StreamConfig call() throws Exception {
                if (exists(streamId)) {
                    return null;
                }
                long createTime = System.currentTimeMillis();
                long partitionDuration = Long.parseLong(properties.getProperty(Constants.Stream.PARTITION_DURATION, cConf.get(Constants.Stream.PARTITION_DURATION)));
                long indexInterval = Long.parseLong(properties.getProperty(Constants.Stream.INDEX_INTERVAL, cConf.get(Constants.Stream.INDEX_INTERVAL)));
                long ttl = Long.parseLong(properties.getProperty(Constants.Stream.TTL, cConf.get(Constants.Stream.TTL)));
                int threshold = Integer.parseInt(properties.getProperty(Constants.Stream.NOTIFICATION_THRESHOLD, cConf.get(Constants.Stream.NOTIFICATION_THRESHOLD)));
                String description = properties.getProperty(Constants.Stream.DESCRIPTION);
                FormatSpecification formatSpec = null;
                if (properties.containsKey(Constants.Stream.FORMAT_SPECIFICATION)) {
                    formatSpec = GSON.fromJson(properties.getProperty(Constants.Stream.FORMAT_SPECIFICATION), FormatSpecification.class);
                }
                final StreamConfig config = new StreamConfig(streamId, partitionDuration, indexInterval, ttl, streamLocation, formatSpec, threshold);
                impersonator.doAs(streamId, new Callable<Void>() {
                    public Void call() throws Exception {
                        writeConfig(config);
                        return null;
                    }
                });
                createStreamFeeds(config);
                alterExploreStream(streamId, true, config.getFormat());
                streamMetaStore.addStream(streamId, description);
                publishAudit(streamId, AuditType.CREATE);
                SystemMetadataWriter systemMetadataWriter = new StreamSystemMetadataWriter(metadataStore, streamId, config, createTime, description);
                systemMetadataWriter.write();
                return config;
            }
        });
    } catch (Exception e) {
        privilegesManager.revoke(streamId);
        ownerAdmin.delete(streamId);
        throw e;
    }
}

Output:
         privilegesManager.grant(streamId, authenticationContext.getPrincipal(), EnumSet.allOf(Action.class));
-        String ownerPrincipal = properties.containsKey(Constants.Security.PRINCIPAL) ? properties.getProperty(Constants.Security.PRINCIPAL) : null;
-        if (exists(streamId)) {
-            verifyOwner(streamId, ownerPrincipal);
-        } else {
-            if (ownerPrincipal != null) {
-                ownerAdmin.add(streamId, new KerberosPrincipalId(ownerPrincipal));
-            }
-        }
-        final Location streamLocation = impersonator.doAs(streamId, new Callable<Location>() {
-            public Location call() throws Exception {
-                assertNamespaceHomeExists(streamId.getParent());
-                Location streamLocation = getStreamLocation(streamId);
-                Locations.mkdirsIfNotExists(streamLocation);
-                return streamLocation;
-            }
-        });
-        return streamCoordinatorClient.createStream(streamId, new Callable<StreamConfig>() {
+        try {
+            final Location streamLocation = impersonator.doAs(streamId, new Callable<Location>() {


Input:
public void onNodeDragStart(NodeDragStartEvent event) {
    m_shapeStartLocations = new NFastDoubleArray();
    Map<String, WiresConnector> connectors = new HashMap<String, WiresConnector>();
    for (WiresShape shape : m_selectionManager.m_selected.m_shapes) {
        WiresShapeControlImpl.collectionSpecialConnectors(shape, connectors);
        shape.getMagnets().onNodeDragStart(event);
        m_shapeStartLocations.push(shape.getX(), shape.getY());
        ((WiresShapeControlImpl) shape.getHandler().getControl()).dragStart(event.getDragContext());
    }
    m_connectorsWithSpecialConnections = connectors.values().toArray(new WiresConnector[connectors.size()]);
    for (WiresConnector connector : m_selectionManager.m_selected.m_connectors) {
        WiresConnector.WiresConnectorHandler handler = connector.getWiresConnectorHandler();
        handler.onNodeDragStart(event);
    }
}

Output:
     for (WiresShape shape : m_selectionManager.m_selected.m_shapes) {
-        WiresShapeControlImpl.collectionSpecialConnectors(shape, connectors);
-        shape.getMagnets().onNodeDragStart(event);
+        if (shape.getMagnets() != null) {
+            WiresShapeControlImpl.collectionSpecialConnectors(shape, connectors);
+            shape.getMagnets().onNodeDragStart(event);
+        }
         m_shapeStartLocations.push(shape.getX(), shape.getY());


Input:
public Entity createEntity(Entity root, CompositeItemVO vo) {
    Entity entity = new Entity();
    addCommonComponents(entity, vo);
    addParentComponent(entity, root);
    addPhysicsComponents(entity, vo);
    entity.flags = COMPOSITE_TYPE;
    return entity;
}

Output:
     Entity entity = new Entity();
-    addCommonComponents(entity, vo);
+    entity.flags = COMPOSITE_TYPE;
+    addCommonComponents(entity, vo, vo.composite);
     addParentComponent(entity, root);


Input:
public Message sendMessage(Message message) {
    try {
        if (message.getMediaTypeSelect() == MEDIA_TYPE_MAIL) {
            return sendByMail(message);
        } else if (message.getMediaTypeSelect() == MEDIA_TYPE_EMAIL) {
            return sendByEmail(message);
        } else if (message.getMediaTypeSelect() == MEDIA_TYPE_CHAT) {
            return sendToUser(message);
        }
    } catch (MessagingException | IOException e) {
        LOG.error(e.getMessage());
    }
    return message;
}

Output:
     } catch (MessagingException | IOException e) {
-        LOG.error(e.getMessage());
+        TraceBackService.trace(e);
     }


Input:
protected boolean cacheInBackground() {
    try {
        List<Picture> results;
        if (SearchActivity.pictures.isEmpty()) {
            results = PictureFactory.search(SearchActivity.query);
        } else {
            results = PictureFactory.search(SearchActivity.query, page);
        }
        page++;
        if (results.isEmpty()) {
            Log.d("String_Node_Str", "String_Node_Str");
            return false;
        }
        SearchActivity.pictures.addAll(results);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

Output:
         if (results.isEmpty()) {
-            Log.d("String_Node_Str", "String_Node_Str");
+            activity.findViewById(R.id.no_results).setVisibility(View.VISIBLE);
+            activity.findViewById(R.id.list_progress).setVisibility(View.GONE);
             return false;


Input:
public void testGridInstance() throws ScriptException {
    TableContent content = (TableContent) reportContent.createTableContent();
    new GridInstance(content, null);
}

Output:
     TableContent content = (TableContent) reportContent.createTableContent();
-    new GridInstance(content, null);
+    new GridInstance(content, null, null);
 }


Input:
public Desktop getDesktopIfAny(String desktopId) {
    synchronized (_desktops) {
        return (Desktop) _desktops.get(desktopId);
    }
}

Output:
     synchronized (_desktops) {
-        return (Desktop) _desktops.get(desktopId);
+        final boolean old = _desktops.disableExpunge(true);
+        try {
+            return (Desktop) _desktops.get(desktopId);
+        } finally {
+            _desktops.disableExpunge(old);
+        }
     }


Input:
void readArrayMapSafelyInternal(ArrayMap outVal, int N, ClassLoader loader) {
    if (DEBUG_ARRAY_MAP) {
        RuntimeException here = new RuntimeException("String_Node_Str");
        here.fillInStackTrace();
        Log.d(TAG, "String_Node_Str" + N + "String_Node_Str", here);
    }
    while (N > 0) {
        Object key = readValue(loader);
        if (DEBUG_ARRAY_MAP)
            Log.d(TAG, "String_Node_Str" + (N - 1) + "String_Node_Str" + (key != null ? key.hashCode() : 0) + "String_Node_Str" + key);
        Object value = readValue(loader);
        outVal.put(key, value);
        N--;
    }
}

Output:
     while (N > 0) {
-        Object key = readValue(loader);
+        String key = readString();
         if (DEBUG_ARRAY_MAP)


Input:
public List<ItemStack> getDrops(IBlockAccess blockAccess, BlockPos pos, IBlockState state, int fortune) {
    World world = (World) blockAccess;
    List<ItemStack> drops = super.getDrops(world, pos, state, fortune);
    if (!world.isRemote) {
        TileEntity te = world.getTileEntity(pos);
        if (te instanceof PowerCellTileEntity) {
            PowerCellNetwork.Network network = ((PowerCellTileEntity) te).getNetwork();
            if (network != null) {
                int energy = network.getEnergySingleBlock();
                if (!drops.isEmpty()) {
                    NBTTagCompound tagCompound = drops.get(0).getTagCompound();
                    if (tagCompound == null) {
                        tagCompound = new NBTTagCompound();
                        drops.get(0).setTagCompound(tagCompound);
                    }
                    tagCompound.setInteger("String_Node_Str", energy);
                }
            }
        }
    }
    return drops;
}

Output:
             if (network != null) {
-                int energy = network.getEnergySingleBlock();
+                int energy = network.getEnergySingleBlock(isAdvanced());
                 if (!drops.isEmpty()) {


Input:
private boolean mayAddPropToType(Node getProp, RawNominalType rawType) {
    if (!rawType.isStruct()) {
        return true;
    }
    Node parent = getProp.getParent();
    return parent.isAssign() && getProp == parent.getFirstChild() && currentScope.isConstructor();
}

Output:
     Node parent = getProp.getParent();
-    return parent.isAssign() && getProp == parent.getFirstChild() && currentScope.isConstructor();
+    return (parent.isAssign() && getProp == parent.getFirstChild() || parent.isExprResult()) && currentScope.isConstructor();
 }


Input:
public String[] getDocumentIDs() {
    return documentIDs;
}

Output:
 public String[] getDocumentIDs() {
-    return documentIDs;
+    return documentIDs != null ? Arrays.asList(documentIDs).toArray(new String[documentIDs.length]) : null;
 }


Input:
public RawPacket transform(RawPacket pkt) {
    long ssrc = PacketManipulator.GetRTPSSRC(pkt);
    SRTPCryptoContext context = (SRTPCryptoContext) this.contexts.get(ssrc);
    if (context == null) {
        context = this.engine.getDefaultContext().deriveContext(ssrc, 0, 0);
        if (context != null) {
            context.deriveSrtpKeys(0);
            this.contexts.put(ssrc, context);
        }
    }
    if (context != null) {
        context.transformPacket(pkt);
    }
    return pkt;
}

Output:
     long ssrc = PacketManipulator.GetRTPSSRC(pkt);
-    SRTPCryptoContext context = (SRTPCryptoContext) this.contexts.get(ssrc);
+    SRTPCryptoContext context = this.contexts.get(ssrc);
     if (context == null) {


Input:
public void onCreate() {
    viewerBinding = DataBindingUtil.inflate(LayoutInflater.from(getBaseContext()), R.layout.view_viewer, null, false);
    toggleBinding = DataBindingUtil.inflate(LayoutInflater.from(getBaseContext()), R.layout.view_toggle, null, false);
    mParams = new WindowManager.LayoutParams(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT, Build.VERSION.SDK_INT < Build.VERSION_CODES.O ? WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY : WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN, PixelFormat.TRANSLUCENT);
    mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
    mWindowManager.addView(viewerBinding.getRoot(), mParams);
    mWindowManager.addView(toggleBinding.getRoot(), new WindowManager.LayoutParams(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.WRAP_CONTENT, Build.VERSION.SDK_INT < Build.VERSION_CODES.O ? WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY : WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN, PixelFormat.TRANSLUCENT));
    super.onCreate();
}

Output:
     toggleBinding = DataBindingUtil.inflate(LayoutInflater.from(getBaseContext()), R.layout.view_toggle, null, false);
-    mParams = new WindowManager.LayoutParams(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT, Build.VERSION.SDK_INT < Build.VERSION_CODES.O ? WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY : WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN, PixelFormat.TRANSLUCENT);
+    mParams = new WindowManager.LayoutParams(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT, Build.VERSION.SDK_INT < Build.VERSION_CODES.O ? WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY : WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE, PixelFormat.TRANSLUCENT);
     mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);


Input:
private void addClickSelectionMechanism() {
    for (final GNode node : model.getNodes()) {
        final GNodeSkin nodeSkin = skinLookup.lookupNode(node);
        final Region nodeRegion = nodeSkin.getRoot();
        final EventHandler<MouseEvent> oldNodePressedHandler = nodePressedHandlers.get(node);
        final EventHandler<MouseEvent> oldNodeReleasedHandler = nodeReleasedHandlers.get(node);
        if (oldNodePressedHandler != null) {
            nodeRegion.removeEventHandler(MouseEvent.MOUSE_PRESSED, oldNodePressedHandler);
        }
        if (oldNodeReleasedHandler != null) {
            nodeRegion.removeEventHandler(MouseEvent.MOUSE_RELEASED, oldNodeReleasedHandler);
        }
        final EventHandler<MouseEvent> newNodePressedHandler = event -> handleNodePressed(event, node);
        final EventHandler<MouseEvent> newNodeReleasedHandler = event -> handleNodeReleased(event, node);
        nodeRegion.addEventHandler(MouseEvent.MOUSE_PRESSED, newNodePressedHandler);
        nodeRegion.addEventHandler(MouseEvent.MOUSE_RELEASED, newNodeReleasedHandler);
        nodePressedHandlers.put(node, newNodePressedHandler);
        nodeReleasedHandlers.put(node, newNodeReleasedHandler);
        for (final GConnector connector : node.getConnectors()) {
            final Node connectorRoot = skinLookup.lookupConnector(connector).getRoot();
            final EventHandler<MouseEvent> oldConnectorPressedHandler = connectorPressedHandlers.get(connector);
            if (oldConnectorPressedHandler != null) {
                connectorRoot.removeEventHandler(MouseEvent.MOUSE_PRESSED, oldConnectorPressedHandler);
            }
            final EventHandler<MouseEvent> newConnectorPressedHandler = event -> handleConnectorPressed(event);
            connectorRoot.addEventHandler(MouseEvent.MOUSE_PRESSED, newConnectorPressedHandler);
            connectorPressedHandlers.put(connector, newConnectorPressedHandler);
        }
    }
    for (final GConnection connection : model.getConnections()) {
        for (final GJoint joint : connection.getJoints()) {
            final GJointSkin jointSkin = skinLookup.lookupJoint(joint);
            final Region jointRegion = jointSkin.getRoot();
            final EventHandler<MouseEvent> oldJointPressedHandler = nodePressedHandlers.get(joint);
            final EventHandler<MouseEvent> oldJointReleasedHandler = nodeReleasedHandlers.get(joint);
            if (oldJointPressedHandler != null) {
                jointRegion.removeEventHandler(MouseEvent.MOUSE_PRESSED, oldJointPressedHandler);
            }
            if (oldJointReleasedHandler != null) {
                jointRegion.removeEventHandler(MouseEvent.MOUSE_RELEASED, oldJointReleasedHandler);
            }
            final EventHandler<MouseEvent> newJointPressedHandler = event -> handleJointPressed(event, joint);
            final EventHandler<MouseEvent> newJointReleasedHandler = event -> handleJointReleased(event, joint);
            jointRegion.addEventHandler(MouseEvent.MOUSE_PRESSED, newJointPressedHandler);
            jointRegion.addEventHandler(MouseEvent.MOUSE_RELEASED, newJointReleasedHandler);
            jointPressedHandlers.put(joint, newJointPressedHandler);
            jointReleasedHandlers.put(joint, newJointReleasedHandler);
        }
    }
}

Output:
     for (final GNode node : model.getNodes()) {
-        final GNodeSkin nodeSkin = skinLookup.lookupNode(node);
-        final Region nodeRegion = nodeSkin.getRoot();
+        final Region nodeRegion = skinLookup.lookupNode(node).getRoot();
         final EventHandler<MouseEvent> oldNodePressedHandler = nodePressedHandlers.get(node);


Input:
protected String createLaunchStr(IPath valgrindPath) throws CoreException {
    String projectName = configUtils.getProjectName();
    IProject project = ConfigUtils.getProject(projectName);
    URI projectURI = project.getLocationURI();
    String Location = projectURI.getScheme() + "String_Node_Str" + projectURI.getHost();
    return config.getName() + "String_Node_Str" + valgrindPath.toString() + "String_Node_Str" + getPlugin().getToolName(toolID) + "String_Node_Str" + Location + "String_Node_Str";
}

Output:
     URI projectURI = project.getLocationURI();
-    String Location = projectURI.getScheme() + "String_Node_Str" + projectURI.getHost();
-    return config.getName() + "String_Node_Str" + valgrindPath.toString() + "String_Node_Str" + getPlugin().getToolName(toolID) + "String_Node_Str" + Location + "String_Node_Str";
+    String host = projectURI.getHost();
+    if (host == null) {
+        host = projectURI.getAuthority();
+    }
+    String location;
+    if (host == null) {
+        location = "String_Node_Str";
+    } else {
+        location = projectURI.getScheme() + "String_Node_Str" + host;
+    }
+    return config.getName() + "String_Node_Str" + valgrindPath.toString() + "String_Node_Str" + getPlugin().getToolName(toolID) + "String_Node_Str" + location + "String_Node_Str";
 }


Input:
protected void startUp() throws Exception {
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    for (Map.Entry<OperationalExtensionId, OperationalStats> entry : operationalStatsLoader.getAll().entrySet()) {
        ObjectName objectName = getObjectName(entry.getValue());
        if (objectName == null) {
            LOG.warn("String_Node_Str", OperationalStats.class.getName());
            continue;
        }
        LOG.debug("String_Node_Str", entry.getValue(), entry.getKey());
        mbs.registerMBean(entry.getValue(), objectName);
    }
    LOG.info("String_Node_Str");
}

Output:
     for (Map.Entry<OperationalExtensionId, OperationalStats> entry : operationalStatsLoader.getAll().entrySet()) {
-        ObjectName objectName = getObjectName(entry.getValue());
+        OperationalStats operationalStats = entry.getValue();
+        ObjectName objectName = getObjectName(operationalStats);
         if (objectName == null) {


Input:
private void actionRowSelected(RowSelectionEvent arg0) {
    this.selectedColumn = null;
    this.selectedRow = null;
    int row = arg0.getRowPositionRanges().iterator().next().start;
    if (row >= 0) {
        this.selectedRow = row;
        fireSelectionEvent();
    }
}

Output:
     int row = arg0.getRowPositionRanges().iterator().next().start;
-    if (row >= 0) {
+    if (row >= 0 && row < dataProviderBody.getRowCount()) {
         this.selectedRow = row;