Input:
private boolean flagCondition(CorrelationStruct struct) {
    double ratio = struct.numSamplesA / (double) struct.numSamplesB;
    return struct.coefficientValue > 0.0 && struct.coefficientValue < this.alpha && struct.numSamplesA > minSamples && struct.numSamplesB > minSamples && ratio > 1.0 - ratioRange && ratio < 1.0 + ratioRange;
}

Output:
     double ratio = struct.numSamplesA / (double) struct.numSamplesB;
-    return struct.coefficientValue > 0.0 && struct.coefficientValue < this.alpha && struct.numSamplesA > minSamples && struct.numSamplesB > minSamples && ratio > 1.0 - ratioRange && ratio < 1.0 + ratioRange;
+    return struct.coefficientPValue > 0.0 && struct.coefficientPValue < this.alpha && struct.numSamplesA > minSamples && struct.numSamplesB > minSamples && ratio > 1.0 - ratioRange && ratio < 1.0 + ratioRange;
 }


Input:
private void readObject(final java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
    final int count = in.readInt();
    adapterMap = new HashMap<ByteArrayId, DataAdapter<?>>();
    for (int i = 0; i < count; i++) {
        final ByteArrayId id = (ByteArrayId) in.readObject();
        final byte[] data = (byte[]) in.readObject();
        adapterMap.put(id, PersistenceUtils.fromBinary(data, DataAdapter.class));
    }
}

Output:
     final int count = in.readInt();
-    adapterMap = new HashMap<ByteArrayId, DataAdapter<?>>();
+    adapterMap = Collections.synchronizedMap(new HashMap<ByteArrayId, DataAdapter<?>>());
     for (int i = 0; i < count; i++) {


Input:
public static Cursor getAllFriends(Context context) {
    String sortOrder = UserTable.Cols.ID + "String_Node_Str" + UserTable.Cols.FULL_NAME + "String_Node_Str";
    ContentResolver resolver = context.getContentResolver();
    Cursor cursor = resolver.query(UserTable.USER_FRIEND_CONTENT_URI, null, USER_FRIEND_RELATION_KEY, null, sortOrder);
    return cursor;
}

Output:
     ContentResolver resolver = context.getContentResolver();
-    Cursor cursor = resolver.query(UserTable.USER_FRIEND_CONTENT_URI, null, USER_FRIEND_RELATION_KEY, null, sortOrder);
+    Cursor cursor = resolver.query(UserTable.USER_FRIEND_CONTENT_URI, null, USER_FRIEND_RELATION_KEY + "String_Node_Str" + condition, null, sortOrder);
     return cursor;


Input:
public void node(Node node, NamespaceResolver namespaceResolver) {
    if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
        Attr attr = (Attr) node;
        String resolverPfx = null;
        if (getNamespaceResolver() != null) {
            resolverPfx = getNamespaceResolver().resolveNamespaceURI(attr.getNamespaceURI());
        }
        if (resolverPfx != null) {
            attribute(attr.getNamespaceURI(), XMLConstants.EMPTY_STRING, resolverPfx + XMLConstants.COLON + attr.getLocalName(), attr.getNodeValue());
        } else {
            attribute(attr.getNamespaceURI(), XMLConstants.EMPTY_STRING, attr.getName(), attr.getNodeValue());
            if (attr.getNamespaceURI() != null) {
                attribute(XMLConstants.XMLNS_URL, XMLConstants.EMPTY_STRING, XMLConstants.XMLNS + XMLConstants.COLON + attr.getPrefix(), attr.getNamespaceURI());
                this.getNamespaceResolver().put(attr.getPrefix(), attr.getNamespaceURI());
            }
        }
    } else if (node.getNodeType() == Node.TEXT_NODE) {
        nonStringCharacters(node.getNodeValue());
    } else {
        try {
            JSONFormattedWriterRecordContentHandler wrcHandler = new JSONFormattedWriterRecordContentHandler();
            XMLFragmentReader xfragReader = new XMLFragmentReader(namespaceResolver);
            xfragReader.setContentHandler(wrcHandler);
            xfragReader.setProperty("String_Node_Str", wrcHandler);
            xfragReader.parse(node);
        } catch (SAXException sex) {
            throw XMLMarshalException.marshalException(sex);
        }
    }
}

Output:
     } else if (node.getNodeType() == Node.TEXT_NODE) {
-        nonStringCharacters(node.getNodeValue());
+        characters(node.getNodeValue(), false, false);
     } else {


Input:
public String create(final String streamName, final String query) {
    try {
        String queryId = stratioStreamingApi.addQuery(streamName, query);
        return "String_Node_Str".concat(streamName).concat("String_Node_Str".concat(queryId));
    } catch (StratioEngineStatusException | StratioAPISecurityException | StratioEngineOperationException e) {
        throw new StreamingShellException(e);
    }
}

Output:
     try {
-        String queryId = stratioStreamingApi.addQuery(streamName, query);
+        String queryId = ssaw.api().addQuery(streamName, query);
         return "String_Node_Str".concat(streamName).concat("String_Node_Str".concat(queryId));


Input:
public void init(FMLInitializationEvent event) {
    FMLInterModComms.sendMessage("String_Node_Str", "String_Node_Str", "String_Node_Str");
    ClientCommandHandler.instance.registerCommand(new CommandReload());
    ClientCommandHandler.instance.registerCommand(new CommandName());
}

Output:
 public void init(FMLInitializationEvent event) {
-    FMLInterModComms.sendMessage("String_Node_Str", "String_Node_Str", "String_Node_Str");
-    ClientCommandHandler.instance.registerCommand(new CommandReload());
-    ClientCommandHandler.instance.registerCommand(new CommandName());
+    proxy.init(event);
 }


Input:
public DataStreamsPipelineSpec generateSpec(DataStreamsConfig config) {
    long batchIntervalMillis;
    try {
        batchIntervalMillis = TimeParser.parseDuration(config.getBatchInterval());
    } catch (Exception e) {
        throw new IllegalArgumentException(String.format("String_Node_Str", config.getBatchInterval()));
    }
    DataStreamsPipelineSpec.Builder specBuilder = DataStreamsPipelineSpec.builder(batchIntervalMillis).setExtraJavaOpts(config.getExtraJavaOpts());
    configureStages(config, specBuilder);
    return specBuilder.build();
}

Output:
     }
-    DataStreamsPipelineSpec.Builder specBuilder = DataStreamsPipelineSpec.builder(batchIntervalMillis).setExtraJavaOpts(config.getExtraJavaOpts());
+    DataStreamsPipelineSpec.Builder specBuilder = DataStreamsPipelineSpec.builder(batchIntervalMillis).setExtraJavaOpts(config.getExtraJavaOpts()).setStopGracefully(config.getStopGracefully());
     configureStages(config, specBuilder);


Input:
static SetterData createFlushMode(FlushModeType flushMode) {
    SetterData data = new SetterData();
    data.type = SetterType.FLUSH_MODE;
    data.flushMode = flushMode;
    return data;
}

Output:
 static SetterData createFlushMode(FlushModeType flushMode) {
-    SetterData data = new SetterData();
-    data.type = SetterType.FLUSH_MODE;
+    SetterData data = new SetterData(SetterType.FLUSH_MODE);
     data.flushMode = flushMode;


Input:
private File verifyDir(String configKey, String defaultPath) {
    String dirStr = this.config.getString(configKey);
    File fileDir;
    if (StringUtils.isBlank(dirStr)) {
        dirStr = defaultPath;
        fileDir = new File(appHome(), dirStr);
    } else {
        dirStr = StringUtils.trim(dirStr);
        if (StringUtils.startsWith(dirStr, "String_Node_Str")) {
            fileDir = new File(dirStr);
        } else {
            fileDir = new File(appHome(), dirStr);
        }
    }
    if (!fileDir.exists()) {
        try {
            if (fileDir.mkdirs()) {
                logger.info("String_Node_Str" + configKey + "String_Node_Str" + fileDir.getAbsolutePath());
            } else {
                throw new RuntimeException("String_Node_Str" + fileDir.getAbsolutePath());
            }
        } catch (Exception e) {
            throw new RuntimeException("String_Node_Str" + fileDir.getAbsolutePath() + "String_Node_Str" + e);
        }
    } else if (!fileDir.isDirectory()) {
        throw new RuntimeException("String_Node_Str" + fileDir.getAbsolutePath());
    } else if (!fileDir.canRead()) {
        throw new RuntimeException("String_Node_Str" + fileDir.getAbsolutePath());
    } else {
        logger.info("String_Node_Str" + configKey + "String_Node_Str" + fileDir.getAbsolutePath());
    }
    this.config.setProperty(configKey, fileDir.getAbsolutePath());
    return fileDir;
}

Output:
         dirStr = StringUtils.trim(dirStr);
-        if (StringUtils.startsWith(dirStr, "String_Node_Str")) {
+        if (StringUtils.startsWith(dirStr, SLASH)) {
             fileDir = new File(dirStr);


Input:
NBTTagCompound writeFullUpdate(NBTTagCompound nbt) {
    nbt = writeUpdate(nbt);
    nbt.setInteger("String_Node_Str", maxBlood);
    return nbt;
}

Output:
 NBTTagCompound writeFullUpdate(NBTTagCompound nbt) {
-    nbt = writeUpdate(nbt);
+    writeUpdate(nbt);
     nbt.setInteger("String_Node_Str", maxBlood);


Input:
private DeploymentTopology generateDeploymentTopology(String id, ApplicationEnvironment environment, Topology topology, DeploymentTopology deploymentTopology) {
    deploymentTopology.setVersionId(environment.getCurrentVersionId());
    deploymentTopology.setEnvironmentId(environment.getId());
    deploymentTopology.setInitialTopologyId(topology.getId());
    deploymentTopology.setId(id);
    doUpdateDeploymentTopology(deploymentTopology, topology, environment);
    return deploymentTopology;
}

Output:
     deploymentTopology.setId(id);
-    doUpdateDeploymentTopology(deploymentTopology, topology, environment);
+    doUpdateDeploymentTopology(deploymentTopology, topology);
     return deploymentTopology;


Input:
public WiresConnector setTailMagnet(WiresMagnet tailMagnet) {
    if (null != tailMagnet) {
        m_tailConnection.setMagnet(tailMagnet);
    }
    return this;
}

Output:
 public WiresConnector setTailMagnet(WiresMagnet tailMagnet) {
-    if (null != tailMagnet) {
-        m_tailConnection.setMagnet(tailMagnet);
-    }
+    m_tailConnection.setMagnet(tailMagnet);
     return this;


Input:
public static void start(Context context, User friend) {
    Intent intent = new Intent(QBServiceConsts.REMOVE_FRIEND_ACTION, null, context, QBService.class);
    intent.putExtra(QBServiceConsts.EXTRA_FRIEND, friend);
    context.startService(intent);
}

Output:
     Intent intent = new Intent(QBServiceConsts.REMOVE_FRIEND_ACTION, null, context, QBService.class);
-    intent.putExtra(QBServiceConsts.EXTRA_FRIEND, friend);
+    intent.putExtra(QBServiceConsts.EXTRA_FRIEND_ID, friendId);
     context.startService(intent);


Input:
protected void createFormElements(Composite editArea) {
    GridDataFactory gdf = GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, false);
    Label label = new Label(editArea, SWT.NONE);
    label.setText(Messages.ColumnAccountFrom);
    ComboViewer comboFrom = new ComboViewer(editArea, SWT.READ_ONLY);
    comboFrom.setContentProvider(ArrayContentProvider.getInstance());
    comboFrom.setLabelProvider(new LabelProvider() {
        public String getText(Object element) {
            return ((Account) element).getName();
        }
    });
    comboFrom.setInput(getModel().getClient().getAccounts().toArray());
    gdf.applyTo(comboFrom.getControl());
    final IViewerObservableValue observableFrom = ViewersObservables.observeSingleSelection(comboFrom);
    label = new Label(editArea, SWT.NONE);
    label.setText(Messages.ColumnAccountTo);
    ComboViewer comboTo = new ComboViewer(editArea, SWT.READ_ONLY);
    comboTo.setContentProvider(ArrayContentProvider.getInstance());
    comboTo.setLabelProvider(new LabelProvider() {
        public String getText(Object element) {
            return ((Account) element).getName();
        }
    });
    comboTo.setInput(getModel().getClient().getAccounts().toArray());
    gdf.applyTo(comboTo.getControl());
    final IViewerObservableValue observableTo = ViewersObservables.observeSingleSelection(comboTo);
    bindings.bindMandatoryAmountInput(editArea, Messages.ColumnAmount, "String_Node_Str");
    bindings.bindDatePicker(editArea, Messages.ColumnDate, "String_Node_Str");
    DataBindingContext context = getBindingContext();
    MultiValidator validator = new MultiValidator() {
        protected IStatus validate() {
            Object from = observableFrom.getValue();
            Object to = observableTo.getValue();
            return from != null && to != null && from != to ? ValidationStatus.ok() : ValidationStatus.error(Messages.MsgAccountMustBeDifferent);
        }
    };
    context.addValidationStatusProvider(validator);
    context.bindValue(validator.observeValidatedValue(observableFrom), BeansObservables.observeValue(getModel(), "String_Node_Str"));
    context.bindValue(validator.observeValidatedValue(observableTo), BeansObservables.observeValue(getModel(), "String_Node_Str"));
}

Output:
     final IViewerObservableValue observableTo = ViewersObservables.observeSingleSelection(comboTo);
-    bindings.bindMandatoryAmountInput(editArea, Messages.ColumnAmount, "String_Node_Str");
-    bindings.bindDatePicker(editArea, Messages.ColumnDate, "String_Node_Str");
+    bindings().bindMandatoryAmountInput(editArea, Messages.ColumnAmount, "String_Node_Str");
+    bindings().bindDatePicker(editArea, Messages.ColumnDate, "String_Node_Str");
     DataBindingContext context = getBindingContext();


Input:
private void onSelectRecommendation(Recommendation recommendation) {
    getActivity().startActivity(RecommendedRouteActivity.getIntent(getActivity(), currentLocation, recommendation.getPoi()));
}

Output:
 private void onSelectRecommendation(Recommendation recommendation) {
-    getActivity().startActivity(RecommendedRouteActivity.getIntent(getActivity(), currentLocation, recommendation.getPoi()));
+    if (currentLocation != null) {
+        getActivity().startActivity(RecommendedRouteActivity.getIntent(getActivity(), currentLocation, recommendation.getPoi()));
+    }
 }


Input:
private void convertFormat(String inventory) {
    String inventory2 = inventory.replaceAll("String_Node_Str", "String_Node_Str");
    if (!(inventory.equals(inventory2))) {
        String[] parts = inventory2.split("String_Node_Str");
        if (parts.length > 2) {
            inventory2 = parts[0] + "String_Node_Str" + parts[1];
        }
        inventories.put(inventory2, inventories.get(inventory));
        debugger.debugEvent(MultiInvEvent.INVENTORY_ADDED, new String[] { inventory2 });
        inventories.remove(inventory);
        debugger.debugEvent(MultiInvEvent.INVENTORY_DELETE, new String[] { inventory });
        log.info("String_Node_Str" + pluginName + "String_Node_Str" + inventory + "String_Node_Str" + inventory2);
    }
    return;
}

Output:
     }
-    return;
+    return inventory2;
 }


Input:
protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
    if (node instanceof FieldQueryNode) {
        QueryConfigHandler config = getQueryConfigHandler();
        if (!((FieldQueryNode) node).getField().equals(config.get(AqpAdsabsQueryConfigHandler.ConfigurationKeys.UNFIELDED_SEARCH_FIELD))) {
            return node;
        }
        if (!config.has(AqpAdsabsQueryConfigHandler.ConfigurationKeys.FUNCTION_QUERY_BUILDER_CONFIG)) {
            throw new QueryNodeException(new MessageImpl("String_Node_Str", "String_Node_Str"));
        }
        String funcName = "String_Node_Str";
        String subQuery = ((FieldQueryNode) node).getTextAsString();
        if (node instanceof AqpNonAnalyzedQueryNode) {
            funcName = "String_Node_Str";
        } else {
            if (node instanceof QuotedFieldQueryNode) {
                subQuery = "String_Node_Str" + subQuery + "String_Node_Str";
            }
            if (node.getParent() instanceof SlopQueryNode) {
                subQuery = subQuery + "String_Node_Str" + ((SlopQueryNode) node.getParent()).getValue();
                if (node.getParent().getParent() instanceof BoostQueryNode) {
                    subQuery = subQuery + "String_Node_Str" + ((BoostQueryNode) node.getParent().getParent()).getValue();
                }
            } else if (node.getParent() instanceof BoostQueryNode) {
                subQuery = subQuery + "String_Node_Str" + ((BoostQueryNode) node.getParent()).getValue();
            }
        }
        node.setTag("String_Node_Str", subQuery);
        AqpFunctionQueryBuilder builder = config.get(AqpAdsabsQueryConfigHandler.ConfigurationKeys.FUNCTION_QUERY_BUILDER_CONFIG).getBuilder(funcName, (QueryNode) node, config);
        if (builder == null) {
            throw new QueryNodeException(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, "String_Node_Str" + funcName + "String_Node_Str"));
        }
        List<OriginalInput> fValues = new ArrayList<OriginalInput>();
        fValues.add(new OriginalInput(subQuery, -1, -1));
        return new AqpFunctionQueryNode(funcName, builder, fValues);
    }
    return node;
}

Output:
 protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
-    if (node instanceof FieldQueryNode) {
+    if (node instanceof FieldQueryNode && !(node instanceof AqpAdsabsRegexQueryNode)) {
         QueryConfigHandler config = getQueryConfigHandler();


Input:
private RestResult<T> getResultNow() {
    try {
        return get();
    } catch (InterruptedException e) {
        throw PodioException.fromThrowable(e);
    } catch (ExecutionException e) {
        if (e.getCause() instanceof PodioException) {
            throw (PodioException) e.getCause();
        } else {
            throw PodioException.fromThrowable(e);
        }
    }
}

Output:
     } catch (InterruptedException e) {
-        throw PodioException.fromThrowable(e);
+        return null;
     } catch (ExecutionException e) {


Input:
public boolean canWrite(Class<?> clazz, MediaType mediaType) {
    return true;
}

Output:
 public boolean canWrite(Class<?> clazz, MediaType mediaType) {
-    return true;
+    if (clazz == String.class) {
+        return true;
+    }
+    return false;
 }


Input:
public void activate() {
    CellEmitter.get(pos).start(Speck.factory(Speck.LIGHT), 0.2f, 3);
    Sample.INSTANCE.play(Assets.SND_TELEPORT);
    Char ch = Actor.findChar(pos);
    if (ch instanceof Hero) {
        ScrollOfTeleportation.teleportHero((Hero) ch);
    } else if (ch != null) {
        int count = 10;
        int pos;
        do {
            pos = Dungeon.level.randomRespawnCell();
            if (count-- <= 0) {
                break;
            }
        } while (pos == -1);
        if (pos == -1) {
            GLog.w(ScrollOfTeleportation.TXT_NO_TELEPORT);
        } else {
            ch.pos = pos;
            ch.sprite.place(ch.pos);
            ch.sprite.visible = Dungeon.visible[pos];
        }
    }
    Heap heap = Dungeon.level.heaps.get(pos);
    if (heap != null) {
        int cell = Dungeon.level.randomRespawnCell();
        Item item = heap.pickUp();
        if (cell != -1) {
            Dungeon.level.drop(item, cell);
        }
    }
}

Output:
         } while (pos == -1);
-        if (pos == -1) {
+        if (pos == -1 || Dungeon.bossLevel()) {
             GLog.w(ScrollOfTeleportation.TXT_NO_TELEPORT);


Input:
public void checkStateChanged(CheckStateChangedEvent e) {
    if (checkUpdating) {
        return;
    }
    try {
        checkUpdating = true;
        if (e.getChecked() && isSelectDependencies()) {
            ITernModule module = ((ITernModule) e.getElement());
            TernModuleMetadata metadata = module.getMetadata();
            if (metadata != null) {
                ITernModule dependencyModule = null;
                for (String moduleName : metadata.getDependencies()) {
                    dependencyModule = TernCorePlugin.getTernServerTypeManager().findTernModule(moduleName);
                    if (dependencyModule != null) {
                        if (!tableViewer.getChecked(dependencyModule)) {
                            tableViewer.setChecked(dependencyModule, true);
                        }
                    }
                }
            }
        }
    } finally {
        checkUpdating = false;
    }
}

Output:
                 for (String moduleName : metadata.getDependencies()) {
-                    dependencyModule = TernCorePlugin.getTernServerTypeManager().findTernModule(moduleName);
+                    dependencyModule = ternModules.get(moduleName);
                     if (dependencyModule != null) {


Input:
private void fillSubstituteAttributesFromOutputProperties(Topology topology, NodeType substituteNodeType) {
    Map<String, IValue> attributes = substituteNodeType.getAttributes();
    Map<String, Set<String>> outputProperties = topology.getOutputProperties();
    if (outputProperties != null) {
        for (Map.Entry<String, Set<String>> ope : outputProperties.entrySet()) {
            String nodeName = ope.getKey();
            NodeTemplate nodeTemplate = topology.getNodeTemplates().get(nodeName);
            NodeType nodeTemplateType = ToscaContext.getOrFail(NodeType.class, nodeTemplate.getType());
            for (String propertyName : ope.getValue()) {
                PropertyDefinition pd = nodeTemplateType.getProperties().get(propertyName);
                if (pd != null && !attributes.containsKey(propertyName)) {
                    if (ToscaType.isSimple(pd.getType())) {
                        AttributeDefinition attributeDefinition = new AttributeDefinition();
                        attributeDefinition.setType(pd.getType());
                        attributeDefinition.setDescription(pd.getDescription());
                        if (pd.getDefault() != null && pd.getDefault() instanceof ScalarPropertyValue) {
                            attributeDefinition.setDefault(((ScalarPropertyValue) pd.getDefault()).getValue());
                        }
                        attributes.put(propertyName, attributeDefinition);
                    }
                }
            }
        }
    }
}

Output:
                 PropertyDefinition pd = nodeTemplateType.getProperties().get(propertyName);
-                if (pd != null && !attributes.containsKey(propertyName)) {
-                    if (ToscaType.isSimple(pd.getType())) {
-                        AttributeDefinition attributeDefinition = new AttributeDefinition();
-                        attributeDefinition.setType(pd.getType());
-                        attributeDefinition.setDescription(pd.getDescription());
-                        if (pd.getDefault() != null && pd.getDefault() instanceof ScalarPropertyValue) {
-                            attributeDefinition.setDefault(((ScalarPropertyValue) pd.getDefault()).getValue());
-                        }
-                        attributes.put(propertyName, attributeDefinition);
-                    }
-                }
+                addAttributeFromPropertyDefinition(pd, propertyName, substituteNodeType);
             }


Input:
protected void checkFullscreen() {
    if (isFullscreenEnabled()) {
        int uiOptions = getWindow().getDecorView().getSystemUiVisibility();
        uiOptions |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
        uiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
        uiOptions |= View.SYSTEM_UI_FLAG_FULLSCREEN;
        getWindow().getDecorView().setSystemUiVisibility(uiOptions);
    }
}

Output:
         uiOptions |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
-        uiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
-        uiOptions |= View.SYSTEM_UI_FLAG_FULLSCREEN;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            uiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
+            uiOptions |= View.SYSTEM_UI_FLAG_FULLSCREEN;
+        }
         getWindow().getDecorView().setSystemUiVisibility(uiOptions);


Input:
public double[] getChooseMulti(Label parent, List<Label> children) {
    Map<Label, Integer> childCounts = chooseCounts.get(parent);
    double[] mult = new double[children.size()];
    for (int i = 0; i < mult.length; i++) {
        mult[i] = childCounts.get(children.get(i));
    }
    Multinomials.normalizeProps(mult);
    return mult;
}

Output:
     for (int i = 0; i < mult.length; i++) {
-        mult[i] = childCounts.get(children.get(i));
+        int childCount;
+        if (childCounts != null) {
+            childCount = Utilities.safeGet(childCounts, children.get(i));
+        } else {
+            childCount = 0;
+        }
+        mult[i] = childCount + lambda;
     }


Input:
public List<String> getWailaBody(Entity entity, List<String> tip, IWailaEntityAccessor data, IWailaConfigHandler cfg) {
    if (entity instanceof EntityHorse) {
        EntityHorse horse = (EntityHorse) entity;
        if (cfg.getConfig("String_Node_Str"))
            tip.add(StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str" + Utilities.round(horse.getHorseJumpStrength(), 4));
        if (cfg.getConfig("String_Node_Str"))
            tip.add(StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str" + Utilities.round(horse.getEntityAttribute(SharedMonsterAttributes.movementSpeed).getAttributeValue(), 4));
    } else if (cfg.getConfig(showProfession)) {
        String profession = "String_Node_Str";
        if (FMLCommonHandler.instance().getSide().equals(Side.CLIENT) && entity instanceof EntityVillager) {
            EntityVillager villager = (EntityVillager) entity;
            profession = StatCollector.translateToLocal("String_Node_Str" + Utilities.getVillagerName(villager.getProfession()));
        }
        if (entity instanceof EntityZombie) {
            EntityZombie zombie = (EntityZombie) entity;
            if (zombie.isVillager())
                profession = StatCollector.translateToLocal("String_Node_Str");
        }
        if (entity instanceof EntityWitch)
            profession = StatCollector.translateToLocal("String_Node_Str");
        if (!profession.isEmpty())
            tip.add(StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str" + profession);
    } else if (entity instanceof EntityTNTPrimed && cfg.getConfig(showTntFuse))
        tip.add(StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str" + data.getNBTData().getByte("String_Node_Str"));
    return tip;
}

Output:
             tip.add(StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str" + Utilities.round(horse.getEntityAttribute(SharedMonsterAttributes.movementSpeed).getAttributeValue(), 4));
-    } else if (cfg.getConfig(showProfession)) {
+    } else if (entity instanceof EntityTNTPrimed && cfg.getConfig(showTntFuse))
+        tip.add(StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str" + data.getNBTData().getByte("String_Node_Str"));
+    if (cfg.getConfig(showProfession)) {
         String profession = "String_Node_Str";


Input:
public void stopIT(boolean terminate) {
    synchronized (this) {
        if (Tracer.isActivated()) {
            Tracer.emitEvent(Tracer.Event.STOP.getId(), Tracer.Event.STOP.getType());
        }
        td.getTaskSummary(logger);
        logger.info("String_Node_Str");
        if (GraphGenerator.isEnabled()) {
            logger.debug("String_Node_Str");
        }
        if (RuntimeMonitor.isEnabled()) {
            logger.debug("String_Node_Str");
            runtimeMonitor.shutdown();
        }
        logger.debug("String_Node_Str");
        if (ap != null) {
            ap.shutdown();
        } else {
            logger.debug("String_Node_Str");
        }
        logger.debug("String_Node_Str");
        if (td != null) {
            td.shutdown();
        } else {
            logger.debug("String_Node_Str");
        }
        logger.debug("String_Node_Str");
        Comm.stop();
        logger.debug("String_Node_Str");
    }
    logger.warn("String_Node_Str");
}

Output:
         }
-        td.getTaskSummary(logger);
+        boolean taskSummaryEnabled = System.getProperty(ITConstants.IT_TASK_SUMMARY) != null && !System.getProperty(ITConstants.IT_TASK_SUMMARY).isEmpty() && Boolean.valueOf(System.getProperty(ITConstants.IT_TASK_SUMMARY));
+        if (taskSummaryEnabled) {
+            td.getTaskSummary(logger);
+        }
         logger.info("String_Node_Str");


Input:
public ReaderImageList getImageList(int maxImageCount, int minImageWidth) {
    ReaderImageList imageList = new ReaderImageList(mIsPrivate);
    if (!mContentContainsImages) {
        return imageList;
    }
    Matcher imgMatcher = IMG_TAG_PATTERN.matcher(mContent);
    while (imgMatcher.find()) {
        String imageTag = imgMatcher.group(1);
        String imageUrl = imgMatcher.group(2);
        if (minImageWidth == 0) {
            imageList.addImageUrl(imageUrl);
        } else {
            int width = Math.max(ReaderHtmlUtils.getWidthAttrValue(imageTag), ReaderHtmlUtils.getIntQueryParam(imageUrl, "String_Node_Str"));
            if (width >= minImageWidth) {
                imageList.addImageUrl(imageUrl);
                if (maxImageCount > 0 && imageList.size() >= maxImageCount) {
                    break;
                }
            }
        }
    }
    return imageList;
}

Output:
     while (imgMatcher.find()) {
-        String imageTag = imgMatcher.group(1);
-        String imageUrl = imgMatcher.group(2);
+        String imageTag = imgMatcher.group(0);
+        String imageUrl = imgMatcher.group(1);
         if (minImageWidth == 0) {


Input:
private void initLinker(TreeItem node, TableItem[] tableItems) {
    FOXTreeNode treeNode = (FOXTreeNode) node.getData();
    IMetadataColumn column = treeNode.getColumn();
    if (column != null) {
        for (int i = 0; i < tableItems.length; i++) {
            MetadataColumn metadataColumn = (MetadataColumn) tableItems[i].getData();
            if (metadataColumn.getLabel().equals(column.getLabel())) {
                linker.addLoopLink(tableItems[i], tableItems[i].getData(), xmlViewer.getTree(), treeNode, false);
                break;
            }
        }
    }
    TreeItem[] children = node.getItems();
    for (int i = 0; i < children.length; i++) {
        initLinker(children[i], tableItems);
    }
}

Output:
             if (metadataColumn.getLabel().equals(column.getLabel())) {
-                linker.addLoopLink(tableItems[i], tableItems[i].getData(), xmlViewer.getTree(), treeNode, false);
+                if (os.startsWith("String_Node_Str")) {
+                    isLastOne = true;
+                }
+                linker.addLoopLink(tableItems[i], tableItems[i].getData(), xmlViewer.getTree(), treeNode, isLastOne);
                 break;


Input:
public void run() {
    final int x0 = rectangle.x;
    final int y0 = rectangle.y;
    final int w = rectangle.width;
    final int h = rectangle.height;
    final int xMax = x0 + w;
    final int yMax = y0 + h;
    for (int i = 0; i < sourceTiles.length; ++i) {
        sourceTiles[i] = op.getSourceTile(srcBandList.srcBands[i], rectangle);
        dataBuffers[i] = sourceTiles[i].getDataBuffer();
    }
    final TileIndex srcIndex = new TileIndex(sourceTiles[0]);
    for (int y = y0; y < yMax; ++y) {
        srcIndex.calculateStride(y);
        for (int x = x0; x < xMax; ++x) {
            PolOpUtils.getCoherencyMatrixT3(srcIndex.getIndex(x), sourceProductType, dataBuffers, Tr, Ti);
            synchronized (clusterCounter) {
                int clusterIdx;
                if (mask[y][x] < -64) {
                    clusterIdx = mask[y][x] + 128;
                    computeSummationOfT3(clusterIdx + 1, Tr, Ti, pvSumRe, pvSumIm);
                    clusterCounter[0][clusterIdx]++;
                } else if (mask[y][x] < 0) {
                    clusterIdx = mask[y][x] + 64;
                    computeSummationOfT3(clusterIdx + 1, Tr, Ti, pdSumRe, pdSumIm);
                    clusterCounter[1][clusterIdx]++;
                } else if (mask[y][x] < 64) {
                    clusterIdx = mask[y][x];
                    computeSummationOfT3(clusterIdx + 1, Tr, Ti, psSumRe, psSumIm);
                    clusterCounter[2][clusterIdx]++;
                }
            }
        }
    }
}

Output:
             synchronized (clusterCounter) {
-                int clusterIdx;
-                if (mask[y][x] < -64) {
-                    clusterIdx = mask[y][x] + 128;
-                    computeSummationOfT3(clusterIdx + 1, Tr, Ti, pvSumRe, pvSumIm);
-                    clusterCounter[0][clusterIdx]++;
-                } else if (mask[y][x] < 0) {
-                    clusterIdx = mask[y][x] + 64;
-                    computeSummationOfT3(clusterIdx + 1, Tr, Ti, pdSumRe, pdSumIm);
-                    clusterCounter[1][clusterIdx]++;
-                } else if (mask[y][x] < 64) {
-                    clusterIdx = mask[y][x];
-                    computeSummationOfT3(clusterIdx + 1, Tr, Ti, psSumRe, psSumIm);
-                    clusterCounter[2][clusterIdx]++;
+                if (category[y][x] == Categories.vol) {
+                    computeSummationOfT3(cluster[y][x] + 1, Tr, Ti, pvSumRe, pvSumIm);
+                    clusterCounter[0][cluster[y][x]]++;
+                } else if (category[y][x] == Categories.dbl) {
+                    computeSummationOfT3(cluster[y][x] + 1, Tr, Ti, pdSumRe, pdSumIm);
+                    clusterCounter[1][cluster[y][x]]++;
+                } else if (category[y][x] == Categories.suf) {
+                    computeSummationOfT3(cluster[y][x] + 1, Tr, Ti, psSumRe, psSumIm);
+                    clusterCounter[2][cluster[y][x]]++;
                 }


Input:
public JSONObject getPreferences(String name) {
    try {
        String json = new String(Files.readAllBytes(Paths.get(System.getenv("String_Node_Str"), name)));
        return JSON.parse(json);
    } catch (Exception e) {
        return new JSONObject();
    }
}

Output:
     try {
-        String json = new String(Files.readAllBytes(Paths.get(System.getenv("String_Node_Str"), name)));
+        String json = new String(Files.readAllBytes(Paths.get(System.getProperty("String_Node_Str"), name)));
         return JSON.parse(json);


Input:
public void deployVirtualMachine(String reservationId, String caller, Map<VirtualMachineProfile.Param, Object> params) throws InsufficientCapacityException, ResourceUnavailableException {
    VMReservationVO vmReservation = _reservationDao.findByReservationId(reservationId);
    long vmId = vmReservation.getVmId();
    VMInstanceVO vm = _vmDao.findById(vmId);
    Long poolId = null;
    Map<Long, Long> storage = vmReservation.getVolumeReservation();
    if (storage != null) {
        List<Long> volIdList = new ArrayList<Long>(storage.keySet());
        if (volIdList != null && !volIdList.isEmpty()) {
            poolId = storage.get(volIdList.get(0));
        }
    }
    DataCenterDeployment plan = new DataCenterDeployment(vm.getDataCenterId(), vmReservation.getPodId(), vmReservation.getClusterId(), vmReservation.getHostId(), poolId, null);
    VMInstanceVO vmDeployed = _itMgr.start(vm, params, _userDao.findById(new Long(caller)), _accountDao.findById(vm.getAccountId()), plan);
}

Output:
     }
-    DataCenterDeployment plan = new DataCenterDeployment(vm.getDataCenterId(), vmReservation.getPodId(), vmReservation.getClusterId(), vmReservation.getHostId(), poolId, null);
+    DataCenterDeployment plan = new DataCenterDeployment(vm.getDataCenterId(), vmReservation.getPodId(), vmReservation.getClusterId(), vmReservation.getHostId(), null, null);
     VMInstanceVO vmDeployed = _itMgr.start(vm, params, _userDao.findById(new Long(caller)), _accountDao.findById(vm.getAccountId()), plan);


Input:
public MetadataDatasource get(String id) throws GenericDatasourceServiceException, PentahoAccessControlException {
    helper.checkAdministratorAccess();
    Domain domain = metadataDomainRepository.getDomain(id);
    if (domain != null) {
        return new MetadataDatasource(domain, domain.getId(), TYPE);
    } else {
        return null;
    }
}

Output:
     if (domain != null) {
-        return new MetadataDatasource(domain, domain.getId(), TYPE);
+        return new MetadataDatasource(domain, domain.getId(), domain.getId(), TYPE);
     } else {


Input:
protected boolean fitSystemWindows(Rect insets) {
    pullChildren();
    final int vis = getWindowSystemUiVisibility();
    final boolean stable = (vis & SYSTEM_UI_FLAG_LAYOUT_STABLE) != 0;
    boolean changed = applyInsets(mActionBarTop, insets, true, true, false, true);
    if (mActionBarBottom != null) {
        changed |= applyInsets(mActionBarBottom, insets, true, false, true, true);
    }
    int topSpace = 0;
    if (stable || mActionBarTop.getVisibility() == VISIBLE) {
        topSpace = mActionBarHeight;
    }
    if (mActionBar != null && mActionBar.hasNonEmbeddedTabs()) {
        View tabs = mContainerView.getTabContainer();
        if (tabs != null && (stable || tabs.getVisibility() == VISIBLE)) {
            topSpace += mActionBarHeight;
        }
    }
    int bottomSpace = 0;
    if (mActionView.isSplitActionBar()) {
        if ((mActionBarBottom != null && (stable || mActionBarBottom.getVisibility() == VISIBLE))) {
            bottomSpace = mActionBarHeight;
        }
    }
    boolean res = computeFitSystemWindows(insets, mLocalInsets);
    if (!mOverlayMode && !stable) {
        mLocalInsets.top += topSpace;
        mLocalInsets.bottom += bottomSpace;
    } else {
        insets.top += topSpace;
        insets.bottom += bottomSpace;
    }
    changed |= applyInsets(mContent, mLocalInsets, true, true, true, true);
    if (changed) {
        requestLayout();
    }
    super.fitSystemWindows(insets);
    return true;
}

Output:
     boolean changed = applyInsets(mActionBarTop, insets, true, true, false, true);
-    if (mActionBarBottom != null) {
-        changed |= applyInsets(mActionBarBottom, insets, true, false, true, true);
+    changed |= applyInsets(mActionBarBottom, insets, true, false, true, true);
+    mBaseInnerInsets.set(insets);
+    computeFitSystemWindows(mBaseInnerInsets, mBaseContentInsets);
+    if (!mLastBaseContentInsets.equals(mBaseContentInsets)) {
+        changed = true;
+        mLastBaseContentInsets.set(mBaseContentInsets);
     }


Input:
private void validateXmlSchema(List<ValidationMessage> messages) throws FileNotFoundException, IOException, SAXException {
    XmlValidator xml = new XmlValidator(messages, loadSchemas(), loadTransforms());
    messages.add(new ValidationMessage(Source.InstanceValidator, IssueType.INFORMATIONAL, "String_Node_Str", IssueSeverity.INFORMATION));
}

Output:
     XmlValidator xml = new XmlValidator(messages, loadSchemas(), loadTransforms());
-    messages.add(new ValidationMessage(Source.InstanceValidator, IssueType.INFORMATIONAL, "String_Node_Str", IssueSeverity.INFORMATION));
+    messages.add(new ValidationMessage(Source.InstanceValidator, IssueType.INFORMATIONAL, location, "String_Node_Str", IssueSeverity.INFORMATION));
 }


Input:
public static String extractArchive(File sourceFile, String destination) throws APIImportException {
    BufferedInputStream inputStream = null;
    InputStream zipInputStream = null;
    FileOutputStream outputStream = null;
    ZipFile zip = null;
    String archiveName = null;
    try {
        zip = new ZipFile(sourceFile);
        Enumeration zipFileEntries = zip.entries();
        int index = 0;
        while (zipFileEntries.hasMoreElements()) {
            ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
            String currentEntry = entry.getName();
            if (index == 0) {
                archiveName = currentEntry.substring(0, currentEntry.indexOf(File.separatorChar));
                --index;
            }
            File destinationFile = new File(destination, currentEntry);
            File destinationParent = destinationFile.getParentFile();
            if (destinationParent.mkdirs()) {
                log.info("String_Node_Str" + destinationParent.getName());
            }
            if (!entry.isDirectory()) {
                zipInputStream = zip.getInputStream(entry);
                inputStream = new BufferedInputStream(zipInputStream);
                outputStream = new FileOutputStream(destinationFile);
                IOUtils.copy(inputStream, outputStream);
            }
        }
        return archiveName;
    } catch (IOException e) {
        String errorMessage = "String_Node_Str";
        log.error(errorMessage, e);
        throw new APIImportException(errorMessage, e);
    } finally {
        IOUtils.closeQuietly(zipInputStream);
        IOUtils.closeQuietly(inputStream);
        IOUtils.closeQuietly(outputStream);
    }
}

Output:
             if (index == 0) {
-                archiveName = currentEntry.substring(0, currentEntry.indexOf(File.separatorChar));
+                archiveName = currentEntry.substring(0, currentEntry.indexOf(APIImportExportConstants.ZIP_FILE_SEPARATOR));
                 --index;


Input:
public synchronized IRemoteServiceContainer[] selectHostContainers(ServiceReference serviceReference, Map<String, Object> overridingProperties, String[] serviceExportedInterfaces, String[] serviceExportedConfigs, String[] serviceIntents) throws SelectContainerException {
    Collection rsContainers = selectExistingHostContainers(serviceReference, overridingProperties, serviceExportedInterfaces, serviceExportedConfigs, serviceIntents);
    if (rsContainers.size() == 0 && autoCreateContainer) {
        rsContainers = createAndConfigureHostContainers(serviceReference, overridingProperties, serviceExportedInterfaces, serviceExportedConfigs, serviceIntents);
        Object target = overridingProperties.get(RemoteConstants.ENDPOINT_CONNECTTARGET_ID);
        if (target != null) {
            for (Iterator i = rsContainers.iterator(); i.hasNext(); ) {
                IContainer container = ((IRemoteServiceContainer) i.next()).getContainer();
                try {
                    connectHostContainer(serviceReference, overridingProperties, container, target);
                } catch (Exception e) {
                    logException("String_Node_Str" + container.getID() + "String_Node_Str" + target, e);
                }
            }
        }
    }
    return (IRemoteServiceContainer[]) rsContainers.toArray(new IRemoteServiceContainer[] {});
}

Output:
 public synchronized IRemoteServiceContainer[] selectHostContainers(ServiceReference serviceReference, Map<String, Object> overridingProperties, String[] serviceExportedInterfaces, String[] serviceExportedConfigs, String[] serviceIntents) throws SelectContainerException {
-    Collection rsContainers = selectExistingHostContainers(serviceReference, overridingProperties, serviceExportedInterfaces, serviceExportedConfigs, serviceIntents);
+    Collection rsContainers = (reuseExistingContainers) ? selectExistingHostContainers(serviceReference, overridingProperties, serviceExportedInterfaces, serviceExportedConfigs, serviceIntents) : Collections.EMPTY_LIST;
     if (rsContainers.size() == 0 && autoCreateContainer) {


Input:
private void initialize() {
    initialize(context);
    if (success && !instanceInitialized && enabled) {
        instanceInitialized = true;
        try {
            SSLContext sslContext = SSLContext.getInstance("String_Node_Str");
            sslContext.init(null, null, null);
            middleware.setSSLContext(sslContext);
        } catch (Exception e) {
        }
    }
}

Output:
             sslContext.init(null, null, null);
-            middleware.setSSLContext(sslContext);
+            for (AsyncSSLSocketMiddleware m : middleware) {
+                m.setSSLContext(sslContext);
+            }
         } catch (Exception e) {


Input:
protected void createSystemRoutines() throws PersistenceException {
    ILibrariesService service = null;
    if (!GlobalServiceRegister.getDefault().isServiceRegistered(ILibrariesService.class)) {
        return;
    }
    service = (ILibrariesService) GlobalServiceRegister.getDefault().getService(ILibrariesService.class);
    Project project = getRepositoryContext().getProject();
    FolderHelper folderHelper = getFolderHelper(project.getEmfProject());
    List<URL> routines = service.getSystemRoutines();
    Path path = new Path(RepositoryConstants.SYSTEM_DIRECTORY);
    IPath systemRoutinePath = new Path(ERepositoryObjectType.getFolderName(ERepositoryObjectType.ROUTINES));
    systemRoutinePath = systemRoutinePath.append(RepositoryConstants.SYSTEM_DIRECTORY);
    FolderItem folderItem = folderHelper.getFolder(systemRoutinePath);
    if (folderItem == null) {
        folderItem = folderHelper.createFolder(systemRoutinePath.toString());
    }
    IPath systemRoutineApiPath = new Path(ERepositoryObjectType.getFolderName(ERepositoryObjectType.ROUTINES));
    systemRoutineApiPath = systemRoutinePath.append(RepositoryConstants.SYSTEM_DIRECTORY).append("String_Node_Str");
    FolderItem folderItemApi = folderHelper.getFolder(systemRoutineApiPath);
    if (folderItemApi == null) {
        folderItemApi = folderHelper.createFolder(systemRoutineApiPath.toString());
    }
    List<IRepositoryViewObject> repositoryObjects = getAll(project, ERepositoryObjectType.ROUTINES, false, false);
    Map<String, List<LibraryInfo>> routineAndJars = coreSerivce.getRoutineAndJars();
    for (URL url : routines) {
        String[] fragments = url.toString().split("String_Node_Str");
        String label = fragments[fragments.length - 1];
        String[] tmp = label.split("String_Node_Str");
        String routineLabel = tmp[0];
        if (routineLabel.equals(coreSerivce.getTemplateString())) {
            continue;
        }
        RoutineItem existingItem = null;
        for (IRepositoryViewObject object : repositoryObjects) {
            if (object.getLabel().equals(routineLabel) && object.getProperty().getItem() instanceof RoutineItem) {
                existingItem = (RoutineItem) object.getProperty().getItem();
                break;
            }
        }
        if (existingItem == null) {
            createRoutine(url, path, routineLabel, routineAndJars != null ? routineAndJars.get(routineLabel) : null);
        } else {
            updateRoutine(url, existingItem);
            existingItem.setParent(folderItem);
        }
    }
}

Output:
     Path path = new Path(RepositoryConstants.SYSTEM_DIRECTORY);
-    IPath systemRoutinePath = new Path(ERepositoryObjectType.getFolderName(ERepositoryObjectType.ROUTINES));
+    IPath systemRoutinePath = new Path(ERepositoryObjectType.getFolderName(routinesType));
     systemRoutinePath = systemRoutinePath.append(RepositoryConstants.SYSTEM_DIRECTORY);


Input:
public final void close() throws IOException {
    synchronized (AssetManager.this) {
        if (mAsset != 0) {
            destroyAsset(mAsset);
            mAsset = 0;
            decRefsLocked();
        }
    }
}

Output:
             mAsset = 0;
-            decRefsLocked();
+            decRefsLocked(hashCode());
         }


Input:
public void setData(String author, String body, long createdUtc, int downs, int kind, int likes, int nesting, long nowTimeMs, int numComments, String title, String thingId, int ups) {
    this.likes = likes;
    this.nesting = nesting;
    this.title = title;
    this.thingId = thingId;
    this.scoreText = VotingArrows.getScoreText(ups - downs + likes);
    this.bodyText = FORMATTER.formatSpans(getContext(), body);
    this.statusText = getStatus(getContext(), author, createdUtc, kind, nowTimeMs, numComments);
    requestLayout();
}

Output:
     this.thingId = thingId;
-    this.scoreText = VotingArrows.getScoreText(ups - downs + likes);
+    this.scoreText = VotingArrows.getScoreText(score);
     this.bodyText = FORMATTER.formatSpans(getContext(), body);


Input:
public void shouldAddTwoSimpleItemWithTheSameName() throws NoSuchFieldException {
    ResponseItem childItemA = new ResponseItem("String_Node_Str");
    childItemA.setContent("String_Node_Str");
    item.addItem(childItemA);
    ResponseItem childItemB = new ResponseItem("String_Node_Str");
    childItemB.setContent("String_Node_Str");
    item.addItem(childItemB);
    List<ResponseItem> children = item.getAttrAsList("String_Node_Str");
    assertEquals("String_Node_Str", children.get(0).getContent());
    assertEquals("String_Node_Str", children.get(1).getContent());
}

Output:
     childItemA.setContent("String_Node_Str");
-    item.addItem(childItemA);
+    item.addChild(childItemA);
     ResponseItem childItemB = new ResponseItem("String_Node_Str");


Input:
private boolean showPhotoViewer(String imageUrl, View sourceView, int startX, int startY) {
    if (!isAdded() || TextUtils.isEmpty(imageUrl)) {
        return false;
    }
    if (!imageUrl.startsWith("String_Node_Str")) {
        return false;
    }
    String postContent = (mRenderer != null ? mRenderer.getRenderedHtml() : null);
    boolean isPrivatePost = (mPost != null && mPost.isPrivate);
    EnumSet<PhotoViewerOption> options = EnumSet.noneOf(PhotoViewerOption.class);
    if (isPrivatePost) {
        options.add(ReaderActivityLauncher.PhotoViewerOption.IS_PRIVATE_IMAGE);
    }
    ReaderActivityLauncher.showReaderPhotoViewer(getActivity(), imageUrl, postContent, sourceView, options, startX, startY);
    return true;
}

Output:
     }
-    String postContent = (mRenderer != null ? mRenderer.getRenderedHtml() : null);
+    String postContent = (mPost != null ? mPost.getText() : null);
     boolean isPrivatePost = (mPost != null && mPost.isPrivate);


Input:
public void run() {
    map.remove(player.getName());
}

Output:
 public void run() {
-    map.remove(player.getName());
+    if (map.get(player.getName()) == obj) {
+        map.remove(player.getName());
+    } else {
+    }
 }


Input:
private void runPigScore(EvalConfig evalConfig) throws IOException {
    SourceType sourceType = evalConfig.getDataSet().getSource();
    ShifuFileUtils.deleteFile(pathFinder.getEvalNormalizedPath(evalConfig), sourceType);
    ShifuFileUtils.deleteFile(pathFinder.getEvalScorePath(evalConfig), sourceType);
    ShifuFileUtils.deleteFile(pathFinder.getEvalPerformancePath(evalConfig), sourceType);
    Map<String, String> paramsMap = new HashMap<String, String>();
    paramsMap.put(Constants.SOURCE_TYPE, sourceType.toString());
    paramsMap.put("String_Node_Str", evalConfig.getDataSet().getDataPath());
    paramsMap.put("String_Node_Str", pathFinder.getEvalNormalizedPath(evalConfig));
    paramsMap.put("String_Node_Str", pathFinder.getEvalScorePath(evalConfig));
    paramsMap.put("String_Node_Str", pathFinder.getEvalPerformancePath(evalConfig));
    paramsMap.put("String_Node_Str", evalConfig.getName());
    paramsMap.put("String_Node_Str", evalConfig.getDataSet().getDataDelimiter());
    paramsMap.put("String_Node_Str", evalConfig.getPerformanceScoreSelector().trim());
    String pigScript = "String_Node_Str";
    if (modelConfig.isClassification()) {
        pigScript = "String_Node_Str";
    }
    try {
        PigExecutor.getExecutor().submitJob(modelConfig, pathFinder.getAbsolutePath(pigScript), paramsMap, evalConfig.getDataSet().getSource());
    } catch (IOException e) {
        throw new ShifuException(ShifuErrorCode.ERROR_RUNNING_PIG_JOB, e);
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }
    Iterator<JobStats> iter = PigStats.get().getJobGraph().iterator();
    while (iter.hasNext()) {
        JobStats jobStats = iter.next();
        this.evalRecords = jobStats.getHadoopCounters().getGroup(Constants.SHIFU_GROUP_COUNTER).getCounter(Constants.COUNTER_RECORDS);
        log.info("String_Node_Str" + evalRecords);
        if (this.evalRecords == 0L) {
            continue;
        }
        this.pigPosTags = jobStats.getHadoopCounters().getGroup(Constants.SHIFU_GROUP_COUNTER).getCounter(Constants.COUNTER_POSTAGS);
        this.pigNegTags = jobStats.getHadoopCounters().getGroup(Constants.SHIFU_GROUP_COUNTER).getCounter(Constants.COUNTER_NEGTAGS);
        this.pigPosWeightTags = jobStats.getHadoopCounters().getGroup(Constants.SHIFU_GROUP_COUNTER).getCounter(Constants.COUNTER_WPOSTAGS) / (Constants.EVAL_COUNTER_WEIGHT_SCALE * 1.0d);
        this.pigNegWeightTags = jobStats.getHadoopCounters().getGroup(Constants.SHIFU_GROUP_COUNTER).getCounter(Constants.COUNTER_WNEGTAGS) / (Constants.EVAL_COUNTER_WEIGHT_SCALE * 1.0d);
        break;
    }
}

Output:
     try {
-        PigExecutor.getExecutor().submitJob(modelConfig, pathFinder.getAbsolutePath(pigScript), paramsMap, evalConfig.getDataSet().getSource());
+        PigExecutor.getExecutor().submitJob(modelConfig, pathFinder.getAbsolutePath(pigScript), paramsMap, evalConfig.getDataSet().getSource(), super.pathFinder);
     } catch (IOException e) {


Input:
public boolean sameConcept(Unit toUnit) {
    if (this.getBaseName() != toUnit.getBaseName() && getParentQuantity() != toUnit.getParentQuantity() && !getParentQuantity().getConcept().equals(toUnit.getParentQuantity().getConcept())) {
        return false;
    }
    return true;
}

Output:
 public boolean sameConcept(Unit toUnit) {
-    if (this.getBaseName() != toUnit.getBaseName() && getParentQuantity() != toUnit.getParentQuantity() && !getParentQuantity().getConcept().equals(toUnit.getParentQuantity().getConcept())) {
+    if (!this.getBaseName().equalsIgnoreCase(toUnit.getBaseName()) && getParentQuantity() != toUnit.getParentQuantity() && (getParentQuantity() == null || toUnit.getParentQuantity() == null || !getParentQuantity().getConcept().equalsIgnoreCase(toUnit.getParentQuantity().getConcept()))) {
         return false;


Input:
public ClassDefinitionBuilder addIntArrayField(String fieldName) {
    check();
    cd.add(new FieldDefinitionImpl(index++, fieldName, FieldType.INT_ARRAY));
    return this;
}

Output:
     check();
-    cd.add(new FieldDefinitionImpl(index++, fieldName, FieldType.INT_ARRAY));
+    fieldDefinitions.add(new FieldDefinitionImpl(index++, fieldName, FieldType.INT_ARRAY));
     return this;


Input:
public Boolean isVmAlive(VirtualMachine vm, Host host) {
    if (vm.getHypervisorType() == HypervisorType.VMware)
        return true;
    return null;
}

Output:
         return true;
-    return null;
+    throw new UnknownVM();
 }


Input:
private void compactChain(final int deleteIndex) {
    final int[] values = this.values;
    int index = deleteIndex;
    while (true) {
        final int previousIndex = index;
        index = next(index);
        if (values[index] == missingValue) {
            return;
        }
        values[previousIndex] = values[index];
        values[index] = missingValue;
    }
}

Output:
         }
-        values[previousIndex] = values[index];
-        values[index] = missingValue;
+        final int hash = Hashing.intHash(values[index], mask);
+        if ((index < hash && (hash <= deleteIndex || deleteIndex <= index)) || (hash <= deleteIndex && deleteIndex <= index)) {
+            values[deleteIndex] = values[index];
+            values[index] = missingValue;
+            deleteIndex = index;
+        }
     }


Input:
public String getVersion() throws paloexception {
    List<NameValuePair> qparams = new ArrayList<NameValuePair>();
    qparams.add(new BasicNameValuePair("String_Node_Str", "String_Node_Str"));
    try {
        StringBuilder sb = new StringBuilder();
        HttpEntity entity = sendToServer(qparams, "String_Node_Str");
        CsvReader csv = new CsvReader(entity.getContent(), Charset.forName("String_Node_Str"));
        csv.setDelimiter(';');
        csv.setTextQualifier('"');
        while (csv.readRecord()) {
            sb.append(csv.get(0));
            sb.append("String_Node_Str");
            sb.append(csv.get(1));
            sb.append("String_Node_Str");
            sb.append(csv.get(2));
            sb.append("String_Node_Str");
            sb.append(csv.get(3));
        }
        csv.close();
        entity.consumeContent();
        return sb.toString();
    } catch (Exception e) {
        throw new paloexception(e.getMessage());
    }
}

Output:
         HttpEntity entity = sendToServer(qparams, "String_Node_Str");
-        CsvReader csv = new CsvReader(entity.getContent(), Charset.forName("String_Node_Str"));
-        csv.setDelimiter(';');
-        csv.setTextQualifier('"');
-        while (csv.readRecord()) {
-            sb.append(csv.get(0));
+        CSVReader csv = new CSVReader(entity.getContent(), "String_Node_Str", "String_Node_Str", ';', '"', '\\', false, 0);
+        String[] result = null;
+        while ((result = csv.readNext()) != null) {
+            sb.append(result[0]);
             sb.append("String_Node_Str");


Input:
public void testGetTypedWordInfoOrNull() {
    final String TYPED_WORD = "String_Node_Str";
    final int NUMBER_OF_ADDED_SUGGESTIONS = 5;
    final ArrayList<SuggestedWordInfo> list = new ArrayList<>();
    list.add(createTypedWordInfo(TYPED_WORD));
    for (int i = 0; i < NUMBER_OF_ADDED_SUGGESTIONS; ++i) {
        list.add(createCorrectionWordInfo(Integer.toString(i)));
    }
    final SuggestedWords wordsWithTypedWord = new SuggestedWords(list, null, false, false, false, false, SuggestedWords.INPUT_STYLE_NONE);
    final SuggestedWordInfo typedWord = wordsWithTypedWord.getTypedWordInfoOrNull();
    assertNotNull(typedWord);
    assertEquals(TYPED_WORD, typedWord.mWord);
    final SuggestedWords wordsWithoutTypedWord = wordsWithTypedWord.getSuggestedWordsExcludingTypedWord(SuggestedWords.INPUT_STYLE_NONE);
    assertNull(wordsWithoutTypedWord.getTypedWordInfoOrNull());
    assertNull(SuggestedWords.EMPTY.getTypedWordInfoOrNull());
}

Output:
     }
-    final SuggestedWords wordsWithTypedWord = new SuggestedWords(list, null, false, false, false, false, SuggestedWords.INPUT_STYLE_NONE);
+    final SuggestedWords wordsWithTypedWord = new SuggestedWords(list, null, false, false, false, SuggestedWords.INPUT_STYLE_NONE);
     final SuggestedWordInfo typedWord = wordsWithTypedWord.getTypedWordInfoOrNull();


Input:
public void applyGameUpdate(GameUpdateMessage msg) {
    NetGameUpdate netUpdate = msg.netUpdate;
    gameClock = netUpdate.time;
    if (netUpdate.entities != null) {
        int size = netUpdate.entities.length;
        for (int i = 0; i < size; i++) {
            NetEntity netEnt = netUpdate.entities[i];
            if (netEnt != null) {
                if (entities.containsEntity(netEnt.id)) {
                    ClientEntity ent = entities.getEntity(netEnt.id);
                    if (Type.fromNet(netEnt.type) == ent.getType()) {
                        ent.updateState(netEnt, gameClock);
                    } else {
                        removeEntity(i);
                        createEntity(netEnt);
                    }
                } else {
                    createEntity(netEnt);
                }
            } else {
                if (i < SeventhConstants.MAX_PERSISTANT_ENTITIES) {
                    if (netUpdate.deadPersistantEntities.getBit(i)) {
                        removeEntity(i);
                    }
                } else {
                    removeEntity(i);
                }
            }
        }
    }
    if (netUpdate.sounds != null) {
        int size = netUpdate.numberOfSounds;
        for (int i = 0; i < size; i++) {
            NetSound snd = netUpdate.sounds[i];
            if (snd != null) {
                Sounds.playSound(snd, snd.posX, snd.posY);
            }
        }
    }
    if (netUpdate.spectatingPlayerId > -1 && !cameraController.isCameraRoaming()) {
        int previousSpec = localPlayer.getSpectatingPlayerId();
        localPlayer.setSpectatingPlayerId(netUpdate.spectatingPlayerId);
        if (previousSpec != netUpdate.spectatingPlayerId) {
            ClientEntity ent = this.entities.getEntity(netUpdate.spectatingPlayerId);
            if (ent != null) {
                camera.centerAroundNow(ent.getCenterPos());
            }
        }
    } else {
        localPlayer.setSpectatingPlayerId(Entity.INVALID_ENTITY_ID);
    }
}

Output:
             if (snd != null) {
-                Sounds.playSound(snd, snd.posX, snd.posY);
+                switch(snd.getSoundType().getSourceType()) {
+                    case POSITIONAL:
+                        {
+                            Sounds.playSound(snd, snd.posX, snd.posY);
+                            break;
+                        }
+                    case REFERENCED:
+                        {
+                            NetSoundByEntity soundByEntity = (NetSoundByEntity) snd;
+                            if (soundByEntity.hasPositionalInformation()) {
+                                Sounds.playSound(snd, snd.posX, snd.posY);
+                            } else {
+                                ClientEntity entity = this.entities.getEntity(soundByEntity.entityId);
+                                if (entity != null) {
+                                    Vector2f pos = entity.getCenterPos();
+                                    if (entity.getId() == this.localPlayer.getViewingEntityId()) {
+                                        switch(snd.getSoundType()) {
+                                            case SURFACE_DIRT:
+                                            case SURFACE_GRASS:
+                                            case SURFACE_METAL:
+                                            case SURFACE_NORMAL:
+                                            case SURFACE_SAND:
+                                            case SURFACE_WATER:
+                                            case SURFACE_WOOD:
+                                                Sounds.playSound(snd, pos.x, pos.y, 0.35f);
+                                                break;
+                                            default:
+                                                Sounds.playSound(snd, pos.x, pos.y);
+                                        }
+                                    } else {
+                                        Sounds.playSound(snd, pos.x, pos.y);
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    case REFERENCED_ATTACHED:
+                        {
+                            NetSoundByEntity soundByEntity = (NetSoundByEntity) snd;
+                            if (soundByEntity.hasPositionalInformation()) {
+                                Sounds.playSound(snd, snd.posX, snd.posY);
+                            } else {
+                                ClientEntity entity = this.entities.getEntity(soundByEntity.entityId);
+                                if (entity != null) {
+                                    Vector2f pos = entity.getCenterPos();
+                                    entity.attachSound(Sounds.playSound(snd, pos.x, pos.y));
+                                }
+                            }
+                            break;
+                        }
+                    case GLOBAL:
+                        Sounds.playGlobalSound(snd);
+                        break;
+                }
             }


Input:
public void updateMenuEntry(String origMenuText, String newMenuText, final SystemTrayMenuAction newCallback) {
    synchronized (this.menuEntries) {
        MenuEntry menuEntry = this.menuEntries.get(origMenuText);
        if (menuEntry != null) {
            libgtk.gtk_menu_item_set_label(menuEntry.dashboardItem, newMenuText);
            Gobject.GCallback gtkCallback = new Gobject.GCallback() {
                public void callback(Pointer instance, Pointer data) {
                    AppIndicatorTray.this.callbackExecutor.execute(new Runnable() {
                        public void run() {
                            newCallback.onClick(AppIndicatorTray.this);
                        }
                    });
                }
            };
            libgobject.g_signal_connect_data(menuEntry.dashboardItem, "String_Node_Str", gtkCallback, null, null, 0);
            libgtk.gtk_widget_show_all(menuEntry.dashboardItem);
        } else {
            addMenuEntry(origMenuText, newCallback);
        }
    }
}

Output:
             };
-            libgobject.g_signal_connect_data(menuEntry.dashboardItem, "String_Node_Str", gtkCallback, null, null, 0);
+            libgobject.g_signal_connect_data(menuEntry.dashboardItem, "String_Node_Str", menuEntry.gtkCallback, null, null, 0);
             libgtk.gtk_widget_show_all(menuEntry.dashboardItem);


Input:
private ManagedObject<?> getClassFromManagedObject(Class<?> clazz) {
    ManagedObjectFactory<?> managedObjectFactory = getManagedObjectFactory(clazz);
    ManagedObject<?> bean = null;
    try {
        bean = managedObjectFactory.createManagedObject();
    } catch (Exception e) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "String_Node_Str" + clazz.getName() + "String_Node_Str" + e.toString());
        }
    }
    if (bean == null) {
        return null;
    }
    return bean;
}

Output:
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
-            Tr.debug(tc, "String_Node_Str" + clazz.getName() + "String_Node_Str" + e.toString());
+            Tr.debug(tc, "String_Node_Str" + clazz.getName() + "String_Node_Str", e);
         }


Input:
public void requestPostDialog(Bundle bundle, OnPostingCompleteListener onPostingCompleteListener) {
    super.requestPostDialog(bundle, onPostingCompleteListener);
    PlusShare.Builder plusShare = new PlusShare.Builder(mSocialNetworkManager.getActivity()).setType("String_Node_Str");
    if (bundle != null) {
        if (bundle.containsKey(BUNDLE_MESSAGE)) {
            plusShare.setText(bundle.getString(BUNDLE_MESSAGE));
        }
        if (bundle.containsKey(BUNDLE_LINK)) {
            plusShare.setContentUrl(Uri.parse(bundle.getString(BUNDLE_LINK)));
        }
    }
    Intent shareIntent = plusShare.getIntent();
    mSocialNetworkManager.getActivity().startActivityForResult(shareIntent, 0);
}

Output:
     super.requestPostDialog(bundle, onPostingCompleteListener);
-    PlusShare.Builder plusShare = new PlusShare.Builder(mSocialNetworkManager.getActivity()).setType("String_Node_Str");
+    PlusShare.Builder plusShare = new PlusShare.Builder(mActivity).setType("String_Node_Str");
     if (bundle != null) {


Input:
public void onUpdate() {
    super.onUpdate();
    if (this.rand.nextInt(500) == 250) {
        if (art == EnumArt.AngelOne) {
            spawnAngel(world);
            art = EnumArt.BlankPaintingOne;
        }
        if (art == EnumArt.AngelTwo) {
            spawnAngel(world);
            art = EnumArt.BlankPaintingTwo;
        }
        if (art == EnumArt.AngelThree) {
            spawnAngel(world);
            art = EnumArt.BlankPaintingThree;
        }
        if (art == EnumArt.AngelFour) {
            spawnAngel(world);
            art = EnumArt.BlankPaintingFour;
        }
        if (art == EnumArt.AngelFive) {
            spawnAngel(world);
            art = EnumArt.BlankPaintingFive;
        }
        if (art == EnumArt.AngelSix) {
            spawnAngel(world);
            art = EnumArt.BlankPaintingSix;
        }
    }
}

Output:
         if (art == EnumArt.AngelOne) {
-            spawnAngel(world);
+            spawnAngel(getEntityWorld());
             art = EnumArt.BlankPaintingOne;


Input:
protected void editItem(ISelection sel) {
    IStructuredSelection selection = (IStructuredSelection) sel;
    String existing = (String) selection.getFirstElement();
    String value = getExistingInputObject(existing.replace("String_Node_Str", "String_Node_Str"));
    if (value != null) {
        int indexOf = list.indexOf(existing);
        list.remove(existing);
        list.add(indexOf, value);
        viewer.refresh();
    }
}

Output:
     String existing = (String) selection.getFirstElement();
-    String value = getExistingInputObject(existing.replace("String_Node_Str", "String_Node_Str"));
+    String value = getExistingInputObject(existing);
     if (value != null) {


Input:
public IDataQueryDefinition[] createReportQueries(IDataQueryDefinition parent) throws BirtException {
    if (crosstabItem == null) {
        throw new CrosstabException(Messages.getString("String_Node_Str"));
    }
    IDataQueryDefinition cubeQuery = CrosstabQueryUtil.createCubeQuery(crosstabItem, parent, true, true, true, true, true, true);
    String emptyValue = crosstabItem.getEmptyCellValue();
    if (context != null) {
        processChildQuery(cubeQuery, crosstabItem.getHeader(), emptyValue);
        for (int i = 0; i < crosstabItem.getMeasureCount(); i++) {
            MeasureViewHandle mv = crosstabItem.getMeasure(i);
            processChildQuery(cubeQuery, mv.getCell(), emptyValue);
            processChildQuery(cubeQuery, mv.getHeader(), emptyValue);
            for (int j = 0; j < mv.getAggregationCount(); j++) {
                processChildQuery(cubeQuery, mv.getAggregationCell(j), emptyValue);
            }
        }
        if (crosstabItem.getDimensionCount(ROW_AXIS_TYPE) > 0) {
            for (int i = 0; i < crosstabItem.getDimensionCount(ROW_AXIS_TYPE); i++) {
                DimensionViewHandle dv = crosstabItem.getDimension(ROW_AXIS_TYPE, i);
                for (int j = 0; j < dv.getLevelCount(); j++) {
                    LevelViewHandle lv = dv.getLevel(j);
                    processChildQuery(cubeQuery, lv.getCell(), emptyValue);
                    processChildQuery(cubeQuery, lv.getAggregationHeader(), emptyValue);
                }
            }
        }
        if (crosstabItem.getDimensionCount(COLUMN_AXIS_TYPE) > 0) {
            for (int i = 0; i < crosstabItem.getDimensionCount(COLUMN_AXIS_TYPE); i++) {
                DimensionViewHandle dv = crosstabItem.getDimension(COLUMN_AXIS_TYPE, i);
                for (int j = 0; j < dv.getLevelCount(); j++) {
                    LevelViewHandle lv = dv.getLevel(j);
                    processChildQuery(cubeQuery, lv.getCell(), emptyValue);
                    processChildQuery(cubeQuery, lv.getAggregationHeader(), emptyValue);
                }
            }
        }
        processChildQuery(cubeQuery, crosstabItem.getGrandTotal(ROW_AXIS_TYPE), emptyValue);
        processChildQuery(cubeQuery, crosstabItem.getGrandTotal(COLUMN_AXIS_TYPE), emptyValue);
    }
    return new IDataQueryDefinition[] { cubeQuery };
}

Output:
     if (context != null) {
-        processChildQuery(cubeQuery, crosstabItem.getHeader(), emptyValue);
+        processChildQuery(cubeQuery, crosstabItem.getHeader());
         for (int i = 0; i < crosstabItem.getMeasureCount(); i++) {


Input:
public Dimension getSize() {
    DimensionHandle handle = ((ReportItemHandle) getHandle()).getWidth();
    int px = 0;
    int py = 0;
    if (!DesignChoiceConstants.UNITS_PERCENTAGE.equals(handle.getUnits())) {
        px = (int) DEUtil.convertoToPixel(handle);
    }
    handle = ((ReportItemHandle) getHandle()).getHeight();
    if (!DesignChoiceConstants.UNITS_PERCENTAGE.equals(handle.getUnits())) {
        py = (int) DEUtil.convertoToPixel(handle);
    }
    px = Math.max(0, px);
    py = Math.max(0, py);
    return new Dimension(px, py);
}

Output:
 public Dimension getSize() {
-    DimensionHandle handle = ((ReportItemHandle) getHandle()).getWidth();
+    DimensionHandle widthHandle = ((ReportItemHandle) getHandle()).getWidth();
     int px = 0;


Input:
public void addRoleToPrincipal(HttpRequest httpRequest, HttpResponder httpResponder, String principalType, String principalName, String roleName) throws Exception {
    ensureSecurityEnabled();
    authorizerInstantiatorService.get().addRoleToPrincipal(new Role(roleName), new Principal(principalName, Principal.PrincipalType.valueOf(principalType.toUpperCase())));
    httpResponder.sendStatus(HttpResponseStatus.OK);
    createLogEntry(httpRequest, null, HttpResponseStatus.OK);
}

Output:
     ensureSecurityEnabled();
-    authorizerInstantiatorService.get().addRoleToPrincipal(new Role(roleName), new Principal(principalName, Principal.PrincipalType.valueOf(principalType.toUpperCase())));
+    authorizerInstantiator.get().addRoleToPrincipal(new Role(roleName), new Principal(principalName, Principal.PrincipalType.valueOf(principalType.toUpperCase())));
     httpResponder.sendStatus(HttpResponseStatus.OK);


Input:
public List<IRepositoryNode> getChildren() {
    try {
        super.getChildren().clear();
        RootContainer<String, IRepositoryViewObject> tdqViewObjects = ProxyRepositoryFactory.getInstance().getTdqRepositoryViewObjects(getContentType(), RepositoryNodeHelper.getPath(this).toString());
        for (Container<String, IRepositoryViewObject> container : tdqViewObjects.getSubContainer()) {
            Folder folder = new Folder((Property) container.getProperty(), ERepositoryObjectType.TDQ_ANALYSIS);
            if (folder.isDeleted()) {
                continue;
            }
            AnalysisSubFolderRepNode childNodeFolder = new AnalysisSubFolderRepNode(folder, this, ENodeType.SIMPLE_FOLDER);
            childNodeFolder.setProperties(EProperties.LABEL, ERepositoryObjectType.TDQ_ANALYSIS_ELEMENT);
            childNodeFolder.setProperties(EProperties.CONTENT_TYPE, ERepositoryObjectType.TDQ_ANALYSIS_ELEMENT);
            folder.setRepositoryNode(childNodeFolder);
            super.getChildren().add(childNodeFolder);
        }
        for (IRepositoryViewObject viewObject : tdqViewObjects.getMembers()) {
            if (viewObject.isDeleted()) {
                continue;
            }
            AnalysisRepNode anaNode = new AnalysisRepNode(viewObject, this, ENodeType.REPOSITORY_ELEMENT);
            anaNode.setProperties(EProperties.LABEL, ERepositoryObjectType.TDQ_ANALYSIS_ELEMENT);
            anaNode.setProperties(EProperties.CONTENT_TYPE, ERepositoryObjectType.TDQ_ANALYSIS_ELEMENT);
            viewObject.setRepositoryNode(anaNode);
            super.getChildren().add(anaNode);
        }
    } catch (PersistenceException e) {
        log.error(e, e);
    }
    return super.getChildren();
}

Output:
             Folder folder = new Folder((Property) container.getProperty(), ERepositoryObjectType.TDQ_ANALYSIS);
-            if (folder.isDeleted()) {
+            if (!withDeleted && folder.isDeleted()) {
                 continue;


Input:
public void transform(NodeType node) {
    ElementParameterType specifyKeys = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType specifyColumns = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType columns = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType columnStart = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType columnEnd = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType columnLimit = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType keyStart = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType keyEnd = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    ElementParameterType count = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    if (specifyKeys == null && specifyColumns == null && columnStart == null && columnEnd == null && columns != null && columnLimit == null && keyStart != null && keyEnd != null && count != null) {
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue("String_Node_Str");
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
        if (!"String_Node_Str".equals(columns.getValue()) && !"String_Node_Str".equals(columns.getValue())) {
            ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue("String_Node_Str");
        }
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
        ComponentUtilities.removeNodeProperty(node, "String_Node_Str");
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue(columns.getValue());
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue(keyStart.getValue());
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue("String_Node_Str");
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue(keyEnd.getValue());
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue("String_Node_Str");
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
        ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue(count.getValue());
    }
}

Output:
         ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
-        if (!"String_Node_Str".equals(columns.getValue()) && !"String_Node_Str".equals(columns.getValue())) {
+        if ("String_Node_Str".equals(columnFamilyType.getValue()) && (!"String_Node_Str".equals(columns.getValue())) && (!"String_Node_Str".equals(columns.getValue()))) {
             ComponentUtilities.getNodeProperty(node, "String_Node_Str").setValue("String_Node_Str");


Input:
public void complete() {
    int rowcount = cache.getMaxRow();
    for (int i = 0; i < rowcount; i++) {
        Object[] row = cache.getRowData(i);
        for (int j = 0; j < row.length; j++) {
            if (row[j] == waste) {
                continue;
            }
            Data d = (Data) row[j];
            int styleid = engine.getStyleID(d.getStyleEntry());
            d.setStyleId(styleid);
            Rule rule = d.getRule();
            int start = axis.getCoordinate(rule.getStart()) + 1;
            int end = axis.getCoordinate(rule.getEnd()) + 1;
            end = Math.min(end, MAX_COLUMN);
            int scount = Math.max(0, end - start - 1);
            Span span = new Span(start, scount);
            HyperlinkDef link = d.getHyperlinkDef();
            if (link != null && link.getBookmark() != null) {
                links.put(link.getBookmark(), getCellName(i + 1, start + 1));
            }
            d.setSpan(span);
        }
    }
}

Output:
             Rule rule = d.getRule();
-            int start = axis.getCoordinate(rule.getStart()) + 1;
-            int end = axis.getCoordinate(rule.getEnd()) + 1;
+            int start = axis.getCoordinateIndex(rule.getStart()) + 1;
+            int end = axis.getCoordinateIndex(rule.getEnd()) + 1;
             end = Math.min(end, MAX_COLUMN);


Input:
private void track(String eventName, HashMap<String, Object> attributes, Date date) {
    if ((mCurrentUser == null) || (mCurrentSession == null)) {
        identifyUser();
    }
    if ((eventName == null) || (eventName.length() == 0)) {
        eventName = "String_Node_Str";
    }
    if (!Liquid.assertEventAttributeTypes(attributes)) {
        return;
    }
    final String finalEventName = eventName;
    final HashMap<String, Object> finalAttributes = sanitizeAttributes(attributes);
    final LQUser finalUser = mCurrentUser;
    final LQDevice finalDevice = mDevice;
    final LQSession finalSession = mCurrentSession;
    final Date finalDate = date;
    mQueue.execute(new Runnable() {
        public void run() {
            LQEvent event = new LQEvent(finalEventName, finalAttributes, finalDate);
            LQDataPoint dataPoint = new LQDataPoint(finalUser, finalDevice, finalSession, event, mAppliedLiquidPackage.getValues(), finalDate);
            LQLog.data(dataPoint.toJSON());
            String endPoint = LIQUID_SERVER_URL + "String_Node_Str";
            addToHttpQueue(dataPoint.toJSON(), endPoint, "String_Node_Str");
        }
    });
}

Output:
     final String finalEventName = eventName;
-    final HashMap<String, Object> finalAttributes = sanitizeAttributes(attributes);
+    final HashMap<String, Object> finalAttributes = LQModel.sanitizeAttributes(attributes, isDevelopmentMode);
     final LQUser finalUser = mCurrentUser;


Input:
protected DataMatrix getInputBuffer() {
    checkRegistry();
    return this.dataGH;
}

Output:
     checkRegistry();
-    return this.dataGH;
+    return this.dataGeneralized;
 }


Input:
public Control createContents(Composite parent) {
    initColumnNames();
    viewer = new PropertyHandleTableViewer(parent, true, true, true);
    TableColumn column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
    column.setText(cellLabels[0]);
    column.setWidth(150);
    column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
    column.setText(cellLabels[1]);
    column.setWidth(100);
    column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
    column.setText(cellLabels[2]);
    column.setWidth(100);
    column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
    column.setText(cellLabels[3]);
    column.setWidth(100);
    initializeFilters();
    viewer.getViewer().setContentProvider(new IStructuredContentProvider() {
        public Object[] getElements(Object inputElement) {
            ArrayList filterList = new ArrayList(10);
            Iterator iter = filters.iterator();
            if (iter != null) {
                while (iter.hasNext()) {
                    filterList.add(iter.next());
                }
            }
            return filterList.toArray();
        }
        public void dispose() {
        }
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }
    });
    viewer.getViewer().setLabelProvider(this);
    viewer.getViewer().setInput(filters);
    addListeners();
    setToolTips();
    return viewer.getControl();
}

Output:
     });
-    viewer.getViewer().setLabelProvider(this);
+    viewer.getViewer().setLabelProvider(new FilterTableProvider());
     viewer.getViewer().setInput(filters);


Input:
public void run() {
    try {
        while (!process.isTerminated()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
        if (process.getExitValue() == ReportLauncher.EXIT_OK) {
            File file = new File(fileName);
            String openName = ReportLauncher.getOutputFileName(outputFolder, file.getName(), suffix);
            if (openName != null && new File(openName).exists()) {
                Program.launch(openName);
            }
        }
    } catch (Exception e) {
    }
}

Output:
         }
-    } catch (Exception e) {
+    } catch (DebugException e) {
     }


Input:
private TextureRegion scale(TextureRegion tex) {
    TextureRegion sprite = new TextureRegion(tex);
    sprite.setRegionWidth(350);
    return sprite;
}

Output:
 private TextureRegion scale(TextureRegion tex) {
-    TextureRegion sprite = new TextureRegion(tex);
-    sprite.setRegionWidth(350);
+    Sprite sprite = new Sprite(tex);
+    sprite.setSize(110, 45);
     return sprite;


Input:
public void testMerge() throws Exception {
    Configuration c = new Configuration();
    ManagedRepositoryConfiguration testRepo = new ManagedRepositoryConfiguration();
    testRepo.setId(TEST_REPO_ID);
    testRepo.setLocation("String_Node_Str");
    RepositoryScanningConfiguration repoScanConfig = new RepositoryScanningConfiguration();
    List<String> knownContentConsumers = new ArrayList<String>();
    knownContentConsumers.add("String_Node_Str");
    repoScanConfig.setKnownContentConsumers(knownContentConsumers);
    c.setRepositoryScanning(repoScanConfig);
    ManagedRepositoryConfiguration targetRepo = new ManagedRepositoryConfiguration();
    targetRepo.setId("String_Node_Str");
    targetRepo.setLocation("String_Node_Str");
    c.addManagedRepository(testRepo);
    c.addManagedRepository(targetRepo);
    configuration.save(c);
    when(metadataRepository.getArtifacts(TEST_REPO_ID)).thenReturn(getArtifacts());
    repositoryMerger.merge(metadataRepository, TEST_REPO_ID, "String_Node_Str");
    verify(metadataRepository).getArtifacts(TEST_REPO_ID);
}

Output:
     testRepo.setId(TEST_REPO_ID);
-    testRepo.setLocation("String_Node_Str");
+    testRepo.setLocation("String_Node_Str" + File.separatorChar + "String_Node_Str");
     RepositoryScanningConfiguration repoScanConfig = new RepositoryScanningConfiguration();


Input:
public byte[] getData() {
    byte[] result = null;
    if (!Pointer.NULL.equals(data)) {
        data.buffer(getLength()).get();
    }
    return result;
}

Output:
     if (!Pointer.NULL.equals(data)) {
-        data.buffer(getLength()).get();
+        result = data.buffer(getLength()).get();
     }


Input:
public static ArrayList<String> toHtmlList(Context context) {
    ArrayList<String> items = new ArrayList<String>();
    items.add("String_Node_Str" + PackageUtils.getVersionName(context) + "String_Node_Str");
    items.add("String_Node_Str" + DeviceUtils.getInstance().getDeviceName(context) + "String_Node_Str");
    Iterator<LogEntry> it = mLogEntries.iterator();
    while (it.hasNext()) {
        items.add(it.next().toHtml());
    }
    return items;
}

Output:
     ArrayList<String> items = new ArrayList<String>();
-    items.add("String_Node_Str" + PackageUtils.getVersionName(context) + "String_Node_Str");
-    items.add("String_Node_Str" + DeviceUtils.getInstance().getDeviceName(context) + "String_Node_Str");
+    items.add("String_Node_Str" + getAppInfoHeaderText(context) + "String_Node_Str");
+    items.add("String_Node_Str" + getDeviceInfoHeaderText(context) + "String_Node_Str");
     Iterator<LogEntry> it = mLogEntries.iterator();


Input:
private Timer getTimer() {
    synchronized (getTimerLock) {
        if (timer == null) {
            ClassLoader loader = null;
            try {
                loader = Thread.currentThread().getContextClassLoader();
                Thread.currentThread().setContextClassLoader(ConnectorRuntime.getRuntime().getConnectorClassLoader());
                timer = new Timer("String_Node_Str", true);
            } finally {
                Thread.currentThread().setContextClassLoader(loader);
            }
        }
    }
    return timer;
}

Output:
     synchronized (getTimerLock) {
-        if (timer == null) {
+        if (timer == null || timerException) {
             ClassLoader loader = null;


Input:
private void showThumbnail(int position) {
    Media[] medias = mMPM.mScene.getMediaAsArray();
    if (medias[position] != null) {
        mImageViewMedia.setVisibility(View.VISIBLE);
        mPreviewVideoView.setVisibility(View.GONE);
        mImageViewMedia.setImageBitmap(mActivity.getThumbnail(medias[position]));
        mImageViewMedia.invalidate();
    }
}

Output:
         mPreviewVideoView.setVisibility(View.GONE);
-        mImageViewMedia.setImageBitmap(mActivity.getThumbnail(medias[position]));
+        Bitmap thumb = Media.getThumbnail(mActivity, medias[position], mActivity.mMPM.mProject);
+        mImageViewMedia.setImageBitmap(thumb);
         mImageViewMedia.invalidate();


Input:
public void continueTask() {
    synchronized (this) {
        notify();
    }
    return;
}

Output:
 public void continueTask() {
-    synchronized (this) {
-        notify();
+    synchronized (lock) {
+        lock.notify();
     }


Input:
public boolean onSneakMachineActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ) {
    if (entityPlayer != null) {
        entityPlayer.openGui(ICBMSentry.INSTANCE, 1, world, x, y, z);
        return true;
    }
    return false;
}

Output:
     if (entityPlayer != null) {
-        entityPlayer.openGui(ICBMSentry.INSTANCE, 1, world, x, y, z);
+        if (!world.isRemote)
+            entityPlayer.openGui(ICBMSentry.INSTANCE, 1, world, x, y, z);
         return true;


Input:
public void update(final ModelEvent event) {
    if (event.part == ModelPart.OUTPUT || event.part == ModelPart.INPUT || event.part == ModelPart.VIEW_CONFIG) {
        if (model != null && model.getOutput() != null) {
            groupsButton.setEnabled(true);
            subsetButton.setEnabled(true);
        } else {
            groupsButton.setEnabled(false);
            subsetButton.setEnabled(false);
        }
    }
    if (event.part == ModelPart.SELECTED_ATTRIBUTE) {
        table.setAttribute(model.getSelectedAttribute());
        table.redraw();
    } else if (event.part == reset) {
        reset();
    } else if (event.part == ModelPart.MODEL) {
        model = (Model) event.data;
        reset();
    } else if (event.part == target) {
        if (event.data == null) {
            reset();
            return;
        }
        DataDefinition definition = model.getInputConfig().getInput().getDefinition();
        if (target == ModelPart.OUTPUT) {
            definition = model.getOutputConfig().getInput().getDefinition();
        }
        handle = (DataHandle) event.data;
        DataHandle data = handle;
        if (model.getViewConfig().isSubset() && model.getOutputConfig() != null && model.getOutputConfig().getConfig() != null) {
            data = handle.getView();
        }
        table.setResearchSubset(model.getInputConfig().getResearchSubset());
        table.setGroups(target == ModelPart.OUTPUT ? model.getGroups() : null);
        table.setData(data);
        table.getHeaderImages().clear();
        for (int i = 0; i < handle.getNumColumns(); i++) {
            updateHeaderImage(i, definition.getAttributeType(handle.getAttributeName(i)));
        }
        table.setEnabled(true);
        table.redraw();
    } else if (event.part == ModelPart.ATTRIBUTE_TYPE) {
        if ((model != null) && (handle != null)) {
            final String attr = (String) event.data;
            DataDefinition definition = model.getInputConfig().getInput().getDefinition();
            if (target == ModelPart.OUTPUT) {
                definition = model.getOutputConfig().getInput().getDefinition();
            }
            final int index = handle.getColumnIndexOf(attr);
            updateHeaderImage(index, definition.getAttributeType(attr));
            table.setEnabled(true);
            table.redraw();
        }
    } else if (event.part == ModelPart.RESEARCH_SUBSET) {
        table.setResearchSubset((RowSet) event.data);
        table.redraw();
    } else if (event.part == ModelPart.VIEW_CONFIG) {
        DataHandle data = handle;
        if (model.getViewConfig().isSubset() && model.getOutputConfig() != null && model.getOutputConfig().getConfig() != null) {
            data = handle.getView();
        }
        table.setGroups(target == ModelPart.OUTPUT ? model.getGroups() : null);
        table.setResearchSubset(model.getInputConfig().getResearchSubset());
        if (table.getData() != data)
            table.setData(data);
        table.redraw();
        subsetButton.setSelection(model.getViewConfig().isSubset());
    }
}

Output:
     }
-    if (event.part == ModelPart.SELECTED_ATTRIBUTE) {
-        table.setAttribute(model.getSelectedAttribute());
-        table.redraw();
-    } else if (event.part == reset) {
-        reset();
-    } else if (event.part == ModelPart.MODEL) {
+    if (event.part == ModelPart.MODEL) {
         model = (Model) event.data;


Input:
public boolean contains(String text) {
    int nodeIndex = 0;
    FastTailCharIterator it = new FastTailCharIterator(tails, -1);
    int n = text.length();
    for (int i = 0; i < n; i++) {
        char cid = charToCode[text.charAt(i)];
        if (cid == 0)
            return false;
        int next = base[nodeIndex] + cid;
        if (check[next] != nodeIndex)
            return false;
        nodeIndex = next;
        int ti = tail[nodeIndex];
        if (ti == -1)
            continue;
        it.setIndex(ti);
        char c;
        while ((c = it.getNext()) != '\0') {
            i++;
            if (i == n)
                return false;
            if (text.charAt(i) != c)
                return false;
        }
    }
    return term.get(nodeIndex);
}

Output:
         int next = base[nodeIndex] + cid;
-        if (check[next] != nodeIndex)
+        if (next < 0 || check[next] != nodeIndex)
             return false;


Input:
public ArrayList<ImagePlus> call() {
    ImagePlus[] channels = extractChannels(originalImage);
    ArrayList<ImagePlus>[] results = new ArrayList[channels.length];
    for (int ch = 0; ch < channels.length; ch++) {
        results[ch] = new ArrayList<ImagePlus>();
        final ImagePlus channel = channels[ch].duplicate();
        channel.getImageStack().addSlice("String_Node_Str", channels[ch].getImageStack().getProcessor(channels[ch].getImageStackSize()));
        channel.getImageStack().addSlice("String_Node_Str", channels[ch].getImageStack().getProcessor(1), 1);
        Calibration c = channel.getCalibration();
        c.pixelWidth = scaleFactor[0];
        c.pixelHeight = scaleFactor[1];
        c.pixelDepth = scaleFactor[2];
        final ImagePlus ip = ImageScience.computeEdgesImage(sigma, channel);
        ip.setTitle(availableFeatures[EDGES] + "String_Node_Str" + sigma);
        ip.getImageStack().deleteLastSlice();
        ip.getImageStack().deleteSlice(1);
        results[ch].add(ip);
    }
    return mergeResultChannels(results);
}

Output:
         Calibration c = channel.getCalibration();
-        c.pixelWidth = scaleFactor[0];
-        c.pixelHeight = scaleFactor[1];
-        c.pixelDepth = scaleFactor[2];
+        c.pixelWidth = 1.0 / scaleFactor[0];
+        c.pixelHeight = 1.0 / scaleFactor[1];
+        c.pixelDepth = 1.0 / scaleFactor[2];
         final ImagePlus ip = ImageScience.computeEdgesImage(sigma, channel);


Input:
private void hasValidMapping(WebBundleDescriptor descriptor, String filterName) {
    Enumeration filtermapperEnum = descriptor.getServletFilterMappingDescriptors().elements();
    if (filtermapperEnum.hasMoreElements()) {
        ServletFilterMappingDescriptor filterMapper = null;
        boolean mappingFound = false;
        do {
            filterMapper = (ServletFilterMappingDescriptor) filtermapperEnum.nextElement();
            String filterMapping = filterMapper.getName();
            mappingFound = filterName.equals(filterMapping);
        } while (!mappingFound && filtermapperEnum.hasMoreElements());
        if (mappingFound) {
            List<String> urlPatterns = filterMapper.getURLPatterns();
            for (String url : urlPatterns) {
                if (!((url.startsWith("String_Node_Str")) || ((url.startsWith("String_Node_Str")) && (url.endsWith("String_Node_Str"))) || (url.startsWith("String_Node_Str")))) {
                    addErrorDetails(result, compName);
                    result.failed(smh.getLocalString(getClass().getName() + "String_Node_Str", "String_Node_Str" + "String_Node_Str", new Object[] { filterName, url }));
                }
            }
            List<String> servletsInFilter = filterMapper.getServletNames();
            final String ALL_SERVLETS_NAME = "String_Node_Str";
            servletsInFilter.remove(ALL_SERVLETS_NAME);
            List<String> servletsInWAR = new ArrayList<String>();
            if (servletsInFilter.size() > 0) {
                Set servletDescriptor = descriptor.getServletDescriptors();
                Iterator itr = servletDescriptor.iterator();
                while (itr.hasNext()) {
                    WebComponentDescriptor servlet = (WebComponentDescriptor) itr.next();
                    servletsInWAR.add(servlet.getCanonicalName());
                }
                if (!(servletsInWAR != null && servletsInWAR.containsAll(servletsInFilter))) {
                    addErrorDetails(result, compName);
                    result.failed(smh.getLocalString(getClass().getName() + "String_Node_Str", "String_Node_Str", new Object[] { filterName }));
                }
            }
        }
    }
}

Output:
         if (mappingFound) {
-            List<String> urlPatterns = filterMapper.getURLPatterns();
+            List<String> urlPatterns = filterMapper.getUrlPatterns();
             for (String url : urlPatterns) {


Input:
public synchronized void setCommittedTx(long tx) {
    msgLog.logMessage("String_Node_Str" + tx + "String_Node_Str" + machineId);
    waitForSyncConnected();
    this.committedTx = tx;
    String root = getRoot();
    String path = root + "String_Node_Str" + machineId + "String_Node_Str" + sequenceNr;
    byte[] data = dataRepresentingMe(tx);
    try {
        zooKeeper.setData(path, data, -1);
    } catch (KeeperException e) {
        throw new ZooKeeperException("String_Node_Str", e);
    } catch (InterruptedException e) {
        Thread.interrupted();
        throw new ZooKeeperException("String_Node_Str", e);
    }
}

Output:
 public synchronized void setCommittedTx(long tx) {
-    msgLog.logMessage("String_Node_Str" + tx + "String_Node_Str" + machineId);
+    msgLog.logMessage("String_Node_Str" + tx + "String_Node_Str" + machineId, true);
     waitForSyncConnected();


Input:
private void doFinish(IPath locationPath, String fileName, String sourceFileName, IProgressMonitor monitor) {
    monitor.beginTask(CREATING + fileName, 2);
    File container = null;
    try {
        container = new File(locationPath.toString());
        if (!container.exists()) {
            container.mkdirs();
        }
    } catch (Exception e) {
        ExceptionHandler.handle(e);
    }
    if (container == null) {
        return;
    }
    final File file = new File(locationPath.toString(), fileName);
    try {
        ModuleHandle handle = SessionHandleAdapter.getInstance().getSessionHandle().openLibrary(sourceFileName);
        if (ReportPlugin.getDefault().getEnableCommentPreference()) {
            handle.setStringProperty(ModuleHandle.COMMENTS_PROP, ReportPlugin.getDefault().getCommentPreference());
        }
        if (ReportPlugin.getDefault().getDefaultUnitPreference() != null) {
            handle.setStringProperty(ModuleHandle.UNITS_PROP, ReportPlugin.getDefault().getDefaultUnitPreference());
        }
        if (inPredifinedTemplateFolder(sourceFileName)) {
            String description = handle.getDescription();
            if (description != null && description.trim().length() > 0) {
                handle.setDescription(Messages.getString(description));
            }
        }
        handle.saveAs(file.getAbsolutePath());
        handle.close();
    } catch (Exception e) {
    }
    monitor.worked(1);
    monitor.setTaskName(OPENING_FILE_FOR_EDITING);
    getShell().getDisplay().asyncExec(new Runnable() {
        public void run() {
            IWorkbench workbench = PlatformUI.getWorkbench();
            IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
            IWorkbenchPage page = window.getActivePage();
            try {
                page.openEditor(new ReportEditorInput(file), IReportEditorContants.LIBRARY_EDITOR_ID, true);
            } catch (Exception e) {
                ExceptionHandler.handle(e);
            }
        }
    });
    monitor.worked(1);
    fireLibraryChanged(fileName);
}

Output:
     try {
-        ModuleHandle handle = SessionHandleAdapter.getInstance().getSessionHandle().openLibrary(sourceFileName);
+        ModuleHandle handle = SessionHandleAdapter.getInstance().getSessionHandle().createLibraryFromTemplate(sourceFileName);
         if (ReportPlugin.getDefault().getEnableCommentPreference()) {


Input:
private void setAllSocketOptions() throws SocketException {
    for (SocketOptionSetter s : optionsToSet) {
        s.run();
    }
}

Output:
 private void setAllSocketOptions() throws SocketException {
-    for (SocketOptionSetter s : optionsToSet) {
+    for (final SocketOptionSetter s : optionsToSet) {
         s.run();


Input:
public void run() {
    UpdateSyncButtonLayout();
}

Output:
 public void run() {
-    UpdateSyncButtonLayout();
+    ((NewsReaderListActivity) getActivity()).UpdateButtonLayout();
 }