Input:
ClassDescriptor doReadClassDescriptor(final int classType) throws IOException, ClassNotFoundException {
    final ArrayList<ClassDescriptor> classCache = this.classCache;
    switch(classType) {
        case ID_REPEAT_CLASS_FAR:
            {
                return classCache.get(readInt());
            }
        case ID_REPEAT_CLASS_NEAR:
            {
                return classCache.get((readByte() | 0xffffff00) + classCache.size());
            }
        case ID_REPEAT_CLASS_NEARISH:
            {
                return classCache.get((readShort() | 0xffff0000) + classCache.size());
            }
        case ID_PREDEFINED_ENUM_TYPE_CLASS:
            {
                final int idx = classCache.size();
                classCache.add(null);
                final Class<?> type = classTable.readClass(this);
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(type, ID_ENUM_TYPE_CLASS);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_PREDEFINED_EXTERNALIZABLE_CLASS:
            {
                final int idx = classCache.size();
                classCache.add(null);
                final Class<?> type = classTable.readClass(this);
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(type, ID_EXTERNALIZABLE_CLASS);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_PREDEFINED_EXTERNALIZER_CLASS:
            {
                final int idx = classCache.size();
                classCache.add(null);
                final Class<?> type = classTable.readClass(this);
                final Externalizer externalizer = (Externalizer) readObject();
                final SimpleClassDescriptor descriptor = new ExternalizerClassDescriptor(type, externalizer);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_PREDEFINED_PLAIN_CLASS:
            {
                final int idx = classCache.size();
                classCache.add(null);
                final Class<?> type = classTable.readClass(this);
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(type, ID_PLAIN_CLASS);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_PREDEFINED_PROXY_CLASS:
            {
                final int idx = classCache.size();
                classCache.add(null);
                final Class<?> type = classTable.readClass(this);
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(type, ID_PROXY_CLASS);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_PREDEFINED_SERIALIZABLE_CLASS:
            {
                final int idx = classCache.size();
                classCache.add(null);
                final Class<?> type = classTable.readClass(this);
                final SerializableClass serializableClass = registry.lookup(type);
                int descType = serializableClass.hasWriteObject() ? ID_WRITE_OBJECT_CLASS : ID_SERIALIZABLE_CLASS;
                final ClassDescriptor descriptor = new BasicSerializableClassDescriptor(serializableClass, doReadClassDescriptor(readUnsignedByte()), serializableClass.getFields(), descType);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_PLAIN_CLASS:
            {
                final String className = readString();
                final Class<?> clazz = classResolver.resolveClass(this, className, 0L);
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(clazz, ID_PLAIN_CLASS);
                classCache.add(descriptor);
                return descriptor;
            }
        case ID_PROXY_CLASS:
            {
                String[] interfaces = new String[readInt()];
                for (int i = 0; i < interfaces.length; i++) {
                    interfaces[i] = readString();
                }
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(classResolver.resolveProxyClass(this, interfaces), ID_PROXY_CLASS);
                classCache.add(descriptor);
                return descriptor;
            }
        case ID_WRITE_OBJECT_CLASS:
        case ID_SERIALIZABLE_CLASS:
            {
                int idx = classCache.size();
                classCache.add(null);
                final String className = readString();
                final long uid = readLong();
                final Class<?> clazz = classResolver.resolveClass(this, className, uid);
                final Class<?> superClazz = clazz.getSuperclass();
                final FutureSerializableClassDescriptor descriptor = new FutureSerializableClassDescriptor(clazz, classType);
                classCache.set(idx, descriptor);
                final int cnt = readInt();
                final String[] names = new String[cnt];
                final ClassDescriptor[] descriptors = new ClassDescriptor[cnt];
                final boolean[] unshareds = new boolean[cnt];
                for (int i = 0; i < cnt; i++) {
                    names[i] = readUTF();
                    descriptors[i] = doReadClassDescriptor(readUnsignedByte());
                    unshareds[i] = readBoolean();
                }
                ClassDescriptor superDescriptor = doReadClassDescriptor(readUnsignedByte());
                if (superDescriptor != null) {
                    final Class<?> superType = superDescriptor.getType();
                    if (!superType.isAssignableFrom(clazz)) {
                        throw new InvalidClassException(clazz.getName(), "String_Node_Str");
                    }
                    Class<?> cl = superClazz;
                    while (cl != superType) {
                        superDescriptor = new SerializableGapClassDescriptor(registry.lookup(cl), superDescriptor);
                        cl = cl.getSuperclass();
                    }
                } else if (superClazz != null) {
                    Class<?> cl = superClazz;
                    while (serializabilityChecker.isSerializable(cl)) {
                        superDescriptor = new SerializableGapClassDescriptor(registry.lookup(cl), superDescriptor);
                        cl = cl.getSuperclass();
                    }
                }
                final SerializableClass serializableClass = registry.lookup(clazz);
                final SerializableField[] fields = new SerializableField[cnt];
                for (int i = 0; i < cnt; i++) {
                    fields[i] = serializableClass.getSerializableField(names[i], descriptors[i].getType(), unshareds[i]);
                }
                descriptor.setResult(new BasicSerializableClassDescriptor(serializableClass, superDescriptor, fields, classType));
                return descriptor;
            }
        case ID_EXTERNALIZABLE_CLASS:
            {
                final String className = readString();
                final long uid = readLong();
                final Class<?> clazz = classResolver.resolveClass(this, className, uid);
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(clazz, ID_EXTERNALIZABLE_CLASS);
                classCache.add(descriptor);
                return descriptor;
            }
        case ID_EXTERNALIZER_CLASS:
            {
                final String className = readString();
                int idx = classCache.size();
                classCache.add(null);
                final Class<?> clazz = classResolver.resolveClass(this, className, 0L);
                final Externalizer externalizer = (Externalizer) readObject();
                final SimpleClassDescriptor descriptor = new ExternalizerClassDescriptor(clazz, externalizer);
                classCache.set(idx, descriptor);
                return descriptor;
            }
        case ID_ENUM_TYPE_CLASS:
            {
                final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(classResolver.resolveClass(this, readString(), 0L), ID_ENUM_TYPE_CLASS);
                classCache.add(descriptor);
                return descriptor;
            }
        case ID_OBJECT_ARRAY_TYPE_CLASS:
            {
                final ClassDescriptor elementType = doReadClassDescriptor(readUnsignedByte());
                final SimpleClassDescriptor arrayDescriptor = new SimpleClassDescriptor(Array.newInstance(elementType.getType(), 0).getClass(), ID_OBJECT_ARRAY_TYPE_CLASS);
                classCache.add(arrayDescriptor);
                return arrayDescriptor;
            }
        case ID_CC_ARRAY_LIST:
            {
                return ClassDescriptors.CC_ARRAY_LIST;
            }
        case ID_CC_LINKED_LIST:
            {
                return ClassDescriptors.CC_LINKED_LIST;
            }
        case ID_CC_HASH_SET:
            {
                return ClassDescriptors.CC_HASH_SET;
            }
        case ID_CC_LINKED_HASH_SET:
            {
                return ClassDescriptors.CC_LINKED_HASH_SET;
            }
        case ID_CC_TREE_SET:
            {
                return ClassDescriptors.CC_TREE_SET;
            }
        case ID_CC_IDENTITY_HASH_MAP:
            {
                return ClassDescriptors.CC_IDENTITY_HASH_MAP;
            }
        case ID_CC_HASH_MAP:
            {
                return ClassDescriptors.CC_HASH_MAP;
            }
        case ID_CC_HASHTABLE:
            {
                return ClassDescriptors.CC_HASHTABLE;
            }
        case ID_CC_LINKED_HASH_MAP:
            {
                return ClassDescriptors.CC_LINKED_HASH_MAP;
            }
        case ID_CC_TREE_MAP:
            {
                return ClassDescriptors.CC_TREE_MAP;
            }
        case ID_CC_ENUM_SET:
            {
                return ClassDescriptors.CC_ENUM_SET;
            }
        case ID_CC_ENUM_MAP:
            {
                return ClassDescriptors.CC_ENUM_MAP;
            }
        case ID_ABSTRACT_COLLECTION:
            {
                return ClassDescriptors.ABSTRACT_COLLECTION;
            }
        case ID_ABSTRACT_LIST:
            {
                return ClassDescriptors.ABSTRACT_LIST;
            }
        case ID_ABSTRACT_QUEUE:
            {
                return ClassDescriptors.ABSTRACT_QUEUE;
            }
        case ID_ABSTRACT_SEQUENTIAL_LIST:
            {
                return ClassDescriptors.ABSTRACT_SEQUENTIAL_LIST;
            }
        case ID_ABSTRACT_SET:
            {
                return ClassDescriptors.ABSTRACT_SET;
            }
        case ID_CC_CONCURRENT_HASH_MAP:
            {
                return ClassDescriptors.CONCURRENT_HASH_MAP;
            }
        case ID_CC_COPY_ON_WRITE_ARRAY_LIST:
            {
                return ClassDescriptors.COPY_ON_WRITE_ARRAY_LIST;
            }
        case ID_CC_COPY_ON_WRITE_ARRAY_SET:
            {
                return ClassDescriptors.COPY_ON_WRITE_ARRAY_SET;
            }
        case ID_CC_VECTOR:
            {
                return ClassDescriptors.VECTOR;
            }
        case ID_CC_STACK:
            {
                return ClassDescriptors.STACK;
            }
        case ID_CC_ARRAY_DEQUE:
            {
                return ClassDescriptors.ARRAY_DEQUE;
            }
        case ID_CC_NCOPIES:
            {
                return ClassDescriptors.NCOPIES;
            }
        case ID_SINGLETON_MAP_OBJECT:
            {
                return ClassDescriptors.SINGLETON_MAP;
            }
        case ID_SINGLETON_SET_OBJECT:
            {
                return ClassDescriptors.SINGLETON_SET;
            }
        case ID_SINGLETON_LIST_OBJECT:
            {
                return ClassDescriptors.SINGLETON_LIST;
            }
        case ID_EMPTY_MAP_OBJECT:
            {
                return ClassDescriptors.EMPTY_MAP;
            }
        case ID_EMPTY_SET_OBJECT:
            {
                return ClassDescriptors.EMPTY_SET;
            }
        case ID_EMPTY_LIST_OBJECT:
            {
                return ClassDescriptors.EMPTY_LIST;
            }
        case ID_REVERSE_ORDER_OBJECT:
            {
                return ClassDescriptors.REVERSE_ORDER;
            }
        case ID_REVERSE_ORDER2_OBJECT:
            {
                return ClassDescriptors.REVERSE_ORDER2;
            }
        case ID_PAIR:
            {
                return ClassDescriptors.PAIR;
            }
        case ID_STRING_CLASS:
            {
                return ClassDescriptors.STRING_DESCRIPTOR;
            }
        case ID_OBJECT_CLASS:
            {
                return ClassDescriptors.OBJECT_DESCRIPTOR;
            }
        case ID_CLASS_CLASS:
            {
                return ClassDescriptors.CLASS_DESCRIPTOR;
            }
        case ID_ENUM_CLASS:
            {
                return ClassDescriptors.ENUM_DESCRIPTOR;
            }
        case ID_BOOLEAN_ARRAY_CLASS:
            {
                return ClassDescriptors.BOOLEAN_ARRAY;
            }
        case ID_BYTE_ARRAY_CLASS:
            {
                return ClassDescriptors.BYTE_ARRAY;
            }
        case ID_SHORT_ARRAY_CLASS:
            {
                return ClassDescriptors.SHORT_ARRAY;
            }
        case ID_INT_ARRAY_CLASS:
            {
                return ClassDescriptors.INT_ARRAY;
            }
        case ID_LONG_ARRAY_CLASS:
            {
                return ClassDescriptors.LONG_ARRAY;
            }
        case ID_CHAR_ARRAY_CLASS:
            {
                return ClassDescriptors.CHAR_ARRAY;
            }
        case ID_FLOAT_ARRAY_CLASS:
            {
                return ClassDescriptors.FLOAT_ARRAY;
            }
        case ID_DOUBLE_ARRAY_CLASS:
            {
                return ClassDescriptors.DOUBLE_ARRAY;
            }
        case ID_PRIM_BOOLEAN:
            {
                return ClassDescriptors.BOOLEAN;
            }
        case ID_PRIM_BYTE:
            {
                return ClassDescriptors.BYTE;
            }
        case ID_PRIM_CHAR:
            {
                return ClassDescriptors.CHAR;
            }
        case ID_PRIM_DOUBLE:
            {
                return ClassDescriptors.DOUBLE;
            }
        case ID_PRIM_FLOAT:
            {
                return ClassDescriptors.FLOAT;
            }
        case ID_PRIM_INT:
            {
                return ClassDescriptors.INT;
            }
        case ID_PRIM_LONG:
            {
                return ClassDescriptors.LONG;
            }
        case ID_PRIM_SHORT:
            {
                return ClassDescriptors.SHORT;
            }
        case ID_VOID:
            {
                return ClassDescriptors.VOID;
            }
        case ID_BOOLEAN_CLASS:
            {
                return ClassDescriptors.BOOLEAN_OBJ;
            }
        case ID_BYTE_CLASS:
            {
                return ClassDescriptors.BYTE_OBJ;
            }
        case ID_SHORT_CLASS:
            {
                return ClassDescriptors.SHORT_OBJ;
            }
        case ID_INTEGER_CLASS:
            {
                return ClassDescriptors.INTEGER_OBJ;
            }
        case ID_LONG_CLASS:
            {
                return ClassDescriptors.LONG_OBJ;
            }
        case ID_CHARACTER_CLASS:
            {
                return ClassDescriptors.CHARACTER_OBJ;
            }
        case ID_FLOAT_CLASS:
            {
                return ClassDescriptors.FLOAT_OBJ;
            }
        case ID_DOUBLE_CLASS:
            {
                return ClassDescriptors.DOUBLE_OBJ;
            }
        case ID_VOID_CLASS:
            {
                return ClassDescriptors.VOID_OBJ;
            }
        default:
            {
                throw new InvalidClassException("String_Node_Str" + classType);
            }
    }
}

Output:
                 final SimpleClassDescriptor descriptor = new SimpleClassDescriptor(classResolver.resolveProxyClass(this, interfaces), ID_PROXY_CLASS);
-                classCache.add(descriptor);
+                classCache.set(idx, descriptor);
                 return descriptor;


Input:
public Item createItem(ModelElement element) {
    Item item = null;
    if (ModelElementIdentifier.isAnalysis(element)) {
        item = PropertiesFactory.eINSTANCE.createTDQAnalysisItem();
    } else if (ModelElementIdentifier.isDQRule(element)) {
        item = PropertiesFactory.eINSTANCE.createTDQBusinessRuleItem();
    } else if (ModelElementIdentifier.isDataProvider(element)) {
        if (element instanceof DatabaseConnection) {
            item = org.talend.core.model.properties.PropertiesFactory.eINSTANCE.createDatabaseConnectionItem();
        } else if (element instanceof MDMConnection) {
            item = org.talend.core.model.properties.PropertiesFactory.eINSTANCE.createMDMConnectionItem();
        }
        ((ConnectionItem) item).setConnection((Connection) element);
    } else if (ModelElementIdentifier.isID(element)) {
        item = PropertiesFactory.eINSTANCE.createTDQIndicatorDefinitionItem();
    } else if (ModelElementIdentifier.isPattern(element)) {
        item = PropertiesFactory.eINSTANCE.createTDQPatternItem();
    } else if (ModelElementIdentifier.isReport(element)) {
        item = PropertiesFactory.eINSTANCE.createTDQReportItem();
    } else {
        item = org.talend.core.model.properties.PropertiesFactory.eINSTANCE.createTDQItem();
    }
    ItemState itemState = org.talend.core.model.properties.PropertiesFactory.eINSTANCE.createItemState();
    itemState.setDeleted(false);
    item.setState(itemState);
    Resource eResource = element.eResource();
    if (eResource != null) {
        URI uri = eResource.getURI();
        if (item instanceof TDQItem) {
            ((TDQItem) item).setFilename(uri.lastSegment());
        }
        if (uri.isPlatform()) {
            IPath elementPath = new Path(uri.toPlatformString(true)).removeLastSegments(1);
            IPath typedPath = ResourceManager.getRootProject().getFullPath().append(PropertyHelper.getItemTypedPath(item));
            IPath statePath = elementPath.makeRelativeTo(typedPath);
            itemState.setPath(statePath.toString());
        }
    }
    return item;
}

Output:
         if (item instanceof TDQItem) {
-            ((TDQItem) item).setFilename(uri.lastSegment());
+            ((TDQItem) item).setFilename(URI.decode(uri.lastSegment()));
         }


Input:
public void installComponents() {
    jLayeredPane.setOpaque(false);
    jLayeredPane.add(abilityPicker);
    jLayeredPane.add(DialogManager.getManager(), JLayeredPane.MODAL_LAYER, 0);
    abilityPicker.setVisible(false);
}

Output:
     jLayeredPane.add(abilityPicker);
-    jLayeredPane.add(DialogManager.getManager(), JLayeredPane.MODAL_LAYER, 0);
+    jLayeredPane.add(DialogManager.getManager(gameId), JLayeredPane.MODAL_LAYER, 0);
     abilityPicker.setVisible(false);


Input:
public static void execThreadOutput(final String cmd) throws IOException {
    logger.fine("String_Node_Str" + Thread.currentThread().getId() + "String_Node_Str" + cmd);
    final long startTime = System.currentTimeMillis();
    Process p = Runtime.getRuntime().exec(cmd);
    final BufferedReader stdr = new BufferedReader(new InputStreamReader(p.getInputStream()));
    final BufferedReader errr = new BufferedReader(new InputStreamReader(p.getErrorStream()));
    new Thread(new ProcessThreadOutput(stdr, System.out)).run();
    new Thread(new ProcessThreadOutput(errr, System.err)).run();
    logEndTime(p, cmd, startTime);
}

Output:
     new Thread(new ProcessThreadOutput(errr, System.err)).run();
-    logEndTime(p, cmd, startTime);
+    logEndTime(p, Joiner.on(' ').join(cmd), startTime);
 }


Input:
public static void init() {
    if (consumerKey == null) {
        System.out.println("String_Node_Str");
        return;
    }
    ConfigurationBuilder cb = new ConfigurationBuilder();
    try {
        cb.setDebugEnabled(true).setOAuthConsumerKey(Encryption.decrypt(consumerKey)).setOAuthConsumerSecret(Encryption.decrypt(consumerSecret)).setOAuthAccessToken(Encryption.decrypt(accessToken)).setOAuthAccessTokenSecret(Encryption.decrypt(accessSecret));
    } catch (GeneralSecurityException | IOException generalSecurityException) {
    }
    TwitterFactory tf = new TwitterFactory(cb.build());
    twitter = tf.getInstance();
    try {
        List<Status> statuses = twitter.getUserTimeline(TWITTERHANDLE);
        officialPAXTwitterID = statuses.get(0).getUser().getId();
    } catch (Exception ex) {
        System.out.println("String_Node_Str");
    }
    System.out.println("String_Node_Str");
}

Output:
 public static void init() {
-    if (consumerKey == null) {
+    if (consumerKey == null || consumerSecret == null || accessToken == null || accessSecret == null) {
         System.out.println("String_Node_Str");


Input:
boolean startCleanup(boolean forced) {
    final long now = Clock.currentTimeMillis();
    long dirtyAge = (now - lastCleanup);
    boolean shouldRun = forced || (store != null && dirty && dirtyAge >= writeDelayMillis) || (dirtyAge > cleanupDelayMillis);
    if (shouldRun && cleanupActive.compareAndSet(false, true)) {
        lastCleanup = now;
        try {
            if (nearCache != null) {
                nearCache.evict(now, false);
            }
            dirty = false;
            final Set<Record> recordsDirty = new HashSet<Record>();
            final Set<Record> recordsUnknown = new HashSet<Record>();
            final Set<Record> recordsToPurge = new HashSet<Record>();
            final Set<Record> recordsToEvict = new HashSet<Record>();
            final Set<Record> sortedRecords = new TreeSet<Record>(new ComparatorWrapper(evictionComparator));
            final Collection<Record> records = mapRecords.values();
            final boolean overCapacity = overCapacity();
            final boolean evictionAware = evictionComparator != null && overCapacity;
            int recordsStillOwned = 0;
            int backupPurgeCount = 0;
            long costOfRecords = 0L;
            PartitionManager partitionManager = concurrentMapManager.partitionManager;
            for (Record record : records) {
                PartitionInfo partition = partitionManager.getPartition(record.getBlockId());
                Address owner = partition.getOwner();
                boolean owned = (owner != null && thisAddress.equals(owner));
                boolean ownedOrBackup = partition.isOwnerOrBackup(thisAddress, getTotalBackupCount());
                if (owner != null && !partitionManager.isPartitionMigrating(partition.getPartitionId())) {
                    if (owned) {
                        if (store != null && mapStoreWrapper.isEnabled() && writeDelayMillis > 0 && record.isDirty()) {
                            if (now > record.getWriteTime()) {
                                recordsDirty.add(record);
                                record.setDirty(false);
                            } else {
                                dirty = true;
                            }
                        } else if (shouldPurgeRecord(record, now)) {
                            recordsToPurge.add(record);
                        } else if (record.isActive() && !record.isValid(now)) {
                            recordsToEvict.add(record);
                        } else if (evictionAware && record.isActive() && record.isEvictable()) {
                            sortedRecords.add(record);
                            recordsStillOwned++;
                        }
                        if (record.isActive() && record.isValid(now)) {
                            costOfRecords += record.getCost();
                        }
                    } else if (ownedOrBackup) {
                        if (shouldPurgeRecord(record, now)) {
                            recordsToPurge.add(record);
                            backupPurgeCount++;
                        }
                    } else {
                        recordsUnknown.add(record);
                    }
                }
            }
            totalCostOfRecords = costOfRecords;
            if (evictionAware && (forced || overCapacity)) {
                int numberOfRecordsToEvict = (int) (recordsStillOwned * evictionRate);
                int evictedCount = 0;
                for (Record record : sortedRecords) {
                    if (record.isActive() && record.isEvictable()) {
                        recordsToEvict.add(record);
                        if (++evictedCount >= numberOfRecordsToEvict) {
                            break;
                        }
                    }
                }
            }
            Level levelLog = (concurrentMapManager.LOG_STATE) ? Level.INFO : Level.FINEST;
            if (logger.isLoggable(levelLog)) {
                logger.log(levelLog, name + "String_Node_Str" + "String_Node_Str" + recordsDirty.size() + "String_Node_Str" + recordsToPurge.size() + "String_Node_Str" + recordsToEvict.size() + "String_Node_Str" + recordsUnknown.size() + "String_Node_Str" + recordsStillOwned + "String_Node_Str" + backupPurgeCount);
                logger.log(levelLog, thisAddress + "String_Node_Str" + mapRecords.size() + "String_Node_Str" + mapIndexService.getOwnedRecords().size() + "String_Node_Str" + costOfRecords);
            }
            executeStoreUpdate(recordsDirty);
            executeEviction(recordsToEvict);
            executePurge(recordsToPurge);
            executePurgeUnknowns(recordsUnknown);
        } finally {
            cleanupActive.set(false);
        }
        return true;
    } else {
        return false;
    }
}

Output:
     long dirtyAge = (now - lastCleanup);
-    boolean shouldRun = forced || (store != null && dirty && dirtyAge >= writeDelayMillis) || (dirtyAge > cleanupDelayMillis);
+    boolean shouldRun = forced || (store != null && mapStoreWrapper.isEnabled() && dirty && dirtyAge >= writeDelayMillis) || (dirtyAge > cleanupDelayMillis);
     if (shouldRun && cleanupActive.compareAndSet(false, true)) {


Input:
private void createSimpleTable2(final ScrolledForm form, final Composite composite, final SimpleStatIndicator simpleStatIndicator) {
    List<IndicatorUnit> units = new ArrayList<IndicatorUnit>();
    units.add(new IndicatorUnit(IndicatorEnum.RowCountIndicatorEnum, masterPage.getSimpleStatIndicator().getRowCountIndicator(), null));
    units.add(new IndicatorUnit(IndicatorEnum.DistinctCountIndicatorEnum, masterPage.getSimpleStatIndicator().getDistinctCountIndicator(), null));
    units.add(new IndicatorUnit(IndicatorEnum.DuplicateCountIndicatorEnum, masterPage.getSimpleStatIndicator().getDuplicateCountIndicator(), null));
    units.add(new IndicatorUnit(IndicatorEnum.UniqueIndicatorEnum, masterPage.getSimpleStatIndicator().getUniqueCountIndicator(), null));
    EIndicatorChartType simpleStatType = EIndicatorChartType.SIMPLE_STATISTICS;
    IChartTypeStates chartTypeState = ChartTypeStatesOperator.getChartState(simpleStatType, units);
    ChartWithData chartData = new ChartWithData(simpleStatType, chartTypeState.getChart(), chartTypeState.getDataEntity());
    TableViewer tableviewer = chartTypeState.getTableForm(composite);
    tableviewer.setInput(chartData);
    DataExplorer dataExplorer = chartTypeState.getDataExplorer();
    ChartTableFactory.addMenuAndTip(tableviewer, dataExplorer, masterPage.getAnalysis());
    JFreeChart chart = chartTypeState.getChart();
    ChartDecorator.decorate(chart);
    if (chart != null) {
        ChartComposite cc = new ChartComposite(composite, SWT.NONE, chart, true);
        GridData gd = new GridData();
        gd.widthHint = PluginConstant.CHART_STANDARD_WIDHT;
        gd.heightHint = PluginConstant.CHART_STANDARD_HEIGHT;
        cc.setLayoutData(gd);
    }
}

Output:
     tableviewer.setInput(chartData);
-    DataExplorer dataExplorer = chartTypeState.getDataExplorer();
-    ChartTableFactory.addMenuAndTip(tableviewer, dataExplorer, masterPage.getAnalysis());
+    TableUtils.addTooltipOnTableItem(tableviewer.getTable());
     JFreeChart chart = chartTypeState.getChart();


Input:
public Weighting createWeighting(HintsMap hintsMap, FlagEncoder encoder, Graph graph, GraphHopperStorage graphStorage) {
    if (weightingFactory != null) {
        return weightingFactory.createWeighting(hintsMap, encoder, graph, locationIndex, graphStorage);
    }
    String weightingStr = hintsMap.getWeighting().toLowerCase();
    Weighting weighting = null;
    if (encoder.supports(GenericWeighting.class)) {
        weighting = new GenericWeighting((DataFlagEncoder) encoder, hintsMap);
    } else if ("String_Node_Str".equalsIgnoreCase(weightingStr)) {
        weighting = new ShortestWeighting(encoder);
    } else if ("String_Node_Str".equalsIgnoreCase(weightingStr) || weightingStr.isEmpty()) {
        if (encoder.supports(PriorityWeighting.class))
            weighting = new PriorityWeighting(encoder, hintsMap);
        else
            weighting = new FastestWeighting(encoder, hintsMap);
    } else if ("String_Node_Str".equalsIgnoreCase(weightingStr)) {
        if (encoder.supports(CurvatureWeighting.class))
            weighting = new CurvatureWeighting(encoder, hintsMap);
    } else if ("String_Node_Str".equalsIgnoreCase(weightingStr)) {
        weighting = new ShortFastestWeighting(encoder, hintsMap);
    }
    if (weighting == null)
        throw new IllegalArgumentException("String_Node_Str" + weighting + "String_Node_Str");
    if (hintsMap.has(Routing.BLOCK_AREA)) {
        String blockAreaStr = hintsMap.get(Parameters.Routing.BLOCK_AREA, "String_Node_Str");
        GraphEdgeIdFinder.BlockArea blockArea = new GraphEdgeIdFinder(graph, locationIndex).parseBlockArea(blockAreaStr, new DefaultEdgeFilter(encoder));
        return new BlockAreaWeighting(weighting, blockArea);
    }
    return weighting;
}

Output:
     if (weightingFactory != null) {
-        return weightingFactory.createWeighting(hintsMap, encoder, graph, locationIndex, graphStorage);
+        return weightingFactory.createWeighting(hintsMap, tMode, encoder, graph, locationIndex, graphStorage);
     }


Input:
public synchronized void uncaughtException(final Thread t, final Throwable e) {
    report.append("String_Node_Str");
    report.append("String_Node_Str" + getTotalInternalMemorySize() + "String_Node_Str");
    report.append("String_Node_Str" + getAvailableInternalMemorySize() + "String_Node_Str");
    report.append("String_Node_Str");
    final Writer result = new StringWriter();
    final PrintWriter printWriter = new PrintWriter(result);
    e.printStackTrace(printWriter);
    final String stacktrace = result.toString();
    report.append(stacktrace + "String_Node_Str");
    Throwable cause = e.getCause();
    while (cause != null) {
        cause.printStackTrace(printWriter);
        report.append("String_Node_Str");
        report.append(result.toString() + "String_Node_Str");
        cause = cause.getCause();
    }
    printWriter.close();
    report.append("String_Node_Str" + filesDir + "String_Node_Str");
    appendReport(report, filesDir, 0);
    report.append("String_Node_Str" + cacheDir + "String_Node_Str");
    appendReport(report, cacheDir, 0);
    Process process = null;
    try {
        process = Runtime.getRuntime().exec("String_Node_Str");
        final BufferedReader logReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        report.append('\n');
        String line;
        while ((line = logReader.readLine()) != null) report.append(line).append('\n');
        logReader.close();
    } catch (final IOException x) {
        x.printStackTrace();
    } finally {
        if (process != null)
            process.destroy();
    }
    saveAsFile(report.toString());
    previousHandler.uncaughtException(t, e);
}

Output:
         logReader.close();
-    } catch (final IOException x) {
+        saveAsFile(report.toString());
+    } catch (final Exception x) {
         x.printStackTrace();


Input:
private Object evaluteFilterExpression(Context cx, IFilterDefinition filter) throws DataException {
    IBaseExpression expr = filter.getExpression();
    FilterUtil.prepareFilterExpression(expr, filterPass);
    Object result = ScriptEvalUtil.evalExpr(expr, cx, this.groupProcessor.getExpressionProcessor().getScope(), "String_Node_Str", 0);
    if (result == null) {
        Object info = null;
        if (expr instanceof IScriptExpression)
            info = ((IScriptExpression) expr).getText();
        else
            info = expr;
        throw new DataException(ResourceConstants.INVALID_EXPRESSION_IN_FILTER, info);
    }
    return result;
}

Output:
     IBaseExpression expr = filter.getExpression();
-    FilterUtil.prepareFilterExpression(expr, filterPass);
+    FilterUtil.prepareFilterExpression(expr, filterPass, this.populator.getEventHandler().getExecutorHelper());
     Object result = ScriptEvalUtil.evalExpr(expr, cx, this.groupProcessor.getExpressionProcessor().getScope(), "String_Node_Str", 0);


Input:
public void processJoinedMappings(AbstractSession session) {
    Set<String> fetchGroupAttributes = null;
    FetchGroup fetchGroup = getBaseQuery().getExecutionFetchGroup();
    if (fetchGroup != null) {
        fetchGroupAttributes = fetchGroup.getAttributeNames();
    }
    ObjectBuilder objectBuilder = getDescriptor().getObjectBuilder();
    if (objectBuilder.hasJoinedAttributes()) {
        List mappingJoinedAttributes = objectBuilder.getJoinedAttributes();
        if (!hasJoinedAttributeExpressions()) {
            for (int i = 0; i < mappingJoinedAttributes.size(); i++) {
                ForeignReferenceMapping mapping = (ForeignReferenceMapping) mappingJoinedAttributes.get(i);
                if (fetchGroupAttributes == null || fetchGroupAttributes.contains(mapping.getAttributeName())) {
                    Expression expression = addJoinedMapping(mapping);
                    if (expression != null) {
                        prepareJoinExpression(expression, session);
                    }
                }
            }
        } else {
            for (int i = 0; i < mappingJoinedAttributes.size(); i++) {
                ForeignReferenceMapping mapping = (ForeignReferenceMapping) mappingJoinedAttributes.get(i);
                if (!isAttributeExpressionJoined(mapping)) {
                    if (fetchGroupAttributes == null || fetchGroupAttributes.contains(mapping.getAttributeName())) {
                        Expression expression = addJoinedMapping(mapping);
                        if (expression != null) {
                            prepareJoinExpression(expression, session);
                        }
                    }
                }
            }
        }
    }
}

Output:
                 if (fetchGroupAttributes == null || fetchGroupAttributes.contains(mapping.getAttributeName())) {
-                    Expression expression = addJoinedMapping(mapping);
-                    if (expression != null) {
-                        prepareJoinExpression(expression, session);
-                    }
+                    addAndPrepareJoinedMapping(mapping, session);
                 }


Input:
public boolean parse(MarkerList markers, TokenIterator tokens, Parser parser) {
    this.tokens = tokens;
    this.parser = parser;
    this.skip = 0;
    this.reparse = false;
    this.markers = markers;
    this.syntaxErrors = false;
    IToken token = null, prev = null;
    tokens.reset();
    while (tokens.hasNext()) {
        token = tokens.next();
        token.setPrev(prev);
        prev = token;
    }
    if (prev == null) {
        return false;
    }
    int type = prev.type();
    if (!ParserUtil.isSeperator(type) && type != (Tokens.IDENTIFIER | Tokens.MOD_SYMBOL)) {
        IToken semicolon = new InferredSemicolon(prev.endLine(), prev.endIndex());
        semicolon.setPrev(prev);
        prev.setNext(semicolon);
    }
    tokens.reset();
    while (true) {
        if (this.reparse) {
            this.reparse = false;
        } else {
            token = tokens.next();
            if (token == null) {
                break;
            }
        }
        if (this.skip > 0) {
            this.skip--;
            continue;
        }
        try {
            this.parser.parse(this, token);
        } catch (Exception ex) {
            ex.printStackTrace();
            return false;
        }
        if (this.parser == null || this.syntaxErrors && this.markers == null) {
            break;
        }
        if (DyvilCompiler.parseStack) {
            System.out.println(token + "String_Node_Str" + this.parser.getName() + "String_Node_Str" + this.parser.getMode());
        }
    }
    return !this.syntaxErrors;
}

Output:
     tokens.reset();
-    while (true) {
-        if (this.reparse) {
-            this.reparse = false;
-        } else {
-            token = tokens.next();
-            if (token == null) {
-                break;
-            }
-        }
-        if (this.skip > 0) {
-            this.skip--;
-            continue;
-        }
-        try {
-            this.parser.parse(this, token);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            return false;
-        }
-        if (this.parser == null || this.syntaxErrors && this.markers == null) {
-            break;
-        }
-        if (DyvilCompiler.parseStack) {
-            System.out.println(token + "String_Node_Str" + this.parser.getName() + "String_Node_Str" + this.parser.getMode());
-        }
-    }
+    super.parse(tokens);
     return !this.syntaxErrors;


Input:
public String doSelection(String input) {
    String retValue = null;
    if (dataSetHandle != null || designHandle instanceof TabularCubeHandle || designHandle instanceof TabularHierarchyHandle) {
        DataSetHandle dataSet = null;
        if (dataSetHandle != null) {
            dataSet = dataSetHandle;
        } else {
            if (designHandle instanceof TabularCubeHandle) {
                dataSet = ((TabularCubeHandle) designHandle).getDataSet();
            } else {
                dataSet = ((TabularHierarchyHandle) designHandle).getDataSet();
            }
        }
        try {
            List selectValueList = dataSetHandle != null ? SelectValueFetcher.getSelectValueList(ExpressionButtonUtil.getExpression(expression), dataSet, false) : SelectValueFetcher.getSelectValueFromBinding(ExpressionButtonUtil.getExpression(expression), dataSet, DEUtil.getVisiableColumnBindingsList(designHandle).iterator(), false);
            SelectValueDialog dialog = new SelectValueDialog(PlatformUI.getWorkbench().getDisplay().getActiveShell(), Messages.getString("String_Node_Str"));
            dialog.setSelectedValueList(selectValueList);
            if (dialog.open() == IDialogConstants.OK_ID) {
                retValue = dialog.getSelectedExprValue();
            }
        } catch (BirtException e1) {
            MessageDialog.openError(null, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str") + "String_Node_Str" + e1.getMessage());
        }
    } else {
        for (Iterator iter = columnList.iterator(); iter.hasNext(); ) {
            String columnName = getColumnName(iter.next());
            Expression expr = ExpressionButtonUtil.getExpression(expression);
            if (expr != null) {
                String exprType = expr.getType();
                IExpressionConverter converter = ExpressionUtility.getExpressionConverter(exprType);
                if (expression.getText().equals(ExpressionUtility.getColumnExpression(columnName, converter))) {
                    bindingName = columnName;
                    break;
                }
            }
        }
        if (bindingName == null && expression.getText().trim().length() > 0)
            bindingName = expression.getText().trim();
        if (bindingName != null) {
            try {
                List selectValueList = getSelectValueList();
                SelectValueDialog dialog = new SelectValueDialog(PlatformUI.getWorkbench().getDisplay().getActiveShell(), Messages.getString("String_Node_Str"));
                dialog.setSelectedValueList(selectValueList);
                if (bindingParams != null) {
                    dialog.setBindingParams(bindingParams);
                }
                if (dialog.open() == IDialogConstants.OK_ID) {
                    retValue = dialog.getSelectedExprValue();
                }
            } catch (Exception ex) {
                MessageDialog.openError(null, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str") + "String_Node_Str" + ex.getMessage());
            }
        } else {
            MessageDialog.openInformation(null, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
        }
    }
    return retValue;
}

Output:
         try {
-            List selectValueList = dataSetHandle != null ? SelectValueFetcher.getSelectValueList(ExpressionButtonUtil.getExpression(expression), dataSet, false) : SelectValueFetcher.getSelectValueFromBinding(ExpressionButtonUtil.getExpression(expression), dataSet, DEUtil.getVisiableColumnBindingsList(designHandle).iterator(), false);
+            List selectValueList = dataSetHandle != null ? SelectValueFetcher.getSelectValueList(ExpressionButtonUtil.getExpression(expression), dataSet, false) : SelectValueFetcher.getSelectValueFromBinding(ExpressionButtonUtil.getExpression(expression), dataSet, DEUtil.getVisiableColumnBindingsList(designHandle).iterator(), DEUtil.getGroups(designHandle).iterator(), false);
             SelectValueDialog dialog = new SelectValueDialog(PlatformUI.getWorkbench().getDisplay().getActiveShell(), Messages.getString("String_Node_Str"));


Input:
public void selectDay(int dayOfMonth) {
    clearSelectedDay();
    selectedDay = dayOfMonth + 6 + startingDayOfWeek;
    if (Utils.isWeekOfYearEnabled()) {
        selectedDay = selectedDay + selectedDay / 7 + 1;
    }
    notifyItemChanged(selectedDay);
}

Output:
 public void selectDay(int dayOfMonth) {
-    clearSelectedDay();
+    int prevDay = selectedDay;
+    selectedDay = -1;
+    notifyItemChanged(prevDay);
+    if (dayOfMonth == -1) {
+        return;
+    }
     selectedDay = dayOfMonth + 6 + startingDayOfWeek;


Input:
private void standardiseStatusLabels(List<Label> ghLabels) {
    List<String> defaultStatuses = Defaults.getDefaultStatusLabels();
    List<String> projectLabels = new ArrayList<String>();
    ghLabels.stream().forEach(label -> projectLabels.add(label.getName()));
    defaultStatuses.removeAll(projectLabels);
    for (String standardStatus : defaultStatuses) {
        Label statusLabel = new Label();
        statusLabel.setName(standardStatus);
        if (standardStatus.endsWith("String_Node_Str") || standardStatus.endsWith("String_Node_Str") || standardStatus.endsWith("String_Node_Str") || standardStatus.endsWith("String_Node_Str")) {
            statusLabel.setColor("String_Node_Str");
        } else {
            statusLabel.setColor("String_Node_Str");
        }
        try {
            ghLabels.add(ServiceManager.getInstance().createLabel(statusLabel));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:
     List<String> projectLabels = new ArrayList<String>();
-    ghLabels.stream().forEach(label -> projectLabels.add(label.getName()));
+    for (Label label : ghLabels) {
+        projectLabels.add(label.getName());
+    }
     defaultStatuses.removeAll(projectLabels);


Input:
public int save() {
    if (StringUtils.isEmpty(mFormFilePath)) {
        throw new SQLException("String_Node_Str");
    }
    if (mDate == -1) {
        mDate = System.currentTimeMillis();
    }
    if (mDisplaySubtext == null) {
        mDisplaySubtext = getDisplaySubtext();
    }
    File form = new File(mFormFilePath);
    if (StringUtils.isEmpty(mDisplayName)) {
        mDisplayName = form.getName();
    }
    mMd5Hash = FileUtil.getMd5Hash(form);
    if (StringUtils.isEmpty(mJrcacheFilePath)) {
        mJrcacheFilePath = getCachePath(mMd5Hash);
    }
    if (StringUtils.isEmpty(mFormMediaPath)) {
        mFormMediaPath = getMediaPath(mFormFilePath);
    }
    getFormDefStorage().write(this);
    if (recordId == -1) {
        throw new SQLException("String_Node_Str" + toString());
    }
    return recordId;
}

Output:
     }
-    if (mDate == -1) {
-        mDate = System.currentTimeMillis();
+    if (mDate == null) {
+        mDate = new Date();
     }


Input:
public static IResultObject readResultObject(DataInputStream dis, IResultClass rsMeta, int count, Map<String, StringTable> stringTableMap, Map<String, DataSetInMemoryStringIndex> index) throws DataException {
    int i = 0;
    try {
        Object[] obs = new Object[rsMeta.getFieldCount()];
        for (i = 0; i < count; i++) {
            if (rsMeta.isIndexColumn(i + 1)) {
                obs[i] = IOUtil.readObject(dis, DataEngineSession.getCurrentClassLoader());
                if (index.containsKey(rsMeta.getFieldName(i + 1))) {
                    obs[i] = index.get(rsMeta.getFieldName(i + 1)).getKeyValue(obs[i]);
                }
            } else if (rsMeta.getFieldMetaData(i + 1).getDataType() == String.class && rsMeta.isCompressedColumn(i + 1)) {
                StringTable stringTable = null;
                if (stringTableMap != null) {
                    stringTable = stringTableMap.get(rsMeta.getFieldName(i + 1));
                }
                if (stringTable != null) {
                    obs[i] = stringTable.getStringValue(IOUtil.readInt(dis));
                } else {
                    obs[i] = IOUtil.readObject(dis, DataEngineSession.getCurrentClassLoader());
                }
            } else {
                obs[i] = IOUtil.readObject(dis, DataEngineSession.getCurrentClassLoader());
            }
        }
        return new ResultObject(rsMeta, obs);
    } catch (IOException e) {
        Throwable t = e.getCause();
        if (t instanceof ClassNotFoundException) {
            throw new DataException(ResourceConstants.FAIL_LOAD_CLASS, e, new String[] { t.getMessage(), rsMeta.getFieldNativeTypeName(i + 1), rsMeta.getFieldName(i + 1) });
        } else {
            throw new DataException(ResourceConstants.FAIL_LOAD_COLUMN_VALUE, e, new String[] { rsMeta.getFieldNativeTypeName(i + 1), rsMeta.getFieldName(i + 1) });
        }
    }
}

Output:
         for (i = 0; i < count; i++) {
-            if (rsMeta.isIndexColumn(i + 1)) {
+            if (rsMeta.isIndexColumn(i + 1) && (index.containsKey(rsMeta.getFieldName(i + 1)))) {
                 obs[i] = IOUtil.readObject(dis, DataEngineSession.getCurrentClassLoader());


Input:
public static List getAttachedDevices() {
    BMIDevice[] devs = getDevices();
    List l = new ArrayList();
    for (int i = 0; i < 4; ++i) {
        if (devs[i] != null) {
            l.add(devs[i]);
        }
    }
    return l;
}

Output:
     BMIDevice[] devs = getDevices();
-    List l = new ArrayList();
+    List<BMIDevice> l = new ArrayList<BMIDevice>();
     for (int i = 0; i < 4; ++i) {


Input:
public void delete(String name) {
    entityManager.remove(find(name));
}

Output:
 public void delete(String name) {
-    entityManager.remove(find(name));
+    try {
+        entityManager.remove(find(name));
+    } catch (MissingConfKeyException e) {
+        log.error("String_Node_Str" + name, e);
+    }
 }


Input:
public RaytraceResult doRayTrace(final World world, final BlockPos pos, final Vec3 origin, final Vec3 direction) {
    Pipe<?> pipe = getPipe(world, pos);
    if (!isValid(pipe)) {
        return null;
    }
    TileGenericPipe tileG = pipe.container;
    if (tileG == null) {
        return null;
    }
    TraceTester tester = new TraceTester(world, pos, origin, direction);
    tester.test(getPipeBoundingBox(null), null);
    for (EnumFacing face : EnumFacing.values()) {
        if (tileG.isPipeConnected(face)) {
            tester.test(getPipeBoundingBox(face), face);
        }
    }
    for (EnumFacing face : EnumFacing.values()) {
        if (tileG.getPipePluggable(face) != null) {
            AxisAlignedBB aabb = tileG.getPipePluggable(face).getBoundingBox(face);
            IdentifiableAABB<Part> iaabb = new IdentifiableAABB<Part>(aabb, Part.Pluggable);
            tester.test(iaabb, face);
        }
    }
    setBlockBounds(0, 0, 0, 1, 1, 1);
    if (tester.closestHit != null) {
        return new RaytraceResult(tester.closestHit, tester.closestBox, tester.closestSide, tester.closestSideHit);
    } else {
        return null;
    }
}

Output:
             AxisAlignedBB aabb = tileG.getPipePluggable(face).getBoundingBox(face);
-            IdentifiableAABB<Part> iaabb = new IdentifiableAABB<Part>(aabb, Part.Pluggable);
+            IdentifiableAABB<Part> iaabb = new IdentifiableAABB<>(aabb, Part.Pluggable);
             tester.test(iaabb, face);


Input:
public void visitInnerClass(String internalName, String enclosingInternalName, String innerName, int access) {
    buildNestedSourceName(internalName, enclosingInternalName, innerName);
    if (this.internalName.equals(internalName)) {
        if (enclosingInternalName != null) {
            this.enclosingInternalName = enclosingInternalName;
        }
        int copyFlags = access & (Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE);
        this.access |= copyFlags;
        boolean isStatic = (access & Opcodes.ACC_STATIC) != 0;
        switch(classType) {
            case TopLevel:
                classType = isStatic ? ClassType.Nested : ClassType.Inner;
                break;
            case Anonymous:
                if (innerName != null) {
                    classType = ClassType.Local;
                }
                break;
            case Inner:
                break;
            default:
                throw new IllegalStateException("String_Node_Str" + classType);
        }
    }
}

Output:
         }
-        int copyFlags = access & (Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE);
-        this.access |= copyFlags;
+        this.access = access;
         boolean isStatic = (access & Opcodes.ACC_STATIC) != 0;


Input:
public boolean canActivateWeapon() {
    if (this.getPlatform() != null) {
        if (this.getPlatform().hasAmmunition(ProjectileType.RAILGUN) != null) {
            if (this.getPlatform().provideElectricity(ForgeDirection.UP, ElectricityPack.getFromWatts(this.getFiringRequest(), this.getVoltage()), false).getWatts() >= this.getFiringRequest()) {
                return true;
            }
        }
    }
    return false;
}

Output:
         if (this.getPlatform().hasAmmunition(ProjectileType.RAILGUN) != null) {
-            if (this.getPlatform().provideElectricity(ForgeDirection.UP, ElectricityPack.getFromWatts(this.getFiringRequest(), this.getVoltage()), false).getWatts() >= this.getFiringRequest()) {
+            if (Math.round(this.getPlatform().provideElectricity(this.getFiringRequest(), false).getWatts()) >= this.getFiringRequest()) {
                 return true;


Input:
public void onItemSelected(Issue item) {
    IssueInfo info = new IssueInfo();
    info.num = item.getNumber();
    info.repoInfo = new RepoInfo();
    info.repoInfo.owner = item.getRepository().getOwner().getLogin();
    info.repoInfo.name = item.getRepository().getName();
    if (item.getPullRequest() != null) {
        Intent intent = PullRequestDetailActivity.createLauncherIntent(getActivity(), info);
        startActivity(intent);
    } else {
        Intent intent = IssueDetailActivity.createLauncherIntent(getActivity(), info);
        startActivity(intent);
    }
}

Output:
     info.repoInfo = new RepoInfo();
-    info.repoInfo.owner = item.getRepository().getOwner().getLogin();
-    info.repoInfo.name = item.getRepository().getName();
-    if (item.getPullRequest() != null) {
-        Intent intent = PullRequestDetailActivity.createLauncherIntent(getActivity(), info);
-        startActivity(intent);
-    } else {
-        Intent intent = IssueDetailActivity.createLauncherIntent(getActivity(), info);
-        startActivity(intent);
+    if (item.getRepository() != null) {
+        info.repoInfo = new RepoInfo();
+        info.repoInfo.owner = item.getRepository().getOwner().getLogin();
+        info.repoInfo.name = item.getRepository().getName();
+    } else if (item.getRepositoryUrl() != null) {
+        info.repoInfo = new RepoInfo();
+        Uri parse = Uri.parse(item.getRepositoryUrl());
+        List<String> pathSegments = parse.getPathSegments();
+        if (pathSegments != null && pathSegments.size() > 1) {
+            pathSegments = new ArrayList<>(pathSegments);
+            Collections.reverse(pathSegments);
+            info.repoInfo.name = pathSegments.get(0);
+            info.repoInfo.owner = pathSegments.get(1);
+        }
+    }
+    if (info.repoInfo != null) {
+        if (item.getPullRequest() != null) {
+            Intent intent = PullRequestDetailActivity.createLauncherIntent(getActivity(), info);
+            startActivity(intent);
+        } else {
+            Intent intent = IssueDetailActivity.createLauncherIntent(getActivity(), info);
+            startActivity(intent);
+        }
     }


Input:
protected void onSelect(AjaxRequestTarget target, final OClass selectedOEdgeClass) {
    createVertex(selectedOVertexClass, selectedOEdgeClass);
    modal.setWindowClosedCallback(new ModalWindow.WindowClosedCallback() {
        private static final long serialVersionUID = 1L;
        public void onClose(AjaxRequestTarget target) {
            setResponsePage(new ODocumentPage(new ODocumentModel(documentModel.getObject())).setModeObject(DisplayMode.VIEW));
        }
    });
}

Output:
 protected void onSelect(AjaxRequestTarget target, final OClass selectedOEdgeClass) {
-    createVertex(selectedOVertexClass, selectedOEdgeClass);
-    modal.setWindowClosedCallback(new ModalWindow.WindowClosedCallback() {
-        private static final long serialVersionUID = 1L;
-        public void onClose(AjaxRequestTarget target) {
-            setResponsePage(new ODocumentPage(new ODocumentModel(documentModel.getObject())).setModeObject(DisplayMode.VIEW));
-        }
-    });
+    OrientVertex newV = createVertex(selectedOVertextClassModel.getObject(), selectedOEdgeClass);
+    setResponsePage(new ODocumentPage(newV.getRecord()).setModeObject(DisplayMode.EDIT));
 }


Input:
public Description getCurrentlyBestDescription() {
    return getCurrentlyBestEvaluatedDescription().getDescription();
}

Output:
 public Description getCurrentlyBestDescription() {
-    return getCurrentlyBestEvaluatedDescription().getDescription();
+    EvaluatedDescription ed = getCurrentlyBestEvaluatedDescription();
+    return ed == null ? null : ed.getDescription();
 }


Input:
public void run() {
    final ClientClusterService clusterService = client.getClientClusterService();
    final Address master = clusterService.getMasterAddress();
    final PartitionsResponse response = getPartitionsFrom((ClientClusterServiceImpl) clusterService, master);
    if (response != null) {
        processPartitionResponse(response);
    }
}

Output:
 public void run() {
-    final ClientClusterService clusterService = client.getClientClusterService();
-    final Address master = clusterService.getMasterAddress();
-    final PartitionsResponse response = getPartitionsFrom((ClientClusterServiceImpl) clusterService, master);
-    if (response != null) {
-        processPartitionResponse(response);
+    if (updating.compareAndSet(false, true)) {
+        try {
+            final ClientClusterService clusterService = client.getClientClusterService();
+            final Address master = clusterService.getMasterAddress();
+            final PartitionsResponse response = getPartitionsFrom((ClientClusterServiceImpl) clusterService, master);
+            if (response != null) {
+                processPartitionResponse(response);
+            }
+        } finally {
+            updating.set(false);
+        }
     }


Input:
public void validateGroupConfig(ClusterBlueprint blueprint, List<String> failedMsgList, List<String> warningMsgList) {
    List<NodeGroupInfo> nodeGroups = blueprint.getNodeGroups();
    boolean namenodeHACheck = false;
    int masterCount = 0, jobtrackerCount = 0, resourcemanagerCount = 0, hbasemasterCount = 0, zookeeperCount = 0, workerCount = 0, numOfJournalNode = 0;
    for (NodeGroupInfo nodeGroup : nodeGroups) {
        List<NodeGroupRole> groupRoles = getNodeGroupRoles(nodeGroup);
        if (groupRoles != null) {
            for (NodeGroupRole role : groupRoles) {
                switch(role) {
                    case MASTER:
                        masterCount++;
                        int numOfInstance = nodeGroup.getInstanceNum();
                        if (numOfInstance >= 0 && numOfInstance != 1) {
                            if (numOfInstance != 2) {
                                collectInstanceNumInvalidateMsg(nodeGroup, failedMsgList);
                            } else {
                                namenodeHACheck = true;
                            }
                        }
                        break;
                    case JOB_TRACKER:
                        jobtrackerCount++;
                        if (nodeGroup.getInstanceNum() >= 0 && nodeGroup.getInstanceNum() != 1) {
                            failedMsgList.add(Constants.WRONG_NUM_OF_JOBTRACKER);
                        }
                        break;
                    case RESOURCEMANAGER:
                        resourcemanagerCount++;
                        if (nodeGroup.getInstanceNum() >= 0 && nodeGroup.getInstanceNum() != 1) {
                            failedMsgList.add(Constants.WRONG_NUM_OF_RESOURCEMANAGER);
                        }
                        break;
                    case HBASE_MASTER:
                        hbasemasterCount++;
                        if (nodeGroup.getInstanceNum() == 0) {
                            collectInstanceNumInvalidateMsg(nodeGroup, failedMsgList);
                        }
                        break;
                    case ZOOKEEPER:
                        zookeeperCount++;
                        if (nodeGroup.getInstanceNum() > 0 && nodeGroup.getInstanceNum() < 3) {
                            failedMsgList.add(Constants.WRONG_NUM_OF_ZOOKEEPER);
                        } else if (nodeGroup.getInstanceNum() > 0 && nodeGroup.getInstanceNum() % 2 == 0) {
                            warningMsgList.add(Constants.ODD_NUM_OF_ZOOKEEPER);
                        }
                        break;
                    case JOURNAL_NODE:
                        numOfJournalNode += nodeGroup.getInstanceNum();
                        if (nodeGroup.getRoles().contains(HadoopRole.HADOOP_DATANODE.toString()) || nodeGroup.getRoles().contains(HadoopRole.HADOOP_CLIENT_ROLE.toString())) {
                            failedMsgList.add(Constants.DATA_CLIENT_NODE_JOURNALNODE_COEXIST);
                        }
                        break;
                    case WORKER:
                        workerCount++;
                        if (nodeGroup.getInstanceNum() == 0) {
                            collectInstanceNumInvalidateMsg(nodeGroup, failedMsgList);
                        } else if (nodeGroup.isHaEnabled()) {
                            warningMsgList.add(Constants.WORKER_CLIENT_HA_FLAG);
                        }
                        List<String> roles = nodeGroup.getRoles();
                        if (roles.contains(HadoopRole.HBASE_REGIONSERVER_ROLE.toString()) && !roles.contains(HadoopRole.HADOOP_DATANODE.toString())) {
                            warningMsgList.add(Constants.REGISONSERVER_DATANODE_SEPERATION);
                        }
                        break;
                    case CLIENT:
                        if (nodeGroup.isHaEnabled()) {
                            warningMsgList.add(Constants.WORKER_CLIENT_HA_FLAG);
                        }
                        break;
                    case NONE:
                        break;
                    default:
                        break;
                }
            }
        }
        if (!supportedWithHdfs2(blueprint)) {
            if (namenodeHACheck || masterCount > 1) {
                failedMsgList.add(Constants.CURRENT_DISTRO_CAN_NOT_SUPPORT_HDFS2);
            }
        } else if (namenodeHACheck) {
            if (numOfJournalNode >= 0 && numOfJournalNode < 3) {
                failedMsgList.add(Constants.WRONG_NUM_OF_JOURNALNODE);
            } else if (numOfJournalNode > 0 && numOfJournalNode % 2 == 0) {
                warningMsgList.add(Constants.ODD_NUM_OF_JOURNALNODE);
            }
            if (zookeeperCount == 0) {
                failedMsgList.add(Constants.NAMENODE_AUTO_FAILOVER_ZOOKEEPER);
            }
        }
        if ((jobtrackerCount > 1) || (resourcemanagerCount > 1) || (zookeeperCount > 1) || (hbasemasterCount > 1)) {
            failedMsgList.add(Constants.WRONG_NUM_OF_NODEGROUPS);
        }
        if (numOfJournalNode > 0 && !namenodeHACheck) {
            failedMsgList.add(Constants.NO_NAMENODE_HA);
        }
    }
    if (!warningMsgList.isEmpty() && !warningMsgList.get(0).startsWith("String_Node_Str")) {
        warningMsgList.set(0, "String_Node_Str" + warningMsgList.get(0));
    }
}

Output:
         }
-        if (!supportedWithHdfs2(blueprint)) {
-            if (namenodeHACheck || masterCount > 1) {
-                failedMsgList.add(Constants.CURRENT_DISTRO_CAN_NOT_SUPPORT_HDFS2);
-            }
-        } else if (namenodeHACheck) {
-            if (numOfJournalNode >= 0 && numOfJournalNode < 3) {
-                failedMsgList.add(Constants.WRONG_NUM_OF_JOURNALNODE);
-            } else if (numOfJournalNode > 0 && numOfJournalNode % 2 == 0) {
-                warningMsgList.add(Constants.ODD_NUM_OF_JOURNALNODE);
-            }
-            if (zookeeperCount == 0) {
-                failedMsgList.add(Constants.NAMENODE_AUTO_FAILOVER_ZOOKEEPER);
-            }
+    }
+    if (!supportedWithHdfs2(blueprint)) {
+        if (namenodeHACheck || masterCount > 1) {
+            failedMsgList.add(Constants.CURRENT_DISTRO_CAN_NOT_SUPPORT_HDFS2);
         }


Input:
public void stateChanged(LifecycleEvent event) {
    if (event.getState() == LifecycleEvent.LifecycleState.MERGED) {
        latch.countDown();
    }
}

Output:
 public void stateChanged(LifecycleEvent event) {
-    if (event.getState() == LifecycleEvent.LifecycleState.MERGED) {
-        latch.countDown();
+    if (event.getState() == LifecycleEvent.LifecycleState.MERGING) {
+        try {
+            mergeBlockingLatch.await(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            ExceptionUtil.rethrow(e);
+        }
+    } else if (event.getState() == LifecycleEvent.LifecycleState.MERGED) {
+        mergeFinishedLatch.countDown();
     }


Input:
public void AnnotateArticle(Article a) {
    try {
        Utilities.MakeDirectory("String_Node_Str");
        DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
        Document doc = docBuilder.newDocument();
        Element rootElement = doc.createElement("String_Node_Str");
        doc.appendChild(rootElement);
        Element pmcid = doc.createElement("String_Node_Str");
        pmcid.setTextContent(a.getPmc());
        rootElement.appendChild(pmcid);
        Element pcid = doc.createElement("String_Node_Str");
        pcid.setTextContent(a.getPmid());
        rootElement.appendChild(pcid);
        Element pissn = doc.createElement("String_Node_Str");
        pissn.setTextContent(a.getPissn());
        rootElement.appendChild(pissn);
        Element eissn = doc.createElement("String_Node_Str");
        eissn.setTextContent(a.getEissn());
        rootElement.appendChild(eissn);
        Element title = doc.createElement("String_Node_Str");
        title.setTextContent(a.getTitle());
        rootElement.appendChild(title);
        Element authors = doc.createElement("String_Node_Str");
        for (int i = 0; i < a.getAuthors().size(); i++) {
            Element author = doc.createElement("String_Node_Str");
            Element authorName = doc.createElement("String_Node_Str");
            authorName.setTextContent(a.getAuthors().get(i).name);
            author.appendChild(authorName);
            for (int j = 0; j < a.getAuthors().get(i).affiliation.size(); j++) {
                Element AuthorAffiliation = doc.createElement("String_Node_Str");
                AuthorAffiliation.setTextContent(a.getAuthors().get(i).affiliation.get(j));
                author.appendChild(AuthorAffiliation);
            }
            Element authorEmail = doc.createElement("String_Node_Str");
            authorEmail.setTextContent(a.getAuthors().get(i).email);
            author.appendChild(authorEmail);
            authors.appendChild(author);
        }
        rootElement.appendChild(authors);
        Element keywords = doc.createElement("String_Node_Str");
        for (int i = 0; i < a.getKeywords().length; i++) {
            Element keyword = doc.createElement("String_Node_Str");
            keyword.setTextContent(a.getKeywords()[i]);
            keywords.appendChild(keyword);
        }
        rootElement.appendChild(keywords);
        Element publisher = doc.createElement("String_Node_Str");
        Element publisherName = doc.createElement("String_Node_Str");
        publisherName.setTextContent(a.getPublisher_name());
        publisher.appendChild(publisherName);
        Element publisherLoc = doc.createElement("String_Node_Str");
        publisherLoc.setTextContent(a.getPublisher_loc());
        publisher.appendChild(publisherLoc);
        rootElement.appendChild(publisher);
        Element venue = doc.createElement("String_Node_Str");
        venue.setTextContent(a.getVenue());
        publisher.appendChild(venue);
        Element journal = doc.createElement("String_Node_Str");
        journal.setTextContent(a.getJournal_name());
        publisher.appendChild(journal);
        Element abstractEl = doc.createElement("String_Node_Str");
        abstractEl.setTextContent(a.getAbstract());
        rootElement.appendChild(abstractEl);
        Table[] tables = a.getTables();
        Element tablesEl = doc.createElement("String_Node_Str");
        rootElement.appendChild(tablesEl);
        for (int i = 0; i < tables.length; i++) {
            Element tableEl = doc.createElement("String_Node_Str");
            tablesEl.appendChild(tableEl);
            Table table = tables[i];
            Element TabOrder = doc.createElement("String_Node_Str");
            TabOrder.setTextContent(table.getTable_title());
            tableEl.appendChild(TabOrder);
            Element TabCaption = doc.createElement("String_Node_Str");
            TabCaption.setTextContent(table.getTable_caption());
            tableEl.appendChild(TabCaption);
            Element TabFooter = doc.createElement("String_Node_Str");
            TabFooter.setTextContent(table.getTable_footer());
            tableEl.appendChild(TabFooter);
            Element TabStructure = doc.createElement("String_Node_Str");
            if (table.getTableStructureType() == null) {
                table.setTableStructureType(StructureType.NULL);
            }
            TabStructure.setTextContent(table.getTableStructureType().toString());
            tableEl.appendChild(TabStructure);
            Element TabPragmatic = doc.createElement("String_Node_Str");
            TabPragmatic.setTextContent(table.PragmaticClass);
            tableEl.appendChild(TabPragmatic);
            Element TabHasXML = doc.createElement("String_Node_Str");
            if (table.isNoXMLTable())
                TabHasXML.setTextContent("String_Node_Str");
            else
                TabHasXML.setTextContent("String_Node_Str");
            tableEl.appendChild(TabHasXML);
            Element CellsEl = doc.createElement("String_Node_Str");
            tableEl.appendChild(CellsEl);
            Cell[][] cells = table.original_cells;
            if (cells != null) {
                for (int j = 0; j < cells.length; j++) {
                    for (int k = 0; k < cells[j].length; k++) {
                        Element CellEl = doc.createElement("String_Node_Str");
                        CellsEl.appendChild(CellEl);
                        Element CellID = doc.createElement("String_Node_Str");
                        String cellIDStr = "String_Node_Str" + j + "String_Node_Str" + k;
                        CellID.setTextContent(cellIDStr);
                        cells[j][k].CellId = cellIDStr;
                        CellEl.appendChild(CellID);
                        if (cells[j][k].getSuperRowIndex() != null && !cells[j][k].getSuperRowIndex().equals("String_Node_Str")) {
                            Element SuperRowRef = doc.createElement("String_Node_Str");
                            SuperRowRef.setTextContent(cells[j][k].getSuperRowIndex());
                            CellEl.appendChild(SuperRowRef);
                        }
                        Element CellValue = doc.createElement("String_Node_Str");
                        CellValue.setTextContent(cells[j][k].getCell_content());
                        CellEl.appendChild(CellValue);
                        String valueToParse = cells[j][k].getCell_content();
                        LinkedList<ValueItem> valueTags = TablInExMain.vp.parseValue(valueToParse);
                        Element CellSemantics = doc.createElement("String_Node_Str");
                        CellEl.appendChild(CellSemantics);
                        for (int p = 0; p < valueTags.size(); p++) {
                            Element CellValueSemantics = doc.createElement("String_Node_Str");
                            CellValueSemantics.setAttribute("String_Node_Str", "String_Node_Str");
                            CellValueSemantics.setAttribute("String_Node_Str", valueTags.get(p).type.toString());
                            CellValueSemantics.setAttribute("String_Node_Str", valueTags.get(p).start_position + "String_Node_Str");
                            CellValueSemantics.setAttribute("String_Node_Str", valueTags.get(p).end_position + "String_Node_Str");
                            CellValueSemantics.setAttribute("String_Node_Str", valueTags.get(p).value);
                            CellValueSemantics.setAttribute("String_Node_Str", "String_Node_Str");
                            CellValueSemantics.setAttribute("String_Node_Str", "String_Node_Str");
                            CellValueSemantics.setAttribute("String_Node_Str", "String_Node_Str");
                            CellSemantics.appendChild(CellValueSemantics);
                        }
                        int mathTypeIndex = valueToParse.indexOf("String_Node_Str");
                        if (mathTypeIndex > 0) {
                            valueToParse = valueToParse.substring(0, mathTypeIndex);
                        }
                        LinkedList<Word> words = null;
                        if (valueToParse != null) {
                            valueToParse = valueToParse.trim();
                            if (!Utilities.isSpaceOrEmpty(valueToParse)) {
                                words = TablInExMain.marvin.annotate(valueToParse);
                            }
                        }
                        if (words != null) {
                            for (int p = 0; p < words.size(); p++) {
                                for (int s = 0; s < words.get(p).wordmeanings.size(); s++) {
                                    Element Meaning = doc.createElement("String_Node_Str");
                                    Meaning.setAttribute("String_Node_Str", "String_Node_Str");
                                    Meaning.setAttribute("String_Node_Str", "String_Node_Str");
                                    Meaning.setAttribute("String_Node_Str", words.get(p).wordmeanings.get(s).Source);
                                    Meaning.setAttribute("String_Node_Str", words.get(p).wordmeanings.get(s).id);
                                    Meaning.setAttribute("String_Node_Str", words.get(p).wordmeanings.get(s).URL);
                                    Meaning.setAttribute("String_Node_Str", words.get(p).wordmeanings.get(s).startAt + "String_Node_Str");
                                    Meaning.setAttribute("String_Node_Str", words.get(p).wordmeanings.get(s).endAt + "String_Node_Str");
                                    Meaning.setAttribute("String_Node_Str", words.get(p).wordmeanings.get(s).appearingWord);
                                    CellSemantics.appendChild(Meaning);
                                }
                            }
                        }
                        Element CellType = doc.createElement("String_Node_Str");
                        CellType.setTextContent(cells[j][k].getCellType());
                        CellEl.appendChild(CellType);
                        for (int s = j - 1; s >= 0; s--) {
                            if (s >= 0 && cells[j][k].isIs_header() && !cells[s][k].isIs_header() && !cells[j][k].getCell_content().equals("String_Node_Str")) {
                                break;
                            }
                            if (s >= 0 && cells[s][k] != null && cells[j][k].isIs_header() && !cells[j - 1][k].isIs_header()) {
                                break;
                            }
                            if (s >= 0 && cells[s][k] != null && cells[s][k].isIs_header()) {
                                Element HeaderRef = doc.createElement("String_Node_Str");
                                HeaderRef.setTextContent("String_Node_Str" + s + "String_Node_Str" + k);
                                CellEl.appendChild(HeaderRef);
                            }
                            if (s >= 0 && cells[s][k] != null && cells[s][k].isIs_header()) {
                                Element HeaderCatRef = doc.createElement("String_Node_Str");
                                HeaderCatRef.setTextContent("String_Node_Str" + s + "String_Node_Str" + 0);
                                CellEl.appendChild(HeaderCatRef);
                                break;
                            }
                        }
                        for (int s = k - 1; s >= 0; s--) {
                            if (s >= 0 && cells[j][s] != null && cells[j][s].isIs_stub()) {
                                Element StubRef = doc.createElement("String_Node_Str");
                                StubRef.setTextContent("String_Node_Str" + j + "String_Node_Str" + s);
                                CellEl.appendChild(StubRef);
                                break;
                            }
                        }
                        Element CellRoles = doc.createElement("String_Node_Str");
                        CellEl.appendChild(CellRoles);
                        boolean isDataCell = true;
                        if (cells[j][k].isIs_header()) {
                            Element CellRole = doc.createElement("String_Node_Str");
                            CellRole.setTextContent("String_Node_Str");
                            CellRoles.appendChild(CellRole);
                            isDataCell = false;
                        }
                        if (cells[j][k].isIs_stub() && cells[j][k].getCells_columnspanning() == 0) {
                            Element CellRole = doc.createElement("String_Node_Str");
                            CellRole.setTextContent("String_Node_Str");
                            CellRoles.appendChild(CellRole);
                            isDataCell = false;
                        }
                        boolean isSuperRow = false;
                        for (int l = 0; l < 5; l++) {
                            if (cells[j][k] != null && j + l < cells.length && cells[j + l][k] != null && cells[j + l][k].getSuperRowIndex() != null && cells[j + l][k].getSuperRowIndex().equals(cells[j][k].CellId)) {
                                isSuperRow = true;
                                break;
                            }
                        }
                        if (isSuperRow) {
                            for (int l = 0; l < cells[j].length; l++) {
                                cells[j][l].setIs_subheader(true);
                            }
                        }
                        if (cells[j][k].isIs_subheader()) {
                            Element CellRole = doc.createElement("String_Node_Str");
                            CellRole.setTextContent("String_Node_Str");
                            CellRoles.appendChild(CellRole);
                        }
                        if (k == 0 && cells[j][k].isIs_header()) {
                            Element CellRole = doc.createElement("String_Node_Str");
                            CellRole.setTextContent("String_Node_Str");
                            CellRoles.appendChild(CellRole);
                            isDataCell = false;
                        }
                        if (isDataCell) {
                            Element CellRole = doc.createElement("String_Node_Str");
                            CellRole.setTextContent("String_Node_Str");
                            CellRoles.appendChild(CellRole);
                        }
                        Element CellRow = doc.createElement("String_Node_Str");
                        CellRow.setTextContent(j + "String_Node_Str");
                        CellEl.appendChild(CellRow);
                        Element CellColumn = doc.createElement("String_Node_Str");
                        CellColumn.setTextContent(k + "String_Node_Str");
                        CellEl.appendChild(CellColumn);
                    }
                }
            }
        }
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.INDENT, "String_Node_Str");
        DOMSource source;
        source = new DOMSource(doc);
        StreamResult result = new StreamResult(new File("String_Node_Str" + a.getPmc() + "String_Node_Str"));
        transformer.transform(source, result);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

Output:
                         }
-                        if (cells[j][k].isIs_stub() && cells[j][k].getCells_columnspanning() == 0) {
+                        if (cells[j][k].isIs_stub() && cells[j][k].getColumnspanning_index() == 0) {
                             Element CellRole = doc.createElement("String_Node_Str");


Input:
public static boolean deleteDir(File dir, boolean logFailure) {
    String[] files = dir.list();
    if (files == null) {
        files = new String[0];
    }
    for (int i = 0; i < files.length; i++) {
        File file = new File(dir, files[i]);
        if (file.isDirectory()) {
            deleteDir(file, logFailure);
        } else {
            file.delete();
        }
    }
    boolean result;
    if (dir.exists()) {
        result = dir.delete();
    } else {
        result = true;
    }
    if (logFailure && !result) {
        log.severe(sm.getString("String_Node_Str", dir.getAbsolutePath()));
    }
    return result;
}

Output:
         } else {
-            file.delete();
+            if (!file.delete() && logFailure) {
+                log.severe(sm.getString("String_Node_Str", file.getAbsolutePath()));
+            }
         }


Input:
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }
    if (getClass().equals(obj.getClass())) {
        ResolutionFailure other = (ResolutionFailure) obj;
        return (getMethod().equals(other.getMethod()) && getLevel() == other.getLevel() && ref.equals(other.ref));
    } else {
        return false;
    }
}

Output:
 public boolean equals(Object obj) {
-    if (obj == null) {
+    if (this == obj)
+        return true;
+    if (!super.equals(obj))
         return false;


Input:
public void validate() throws RuleValidationException {
    if (isPortNameEnabled()) {
        if (_portName.get().equals("String_Node_Str")) {
            throw new RuleValidationException("String_Node_Str");
        }
        try {
            _portName.getPattern();
        } catch (PatternSyntaxException e) {
            throw new RuleValidationException("String_Node_Str" + _portName + "String_Node_Str", e);
        }
    }
    if (isPortTypeEnabled()) {
        if (_portType.get().equals("String_Node_Str")) {
            throw new RuleValidationException("String_Node_Str");
        }
        try {
            _portType.getToken().getType();
        } catch (IllegalActionException e) {
            throw new RuleValidationException("String_Node_Str" + _portType + "String_Node_Str", e);
        }
    }
}

Output:
         if (_portName.get().equals("String_Node_Str")) {
-            throw new RuleValidationException("String_Node_Str");
+            throw new ValidationException("String_Node_Str");
         }


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object objectValue, CoreAbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    XPathFragment rootFragment = null;
    Marshaller marshaller = marshalRecord.getMarshaller();
    objectValue = xmlAnyObjectMapping.convertObjectValueToDataValue(objectValue, session, marshalRecord.getMarshaller());
    if (null == objectValue) {
        return false;
    }
    XPathFragment groupingFragment = marshalRecord.openStartGroupingElements(namespaceResolver);
    marshalRecord.closeStartGroupingElements(groupingFragment);
    boolean wasXMLRoot = false;
    XPathFragment xmlRootFragment = null;
    Object originalValue = objectValue;
    if (xmlAnyObjectMapping.usesXMLRoot() && (objectValue instanceof Root)) {
        xmlRootFragment = new XPathFragment();
        xmlRootFragment.setNamespaceAware(marshalRecord.isNamespaceAware());
        wasXMLRoot = true;
        objectValue = ((Root) objectValue).getObject();
    }
    if (objectValue instanceof String) {
        marshalSimpleValue(xmlRootFragment, marshalRecord, originalValue, object, objectValue, session, namespaceResolver);
    } else {
        CoreSession childSession = null;
        try {
            childSession = marshaller.getContext().getSession(objectValue);
        } catch (XMLMarshalException e) {
            marshalSimpleValue(xmlRootFragment, marshalRecord, originalValue, object, objectValue, session, namespaceResolver);
            return true;
        }
        Descriptor descriptor = (Descriptor) childSession.getDescriptor(objectValue);
        ObjectBuilder objectBuilder = (ObjectBuilder) descriptor.getObjectBuilder();
        List extraNamespaces = objectBuilder.addExtraNamespacesToNamespaceResolver(descriptor, marshalRecord, session, true, true);
        if (wasXMLRoot) {
            Namespace generatedNamespace = setupFragment(((Root) originalValue), xmlRootFragment, marshalRecord);
            if (generatedNamespace != null) {
                extraNamespaces.add(generatedNamespace);
            }
        }
        String defaultRootElementString = descriptor.getDefaultRootElement();
        if (!wasXMLRoot && (defaultRootElementString == null)) {
            AbstractSessionLog.getLog().log(SessionLog.WARNING, "String_Node_Str", new Object[] { Helper.getShortClassName(this.getClass()), descriptor });
        } else {
            marshalRecord.beforeContainmentMarshal(objectValue);
            if (xmlRootFragment != null) {
                rootFragment = xmlRootFragment;
            } else {
                rootFragment = new XPathFragment(defaultRootElementString);
                if (rootFragment.getNamespaceURI() == null) {
                    if (rootFragment.getPrefix() != null) {
                        String uri = descriptor.getNonNullNamespaceResolver().resolveNamespacePrefix(rootFragment.getPrefix());
                        rootFragment.setNamespaceURI(uri);
                    } else {
                        rootFragment.setNamespaceURI(descriptor.getNonNullNamespaceResolver().getDefaultNamespaceURI());
                    }
                }
            }
            if (!wasXMLRoot) {
                marshalRecord.setLeafElementType(descriptor.getDefaultRootElementType());
            }
            getXPathNode().startElement(marshalRecord, rootFragment, object, session, descriptor.getNonNullNamespaceResolver(), objectBuilder, objectValue);
            writeExtraNamespaces(extraNamespaces, marshalRecord, session);
            marshalRecord.addXsiTypeAndClassIndicatorIfRequired(descriptor, descriptor, (Field) xmlAnyObjectMapping.getField(), originalValue, objectValue, wasXMLRoot, false);
            objectBuilder.buildRow(marshalRecord, objectValue, (org.eclipse.persistence.internal.sessions.AbstractSession) childSession, marshaller, null);
            marshalRecord.afterContainmentMarshal(object, objectValue);
            marshalRecord.endElement(rootFragment, namespaceResolver);
            marshalRecord.removeExtraNamespacesFromNamespaceResolver(extraNamespaces, session);
        }
    }
    return true;
}

Output:
         if (wasXMLRoot) {
-            Namespace generatedNamespace = setupFragment(((Root) originalValue), xmlRootFragment, marshalRecord);
-            if (generatedNamespace != null) {
-                extraNamespaces.add(generatedNamespace);
-            }
+            setupFragment(((Root) originalValue), xmlRootFragment, marshalRecord);
         }


Input:
public void testCreateMapWithLists() {
    V8Object object = v8.executeObjectScript("String_Node_Str");
    Map<String, Object> map = V8ObjectUtils.toMap(object);
    assertEquals(2, map.size());
    assertEquals(1, ((List) map.get("String_Node_Str")).get(0));
    assertEquals(2, ((List) map.get("String_Node_Str")).get(1));
    assertEquals(3, ((List) map.get("String_Node_Str")).get(2));
    assertEquals(4, ((List) map.get("String_Node_Str")).get(0));
    assertEquals(5, ((List) map.get("String_Node_Str")).get(1));
    assertEquals(6, ((List) map.get("String_Node_Str")).get(2));
    object.release();
}

Output:
     V8Object object = v8.executeObjectScript("String_Node_Str");
-    Map<String, Object> map = V8ObjectUtils.toMap(object);
+    Map<String, ? super Object> map = V8ObjectUtils.toMap(object);
     assertEquals(2, map.size());


Input:
public int search(int[] input, int search) {
    int low = 0;
    int high = input.length - 1;
    int mid = 0;
    while (low <= high) {
        mid = (low + high) / 2;
        if (input[mid] == search) {
            return mid;
        } else if (input[mid] < search) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1;
}

Output:
     int high = input.length - 1;
-    int mid = 0;
+    int mid;
     while (low <= high) {


Input:
public RouteInfo select(EnumDBMasterSlave masterSlave, String tableName, IShardingKey<?> value) throws DBRouteException {
    RouteInfo dbRouteInfo = new RouteInfo();
    long shardingValue = getShardingValue(value);
    String clusterName = value.getClusterName();
    DBClusterInfo dbClusterInfo = this.dbCluster.getDBClusterInfo(clusterName);
    if (dbClusterInfo == null) {
        throw new IllegalStateException("String_Node_Str" + clusterName);
    }
    List<DBRegionInfo> regionInfos = dbClusterInfo.getDbRegions();
    if (regionInfos == null || regionInfos.isEmpty()) {
        throw new DBRouteException("String_Node_Str" + clusterName);
    }
    DBRegionInfo regionInfo = null;
    int regionIndex = 0;
    for (DBRegionInfo region : regionInfos) {
        if (region.isMatch(shardingValue)) {
            regionInfo = region;
            break;
        }
        regionIndex++;
    }
    if (regionInfo == null) {
        throw new DBRouteException("String_Node_Str" + clusterName + "String_Node_Str" + shardingValue);
    }
    List<DBInfo> dbInfos = null;
    switch(masterSlave) {
        case MASTER:
            dbInfos = regionInfo.getMasterDBInfos();
            break;
        case AUTO:
            List<List<DBInfo>> multiSlaveDBInfos = regionInfo.getSlaveDBInfos();
            if (multiSlaveDBInfos == null || multiSlaveDBInfos.isEmpty()) {
                throw new DBRouteException("String_Node_Str" + clusterName);
            }
            int slaveIndex = AbstractDBCluster.r.nextInt(multiSlaveDBInfos.size() - 1);
            dbInfos = multiSlaveDBInfos.get(slaveIndex);
            break;
        default:
            multiSlaveDBInfos = regionInfo.getSlaveDBInfos();
            if (multiSlaveDBInfos == null || multiSlaveDBInfos.isEmpty()) {
                throw new DBRouteException("String_Node_Str" + clusterName);
            }
            slaveIndex = masterSlave.getValue();
            dbInfos = multiSlaveDBInfos.get(slaveIndex);
            break;
    }
    if (dbInfos == null || dbInfos.isEmpty()) {
        throw new DBRouteException("String_Node_Str" + clusterName);
    }
    DBInfo dbInfo = doSelect(dbInfos, value);
    dbRouteInfo.setDbInfo(dbInfo);
    dbRouteInfo.setClusterName(clusterName);
    dbRouteInfo.setRegionIndex(regionIndex);
    try {
        int tableNum = tableCluster.getTableNumber(clusterName, tableName);
        int tableIndex = (int) shardingValue % tableNum;
        dbRouteInfo.setTableName(tableName);
        dbRouteInfo.setTableIndex(tableIndex);
    } catch (Exception e) {
        throw new DBRouteException("String_Node_Str" + dbRouteInfo.getClusterName() + "String_Node_Str" + dbRouteInfo.getDbInfo().getDbName() + "String_Node_Str" + tableName);
    }
    return dbRouteInfo;
}

Output:
             }
-            int slaveIndex = AbstractDBCluster.r.nextInt(multiSlaveDBInfos.size() - 1);
+            int slaveIndex = AbstractDBCluster.r.nextInt(multiSlaveDBInfos.size());
             dbInfos = multiSlaveDBInfos.get(slaveIndex);


Input:
public void veryHardShouldConquerHard() throws MapLoadException {
    holdBattleBetween(EPlayerType.AI_VERY_HARD, EPlayerType.AI_HARD, 100 * MINUTES);
}

Output:
 public void veryHardShouldConquerHard() throws MapLoadException {
-    holdBattleBetween(EPlayerType.AI_VERY_HARD, EPlayerType.AI_HARD, 100 * MINUTES);
+    holdBattleBetween(EPlayerType.AI_VERY_HARD, EPlayerType.AI_HARD, 120 * MINUTES);
 }


Input:
public static void shutdown() {
    if (dataMonitor != null) {
        dataMonitor = null;
    }
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    Set<ObjectName> entries;
    try {
        entries = mbs.queryNames(new ObjectName(MBeanBuilder.NAME_DOMAIN + "String_Node_Str"), null);
        for (ObjectName name : entries) {
            mbs.unregisterMBean(name);
        }
    } catch (Exception e) {
        logger.log(Level.WARNING, "String_Node_Str", e);
    }
    if (statCollectors != null) {
        statCollectors.shutdownNow();
    }
}

Output:
     } catch (Exception e) {
-        logger.log(Level.WARNING, "String_Node_Str", e);
+        logger.log(Level.FINE, "String_Node_Str", e);
     }


Input:
public void onReceive(Context context, Intent intent) {
    if (DELAYED_KEYGUARD_ACTION.equals(intent.getAction())) {
        final int sequence = intent.getIntExtra("String_Node_Str", 0);
        if (DEBUG)
            Log.d(TAG, "String_Node_Str" + sequence + "String_Node_Str" + mDelayedShowingSequence);
        synchronized (KeyguardViewMediator.this) {
            doKeyguardLocked(null);
        }
    } else if (DELAYED_LOCK_PROFILE_ACTION.equals(intent.getAction())) {
        int userId = intent.getIntExtra(Intent.EXTRA_USER_ID, 0);
        if (userId != 0) {
            synchronized (KeyguardViewMediator.this) {
                lockProfile(userId);
            }
        }
    }
}

Output:
         synchronized (KeyguardViewMediator.this) {
-            doKeyguardLocked(null);
+            if (mDelayedShowingSequence == sequence) {
+                doKeyguardLocked(null);
+            }
         }


Input:
protected ArrayList<HappyBottle> download(Task t) {
    String page = "String_Node_Str";
    try {
        HttpGet request = new HttpGet();
        request.setURI(new URI("String_Node_Str"));
        if (t.equals(Task.GETMINE)) {
            request.setURI(new URI("String_Node_Str" + myID + "String_Node_Str"));
        }
        BasicHeader declareAuth = new BasicHeader("String_Node_Str", "String_Node_Str" + Base64.encodeToString("String_Node_Str".getBytes(), Base64.DEFAULT) + "String_Node_Str");
        request.setHeader(declareAuth);
        page = connectionHelper(request);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return parse(page);
}

Output:
         }
-        BasicHeader declareAuth = new BasicHeader("String_Node_Str", "String_Node_Str" + Base64.encodeToString("String_Node_Str".getBytes(), Base64.DEFAULT) + "String_Node_Str");
-        request.setHeader(declareAuth);
+        Log.d(TAG, "String_Node_Str" + request.getURI().toString());
         page = connectionHelper(request);


Input:
public int complete(String buffer, int cursor, List<CharSequence> candidates) {
    Map<String, String> arguments = ArgumentParser.getArguments(buffer, PATTERN);
    ProgramIdArgument programIdArgument = ArgumentParser.parseProgramId(arguments.get(PROGRAM_ID));
    if (programIdArgument != null) {
        ServiceId service = cliConfig.getCurrentNamespace().app(programIdArgument.getAppId()).service(programIdArgument.getProgramId());
        completer.setEndpoints(getEndpoints(service, arguments.get(METHOD)));
    } else {
        completer.setEndpoints(Collections.<String>emptyList());
    }
    return super.complete(buffer, cursor, candidates);
}

Output:
     Map<String, String> arguments = ArgumentParser.getArguments(buffer, PATTERN);
-    ProgramIdArgument programIdArgument = ArgumentParser.parseProgramId(arguments.get(PROGRAM_ID));
+    ProgramIdArgument programIdArgument = ArgumentParser.parseProgramId(arguments.get(SERVICE_ID));
     if (programIdArgument != null) {


Input:
public Object convertToObject(String orig) {
    Iterator iter = options.entrySet().iterator();
    Map.Entry mapEntry = null;
    while (iter.hasNext()) {
        mapEntry = (Map.Entry) iter.next();
        if (mapEntry.getValue().toString().equals(orig) || mapEntry.getKey().toString().equals(orig)) {
            return mapEntry.getKey();
        }
    }
    Reporter.informUser(this, Msg.IGNORE, new Object[] { orig });
    return "String_Node_Str";
}

Output:
         if (mapEntry.getValue().toString().equals(orig) || mapEntry.getKey().toString().equals(orig)) {
-            return mapEntry.getKey();
+            return mapEntry.getKey().toString();
         }


Input:
private long getReadLocation() {
    return buffer.readVolatileLong(readLocationOffset);
}

Output:
 private long getReadLocation() {
-    return buffer.readVolatileLong(readLocationOffset);
+    return readLocationAtomic.get();
 }


Input:
private Option<View> setupView(final View view) {
    AdView adView;
    try {
        adView = (AdView) view;
    } catch (ClassCastException err) {
        adView = null;
        Crashlytics.logException(err);
    }
    if (adView != null) {
        final AdRequest adRequest = new AdRequest.Builder().addTestDevice(AdRequest.DEVICE_ID_EMULATOR).build();
        adView.loadAd(adRequest);
        return Option.some(adView);
    }
    return Option.none();
}

Output:
         final AdRequest adRequest = new AdRequest.Builder().addTestDevice(AdRequest.DEVICE_ID_EMULATOR).build();
-        adView.loadAd(adRequest);
+        try {
+            adView.loadAd(adRequest);
+        } catch (OutOfMemoryError err) {
+            return Option.none();
+        }
         return Option.some(adView);


Input:
public ResultSet executeSparqlQuery(SparqlQuery query) {
    String result = getCacheEntry(query.getQueryString());
    if (result != null) {
        return SparqlQuery.JSONtoResultSet(result);
    } else {
        query.send();
        ResultSet rs = query.getResultSet();
        if (rs != null) {
            String json = SparqlQuery.getAsJSON(rs);
            addToCache(query.getQueryString(), json);
            return SparqlQuery.JSONtoResultSet(json);
        }
        return rs;
    }
}

Output:
     if (result != null) {
-        return SparqlQuery.JSONtoResultSet(result);
+        return result;
     } else {


Input:
public void draw() {
    super.draw();
    if (!updated.isEmpty()) {
        updateVertices();
        quads.limit(bufferLength * 16);
        if (buffer == null)
            buffer = new Vertexbuffer(quads);
        else {
            if (fullUpdate) {
                buffer.updateVertices(quads);
                fullUpdate = false;
            } else {
                buffer.updateVertices(quads, topLeftUpdating * 16, bottomRightUpdating * 16);
            }
        }
        topLeftUpdating = 0;
        updating.setEmpty();
    }
    Camera c = Camera.main;
    if (camX == null || camX != (int) c.scroll.x / 16 || camY != (int) c.scroll.y / 16 || camW != (int) Math.ceil(c.width / cellW) || camH != (int) Math.ceil(c.height / cellH)) {
        camX = (int) c.scroll.x / 16;
        camY = (int) c.scroll.y / 16;
        camW = (int) Math.ceil(c.width / cellW);
        camH = (int) Math.ceil(c.height / cellH);
        if (camX >= mapWidth || camY >= mapHeight || camW + camW <= 0 || camH + camH <= 0)
            return;
        topLeft = Math.max(camX, 0) + Math.max(camY * mapWidth, 0);
        while (bufferPositions[topLeft] == -1) topLeft++;
        bottomRight = Math.min(camX + camW, mapWidth - 1) + Math.min((camY + camH) * mapWidth, (mapHeight - 1) * mapWidth);
        while (bufferPositions[bottomRight] == -1) bottomRight--;
        length = bufferPositions[bottomRight] - bufferPositions[topLeft] + 1;
    }
    if (camX >= mapWidth || camY >= mapHeight || camW + camW <= 0 || camH + camH <= 0)
        return;
    NoosaScript script = NoosaScriptNoLighting.get();
    texture.bind();
    script.uModel.valueM4(matrix);
    script.camera(camera);
    script.drawQuadSet(buffer, length, bufferPositions[topLeft]);
}

Output:
         topLeft = Math.max(camX, 0) + Math.max(camY * mapWidth, 0);
-        while (bufferPositions[topLeft] == -1) topLeft++;
+        while (topLeft < bufferPositions.length && bufferPositions[topLeft] == -1) topLeft++;
         bottomRight = Math.min(camX + camW, mapWidth - 1) + Math.min((camY + camH) * mapWidth, (mapHeight - 1) * mapWidth);


Input:
public boolean select(Viewer viewer, Object parentElement, Object element) {
    if (element instanceof IFile) {
        IFile file = (IFile) element;
        if (FactoriesUtil.PATTERN.equals(file.getFileExtension())) {
            return true;
        }
    } else if (element instanceof IFolder) {
        IFolder folder = (IFolder) element;
        return ResourceManager.isSubFolder(ResourceManager.getPatternFolder(), folder);
    }
    return false;
}

Output:
         IFolder folder = (IFolder) element;
-        return ResourceManager.isSubFolder(ResourceManager.getPatternFolder(), folder);
+        return ResourceService.isSubFolder(ResourceManager.getPatternFolder(), folder);
     }