Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.show_habits, container, false);
    DisplayMetrics dm = getResources().getDisplayMetrics();
    int width = (int) (dm.widthPixels / dm.density);
    button_count = (int) ((width - 160) / 42);
    tvNameWidth = (int) ((width - 30 - button_count * 42) * dm.density);
    adapter = new ShowHabitsAdapter(getActivity());
    listView = (DragSortListView) view.findViewById(R.id.listView);
    listView.setAdapter(adapter);
    listView.setOnItemClickListener(this);
    registerForContextMenu(listView);
    listView.setDropListener(this);
    DragSortController controller = new DragSortController(listView);
    controller.setDragHandleId(R.id.tvStar);
    controller.setRemoveEnabled(false);
    controller.setSortEnabled(true);
    controller.setDragInitMode(1);
    listView.setFloatViewManager(controller);
    listView.setOnTouchListener(controller);
    listView.setDragEnabled(true);
    GregorianCalendar day = new GregorianCalendar();
    day.setTimeInMillis(DateHelper.getLocalTime());
    for (int i = 0; i < button_count; i++) {
        View check = inflater.inflate(R.layout.show_habits_header_check, null);
        Button btCheck = (Button) check.findViewById(R.id.tvCheck);
        btCheck.setText(day.getDisplayName(GregorianCalendar.DAY_OF_WEEK, GregorianCalendar.SHORT, Locale.US) + "String_Node_Str" + Integer.toString(day.get(GregorianCalendar.DAY_OF_MONTH)));
        ((LinearLayout) view.findViewById(R.id.llButtonsHeader)).addView(check);
        day.add(GregorianCalendar.DAY_OF_MONTH, -1);
    }
    setHasOptionsMenu(true);
    return view;
}

Output:
     listView.setDragEnabled(true);
-    GregorianCalendar day = new GregorianCalendar();
-    day.setTimeInMillis(DateHelper.getLocalTime());
+    GregorianCalendar day = new GregorianCalendar(TimeZone.getTimeZone("String_Node_Str"));
+    day.setTimeInMillis(DateHelper.getStartOfDay(DateHelper.getLocalTime()));
     for (int i = 0; i < button_count; i++) {


Input:
private void createOperation(final String newJobName, final RepositoryNode target, CopyObjectAction copyObjectAction, final TreeSelection selectionInClipboard) {
    final IWorkspaceRunnable op = new IWorkspaceRunnable() {
        public void run(IProgressMonitor monitor) throws CoreException {
            Object currentSource = selectionInClipboard.toArray()[0];
            try {
                IPath path = RepositoryNodeUtilities.getPath(target);
                if (((RepositoryNode) currentSource).getType().equals(ENodeType.REPOSITORY_ELEMENT)) {
                    Item originalItem = ((RepositoryNode) currentSource).getObject().getProperty().getItem();
                    List<IRepositoryViewObject> allVersion = factory.getAllVersion(originalItem.getProperty().getId());
                    for (IRepositoryViewObject obj : allVersion) {
                        if (obj.getVersion().equals(originalItem.getProperty().getVersion())) {
                            originalItem = obj.getProperty().getItem();
                            break;
                        }
                    }
                    if (allVersion.size() == 1) {
                        duplicateSingleVersionItem(originalItem, path, newJobName);
                    } else if (allVersion.size() > 1) {
                        PastSelectorDialog dialog = new PastSelectorDialog(Display.getCurrent().getActiveShell(), allVersion, sourceNode);
                        if (dialog.open() == Window.OK) {
                            Set<IRepositoryViewObject> selectedVersionItems = dialog.getSelectedVersionItems();
                            String id = null;
                            String label = null;
                            boolean isfirst = true;
                            boolean needSys = true;
                            for (IRepositoryViewObject object : selectedVersionItems) {
                                Item selectedItem = object.getProperty().getItem();
                                final Item copy = factory.copy(selectedItem, path);
                                if (isfirst) {
                                    id = copy.getProperty().getId();
                                    label = copy.getProperty().getLabel();
                                    isfirst = false;
                                }
                                copy.getProperty().setId(id);
                                copy.getProperty().setLabel(newJobName);
                                copy.getProperty().setDisplayName(newJobName);
                                if (needSys && originalItem instanceof RoutineItem) {
                                    String lastestVersion = getLastestVersion(selectedVersionItems);
                                    if (lastestVersion.equals(copy.getProperty().getVersion())) {
                                        synDuplicatedRoutine((RoutineItem) copy);
                                        needSys = false;
                                    }
                                }
                                final RepositoryWorkUnit<Object> workUnit = new RepositoryWorkUnit<Object>(getText(), this) {
                                    protected void run() throws LoginException, PersistenceException {
                                        if (copy instanceof ProcessItem) {
                                            RelationshipItemBuilder.getInstance().addOrUpdateItem(copy);
                                        }
                                        factory.save(copy);
                                    }
                                };
                                workUnit.setAvoidUnloadResources(true);
                                factory.executeRepositoryWorkUnit(workUnit);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                ExceptionHandler.process(e);
            }
        }
    };
    IRunnableWithProgress iRunnableWithProgress = new IRunnableWithProgress() {
        public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
            IWorkspace workspace = ResourcesPlugin.getWorkspace();
            try {
                ISchedulingRule schedulingRule = workspace.getRoot();
                workspace.run(op, schedulingRule, IWorkspace.AVOID_UPDATE, monitor);
            } catch (CoreException e) {
                throw new InvocationTargetException(e);
            }
        }
    };
    try {
        new ProgressMonitorDialog(null).run(true, true, iRunnableWithProgress);
    } catch (InvocationTargetException e) {
        ExceptionHandler.process(e);
    } catch (InterruptedException e) {
    }
}

Output:
         }
-    };
-    IRunnableWithProgress iRunnableWithProgress = new IRunnableWithProgress() {
-        public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
-            IWorkspace workspace = ResourcesPlugin.getWorkspace();
-            try {
-                ISchedulingRule schedulingRule = workspace.getRoot();
-                workspace.run(op, schedulingRule, IWorkspace.AVOID_UPDATE, monitor);
-            } catch (CoreException e) {
-                throw new InvocationTargetException(e);
-            }
-        }
-    };
-    try {
-        new ProgressMonitorDialog(null).run(true, true, iRunnableWithProgress);
-    } catch (InvocationTargetException e) {
+    } catch (Exception e) {
         ExceptionHandler.process(e);


Input:
protected List<Path> resolve0(Object x) {
    _ct = unsafe(getCallTarget(Capsule.class));
    final String target = (_ct != null ? _ct.getClass().getName() : Capsule.class.getName());
    log(LOG_DEBUG, "String_Node_Str" + target + "String_Node_Str" + x);
    final List<Path> res = _ct != null ? _ct.resolve0(x) : resolve00(x);
    log(LOG_DEBUG, "String_Node_Str" + target + "String_Node_Str" + x + "String_Node_Str" + res);
    return res;
}

Output:
     _ct = unsafe(getCallTarget(Capsule.class));
-    final String target = (_ct != null ? _ct.getClass().getName() : Capsule.class.getName());
+    final String target = (_ct != null ? _ct.getClass().getName() : Capsule.class.getName()) + '@' + Integer.toHexString(System.identityHashCode(_ct));
     log(LOG_DEBUG, "String_Node_Str" + target + "String_Node_Str" + x);


Input:
private void setText(String text) {
    Field field = ReflectionUtils.getFields(this, ISetValue.class).get(0);
    ISetValue setValueElement = (ISetValue) ReflectionUtils.getFieldValue(field, this);
    doActionRule.invoke(text, val -> setValueAction(val, setValueElement));
}

Output:
 private void setText(String text) {
-    Field field = ReflectionUtils.getFields(this, ISetValue.class).get(0);
-    ISetValue setValueElement = (ISetValue) ReflectionUtils.getFieldValue(field, this);
+    Field field = getFields(this, ISetValue.class).get(0);
+    ISetValue setValueElement = (ISetValue) getValueField(field, this);
     doActionRule.invoke(text, val -> setValueAction(val, setValueElement));


Input:
public void flush(String name) {
    CMap cmap = getMap(name);
    if (cmap != null && cmap.store != null && cmap.writeDelayMillis > 0) {
        Map mapDirtyEntries = new HashMap();
        for (Record record : cmap.mapRecords.values()) {
            if (record.isDirty()) {
                Object key = record.getKey();
                Object value = record.getValue();
                if (key != null && value != null) {
                    mapDirtyEntries.put(key, value);
                }
            }
        }
        if (mapDirtyEntries.size() > 0) {
            cmap.store.storeAll(mapDirtyEntries);
        }
    }
}

Output:
     if (cmap != null && cmap.store != null && cmap.writeDelayMillis > 0) {
-        Map mapDirtyEntries = new HashMap();
+        final Set<Record> dirtyRecords = new HashSet<Record>();
         for (Record record : cmap.mapRecords.values()) {


Input:
public void testLoadFiles() throws Exception {
    final FileInfo info = new FileInfo("String_Node_Str", 1234, false, true, null);
    final String infoData = "String_Node_Str";
    final boolean shouldReset = false;
    List<FileInfo> actual = new ProcessingFileLoader(new FileReader() {
        public String readFile(String file) {
            assertEquals(info.getAbsoluteFileName(new File("String_Node_Str")), file);
            return infoData;
        }
    }, Collections.<FileLoadPostProcessor>emptySet(), new File("String_Node_Str"), new com.google.jstestdriver.util.NullStopWatch()).loadFiles(Collections.singleton(info), shouldReset);
    assertEquals(infoData, actual.get(0).getData());
    assertEquals(info.getFilePath(), actual.get(0).getFilePath());
    assertEquals(info.getTimestamp(), actual.get(0).getTimestamp());
    assertEquals(info.isServeOnly(), actual.get(0).isServeOnly());
}

Output:
 public void testLoadFiles() throws Exception {
-    final FileInfo info = new FileInfo("String_Node_Str", 1234, false, true, null);
+    final FileInfo info = new FileInfo("String_Node_Str", 1234, -1, false, true, null);
     final String infoData = "String_Node_Str";


Input:
private RawContactMatchingCandidates findRawContactMatchingCandidates(SQLiteDatabase db, long rawContactId, MatchCandidateList candidates, RawContactMatcher matcher) {
    updateMatchScoresForSuggestionsBasedOnDataMatches(db, rawContactId, candidates, matcher);
    final RawContactMatchingCandidates matchingCandidates = new RawContactMatchingCandidates(matcher.pickBestMatches(SCORE_THRESHOLD_SUGGEST));
    Set<Long> newIds = new HashSet<>();
    newIds.addAll(matchingCandidates.getRawContactIdSet());
    while (!newIds.isEmpty()) {
        final Set<Long> tmpIdSet = new HashSet<>();
        for (long rId : newIds) {
            final RawContactMatcher rMatcher = new RawContactMatcher();
            updateMatchScoresForSuggestionsBasedOnDataMatches(db, rId, new MatchCandidateList(), rMatcher);
            List<MatchScore> newMatches = rMatcher.pickBestMatches(SCORE_THRESHOLD_SUGGEST);
            for (MatchScore newMatch : newMatches) {
                final long newRawContactId = newMatch.getRawContactId();
                if (!matchingCandidates.getRawContactIdSet().contains(newRawContactId)) {
                    tmpIdSet.add(newRawContactId);
                    matchingCandidates.add(newMatch);
                }
            }
        }
        newIds.clear();
        newIds.addAll(tmpIdSet);
    }
    return matchingCandidates;
}

Output:
 private RawContactMatchingCandidates findRawContactMatchingCandidates(SQLiteDatabase db, long rawContactId, MatchCandidateList candidates, RawContactMatcher matcher) {
-    updateMatchScoresForSuggestionsBasedOnDataMatches(db, rawContactId, candidates, matcher);
-    final RawContactMatchingCandidates matchingCandidates = new RawContactMatchingCandidates(matcher.pickBestMatches(SCORE_THRESHOLD_SUGGEST));
+    updateMatchScores(db, rawContactId, candidates, matcher);
+    final RawContactMatchingCandidates matchingCandidates = new RawContactMatchingCandidates(matcher.pickBestMatches());
     Set<Long> newIds = new HashSet<>();


Input:
private void handlePlayerItemClicked(int slot, PlayerInventory playerInv) {
    playerInv.setItem(slot, previousPlayerInv.getItem(slot));
    ItemStack i = playerInv.getItem(slot);
    Stockable stockable = getStockable(i, "String_Node_Str", true);
    if (stockable == null)
        return;
    if (previousPlayerClickedSlot != slot) {
        previousPlayerClickedSlot = slot;
        sendStockableMessage("String_Node_Str", stockable);
        return;
    }
    previousPlayerClickedSlot = slot;
    if (checkMiscellaneous(playerInv, stockable, slot, "String_Node_Str", false))
        return;
    ItemStack selling = stockable.getStocking();
    HashMap<Integer, ItemStack> unsold = new HashMap<Integer, ItemStack>();
    if (mode != Mode.INFINITE) {
        unsold = npc.getInventory().addItem(stockable.getPrice().getItemStack());
    }
    if (unsold.size() >= 1) {
        restorePreviousState();
        player.sendMessage(ChatColor.RED + "String_Node_Str" + MessageUtils.getStackToString(selling, ChatColor.RED) + "String_Node_Str");
        return;
    }
    if (!stockable.isiConomy()) {
        unsold = player.getInventory().addItem(stockable.getStocking());
        if (unsold.size() >= 1) {
            restorePreviousState();
            player.sendMessage(ChatColor.RED + "String_Node_Str" + stockable.getString(ChatColor.RED) + "String_Node_Str");
            return;
        }
    }
    if (mode != Mode.INFINITE)
        EconomyHandler.pay(new Payment(stockable.getStocking(), false), npc, -1);
    EconomyHandler.pay(new Payment(stockable.getPrice()), player, slot);
    player.sendMessage(ChatColor.GREEN + "String_Node_Str");
}

Output:
     if (mode != Mode.INFINITE) {
-        unsold = npc.getInventory().addItem(stockable.getPrice().getItemStack());
+        unsold = npc.getInventory().addItem(stockable.getStocking());
     }


Input:
public void addFacade(ItemStack itemStack) {
    if (itemStack.stackSize == 0) {
        itemStack.stackSize = 1;
    }
    Block block = Block.getBlockFromItem(itemStack.getItem());
    if (block == null) {
        return;
    }
    if (!block.getMaterial().blocksMovement()) {
        return;
    }
    String recipeId = "String_Node_Str" + Block.blockRegistry.getNameForObject(block) + "String_Node_Str" + itemStack.getItemDamage() + "String_Node_Str";
    ItemStack facade = getFacadeForBlock(block, itemStack.getItemDamage());
    if (!allFacadeIDs.contains(recipeId)) {
        allFacadeIDs.add(recipeId);
        allFacades.add(facade);
        ItemStack facade6 = facade.copy();
        facade6.stackSize = 6;
        FacadeState state = getFacadeStates(facade6)[0];
        ItemStack facadeHollow = getFacade(new FacadeState(state.block, state.metadata, state.wire, true));
        allHollowFacades.add(facadeHollow);
        ItemStack facade6Hollow = facadeHollow.copy();
        facade6Hollow.stackSize = 6;
        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId, 8000, facade6, new ItemStack(BuildCraftTransport.pipeStructureCobblestone, 3), itemStack);
        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 8000, facade6Hollow, new ItemStack(BuildCraftTransport.pipeStructureCobblestone, 3), itemStack);
        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 160, facadeHollow, facade);
        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 160, facade, facadeHollow);
    }
}

Output:
         facade6Hollow.stackSize = 6;
-        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId, 8000, facade6, new ItemStack(BuildCraftTransport.pipeStructureCobblestone, 3), itemStack);
-        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 8000, facade6Hollow, new ItemStack(BuildCraftTransport.pipeStructureCobblestone, 3), itemStack);
-        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 160, facadeHollow, facade);
-        BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 160, facade, facadeHollow);
+        if (Loader.isModLoaded("String_Node_Str")) {
+            BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId, 8000, facade6, new ItemStack(BuildCraftTransport.pipeStructureCobblestone, 3), itemStack);
+            BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 8000, facade6Hollow, new ItemStack(BuildCraftTransport.pipeStructureCobblestone, 3), itemStack);
+            BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 160, facadeHollow, facade);
+            BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipeId + "String_Node_Str", 160, facade, facadeHollow);
+        } else {
+            GameRegistry.addShapedRecipe(facade6, "String_Node_Str", "String_Node_Str", "String_Node_Str", 't', itemStack, 's', BuildCraftTransport.pipeStructureCobblestone);
+            GameRegistry.addShapedRecipe(facade6Hollow, "String_Node_Str", "String_Node_Str", "String_Node_Str", 't', itemStack, 's', BuildCraftTransport.pipeStructureCobblestone);
+        }
     }


Input:
public int getID() {
    return 0;
}

Output:
 public int getID() {
-    return 0;
+    return ID;
 }


Input:
public static void stopSparkProgram() {
    sparkContextStopBugFixer();
    if (isScalaProgram()) {
        ((org.apache.spark.SparkContext) getSparkContext().getOriginalSparkContext()).stop();
    } else {
        ((org.apache.spark.api.java.JavaSparkContext) getSparkContext().getOriginalSparkContext()).stop();
    }
}

Output:
 public static void stopSparkProgram() {
-    sparkContextStopBugFixer();
-    if (isScalaProgram()) {
-        ((org.apache.spark.SparkContext) getSparkContext().getOriginalSparkContext()).stop();
-    } else {
-        ((org.apache.spark.api.java.JavaSparkContext) getSparkContext().getOriginalSparkContext()).stop();
+    if (getSparkContext() != null) {
+        if (isScalaProgram()) {
+            ((org.apache.spark.SparkContext) getSparkContext().getOriginalSparkContext()).stop();
+        } else {
+            ((org.apache.spark.api.java.JavaSparkContext) getSparkContext().getOriginalSparkContext()).stop();
+        }
     }


Input:
public void onClick(View v) {
    EditText priceEditText = (EditText) portfolioItemEdit.findViewById(R.id.portfolio_item_price);
    String price = priceEditText.getText().toString();
    EditText dateEditText = (EditText) portfolioItemEdit.findViewById(R.id.portfolio_item_date);
    String date = dateEditText.getText().toString();
    EditText quantityEditText = (EditText) portfolioItemEdit.findViewById(R.id.portfolio_item_quantity);
    String quantity = quantityEditText.getText().toString();
    EditText limitHighEditText = (EditText) portfolioItemEdit.findViewById(R.id.portfolio_item_limit_high);
    String limitHigh = limitHighEditText.getText().toString();
    EditText limitLowEditText = (EditText) portfolioItemEdit.findViewById(R.id.portfolio_item_limit_low);
    String limitLow = limitLowEditText.getText().toString();
    EditText customDisplayText = (EditText) portfolioItemEdit.findViewById(R.id.portfolio_item_symbol);
    String customDisplay = customDisplayText.getText().toString();
    if (price.equals("String_Node_Str")) {
        date = "String_Node_Str";
        quantity = "String_Node_Str";
        limitHigh = "String_Node_Str";
        limitLow = "String_Node_Str";
    } else {
        try {
            price = Double.toString(Double.parseDouble(price));
            if (!date.equals("String_Node_Str")) {
                SimpleDateFormat formatter = new SimpleDateFormat("String_Node_Str");
                date = formatter.format(formatter.parse(date.replaceAll("String_Node_Str", "String_Node_Str"))).toUpperCase();
            }
            if (!quantity.equals("String_Node_Str")) {
                quantity = Double.toString(Double.parseDouble(quantity));
            }
            if (!limitHigh.equals("String_Node_Str")) {
                limitHigh = Double.toString(Double.parseDouble(limitHigh));
            }
            if (!limitLow.equals("String_Node_Str")) {
                limitLow = Double.toString(Double.parseDouble(limitLow));
            }
        } catch (Exception e) {
            portfolioItemEdit.dismiss();
            return;
        }
    }
    if (price.indexOf("String_Node_Str") == price.length() - 2) {
        price = price + "String_Node_Str";
    }
    portfolioRepository.updateStock(price, date, quantity, limitHigh, limitLow, customDisplay);
    refreshView();
    portfolioItemEdit.dismiss();
}

Output:
     }
-    portfolioRepository.updateStock(price, date, quantity, limitHigh, limitLow, customDisplay);
+    portfolioRepository.updateStock(mStockSymbol, price, date, quantity, limitHigh, limitLow, customDisplay);
     refreshView();


Input:
public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException {
    levelIndex++;
    StartElementEvent event = new StartElementEvent(uri, localName, qName, atts);
    events.add(event);
    if (startOccurred) {
        processComplexElement();
        return;
    }
    startOccurred = true;
}

Output:
     levelIndex++;
-    StartElementEvent event = new StartElementEvent(uri, localName, qName, atts);
+    Attributes copiedAttrs = buildAttributeList(atts);
+    StartElementEvent event = new StartElementEvent(uri, localName, qName, copiedAttrs);
     events.add(event);


Input:
private void addUpdate(final LogEvent logEvent) {
    new SwingWorker<LogEvent, Void>() {

        protected LogEvent doInBackground() throws Exception {
            return logEvent;
        }
        protected void done() {
            LogEvent event;
            try {
                event = get();
                SwingTreeLogger logger = event.childLogger;
                DefaultMutableTreeNode node;
                DefaultMutableTreeNode parent;
                int idx;
                if (event.isBranchCommit) {
                    SwingTreeLogger parentLogger = (SwingTreeLogger) logger.getParentLogger();
                    parent = parentLogger.treeNode;
                    idx = logger.getBranchedIndex();
                    node = logger.treeNode;
                } else {
                    parent = logger.treeNode;
                    idx = event.index;
                    node = new DefaultMutableTreeNode(event);
                }
                int insertIndex = findInsertionPoint(parent, idx);
                panel.treeModel.insertNodeInto(node, parent, insertIndex);
                if (parent == panel.treeModel.getRoot() && parent.getChildCount() == 1) {
                    panel.treeModel.reload();
                }
                if (event.type.needsAttention()) {
                    panel.tree.makeVisible(new TreePath(node.getPath()));
                }
                Type priority = event.getInheritedPriority();
                while (parent != panel.treeModel.getRoot()) {
                    LogEvent parentEvent = (LogEvent) parent.getUserObject();
                    if (!parentEvent.updateInheritedPriority(priority)) {
                        break;
                    }
                    parent = (DefaultMutableTreeNode) parent.getParent();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        private int findInsertionPoint(DefaultMutableTreeNode parent, int index) {
            int high = parent.getChildCount() - 1;
            if (high < 0) {
                return 0;
            }
            int low = 0;
            while (low <= high) {
                final int mid = low + ((high - low) >> 1);
                DefaultMutableTreeNode midChild = (DefaultMutableTreeNode) parent.getChildAt(mid);
                final Object userObject = midChild.getUserObject();
                int compIdx = -1;
                if (userObject instanceof LogEvent) {
                    LogEvent event = (LogEvent) userObject;
                    compIdx = event.index;
                }
                if (compIdx < index) {
                    low = mid + 1;
                } else if (compIdx > index) {
                    high = mid - 1;
                } else {
                    return mid;
                }
            }
            return low;
        }
    }.execute();
}

Output:
 private void addUpdate(final LogEvent logEvent) {
-    new SwingWorker<LogEvent, Void>() {
+    EventQueue.invokeLater(new Runnable() {


Input:
public void handle(RoutingContext ctx) {
    if (nagHttps) {
        String uri = ctx.request().absoluteURI();
        if (!uri.startsWith("String_Node_Str")) {
            log.warn("String_Node_Str" + uri);
        }
    }
    HttpMethod method = ctx.request().method();
    switch(method) {
        case GET:
            final String token = generateToken();
            ctx.put(headerName, token);
            ctx.addCookie(Cookie.cookie(cookieName, token));
            ctx.next();
            break;
        case POST:
        case PUT:
        case DELETE:
        case PATCH:
            final String header = ctx.request().getHeader(headerName);
            if (validateToken(header == null ? ctx.request().getFormAttribute(headerName) : header)) {
                ctx.next();
            } else {
                ctx.fail(403);
            }
            break;
        default:
            ctx.next();
            break;
    }
}

Output:
             } else {
-                ctx.fail(403);
+                forbidden(ctx);
             }


Input:
public List<ConnBundleTO> getAllBundles() {
    List<ConnBundleTO> bundles = null;
    try {
        bundles = Arrays.asList(restTemplate.getForObject(baseURL + "String_Node_Str", ConnBundleTO[].class));
    } catch (SyncopeClientCompositeErrorException e) {
        LOG.error("String_Node_Str", e);
    }
    return bundles;
}

Output:
     try {
-        bundles = Arrays.asList(restTemplate.getForObject(baseURL + "String_Node_Str", ConnBundleTO[].class));
+        bundles = Arrays.asList(restTemplate.getForObject(baseURL + "String_Node_Str" + SyncopeSession.get().getLocale(), ConnBundleTO[].class));
     } catch (SyncopeClientCompositeErrorException e) {


Input:
public FluidTank getTank() {
    if (this.getBlockMetadata() > 0) {
        if (this.getBlockMetadata() == 1) {
            return this.myTank;
        } else {
            if (this.hasMaster()) {
                return this.getMasterTileEntity().getTank();
            }
        }
    }
    return null;
}

Output:
         } else {
-            if (this.hasMaster()) {
-                return this.getMasterTileEntity().getTank();
+            if (this.hasPrimary()) {
+                return this.getPrimaryTileEntity().getTank();
             }


Input:
public List<Quote> getLastQuotes(Symbol symbol) throws ProviderException {
    boolean download = true;
    File f = new File("String_Node_Str");
    if (f.exists()) {
        Date modified = new Date(f.lastModified());
        if (DateUtils.isToday(modified)) {
            download = false;
        }
    }
    if (download) {
        try {
            new MedusaHttpClient().download(LAST_QUOTES_URL, f);
        } catch (HttpException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    List<File> files = new LinkedList<File>();
    ZipEntry entry = null;
    String name = null;
    FileOutputStream fos = null;
    InputStream is = null;
    int i = -1;
    byte[] bytes = new byte[1024];
    try {
        ZipFile zip = new ZipFile(f);
        Enumeration<? extends ZipEntry> entries = zip.entries();
        while (entries.hasMoreElements()) {
            entry = entries.nextElement();
            name = entry.getName();
            if (!name.matches("String_Node_Str")) {
                continue;
            }
            is = zip.getInputStream(entry);
            f = new File("String_Node_Str" + name);
            if (!f.exists()) {
                if (!f.createNewFile()) {
                    throw new ProviderException("String_Node_Str" + f.getName());
                }
            }
            fos = new FileOutputStream(f);
            while ((i = is.read(bytes)) != -1) {
                fos.write(bytes, 0, i);
            }
            fos.close();
            files.add(f);
        }
    } catch (Exception e) {
        throw new ProviderException(e);
    }
    FileInputStream fis = null;
    InputStreamReader isr = null;
    BufferedReader br = null;
    String line = null;
    String[] parts = null;
    Date date = null;
    double open = 0;
    double high = 0;
    double low = 0;
    double close = 0;
    long volume = 0;
    List<Quote> quotes = new LinkedList<Quote>();
    Quote quote = null;
    for (File file : files) {
        try {
            fis = new FileInputStream(file);
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);
            while (br.ready()) {
                line = br.readLine();
                if (line.startsWith(symbol.getName())) {
                    parts = line.split("String_Node_Str");
                    break;
                }
            }
            if (parts == null) {
                if (quote == null) {
                    List<Quote> tmp = QuotesRegistry.getInstance().getQuotes(symbol);
                    if (tmp.size() > 0) {
                        quote = tmp.get(tmp.size() - 1);
                    } else {
                        continue;
                    }
                } else {
                }
            } else {
                if (parts.length < 7) {
                    throw new ProviderException("String_Node_Str" + "String_Node_Str" + parts.length + "String_Node_Str");
                }
                if (!parts[0].equals(symbol.getName())) {
                    throw new ProviderException("String_Node_Str" + symbol + "String_Node_Str" + "String_Node_Str" + parts[0] + "String_Node_Str");
                }
                date = DATE_FORMAT.parse(parts[1]);
                open = Double.valueOf(parts[2]);
                high = Double.valueOf(parts[3]);
                low = Double.valueOf(parts[4]);
                close = Double.valueOf(parts[5]);
                volume = Long.valueOf(parts[6]);
                quote = new Quote(date, open, high, low, close, volume);
            }
            quotes.add(quote);
        } catch (Throwable e) {
            throw new ProviderException(e);
        }
    }
    return quotes;
}

Output:
     boolean download = true;
-    File f = new File("String_Node_Str");
+    String dir = CFG.getProperty("String_Node_Str", "String_Node_Str");
+    File f = new File(dir + "String_Node_Str");
     if (f.exists()) {


Input:
private void showHelp() {
    getShell().setFocus();
    IContext context = HelpSystem.getContext(HelpPlugin.getDefault().getIndicatorHelpContextID());
    IWorkbenchHelpSystem helpSystem = PlatformUI.getWorkbench().getHelpSystem();
    helpSystem.displayHelp(context);
    ReusableHelpPart lastActiveInstance = ReusableHelpPart.getLastActiveInstance();
    if (lastActiveInstance != null) {
        lastActiveInstance.showURL(href);
    }
}

Output:
     IWorkbenchHelpSystem helpSystem = PlatformUI.getWorkbench().getHelpSystem();
-    helpSystem.displayHelp(context);
-    ReusableHelpPart lastActiveInstance = ReusableHelpPart.getLastActiveInstance();
-    if (lastActiveInstance != null) {
-        lastActiveInstance.showURL(href);
+    if (href.endsWith(HelpPlugin.HELP_FILE_SUFFIX)) {
+        helpSystem.displayHelp(context);
+        ReusableHelpPart lastActiveInstance = ReusableHelpPart.getLastActiveInstance();
+        if (lastActiveInstance != null) {
+            lastActiveInstance.showURL(href);
+        }
     }


Input:
private int getLineNumber(CallInfo ci) {
    int[] lineNumbers = ci.closure.p.lineinfo;
    int pc = ci.pc;
    int line = (lineNumbers != null && lineNumbers.length > pc ? lineNumbers[pc] : -1);
    return line;
}

Output:
     int[] lineNumbers = ci.closure.p.lineinfo;
-    int pc = ci.pc;
+    int pc = (ci != calls[cc] ? ci.pc - 1 : ci.pc);
     int line = (lineNumbers != null && lineNumbers.length > pc ? lineNumbers[pc] : -1);


Input:
public void renderGridLines(Canvas c) {
    if (!mXAxis.isDrawGridLinesEnabled() || !mXAxis.isEnabled())
        return;
    float[] position = new float[] { 0f, 0f };
    mGridPaint.setColor(mXAxis.getGridColor());
    mGridPaint.setStrokeWidth(mXAxis.getGridLineWidth());
    mGridPaint.setPathEffect(mXAxis.getGridDashPathEffect());
    for (int i = mMinX; i <= mMaxX; i += mXAxis.mAxisLabelModulus) {
        position[0] = i;
        mTrans.pointValuesToPixel(position);
        if (position[0] >= mViewPortHandler.offsetLeft() && position[0] <= mViewPortHandler.getChartWidth()) {
            c.drawLine(position[0], mViewPortHandler.offsetTop(), position[0], mViewPortHandler.contentBottom(), mGridPaint);
        }
    }
}

Output:
         if (position[0] >= mViewPortHandler.offsetLeft() && position[0] <= mViewPortHandler.getChartWidth()) {
-            c.drawLine(position[0], mViewPortHandler.offsetTop(), position[0], mViewPortHandler.contentBottom(), mGridPaint);
+            gridLinePath.moveTo(position[0], mViewPortHandler.contentBottom());
+            gridLinePath.lineTo(position[0], mViewPortHandler.contentTop());
+            c.drawPath(gridLinePath, mGridPaint);
         }


Input:
public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) {
    if (game.getPlayer(sourceControllerId).getGraveyard().count(filter, sourceId, sourceControllerId, game) >= this.minNumberOfTargets) {
        return true;
    }
    return false;
}

Output:
 public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) {
-    if (game.getPlayer(sourceControllerId).getGraveyard().count(filter, sourceId, sourceControllerId, game) >= this.minNumberOfTargets) {
-        return true;
+    Player player = game.getPlayer(sourceControllerId);
+    if (player != null) {
+        int possibleTargets = 0;
+        for (Card card : player.getGraveyard().getCards(filter, game)) {
+            if (sourceId == null || isNotTarget() || !game.replaceEvent(GameEvent.getEvent(GameEvent.EventType.TARGET, card.getId(), sourceId, sourceControllerId))) {
+                possibleTargets++;
+                if (possibleTargets >= this.minNumberOfTargets) {
+                    return true;
+                }
+            }
+        }
     }


Input:
public void perform(GraphRewrite event, EvaluationContext context) {
    VarStack varStack = VarStack.instance(event);
    MavenProjectModel mavenFacetModel = varStack.getCurrentPayload(MavenProjectModel.class, "String_Node_Str");
    results.add(mavenFacetModel);
}

Output:
     VarStack varStack = VarStack.instance(event);
-    MavenProjectModel mavenFacetModel = varStack.getCurrentPayload(MavenProjectModel.class, "String_Node_Str");
+    MavenProjectModel mavenFacetModel = Iteration.getCurrentPayload(varStack, MavenProjectModel.class, "String_Node_Str");
     results.add(mavenFacetModel);


Input:
public void addVessel(Vessel vessel) throws VesselAlreadyExistsException {
    if (vesselDao.findDuplicateByVesselNumber(vessel.getVesselNumber()).size() > 0)
        throw new VesselAlreadyExistsException(vessel.getVesselNumber());
    else
        vesselDao.addVessel(vessel);
}

Output:
 public void addVessel(Vessel vessel) throws VesselAlreadyExistsException {
-    if (vesselDao.findDuplicateByVesselNumber(vessel.getVesselNumber()).size() > 0)
-        throw new VesselAlreadyExistsException(vessel.getVesselNumber());
+    if (vesselDao.findVesselByName(vessel.getVesselName()).size() > 0)
+        throw new VesselAlreadyExistsException(vessel.getVesselName());
     else


Input:
public void init(GameEngine gameEngine) {
    context = gameEngine.createChildContext();
    CoreRegistry.setContext(context);
    EntitySystemSetupUtil.addEntityManagementRelatedClasses(context);
    entityManager = context.get(EngineEntityManager.class);
    eventSystem = context.get(EventSystem.class);
    context.put(Console.class, new ConsoleImpl(context));
    NUIManager nuiManager = new NUIManagerInternal(context.get(CanvasRenderer.class), context);
    context.put(NUIManager.class, nuiManager);
    componentSystemManager = new ComponentSystemManager(context);
    context.put(ComponentSystemManager.class, componentSystemManager);
    componentSystemManager.register(new ConsoleSystem(), "String_Node_Str");
    componentSystemManager.register(new CoreCommands(), "String_Node_Str");
    componentSystemManager.register(context.get(InputSystem.class), "String_Node_Str");
    EntityRef localPlayerEntity = entityManager.create(new ClientComponent());
    LocalPlayer localPlayer = new LocalPlayer(context.get(EntityIdMap.class));
    context.put(LocalPlayer.class, localPlayer);
    localPlayer.setClientEntity(localPlayerEntity);
    componentSystemManager.initialise();
    GameManifest gameManifest = null;
    List<GameInfo> savedGames = GameProvider.getSavedGames();
    if (savedGames.size() > 0) {
        gameManifest = savedGames.get(0).getManifest();
    } else {
        gameManifest = createGameManifest();
    }
    gameEngine.changeState(new StateLoading(gameManifest, NetworkMode.LISTEN_SERVER));
}

Output:
     componentSystemManager.initialise();
-    GameManifest gameManifest = null;
+    GameManifest gameManifest;
     List<GameInfo> savedGames = GameProvider.getSavedGames();


Input:
public Map<String, UIComponent> getFacets(UIComponent comp, Object nodeObject) {
    if (nodeObject == null) {
        return null;
    }
    if (nodeObject == TOP_ID) {
        return null;
    }
    Properties props = new Properties();
    LayoutComponent desc = this.getLayoutComponent();
    setProperty(props, "String_Node_Str", desc.getOption("String_Node_Str"));
    setProperty(props, "String_Node_Str", desc.getOption("String_Node_Str"));
    FacesContext ctx = FacesContext.getCurrentInstance();
    ComponentUtil compUtil = ComponentUtil.getInstance(ctx);
    UIComponent imageLink = compUtil.getChild(comp, "String_Node_Str", "String_Node_Str", props, "String_Node_Str");
    imageLink.setRendererType("String_Node_Str");
    setProperty(props, "String_Node_Str", comp.getAttributes().get("String_Node_Str"));
    UIComponent link = compUtil.getChild(comp, "String_Node_Str", "String_Node_Str", props, "String_Node_Str");
    link.setRendererType("String_Node_Str");
    Object val = desc.getOption("String_Node_Str");
    if (val != null) {
        val = desc.resolveValue(ctx, link, val);
        link.getAttributes().put("String_Node_Str", val);
        imageLink.getAttributes().put("String_Node_Str", val);
    }
    val = desc.getOption("String_Node_Str");
    if (val != null) {
        imageLink.getAttributes().put("String_Node_Str", desc.resolveValue(ctx, link, val));
    }
    List handlers = desc.getHandlers("String_Node_Str");
    if (handlers != null) {
        link.getAttributes().put("String_Node_Str", handlers);
        imageLink.getAttributes().put("String_Node_Str", handlers);
        ((ActionSource) link).addActionListener(CommandActionListener.getInstance());
        ((ActionSource) imageLink).addActionListener(CommandActionListener.getInstance());
    }
    return null;
}

Output:
     }
-    if (nodeObject == TOP_ID) {
+    if ((nodeObject instanceof Integer) && nodeObject == TOP_ID) {
         return null;


Input:
private void forwardQueryToUltrapeers(QueryRequest query, ReplyHandler handler) {
    List list = _manager.getInitializedConnections();
    int limit = list.size();
    for (int i = 0; i < limit; i++) {
        ManagedConnection mc = (ManagedConnection) list.get(i);
        forwardQueryToUltrapeer(query, handler, mc);
    }
}

Output:
 private void forwardQueryToUltrapeers(QueryRequest query, ReplyHandler handler) {
-    List list = _manager.getInitializedConnections();
+    List<ManagedConnection> list = _manager.getInitializedConnections();
     int limit = list.size();


Input:
protected boolean storeStatement(WikidataStatement statement) throws DaoException {
    int itemId = statement.getItem().getId();
    Geometry g = EarthBasicCoordinatesWikidataLayerLoader.jsonToGeometry(statement.getValue().getJsonValue().getAsJsonObject());
    if (g != null) {
        Iterable<WikidataStatement> instanceOfStatements = wdDao.get((new WikidataFilter.Builder()).withPropertyId(INSTANCE_OF_PROPERTY_ID).withEntityId(itemId).build());
        int count = 0;
        for (WikidataStatement instanceOfStatement : instanceOfStatements) {
            int typeItemId = instanceOfStatement.getValue().getItemValue();
            String layerName = Integer.toString(typeItemId);
            spatialDao.saveGeometry(itemId, layerName, EARTH_REF_SYS_NAME, g);
            count++;
        }
        if (count > 0) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

Output:
     if (g != null) {
-        Iterable<WikidataStatement> instanceOfStatements = wdDao.get((new WikidataFilter.Builder()).withPropertyId(INSTANCE_OF_PROPERTY_ID).withEntityId(itemId).build());
+        Iterable<WikidataStatement> instanceOfStatements = wdDao.get((new WikidataFilter.Builder()).withEntityId(itemId).withPropertyId(INSTANCE_OF_PROPERTY_ID).build());
         int count = 0;


Input:
public void testGoogIsArray2() throws Exception {
    testClosureFunction("String_Node_Str", ALL_TYPE, ALL_TYPE, ALL_TYPE);
}

Output:
 public void testGoogIsArray2() throws Exception {
-    testClosureFunction("String_Node_Str", ALL_TYPE, ALL_TYPE, ALL_TYPE);
+    testClosureFunction("String_Node_Str", ALL_TYPE, ARRAY_TYPE, ALL_TYPE);
 }


Input:
private void initialize() throws Exception {
    if (ejbStatsProvider == null) {
        synchronized (EjbSecurityStatsProvider.class) {
            if (ejbStatsProvider == null) {
                ejbStatsProvider = new EjbSecurityStatsProvider();
                StatsProviderManager.register("String_Node_Str", PluginPoint.SERVER, "String_Node_Str", ejbStatsProvider);
            }
        }
    }
    contextId = getContextID(deploymentDescriptor);
    String appName = deploymentDescriptor.getApplication().getRegistrationName();
    roleMapperFactory.setAppNameForContext(appName, contextId);
    codesource = getApplicationCodeSource(contextId);
    ejbName = deploymentDescriptor.getName();
    realmName = deploymentDescriptor.getApplication().getRealm();
    if (realmName == null) {
        Set iorConfigs = deploymentDescriptor.getIORConfigurationDescriptors();
        Iterator iter = iorConfigs.iterator();
        if (iter != null) {
            while (iter.hasNext()) {
                EjbIORConfigurationDescriptor iorConfig = (EjbIORConfigurationDescriptor) iter.next();
                realmName = iorConfig.getRealmName();
            }
        }
    }
    if (_logger.isLoggable(Level.FINE)) {
        _logger.fine("String_Node_Str" + contextId);
        _logger.fine("String_Node_Str" + ejbName + "String_Node_Str" + codebase);
    }
    loadPolicyConfiguration(deploymentDescriptor);
    uncheckedMethodPermissionCache = PermissionCacheFactory.createPermissionCache(this.contextId, this.codesource, EJBMethodPermission.class, this.ejbName);
    auditManager = this.ejbSFM.getAuditManager();
}

Output:
     if (realmName == null) {
-        Set iorConfigs = deploymentDescriptor.getIORConfigurationDescriptors();
-        Iterator iter = iorConfigs.iterator();
+        Set<EjbIORConfigurationDescriptor> iorConfigs = deploymentDescriptor.getIORConfigurationDescriptors();
+        Iterator<EjbIORConfigurationDescriptor> iter = iorConfigs.iterator();
         if (iter != null) {


Input:
public int copyCodePointsExceptTrailingSingleQuotesAndReturnCodePointCount(final int[] destination, final int maxSize) {
    final int i = mTypedWordCache.length() - 1 - trailingSingleQuotesCount();
    if (i < 0) {
        return 0;
    }
    final int codePointSize = Character.codePointCount(mTypedWordCache, 0, i);
    if (codePointSize > maxSize) {
        return -1;
    }
    return StringUtils.copyCodePointsAndReturnCodePointCount(destination, mTypedWordCache, 0, i + 1, true);
}

Output:
     }
-    final int codePointSize = Character.codePointCount(mTypedWordCache, 0, i);
-    if (codePointSize > maxSize) {
+    final int codePointSize = Character.codePointCount(mTypedWordCache, 0, lastIndex);
+    if (codePointSize > destination.length) {
         return -1;


Input:
private void displaySuperToast(SuperActivityToast superActivityToast) {
    if (superActivityToast.isShowing()) {
        return;
    }
    final ViewGroup viewGroup = superActivityToast.getViewGroup();
    final View toastView = superActivityToast.getView();
    if (viewGroup != null) {
        try {
            viewGroup.addView(toastView);
            if (!superActivityToast.getShowImmediate()) {
                toastView.startAnimation(getShowAnimation(superActivityToast));
            }
        } catch (IllegalStateException e) {
            Log.e(TAG, e.toString());
            clearSuperActivityToastsForActivity(superActivityToast.getActivity());
        }
    }
    if (!superActivityToast.isIndeterminate()) {
        Message message = obtainMessage(Messages.REMOVE);
        message.obj = superActivityToast;
        sendMessageDelayed(message, superActivityToast.getDuration() + getShowAnimation(superActivityToast).getDuration());
    }
}

Output:
         } catch (IllegalStateException e) {
-            Log.e(TAG, e.toString());
-            clearSuperActivityToastsForActivity(superActivityToast.getActivity());
+            this.cancelAllSuperActivityToastsForActivity(superActivityToast.getActivity());
         }


Input:
public String getLabel() {
    if (label == null) {
        IBrandingService brandingService = (IBrandingService) GlobalServiceRegister.getDefault().getService(IBrandingService.class);
        boolean allowVerchange = brandingService.getBrandingConfiguration().isAllowChengeVersion();
        if (allowVerchange) {
            label = property.getLabel() + "String_Node_Str" + property.getVersion();
        } else {
            label = property.getLabel();
        }
    }
    return label;
}

Output:
         boolean allowVerchange = brandingService.getBrandingConfiguration().isAllowChengeVersion();
-        if (allowVerchange) {
+        if (allowVerchange && property.getItem().isNeedVersion()) {
             label = property.getLabel() + "String_Node_Str" + property.getVersion();


Input:
public void onAudioMetadataRetrieved(AudioMetadataRetrievedEvent event) {
    this.audioMetadataFormatter = new AudioMetadataFormatter(event.getAudioTitle(), event.getAudioArtist(), event.getAudioAlbum());
    this.audioAlbumArt = event.getAudioAlbumArt();
    setUpAudioPlayerRemote(audioMetadataFormatter, audioAlbumArt);
    setUpAudioPlayerNotification(audioMetadataFormatter, audioAlbumArt);
}

Output:
     setUpAudioPlayerRemote(audioMetadataFormatter, audioAlbumArt);
-    setUpAudioPlayerNotification(audioMetadataFormatter, audioAlbumArt);
+    mMediaNotificationManager.startNotification();
 }


Input:
private void readCurrentRow() throws DataException {
    try {
        rowIndex = IOUtil.readInt(rowInputStream);
        startingGroupLevel = IOUtil.readInt(rowInputStream);
        endingGroupLevel = IOUtil.readInt(rowInputStream);
        columnValueMap.clear();
        for (int i = 0; i < columnList.size(); i++) {
            columnValueMap.put(columnList.get(i), IOUtil.readObject(rowInputStream));
        }
    } catch (IOException e) {
        throw new DataException(ResourceConstants.READ_CACHE_TEMPFILE_ERROR);
    }
}

Output:
         for (int i = 0; i < columnList.size(); i++) {
-            columnValueMap.put(columnList.get(i), IOUtil.readObject(rowInputStream));
+            columnValueMap.put(columnList.get(i), IOUtil.readObject(rowInputStream, DataEngineSession.getCurrentClassLoader()));
         }


Input:
public Map<String, Object> mockSinglePull(boolean shutdownMockWebserver, MockDispatcher.ServerType serverType, boolean addAttachments) throws Exception {
    String doc1Id = "String_Node_Str";
    String doc1Rev = "String_Node_Str";
    String doc2Id = "String_Node_Str";
    String doc2Rev = "String_Node_Str";
    String doc1AttachName = "String_Node_Str";
    String doc2AttachName = "String_Node_Str";
    int doc1Seq = 1;
    int doc2Seq = 2;
    MockWebServer server = MockHelper.getMockWebServer();
    MockDispatcher dispatcher = new MockDispatcher();
    dispatcher.setServerType(serverType);
    server.setDispatcher(dispatcher);
    MockResponse fakeCheckpointResponse = new MockResponse();
    MockHelper.set404NotFoundJson(fakeCheckpointResponse);
    dispatcher.enqueueResponse(MockHelper.PATH_REGEX_CHECKPOINT, fakeCheckpointResponse);
    MockChangesFeed mockChangesFeed = new MockChangesFeed();
    MockChangedDoc mockChangedDoc1 = new MockChangedDoc().setSeq(doc1Seq).setDocId(doc1Id).setChangedRevIds(Arrays.asList(doc1Rev));
    mockChangesFeed.add(mockChangedDoc1);
    MockChangedDoc mockChangedDoc2 = new MockChangedDoc().setSeq(doc2Seq).setDocId(doc2Id).setChangedRevIds(Arrays.asList(doc2Rev));
    mockChangesFeed.add(mockChangedDoc2);
    dispatcher.enqueueResponse(MockHelper.PATH_REGEX_CHANGES, mockChangesFeed.generateMockResponse());
    Map<String, Object> doc1JsonMap = MockHelper.generateRandomJsonMap();
    MockDocumentGet mockDocumentGet = new MockDocumentGet().setDocId(doc1Id).setRev(doc1Rev).setJsonMap(doc1JsonMap);
    if (addAttachments) {
        mockDocumentGet.addAttachmentFilename(doc1AttachName);
    }
    dispatcher.enqueueResponse("String_Node_Str", mockDocumentGet.generateMockResponse());
    Map<String, Object> doc2JsonMap = MockHelper.generateRandomJsonMap();
    mockDocumentGet = new MockDocumentGet().setDocId(doc2Id).setRev(doc2Rev).setJsonMap(doc2JsonMap);
    if (addAttachments) {
        mockDocumentGet.addAttachmentFilename(doc2AttachName);
    }
    dispatcher.enqueueResponse("String_Node_Str", mockDocumentGet.generateMockResponse());
    MockCheckpointPut mockCheckpointPut = new MockCheckpointPut();
    dispatcher.enqueueResponse(MockHelper.PATH_REGEX_CHECKPOINT, mockCheckpointPut);
    dispatcher.enqueueResponse(MockHelper.PATH_REGEX_CHECKPOINT, mockCheckpointPut);
    server.play();
    Replication pullReplication = doPullReplication(server.getUrl("String_Node_Str"));
    assertNotNull(database);
    Document doc1 = database.getDocument(doc1Id);
    assertNotNull(doc1);
    assertNotNull(doc1.getCurrentRevisionId());
    assertTrue(doc1.getCurrentRevisionId().startsWith("String_Node_Str"));
    assertNotNull(doc1.getProperties());
    assertEquals(doc1JsonMap, doc1.getUserProperties());
    Document doc2 = database.getDocument(doc2Id);
    assertNotNull(doc2);
    assertNotNull(doc2.getCurrentRevisionId());
    assertNotNull(doc2.getProperties());
    assertTrue(doc2.getCurrentRevisionId().startsWith("String_Node_Str"));
    assertEquals(doc2JsonMap, doc2.getUserProperties());
    if (addAttachments) {
        attachmentAsserts(doc1AttachName, doc1);
        attachmentAsserts(doc2AttachName, doc2);
    }
    RecordedRequest getCheckpointRequest = server.takeRequest();
    assertTrue(getCheckpointRequest.getMethod().equals("String_Node_Str"));
    assertTrue(getCheckpointRequest.getPath().matches(MockHelper.PATH_REGEX_CHECKPOINT));
    RecordedRequest getChangesFeedRequest = server.takeRequest();
    if (serverType == MockDispatcher.ServerType.SYNC_GW) {
        assertTrue(getChangesFeedRequest.getMethod().equals("String_Node_Str"));
    } else {
        assertTrue(getChangesFeedRequest.getMethod().equals("String_Node_Str"));
    }
    assertTrue(getChangesFeedRequest.getPath().matches(MockHelper.PATH_REGEX_CHANGES));
    RecordedRequest doc1Request = server.takeRequest();
    assertTrue(doc1Request.getMethod().equals("String_Node_Str"));
    assertTrue(doc1Request.getPath().matches("String_Node_Str"));
    RecordedRequest doc2Request = server.takeRequest();
    assertTrue(doc2Request.getMethod().equals("String_Node_Str"));
    assertTrue(doc2Request.getPath().matches("String_Node_Str"));
    RecordedRequest putCheckpointRequest = server.takeRequest();
    assertTrue(putCheckpointRequest.getMethod().equals("String_Node_Str"));
    assertTrue(putCheckpointRequest.getPath().matches(MockHelper.PATH_REGEX_CHECKPOINT));
    putCheckpointRequest = server.takeRequest();
    assertTrue(putCheckpointRequest.getMethod().equals("String_Node_Str"));
    assertTrue(putCheckpointRequest.getPath().matches(MockHelper.PATH_REGEX_CHECKPOINT));
    if (shutdownMockWebserver) {
        server.shutdown();
    }
    Map<String, Object> returnVal = new HashMap<String, Object>();
    returnVal.put("String_Node_Str", server);
    returnVal.put("String_Node_Str", dispatcher);
    return returnVal;
}

Output:
     }
-    dispatcher.enqueueResponse("String_Node_Str", mockDocumentGet.generateMockResponse());
+    String doc1PathRegex = "String_Node_Str";
+    dispatcher.enqueueResponse(doc1PathRegex, mockDocumentGet.generateMockResponse());
     Map<String, Object> doc2JsonMap = MockHelper.generateRandomJsonMap();


Input:
public boolean createEntity(Dao dao, Entity<?> en) {
    StringBuilder sb = new StringBuilder("String_Node_Str" + en.getTableName() + "String_Node_Str");
    for (MappingField mf : en.getMappingFields()) {
        sb.append('\n').append(mf.getColumnName());
        sb.append(' ').append(evalFieldType(mf));
        if (mf.isName() && en.getPkType() != PkType.NAME) {
            sb.append("String_Node_Str");
        } else {
            if (mf.isNotNull() || mf.isPk())
                sb.append("String_Node_Str");
            if (mf.hasDefaultValue())
                sb.append("String_Node_Str").append(mf.getDefaultValue(null)).append('\'');
            if (mf.isAutoIncreasement())
                sb.append("String_Node_Str");
            if (mf.isPk() && en.getPks().size() == 1) {
                sb.append("String_Node_Str");
            }
        }
        sb.append(',');
    }
    sb.setCharAt(sb.length() - 1, ')');
    dao.execute(Sqls.create(sb.toString()));
    if (en.getPks().size() > 1) {
        sb = new StringBuilder();
        sb.append("String_Node_Str").append(en.getTableName()).append("String_Node_Str");
        for (MappingField mf : en.getPks()) {
            sb.append(mf.getName()).append("String_Node_Str");
        }
        sb.setCharAt(sb.length() - 1, ')');
        dao.execute(Sqls.create(sb.toString()));
    }
    createRelation(dao, en);
    return true;
}

Output:
         for (MappingField mf : en.getPks()) {
-            sb.append(mf.getName()).append("String_Node_Str");
+            sb.append("String_Node_Str").append(mf.getColumnName());
+        }
+        sb.append("String_Node_Str");
+        for (MappingField mf : en.getPks()) {
+            sb.append(mf.getColumnName()).append("String_Node_Str");
         }


Input:
private boolean editDataSet(List existingDataSets, List newDataSets) {
    if (existingDataSets == null || newDataSets == null) {
        return false;
    }
    if (newDataSets.size() <= existingDataSets.size()) {
        return false;
    }
    dataSetHandle = findNewDataSet(existingDataSets, newDataSets);
    if (dataSetHandle == null)
        return false;
    if (dataSetHandle instanceof ScriptDataSetHandle) {
        return false;
    }
    DataSetEditor dialog = new DataSetEditor(PlatformUI.getWorkbench().getDisplay().getActiveShell(), dataSetHandle, true);
    return (dialog.open() == Window.OK);
}

Output:
     }
-    DataSetEditor dialog = new DataSetEditor(PlatformUI.getWorkbench().getDisplay().getActiveShell(), dataSetHandle, true);
+    DataSetEditor dialog = new AdvancedDataSetEditor(PlatformUI.getWorkbench().getDisplay().getActiveShell(), dataSetHandle, true);
     return (dialog.open() == Window.OK);


Input:
private static LuceneCacheWrapper<NumericDocValues> getLuceneCache(FunctionQParser fp, String fieldname) throws SyntaxError {
    LuceneCacheWrapper<NumericDocValues> cacheWrapper;
    SchemaField field = fp.getReq().getSchema().getField(fieldname);
    try {
        cacheWrapper = LuceneCacheWrapper.getFloatCache("String_Node_Str", field.getType().getUninversionType(field), fp.getReq().getSearcher().getLeafReader());
    } catch (IOException e) {
        throw new SyntaxError("String_Node_Str", e);
    }
    return cacheWrapper;
}

Output:
     try {
-        cacheWrapper = LuceneCacheWrapper.getFloatCache("String_Node_Str", field.getType().getUninversionType(field), fp.getReq().getSearcher().getLeafReader());
+        cacheWrapper = LuceneCacheWrapper.getFloatCache("String_Node_Str", UninvertingReader.Type.SORTED_SET_FLOAT, fp.getReq().getSearcher().getLeafReader());
     } catch (IOException e) {


Input:
private void createMenuBar() {
    JMenu fileMenu = new JMenu("String_Node_Str");
    JMenuItem fileOpenItem = new JMenuItem("String_Node_Str");
    fileOpenItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            showOpenLogDialog();
        }
    });
    fileMenu.add(fileOpenItem);
    JMenuItem loadPresetItem = new JMenuItem("String_Node_Str");
    loadPresetItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            showImportPresetDialog();
        }
    });
    fileMenu.add(loadPresetItem);
    JMenuItem savePresetItem = new JMenuItem("String_Node_Str");
    savePresetItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            showPresetExportDialog();
        }
    });
    fileMenu.add(savePresetItem);
    JMenuItem exportPlotItem = new JMenuItem("String_Node_Str");
    exportPlotItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            showPlotExportDialog();
        }
    });
    fileMenu.add(exportPlotItem);
    JMenuItem exportTrackItem = new JMenuItem("String_Node_Str");
    exportTrackItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            showTrackExportDialog();
        }
    });
    fileMenu.add(exportTrackItem);
    JMenuItem exportParametersItem = new JMenuItem("String_Node_Str");
    exportParametersItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            showParametersExportDialog();
        }
    });
    fileMenu.add(exportParametersItem);
    if (!OSValidator.isMac()) {
        fileMenu.add(new JPopupMenu.Separator());
        JMenuItem exitItem = new JMenuItem("String_Node_Str");
        exitItem.setAccelerator(KeyStroke.getKeyStroke('Q', Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
        exitItem.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                onQuit();
            }
        });
        fileMenu.add(exitItem);
    }
    JMenu viewMenu = new JMenu("String_Node_Str");
    timeModeItems = new JRadioButtonMenuItem[3];
    timeModeItems[TIME_MODE_LOG_START] = new JRadioButtonMenuItem("String_Node_Str");
    timeModeItems[TIME_MODE_BOOT] = new JRadioButtonMenuItem("String_Node_Str");
    timeModeItems[TIME_MODE_GPS] = new JRadioButtonMenuItem("String_Node_Str");
    ButtonGroup timeModeGroup = new ButtonGroup();
    for (JRadioButtonMenuItem item : timeModeItems) {
        timeModeGroup.add(item);
        item.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                onTimeModeChanged();
                processFile();
            }
        });
        viewMenu.add(item);
    }
    JMenuBar menuBar = new JMenuBar();
    menuBar.add(fileMenu);
    menuBar.add(viewMenu);
    mainFrame.setJMenuBar(menuBar);
}

Output:
     });
-    fileMenu.add(exportPlotItem);
+    fileMenu.add(exportAsImageItem);
     JMenuItem exportTrackItem = new JMenuItem("String_Node_Str");


Input:
public void setShares(long shares) {
    firePropertyChange(Properties.shares.name(), this.shares, this.shares = shares);
    if (quote.doubleValue() != 0) {
        setAmount(Math.round(shares * quote.doubleValue() * Values.Amount.factor() / Values.Share.divider()));
    } else if (amount != 0 && shares != 0) {
        setQuote(new BigDecimal(amount * Values.Share.factor() / (shares * Values.Amount.divider())));
    }
    firePropertyChange(Properties.calculationStatus.name(), this.calculationStatus, this.calculationStatus = calculateStatus());
}

Output:
     } else if (amount != 0 && shares != 0) {
-        setQuote(new BigDecimal(amount * Values.Share.factor() / (shares * Values.Amount.divider())));
+        setQuote(BigDecimal.valueOf(amount * Values.Share.factor() / (shares * Values.Amount.divider())));
     }


Input:
public void onClick(View v) {
    myCal.add(Calendar.YEAR, -1);
    updateCalendar();
}

Output:
     myCal.add(Calendar.YEAR, -1);
-    updateCalendar();
+    refresh();
 }


Input:
public static void updateRequestAttributes(HttpServletRequest req) {
    HttpSession sess = getHttpSession();
    if (null != getMessageSet()) {
        Map<String, String> msgs = null;
        if (!hasLocale(sess))
            msgs = setLocale(sess, getLocaleName(sess));
        else
            msgs = (Map<String, String>) sess.getAttribute(MSG);
        if (null == msgs) {
            Map<String, Map<String, String>> msgss = getMessageSet();
            if (msgss.size() > 0)
                msgs = msgss.values().iterator().next();
        }
        req.setAttribute(MSG, msgs);
    }
    req.setAttribute("String_Node_Str", req.getContextPath());
    req.setAttribute("String_Node_Str", req);
}

Output:
     if (null != getMessageSet()) {
-        Map<String, String> msgs = null;
+        Map<String, Object> msgs = null;
         if (!hasLocale(sess))


Input:
public int compare(Object o1, Object o2) {
    if (!(o1 instanceof String) || !(o2 instanceof String)) {
        return 0;
    }
    String s1 = (String) o1;
    String s2 = (String) o2;
    int thisMarker = 0;
    int thisNumericChunk = 0;
    int thatMarker = 0;
    int thatNumericChunk = 0;
    while ((thisMarker < s1.length()) && (thatMarker < s2.length())) {
        char thisCh = s1.charAt(thisMarker);
        char thatCh = s2.charAt(thatMarker);
        StringBuilder thisChunk = new StringBuilder();
        StringBuilder thatChunk = new StringBuilder();
        while ((thisMarker < s1.length()) && inChunk(thisCh, thisChunk.toString())) {
            thisChunk.append(thisCh);
            thisMarker++;
            if (thisMarker < s1.length())
                thisCh = s1.charAt(thisMarker);
        }
        while ((thatMarker < s2.length()) && inChunk(thatCh, thatChunk.toString())) {
            thatChunk.append(thatCh);
            thatMarker++;
            if (thatMarker < s2.length())
                thatCh = s2.charAt(thatMarker);
        }
        int thisChunkType = isIn(thisChunk.charAt(0), numbers) ? 1 : 0;
        int thatChunkType = isIn(thatChunk.charAt(0), numbers) ? 1 : 0;
        int result = 0;
        if ((thisChunkType == 1) && (thatChunkType == 1)) {
            thisNumericChunk = Integer.parseInt(thisChunk.toString());
            thatNumericChunk = Integer.parseInt(thatChunk.toString());
            if (thisNumericChunk < thatNumericChunk)
                result = -1;
            if (thisNumericChunk > thatNumericChunk)
                result = 1;
        } else {
            result = thisChunk.toString().compareTo(thatChunk.toString());
        }
        if (result != 0)
            return result;
    }
    return 0;
}

Output:
     }
-    return 0;
+    return new Integer(s1.length()).compareTo(s2.length());
 }


Input:
public void blockForm(BlockFormEvent event) {
    Map<String, dObject> context = new HashMap<String, dObject>();
    dMaterial material = dMaterial.getMaterialFrom(event.getBlock().getType(), event.getBlock().getData());
    context.put("String_Node_Str", new dLocation(event.getBlock().getLocation()));
    context.put("String_Node_Str", material);
    String determination = EventManager.doEvents(Arrays.asList("String_Node_Str", material.identifySimple() + "String_Node_Str"), null, null, context, true);
    if (determination.toUpperCase().startsWith("String_Node_Str"))
        event.setCancelled(true);
}

Output:
     Map<String, dObject> context = new HashMap<String, dObject>();
-    dMaterial material = dMaterial.getMaterialFrom(event.getBlock().getType(), event.getBlock().getData());
+    dMaterial material = dMaterial.getMaterialFrom(event.getNewState().getType(), event.getNewState().getData().getData());
     context.put("String_Node_Str", new dLocation(event.getBlock().getLocation()));


Input:
public void dispose() {
    synchronized (singletonLock) {
        singleton = null;
    }
    super.dispose();
}

Output:
 public void dispose() {
-    synchronized (singletonLock) {
-        singleton = null;
-    }
+    releaseSingleton(getSelectedPanelIndex());
     super.dispose();


Input:
public Void execute() throws Throwable {
    nodeService.setProperty(OLD_BEHAVIOR_SCRIPTS_FOLDER, ContentModel.PROP_DESCRIPTION, "String_Node_Str");
    List<FileInfo> oldBehaviorScripts = fileFolderService.listFiles(OLD_BEHAVIOR_SCRIPTS_FOLDER);
    if (oldBehaviorScripts != null && !oldBehaviorScripts.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str");
        }
        for (FileInfo script : oldBehaviorScripts) {
            fileFolderService.moveFrom(script.getNodeRef(), OLD_BEHAVIOR_SCRIPTS_FOLDER, RMv21BehaviorScriptsPatch.newBehaviorScriptsFolder, script.getName());
            if (logger.isDebugEnabled()) {
                logger.debug("String_Node_Str" + script.getName());
            }
        }
    }
    return null;
}

Output:
     if (oldBehaviorScripts != null && !oldBehaviorScripts.isEmpty()) {
-        if (logger.isDebugEnabled()) {
-            logger.debug("String_Node_Str");
+        if (LOGGER.isDebugEnabled()) {
+            LOGGER.debug("String_Node_Str");
         }


Input:
private void addOriginalMetadata(IResultClass meta, List projectedColumns) throws DataException {
    for (int i = 1; i <= meta.getFieldCount(); i++) {
        projectedColumns.add(new ResultFieldMetadata(i, meta.getFieldName(i), meta.getFieldName(i), meta.getFieldValueClass(i), meta.getFieldNativeTypeName(i), false));
    }
}

Output:
     for (int i = 1; i <= meta.getFieldCount(); i++) {
-        projectedColumns.add(new ResultFieldMetadata(i, meta.getFieldName(i), meta.getFieldName(i), meta.getFieldValueClass(i), meta.getFieldNativeTypeName(i), false));
+        ResultFieldMetadata rfm = new ResultFieldMetadata(i, meta.getFieldName(i), meta.getFieldName(i), meta.getFieldValueClass(i), meta.getFieldNativeTypeName(i), false);
+        rfm.setAlias(meta.getFieldAlias(i));
+        projectedColumns.add(rfm);
     }


Input:
public Object getJson() {
    Object _body = body();
    if (_body != null && _body instanceof String) {
        char initial = ((String) _body).charAt(0);
        if (initial == '{') {
            JsonSlurper slurper = new JsonSlurper();
            return slurper.parseText((String) _body);
        }
    }
    return null;
}

Output:
     if (_body != null && _body instanceof String) {
-        char initial = ((String) _body).charAt(0);
-        if (initial == '{') {
-            JsonSlurper slurper = new JsonSlurper();
-            return slurper.parseText((String) _body);
+        Boolean validObject = (Boolean) get("String_Node_Str");
+        Boolean validArray = (Boolean) get("String_Node_Str");
+        if (validObject != null && validObject) {
+            return parseText((String) _body);
+        }
+        if (validArray != null && validArray) {
+            return parseText((String) _body);
         }


Input:
public void processRequest() throws Exception {
    FormProcessor fp = new FormProcessor(request);
    HashMap<String, String> newUploadedFiles = (HashMap<String, String>) session.getAttribute("String_Node_Str");
    if (newUploadedFiles == null) {
        newUploadedFiles = new HashMap<String, String>();
    }
    String submitted = fp.getString("String_Node_Str") != null ? fp.getString("String_Node_Str") : "String_Node_Str";
    if ("String_Node_Str".equalsIgnoreCase(submitted)) {
        request.setAttribute("String_Node_Str", fp.getString("String_Node_Str"));
        request.setAttribute("String_Node_Str", fp.getString("String_Node_Str"));
        forwardPage(Page.FILE_UPLOAD);
    } else {
        String dir = Utils.getAttachedFilePath(currentStudy);
        if (dir == null || dir.length() <= 0) {
            request.setAttribute("String_Node_Str", "String_Node_Str");
            this.forwardPage(Page.FILE_UPLOAD);
        } else {
            if (!new File(dir).isDirectory()) {
                new File(dir).mkdirs();
                logger.info("String_Node_Str" + dir);
            }
            request.setAttribute("String_Node_Str", dir);
            try {
                List<File> files = uploadHelper.returnFiles(request, context, dir, new OCFileRename());
                String fileName = "String_Node_Str";
                for (File temp : files) {
                    if (temp == null || temp.getName() == null) {
                        fileName = "String_Node_Str";
                    } else {
                        fileName = temp.getName();
                        logger.info("String_Node_Str" + fileName);
                    }
                }
                logger.info("String_Node_Str" + fileName);
                request.setAttribute("String_Node_Str", fileName);
                request.setAttribute("String_Node_Str", "String_Node_Str");
                String key = "String_Node_Str";
                String inputName = (String) request.getAttribute("String_Node_Str");
                String itemId = (String) request.getAttribute("String_Node_Str");
                request.setAttribute("String_Node_Str", itemId + "String_Node_Str");
                if (inputName != null && inputName.length() > 0) {
                    key = fileName;
                } else {
                    key = itemId;
                }
                if (fileName.length() > 0) {
                    newUploadedFiles.put(key, dir + File.separator + fileName);
                    addPageMessage(fileName + "String_Node_Str" + respage.getString("String_Node_Str"));
                } else {
                    request.setAttribute("String_Node_Str", "String_Node_Str");
                    addPageMessage(respage.getString("String_Node_Str"));
                }
                if (inputName != null && inputName.length() > 0) {
                    request.setAttribute("String_Node_Str", inputName);
                }
                session.setAttribute("String_Node_Str", newUploadedFiles);
            } catch (OpenClinicaSystemException e) {
                request.setAttribute("String_Node_Str", "String_Node_Str");
                addPageMessage(respage.getString("String_Node_Str"));
                e.printStackTrace();
            }
            this.forwardPage(Page.FILE_UPLOAD);
        }
    }
}

Output:
                 request.setAttribute("String_Node_Str", "String_Node_Str");
-                addPageMessage(respage.getString("String_Node_Str"));
+                MessageFormat mf = new MessageFormat("String_Node_Str");
+                mf.applyPattern(respage.getString(e.getErrorCode()));
+                Object[] arguments = e.getErrorParams();
+                addPageMessage(respage.getString("String_Node_Str") + mf.format(arguments));
                 e.printStackTrace();


Input:
public static void setPostReblogged(ReaderPost post, boolean isReblogged) {
    if (post == null)
        return;
    String sql = "String_Node_Str" + SqlUtils.boolToSql(isReblogged) + "String_Node_Str";
    String[] args = { Long.toString(post.blogId), Long.toString(post.postId) };
    ReaderDatabase.getWritableDb().execSQL(sql, args);
}

Output:
 public static void setPostReblogged(ReaderPost post, boolean isReblogged) {
-    if (post == null)
+    if (post == null) {
         return;


Input:
public IRepositoryViewObject getLastVersion(Project project, String id, String relativeFolder, ERepositoryObjectType type) throws PersistenceException {
    List<IRepositoryViewObject> serializableAllVersion = null;
    Object fullFolder = getFullFolder(project, type, relativeFolder);
    serializableAllVersion = getSerializableFromFolder(project, fullFolder, id, type, false, false, false, true);
    if (serializableAllVersion.isEmpty()) {
        serializableAllVersion = getSerializable(project, id, true, false);
    }
    int size = serializableAllVersion.size();
    if (size > 1) {
        String message = getItemsMessages(serializableAllVersion, size);
        throw new PersistenceException(Messages.getString("String_Node_Str", message));
    } else if (size == 1) {
        return serializableAllVersion.get(0);
    } else {
        return null;
    }
}

Output:
     Object fullFolder = getFullFolder(project, type, relativeFolder);
-    serializableAllVersion = getSerializableFromFolder(project, fullFolder, id, type, false, false, false, true);
+    serializableAllVersion = getSerializableFromFolder(project, fullFolder, id, type, false, false, true, true);
     if (serializableAllVersion.isEmpty()) {


Input:
private String getTextValue(Element ele, String tagName) {
    String textVal = null;
    NodeList nl = ele.getElementsByTagName(tagName);
    if (nl != null && nl.getLength() > 0) {
        Element el = (Element) nl.item(0);
        textVal = el.getFirstChild().getNodeValue();
    }
    return textVal;
}

Output:
         Element el = (Element) nl.item(0);
-        textVal = el.getFirstChild().getNodeValue();
+        if (el != null) {
+            Node node = el.getFirstChild();
+            if (node != null)
+                textVal = node.getNodeValue();
+        }
     }


Input:
public void getNextChunk(MediaChunk previous, long playbackPositionUs, ChunkHolder out) {
    long bufferedDurationUs = previous != null ? (previous.endTimeUs - playbackPositionUs) : 0;
    trackSelection.updateSelectedTrack(bufferedDurationUs);
    int chunkIndex = previous == null ? dataSet.getChunkIndexByPosition(playbackPositionUs) : previous.getNextChunkIndex();
    if (chunkIndex >= dataSet.getChunkCount()) {
        out.endOfStream = true;
    } else {
        Format selectedFormat = trackSelection.getSelectedFormat();
        long startTimeUs = dataSet.getStartTime(chunkIndex);
        long endTimeUs = startTimeUs + dataSet.getChunkDuration(chunkIndex);
        String uri = dataSet.getUri(trackSelection.getSelectedIndex());
        Segment fakeDataChunk = dataSet.getData(uri).getSegments().get(chunkIndex);
        DataSpec dataSpec = new DataSpec(Uri.parse(uri), fakeDataChunk.byteOffset, fakeDataChunk.length, null);
        int trackType = MimeTypes.getTrackType(selectedFormat.sampleMimeType);
        out.chunk = new SingleSampleMediaChunk(dataSource, dataSpec, selectedFormat, trackSelection.getSelectionReason(), trackSelection.getSelectionData(), startTimeUs, endTimeUs, chunkIndex, trackType, selectedFormat);
    }
}

Output:
         long endTimeUs = startTimeUs + dataSet.getChunkDuration(chunkIndex);
-        String uri = dataSet.getUri(trackSelection.getSelectedIndex());
+        int trackGroupIndex = trackSelection.getIndexInTrackGroup(trackSelection.getSelectedIndex());
+        String uri = dataSet.getUri(trackGroupIndex);
         Segment fakeDataChunk = dataSet.getData(uri).getSegments().get(chunkIndex);


Input:
private boolean isAllCellNumberType(int idx) {
    XSheet sheet = ss.getSelectedXSheet();
    Rect rect = ss.getSelection();
    int top = sortOrientation ? idx : rect.getTop();
    int left = sortOrientation ? rect.getLeft() : idx;
    int bottom = sortOrientation ? idx : rect.getBottom();
    int right = sortOrientation ? rect.getRight() : idx;
    for (int row = top; row <= bottom; row++) {
        for (int col = left; col <= right; col++) {
            Cell c = Utils.getCell(sheet, row, col);
            if (c != null) {
                int type = c.getCellType() != Cell.CELL_TYPE_FORMULA ? c.getCellType() : c.getCachedFormulaResultType();
                if (type != Cell.CELL_TYPE_NUMERIC)
                    return false;
            }
        }
    }
    return true;
}

Output:
 private boolean isAllCellNumberType(int idx) {
-    XSheet sheet = ss.getSelectedXSheet();
+    Sheet sheet = ss.getSelectedSheet();
     Rect rect = ss.getSelection();


Input:
public void onAnimationEnd(Animator animation) {
    if (!hasLoadedGroups) {
        getButtons();
        initView();
        hasLoadedGroups = true;
    }
}

Output:
 public void onAnimationEnd(Animator animation) {
-    if (!hasLoadedGroups) {
+    long lastDBVersion = SharedUtil.readLong(Consts.Key_Last_Post_Groups_Version, 0);
+    if (currentDBVersion != lastDBVersion) {
         getButtons();


Input:
protected void findTable() {
    int meta = getBlockMetadata();
    int minX = xCoord - 5;
    int minY = yCoord - 5;
    int minZ = zCoord - 5;
    int maxX = xCoord + 5;
    int maxY = yCoord + 5;
    int maxZ = zCoord + 5;
    switch(EnumFacing.getOrientation(meta)) {
        case WEST:
            maxX = xCoord;
            break;
        case EAST:
            minX = xCoord;
            break;
        case DOWN:
            maxY = yCoord;
            break;
        case UP:
            minY = yCoord;
            break;
        case NORTH:
            maxZ = zCoord;
            break;
        default:
        case SOUTH:
            minZ = zCoord;
            break;
    }
    List<ILaserTarget> targets = new LinkedList<ILaserTarget>();
    if (minY < 0) {
        minY = 0;
    }
    if (maxY > 255) {
        maxY = 255;
    }
    for (int y = minY; y <= maxY; ++y) {
        for (int x = minX; x <= maxX; ++x) {
            for (int z = minZ; z <= maxZ; ++z) {
                if (BlockUtils.getBlock(worldObj, pos) instanceof ILaserTargetBlock) {
                    TileEntity tile = BlockUtils.getTileEntity(worldObj, pos);
                    if (tile instanceof ILaserTarget) {
                        ILaserTarget table = (ILaserTarget) tile;
                        if (table.requiresLaserEnergy()) {
                            targets.add(table);
                        }
                    }
                }
            }
        }
    }
    if (targets.isEmpty()) {
        return;
    }
    laserTarget = targets.get(worldObj.rand.nextInt(targets.size()));
}

Output:
     int maxZ = zCoord + 5;
-    switch(EnumFacing.getOrientation(meta)) {
+    switch(EnumFacing.getFront(meta)) {
         case WEST:


Input:
public AutoRefTeam getExpectedTeam(Player player) {
    AutoRefTeam actualTeam = getTeam(player);
    if (actualTeam != null)
        return actualTeam;
    for (AutoRefMatch match : matches.values()) {
        for (AutoRefTeam team : match.getTeams()) if (team.getExpectedPlayers().contains(player))
            return team;
    }
    return null;
}

Output:
     for (AutoRefMatch match : matches.values()) {
-        for (AutoRefTeam team : match.getTeams()) if (team.getExpectedPlayers().contains(player))
+        for (AutoRefTeam team : match.getTeams()) if (team.getExpectedPlayers().contains(player.getName()))
             return team;


Input:
public String getIcoIcon() {
    return RestApi.ICON_URL + app.hashTagICO + "String_Node_Str" + app.hashICO + "String_Node_Str" + icoInfo.iconUrl;
}

Output:
 public String getIcoIcon() {
-    return RestApi.ICON_URL + app.hashTagICO + "String_Node_Str" + app.hashICO + "String_Node_Str" + icoInfo.iconUrl;
+    return RestApi.ICON_URL + app.hashTagICO + "String_Node_Str" + app.hashICO + "String_Node_Str" + infoICO.iconUrl;
 }


Input:
public XMLCompositeObjectMapping generateCompositeObjectMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo, String referenceClassName) {
    XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
    mapping.setAttributeName(property.getPropertyName());
    if (property.isMethodProperty()) {
        if (property.getGetMethodName() == null) {
            String paramTypeAsString = property.getType().getName();
            mapping.setAttributeAccessor(new JAXBSetMethodAttributeAccessor(paramTypeAsString, helper.getClassLoader()));
            mapping.setIsReadOnly(true);
            mapping.setSetMethodName(property.getSetMethodName());
        } else if (property.getSetMethodName() == null) {
            mapping.setGetMethodName(property.getGetMethodName());
            mapping.setIsWriteOnly(true);
        } else {
            mapping.setSetMethodName(property.getSetMethodName());
            mapping.setGetMethodName(property.getGetMethodName());
        }
    }
    if (property.isNillable()) {
        mapping.getNullPolicy().setNullRepresentedByXsiNil(true);
    }
    mapping.setXPath(getXPathForField(property, namespaceInfo, false).getXPath());
    if (referenceClassName == null) {
        ((XMLField) mapping.getField()).setIsTypedTextField(true);
        ((XMLField) mapping.getField()).setSchemaType(XMLConstants.ANY_TYPE_QNAME);
        String defaultValue = property.getDefaultValue();
        if (null != defaultValue) {
            mapping.setConverter(new DefaultElementConverter(defaultValue));
        }
    } else {
        mapping.setReferenceClassName(referenceClassName);
    }
    if (property.getBackpointerPropertyName() != null) {
        mapping.setContainerAttributeName(property.getBackpointerPropertyName());
        if (!property.getBackpointerGetMethodName().equals("String_Node_Str") && !property.getBackpointerSetMethodName().equals("String_Node_Str")) {
            mapping.setContainerGetMethodName(property.getBackpointerSetMethodName());
            mapping.setContainerSetMethodName(property.getBackpointerSetMethodName());
        }
    }
    if (property.isRequired()) {
        ((XMLField) mapping.getField()).setRequired(true);
    }
    descriptor.addMapping(mapping);
    return mapping;
}

Output:
     }
-    if (property.getBackpointerPropertyName() != null) {
-        mapping.setContainerAttributeName(property.getBackpointerPropertyName());
-        if (!property.getBackpointerGetMethodName().equals("String_Node_Str") && !property.getBackpointerSetMethodName().equals("String_Node_Str")) {
-            mapping.setContainerGetMethodName(property.getBackpointerSetMethodName());
-            mapping.setContainerSetMethodName(property.getBackpointerSetMethodName());
+    if (property.getBidirectionalPropertyName() != null) {
+        mapping.setContainerAttributeName(property.getBidirectionalPropertyName());
+        JavaClass backPointerPropertyType = null;
+        JavaClass referenceClass = property.getActualType();
+        if (property.getBidirectionalPropertyGetMethodName() != null && property.getBidirectionalPropertySetMethodName() != null && !property.getBidirectionalPropertyGetMethodName().equals("String_Node_Str") && !property.getBidirectionalPropertySetMethodName().equals("String_Node_Str")) {
+            mapping.setContainerGetMethodName(property.getBidirectionalPropertySetMethodName());
+            mapping.setContainerSetMethodName(property.getBidirectionalPropertySetMethodName());
+            JavaMethod getMethod = referenceClass.getDeclaredMethod(mapping.getContainerGetMethodName(), new JavaClass[] {});
+            if (getMethod != null) {
+                backPointerPropertyType = getMethod.getReturnType();
+            }
+        } else {
+            JavaField backpointerField = referenceClass.getDeclaredField(property.getBidirectionalPropertyName());
+            if (backpointerField != null) {
+                backPointerPropertyType = backpointerField.getResolvedType();
+            }
+        }
+        if (isCollectionType(backPointerPropertyType)) {
+            mapping.getBidirectionalPolicy().setBidirectionalTargetContainerPolicy(ContainerPolicy.buildDefaultPolicy());
         }


Input:
void crashApplicationInner(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) {
    long timeMillis = System.currentTimeMillis();
    String shortMsg = crashInfo.exceptionClassName;
    String longMsg = crashInfo.exceptionMessage;
    String stackTrace = crashInfo.stackTrace;
    if (shortMsg != null && longMsg != null) {
        longMsg = shortMsg + "String_Node_Str" + longMsg;
    } else if (shortMsg != null) {
        longMsg = shortMsg;
    }
    AppErrorResult result = new AppErrorResult();
    TaskRecord task;
    synchronized (mService) {
        if (handleAppCrashInActivityController(r, crashInfo, shortMsg, longMsg, stackTrace, timeMillis)) {
            return;
        }
        if (r != null && r.instrumentationClass != null) {
            return;
        }
        if (r != null) {
            mService.mBatteryStatsService.noteProcessCrash(r.processName, r.uid);
        }
        AppErrorDialog.Data data = new AppErrorDialog.Data();
        data.result = result;
        data.proc = r;
        if (r == null || !makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, data)) {
            return;
        }
        Message msg = Message.obtain();
        msg.what = ActivityManagerService.SHOW_ERROR_UI_MSG;
        task = data.task;
        msg.obj = data;
        mService.mUiHandler.sendMessage(msg);
    }
    int res = result.get();
    Intent appErrorIntent = null;
    MetricsLogger.action(mContext, MetricsProto.MetricsEvent.ACTION_APP_CRASH, res);
    if (res == AppErrorDialog.TIMEOUT || res == AppErrorDialog.CANCEL) {
        res = AppErrorDialog.FORCE_QUIT;
    }
    synchronized (mService) {
        if (res == AppErrorDialog.MUTE) {
            stopReportingCrashesLocked(r);
        }
        if (res == AppErrorDialog.RESTART) {
            mService.removeProcessLocked(r, false, true, "String_Node_Str");
            if (task != null) {
                try {
                    mService.startActivityFromRecents(task.taskId, ActivityOptions.makeBasic().toBundle());
                } catch (IllegalArgumentException e) {
                    if (task.intent.getCategories().contains(Intent.CATEGORY_LAUNCHER)) {
                        mService.startActivityInPackage(task.mCallingUid, task.mCallingPackage, task.intent, null, null, null, 0, 0, ActivityOptions.makeBasic().toBundle(), task.userId, null, null);
                    }
                }
            }
        }
        if (res == AppErrorDialog.FORCE_QUIT) {
            long orig = Binder.clearCallingIdentity();
            try {
                mService.mStackSupervisor.handleAppCrashLocked(r);
                if (!r.persistent) {
                    mService.removeProcessLocked(r, false, false, "String_Node_Str");
                    mService.mStackSupervisor.resumeFocusedStackTopActivityLocked();
                }
            } finally {
                Binder.restoreCallingIdentity(orig);
            }
        }
        if (res == AppErrorDialog.FORCE_QUIT_AND_REPORT) {
            appErrorIntent = createAppErrorIntentLocked(r, timeMillis, crashInfo);
        }
        if (r != null && !r.isolated && res != AppErrorDialog.RESTART) {
            mProcessCrashTimes.put(r.info.processName, r.uid, SystemClock.uptimeMillis());
        }
    }
    if (appErrorIntent != null) {
        try {
            mContext.startActivityAsUser(appErrorIntent, new UserHandle(r.userId));
        } catch (ActivityNotFoundException e) {
            Slog.w(TAG, "String_Node_Str", e);
        }
    }
}

Output:
                 } catch (IllegalArgumentException e) {
-                    if (task.intent.getCategories().contains(Intent.CATEGORY_LAUNCHER)) {
+                    final Set<String> cats = task.intent.getCategories();
+                    if (cats != null && cats.contains(Intent.CATEGORY_LAUNCHER)) {
                         mService.startActivityInPackage(task.mCallingUid, task.mCallingPackage, task.intent, null, null, null, 0, 0, ActivityOptions.makeBasic().toBundle(), task.userId, null, null);


Input:
public Object call(Object[] args) throws Exception {
    try {
        return World.getInstance().getModelProp(args[0].toString());
    } catch (Exception e) {
        EngineLogger.error("String_Node_Str" + e.getMessage());
    }
    return null;
}

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


Input:
private void buildDisplayList(final GL gl, int iGLDisplayListIndex) {
    gl.glNewList(iGLDisplayListIndex, GL.GL_COMPILE);
    gl.glPushMatrix();
    if (isMirrored) {
        gl.glTranslatef(viewFrustum.getWidth(), 0, 0);
        gl.glScalef(-1.0f, 1.0f, 1.0f);
    }
    if (tree == null) {
        iAlClusterNodes.clear();
        if (bRenderContentTree == true) {
            if (set.getContentTree() != null) {
                tree = set.getContentTree();
                groupList = (GroupType) new ContentGroupList();
                rootNode = tree.getRoot();
            } else
                renderSymbol(gl);
        } else {
            if (set.getStorageTree() != null) {
                tree = set.getStorageTree();
                groupList = (GroupType) new StorageGroupList();
                rootNode = set.getStorageTreeRoot();
            } else
                renderSymbol(gl);
        }
    }
    if (tree != null) {
        if (bHasFrustumChanged || bRedrawDendrogram) {
            if (bRenderContentTree) {
                xGlobalMax = viewFrustum.getWidth();
                fSampleHeight = viewFrustum.getHeight() / rootNode.getNrLeaves();
                fLevelWidth = (viewFrustum.getWidth() - 0.1f) / rootNode.getDepth();
                yPosInit = viewFrustum.getHeight();
            } else {
                yGlobalMin = 0.0f;
                fSampleWidth = viewFrustum.getWidth() / rootNode.getNrLeaves();
                fLevelHeight = (viewFrustum.getHeight() - 0.1f) / rootNode.getDepth();
                xPosInit = 0.0f;
            }
            determinePositions();
            bRedrawDendrogram = false;
            bHasFrustumChanged = false;
        }
        gl.glLineWidth(renderStyle.getDendrogramLineWidth());
        if (bRenderContentTree) {
            gl.glTranslatef(0, -fSampleHeight / 2, 0);
            renderDendrogramGenes(gl, rootNode, 1);
        } else {
            gl.glTranslatef(fSampleWidth / 2, 0, 0);
            renderDendrogramExperiments(gl, rootNode, 1);
        }
        if (bRenderUntilCut == false)
            renderSelections(gl, rootNode);
        if (bRenderContentTree)
            gl.glTranslatef(0, +fSampleHeight / 2, 0);
        else
            gl.glTranslatef(-fSampleWidth / 2, 0, 0);
    }
    gl.glEndList();
    gl.glNewList(iGLDisplayListCutOffValue, GL.GL_COMPILE);
    if (tree != null && bRenderUntilCut == false)
        renderCut(gl);
    gl.glPopMatrix();
    gl.glEndList();
}

Output:
         } else {
-            if (set.getStorageTree() != null) {
+            if (!set.getStorageData(StorageVAType.STORAGE).isDefaultTree() && set.getStorageData(StorageVAType.STORAGE).getStorageTree() != null) {
                 tree = set.getStorageTree();


Input:
private void checkOtherTowersInArea(PartitionOccupyingTower tower) {
    IPredicate<ShortPoint2D> predicate = new IPredicate<ShortPoint2D>() {
        public boolean evaluate(ShortPoint2D pos) {
            final int idx = pos.x + pos.y * width;
            return towers[idx] <= 0;
        }
    };
    ArrayList<ShortPoint2D> freedPositions = new IteratorFilter<ShortPoint2D>(tower.area, predicate).toList();
    if (!freedPositions.isEmpty()) {
        List<Tuple<Integer, PartitionOccupyingTower>> towersInRange = occupyingTowers.getTowersInRange(tower.position, tower.radius);
        Collections.sort(towersInRange, Tuple.<Integer, PartitionOccupyingTower>getE1Comparator());
        for (Tuple<Integer, PartitionOccupyingTower> curr : towersInRange) {
            if (curr.e2.playerId == tower.playerId) {
                continue;
            }
            PartitionOccupyingTower currTower = curr.e2;
            final IMapArea currArea = currTower.area;
            IteratorFilter<ShortPoint2D> area = new IteratorFilter<ShortPoint2D>(freedPositions, new IPredicate<ShortPoint2D>() {
                public boolean evaluate(ShortPoint2D object) {
                    return currArea.contains(object);
                }
            });
            occupyAreaByTower(currTower.playerId, area, currTower.areaBorders);
        }
    }
}

Output:
             }
-            PartitionOccupyingTower currTower = curr.e2;
+            final PartitionOccupyingTower currTower = curr.e2;
             final IMapArea currArea = currTower.area;


Input:
public static void main(String[] args) {
    generateAuthorizationData();
    if (true)
        return;
    LSMOAuthHttpManager oM = new LSMOAuthHttpManager(OAuthGraphURL);
    LSMTicketGrantingTicketImpl realTicket = oM.getTicketGranting("String_Node_Str");
    if (realTicket != null) {
        System.out.println("String_Node_Str" + realTicket.getCreationTime() + "String_Node_Str" + new Date(realTicket.getCreationTime()));
        System.out.println("String_Node_Str" + realTicket.isExpired());
        System.out.println("String_Node_Str" + realTicket.isExpiredInternal());
        System.out.println("String_Node_Str" + realTicket.getExpirationPolicy().getClass());
        System.out.println("String_Node_Str" + realTicket.getAuthentication().getPrincipal().getId());
    }
    LSMRegisteredServiceImpl service = oM.getRegisteredService((long) 1);
    System.out.println(service.getUsernameAttribute() == null);
    System.out.println("String_Node_Str" + service.isAnonymousAccess());
    if (true)
        return;
    final LSMTicketGrantingTicketImpl tgt = createTicketGrantingTicket();
    final LSMTicketGrantingTicketImpl ticketGranting = oM.getTicketGranting(tgt.getId());
    System.out.println(ticketGranting);
    final LSMTicketGrantingTicketImpl tgt2 = createTicketGrantingTicket(tgt);
    final LSMTicketGrantingTicketImpl ticketGranting2 = oM.getTicketGranting(tgt2.getId());
    System.out.println(ticketGranting2);
    if (ticketGranting2 != null)
        System.out.println(ticketGranting2.getGrantingTicket());
    final LSMServiceTicketImpl serviceTicket = createServiceTicket(tgt);
    LSMServiceTicketImpl serviceTicket2 = oM.getServiceTicketImpl(serviceTicket.getId());
    System.out.println(serviceTicket2);
    final List<LSMTicketGrantingTicketImpl> allTkts = oM.getAllTicketGrantingTickets();
    System.out.println(allTkts.size());
    if (!allTkts.isEmpty())
        System.out.println(allTkts.get(0));
    final List<LSMServiceTicketImpl> allTktsOf = oM.getAllServiceTicketsOfTicketGrantingTicket(tgt.getId());
    System.out.println("String_Node_Str" + allTktsOf.size());
    if (!allTktsOf.isEmpty())
        System.out.println(allTktsOf.get(0));
    final List<LSMTicketGrantingTicketImpl> allGrantingTktsOf = oM.getAllTicketsOfTicketGrantingTicket(tgt.getId());
    System.out.println("String_Node_Str" + allGrantingTktsOf.size());
    if (!allGrantingTktsOf.isEmpty())
        System.out.println(allGrantingTktsOf.get(0));
    final List<LSMServiceTicketImpl> allServiceTkts = oM.getAllServiceTickets();
    System.out.println("String_Node_Str" + allServiceTkts.size());
    if (!allServiceTkts.isEmpty())
        System.out.println(allServiceTkts.get(0));
    final User user = oM.getUserByUsername("String_Node_Str");
    if (user != null) {
        System.out.println(user.getUsername());
        System.out.println(user.getRoles().size());
    } else
        System.out.println("String_Node_Str");
    final List<RegisteredService> allRegisteredServices = oM.getAllRegisteredServices();
    System.out.println("String_Node_Str" + allRegisteredServices.size());
    if (!allRegisteredServices.isEmpty())
        System.out.println(allRegisteredServices.get(0));
    final int ticketGrantingTicketsCount = oM.getTicketGrantingTicketsCount();
    System.out.println("String_Node_Str" + ticketGrantingTicketsCount);
    final int serviceTicketsCount = oM.getServiceTicketsCount();
    System.out.println("String_Node_Str" + serviceTicketsCount);
}

Output:
 public static void main(String[] args) {
-    generateAuthorizationData();
+    LSMOAuthHttpManager oM = new LSMOAuthHttpManager(OAuthGraphURL);
     if (true)