Input:
public void onInteract(PlayerInteractEvent event) {
    Player player = event.getPlayer();
    PlotPlayer pp = BukkitUtil.getPlayer(player);
    PlotArea area = pp.getPlotAreaAbs();
    if (area == null) {
        return;
    }
    PlayerBlockEventType eventType = null;
    BukkitLazyBlock lb;
    Location location;
    Action action = event.getAction();
    switch(action) {
        case PHYSICAL:
            {
                eventType = PlayerBlockEventType.TRIGGER_PHYSICAL;
                Block block = event.getClickedBlock();
                lb = new BukkitLazyBlock(block);
                location = BukkitUtil.getLocation(block.getLocation());
                break;
            }
        case RIGHT_CLICK_BLOCK:
            {
                Block block = event.getClickedBlock();
                location = BukkitUtil.getLocation(block.getLocation());
                Material blockType = block.getType();
                int blockId = blockType.getId();
                switch(blockType) {
                    case ANVIL:
                    case ACACIA_DOOR:
                    case BIRCH_DOOR:
                    case DARK_OAK_DOOR:
                    case IRON_DOOR:
                    case JUNGLE_DOOR:
                    case SPRUCE_DOOR:
                    case TRAP_DOOR:
                    case IRON_TRAPDOOR:
                    case WOOD_DOOR:
                    case WOODEN_DOOR:
                    case TRAPPED_CHEST:
                    case ENDER_CHEST:
                    case CHEST:
                    case ACACIA_FENCE_GATE:
                    case BIRCH_FENCE_GATE:
                    case DARK_OAK_FENCE_GATE:
                    case FENCE_GATE:
                    case JUNGLE_FENCE_GATE:
                    case SPRUCE_FENCE_GATE:
                    case LEVER:
                    case DIODE:
                    case DIODE_BLOCK_OFF:
                    case DIODE_BLOCK_ON:
                    case COMMAND:
                    case REDSTONE_COMPARATOR:
                    case REDSTONE_COMPARATOR_OFF:
                    case REDSTONE_COMPARATOR_ON:
                    case REDSTONE_ORE:
                    case WOOD_BUTTON:
                    case STONE_BUTTON:
                    case BEACON:
                    case BED_BLOCK:
                    case SIGN:
                    case WALL_SIGN:
                    case SIGN_POST:
                    case ENCHANTMENT_TABLE:
                    case BREWING_STAND:
                    case STANDING_BANNER:
                    case BURNING_FURNACE:
                    case FURNACE:
                    case CAKE_BLOCK:
                    case DISPENSER:
                    case DROPPER:
                    case HOPPER:
                    case NOTE_BLOCK:
                    case JUKEBOX:
                    case WORKBENCH:
                        eventType = PlayerBlockEventType.INTERACT_BLOCK;
                        break;
                    case DRAGON_EGG:
                        eventType = PlayerBlockEventType.TELEPORT_OBJECT;
                        break;
                    default:
                        if (blockId > 197) {
                            eventType = PlayerBlockEventType.INTERACT_BLOCK;
                        }
                        break;
                }
                lb = new BukkitLazyBlock(blockId, block);
                ItemStack hand = player.getItemInHand();
                if (eventType != null) {
                    break;
                }
                Material type = (hand == null) ? null : hand.getType();
                int id = (type == null) ? 0 : type.getId();
                if (id == 0) {
                    eventType = PlayerBlockEventType.INTERACT_BLOCK;
                    lb = new BukkitLazyBlock(0, block);
                    break;
                } else if (id < 198) {
                    location = BukkitUtil.getLocation(block.getRelative(event.getBlockFace()).getLocation());
                    eventType = PlayerBlockEventType.PLACE_BLOCK;
                    lb = new BukkitLazyBlock(id, block);
                    break;
                }
                Material handType = hand.getType();
                lb = new BukkitLazyBlock(new PlotBlock((short) handType.getId(), (byte) 0));
                switch(handType) {
                    case MONSTER_EGG:
                    case MONSTER_EGGS:
                        eventType = PlayerBlockEventType.SPAWN_MOB;
                        break;
                    case ARMOR_STAND:
                        location = BukkitUtil.getLocation(block.getRelative(event.getBlockFace()).getLocation());
                        eventType = PlayerBlockEventType.PLACE_MISC;
                        break;
                    case WRITTEN_BOOK:
                    case BOOK_AND_QUILL:
                    case BOOK:
                        eventType = PlayerBlockEventType.READ;
                        break;
                    case APPLE:
                    case BAKED_POTATO:
                    case MUSHROOM_SOUP:
                    case BREAD:
                    case CARROT:
                    case CARROT_ITEM:
                    case COOKIE:
                    case GRILLED_PORK:
                    case POISONOUS_POTATO:
                    case MUTTON:
                    case PORK:
                    case POTATO:
                    case POTATO_ITEM:
                    case POTION:
                    case PUMPKIN_PIE:
                    case RABBIT:
                    case RABBIT_FOOT:
                    case RABBIT_STEW:
                    case RAW_BEEF:
                    case RAW_FISH:
                    case RAW_CHICKEN:
                        eventType = PlayerBlockEventType.EAT;
                        break;
                    case MINECART:
                    case STORAGE_MINECART:
                    case POWERED_MINECART:
                    case HOPPER_MINECART:
                    case EXPLOSIVE_MINECART:
                    case COMMAND_MINECART:
                    case BOAT:
                        eventType = PlayerBlockEventType.PLACE_VEHICLE;
                        break;
                    case PAINTING:
                    case ITEM_FRAME:
                        location = BukkitUtil.getLocation(block.getRelative(event.getBlockFace()).getLocation());
                        eventType = PlayerBlockEventType.PLACE_HANGING;
                        break;
                    default:
                        eventType = PlayerBlockEventType.INTERACT_BLOCK;
                        break;
                }
                break;
            }
        case LEFT_CLICK_BLOCK:
            Block block = event.getClickedBlock();
            location = BukkitUtil.getLocation(block.getLocation());
            eventType = PlayerBlockEventType.BREAK_BLOCK;
            lb = new BukkitLazyBlock(block);
            break;
        default:
            return;
    }
    if (PS.get().worldedit != null && pp.getAttribute("String_Node_Str")) {
        if (player.getItemInHand().getTypeId() == PS.get().worldedit.getConfiguration().wandItem) {
            return;
        }
    }
    if (!EventUtil.manager.checkPlayerBlockEvent(pp, eventType, location, lb, true)) {
        event.setCancelled(true);
    }
}

Output:
                     break;
-                } else if (id < 198) {
+                }
+                if (id < 198) {
                     location = BukkitUtil.getLocation(block.getRelative(event.getBlockFace()).getLocation());


Input:
public void setValue(Object newvalue) {
    if (value != null && value.equals(newvalue)) {
        return;
    }
    clearValue();
    if (newvalue == null) {
    } else if (newvalue instanceof String) {
        if ("String_Node_Str".equals(newvalue)) {
            type = CellType.BLANK;
            newvalue = null;
        } else if (isFormula((String) newvalue)) {
            setFormulaValue(((String) newvalue).substring(1));
            return;
        } else {
            type = CellType.STRING;
        }
    } else if (newvalue instanceof FormulaExpression) {
        type = CellType.FORMULA;
    } else if (newvalue instanceof Date) {
        type = CellType.NUMBER;
        newvalue = EngineFactory.getInstance().getCalendarUtil().dateToDoubleValue((Date) newvalue, false);
    } else if (newvalue instanceof Boolean) {
        type = CellType.BOOLEAN;
    } else if (newvalue instanceof Double) {
        type = CellType.NUMBER;
    } else if (newvalue instanceof Number) {
        type = CellType.NUMBER;
        newvalue = ((Number) newvalue).doubleValue();
    } else if (newvalue instanceof ErrorValue) {
        type = CellType.ERROR;
    } else {
        throw new IllegalArgumentException("String_Node_Str" + newvalue + "String_Node_Str");
    }
    value = newvalue;
}

Output:
     }
-    clearValue();
+    clearValue(!(newvalue instanceof FormulaExpression));
     if (newvalue == null) {


Input:
private void refreshToolbarDisabled() {
    Set<UserAction> disabled = new HashSet<UserAction>(_actionDisabled);
    disabled.clear();
    if (getBook() == null) {
        disabled.addAll(Arrays.asList(DefaultUserActionHandler.DisabledAction4BookClosed));
    } else {
        if (getSelectedSheet().isProtected()) {
            disabled.addAll(Arrays.asList(DefaultUserActionHandler.DisabledAction4SheetProtected));
        }
        if (!getSelectedSheet().isAutoFilterEnabled()) {
            disabled.addAll(Arrays.asList(DefaultUserActionHandler.DisabledAction4FilterDisabled));
        }
    }
    smartUpdate("String_Node_Str", convertActionDisabledToJSON(_actionDisabled));
}

Output:
 private void refreshToolbarDisabled() {
-    Set<UserAction> disabled = new HashSet<UserAction>(_actionDisabled);
-    disabled.clear();
-    if (getBook() == null) {
-        disabled.addAll(Arrays.asList(DefaultUserActionHandler.DisabledAction4BookClosed));
-    } else {
-        if (getSelectedSheet().isProtected()) {
-            disabled.addAll(Arrays.asList(DefaultUserActionHandler.DisabledAction4SheetProtected));
-        }
-        if (!getSelectedSheet().isAutoFilterEnabled()) {
-            disabled.addAll(Arrays.asList(DefaultUserActionHandler.DisabledAction4FilterDisabled));
-        }
+    if (!isInvalidated()) {
+        smartUpdate("String_Node_Str", convertActionDisabledToJSON(getDisabledUserAction()));
     }


Input:
public Set<MetadataRecord> getSnapshotBeforeTime(MetadataScope scope, final Set<Id.NamespacedId> entityIds, final long timeMillis) {
    Set<MetadataHistoryEntry> metadataHistoryEntries = execute(new TransactionExecutor.Function<MetadataDataset, Set<MetadataHistoryEntry>>() {
        public Set<MetadataHistoryEntry> apply(MetadataDataset input) throws Exception {
            return input.getSnapshotBeforeTime(entityIds, timeMillis);
        }
    }, scope);
    ImmutableSet.Builder<MetadataRecord> builder = ImmutableSet.builder();
    for (MetadataHistoryEntry metadataHistoryEntry : metadataHistoryEntries) {
        builder.add(new MetadataRecord(metadataHistoryEntry.getEntityId(), scope, metadataHistoryEntry.getProperties(), metadataHistoryEntry.getTags()));
    }
    return builder.build();
}

Output:
     ImmutableSet.Builder<MetadataRecord> builder = ImmutableSet.builder();
-    for (MetadataHistoryEntry metadataHistoryEntry : metadataHistoryEntries) {
-        builder.add(new MetadataRecord(metadataHistoryEntry.getEntityId(), scope, metadataHistoryEntry.getProperties(), metadataHistoryEntry.getTags()));
+    for (Metadata metadata : metadataHistoryEntries) {
+        builder.add(new MetadataRecord(metadata.getEntityId(), scope, metadata.getProperties(), metadata.getTags()));
     }


Input:
private static List findFormulasInRow(Sheet sheet, org.apache.poi.ss.usermodel.Row hssfRow) {
    List formulas = new ArrayList();
    if (hssfRow != null) {
        Row row = new Row(sheet, hssfRow);
        CellParser cellParser;
        Formula formula;
        Cell hssfCell;
        for (int i = hssfRow.getFirstCellNum(); i <= hssfRow.getLastCellNum(); i++) {
            hssfCell = hssfRow.getCell(i);
            if (hssfCell != null) {
                cellParser = new CellParser(hssfCell, row, sheet.getConfiguration());
                if (cellParser.parseCellFormula() != null && !cellParser.getCell().getFormula().isInline()) {
                    formula = cellParser.getCell().getFormula();
                    formula.setSheet(sheet);
                    formulas.add(formula);
                }
            }
        }
    }
    return formulas;
}

Output:
         Cell hssfCell;
-        for (int i = hssfRow.getFirstCellNum(); i <= hssfRow.getLastCellNum(); i++) {
+        for (int i = hssfRow.getFirstCellNum(); i <= hssfRow.getLastCellNum() && i > -1; i++) {
             hssfCell = hssfRow.getCell(i);


Input:
private RStarNode loadNode(long nodeId) {
    if (nodeId != -1) {
        try {
            return storage.loadNode(nodeId);
        } catch (FileNotFoundException e) {
            System.err.println("String_Node_Str" + storage.constructFilename(nodeId));
        }
    }
    return null;
}

Output:
         try {
-            return storage.loadNode(nodeId);
+            if (nodeId == rootPointer) {
+                loadRoot();
+                return root;
+            } else {
+                return storage.loadNode(nodeId);
+            }
         } catch (FileNotFoundException e) {


Input:
public Iterator firingIterator() {
    if (_firing == null) {
        _firing = new LinkedList();
        _firing.add(this);
    }
    return _firing.iterator();
}

Output:
     if (_firing == null) {
-        _firing = new LinkedList();
-        _firing.add(this);
+        _firing = Collections.singletonList(this);
     }


Input:
private void convertDesignS3URLs() {
    for (Sample s : this.design.getSamples()) {
        final List<String> readsSources = s.getMetadata().getReads();
        for (int i = 0; i < readsSources.size(); i++) readsSources.set(i, convertS3URL(readsSources.get(i)));
        s.getMetadata().setReads(readsSources);
        if (s.getMetadata().isGenomeField())
            s.getMetadata().setGenome(convertS3URL(s.getMetadata().getGenome()));
        if (s.getMetadata().isAnnotationField())
            s.getMetadata().setAnnotation(convertS3URL(s.getMetadata().getAnnotation()));
    }
}

Output:
     for (Sample s : this.design.getSamples()) {
-        final List<String> readsSources = s.getMetadata().getReads();
+        final List<String> readsSources = Lists.newArrayList(s.getMetadata().getReads());
         for (int i = 0; i < readsSources.size(); i++) readsSources.set(i, convertS3URL(readsSources.get(i)));


Input:
public void renderDetailPanel(EvaluatedDescription desc) {
    accuracy.setVisible(false);
    accuracyText.setVisible(false);
    concept.setVisible(false);
    conceptText.setVisible(false);
    eval = desc;
    this.setInformation();
    p = new GraphicalCoveragePanel(eval, model, conceptText.getText(), this);
    p.setBounds(5, 0, 600, 350);
    unsetEverything();
    conceptPanel.removeAll();
    conceptPanel.add(concept);
    conceptPanel.add(accuracy);
    conceptPanel.add(conceptText);
    conceptPanel.add(accuracyText);
    conceptPanel.setVisible(true);
    this.add(p);
    this.addPropertyChangeListener(handler);
    this.repaint();
}

Output:
     p = new GraphicalCoveragePanel(eval, model, conceptText.getText(), this);
-    p.setBounds(5, 0, 600, 350);
+    p.setBounds(5, 0, 600, 700);
     unsetEverything();


Input:
public String toString() {
    return "String_Node_Str" + username + "String_Node_Str" + url + "String_Node_Str" + id + "String_Node_Str" + clusterName + "String_Node_Str" + dbName + "String_Node_Str" + masterSlave + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + username + "String_Node_Str" + url + "String_Node_Str" + id + "String_Node_Str" + clusterName + "String_Node_Str" + dbName + "String_Node_Str" + masterSlave + "String_Node_Str";
+    return "String_Node_Str" + url + "String_Node_Str" + id + "String_Node_Str" + clusterName + "String_Node_Str" + dbName + "String_Node_Str" + masterSlave + "String_Node_Str";
 }


Input:
public VmwareHypervisorHost getHyperHost(VmwareContext context, Command cmd) {
    String guid = cmd.getContextParam("String_Node_Str");
    assert (guid != null);
    String[] tokens = guid.split("String_Node_Str");
    assert (tokens != null && tokens.length == 2);
    ManagedObjectReference morHyperHost = new ManagedObjectReference();
    String[] hostTokens = tokens[0].split("String_Node_Str");
    if (hostTokens == null || hostTokens.length != 2) {
        s_logger.error("String_Node_Str");
        return null;
    }
    morHyperHost.setType(hostTokens[0]);
    morHyperHost.setValue(hostTokens[1]);
    if (morHyperHost.getProtocol().equalsIgnoreCase("String_Node_Str")) {
        HostMO hostMo = new HostMO(context, morHyperHost);
        try {
            ManagedObjectReference mor = hostMo.getHyperHostCluster();
            ClusterMO clusterMo = new ClusterMO(hostMo.getContext(), mor);
            List<Pair<ManagedObjectReference, String>> hostsInCluster = clusterMo.getClusterHosts();
            for (Pair<ManagedObjectReference, String> hostPair : hostsInCluster) {
                HostMO hostIteratorMo = new HostMO(hostMo.getContext(), hostPair.first());
                VmwareHypervisorHostNetworkSummary netSummary = hostIteratorMo.getHyperHostNetworkSummary(hostIteratorMo.getHostType() == VmwareHostType.ESXi ? cmd.getContextParam("String_Node_Str") : cmd.getContextParam("String_Node_Str"));
                _resource.ensureOutgoingRuleForAddress(netSummary.getHostIp());
                s_logger.info("String_Node_Str" + netSummary.getHostIp());
            }
        } catch (Throwable e) {
            s_logger.warn("String_Node_Str" + e.toString() + "String_Node_Str" + hostTokens[0] + "String_Node_Str" + hostTokens[1]);
        }
        return hostMo;
    }
    assert (false);
    return new ClusterMO(context, morHyperHost);
}

Output:
     morHyperHost.setValue(hostTokens[1]);
-    if (morHyperHost.getProtocol().equalsIgnoreCase("String_Node_Str")) {
+    if (morHyperHost.getType().equalsIgnoreCase("String_Node_Str")) {
         HostMO hostMo = new HostMO(context, morHyperHost);


Input:
public long hashShort(short input) {
    input = NATIVE_XX.toLittleEndian(input);
    long hash = seed() + P5 + 2;
    hash ^= (input & 0xFF) * P5;
    hash = Long.rotateLeft(hash, 11) * P1;
    hash ^= (input >> 8 & 0xFF) * P5;
    hash = Long.rotateLeft(hash, 11) * P1;
    return XxHash_r39.finalize(hash);
}

Output:
     long hash = seed() + P5 + 2;
-    hash ^= (input & 0xFF) * P5;
+    hash ^= Primitives.unsignedByte(input) * P5;
     hash = Long.rotateLeft(hash, 11) * P1;


Input:
public <T extends Record> OutputGate<T> createAndRegisterOutputGate(final ChannelSelector<T> selector, final boolean isBroadcast) {
    if (this.unboundOutputGates == null) {
        final RuntimeOutputGate<T> rog = new RuntimeOutputGate<T>(getJobID(), null, getNumberOfOutputGates(), ChannelType.NETWORK, CompressionLevel.NO_COMPRESSION, selector, isBroadcast, null);
        this.outputGates.add(rog);
        return rog;
    }
    final GateDeploymentDescriptor gdd = this.unboundOutputGates.poll();
    if (gdd == null) {
        throw new IllegalStateException("String_Node_Str");
    }
    RecordSerializerFactory<T> serializerFactory;
    if (gdd.spanningRecordsAllowed()) {
        serializerFactory = new SpanningRecordSerializerFactory<T>();
    } else {
        serializerFactory = new DefaultRecordSerializerFactory<T>();
    }
    final RuntimeOutputGate<T> rog = new RuntimeOutputGate<T>(getJobID(), gdd.getGateID(), getNumberOfInputGates(), gdd.getChannelType(), gdd.getCompressionLevel(), selector, isBroadcast, serializerFactory);
    this.outputGates.add(rog);
    return rog;
}

Output:
     }
-    final RuntimeOutputGate<T> rog = new RuntimeOutputGate<T>(getJobID(), gdd.getGateID(), getNumberOfInputGates(), gdd.getChannelType(), gdd.getCompressionLevel(), selector, isBroadcast, serializerFactory);
+    final RuntimeOutputGate<T> rog = new RuntimeOutputGate<T>(getJobID(), gdd.getGateID(), getNumberOfOutputGates(), gdd.getChannelType(), gdd.getCompressionLevel(), selector, isBroadcast, serializerFactory);
     this.outputGates.add(rog);


Input:
public static String convertValueToString(Object value) {
    String stringVal;
    if (value != null) {
        TypeConverter typeConverter = FlowManager.getTypeConverterForClass(value.getClass());
        if (typeConverter != null) {
            value = typeConverter.getDBValue(value);
        }
    }
    if (value instanceof Number) {
        stringVal = String.valueOf(value);
    } else {
        if (value instanceof NameAlias) {
            stringVal = ((NameAlias) value).getQuery();
        } else if (value instanceof SQLCondition) {
            QueryBuilder queryBuilder = new QueryBuilder();
            ((SQLCondition) value).appendConditionToQuery(queryBuilder);
            stringVal = queryBuilder.toString();
        } else if (value instanceof Query) {
            stringVal = ((Query) value).getQuery();
        } else {
            stringVal = String.valueOf(value);
            if (!stringVal.equals(Condition.Operation.EMPTY_PARAM)) {
                stringVal = DatabaseUtils.sqlEscapeString(stringVal);
            }
        }
    }
    return stringVal;
}

Output:
     } else {
-        if (value instanceof NameAlias) {
+        if (appendInnerQueryParenthesis && value instanceof BaseModelQueriable) {
+            stringVal = String.format("String_Node_Str", ((BaseModelQueriable) value).getQuery().trim());
+        } else if (value instanceof NameAlias) {
             stringVal = ((NameAlias) value).getQuery();


Input:
private void writeMappedField(BasicDBObject dbObject, MappedField mf, Object entity, Map<Object, DBObject> involvedObjects) {
    Class<? extends Annotation> annType = null;
    if (mf.hasAnnotation(NotSaved.class))
        return;
    for (Class<? extends Annotation> testType : new Class[] { Property.class, Embedded.class, Serialized.class, Reference.class }) {
        if (mf.hasAnnotation(testType)) {
            annType = testType;
            break;
        }
    }
    if (Property.class.equals(annType) || Serialized.class.equals(annType) || mf.isTypeMongoCompatible() || (converters.hasSimpleValueConverter(mf) || (converters.hasSimpleValueConverter(mf.getFieldValue(entity)))))
        opts.valueMapper.toDBObject(entity, mf, dbObject, involvedObjects, this);
    else if (Reference.class.equals(annType))
        opts.referenceMapper.toDBObject(entity, mf, dbObject, involvedObjects, this);
    else if (Embedded.class.equals(annType)) {
        opts.embeddedMapper.toDBObject(entity, mf, dbObject, involvedObjects, this);
    } else {
        logger.debug("String_Node_Str" + opts.defaultMapper + "String_Node_Str" + mf);
        opts.defaultMapper.toDBObject(entity, mf, dbObject, involvedObjects, this);
    }
}

Output:
     } else {
-        logger.debug("String_Node_Str" + opts.defaultMapper + "String_Node_Str" + mf);
+        log.debug("String_Node_Str" + opts.defaultMapper + "String_Node_Str" + mf);
         opts.defaultMapper.toDBObject(entity, mf, dbObject, involvedObjects, this);


Input:
public static void writePointOfInterest(Context context, String recordId) {
    if (context == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    String mOutputPath = Environment.getExternalStorageDirectory().getPath();
    mOutputPath += context.getString(R.string.system_path_binary_data);
    if (FileUtils.isDirectoryWritable(mOutputPath) == false) {
        Log.e(TAG, "String_Node_Str");
        return;
    }
    ContentResolver mContentResolver = context.getContentResolver();
    Uri mContentUri = Uri.parse(PointsOfInterestContract.CONTENT_URI.toString() + "String_Node_Str" + recordId);
    Cursor mCursor = mContentResolver.query(mContentUri, null, null, null, null);
    if (mCursor.getCount() == 0) {
        Log.e(TAG, "String_Node_Str");
        return;
    }
    mCursor.moveToFirst();
    String mPhotoName = mCursor.getString(mCursor.getColumnIndex(PointsOfInterestContract.Table.PHOTO));
    if (mPhotoName != null) {
        Rhizome.addFile(context, MediaUtils.getMediaStore() + mPhotoName);
    }
    String mFileName = mCursor.getString(mCursor.getColumnIndex(LocationsContract.Table.PHONE_NUMBER));
    mFileName = mFileName.replace("String_Node_Str", "String_Node_Str");
    mFileName = mFileName.replace("String_Node_Str", "String_Node_Str");
    mFileName = mFileName + "String_Node_Str" + TimeUtils.getTodayWithHour() + BinaryFileContract.POI_EXT;
    FileOutputStream mOutput = null;
    try {
        try {
            mOutput = new FileOutputStream(mOutputPath + mFileName, true);
            BinaryFileContract.writeLocationRecord(mCursor, mOutput);
        } finally {
            mOutput.close();
        }
        Rhizome.addFile(context, mOutputPath + mFileName);
    } catch (FileNotFoundException e) {
        Log.e(TAG, "String_Node_Str", e);
    } catch (IOException e) {
        Log.e(TAG, "String_Node_Str", e);
    } finally {
        try {
            if (mOutput != null) {
                mOutput.close();
            }
        } catch (IOException e) {
            Log.e(TAG, "String_Node_Str", e);
        }
        mCursor.close();
    }
}

Output:
             mOutput = new FileOutputStream(mOutputPath + mFileName, true);
-            BinaryFileContract.writeLocationRecord(mCursor, mOutput);
+            BinaryFileContract.writePointOfInterestRecord(mCursor, mOutput);
         } finally {


Input:
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    HttpServletResponse httpResponse = servlet.httpResponse(response);
    if (request.getAttribute("String_Node_Str") != null) {
        chain.doFilter(request, response);
        return;
    }
    request.setAttribute("String_Node_Str", "String_Node_Str");
    Span span = handler.handleReceive(extractor, httpRequest);
    request.setAttribute(SpanCustomizer.class.getName(), span.customizer());
    request.setAttribute(TraceContext.class.getName(), span.context());
    Throwable error = null;
    try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
        chain.doFilter(httpRequest, httpResponse);
    } catch (IOException | ServletException | RuntimeException | Error e) {
        error = e;
        throw e;
    } finally {
        if (servlet.isAsync(httpRequest)) {
            servlet.handleAsync(handler, httpRequest, span);
        } else {
            handler.handleSend(ADAPTER.adaptResponse(httpRequest, httpResponse), error, span);
        }
    }
}

Output:
     HttpServletResponse httpResponse = servlet.httpResponse(response);
-    if (request.getAttribute("String_Node_Str") != null) {
-        chain.doFilter(request, response);
+    TraceContext context = (TraceContext) request.getAttribute(TraceContext.class.getName());
+    if (context != null) {
+        Scope scope = currentTraceContext.maybeScope(context);
+        try {
+            chain.doFilter(request, response);
+        } finally {
+            scope.close();
+        }
         return;


Input:
private TableViewer createSectionPart(Composite parentComp, final List<Column> columnList, String title, String hyperlinkText) {
    Section columnSetElementSection = masterPage.createSection(form, parentComp, title, null);
    Composite sectionComp = toolkit.createComposite(columnSetElementSection);
    sectionComp.setLayout(new GridLayout());
    Hyperlink selectColumnBtn = toolkit.createHyperlink(sectionComp, hyperlinkText, SWT.NONE);
    GridDataFactory.fillDefaults().align(SWT.BEGINNING, SWT.BEGINNING).applyTo(selectColumnBtn);
    Composite columsComp = toolkit.createComposite(sectionComp, SWT.NULL);
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.BEGINNING).grab(true, true).applyTo(columsComp);
    columsComp.setLayout(new GridLayout());
    final TableViewer columnsElementViewer = createTreeViewer(columnList, columsComp);
    tableViewerPosStack.add(columnsElementViewer);
    TableViewerDNDDecorate dndDecorate = new TableViewerDNDDecorate(allowColumnDupcation);
    dndDecorate.installDND(columnsElementViewer, true, TableViewerDNDDecorate.COLUMN_VALIDATETYPE);
    Composite buttonsComp = toolkit.createComposite(columsComp, SWT.NULL);
    buttonsComp.setLayout(new GridLayout(4, true));
    buttonsComp.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    final Button delButton = new Button(buttonsComp, SWT.NULL);
    delButton.setImage(ImageLib.getImage(ImageLib.DELETE_ACTION));
    GridData buttonGridData = new GridData(GridData.FILL_BOTH);
    delButton.setLayoutData(buttonGridData);
    final Button moveUpButton = new Button(buttonsComp, SWT.NULL);
    moveUpButton.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    moveUpButton.setLayoutData(buttonGridData);
    final Button moveDownButton = new Button(buttonsComp, SWT.NULL);
    moveDownButton.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    moveDownButton.setLayoutData(buttonGridData);
    Button sortButton = new Button(buttonsComp, SWT.NULL);
    sortButton.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    sortButton.setLayoutData(buttonGridData);
    final Button[] buttons = new Button[] { delButton, moveUpButton, moveDownButton };
    columnsElementViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            enabledButtons(buttons, event.getSelection() != null);
        }
    });
    createTableViewerMenu(columnsElementViewer, columnList, buttons);
    delButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            columnList.removeAll(((IStructuredSelection) columnsElementViewer.getSelection()).toList());
            columnsElementViewer.setInput(columnList);
            enabledButtons(buttons, false);
            masterPage.setDirty(true);
        }
    });
    moveUpButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            moveElement(columnList, columnsElementViewer, false);
        }
    });
    moveDownButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            moveElement(columnList, columnsElementViewer, true);
        }
    });
    sortButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            sortElement(columnList, columnsElementViewer);
        }
    });
    this.enabledButtons(new Button[] { delButton, moveUpButton, moveDownButton }, false);
    final List<Column> columnsOfSectionPart = columnList;
    selectColumnBtn.addHyperlinkListener(new HyperlinkAdapter() {
        public void linkActivated(HyperlinkEvent e) {
            openColumnsSelectionDialog(columnsElementViewer, columnsOfSectionPart);
            enabledButtons(buttons, false);
        }
    });
    columnSetElementSection.setClient(sectionComp);
    return columnsElementViewer;
}

Output:
     tableViewerPosStack.add(columnsElementViewer);
-    TableViewerDNDDecorate dndDecorate = new TableViewerDNDDecorate(allowColumnDupcation);
-    dndDecorate.installDND(columnsElementViewer, true, TableViewerDNDDecorate.COLUMN_VALIDATETYPE);
+    ComparisonTableViewerDNDDecorate dndDecorate = new ComparisonTableViewerDNDDecorate(this, masterPage, tableViewerPosStack, allowColumnDupcation);
+    dndDecorate.installDND(columnsElementViewer, true, ComparisonTableViewerDNDDecorate.COLUMN_VALIDATETYPE);
     Composite buttonsComp = toolkit.createComposite(columsComp, SWT.NULL);


Input:
public static org.hl7.fhir.dstu2016may.model.TestScript.TestScriptContactComponent convertTestScriptContactComponent(org.hl7.fhir.dstu3.model.TestScript.TestScriptContactComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.TestScript.TestScriptContactComponent tgt = new org.hl7.fhir.dstu2016may.model.TestScript.TestScriptContactComponent();
    copyElement(src, tgt);
    tgt.setName(src.getName());
    for (org.hl7.fhir.dstu3.model.ContactPoint t : src.getTelecom()) tgt.addTelecom(convertContactPoint(t));
    return tgt;
}

Output:
 public static org.hl7.fhir.dstu2016may.model.TestScript.TestScriptContactComponent convertTestScriptContactComponent(org.hl7.fhir.dstu3.model.TestScript.TestScriptContactComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public int getLabelSize() {
    return this.labelLayoutSize;
}

Output:
 public int getLabelSize() {
-    return this.labelLayoutSize;
+    return showLabelLayout ? this.labelLayoutSize : 0;
 }


Input:
public Method getMethodFor(Class<?> clazz, String name, Object... args) {
    Method[] methods = clazz.getMethods();
    Method compatibleMethod = null;
    for (Method method : methods) {
        if (method.getName().equals(name)) {
            Class<?>[] params = method.getParameterTypes();
            Type[] types = method.getGenericParameterTypes();
            if (isMethodMatched(params, types, args)) {
                compatibleMethod = method;
                break;
            }
        }
    }
    if (compatibleMethod != null) {
        return compatibleMethod;
    }
    return null;
}

Output:
             if (isMethodMatched(params, types, args)) {
-                compatibleMethod = method;
-                break;
+                return method;
             }


Input:
public void run(Uri u, IImage image) {
    if (image == null) {
        return;
    }
    float lat = getLatLng((Image) image, ExifInterface.TAG_GPS_LATITUDE);
    float lng = getLatLng((Image) image, ExifInterface.TAG_GPS_LONGITUDE);
    if (lat == INVALID_LATLNG || lng == INVALID_LATLNG) {
        handler.post(new Runnable() {
            public void run() {
                Toast.makeText(activity, R.string.no_location_image, Toast.LENGTH_SHORT).show();
            }
        });
        return;
    }
    String uri = "String_Node_Str" + "String_Node_Str" + lat + "String_Node_Str" + lng + "String_Node_Str";
    activity.startActivity(new Intent(android.content.Intent.ACTION_VIEW, Uri.parse(uri)));
}

Output:
     }
-    float lat = getLatLng((Image) image, ExifInterface.TAG_GPS_LATITUDE);
-    float lng = getLatLng((Image) image, ExifInterface.TAG_GPS_LONGITUDE);
-    if (lat == INVALID_LATLNG || lng == INVALID_LATLNG) {
+    float[] latlng = getLatLng(getExifData(image));
+    if (latlng == null) {
         handler.post(new Runnable() {


Input:
public double getLearningRate() {
    return config.getLearningRate();
}

Output:
 public double getLearningRate() {
-    return config.getLearningRate();
+    return getConfig().getLearningRate();
 }


Input:
public void GameScreen() {
    if (GameScreen == null) {
        GameScreen = new Scene(5);
        GameScreen.setBackground(base.autoParallaxBackground);
        base.loadCastle(base.getCameraWidth() - (base.getCastleTexture().getWidth()), base.getCameraHeight() - 60 - base.getCastleTexture().getHeight());
        base.CustomHUD.RefreshHUD();
        base.CustomHUD.HideValues(false);
        base.sm.GameScreen.registerUpdateHandler(new IUpdateHandler() {
            public void onUpdate(float pSecondsElapsed) {
                if (base.sPreviousWaveNum != base.theWave.getWaveNumber() && base.sKillCount != base.sPreviousKillCount)
                    if ((base.sKillCount - base.sPreviousKillCount) == base.theWave.getNumberEnemysToSpawn()) {
                        base.theWave.mCashAmountItem.setText("String_Node_Str" + base.sMoney);
                        base.theWave.mBuyMenuItem.setText("String_Node_Str" + base.sCastle.getCurrentHealth() + "String_Node_Str" + base.sCastle.getMaxHealth());
                        base.sEndWaveActive = true;
                        base.sPreviousWaveNum = base.theWave.getWaveNumber();
                        base.sPreviousKillCount += base.theWave.getNumberEnemysToSpawn();
                        base.sm.EndWaveScreen();
                    }
                if (base.lightning != null)
                    if (base.lightning.isAnimationRunning() == false) {
                        base.sm.GameScreen.detachChild(base.lightning);
                        if (base.mLightningBolt == true)
                            base.sm.GameScreen.registerUpdateHandler(new TimerHandler(1 / 4.0f, true, new ITimerCallback() {
                                public void onTimePassed(TimerHandler pTimerHandler) {
                                    base.sm.GameScreen.unregisterUpdateHandler(pTimerHandler);
                                    base.mLightningBolt = false;
                                    base.mLightningBoltX = 0;
                                    base.mLightningBoltY = 0;
                                }
                            }));
                    }
                if (base.mEarthquake == true) {
                    base.mEarthquake = false;
                    base.mEarthQuaking = true;
                    base.sm.GameScreen.registerUpdateHandler(new TimerHandler(1 / 6.0f, new ITimerCallback() {
                        public void onTimePassed(TimerHandler pTimerHandler) {
                            currentEarthDuration++;
                            if (currentEarthDuration >= EarthQuakeDuration) {
                                base.sm.GameScreen.unregisterUpdateHandler(pTimerHandler);
                                currentEarthDuration = 0;
                                base.sCamera.setCenter(base.sCamera.getWidth() / 2, base.sCamera.getHeight() / 2);
                                base.backgroundSprite1.setPosition(0.0f, 0.0f + (base.getCameraHeight() - base.getParallaxLayerBack().getHeight()));
                                base.backgroundSprite2.setPosition(0.0f, 0.0f + 80);
                                base.backgroundSprite3.setPosition(0.0f + 35, 0.0f + 62);
                                base.mEarthQuaking = false;
                            } else {
                                if (currentEarthDuration % 6 == 0 || currentEarthDuration == 1) {
                                    if ((base.mana - 500) >= 0) {
                                        base.mana -= 500;
                                        base.CustomHUD.updateManaValue();
                                        float theX = MathUtils.random(-10.0f, 10.0f);
                                        float theY = MathUtils.random(-10.0f, 10.0f);
                                        base.sCamera.offsetCenter(theX, theY);
                                        base.backgroundSprite1.setPosition(base.backgroundSprite1.getX() - theX, base.backgroundSprite1.getY() - theY);
                                        base.backgroundSprite2.setPosition(base.backgroundSprite2.getX() - theX, base.backgroundSprite2.getY() - theY);
                                        base.backgroundSprite3.setPosition(base.backgroundSprite3.getX() - theX, base.backgroundSprite3.getY() - theY);
                                        base.mEarthQuaking = true;
                                    } else {
                                        base.mEarthQuaking = false;
                                        currentEarthDuration = EarthQuakeDuration;
                                    }
                                } else {
                                    float theX = MathUtils.random(-10.0f, 10.0f);
                                    float theY = MathUtils.random(-10.0f, 10.0f);
                                    base.sCamera.offsetCenter(theX, theY);
                                    base.backgroundSprite1.setPosition(base.backgroundSprite1.getX() - theX, base.backgroundSprite1.getY() - theY);
                                    base.backgroundSprite2.setPosition(base.backgroundSprite2.getX() - theX, base.backgroundSprite2.getY() - theY);
                                    base.backgroundSprite3.setPosition(base.backgroundSprite3.getX() - theX, base.backgroundSprite3.getY() - theY);
                                    base.mEarthQuaking = false;
                                }
                                pTimerHandler.reset();
                            }
                        }
                    }));
                }
            }
            public void reset() {
            }
        });
    }
    if (base.CustomHUD.getHud() != null)
        base.CustomHUD.HideValues(false);
    GameScreen.setOnAreaTouchTraversalFrontToBack();
    base.getEngine().setScene(GameScreen);
    CameraSet();
    base.CustomHUD.RefreshHUD();
}

Output:
     if (GameScreen == null) {
-        GameScreen = new Scene(5);
+        GameScreen = new Scene();
         GameScreen.setBackground(base.autoParallaxBackground);


Input:
public short[][] generateChunk(final World world, RegionWrapper region, final PseudoRandom random, final int cx, final int cz, final BiomeGrid biomes, final short[][] result) {
    if (this.doState) {
        final int prime = 13;
        int h = 1;
        h = (prime * h) + cx;
        h = (prime * h) + cz;
        this.state = h;
    }
    if (this.plotworld.PLOT_BEDROCK) {
        for (short x = 0; x < 16; x++) {
            for (short z = 0; z < 16; z++) {
                setBlock(this.result, x, 0, z, (short) 7);
            }
        }
    }
    if (region != null) {
        final int X = cx << 4;
        final int Z = cz << 4;
        int sx = ((X) % this.size);
        int sz = ((Z) % this.size);
        if (sx < 0) {
            sx += this.size;
        }
        if (sz < 0) {
            sz += this.size;
        }
        for (short x = 0; x < 16; x++) {
            for (short z = 0; z < 16; z++) {
                if (biomes != null) {
                    biomes.setBiome(x, z, this.biome);
                }
                if (contains(region, x, z)) {
                    for (short y = 1; y < this.plotheight; y++) {
                        setBlock(this.result, x, y, z, this.filling);
                    }
                    setBlock(this.result, x, this.plotheight, z, this.plotfloors);
                    final PlotLoc loc = new PlotLoc((short) (X + x), (short) (Z + z));
                    final HashMap<Short, Short> blocks = plotworld.G_SCH.get(loc);
                    if (blocks != null) {
                        for (final Entry<Short, Short> entry : blocks.entrySet()) {
                            setBlock(this.result, x, this.plotheight + entry.getKey(), z, entry.getValue());
                        }
                    }
                }
            }
        }
        return this.result;
    }
    int sx = ((cx << 4) % this.size);
    int sz = ((cz << 4) % this.size);
    if (sx < 0) {
        sx += this.size;
    }
    if (sz < 0) {
        sz += this.size;
    }
    for (short x = 0; x < 16; x++) {
        for (short z = 0; z < 16; z++) {
            if (biomes != null) {
                biomes.setBiome(x, z, this.biome);
            }
            final int absX = ((sx + x) % this.size);
            final int absZ = ((sz + z) % this.size);
            final boolean gx = absX > this.pathWidthLower;
            final boolean gz = absZ > this.pathWidthLower;
            final boolean lx = absX < this.pathWidthUpper;
            final boolean lz = absZ < this.pathWidthUpper;
            if (gx && gz && lx && lz) {
                for (short y = 1; y < this.plotheight; y++) {
                    setBlock(this.result, x, y, z, this.filling);
                }
                setBlock(this.result, x, this.plotheight, z, this.plotfloors);
                if (this.plotworld.PLOT_SCHEMATIC) {
                    final PlotLoc loc = new PlotLoc((short) absX, (short) absZ);
                    final HashMap<Short, Short> blocks = this.plotworld.G_SCH.get(loc);
                    if (blocks != null) {
                        for (final Entry<Short, Short> entry : blocks.entrySet()) {
                            setBlock(this.result, x, this.plotheight + entry.getKey(), z, entry.getValue());
                        }
                    }
                }
            } else {
                if (((absX >= this.pathWidthLower) && (absX <= this.pathWidthUpper) && (absZ >= this.pathWidthLower) && (absZ <= this.pathWidthUpper))) {
                    for (short y = 1; y <= this.wallheight; y++) {
                        setBlock(this.result, x, y, z, this.wallfilling);
                    }
                    if (!this.plotworld.ROAD_SCHEMATIC_ENABLED) {
                        setBlock(this.result, x, this.wallheight + 1, z, this.wall);
                    }
                } else {
                    for (short y = 1; y <= this.roadheight; y++) {
                        setBlock(this.result, x, y, z, this.roadblock);
                    }
                }
                if (this.plotworld.ROAD_SCHEMATIC_ENABLED) {
                    final PlotLoc loc = new PlotLoc((short) absX, (short) absZ);
                    final HashMap<Short, Short> blocks = this.plotworld.G_SCH.get(loc);
                    if (blocks != null) {
                        for (final Entry<Short, Short> entry : blocks.entrySet()) {
                            setBlock(this.result, x, this.roadheight + entry.getKey(), z, entry.getValue());
                        }
                    }
                }
            }
        }
    }
    return this.result;
}

Output:
             for (short z = 0; z < 16; z++) {
-                setBlock(this.result, x, 0, z, (short) 7);
+                setBlock(x, 0, z, (short) 7);
             }


Input:
public void AssertNotObstruction(BlockRecord Record) throws CarriageMotionException {
    if (Body.contains(Record)) {
        return;
    }
    if (World.isAirBlock(Record.X, Record.Y, Record.Z)) {
        return;
    }
    if (World.getBlock(Record.X, Record.Y, Record.Z).getMaterial().isLiquid()) {
        if (ObstructedByLiquids) {
            FailBecauseObstructed(Record, "String_Node_Str");
        }
        return;
    }
    if (World.getBlock(Record.X, Record.Y, Record.Z).canBeReplacedByLeaves(World, Record.X, Record.Y, Record.Z)) {
        if (ObstructedByFragileBlocks) {
            FailBecauseObstructed(Record, "String_Node_Str");
        }
        return;
    }
    FailBecauseObstructed(Record, "String_Node_Str");
}

Output:
     }
-    if (World.isAirBlock(Record.X, Record.Y, Record.Z)) {
+    if (World.isAirBlock(record.X, record.Y, record.Z))
         return;


Input:
private String normalizeJumpToValue(String value) throws BrowseException {
    if (scope.hasJumpToValue()) {
        return OrderFormat.makeSortString(scope.getJumpToValue(), scope.setJumpToValueLang(), scope.getBrowseIndex().getDataType());
    } else if (scope.hasStartsWith()) {
        return OrderFormat.makeSortString(scope.getStartsWith(), null, scope.getBrowseIndex().getDataType());
    }
    return value;
}

Output:
     if (scope.hasJumpToValue()) {
-        return OrderFormat.makeSortString(scope.getJumpToValue(), scope.setJumpToValueLang(), scope.getBrowseIndex().getDataType());
+        return OrderFormat.makeSortString(scope.getJumpToValue(), scope.getJumpToValueLang(), scope.getBrowseIndex().getDataType());
     } else if (scope.hasStartsWith()) {


Input:
public void run() {
    do {
        try {
            this.task = this.msgQueue.take();
            if (this.task != null) {
                Logs.extreme().debug(EventType.QUEUE + "String_Node_Str" + this.task + "String_Node_Str" + Thread.currentThread().getName());
                try {
                    this.task.run();
                } catch (final Exception ex) {
                    Exceptions.maybeInterrupted(ex);
                    Logs.extreme().error(ex, ex);
                }
            }
        } catch (final InterruptedException e) {
            Exceptions.maybeInterrupted(e);
            return;
        }
    } while (!this.msgQueue.isEmpty() || this.running.get());
    Logs.extreme().debug("String_Node_Str" + this.owner + "String_Node_Str" + this.name + "String_Node_Str" + Thread.currentThread().getName());
}

Output:
         try {
-            this.task = this.msgQueue.take();
-            if (this.task != null) {
-                Logs.extreme().debug(EventType.QUEUE + "String_Node_Str" + this.task + "String_Node_Str" + Thread.currentThread().getName());
+            final FutureTask<?> futureTask = this.msgQueue.take();
+            if (futureTask != null) {
+                Logs.extreme().debug(EventType.QUEUE + "String_Node_Str" + (this.currentTask = futureTask) + "String_Node_Str" + Thread.currentThread().getName());
                 try {


Input:
private void sortVariables(List<AbstractVariable> variables1, List<AbstractVariable> variables2, List<AbstractVariable> sortedVariables1, List<AbstractVariable> sortedVariables2) {
    boolean requireVariableNameMatch = getRenamedVariables().isEmpty();
    for (int i = 0; i < variables1.size(); i++) {
        AbstractVariable variable1 = variables1.get(i);
        boolean found = false;
        for (int j = 0; j < variables2.size(); j++) {
            AbstractVariable variable2 = variables2.get(j);
            if (requireVariableNameMatch) {
                if (variable2.getVariableName().equals(variable1.getVariableName()) && variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
                    sortedVariables2.add(variable2);
                    found = true;
                    break;
                }
            } else {
                String renamedVariableName = findRenamedVariableName2(variable2);
                if (renamedVariableName != null) {
                    if (variable2.getVariableType().equals(variable1.getVariableType()) && variable1.getVariableName().equals(renamedVariableName) && !sortedVariables2.contains(variable2)) {
                        sortedVariables2.add(variable2);
                        found = true;
                        break;
                    }
                } else if (findRenamedVariableName1(variable1) == null) {
                    if (variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
                        sortedVariables2.add(variable2);
                        found = true;
                        break;
                    }
                }
            }
        }
        if (found) {
            sortedVariables1.add(variable1);
        }
    }
}

Output:
                 } else if (findRenamedVariableName1(variable1) == null) {
-                    if (variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
+                    if (variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2) && !appearsInMultipleDifferences(variable1) && !appearsInMultipleDifferences(variable2)) {
                         sortedVariables2.add(variable2);


Input:
private boolean checkLimits(MapContainer mapContainer) {
    MaxSizeConfig maxSizeConfig = mapContainer.getMapConfig().getMaxSizeConfig();
    MaxSizeConfig.MaxSizePolicy maxSizePolicy = maxSizeConfig.getMaxSizePolicy();
    String mapName = mapContainer.getName();
    int maxSize = maxSizeConfig.getSize() * 95 / 100;
    if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_NODE || maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
        int totalSize = 0;
        for (int i = 0; i < nodeEngine.getPartitionService().getPartitionCount(); i++) {
            Address owner = nodeEngine.getPartitionService().getPartitionOwner(i);
            if (nodeEngine.getThisAddress().equals(owner)) {
                final PartitionContainer container = partitionContainers[i];
                if (container == null) {
                    return false;
                }
                int size = container.getRecordStore(mapName).getRecords().size();
                if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
                    if (size >= maxSize) {
                        return true;
                    }
                } else {
                    totalSize += size;
                }
            }
        }
        return maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_NODE && totalSize >= maxSize;
    }
    if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_SIZE || maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_PERCENTAGE) {
        final long total = Runtime.getRuntime().totalMemory();
        final long used = mapContainer.getSizeEstimator().getSize();
        if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_SIZE) {
            return maxSize < (used / 1024 / 1024);
        } else {
            return maxSize < (used / total);
        }
    }
    return false;
}

Output:
         } else {
-            return maxSize < (used / total);
+            return maxSize < (100d * used / total);
         }


Input:
private synchronized Connection doConnect(String driverClass, String url, String jndiNameUrl, Properties connectionProperties) throws SQLException, OdaException {
    assert (url != null);
    IConnectionFactory factory = getDriverConnectionFactory(driverClass);
    if (factory != null) {
        if (logger.isLoggable(Level.FINER))
            logger.finer("String_Node_Str" + driverClass + "String_Node_Str" + url);
        return factory.getConnection(driverClass, url, connectionProperties);
    }
    Connection jndiDSConnection = getJndiDSConnection(driverClass, jndiNameUrl, connectionProperties);
    if (jndiDSConnection != null)
        return jndiDSConnection;
    loadAndRegisterDriver(driverClass);
    if (logger.isLoggable(Level.FINER))
        logger.finer("String_Node_Str" + url);
    try {
        return DriverManager.getConnection(url, connectionProperties);
    } catch (RuntimeException e) {
        throw new JDBCException(ResourceConstants.CONN_GET_ERROR, null, e.getMessage());
    }
}

Output:
         return jndiDSConnection;
-    loadAndRegisterDriver(driverClass);
+    loadAndRegisterDriver(driverClass, driverClassPath);
     if (logger.isLoggable(Level.FINER))


Input:
private void preProcessMetadata() {
    if (optionHasOneOf(new String[] { "String_Node_Str", "String_Node_Str" })) {
        Log.debug("String_Node_Str");
        return;
    }
    Map<String, String> settings = ConfigTools.getSettings();
    if (optionHasOneOf(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" })) {
        String user = options.valueOf("String_Node_Str").toString();
        String pass = options.valueOf("String_Node_Str").toString();
        String connection = options.valueOf("String_Node_Str").toString();
        try {
            meta = new MetadataDB(connection, user, pass);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    } else {
        meta = MetadataFactory.get(settings);
    }
    int workflowRunId = 0;
    int workflowRunAccession = 0;
    ArrayList<Integer> parentIDs = new ArrayList<>();
    processingIDFiles = new ArrayList<>();
    ArrayList<Integer> parentAccessions = new ArrayList<>();
    processingAccessionFiles = new ArrayList<>();
    int ancestorWorkflowRunAccession = 0;
    if (options.has("String_Node_Str")) {
        String outputFile = (String) options.valueOf("String_Node_Str");
        File file = new File(outputFile);
        try {
            if (file.exists() && file.canRead()) {
                String readFileToString = FileUtils.readFileToString(file).trim();
                try {
                    int processingAccessionFromFile = Integer.valueOf(readFileToString);
                    Processing proc = meta.getProcessing(processingAccessionFromFile);
                    if (proc != null) {
                        if (proc.getStatus().equals(ProcessingStatus.success)) {
                            Log.error("String_Node_Str");
                            System.exit(ReturnValue.SUCCESS);
                        }
                    }
                } catch (NumberFormatException | NotFoundException ne) {
                    Log.error("String_Node_Str");
                }
                Log.error("String_Node_Str");
            }
            if ((file.exists() || file.createNewFile()) && file.canWrite()) {
                processingAccessionFileCheck = file;
            } else {
                Log.error("String_Node_Str");
                System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
            }
        } catch (IOException e) {
            Log.error("String_Node_Str" + e.getMessage());
            System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
        }
    }
    if (options.has("String_Node_Str")) {
        workflowRunId = meta.add_workflow_run((Integer) options.valueOf("String_Node_Str"));
        workflowRunAccession = meta.get_workflow_run_accession(workflowRunId);
        for (String outputFile : (List<String>) options.valuesOf("String_Node_Str")) {
            File file = new File(outputFile);
            try {
                if ((file.exists() || file.createNewFile()) && file.canWrite()) {
                    int maxTries = (Integer) options.valueOf("String_Node_Str");
                    for (int i = 0; i < maxTries; i++) {
                        if (LockingFileTools.lockAndAppend(file, workflowRunAccession + System.getProperty("String_Node_Str"))) {
                            break;
                        } else if (i < maxTries) {
                            ProcessTools.sleep((Integer) options.valueOf("String_Node_Str"));
                        } else {
                            ReturnValue retval = new ReturnValue();
                            retval.printAndAppendtoStderr("String_Node_Str");
                            retval.setExitStatus(ReturnValue.METADATAINVALIDIDCHAIN);
                            meta.update_processing_event(workflowRunAccession, retval);
                            meta.update_processing_status(workflowRunAccession, ProcessingStatus.failed);
                            System.exit(retval.getExitStatus());
                        }
                    }
                } else {
                    Log.error("String_Node_Str");
                    System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
                }
            } catch (IOException e) {
                Log.error("String_Node_Str" + e.getMessage());
                System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
            }
            break;
        }
    }
    List<Integer> workflowRunAccessions = (List<Integer>) options.valuesOf("String_Node_Str");
    if (workflowRunAccessions.size() == 1) {
        workflowRunAccession = workflowRunAccessions.get(0);
    }
    for (Integer parent : (List<Integer>) options.valuesOf("String_Node_Str")) {
        parentIDs.add(parent);
    }
    for (String file : (List<String>) options.valuesOf("String_Node_Str")) {
        try {
            BufferedReader r;
            String line;
            r = new BufferedReader(new FileReader(file));
            while ((line = r.readLine()) != null) {
                try {
                    parentIDs.add(Integer.parseInt(line));
                } catch (NumberFormatException ex) {
                    Log.error("String_Node_Str" + line + "String_Node_Str");
                    System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
                }
            }
            r.close();
        } catch (Exception e) {
            Log.error("String_Node_Str" + e.getMessage());
            System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
        }
    }
    for (Integer parent : (List<Integer>) options.valuesOf("String_Node_Str")) {
        parentAccessions.add(parent);
    }
    for (String file : (List<String>) options.valuesOf("String_Node_Str")) {
        try {
            BufferedReader r;
            String line;
            r = new BufferedReader(new FileReader(file));
            while ((line = r.readLine()) != null) {
                try {
                    parentAccessions.add(Integer.parseInt(line));
                } catch (NumberFormatException ex) {
                    Log.error("String_Node_Str" + line + "String_Node_Str");
                    System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
                }
            }
            r.close();
        } catch (Exception e) {
            Log.error("String_Node_Str" + e.getMessage());
            System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
        }
    }
    for (Integer accession : (List<Integer>) options.valuesOf("String_Node_Str")) {
        ancestorWorkflowRunAccession = accession;
    }
    for (String file : (List<String>) options.valuesOf("String_Node_Str")) {
        try {
            BufferedReader r;
            String line;
            r = new BufferedReader(new FileReader(file));
            while ((line = r.readLine()) != null) {
                try {
                    ancestorWorkflowRunAccession = Integer.parseInt(line);
                } catch (NumberFormatException ex) {
                    Log.error("String_Node_Str" + line + "String_Node_Str");
                    System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
                }
            }
            r.close();
        } catch (Exception e) {
            Log.error("String_Node_Str" + e.getMessage());
            System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
        }
    }
    for (String outputFile : (List<String>) options.valuesOf("String_Node_Str")) {
        File file = new File(outputFile);
        try {
            if ((file.exists() || file.createNewFile()) && file.canWrite()) {
                processingIDFiles.add(file);
            } else {
                Log.error("String_Node_Str");
                System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
            }
        } catch (IOException e) {
            Log.error("String_Node_Str" + e.getMessage());
            System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
        }
    }
    for (String outputFile : (List<String>) options.valuesOf("String_Node_Str")) {
        File file = new File(outputFile);
        try {
            if ((file.exists() || file.createNewFile()) && file.canWrite()) {
                processingAccessionFiles.add(file);
            } else {
                Log.error("String_Node_Str");
                System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
            }
        } catch (IOException e) {
            Log.error("String_Node_Str" + e.getMessage());
            System.exit(ReturnValue.METADATAINVALIDIDCHAIN);
        }
    }
    processingAccession = 0;
    if (meta != null) {
        int[] parents = new int[parentIDs.size()];
        for (int i = 0; i < parentIDs.size(); i++) {
            parents[i] = parentIDs.get(i);
        }
        int[] parentAccessionsArray = new int[parentAccessions.size()];
        for (int i = 0; i < parentAccessions.size(); i++) {
            parentAccessionsArray[i] = parentAccessions.get(i);
        }
        ReturnValue metaret;
        if (parentAccessionsArray.length > 0) {
            metaret = meta.add_empty_processing_event_by_parent_accession(parentAccessionsArray);
            if (metaret.getExitStatus() == ReturnValue.SUCCESS) {
                processingID = metaret.getReturnValue();
                processingAccession = meta.mapProcessingIdToAccession(processingID);
                printAndAppendtoStdout("String_Node_Str" + processingAccession);
            } else {
                printAndAppendtoStderr("String_Node_Str" + metaret.getExitStatus());
                if (metaret.getStdout() != null) {
                    printAndAppendtoStdout("String_Node_Str" + metaret.getStdout());
                }
                if (metaret.getStderr() != null) {
                    printAndAppendtoStderr("String_Node_Str" + metaret.getStderr());
                }
                System.exit(ReturnValue.SQLQUERYFAILED);
            }
        } else {
            metaret = meta.add_empty_processing_event(parents);
            if (metaret.getExitStatus() == ReturnValue.SUCCESS) {
                processingID = metaret.getReturnValue();
                processingAccession = meta.mapProcessingIdToAccession(processingID);
                printAndAppendtoStdout("String_Node_Str" + processingAccession);
            } else {
                printAndAppendtoStderr("String_Node_Str" + metaret.getExitStatus());
                if (metaret.getStdout() != null) {
                    printAndAppendtoStdout("String_Node_Str" + metaret.getStdout());
                }
                if (metaret.getStderr() != null) {
                    printAndAppendtoStderr("String_Node_Str" + metaret.getStderr());
                }
                System.exit(ReturnValue.SQLQUERYFAILED);
            }
        }
        if (ancestorWorkflowRunAccession > 0 && processingID > 0) {
            meta.add_workflow_run_ancestor(ancestorWorkflowRunAccession, processingID);
        }
        if (workflowRunAccession > 0 && processingID > 0) {
            meta.update_processing_workflow_run(processingID, workflowRunAccession);
        }
    }
}

Output:
                 if ((file.exists() || file.createNewFile()) && file.canWrite()) {
-                    int maxTries = (Integer) options.valueOf("String_Node_Str");
-                    for (int i = 0; i < maxTries; i++) {
-                        if (LockingFileTools.lockAndAppend(file, workflowRunAccession + System.getProperty("String_Node_Str"))) {
-                            break;
-                        } else if (i < maxTries) {
-                            ProcessTools.sleep((Integer) options.valueOf("String_Node_Str"));
-                        } else {
-                            ReturnValue retval = new ReturnValue();
-                            retval.printAndAppendtoStderr("String_Node_Str");
-                            retval.setExitStatus(ReturnValue.METADATAINVALIDIDCHAIN);
-                            meta.update_processing_event(workflowRunAccession, retval);
-                            meta.update_processing_status(workflowRunAccession, ProcessingStatus.failed);
-                            System.exit(retval.getExitStatus());
-                        }
-                    }
+                    this.writeStringToFile(file, true, workflowRunAccession + System.getProperty("String_Node_Str"));
                 } else {


Input:
public FileDesc addFileIfShared(File file, List metadata) {
    FileDesc fd = super.addFileIfShared(file);
    if (fd == null)
        return null;
    if (metadata == null || metadata.size() == 0) {
        if (!LimeXMLUtils.isMP3File(file))
            return fd;
        LimeXMLDocument doc;
        try {
            doc = ID3Reader.readDocument(file);
        } catch (IOException ioe) {
            return fd;
        }
        metadata = new LinkedList();
        metadata.add(doc);
    }
    SchemaReplyCollectionMapper mapper = SchemaReplyCollectionMapper.instance();
    List schemasAddedTo = new LinkedList();
    for (Iterator iter = metadata.iterator(); iter.hasNext(); ) {
        LimeXMLDocument currDoc = (LimeXMLDocument) iter.next();
        String uri = currDoc.getSchemaURI();
        LimeXMLReplyCollection collection = mapper.getReplyCollection(uri);
        if (collection != null && !schemasAddedTo.contains(uri)) {
            schemasAddedTo.add(uri);
            if (ID3Reader.isCorrupted(currDoc))
                currDoc = ID3Reader.fixCorruption(currDoc);
            collection.addReplyWithCommit(file, fd, currDoc);
        }
    }
    _needRebuild = true;
    return fd;
}

Output:
                 currDoc = ID3Reader.fixCorruption(currDoc);
-            collection.addReplyWithCommit(file, fd, currDoc);
+            collection.addReplyWithCommit(file, fd, currDoc, true);
         }


Input:
private boolean createComponentOnLink(Node node, Point originalPoint) {
    boolean executed = false;
    RootEditPart rep = editor.getViewer().getRootEditPart().getRoot();
    Point viewOriginalPosition = new Point();
    if (rep instanceof ScalableFreeformRootEditPart) {
        ScalableFreeformRootEditPart root = (ScalableFreeformRootEditPart) rep;
        Viewport viewport = (Viewport) root.getFigure();
        viewOriginalPosition = viewport.getViewLocation();
    }
    Point point = new Point(originalPoint.x + viewOriginalPosition.x, originalPoint.y + viewOriginalPosition.y);
    CompoundCommand command = new CompoundCommand();
    org.talend.designer.core.ui.editor.connections.Connection targetConnection = CreateComponentOnLinkHelper.getSelectedConnection();
    for (Object child : editor.getProcessPart().getChildren()) {
        if (child instanceof SubjobContainerPart) {
            CreateComponentOnLinkHelper.unselectAllConnections((SubjobContainerPart) child);
        }
    }
    if (targetConnection != null) {
        NodeContainer nodeContainer = new NodeContainer(node);
        IProcess2 p = editor.getProcess();
        if (p instanceof Process) {
            Process process = (Process) p;
            execCommandStack(new CreateNodeContainerCommand(process, nodeContainer, point));
            INode targetNode = targetConnection.getTarget();
            updateConnectionCommand(targetConnection, node, command);
            execCommandStack(command);
            if (node.getComponent().getName().equals("String_Node_Str")) {
                CreateComponentOnLinkHelper.setupTMap(node);
            }
            if (targetNode.getComponent().getName().equals("String_Node_Str")) {
                CreateComponentOnLinkHelper.updateTMap(targetNode, targetConnection, node.getOutgoingConnections().get(0));
            }
            targetNode.renameData(targetConnection.getName(), node.getOutgoingConnections().get(0).getName());
            executed = true;
        }
    }
    return executed;
}

Output:
         if (p instanceof Process) {
-            Process process = (Process) p;
-            execCommandStack(new CreateNodeContainerCommand(process, nodeContainer, point));
-            INode targetNode = targetConnection.getTarget();
-            updateConnectionCommand(targetConnection, node, command);
-            execCommandStack(command);
+            CreateNodeContainerCommand createCmd = new CreateNodeContainerCommand((Process) p, nodeContainer, point);
+            execCommandStack(createCmd);
+            Node originalTarget = (Node) targetConnection.getTarget();
+            INodeConnector targetConnector = node.getConnectorFromType(EConnectionType.FLOW_MAIN);
+            for (INodeConnector connector : node.getConnectorsFromType(EConnectionType.FLOW_MAIN)) {
+                if (connector.getMaxLinkOutput() != 0) {
+                    targetConnector = connector;
+                    break;
+                }
+            }
+            ConnectionCreateCommand.setCreatingConnection(true);
+            if (PluginChecker.isJobLetPluginLoaded()) {
+                IJobletProviderService service = (IJobletProviderService) GlobalServiceRegister.getDefault().getService(IJobletProviderService.class);
+                if (service != null && service.isJobletComponent(targetConnection.getTarget())) {
+                    if (targetConnection.getTarget() instanceof Node) {
+                        NodeContainer jobletContainer = ((Node) targetConnection.getTarget()).getNodeContainer();
+                        jobletContainer.getInputs().remove(targetConnection);
+                    }
+                }
+            }
+            ConnectionReconnectCommand cmd2 = new ConnectionReconnectCommand(targetConnection);
+            cmd2.setNewTarget(node);
+            execCommandStack(cmd2);
+            List<Object> nodeArgs = CreateComponentOnLinkHelper.getTargetArgs(targetConnection, node);
+            ConnectionCreateCommand nodeCmd = new ConnectionCreateCommand(node, targetConnector.getName(), nodeArgs, false);
+            nodeCmd.setTarget(originalTarget);
+            execCommandStack(nodeCmd);
             if (node.getComponent().getName().equals("String_Node_Str")) {


Input:
void doSaveExpr(String name, Object value) throws DataException {
    if (needsSaveToDoc() == false)
        return;
    if (isBasicSaved == false) {
        isBasicSaved = true;
        this.getRdSave().saveResultIterator(new DummyCachedResult(), -1, null);
    }
    this.getRdSave().saveExprValue(0, name, value);
}

Output:
         isBasicSaved = true;
-        this.getRdSave().saveResultIterator(new DummyCachedResult(), -1, null);
+        int groupLevel;
+        int[] subQueryInfo;
+        if (subQueryName == null) {
+            groupLevel = -1;
+            subQueryInfo = null;
+        } else {
+            groupLevel = 1;
+            subQueryInfo = new int[] { 0, 1 };
+        }
+        this.getRdSave().saveResultIterator(new DummyCachedResult(), groupLevel, subQueryInfo);
     }


Input:
private InputSource filesystemLookup(ResourceLocation matchingEntry) {
    String uri = matchingEntry.getLocation();
    URL baseURL = null;
    if (matchingEntry.getBase() != null) {
        baseURL = matchingEntry.getBase();
    } else {
        try {
            baseURL = getProject().getBaseDir().toURL();
        } catch (MalformedURLException ex) {
            throw new BuildException("String_Node_Str");
        }
    }
    InputSource source = null;
    URL url = null;
    try {
        url = new URL(baseURL, uri);
    } catch (MalformedURLException ex) {
    }
    if (url != null) {
        String fileName = url.getFile();
        if (fileName != null) {
            log("String_Node_Str" + fileName, Project.MSG_DEBUG);
            File resFile = new File(fileName);
            if (resFile.exists() && resFile.canRead()) {
                try {
                    source = new InputSource(new FileInputStream(resFile));
                    String sysid = JAXPUtils.getSystemId(resFile);
                    source.setSystemId(sysid);
                    log("String_Node_Str" + sysid + "String_Node_Str", Project.MSG_DEBUG);
                } catch (FileNotFoundException ex) {
                } catch (IOException ex) {
                }
            }
        }
    }
    return source;
}

Output:
         try {
-            baseURL = getProject().getBaseDir().toURL();
+            baseURL = fileUtils.getFileURL(getProject().getBaseDir());
         } catch (MalformedURLException ex) {


Input:
public void prepare(String command) throws OdaException {
    logger.logp(java.util.logging.Level.FINE, Statement.class.getName(), "String_Node_Str", "String_Node_Str" + command + "String_Node_Str");
    try {
        if (command == null) {
            logger.logp(java.util.logging.Level.FINE, Statement.class.getName(), "String_Node_Str", "String_Node_Str");
            throw new OdaException("String_Node_Str");
        }
        this.cachedResultMetaData = null;
        this.cachedResultSet = null;
        this.preStat = conn.prepareStatement(formatQueryText(command));
    } catch (SQLException e) {
        throw new JDBCException(ResourceConstants.STATEMENT_CANNOT_PREPARE, e);
    }
}

Output:
         this.cachedResultSet = null;
-        this.preStat = conn.prepareStatement(formatQueryText(command));
+        this.preStat = conn.prepareStatement(SQLFormatter.formatQueryText(command));
     } catch (SQLException e) {


Input:
public void destroy() {
    System.err.println("String_Node_Str");
    jmolPanel.removeMouseListener(this);
    jmolPanel.removeMouseMotionListener(this);
    jmolPanel.destroy();
}

Output:
 public void destroy() {
-    System.err.println("String_Node_Str");
+    logger.debug("String_Node_Str");
     jmolPanel.removeMouseListener(this);


Input:
public void remove() {
    throw new UnsupportedOperationException("String_Node_Str");
}

Output:
 public void remove() {
-    throw new UnsupportedOperationException("String_Node_Str");
+    throw new UnsupportedOperationException();
 }


Input:
public void run() {
    if (playerInteraction.get(player.getName()) == null)
        NBTTagEditor.removeDescriptions(event.getPlayer().getInventory());
}

Output:
 public void run() {
-    if (playerInteraction.get(player.getName()) == null)
-        NBTTagEditor.removeDescriptions(event.getPlayer().getInventory());
+    tempOpening.remove(player.getName());
 }


Input:
public void setType(JavaClass cls) {
    if (cls == null) {
        return;
    }
    if (type != null && type == cls) {
        return;
    }
    String clsName = cls.getRawName();
    if (isCollectionType(cls)) {
        if (cls.hasActualTypeArguments()) {
            ArrayList typeArgs = (ArrayList) cls.getActualTypeArguments();
            genericType = (JavaClass) typeArgs.get(0);
        } else {
            genericType = helper.getJavaClass(Object.class);
        }
        type = cls;
    } else if (cls.isArray() && !clsName.equals("String_Node_Str") && !clsName.equals("String_Node_Str")) {
        type = cls;
        genericType = cls.getComponentType();
    } else {
        type = cls;
        genericType = null;
    }
    boolean isNewTypeMap = helper.getJavaClass(java.util.Map.class).isAssignableFrom(type);
    setIsMap(isNewTypeMap);
    if (isMap()) {
        Object[] types = type.getActualTypeArguments().toArray();
        if (types.length >= 2) {
            keyType = (JavaClass) types[0];
            valueType = (JavaClass) types[1];
        } else {
            keyType = helper.getJavaClass(Object.class);
            valueType = helper.getJavaClass(Object.class);
        }
    }
}

Output:
             ArrayList typeArgs = (ArrayList) cls.getActualTypeArguments();
-            genericType = (JavaClass) typeArgs.get(0);
+            if (typeArgs.size() > 0) {
+                genericType = (JavaClass) typeArgs.get(0);
+            } else {
+                genericType = helper.getJavaClass(Object.class);
+            }
         } else {


Input:
public static void deletePeopleExceptForFirstPage(int localTableBlogId) {
    int fetchLimit = PeopleUtils.FETCH_LIMIT;
    String[] tables = { TEAM_TABLE, FOLLOWERS_TABLE, EMAIL_FOLLOWERS_TABLE, VIEWERS_TABLE };
    getWritableDb().beginTransaction();
    try {
        for (String table : tables) {
            int size = getPeopleCountForLocalBlogId(table, localTableBlogId);
            if (size > fetchLimit) {
                String where = "String_Node_Str" + localTableBlogId;
                String[] columns = { "String_Node_Str" };
                String limit = Integer.toString(size - fetchLimit);
                String orderBy = null;
                if (shouldOrderAlphabetically(table)) {
                    orderBy = "String_Node_Str";
                }
                String inQuery = SQLiteQueryBuilder.buildQueryString(false, table, columns, where, null, null, orderBy, limit);
                String[] args = new String[] { Integer.toString(localTableBlogId) };
                getWritableDb().delete(table, "String_Node_Str" + inQuery + "String_Node_Str", args);
            }
        }
        getWritableDb().setTransactionSuccessful();
    } finally {
        getWritableDb().endTransaction();
    }
}

Output:
                 String limit = Integer.toString(size - fetchLimit);
-                String orderBy = null;
+                String orderBy;
                 if (shouldOrderAlphabetically(table)) {


Input:
public void testOutputCssMapArtifactWithTestData() throws UnableToCompleteException {
    UnitTestTreeLogger testLogger = new UnitTestTreeLogger.Builder().createLogger();
    ResourceContext mockResourceContext = EasyMock.createMock(ResourceContext.class);
    JMethod mockJMethod1 = EasyMock.createMock(JMethod.class);
    JMethod mockJMethod2 = EasyMock.createMock(JMethod.class);
    JMethod mockJMethod3 = EasyMock.createMock(JMethod.class);
    JClassType mockJClassType1 = EasyMock.createMock(JClassType.class);
    JClassType mockJClassType2 = EasyMock.createMock(JClassType.class);
    JClassType mockJClassType3 = EasyMock.createMock(JClassType.class);
    Map<JMethod, String> testMap = new LinkedHashMap<JMethod, String>();
    testMap.put(mockJMethod1, "String_Node_Str");
    testMap.put(mockJMethod2, "String_Node_Str");
    testMap.put(mockJMethod3, "String_Node_Str");
    ByteArrayOutputStream testOutputStream = new ByteArrayOutputStream();
    GeneratorContext mockGeneratorContext = EasyMock.createMock(GeneratorContext.class);
    GeneratedResource mockGeneratedResource = EasyMock.createMock(GeneratedResource.class);
    EasyMock.expect(mockResourceContext.getGeneratorContext()).andReturn(mockGeneratorContext);
    EasyMock.expectLastCall().times(2);
    EasyMock.expect(mockGeneratorContext.tryCreateResource(testLogger, "String_Node_Str")).andReturn(testOutputStream);
    EasyMock.expect(mockJMethod1.getEnclosingType()).andReturn(mockJClassType1);
    EasyMock.expect(mockJClassType1.getQualifiedSourceName()).andReturn("String_Node_Str");
    EasyMock.expect(mockJMethod1.getName()).andReturn("String_Node_Str");
    EasyMock.expect(mockJMethod2.getEnclosingType()).andReturn(mockJClassType2);
    EasyMock.expect(mockJClassType2.getQualifiedSourceName()).andReturn("String_Node_Str");
    EasyMock.expect(mockJMethod2.getName()).andReturn("String_Node_Str");
    EasyMock.expect(mockJMethod3.getEnclosingType()).andReturn(mockJClassType3);
    EasyMock.expect(mockJClassType3.getQualifiedSourceName()).andReturn("String_Node_Str");
    EasyMock.expect(mockJMethod3.getName()).andReturn("String_Node_Str");
    EasyMock.expect(mockGeneratorContext.commitResource(testLogger, testOutputStream)).andReturn(mockGeneratedResource);
    EasyMock.replay(mockResourceContext);
    EasyMock.replay(mockGeneratorContext);
    EasyMock.replay(mockJMethod1);
    EasyMock.replay(mockJMethod2);
    EasyMock.replay(mockJMethod3);
    EasyMock.replay(mockJClassType1);
    EasyMock.replay(mockJClassType2);
    EasyMock.replay(mockJClassType3);
    CssResourceGenerator crg = new CssResourceGenerator();
    crg.outputCssMapArtifact(testLogger, mockResourceContext, testMap, "String_Node_Str");
    String expectedOutput = "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    assertEquals(expectedOutput, testOutputStream.toString());
    testLogger.assertCorrectLogEntries();
    EasyMock.verify(mockResourceContext);
    EasyMock.verify(mockGeneratorContext);
    EasyMock.verify(mockJMethod1);
    EasyMock.verify(mockJMethod2);
    EasyMock.verify(mockJMethod3);
    EasyMock.verify(mockJClassType1);
    EasyMock.verify(mockJClassType2);
    EasyMock.verify(mockJClassType3);
}

Output:
     CssResourceGenerator crg = new CssResourceGenerator();
-    crg.outputCssMapArtifact(testLogger, mockResourceContext, testMap, "String_Node_Str");
+    crg.outputCssMapArtifact(testLogger, mockResourceContext, method, testMap);
     String expectedOutput = "String_Node_Str" + "String_Node_Str" + "String_Node_Str";


Input:
public void write(JavaWriter javaWriter) throws IOException {
    ColumnDefinition columnDefinition = ((TableDefinition) tableDefinition).autoIncrementDefinition;
    AdapterQueryBuilder queryBuilder = new AdapterQueryBuilder().append(ModelUtils.getVariable(isModelContainerDefinition));
    if (!isModelContainerDefinition) {
        queryBuilder.append("String_Node_Str").append(columnDefinition.columnFieldName).append("String_Node_Str").appendCast(columnDefinition.columnFieldType).append(params[3]).append("String_Node_Str");
    } else {
        queryBuilder.appendPut(columnDefinition.columnFieldName).append(params[3]).append("String_Node_Str");
    }
    javaWriter.emitStatement(queryBuilder.getQuery());
}

Output:
     } else {
-        queryBuilder.appendPut(columnDefinition.columnFieldName).append(params[3]).append("String_Node_Str");
+        String containerKeyName = columnDefinition.columnFieldName;
+        if (columnDefinition.containerKeyName != null) {
+            containerKeyName = columnDefinition.containerKeyName;
+        }
+        queryBuilder.appendPut(containerKeyName).append(params[3]).append("String_Node_Str");
     }


Input:
protected void operateCell(Grid ignore, Grid dst, int col, int row) {
    double x = dst.getWest() + col * dst.getCellSize();
    double y = dst.getNorth() - row * dst.getCellSize();
    double sumWeight = 0;
    double totalX = 0;
    double totalY = 0;
    for (DirectionPoint point : referencePoints) {
        double dx = point.x - x;
        double dy = point.y - y;
        double distance = Math.sqrt(dx * dx + dy * dy);
        double weight = 1d / distance;
        sumWeight += weight;
        totalX += weight * point.dirX;
        totalY += weight * point.dirY;
    }
    totalX /= sumWeight;
    totalY /= sumWeight;
    double dir = Math.toDegrees(Math.atan2(totalY, totalX));
    double azimuth = 90 - dir;
    dst.setValue(azimuth, col, row);
}

Output:
         double distance = Math.sqrt(dx * dx + dy * dy);
-        double weight = 1d / distance;
+        if (distance < 0.0000001) {
+            totalX = point.dirX;
+            totalY = point.dirY;
+            sumWeight = 1;
+            break;
+        }
+        double weight = 1d / (distance * distance);
         sumWeight += weight;


Input:
protected void dropRareDrop(int var1) {
    this.dropItem(TwilightItemsOther.wildWoodSoul, 2);
}

Output:
 protected void dropRareDrop(int var1) {
-    this.dropItem(TwilightItemsOther.wildWoodSoul, 2);
+    this.dropItem(TwilightItemsOther.wildwoodSoul, 2);
 }


Input:
public BufferedImage rasterize(Rectangle rect, int offsetX, int offsetY, double scalingFactor) {
    BufferedImage image = new BufferedImage(rect.width, rect.height, BufferedImage.TYPE_BYTE_BINARY);
    GeometryFactory gf = new GeometryFactory();
    Coordinate[] coords = new Coordinate[] { new Coordinate((int) (((double) rect.getMinX() / scalingFactor)), (int) (((double) rect.getMinY() / scalingFactor))), new Coordinate((int) (((double) rect.getMaxX() / scalingFactor)), (int) (((double) rect.getMinY() / scalingFactor))), new Coordinate((int) (((double) rect.getMaxX() / scalingFactor)), (int) (((double) rect.getMaxY() / scalingFactor))), new Coordinate((int) (((double) rect.getMinX() / scalingFactor)), (int) (((double) rect.getMaxY() / scalingFactor))), new Coordinate((int) (((double) rect.getMinX() / scalingFactor)), (int) (((double) rect.getMinY() / scalingFactor))) };
    Polygon geom = gf.createPolygon(gf.createLinearRing(coords));
    Graphics g2d = image.getGraphics();
    g2d.setColor(Color.WHITE);
    for (Geometry p : maskGeometries) {
        if (p.intersects(geom)) {
            int[] xPoints = new int[p.getNumPoints()];
            int[] yPoints = new int[p.getNumPoints()];
            int i = 0;
            for (Coordinate c : p.getCoordinates()) {
                xPoints[i] = (int) ((c.x + offsetX) * scalingFactor);
                yPoints[i] = (int) ((c.y + offsetY) * scalingFactor);
                i++;
            }
            g2d.fillPolygon(xPoints, yPoints, p.getNumPoints());
        }
    }
    g2d.dispose();
    return image;
}

Output:
     Graphics g2d = image.getGraphics();
-    g2d.setColor(Color.WHITE);
+    g2d.setColor(Color.white);
     for (Geometry p : maskGeometries) {


Input:
public boolean isMarked(short x, short y) {
    return this.markedGrid.get(x * width + y);
}

Output:
 public boolean isMarked(short x, short y) {
-    return this.markedGrid.get(x * width + y);
+    return this.markedGrid.get(getIdx(x, y));
 }


Input:
public void layoutForSimView() {
    preferredSize = new Dimension(610, 471);
    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(258, 299));
    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(16, 54));
    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(21, 331));
    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(183, 149));
}

Output:
     preferredSize = new Dimension(610, 471);
-    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(258, 299));
-    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(16, 54));
-    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(21, 331));
-    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(183, 149));
+    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(168, 128));
+    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(0, 73));
+    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(10, 294));
+    ((ViewableComponent) withName("String_Node_Str")).setPreferredLocation(new Point(222, 337));
 }


Input:
protected boolean setNextOperatingCompany(boolean initial) {
    if (operatingCompanyIndexObject == null) {
        operatingCompanyIndexObject = new IntegerState("String_Node_Str");
    }
    if (initial) {
        operatingCompanyIndexObject.set(0);
    } else {
        operatingCompanyIndexObject.add(1);
    }
    int operatingCompanyIndex = operatingCompanyIndexObject.intValue();
    if (operatingCompanyIndex >= operatingCompanyArray.length) {
        operatingCompany = null;
        return false;
    } else {
        operatingCompany = operatingCompanyArray[operatingCompanyIndex];
        log.debug("String_Node_Str" + operatingCompany.getName() + "String_Node_Str" + getRoundName());
        return true;
    }
}

Output:
     }
-    if (initial) {
-        operatingCompanyIndexObject.set(0);
-    } else {
-        operatingCompanyIndexObject.add(1);
-    }
-    int operatingCompanyIndex = operatingCompanyIndexObject.intValue();
-    if (operatingCompanyIndex >= operatingCompanyArray.length) {
-        operatingCompany = null;
-        return false;
-    } else {
-        operatingCompany = operatingCompanyArray[operatingCompanyIndex];
-        log.debug("String_Node_Str" + operatingCompany.getName() + "String_Node_Str" + getRoundName());
-        return true;
+    while (true) {
+        if (initial) {
+            operatingCompanyIndexObject.set(0);
+            initial = false;
+        } else {
+            operatingCompanyIndexObject.add(1);
+        }
+        int operatingCompanyIndex = operatingCompanyIndexObject.intValue();
+        if (operatingCompanyIndex >= operatingCompanyArray.length) {
+            return false;
+        } else {
+            operatingCompany = operatingCompanyArray[operatingCompanyIndex];
+            if (operatingCompany.isClosed())
+                continue;
+            return true;
+        }
     }


Input:
public static void showAlert(Context context, int titleId, String message, CharSequence positiveButtontxt, DialogInterface.OnClickListener positiveListener) {
    Dialog dlg = new AlertDialog.Builder(context).setIcon(android.R.drawable.ic_dialog_alert).setTitle(titleId).setPositiveButton(positiveButtontxt, positiveListener).setMessage(message).setCancelable(false).create();
    dlg.show();
}

Output:
 public static void showAlert(Context context, int titleId, String message, CharSequence positiveButtontxt, DialogInterface.OnClickListener positiveListener) {
-    Dialog dlg = new AlertDialog.Builder(context).setIcon(android.R.drawable.ic_dialog_alert).setTitle(titleId).setPositiveButton(positiveButtontxt, positiveListener).setMessage(message).setCancelable(false).create();
+    Dialog dlg = new AlertDialog.Builder(context).setTitle(titleId).setPositiveButton(positiveButtontxt, positiveListener).setMessage(message).setCancelable(false).create();
     dlg.show();


Input:
public void updateBinaryRepresenation() {
    if (!this.modified)
        return;
    final int firstModified = this.firstModifiedPos;
    final int numFields = this.numFields;
    final int[] offsets = this.offsets;
    if (this.serializer == null) {
        this.serializer = new InternalDeSerializer();
    }
    final InternalDeSerializer serializer = this.serializer;
    if (numFields > 0) {
        int offset = firstModified <= 0 ? 0 : this.offsets[firstModified - 1] + this.lengths[firstModified - 1];
        serializer.position = offset;
        if (firstModified > 0) {
            serializer.memory = this.binaryData == null ? new byte[numFields * DEFAULT_FIELD_LEN] : this.binaryData;
            try {
                for (int i = firstModified; i < numFields; i++) {
                    if (offsets[i] == NULL_INDICATOR_OFFSET)
                        continue;
                    offsets[i] = offset;
                    this.fields[i].write(serializer);
                    int newOffset = serializer.position;
                    this.lengths[i] = newOffset - offset;
                    offset = newOffset;
                }
            } catch (Exception e) {
                throw new RuntimeException("String_Node_Str" + e.getMessage());
            }
        } else {
            serializer.memory = this.serializationSwitchBuffer == null ? new byte[numFields * DEFAULT_FIELD_LEN] : this.serializationSwitchBuffer;
            if (offset > 0 & this.binaryData != null) {
                System.arraycopy(this.binaryData, 0, serializer.memory, 0, offset);
            }
            try {
                for (int i = firstModified; i < numFields; i++) {
                    final int co = offsets[i];
                    if (co == NULL_INDICATOR_OFFSET)
                        continue;
                    offsets[i] = offset;
                    if (co == MODIFIED_INDICATOR_OFFSET)
                        this.fields[i].write(serializer);
                    else
                        serializer.write(this.binaryData, co, this.lengths[i]);
                    this.lengths[i] = serializer.position - offset;
                    offset = serializer.position;
                }
            } catch (Exception e) {
                throw new RuntimeException("String_Node_Str" + e.getMessage());
            }
            this.serializationSwitchBuffer = this.binaryData;
            this.binaryData = serializer.memory;
        }
    }
    try {
        int slp = serializer.position;
        if (numFields <= 8) {
            int mask = 0;
            for (int i = numFields - 1; i > 0; i--) {
                mask <<= 1;
                if (offsets[i] != NULL_INDICATOR_OFFSET) {
                    slp = serializer.position;
                    serializer.writeValLenIntBackwards(offsets[i]);
                    mask |= 0x1;
                }
            }
            mask <<= 1;
            if (offsets[0] != NULL_INDICATOR_OFFSET) {
                mask |= 0x1;
            } else {
                serializer.position = slp;
            }
            serializer.writeByte(mask);
        } else {
            for (int i = numFields - 1; i > 0; i--) {
                if (offsets[i] != NULL_INDICATOR_OFFSET) {
                    slp = serializer.position;
                    serializer.writeValLenIntBackwards(offsets[i]);
                }
            }
            if (offsets[0] == NULL_INDICATOR_OFFSET) {
                serializer.position = slp;
            }
            int col = numFields - 1;
            int mask = 0;
            for (int i = numFields & 0x7; i > 0; i--, col--) {
                mask <<= 1;
                mask |= (offsets[col] != NULL_INDICATOR_OFFSET) ? 0x1 : 0x0;
            }
            serializer.writeByte(mask);
            for (int i = numFields >>> 3; i > 0; i--) {
                mask = 0;
                for (int k = 0; k < 8; k++, col--) {
                    mask <<= 1;
                    mask |= (offsets[col] != NULL_INDICATOR_OFFSET) ? 0x1 : 0x0;
                }
                serializer.writeByte(mask);
            }
        }
        serializer.writeValLenIntBackwards(numFields);
    } catch (Exception e) {
        throw new RuntimeException("String_Node_Str" + e.getMessage(), e);
    }
    this.binaryData = serializer.memory;
    this.binaryLen = serializer.position;
    this.firstModifiedPos = Integer.MAX_VALUE;
    this.modified = false;
}

Output:
     if (numFields > 0) {
-        int offset = firstModified <= 0 ? 0 : this.offsets[firstModified - 1] + this.lengths[firstModified - 1];
+        int offset = 0;
+        if (firstModified > 0) {
+            for (int i = firstModified - 1; i >= 0; i--) {
+                if (this.offsets[i] != NULL_INDICATOR_OFFSET) {
+                    offset = this.offsets[i] + this.lengths[i];
+                    break;
+                }
+            }
+        }
         serializer.position = offset;


Input:
public ArrayList<AbstractComponentsProvider> getProviders() {
    loadComponentsProvidersFromExtension();
    return providers;
}

Output:
     loadComponentsProvidersFromExtension();
-    return providers;
+    return new ArrayList<AbstractComponentsProvider>(providers);
 }


Input:
public String getServerType() {
    return ServiceType.findServiceType(this.agentInformation.getServerType()).getDesc();
}

Output:
 public String getServerType() {
-    return ServiceType.findServiceType(this.agentInformation.getServerType()).getDesc();
+    return this.agentInformation.getServerServiceType().getDesc();
 }


Input:
private void onComplete(HBaseRpcController controller, ScanResponse resp) {
    if (controller.failed()) {
        onError(controller.getFailed());
        return;
    }
    updateServerSideMetrics(scanMetrics, resp);
    boolean isHeartbeatMessage = resp.hasHeartbeatMessage() && resp.getHeartbeatMessage();
    Result[] results;
    try {
        Result[] rawResults = ResponseConverter.getResults(controller.cellScanner(), resp);
        updateResultsMetrics(scanMetrics, rawResults, isHeartbeatMessage);
        results = resultCache.addAndGet(Optional.ofNullable(rawResults).orElse(ScanResultCache.EMPTY_RESULT_ARRAY), isHeartbeatMessage);
    } catch (IOException e) {
        LOG.warn("String_Node_Str", e);
        completeWhenError(true);
        return;
    }
    int numberOfIndividualRows = numberOfIndividualRows(Arrays.asList(results));
    ScanControllerImpl scanController = new ScanControllerImpl();
    if (results.length == 0) {
        consumer.onHeartbeat(scanController);
    } else {
        updateNextStartRowWhenError(results[results.length - 1]);
        consumer.onNext(results, scanController);
    }
    ScanControllerState state = scanController.destroy();
    if (state == ScanControllerState.TERMINATED) {
        if (resp.getMoreResultsInRegion()) {
            closeScanner();
        }
        completeNoMoreResults();
        return;
    }
    if (state == ScanControllerState.SUSPENDED) {
        if (scanController.resumer.prepare(resp, numberOfIndividualRows)) {
            return;
        }
    }
    completeOrNext(resp, numberOfIndividualRows);
}

Output:
     ScanControllerImpl scanController = new ScanControllerImpl();
-    if (results.length == 0) {
-        consumer.onHeartbeat(scanController);
-    } else {
+    if (results.length > 0) {
         updateNextStartRowWhenError(results[results.length - 1]);