Input:
public static void loadBlocks() {
    FluidRegistry.registerFluid(BlockEnderGoo.fluid);
    register("String_Node_Str", obsidian_falling = new BlockObsidianEnd().setHardness(50F).setResistance(2000F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", obsidian_stairs = new BlockBasicStairs(Blocks.obsidian.getDefaultState()).setHardness(25F).setResistance(1000F).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", obsidian_special = (BlockAbstractState) new BlockObsidianSpecial(false).setHardness(28F).setResistance(2000F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", obsidian_special_glow = (BlockAbstractState) new BlockObsidianSpecial(true).setHardness(28F).setResistance(2000F).setLightLevel(1F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", end_terrain = (BlockAbstractState) new BlockEndstoneTerrain().setHardness(2.5F).setResistance(15F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ravaged_brick = (BlockAbstractState) new BlockRavagedBrick().setHardness(3.5F).setResistance(28F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ravaged_brick_smooth = new BlockBasic(Material.rock).setHardness(1F).setResistance(6F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ravaged_brick_glow = new BlockBasic(Material.rock).setHardness(1F).setResistance(6F).setLightLevel(1F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ravaged_brick_slab = new BlockBasicSlab(ravaged_brick).setHardness(1.75F).setResistance(14F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ravaged_brick_stairs = new BlockBasicStairs(ravaged_brick.getDefaultState()).setHardness(2.25F).setResistance(22F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ravaged_brick_fence = new BlockFence(Material.rock).setHardness(1.5F).setResistance(6F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", dungeon_puzzle = (BlockAbstractState) new BlockDungeonPuzzle().setBlockUnbreakable().setResistance(6000000F).setStepSound(Block.soundTypeMetal).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", cinder = new BlockBasic(Material.rock).setHardness(1F).setResistance(10F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", persegrit = (BlockAbstractState) new BlockPersegrit().setHardness(4F).setResistance(0.2F).setStepSound(Block.soundTypeGravel).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", laboratory_obsidian = new BlockBasic(Material.rock).setHardness(40F).setResistance(500F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", laboratory_floor = new BlockBasic(Material.rock).setHardness(30F).setResistance(100F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", laboratory_stairs = new BlockBasicStairs(laboratory_floor.getDefaultState()).setHardness(20F).setResistance(80F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", end_powder_ore = new BlockEndPowderOre().setHardness(3F).setResistance(12F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", endium_ore = new BlockEndiumOre().setHardness(18F).setResistance(100F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", stardust_ore = (BlockAbstractState) new BlockStardustOre().setHardness(7F).setResistance(4F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", igneous_rock_ore = new BlockIgneousRockOre().setHardness(2F).setResistance(5F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", instability_orb_ore = new BlockInstabilityOrbOre().setHardness(5.5F).setResistance(3F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", sphalerite = (BlockAbstractState) new BlockSphalerite().setHardness(1.8F).setResistance(40F).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", essence_altar = (BlockAbstractState) new BlockEssenceAltar().setHardness(8F).setResistance(20F).setLightOpacity(0).setLightLevel(0.4F).setStepSound(Block.soundTypeMetal).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", enhanced_brewing_stand = new BlockEnhancedBrewingStand().setHardness(0.65F).setLightLevel(0.125F).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", enhanced_tnt = new BlockEnhancedTNT().setHardness(0F).setStepSound(Block.soundTypeGrass).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", void_chest = new BlockVoidChest().setHardness(5F).setResistance(140F).setStepSound(Block.soundTypePiston).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", decomposition_table = new BlockDecompositionTable().setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", experience_table = new BlockExperienceTable().setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", accumulation_table = new BlockAccumulationTable().setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", extraction_table = new BlockExtractionTable().setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", transport_beacon = new BlockTransportBeacon().setBlockUnbreakable().setResistance(6000000F).setLightLevel(1F).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", endium_block = new BlockCompressed(MapColor.pinkColor).setHardness(14F).setResistance(800F).setStepSound(Block.soundTypeMetal).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", spooky_log = (BlockAbstractState) new BlockSpookyLog().setHardness(0.7F).setStepSound(Block.soundTypeWood).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", spooky_leaves = new BlockSpookyLeaves().setHardness(0.1F).setStepSound(Block.soundTypeGrass).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", ender_goo = new BlockEnderGoo().setHardness(150F).setLightOpacity(2).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", crossed_decoration = new BlockCrossedDecoration().setHardness(0F).setStepSound(Block.soundTypeGrass).setCreativeTab(null).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", enderman_head = new BlockEndermanHead().setHardness(1F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", death_flower = new BlockDeathFlower().setHardness(0F).setResistance(4F).setStepSound(Block.soundTypeGrass).setCreativeTab(null).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", energy_cluster = new BlockEnergyCluster().setHardness(0.7F).setResistance(0.2F).setStepSound(BlockEnergyCluster.soundTypeEnergyCluster).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", corrupted_energy_high = (BlockAbstractState) new BlockCorruptedEnergy(true).setBlockUnbreakable().setResistance(6000000F));
    register("String_Node_Str", corrupted_energy_low = (BlockAbstractState) new BlockCorruptedEnergy(false).setBlockUnbreakable().setResistance(6000000F));
    register("String_Node_Str", laboratory_glass = new BlockLaboratoryGlass().setHardness(5F).setResistance(50F).setLightOpacity(5).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", death_flower_pot = new BlockDeathFlowerPot().setHardness(0F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", laser_beam = new BlockLaserBeam().setBlockUnbreakable().setLightLevel(1F).setResistance(6000000F).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", custom_spawner = new BlockCustomSpawner().setHardness(5F).setStepSound(Block.soundTypeMetal).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", temple_end_portal = new BlockTempleEndPortal().setHardness(-1F).setResistance(6000000F).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", biome_core = (BlockAbstractState) new BlockBiomeIslandCore().setBlockUnbreakable().setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
    register("String_Node_Str", special_effects = new BlockSpecialEffects());
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockEssenceAltar.class);
    setItemClass("String_Node_Str", ItemBlockEnhancedTNT.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockEndFlower.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockSlab.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
    setItemClass("String_Node_Str", ItemBlockWithSubtypes.class);
}

Output:
     register("String_Node_Str", endium_ore = new BlockEndiumOre().setHardness(18F).setResistance(100F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
-    register("String_Node_Str", stardust_ore = (BlockAbstractState) new BlockStardustOre().setHardness(7F).setResistance(4F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
+    register("String_Node_Str", stardust_ore = new BlockStardustOre().setHardness(7F).setResistance(4F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));
     register("String_Node_Str", igneous_rock_ore = new BlockIgneousRockOre().setHardness(2F).setResistance(5F).setStepSound(Block.soundTypeStone).setUnlocalizedName("String_Node_Str"));


Input:
public void testCompileKMeansIteration1() {
    IterativeKMeans kmi = new IterativeKMeans();
    Plan plan = kmi.getPlan(String.valueOf(defaultParallelism), IN_FILE_1, IN_FILE_1, OUT_FILE_1, String.valueOf(20));
    setParameterToCross(plan, "String_Node_Str", "String_Node_Str");
    OptimizedPlan op = compile(plan);
    NepheleJobGraphGenerator jgg = new NepheleJobGraphGenerator();
    jgg.compileJobGraph(op);
}

Output:
     IterativeKMeans kmi = new IterativeKMeans();
-    Plan plan = kmi.getPlan(String.valueOf(defaultParallelism), IN_FILE_1, IN_FILE_1, OUT_FILE_1, String.valueOf(20));
+    Plan plan = kmi.getPlan(String.valueOf(DEFAULT_PARALLELISM), IN_FILE_1, IN_FILE_1, OUT_FILE_1, String.valueOf(20));
     setParameterToCross(plan, "String_Node_Str", "String_Node_Str");


Input:
public static Iterable<ServletContainerInitializer> getServletContainerInitializers(Map<String, String> webFragmentMap, List<Object> absoluteOrderingList, boolean hasOthers, ClassLoader cl) {
    if ((absoluteOrderingList != null) && !hasOthers) {
        if (!(cl instanceof URLClassLoader)) {
            log.log(Level.WARNING, "String_Node_Str", cl.getClass().getCanonicalName());
            return null;
        }
        URLClassLoader webAppCl = (URLClassLoader) cl;
        List<URL> newClassLoaderUrlList = new ArrayList<URL>();
        for (URL classLoaderUrl : webAppCl.getURLs()) {
            if (!"String_Node_Str".equals(classLoaderUrl.getProtocol())) {
                continue;
            }
            File file = new File(classLoaderUrl.getFile());
            try {
                file = file.getCanonicalFile();
            } catch (IOException e) {
            }
            if (!file.exists()) {
                continue;
            }
            String path = file.getAbsolutePath();
            if (!path.endsWith("String_Node_Str")) {
                continue;
            }
            if (!isFragmentMissingFromAbsoluteOrdering(file.getName(), webFragmentMap, absoluteOrderingList)) {
                newClassLoaderUrlList.add(classLoaderUrl);
            }
        }
        URL[] urlsForNewClassLoader = new URL[newClassLoaderUrlList.size()];
        cl = new URLClassLoader(newClassLoaderUrlList.toArray(urlsForNewClassLoader), webAppCl.getParent());
    }
    return ServiceLoader.load(ServletContainerInitializer.class, cl);
}

Output:
         }
-        URLClassLoader webAppCl = (URLClassLoader) cl;
+        final URLClassLoader webAppCl = (URLClassLoader) cl;
         List<URL> newClassLoaderUrlList = new ArrayList<URL>();


Input:
public Object[] getFieldValues() {
    Integer[] memberSize = new Integer[1];
    memberSize[0] = Integer.valueOf(getLevelMembers().length);
    Object[][] objectArrays = new Object[getLevelMembers().length + 1 + 3 + measureList.size()][];
    objectArrays[0] = memberSize;
    for (int i = 0; i < getLevelMembers().length; i++) {
        objectArrays[i + 1] = getLevelMembers()[i].getFieldValues();
    }
    objectArrays[getLevelMembers().length + 1] = measures;
    for (int i = 0; i < measureList.size(); i++) {
        objectArrays[getLevelMembers().length + i + 2] = measureList.get(i);
    }
    objectArrays[objectArrays.length - 2] = parameterValues;
    Integer[] dimPosObj = null;
    if (dimPos == null) {
        dimPosObj = new Integer[1];
        dimPosObj[0] = Integer.valueOf(0);
    } else {
        dimPosObj = new Integer[dimPos.length + 1];
        dimPosObj[0] = Integer.valueOf(1);
        for (int i = 0; i < dimPos.length; i++) {
            dimPosObj[i + 1] = Integer.valueOf(dimPos[i]);
        }
    }
    objectArrays[objectArrays.length - 1] = dimPosObj;
    return ObjectArrayUtil.convert(objectArrays);
}

Output:
     }
-    objectArrays[getLevelMembers().length + 1] = measures;
-    for (int i = 0; i < measureList.size(); i++) {
-        objectArrays[getLevelMembers().length + i + 2] = measureList.get(i);
-    }
-    objectArrays[objectArrays.length - 2] = parameterValues;
+    objectArrays[getLevelMembers().length + 1] = parameterValues;
     Integer[] dimPosObj = null;


Input:
public void seek(long pos) throws IOException {
    file.seek(pos);
    this.pos = pos;
}

Output:
 public void seek(long pos) throws IOException {
-    file.seek(pos);
-    this.pos = pos;
+    timeStart();
+    try {
+        file.seek(pos);
+        this.pos = pos;
+        posDirty = false;
+    } finally {
+        timeEnd();
+    }
 }


Input:
private void loadColumnBinningInfo() throws FileNotFoundException, IOException {
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new InputStreamReader(new FileInputStream(Constants.BINNING_INFO_FILE_NAME), Charset.forName("String_Node_Str")));
        String line = reader.readLine();
        while (line != null && line.length() != 0) {
            LOG.debug("String_Node_Str", line);
            String[] cols = CommonUtils.split(line.trim(), Constants.DEFAULT_DELIMITER);
            if (cols != null && cols.length >= 2) {
                Integer columnNum = Integer.parseInt(cols[0]);
                BinningInfoWritable binningInfo = new BinningInfoWritable();
                binningInfo.setColumnNum(columnNum);
                ColumnConfig columnConfig = this.columnConfigList.get(columnNum);
                int binSize = 0;
                if (columnConfig.isNumerical()) {
                    binningInfo.setNumeric(true);
                    List<Double> list = new ArrayList<Double>();
                    for (String startElement : BIN_BOUNDARY_SPLITTER.split(cols[1])) {
                        list.add(Double.valueOf(startElement));
                    }
                    binningInfo.setBinBoundaries(list);
                    binSize = list.size();
                } else {
                    binningInfo.setNumeric(false);
                    List<String> list = new ArrayList<String>();
                    Map<String, Integer> map = this.categoricalBinMap.get(columnNum);
                    if (map == null) {
                        map = new HashMap<String, Integer>();
                        this.categoricalBinMap.put(columnNum, map);
                    }
                    int index = 0;
                    if (!StringUtils.isBlank(cols[1])) {
                        for (String startElement : BIN_BOUNDARY_SPLITTER.split(cols[1])) {
                            list.add(startElement);
                            map.put(startElement, index++);
                        }
                    }
                    binningInfo.setBinCategories(list);
                    binSize = list.size();
                }
                long[] binCountPos = new long[binSize + 1];
                binningInfo.setBinCountPos(binCountPos);
                long[] binCountNeg = new long[binSize + 1];
                binningInfo.setBinCountNeg(binCountNeg);
                double[] binWeightPos = new double[binSize + 1];
                binningInfo.setBinWeightPos(binWeightPos);
                double[] binWeightNeg = new double[binSize + 1];
                binningInfo.setBinWeightNeg(binWeightNeg);
                LOG.info("String_Node_Str", columnNum, binningInfo);
                this.columnBinningInfo.put(columnNum, binningInfo);
            }
            line = reader.readLine();
        }
    } finally {
        if (reader != null) {
            reader.close();
        }
    }
}

Output:
                 binningInfo.setBinWeightNeg(binWeightNeg);
-                LOG.info("String_Node_Str", columnNum, binningInfo);
+                LOG.debug("String_Node_Str", columnNum, binningInfo);
                 this.columnBinningInfo.put(columnNum, binningInfo);


Input:
private void dumpStatus() {
    try {
        log.finest("String_Node_Str" + storeName + "String_Node_Str" + brickCount + "String_Node_Str" + brickSize + "String_Node_Str" + mappedMem + "String_Node_Str" + fileChannel.size() + "String_Node_Str");
    } catch (IOException e) {
        throw new StoreFailureException("String_Node_Str" + storeName, e);
    }
}

Output:
     try {
-        log.finest("String_Node_Str" + storeName + "String_Node_Str" + brickCount + "String_Node_Str" + brickSize + "String_Node_Str" + mappedMem + "String_Node_Str" + fileChannel.size() + "String_Node_Str");
+        log.fine("String_Node_Str" + storeName + "String_Node_Str" + brickCount + "String_Node_Str" + brickSize + "String_Node_Str" + mappedMem + "String_Node_Str" + fileChannel.size() + "String_Node_Str");
     } catch (IOException e) {


Input:
public boolean onTouchEvent(MotionEvent event) {
    final int viewFlags = mViewFlags;
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        return (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
    }
    if (mTouchDelegate != null) {
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }
    if (((viewFlags & CLICKABLE) == CLICKABLE || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
        switch(event.getAction()) {
            case MotionEvent.ACTION_UP:
                if ((mPrivateFlags & PRESSED) != 0) {
                    boolean focusTaken = false;
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                        focusTaken = requestFocus();
                    }
                    if (!mHasPerformedLongPress) {
                        cancelLongPress();
                        if (!focusTaken) {
                            performClick();
                        }
                    }
                    if (mUnsetPressedState == null) {
                        mUnsetPressedState = new UnsetPressedState();
                    }
                    if (!post(mUnsetPressedState)) {
                        mUnsetPressedState.run();
                    }
                }
                break;
            case MotionEvent.ACTION_DOWN:
                mPrivateFlags |= PRESSED;
                refreshDrawableState();
                if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {
                    postCheckForLongClick();
                }
                break;
            case MotionEvent.ACTION_CANCEL:
                mPrivateFlags &= ~PRESSED;
                refreshDrawableState();
                break;
            case MotionEvent.ACTION_MOVE:
                final int x = (int) event.getX();
                final int y = (int) event.getY();
                int slop = ViewConfiguration.get(mContext).getScaledTouchSlop();
                if ((x < 0 - slop) || (x >= getWidth() + slop) || (y < 0 - slop) || (y >= getHeight() + slop)) {
                    if ((mPrivateFlags & PRESSED) != 0) {
                        cancelLongPress();
                        mPrivateFlags &= ~PRESSED;
                        refreshDrawableState();
                    }
                } else {
                    if ((mPrivateFlags & PRESSED) == 0) {
                        mPrivateFlags |= PRESSED;
                        refreshDrawableState();
                    }
                }
                break;
        }
        return true;
    }
    return false;
}

Output:
                     if (!mHasPerformedLongPress) {
-                        cancelLongPress();
+                        removeLongPressCallback();
                         if (!focusTaken) {


Input:
private HttpRequestLine parseHttpRequest(Socket socket) throws IOException {
    socket.setSoTimeout(Constants.TIMEOUT);
    ByteReader br = new ByteReader(socket.getInputStream());
    String str = br.readLine();
    if (str == null) {
        throw new IOException();
    }
    str.trim();
    if (this.isURNGet(str)) {
        return this.parseURNGet(str);
    } else if (this.isMalformedURNGet(str)) {
        return this.parseMalformedURNGet(str);
    }
    return this.parseTraditionalGet(str);
}

Output:
     String str = br.readLine();
-    if (str == null) {
-        throw new IOException();
+    try {
+        if (str == null) {
+            throw new IOException();
+        }
+        str.trim();
+        if (this.isURNGet(str)) {
+            return this.parseURNGet(str);
+        } else if (this.isMalformedURNGet(str)) {
+            return this.parseMalformedURNGet(str);
+        }
+        return this.parseTraditionalGet(str);
+    } catch (IOException ioe) {
+        if (str == null)
+            return new HttpRequestLine(MALFORMED_REQUEST_INDEX, "String_Node_Str", false);
+        else
+            return new HttpRequestLine(MALFORMED_REQUEST_INDEX, "String_Node_Str", isHTTP11Request(str));
     }


Input:
void onListItemClick(SimpleListFragment fragment, int position) {
    if (fragment == middleFragment) {
        ((Button) root.getRightView()).setText(middleContents.get(position));
        root.hideLeft();
        isLeftShowing = false;
    } else {
        middleContents = new ArrayList<String>();
        for (int i = 0; i < 20; i++) {
            middleContents.add(items[position] + "String_Node_Str" + i);
        }
        if (getSupportFragmentManager().findFragmentById(R.id.middle) == null) {
            middleFragment = SimpleListFragment.newInstance(middleContents);
            getSupportFragmentManager().beginTransaction().add(R.id.middle, middleFragment).commit();
        } else {
            middleFragment.setContents(middleContents);
        }
    }
}

Output:
         ((Button) root.getRightView()).setText(middleContents.get(position));
-        root.hideLeft();
-        isLeftShowing = false;
+        if (isLeftShowing) {
+            root.hideLeft();
+            isLeftShowing = false;
+        }
     } else {


Input:
private void populateMirror() throws IOException {
    MemberTreeNode parent;
    MemberTreeNode child;
    Object[] preValue = new Object[mirrorLevel];
    Object[] currValue = new Object[mirrorLevel];
    for (int i = 0; i < rs.length(); i++) {
        rs.seek(i);
        parent = this.rootNode;
        for (int j = 0; j < mirrorLevel; j++) {
            currValue[j] = rs.getLevelKeyValue(j)[0];
        }
        for (int j = 0; j < mirrorLevel; j++) {
            if (!isEqualObject(preValue[j], currValue[j])) {
                child = new MemberTreeNode(currValue[j]);
                parent.insertNode(child);
                child.parentNode = parent;
                parent = child;
            } else {
                if (parent.childNodesList.size() > 0)
                    parent = (MemberTreeNode) parent.childNodesList.get(parent.childNodesList.size() - 1);
                else {
                    child = new MemberTreeNode(currValue[j]);
                    parent.insertNode(child);
                    child.parentNode = parent;
                    parent = child;
                }
            }
        }
        for (int j = 0; j < breakHierarchyList.length; j++) {
            if (!breakHierarchyList[j].contains(rs.getLevelKeyValue(j + mirrorLevel)[0]))
                breakHierarchyList[j].add(rs.getLevelKeyValue(j + mirrorLevel)[0]);
        }
        for (int k = 0; k < mirrorLevel; k++) {
            preValue[k] = currValue[k];
        }
    }
    this.length = getLength(this.rootNode);
    for (int k = 0; k < breakHierarchyList.length; k++) {
        final int sortType = getSortTypeOnMirroredLevel(k + mirrorLevel);
        if (sortType != IDimensionSortDefn.SORT_UNDEFINED) {
            Collections.sort(breakHierarchyList[k], new Comparator() {
                public int compare(final Object arg0, final Object arg1) {
                    if (sortType == IDimensionSortDefn.SORT_ASC)
                        return ((Comparable) arg0).compareTo(arg1);
                    else
                        return ((Comparable) arg0).compareTo(arg1) * -1;
                }
            });
        }
        this.length *= breakHierarchyList[k].size();
    }
}

Output:
             if (!isEqualObject(preValue[j], currValue[j])) {
-                child = new MemberTreeNode(currValue[j]);
+                Member member = new Member();
+                member.setKeyValues(new Object[] { currValue[j] });
+                member.setAttributes(rs.getLevelAttributesValue(j));
+                child = new MemberTreeNode(member);
                 parent.insertNode(child);


Input:
public IStatus doAction() {
    try {
        XSDElementDeclaration decl = xsdElem;
        if (decl == null) {
            ISelection selection = page.getTreeViewer().getSelection();
            decl = (XSDElementDeclaration) ((IStructuredSelection) selection).getFirstElement();
        }
        Set<String> list = Util.getForeignKeys();
        if (list == null) {
            XtentisPort port = null;
            try {
                port = Util.getPort(page.getXObject());
            } catch (XtentisException e) {
                e.printStackTrace();
            }
            list = new HashSet<String>();
            Util.getForeingKeyInDataModel(list, page.getXObject().getParent(), port);
            Util.setForeignKeys(list);
        }
        if (list.contains(decl.getName())) {
            boolean confirmed = MessageDialog.openConfirm(page.getSite().getShell(), "String_Node_Str", "String_Node_Str" + decl.getName() + "String_Node_Str" + "String_Node_Str");
            if (!confirmed) {
                return Status.CANCEL_STATUS;
            }
        }
        ArrayList<Object> objList = new ArrayList<Object>();
        IStructuredContentProvider provider = (IStructuredContentProvider) page.getTreeViewer().getContentProvider();
        Object[] objs = Util.getAllObject(page.getSite(), objList, provider);
        Util.deleteReference(decl, objs);
        if (schema == null)
            schema = ((ISchemaContentProvider) page.getTreeViewer().getContentProvider()).getXsdSchema();
        schema.getContents().remove(decl);
        schema.update();
        xsdElem = null;
        page.refresh();
        page.markDirtyWithoutCommit();
    } catch (Exception e) {
        log.error(e.getMessage(), e);
        MessageDialog.openError(page.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());
        return Status.CANCEL_STATUS;
    }
    return Status.OK_STATUS;
}

Output:
             } catch (XtentisException e) {
-                e.printStackTrace();
+                log.error(e.getMessage(), e);
+                ;
             }


Input:
public void execute() {
    ListResponse<HostResponse> response = null;
    if (getVirtualMachineId() == null) {
        response = _queryService.searchForServers(this);
    } else {
        List<? extends Host> result = new ArrayList<Host>();
        List<? extends Host> hostsWithCapacity = new ArrayList<Host>();
        Pair<List<? extends Host>, List<? extends Host>> hostsForMigration = _mgr.listHostsForMigrationOfVM(getVirtualMachineId(), this.getStartIndex(), this.getPageSizeVal());
        result = hostsForMigration.first();
        hostsWithCapacity = hostsForMigration.second();
        response = new ListResponse<HostResponse>();
        List<HostResponse> hostResponses = new ArrayList<HostResponse>();
        for (Host host : result) {
            HostResponse hostResponse = _responseGenerator.createHostResponse(host, getDetails());
            Boolean suitableForMigration = false;
            if (hostsWithCapacity.contains(host)) {
                suitableForMigration = true;
            }
            hostResponse.setSuitableForMigration(suitableForMigration);
            hostResponse.setObjectName("String_Node_Str");
            hostResponses.add(hostResponse);
        }
        response.setResponses(hostResponses);
    }
    response.setResponseName(getCommandName());
    this.setResponseObject(response);
}

Output:
     } else {
-        List<? extends Host> result = new ArrayList<Host>();
+        Pair<List<? extends Host>, Integer> result;
         List<? extends Host> hostsWithCapacity = new ArrayList<Host>();


Input:
public void open(Properties connProperties) throws OdaException {
    if (connProperties == null) {
        IllegalArgumentException e = new IllegalArgumentException("String_Node_Str");
        logger.logp(java.util.logging.Level.FINE, Connection.class.getName(), "String_Node_Str", e.getMessage(), e);
        throw e;
    }
    if (logger.isLoggable(Level.INFO)) {
        String logMsg = "String_Node_Str";
        for (Enumeration enumeration = connProperties.propertyNames(); enumeration.hasMoreElements(); ) {
            String propName = (String) enumeration.nextElement();
            String lcPropName = propName.toLowerCase();
            String propVal;
            if (lcPropName.indexOf("String_Node_Str") >= 0 || lcPropName.indexOf("String_Node_Str") >= 0)
                propVal = "String_Node_Str";
            else
                propVal = connProperties.getProperty(propName);
            logMsg += propName + "String_Node_Str" + propVal + "String_Node_Str";
        }
        logger.logp(Level.FINE, Connection.class.getName(), "String_Node_Str", logMsg);
    }
    close();
    String dataSource = connProperties.getProperty(Constants.ODADataSource);
    if (dataSource != null) {
        UnsupportedOperationException e = new UnsupportedOperationException("String_Node_Str");
        logger.logp(java.util.logging.Level.FINE, Connection.class.getName(), "String_Node_Str", e.getMessage(), e);
        throw e;
    } else {
        String url = connProperties.getProperty(Constants.ODAURL);
        String jndiName = connProperties.getProperty(Constants.ODAJndiName);
        if ((url == null || url.length() == 0) && (jndiName == null || jndiName.length() == 0)) {
            throw new JDBCException(ResourceConstants.DRIVER_MISSING_PROPERTIES, ResourceConstants.ERROR_MISSING_PROPERTIES);
        }
        connectByUrl(url, connProperties);
    }
}

Output:
     }
-    if (logger.isLoggable(Level.INFO)) {
+    if (logger.isLoggable(Level.FINE)) {
         String logMsg = "String_Node_Str";


Input:
private int handleImg(final XMLEventReader rdr) throws XMLStreamException {
    return rdr.nextEvent().asEndElement().getLocation().getCharacterOffset();
}

Output:
 private int handleImg(final XMLEventReader rdr) throws XMLStreamException {
-    return rdr.nextEvent().asEndElement().getLocation().getCharacterOffset();
+    XMLEvent n = rdr.nextEvent();
+    return n.asEndElement().getLocation().getCharacterOffset();
 }


Input:
public void postProcess(String accountId) {
    if (null == mCrypto) {
        MXFileCryptoStore store = new MXFileCryptoStore();
        store.initWithCredentials(mAppContent, mCredentials);
        if (store.hasData() || mEnableCryptoWhenStartingMXSession) {
            Log.d(LOG_TAG, "String_Node_Str" + this);
            store.open();
            mCrypto = new MXCrypto(MXSession.this, store);
            mDataHandler.setCrypto(mCrypto);
            decryptRoomSummaries();
        } else {
            Log.e(LOG_TAG, "String_Node_Str");
        }
    } else {
        Log.e(LOG_TAG, "String_Node_Str");
    }
}

Output:
             Log.d(LOG_TAG, "String_Node_Str" + this);
-            store.open();
-            mCrypto = new MXCrypto(MXSession.this, store);
-            mDataHandler.setCrypto(mCrypto);
-            decryptRoomSummaries();
+            checkCrypto();
         } else {


Input:
public String info() {
    updateActiveFrequency();
    return "String_Node_Str" + isRadioOn + "String_Node_Str" + chipSelect + "String_Node_Str" + ((status & STATUS_XOSC16M_STABLE) > 0) + "String_Node_Str" + ((status & STATUS_RSSI_VALID) > 0) + "String_Node_Str" + cca + "String_Node_Str" + ((registers[REG_GPIOPOLARITY] & FIFOP_POLARITY) == FIFOP_POLARITY) + "String_Node_Str" + currentFIFOP + "String_Node_Str" + currentFIFO + "String_Node_Str" + currentSFD + "String_Node_Str" + rxFIFO.stateToString() + "String_Node_Str" + rxlen + "String_Node_Str" + stateMachine + "String_Node_Str" + command + "String_Node_Str" + autoAck + "String_Node_Str" + addressDecode + "String_Node_Str" + autoCRC + "String_Node_Str" + Utils.hex8(memory[RAM_PANID + 1]) + Utils.hex8(memory[RAM_PANID]) + "String_Node_Str" + Utils.hex8(memory[RAM_SHORTADDR + 1]) + Utils.hex8(memory[RAM_SHORTADDR]) + "String_Node_Str" + getLongAddress() + "String_Node_Str" + activeChannel + "String_Node_Str" + fifopThr + "String_Node_Str";
}

Output:
     updateActiveFrequency();
-    return "String_Node_Str" + isRadioOn + "String_Node_Str" + chipSelect + "String_Node_Str" + ((status & STATUS_XOSC16M_STABLE) > 0) + "String_Node_Str" + ((status & STATUS_RSSI_VALID) > 0) + "String_Node_Str" + cca + "String_Node_Str" + ((registers[REG_GPIOPOLARITY] & FIFOP_POLARITY) == FIFOP_POLARITY) + "String_Node_Str" + currentFIFOP + "String_Node_Str" + currentFIFO + "String_Node_Str" + currentSFD + "String_Node_Str" + rxFIFO.stateToString() + "String_Node_Str" + rxlen + "String_Node_Str" + stateMachine + "String_Node_Str" + command + "String_Node_Str" + autoAck + "String_Node_Str" + addressDecode + "String_Node_Str" + autoCRC + "String_Node_Str" + Utils.hex8(memory[RAM_PANID + 1]) + Utils.hex8(memory[RAM_PANID]) + "String_Node_Str" + Utils.hex8(memory[RAM_SHORTADDR + 1]) + Utils.hex8(memory[RAM_SHORTADDR]) + "String_Node_Str" + getLongAddress() + "String_Node_Str" + activeChannel + "String_Node_Str" + fifopThr + "String_Node_Str";
+    return "String_Node_Str" + isRadioOn + "String_Node_Str" + chipSelect + "String_Node_Str" + ((status & STATUS_XOSC16M_STABLE) > 0) + "String_Node_Str" + ((status & STATUS_RSSI_VALID) > 0) + "String_Node_Str" + cca + "String_Node_Str" + ((memory[REG_GPIOPOLARITY] & FIFOP_POLARITY) == FIFOP_POLARITY) + "String_Node_Str" + currentFIFOP + "String_Node_Str" + currentFIFO + "String_Node_Str" + currentSFD + "String_Node_Str" + rxFIFO.stateToString() + "String_Node_Str" + rxlen + "String_Node_Str" + stateMachine + "String_Node_Str" + command + "String_Node_Str" + autoAck + "String_Node_Str" + addressDecode + "String_Node_Str" + autoCRC + "String_Node_Str" + Utils.hex8(memory[RAM_PANID + 1]) + Utils.hex8(memory[RAM_PANID]) + "String_Node_Str" + Utils.hex8(memory[RAM_SHORTADDR + 1]) + Utils.hex8(memory[RAM_SHORTADDR]) + "String_Node_Str" + getLongAddress() + "String_Node_Str" + activeChannel + "String_Node_Str" + fifopThr + "String_Node_Str";
 }


Input:
private IBaseExpression[] getAggrExpr() {
    int num2 = 2;
    IBaseExpression[] totalBeArray = new IBaseExpression[num2];
    totalBeArray[0] = new ScriptExpression("String_Node_Str");
    totalBeArray[1] = new ScriptExpression("String_Node_Str");
    return totalBeArray;
}

Output:
     IBaseExpression[] totalBeArray = new IBaseExpression[num2];
-    totalBeArray[0] = new ScriptExpression("String_Node_Str");
+    totalBeArray[0] = new ScriptExpression(null);
     totalBeArray[1] = new ScriptExpression("String_Node_Str");


Input:
public void compute() throws VerdictException {
    if (vc.getDbms() instanceof DbmsJDBC) {
        rs = ((DbmsJDBC) vc.getDbms()).getDatabaseNamesInResultSet();
    } else if (vc.getDbms() instanceof DbmsSpark) {
        df = ((DbmsSpark) vc.getDbms()).getDatabaseNamesInDataFrame();
    } else if (vc.getDbms() instanceof DbmsSpark2) {
        ds = ((DbmsSpark2) vc.getDbms()).getDatabaseNamesInDataFrame();
    }
}

Output:
     } else if (vc.getDbms() instanceof DbmsSpark2) {
-        ds = ((DbmsSpark2) vc.getDbms()).getDatabaseNamesInDataFrame();
+        ds = ((DbmsSpark2) vc.getDbms()).getDatabaseNamesInDataset();
     }


Input:
public void testReturnColumns4DontCreateConnection2TableTypeSynonym() throws Exception {
    PTODO();
}

Output:
 public void testReturnColumns4DontCreateConnection2TableTypeSynonym() throws Exception {
-    PTODO();
+    Assert.assertNotNull(getExtractManger());
+    Connection conn = mockConnection4ReturnColumns();
+    ExtractMetaDataUtils.conn = conn;
+    DatabaseMetaData dbMetadata = mockDatabaseMetaData4ReturnColumns();
+    when(conn.getMetaData()).thenReturn(dbMetadata);
+    ResultSet getColumnsResultSet = mockGetColumnsResultSet4ReturnColumns();
+    doReturn(getColumnsResultSet).when(dbMetadata).getColumns(anyString(), anyString(), anyString(), anyString());
+    IMetadataConnection metadataConn = mockMetadataConnection4ReturnColumns();
+    TableNode tableNode = mockTableNode4ReturnColumns2TableTypeSynonym();
+    TdTable tdTable = mockTable4ReturnColumns();
+    when(tableNode.getTable()).thenReturn(tdTable);
+    List<TdColumn> columns = getExtractManger().returnColumns(metadataConn, tableNode, true);
+    Assert.assertNotNull(columns);
+    Assert.assertTrue(columns.isEmpty());
+    verifyTableNode4ReturnColumns2TableTypeSynonym(tableNode);
+    verifyMeatadataConnection4ReturnColumns4DontCreateConnection(metadataConn);
+    verifyConnection4ReturnColumns4DontCreateConnection(conn);
+    ExtractMetaDataUtils.conn = null;
 }


Input:
public String editOrderItemsOriginModal() {
    Map sessionAttributes = ActionContext.getContext().getSession();
    System.out.println("String_Node_Str" + (Integer) sessionAttributes.get("String_Node_Str"));
    System.out.println("String_Node_Str" + (Integer) sessionAttributes.get("String_Node_Str"));
    System.out.println("String_Node_Str" + vendorId);
    System.out.println("String_Node_Str" + driverCodeParam);
    System.out.println("String_Node_Str" + truckCodeParam);
    System.out.println("String_Node_Str" + finalPickupParam);
    System.out.println("String_Node_Str" + originConfirmFlag);
    Integer orderIdParam = (Integer) sessionAttributes.get("String_Node_Str");
    Integer orderItemId = (Integer) sessionAttributes.get("String_Node_Str");
    check = (String[]) sessionAttributes.get("String_Node_Str");
    if (originConfirmFlag.equals("String_Node_Str")) {
        for (int i = 0; i < check.length; i++) {
            System.out.println("String_Node_Str" + check[i]);
            Integer orderItemIdCheck = Integer.parseInt(check[i]);
            OrderItems entity = operationsService.findOrderItemById(orderItemIdCheck);
            OrderItems saveEntity = operationsService.findOrderItemById(orderItemIdCheck);
            entity.setVendorOrigin(vendorService.findVendorById(vendorId).getVendorCode());
            entity.setVendorDestination(saveEntity.getVendorDestination());
            entity.setFinalPickupDate(finalPickupParam);
            entity.setFinalDeliveryDate(saveEntity.getFinalDeliveryDate());
            entity.setOrderItemId(orderItemIdCheck);
            entity.setClientId(saveEntity.getClientId());
            entity.setNameSize(saveEntity.getNameSize());
            entity.setOrderId(saveEntity.getOrderId());
            entity.setQuantity(saveEntity.getQuantity());
            entity.setClassification(saveEntity.getClassification());
            entity.setCommodity(saveEntity.getCommodity());
            entity.setDeclaredValue(saveEntity.getDeclaredValue());
            entity.setComments(saveEntity.getComments());
            entity.setRate(saveEntity.getRate());
            entity.setCreatedBy(saveEntity.getCreatedBy());
            entity.setModifiedBy(saveEntity.getModifiedBy());
            entity.setCreatedTimestamp(saveEntity.getCreatedTimestamp());
            entity.setModifiedTimestamp(saveEntity.getModifiedTimestamp());
            entity.setWeight(saveEntity.getWeight());
            entity.setDriverOrigin(driverCodeParam);
            entity.setDriverDestination(saveEntity.getDriverDestination());
            entity.setTruckOrigin(truckCodeParam);
            entity.setTruckDestination(saveEntity.getTruckDestination());
            entity.setVendorSea(saveEntity.getVendorSea());
            entity.setVesselScheduleId(saveEntity.getVesselScheduleId());
            entity.setCommodity(saveEntity.getCommodity());
            entity.setComments(saveEntity.getComments());
            entity.setWeight(saveEntity.getWeight());
            entity.setVolume(saveEntity.getVolume());
            entity.setServiceRequirement(saveEntity.getServiceRequirement());
            Orders orderEntity = orderService.findOrdersById(saveEntity.getOrderId());
            if ("String_Node_Str".equals(orderEntity.getServiceType())) {
                if ("String_Node_Str".equals(orderEntity.getServiceMode())) {
                    entity.setStatus("String_Node_Str");
                } else {
                    entity.setStatus("String_Node_Str");
                }
            } else {
                entity.setStatus("String_Node_Str");
            }
            operationsService.updateOrderItem(entity);
        }
    } else {
        OrderItems entity = operationsService.findOrderItemById(orderItemId);
        OrderItems saveEntity = operationsService.findOrderItemById(orderItemId);
        entity.setVendorOrigin(vendorService.findVendorById(vendorId).getVendorCode());
        entity.setVendorDestination(saveEntity.getVendorDestination());
        entity.setFinalPickupDate(finalPickupParam);
        entity.setFinalDeliveryDate(saveEntity.getFinalDeliveryDate());
        entity.setOrderItemId(orderItemId);
        entity.setClientId(saveEntity.getClientId());
        entity.setNameSize(saveEntity.getNameSize());
        entity.setOrderId(saveEntity.getOrderId());
        entity.setQuantity(saveEntity.getQuantity());
        entity.setClassification(saveEntity.getClassification());
        entity.setCommodity(saveEntity.getCommodity());
        entity.setDeclaredValue(saveEntity.getDeclaredValue());
        entity.setComments(saveEntity.getComments());
        entity.setRate(saveEntity.getRate());
        entity.setCreatedBy(saveEntity.getCreatedBy());
        entity.setModifiedBy(saveEntity.getModifiedBy());
        entity.setCreatedTimestamp(saveEntity.getCreatedTimestamp());
        entity.setModifiedTimestamp(saveEntity.getModifiedTimestamp());
        entity.setWeight(saveEntity.getWeight());
        entity.setDriverOrigin(driverCodeParam);
        entity.setDriverDestination(saveEntity.getDriverDestination());
        entity.setTruckOrigin(truckCodeParam);
        entity.setTruckDestination(saveEntity.getTruckDestination());
        entity.setVendorSea(saveEntity.getVendorSea());
        entity.setVesselScheduleId(saveEntity.getVesselScheduleId());
        entity.setCommodity(saveEntity.getCommodity());
        entity.setComments(saveEntity.getComments());
        entity.setWeight(saveEntity.getWeight());
        entity.setVolume(saveEntity.getVolume());
        entity.setServiceRequirement(saveEntity.getServiceRequirement());
        Orders orderEntity = orderService.findOrdersById(saveEntity.getOrderId());
        if ("String_Node_Str".equals(orderEntity.getServiceType())) {
            if ("String_Node_Str".equals(orderEntity.getServiceMode())) {
                entity.setStatus("String_Node_Str");
            } else {
                entity.setStatus("String_Node_Str");
            }
        } else {
            entity.setStatus("String_Node_Str");
        }
        operationsService.updateOrderItem(entity);
    }
    sessionAttributes.put("String_Node_Str", orderIdParam);
    sessionAttributes.put("String_Node_Str", orderItemId);
    return SUCCESS;
}

Output:
     Map sessionAttributes = ActionContext.getContext().getSession();
-    System.out.println("String_Node_Str" + (Integer) sessionAttributes.get("String_Node_Str"));
-    System.out.println("String_Node_Str" + (Integer) sessionAttributes.get("String_Node_Str"));
+    System.out.println("String_Node_Str" + sessionAttributes.get("String_Node_Str"));
+    System.out.println("String_Node_Str" + sessionAttributes.get("String_Node_Str"));
     System.out.println("String_Node_Str" + vendorId);


Input:
public Byte getByteAttribute(String key) {
    final Object attribute = getAttribute(key);
    return attribute != null ? Byte.valueOf(attribute.toString()) : null;
}

Output:
 public Byte getByteAttribute(String key) {
-    final Object attribute = getAttribute(key);
+    Object attribute = getAttribute(key);
     return attribute != null ? Byte.valueOf(attribute.toString()) : null;


Input:
private JstProperty createPropertyFromNV(NV nv) {
    IExpr value = nv.getValue();
    if ((nv.getName() != null) && (nv.getName().length() > 0) && (value instanceof JstLiteral)) {
        JstLiteral literal = (JstLiteral) value;
        List<IJsCommentMeta> commentMeta = TranslateHelper.findMetaFromExpr(literal);
        IJsCommentMeta meta = null;
        if (commentMeta != null) {
            meta = commentMeta.get(0);
        }
        IJstType jstType = null;
        if (meta != null) {
            jstType = TranslateHelper.findType(m_ctx, meta.getTyping(), meta);
        }
        if (jstType == null) {
            jstType = value.getResultType();
        }
        if (jstType == null) {
            jstType = JstCache.getInstance().getType("String_Node_Str");
        }
        JstProperty jstProperty = new JstProperty(jstType, nv.getName(), (JstLiteral) value, new JstModifiers());
        jstProperty.setSource(nv.getSource());
        jstProperty.setComments(nv.getComments());
        return jstProperty;
    }
    return null;
}

Output:
         }
-        JstProperty jstProperty = new JstProperty(jstType, nv.getName(), (JstLiteral) value, new JstModifiers());
+        JstProperty jstProperty = new JstProperty(jstType, nv.getName(), (JstLiteral) value, new JstModifiers().setPublic());
         jstProperty.setSource(nv.getSource());


Input:
public void visit(NodeTraversal t, Node n, Node parent) {
    if (isCallToScopeMethod(n)) {
        validateScopeCall(t, n, n.getParent());
    }
    if (t.getScopeDepth() < 2) {
        return;
    }
    int type = n.getType();
    Var aliasVar = null;
    if (type == Token.NAME) {
        String name = n.getString();
        Var lexicalVar = t.getScope().getVar(n.getString());
        if (lexicalVar != null && lexicalVar == aliases.get(name)) {
            aliasVar = lexicalVar;
        }
    }
    if (t.getScopeDepth() == 2) {
        if (aliasVar != null && NodeUtil.isLValue(n)) {
            if (aliasVar.getNode() == n) {
                aliasDefinitionsInOrder.add(n);
                return;
            } else {
                report(t, n, GOOG_SCOPE_ALIAS_REDEFINED, n.getString());
            }
        }
        if (type == Token.RETURN) {
            report(t, n, GOOG_SCOPE_USES_RETURN);
        } else if (type == Token.THIS) {
            report(t, n, GOOG_SCOPE_REFERENCES_THIS);
        } else if (type == Token.THROW) {
            report(t, n, GOOG_SCOPE_USES_THROW);
        }
    }
    if (t.getScopeDepth() >= 2) {
        if (aliasVar != null) {
            aliasUsages.add(new AliasedNode(aliasVar, n));
        }
        JSDocInfo info = n.getJSDocInfo();
        if (info != null) {
            for (Node node : info.getTypeNodes()) {
                fixTypeNode(node);
            }
        }
    }
}

Output:
         JSDocInfo info = n.getJSDocInfo();
-        if (info != null) {
+        if (info != null && !injectedDecls.contains(n)) {
             for (Node node : info.getTypeNodes()) {


Input:
public final void compute(Bounds bo) throws ChartException, IllegalArgumentException {
    bo = bo.scaledInstance(dPointToPixel);
    dSeriesThickness = (ids.getDpiResolution() / 72d) * cwa.getSeriesThickness();
    double dX = bo.getLeft() + insCA.getLeft();
    double dY = bo.getTop() + insCA.getTop();
    double dW = bo.getWidth() - insCA.getLeft() - insCA.getRight();
    double dH = bo.getHeight() - insCA.getTop() - insCA.getBottom();
    iDimension = getDimension(cwa.getDimension());
    dXAxisPlotSpacing = cwa.getPlot().getHorizontalSpacing() * dPointToPixel;
    dYAxisPlotSpacing = cwa.getPlot().getVerticalSpacing() * dPointToPixel;
    if (iDimension == TWO_5_D) {
        dY += dSeriesThickness;
        dH -= dSeriesThickness;
        dW -= dSeriesThickness;
        bo.setHeight(dH);
        bo.setTop(dY);
        bo.setWidth(dW);
    }
    if (aax.getOverlayCount() > 0) {
        if (aax.areAxesSwapped()) {
            updateOverlayScales(aax, dX, dX + dW, dY, dH);
            dY = aax.getStart();
            dH = aax.getLength();
        } else {
            updateOverlayScales(aax, dY - dH, dY, dX, dW);
            dX = aax.getStart();
            dW = aax.getLength();
        }
    }
    double dStart, dEnd;
    final Axis[] axa = cwa.getPrimaryBaseAxes();
    final Axis axPrimaryBase = axa[0];
    final Axis axPrimaryOrthogonal = cwa.getPrimaryOrthogonalAxis(axPrimaryBase);
    Scale sc = axPrimaryBase.getScale();
    AutoScale scPrimaryBase = null;
    OneAxis oaxPrimaryBase = aax.getPrimaryBase();
    int iAxisType = getAxisType(axPrimaryBase);
    Object oaData = null;
    if (iAxisType == TEXT || oaxPrimaryBase.isCategoryScale()) {
        oaData = getTypedDataSet(axPrimaryBase, iAxisType, 0);
    } else if ((iAxisType & NUMERICAL) == NUMERICAL) {
        oaData = getMinMax(axPrimaryBase, iAxisType);
    } else if ((iAxisType & DATE_TIME) == DATE_TIME) {
        oaData = getMinMax(axPrimaryBase, iAxisType);
    }
    DataSetIterator dsi = (oaData instanceof DataSetIterator) ? (DataSetIterator) oaData : new DataSetIterator(oaData, iAxisType);
    oaData = null;
    dStart = (aax.areAxesSwapped()) ? dY + dH : dX;
    dEnd = (aax.areAxesSwapped()) ? dY : dStart + dW;
    int iDirection = AUTO;
    scPrimaryBase = AutoScale.computeScale(ids, oaxPrimaryBase, dsi, iAxisType, dStart, dEnd, sc, axPrimaryBase.getFormatSpecifier(), rtc, iDirection, 1, iMarginPercent);
    oaxPrimaryBase.set(scPrimaryBase);
    AutoScale scPrimaryOrthogonal = null;
    OneAxis oaxPrimaryOrthogonal = aax.getPrimaryOrthogonal();
    iAxisType = getAxisType(axPrimaryOrthogonal);
    oaData = null;
    if ((iAxisType & NUMERICAL) == NUMERICAL || (iAxisType & DATE_TIME) == DATE_TIME) {
        dsi = new DataSetIterator(getMinMax(axPrimaryOrthogonal, iAxisType), iAxisType);
    } else {
        throw new ChartException(ChartEnginePlugin.ID, ChartException.DATA_FORMAT, "String_Node_Str", Messages.getResourceBundle(rtc.getULocale()));
    }
    dStart = (aax.areAxesSwapped()) ? dX : dY + dH;
    dEnd = (aax.areAxesSwapped()) ? dX + dW : dY;
    sc = axPrimaryOrthogonal.getScale();
    scPrimaryOrthogonal = AutoScale.computeScale(ids, oaxPrimaryOrthogonal, dsi, iAxisType, dStart, dEnd, sc, axPrimaryOrthogonal.getFormatSpecifier(), rtc, AUTO, 1, iMarginPercent);
    oaxPrimaryOrthogonal.set(scPrimaryOrthogonal);
    double dYAxisLocation = adjustHorizontal(dX, dW, aax);
    double dXAxisLocation = adjustVerticalDueToHorizontal(dY, dH, aax);
    iAxisType = getAxisType(axPrimaryOrthogonal);
    oaData = getTypedDataSet(axPrimaryOrthogonal, iAxisType, 0);
    scPrimaryOrthogonal.setData(dsi);
    iAxisType = getAxisType(axPrimaryBase);
    if (iAxisType != IConstants.TEXT) {
        scPrimaryBase.setData(getTypedDataSet(axPrimaryBase, iAxisType, 0));
    }
    scPrimaryBase.resetShifts();
    scPrimaryOrthogonal.resetShifts();
    updateOverlayAxes(aax);
    growBaseAxis(aax, bo);
    final OneAxis axPH = aax.areAxesSwapped() ? aax.getPrimaryOrthogonal() : aax.getPrimaryBase();
    final OneAxis axPV = aax.areAxesSwapped() ? aax.getPrimaryBase() : aax.getPrimaryOrthogonal();
    axPH.setAxisCoordinate(dXAxisLocation);
    axPV.setAxisCoordinate(dYAxisLocation);
    double[] daX = axPH.getScale().getEndPoints();
    double[] daY = axPV.getScale().getEndPoints();
    if (axPH.getScale().getDirection() == BACKWARD) {
        boPlotBackground.setLeft(daX[1] - insCA.getLeft());
        boPlotBackground.setWidth(daX[0] - daX[1] + insCA.getLeft() + insCA.getRight() + 1);
    } else {
        boPlotBackground.setLeft(daX[0] - insCA.getLeft());
        boPlotBackground.setWidth(daX[1] - daX[0] + insCA.getLeft() + insCA.getRight() + 1);
    }
    if (axPV.getScale().getDirection() == FORWARD) {
        boPlotBackground.setTop(daY[0] - insCA.getTop());
        boPlotBackground.setHeight(daY[1] - daY[0] + insCA.getTop() + insCA.getBottom() + 1);
    } else {
        boPlotBackground.setTop(daY[1] - insCA.getTop());
        boPlotBackground.setHeight(daY[0] - daY[1] + insCA.getTop() + insCA.getBottom() + 1);
    }
    if (iDimension == TWO_5_D) {
        boPlotBackground.delta(dSeriesThickness, -dSeriesThickness, 0, 0);
    }
    boPlotWithMargin = BoundsImpl.copyInstance(boPlotBackground);
    if (iMarginPercent > 0) {
        AutoScale scale = axPH.getScale();
        if (scale.getMaxWithMargin() != null || scale.getMinWithMargin() != null) {
            if ((scale.getType() & LINEAR) == LINEAR) {
                double factor = Math.abs(daX[1] - daX[0]) / (asDouble(scale.getMaximum()).doubleValue() - asDouble(scale.getMinimum()).doubleValue());
                if (scale.getMinWithMargin() != null) {
                    boPlotWithMargin.setLeft(boPlotWithMargin.getLeft() - factor * (asDouble(scale.getMinimum()).doubleValue() - asDouble(scale.getMinWithMargin()).doubleValue()));
                }
                boPlotWithMargin.setWidth(factor * (asDouble(scale.getMaxWithMargin() == null ? scale.getMaximum() : scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMinWithMargin() == null ? scale.getMinimum() : scale.getMinWithMargin()).doubleValue()) + insCA.getLeft() + insCA.getRight() + 1);
            }
        }
        scale = axPV.getScale();
        if (scale.getMaxWithMargin() != null || scale.getMinWithMargin() != null) {
            if ((scale.getType() & LINEAR) == LINEAR) {
                double factor = Math.abs(daX[1] - daX[0]) / (asDouble(scale.getMaximum()).doubleValue() - asDouble(scale.getMinimum()).doubleValue());
                if (scale.getMaxWithMargin() != null) {
                    boPlotWithMargin.setTop(boPlotWithMargin.getTop() - factor * (asDouble(scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMaximum()).doubleValue()));
                }
                boPlotWithMargin.setHeight(factor * (asDouble(scale.getMaxWithMargin() == null ? scale.getMaximum() : scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMinWithMargin() == null ? scale.getMinimum() : scale.getMinWithMargin()).doubleValue()) + insCA.getTop() + insCA.getBottom() + 1);
            }
        }
    }
}

Output:
     sc = axPrimaryOrthogonal.getScale();
-    scPrimaryOrthogonal = AutoScale.computeScale(ids, oaxPrimaryOrthogonal, dsi, iAxisType, dStart, dEnd, sc, axPrimaryOrthogonal.getFormatSpecifier(), rtc, AUTO, 1, iMarginPercent);
+    scPrimaryOrthogonal = AutoScale.computeScale(ids, oaxPrimaryOrthogonal, dsi, iAxisType, dStart, dEnd, sc, oaxPrimaryBase.getModelAxis().getOrigin().getValue(), axPrimaryOrthogonal.getFormatSpecifier(), rtc, AUTO, 1, iMarginPercent);
     oaxPrimaryOrthogonal.set(scPrimaryOrthogonal);


Input:
public int decode_nal_units(int[] buf_base, int buf_offset, int buf_size) {
    int buf_index = 0;
    H264Context hx = this;
    int context_count = 0;
    int next_avc = ((this.is_avc != 0) ? 0 : buf_size);
    this.max_contexts = 1;
    if (0 == (s.flags2 & MpegEncContext.CODEC_FLAG2_CHUNKS)) {
        this.current_slice = 0;
        if (0 == s.first_field)
            s.current_picture_ptr = null;
        SEIDecoder.ff_h264_reset_sei(this);
    }
    for (; ; ) {
        int consumed;
        int dst_length;
        int bit_length;
        int[] ptr_base;
        int ptr_offset;
        int i, nalsize = 0;
        int err;
        if (buf_index >= next_avc) {
            if (buf_index >= buf_size)
                break;
            nalsize = 0;
            for (i = 0; i < this.nal_length_size; i++) nalsize = (nalsize << 8) | buf_base[buf_offset + buf_index++];
            if (nalsize <= 0 || nalsize > buf_size - buf_index) {
                break;
            }
            next_avc = buf_index + nalsize;
        } else {
            for (; buf_index + 3 < next_avc; buf_index++) {
                if (buf_base[buf_offset + buf_index] == 0 && buf_base[buf_offset + buf_index + 1] == 0 && buf_base[buf_offset + buf_index + 2] == 1)
                    break;
            }
            if (buf_index + 3 >= buf_size)
                break;
            buf_index += 3;
            if (buf_index >= next_avc)
                continue;
        }
        hx = this.thread_context[context_count];
        int[] param = new int[3];
        ptr_base = hx.ff_h264_decode_nal(buf_base, buf_offset + buf_index, param, next_avc - buf_index);
        dst_length = param[0];
        consumed = param[1];
        ptr_offset = param[2];
        if (ptr_base == null || dst_length < 0) {
            return -1;
        }
        i = buf_index + consumed;
        if ((s.workaround_bugs & MpegEncContext.FF_BUG_AUTODETECT) != 0 && i + 3 < next_avc && buf_base[buf_offset + i] == 0x00 && buf_base[buf_offset + i + 1] == 0x00 && buf_base[buf_offset + i + 2] == 0x01 && buf_base[buf_offset + i + 3] == 0x0E0)
            s.workaround_bugs |= MpegEncContext.FF_BUG_TRUNCATED;
        if (0 == (s.workaround_bugs & MpegEncContext.FF_BUG_TRUNCATED)) {
            while (ptr_base[ptr_offset + dst_length - 1] == 0 && dst_length > 0) dst_length--;
        }
        bit_length = (dst_length == 0) ? 0 : (8 * dst_length - ff_h264_decode_rbsp_trailing(ptr_base, ptr_offset + dst_length - 1));
        if (this.is_avc != 0 && (nalsize != consumed) && nalsize != 0) {
        }
        buf_index += consumed;
        if ((s.hurry_up == 1 && this.nal_ref_idc == 0) || (s.skip_frame >= MpegEncContext.AVDISCARD_NONREF && this.nal_ref_idc == 0))
            continue;
        boolean doAgain = false;
        do {
            doAgain = false;
            err = 0;
            switch(hx.nal_unit_type) {
                case NAL_IDR_SLICE:
                    if (this.nal_unit_type != NAL_IDR_SLICE) {
                        return -1;
                    }
                    idr();
                case NAL_SLICE:
                    hx.s.gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    hx.intra_gb_ptr = hx.inter_gb_ptr = hx.s.gb;
                    hx.s.data_partitioning = 0;
                    err = decode_slice_header(hx, this);
                    if ((err) != 0)
                        break;
                    if (this.current_slice == 1) {
                    }
                    s.current_picture_ptr.key_frame |= (((hx.nal_unit_type == NAL_IDR_SLICE) || (this.sei_recovery_frame_cnt >= 0)) ? 1 : 0);
                    if (hx.redundant_pic_count == 0 && hx.s.hurry_up < 5 && (s.skip_frame < MpegEncContext.AVDISCARD_NONREF || hx.nal_ref_idc != 0) && (s.skip_frame < MpegEncContext.AVDISCARD_BIDIR || hx.slice_type_nos != FF_B_TYPE) && (s.skip_frame < MpegEncContext.AVDISCARD_NONKEY || hx.slice_type_nos == FF_I_TYPE) && s.skip_frame < MpegEncContext.AVDISCARD_ALL) {
                        if (s.hwaccel != 0) {
                        } else {
                            context_count++;
                        }
                    }
                    break;
                case NAL_DPA:
                    hx.s.gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    hx.intra_gb_ptr = hx.inter_gb_ptr = null;
                    err = decode_slice_header(hx, this);
                    if ((err) < 0)
                        break;
                    hx.s.data_partitioning = 1;
                    break;
                case NAL_DPB:
                    hx.intra_gb = new GetBitContext();
                    hx.intra_gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    hx.intra_gb_ptr = hx.intra_gb;
                    break;
                case NAL_DPC:
                    hx.inter_gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    hx.inter_gb_ptr = hx.inter_gb;
                    if (hx.redundant_pic_count == 0 && hx.intra_gb_ptr != null && hx.s.data_partitioning != 0 && s.context_initialized != 0 && s.hurry_up < 5 && (s.skip_frame < MpegEncContext.AVDISCARD_NONREF || hx.nal_ref_idc != 0) && (s.skip_frame < MpegEncContext.AVDISCARD_BIDIR || hx.slice_type_nos != FF_B_TYPE) && (s.skip_frame < MpegEncContext.AVDISCARD_NONKEY || hx.slice_type_nos == FF_I_TYPE) && s.skip_frame < MpegEncContext.AVDISCARD_ALL) {
                        context_count++;
                    }
                    break;
                case NAL_SEI:
                    s.gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    ff_h264_decode_sei();
                    break;
                case NAL_SPS:
                    s.gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    ff_h264_decode_seq_parameter_set();
                    if ((s.flags & MpegEncContext.CODEC_FLAG_LOW_DELAY) != 0)
                        s.low_delay = 1;
                    if (s.has_b_frames < 2)
                        s.has_b_frames = ((0 == s.low_delay) ? 1 : 0);
                    break;
                case NAL_PPS:
                    s.gb.init_get_bits(ptr_base, ptr_offset, bit_length);
                    ff_h264_decode_picture_parameter_set(bit_length);
                    break;
                case NAL_AUD:
                case NAL_END_SEQUENCE:
                case NAL_END_STREAM:
                case NAL_FILLER_DATA:
                case NAL_SPS_EXT:
                case NAL_AUXILIARY_SLICE:
                    break;
                default:
            }
            if (context_count == this.max_contexts) {
                decode_slice();
                context_count = 0;
            }
            if (err < 0) {
            } else if (err == 1) {
                this.nal_unit_type = hx.nal_unit_type;
                this.nal_ref_idc = hx.nal_ref_idc;
                hx = this;
                doAgain = true;
            }
        } while (doAgain == true);
    }
    if (context_count != 0)
        decode_slice();
    return buf_index;
}

Output:
                     err = decode_slice_header(hx, this);
-                    if ((err) != 0)
+                    if ((err) != 0) {
+                        System.out.println("String_Node_Str" + err);
                         break;


Input:
public static File performExternal2Bin(File sourceFile, File targetFile, TaskComplete done) {
    File binaryFile = targetFile;
    DialogExternal2Binary dialog = new DialogExternal2Binary(EncogWorkBench.getInstance().getMainWindow());
    if (binaryFile != null) {
        dialog.getBinaryFile().setValue(binaryFile.toString());
    }
    if (sourceFile != null) {
        dialog.getExternalFile().setValue(sourceFile.toString());
    }
    if (dialog.process()) {
        binaryFile = new File(dialog.getBinaryFile().getValue());
        File externFile = new File(dialog.getExternalFile().getValue());
        int fileType = dialog.getFileType().getSelectedIndex();
        int inputCount = dialog.getInputCount().getValue();
        int idealCount = dialog.getIdealCount().getValue();
        if (ExtensionFilter.getExtension(binaryFile) == null) {
            binaryFile = new File(binaryFile.getPath() + "String_Node_Str");
        }
        DataSetCODEC codec;
        BinaryDataLoader loader;
        if (fileType == 0) {
            DialogCSV dialog2 = new DialogCSV(EncogWorkBench.getInstance().getMainWindow());
            if (dialog2.process()) {
                boolean headers = dialog2.getHeaders().getValue();
                CSVFormat format;
                if (dialog2.getDecimalComma().getValue())
                    format = CSVFormat.DECIMAL_COMMA;
                else
                    format = CSVFormat.DECIMAL_POINT;
                codec = new CSVDataCODEC(externFile, format, headers, inputCount, idealCount);
                loader = new BinaryDataLoader(codec);
                ImportExportDialog dlg = new ImportExportDialog(loader, binaryFile, true);
                dlg.process(done);
            }
        } else if (fileType == 1) {
            codec = new ExcelCODEC(externFile, inputCount, idealCount);
            loader = new BinaryDataLoader(codec);
            ImportExportDialog dlg = new ImportExportDialog(loader, binaryFile, true);
            dlg.process(done);
        }
        return binaryFile;
    } else
        return null;
}

Output:
                     format = CSVFormat.DECIMAL_POINT;
-                codec = new CSVDataCODEC(externFile, format, headers, inputCount, idealCount);
+                codec = new CSVDataCODEC(externFile, format, headers, inputCount, idealCount, dialog.getContainsSignificance().getValue());
                 loader = new BinaryDataLoader(codec);


Input:
public void sendToAllAround(FMLProxyPacket pkt, NetworkRegistry.TargetPoint point) {
    channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT);
    channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point);
    channels.get(Side.SERVER).writeAndFlush(pkt);
}

Output:
     channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point);
-    channels.get(Side.SERVER).writeAndFlush(pkt);
+    channels.get(Side.SERVER).writeAndFlush(pkt).addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
 }


Input:
public void load(CoverageOptionManager coverageOptionManager) throws OseeCoreException {
    coverageUnit.clearCoverageUnits();
    coverageUnit.clearCoverageItems();
    Artifact artifact = getArtifact(false);
    if (artifact != null) {
        for (String value : artifact.getAttributesToStringList(CoverageAttributeTypes.Item)) {
            CoverageItem item = CoverageItem.createCoverageItem(coverageUnit, value, coverageOptionManager, getTestUnitProvider());
            coverageUnit.addCoverageItem(item);
        }
        coverageUnit.setFileContentsProvider(OseeCoverageUnitFileContentsProvider.getInstance(branch));
        coverageUnit.setNotes(artifact.getSoleAttributeValueAsString(CoverageAttributeTypes.Notes, "String_Node_Str"));
        coverageUnit.setFolder(artifact.isOfType(CoverageArtifactTypes.CoverageFolder));
        coverageUnit.setAssignees(artifact.getSoleAttributeValueAsString(CoverageAttributeTypes.Assignees, "String_Node_Str"));
        coverageUnit.setWorkProductTaskGuid(artifact.getSoleAttributeValueAsString(CoverageAttributeTypes.WorkProductTaskGuid, "String_Node_Str"));
        coverageUnit.setNamespace(artifact.getSoleAttributeValueAsString(CoverageAttributeTypes.Namespace, "String_Node_Str"));
        coverageUnit.setOrderNumber(artifact.getSoleAttributeValueAsString(CoverageAttributeTypes.Order, "String_Node_Str"));
        coverageUnit.setLocation(artifact.getSoleAttributeValueAsString(CoverageAttributeTypes.Location, "String_Node_Str"));
        for (Artifact childArt : artifact.getChildren()) {
            if (childArt.isOfType(CoverageArtifactTypes.CoverageUnit, CoverageArtifactTypes.CoverageFolder)) {
                coverageUnit.addCoverageUnit(OseeCoverageUnitStore.get(coverageUnit, childArt, coverageOptionManager, coveragePackage));
            }
        }
    }
}

Output:
         for (String value : artifact.getAttributesToStringList(CoverageAttributeTypes.Item)) {
-            CoverageItem item = CoverageItem.createCoverageItem(coverageUnit, value, coverageOptionManager, getTestUnitProvider());
+            CoverageItem item = CoverageItem.createCoverageItem(coverageUnit, value, coverageOptionManager, getTestUnitProvider(coveragePackage, readOnlyTestUnitNames));
             coverageUnit.addCoverageItem(item);


Input:
public void onSomePackagesChanged() {
    int userHandle = getChangingUserId();
    if (DEBUG)
        Slog.d(TAG, "String_Node_Str" + userHandle);
    ComponentName curInteractor = getCurInteractor(userHandle);
    ComponentName curRecognizer = getCurRecognizer(userHandle);
    if (curRecognizer == null) {
        if (anyPackagesAppearing()) {
            curRecognizer = findAvailRecognizer(null, userHandle);
            if (curRecognizer != null) {
                setCurRecognizer(curRecognizer, userHandle);
            }
        }
        return;
    }
    if (curInteractor != null) {
        int change = isPackageDisappearing(curInteractor.getPackageName());
        if (change == PACKAGE_PERMANENT_CHANGE) {
            setCurInteractor(null, userHandle);
            setCurRecognizer(null, userHandle);
            initForUser(userHandle);
            return;
        }
        change = isPackageAppearing(curInteractor.getPackageName());
        if (change != PACKAGE_UNCHANGED) {
            if (mImpl != null && curInteractor.getPackageName().equals(mImpl.mComponent.getPackageName())) {
                switchImplementationIfNeededLocked(true);
            }
        }
        return;
    }
    int change = isPackageDisappearing(curRecognizer.getPackageName());
    if (change == PACKAGE_PERMANENT_CHANGE || change == PACKAGE_TEMPORARY_CHANGE) {
        setCurRecognizer(findAvailRecognizer(null, userHandle), userHandle);
    } else if (isPackageModified(curRecognizer.getPackageName())) {
        setCurRecognizer(findAvailRecognizer(curRecognizer.getPackageName(), userHandle), userHandle);
    }
}

Output:
         Slog.d(TAG, "String_Node_Str" + userHandle);
-    ComponentName curInteractor = getCurInteractor(userHandle);
-    ComponentName curRecognizer = getCurRecognizer(userHandle);
-    if (curRecognizer == null) {
-        if (anyPackagesAppearing()) {
-            curRecognizer = findAvailRecognizer(null, userHandle);
-            if (curRecognizer != null) {
-                setCurRecognizer(curRecognizer, userHandle);
+    synchronized (VoiceInteractionManagerService.this) {
+        ComponentName curInteractor = getCurInteractor(userHandle);
+        ComponentName curRecognizer = getCurRecognizer(userHandle);
+        if (curRecognizer == null) {
+            if (anyPackagesAppearing()) {
+                curRecognizer = findAvailRecognizer(null, userHandle);
+                if (curRecognizer != null) {
+                    setCurRecognizer(curRecognizer, userHandle);
+                }
             }


Input:
public Object[] getChildren(Object parentElement) {
    if (parentElement instanceof IExecTestCasePO) {
        ISpecTestCasePO referencedTestCase = ((IExecTestCasePO) parentElement).getSpecTestCase();
        if (referencedTestCase != null) {
            return ArrayUtils.addAll(Collections.unmodifiableCollection(referencedTestCase.getAllEventEventExecTC()).toArray(), referencedTestCase.getUnmodifiableNodeList().toArray());
        }
        return ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parentElement instanceof IProjectPO) {
        IProjectPO project = (IProjectPO) parentElement;
        List<Object> elements = new ArrayList<Object>();
        elements.addAll(project.getSpecObjCont().getSpecObjList());
        elements.addAll(project.getUsedProjects());
        return elements.toArray();
    }
    if (parentElement instanceof INodePO) {
        INodePO parentNode = ((INodePO) parentElement);
        Object[] children = parentNode.getUnmodifiableNodeList().toArray();
        if (parentElement instanceof ISpecTestCasePO) {
            children = ArrayUtils.addAll(Collections.unmodifiableCollection(((ISpecTestCasePO) parentElement).getAllEventEventExecTC()).toArray(), children);
        }
        return children;
    }
    if (parentElement instanceof IReusedProjectPO) {
        try {
            IProjectPO reusedProject = ProjectPM.loadReusedProjectInMasterSession((IReusedProjectPO) parentElement);
            if (reusedProject != null) {
                return reusedProject.getSpecObjCont().getSpecObjList().toArray();
            }
            return ArrayUtils.EMPTY_OBJECT_ARRAY;
        } catch (JBException e) {
            Utils.createMessageDialog(e, null, null);
            return ArrayUtils.EMPTY_OBJECT_ARRAY;
        }
    }
    return ArrayUtils.EMPTY_OBJECT_ARRAY;
}

Output:
 public Object[] getChildren(Object parentElement) {
-    if (parentElement instanceof IExecTestCasePO) {
-        ISpecTestCasePO referencedTestCase = ((IExecTestCasePO) parentElement).getSpecTestCase();
-        if (referencedTestCase != null) {
-            return ArrayUtils.addAll(Collections.unmodifiableCollection(referencedTestCase.getAllEventEventExecTC()).toArray(), referencedTestCase.getUnmodifiableNodeList().toArray());
-        }
-        return ArrayUtils.EMPTY_OBJECT_ARRAY;
+    if (parentElement instanceof IProjectPO[]) {
+        return new Object[] { ((IProjectPO[]) parentElement)[0] };
     }


Input:
protected EmvCard readWithPSE() throws CommunicationException {
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("String_Node_Str");
    }
    EmvCard card = null;
    byte[] data = selectPaymentEnvironment();
    if (ResponseUtils.isSucceed(data)) {
        data = parseFCIProprietaryTemplate(data);
        if (ResponseUtils.isSucceed(data)) {
            String label = extractApplicationLabel(data);
            card = extractPublicData(TlvUtil.getValue(data, EmvTags.AID_CARD), label);
        }
    } else if (LOGGER.isDebugEnabled()) {
        LOGGER.debug((contactLess ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    }
    return card;
}

Output:
             String label = extractApplicationLabel(data);
-            card = extractPublicData(TlvUtil.getValue(data, EmvTags.AID_CARD), label);
+            card = extractPublicData(getAid(data), label);
         }


Input:
public static String toJson(Map<String, String> map) {
    if (map == null || map.size() == 0) {
        return null;
    }
    StringBuilder paras = new StringBuilder();
    paras.append("String_Node_Str");
    Iterator<Map.Entry<String, String>> ite = map.entrySet().iterator();
    while (ite.hasNext()) {
        Map.Entry<String, String> entry = (Map.Entry<String, String>) ite.next();
        paras.append("String_Node_Str").append(entry.getKey()).append("String_Node_Str").append(entry.getValue());
        if (ite.hasNext()) {
            paras.append("String_Node_Str");
        }
    }
    paras.append("String_Node_Str");
    return paras.toString();
}

Output:
         Map.Entry<String, String> entry = (Map.Entry<String, String>) ite.next();
-        paras.append("String_Node_Str").append(entry.getKey()).append("String_Node_Str").append(entry.getValue());
+        paras.append("String_Node_Str").append(entry.getKey()).append("String_Node_Str").append(entry.getValue()).append("String_Node_Str");
         if (ite.hasNext()) {


Input:
private static boolean containsWorkVersionReuses(INodePO root, ITestSuitePO ts) {
    final Iterator it = root.getNodeListIterator();
    final List<INodePO> childList = IteratorUtils.toList(it);
    for (INodePO child : childList) {
        if (child instanceof IRefTestSuitePO) {
            final IRefTestSuitePO refTs = (IRefTestSuitePO) child;
            if (ts.getGuid().equals(refTs.getTestSuiteGuid())) {
                return true;
            }
            if (containsWorkVersionReuses(refTs, ts)) {
                return true;
            }
        }
    }
    return false;
}

Output:
 private static boolean containsWorkVersionReuses(INodePO root, ITestSuitePO ts) {
-    final Iterator it = root.getNodeListIterator();
+    final Iterator<INodePO> it = root.getNodeListIterator();
     final List<INodePO> childList = IteratorUtils.toList(it);


Input:
public Object getMax() {
    return max.toByteArray();
}

Output:
 public Object getMax() {
-    return max.toByteArray();
+    return doubleToBytes(max);
 }


Input:
public static Address pickAddress(Node node, final ServerSocketChannel serverSocketChannel) throws Exception {
    String currentAddress = null;
    try {
        final Config config = Config.get();
        final String localAddress = System.getProperty("String_Node_Str");
        if (localAddress != null) {
            currentAddress = InetAddress.getByName(localAddress.trim()).getHostAddress();
        }
        if (currentAddress == null) {
            final Enumeration<NetworkInterface> enums = NetworkInterface.getNetworkInterfaces();
            interfaces: while (enums.hasMoreElements()) {
                final NetworkInterface ni = enums.nextElement();
                final Enumeration<InetAddress> e = ni.getInetAddresses();
                while (e.hasMoreElements()) {
                    final InetAddress inetAddress = e.nextElement();
                    if (inetAddress instanceof Inet4Address) {
                        final String address = inetAddress.getHostAddress();
                        if (config.getNetworkConfig().getInterfaces().isEnabled()) {
                            if (matchAddress(address)) {
                                currentAddress = address;
                                break interfaces;
                            }
                        } else {
                            if (!inetAddress.isLoopbackAddress()) {
                                currentAddress = address;
                                break interfaces;
                            }
                        }
                    }
                }
            }
            if (config.getNetworkConfig().getInterfaces().isEnabled() && currentAddress == null) {
                String msg = "String_Node_Str";
                msg += "String_Node_Str";
                logger.log(Level.SEVERE, msg);
                node.dumpCore(null);
                return null;
            }
        }
        if (currentAddress == null) {
            currentAddress = "String_Node_Str";
        }
        final InetAddress inetAddress = InetAddress.getByName(currentAddress);
        ServerSocket serverSocket = serverSocketChannel.socket();
        serverSocket.setReuseAddress(false);
        InetSocketAddress isa;
        int port = config.getPort();
        for (int i = 0; i < 100; i++) {
            try {
                isa = new InetSocketAddress(inetAddress, port);
                serverSocket.bind(isa, 100);
                break;
            } catch (final Exception e) {
                serverSocket = serverSocketChannel.socket();
                serverSocket.setReuseAddress(false);
                port++;
            }
        }
        serverSocketChannel.configureBlocking(false);
        return new Address(currentAddress, port);
    } catch (final Exception e) {
        node.dumpCore(e);
        e.printStackTrace();
        throw e;
    }
}

Output:
         ServerSocket serverSocket = serverSocketChannel.socket();
-        serverSocket.setReuseAddress(false);
+        serverSocket.setReuseAddress(true);
         InetSocketAddress isa;


Input:
protected String getManagedObjectPath(Context context) {
    return resourcePath.child(getManagedObjectId(context)).toString();
}

Output:
 protected String getManagedObjectPath(Context context) {
-    return resourcePath.child(getManagedObjectId(context)).toString();
+    return resourceContainer.child(getManagedObjectId(context)).toString();
 }


Input:
public void addMetadata(PartitionKey key, Map<String, String> metadata) {
    final byte[] rowKey = generateRowKey(key, partitioning);
    Row row = partitionsTable.get(rowKey);
    if (row.isEmpty()) {
        throw new PartitionNotFoundException(key, getName());
    }
    Put put = new Put(rowKey);
    addMetadataToPut(metadata, put);
    partitionsTable.put(put);
}

Output:
 public void addMetadata(PartitionKey key, Map<String, String> metadata) {
-    final byte[] rowKey = generateRowKey(key, partitioning);
-    Row row = partitionsTable.get(rowKey);
-    if (row.isEmpty()) {
-        throw new PartitionNotFoundException(key, getName());
-    }
-    Put put = new Put(rowKey);
-    addMetadataToPut(metadata, put);
-    partitionsTable.put(put);
+    setMetadata(key, metadata, false);
 }


Input:
public void updateMetadata() {
    PlayOutEntityMetadata packet = new PlayOutEntityMetadata(this);
    RecipientSelector.whoCanSee(this, packet, false);
}

Output:
     PlayOutEntityMetadata packet = new PlayOutEntityMetadata(this);
-    RecipientSelector.whoCanSee(this, packet, false);
+    RecipientSelector.whoCanSee(this, false, packet);
 }


Input:
public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
    builder.startObject(name);
    builder.field(Fields._TYPE, TermListFacet.TYPE);
    builder.array(Fields.ENTRIES, strings);
    builder.endObject();
    return builder;
}

Output:
 public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
-    builder.startObject(name);
+    builder.startObject(this.getName());
     builder.field(Fields._TYPE, TermListFacet.TYPE);


Input:
LogisimFile readLibrary(InputStream is) throws IOException, SAXException {
    Document doc = loadXmlFrom(is);
    Element elt = doc.getDocumentElement();
    elt = ensureLogisimCompatibility(elt, doc);
    considerRepairs(doc, elt);
    LogisimFile file = new LogisimFile((Loader) loader);
    ReadContext context = new ReadContext(file);
    context.toLogisimFile(elt);
    if (file.getCircuitCount() == 0) {
        file.addCircuit(new Circuit("String_Node_Str", file));
    }
    if (context.messages.size() > 0) {
        StringBuilder all = new StringBuilder();
        for (String msg : context.messages) {
            all.append(msg);
            all.append("String_Node_Str");
        }
        loader.showError(all.substring(0, all.length() - 1));
    }
    return file;
}

Output:
     Element elt = doc.getDocumentElement();
-    elt = ensureLogisimCompatibility(elt, doc);
+    elt = ensureLogisimCompatibility(elt);
     considerRepairs(doc, elt);


Input:
public void testExtends() throws Exception {
    openDesign(FILE_NAME_EXTENDS);
    assertNotNull(designHandle);
    libraryHandle = designHandle.getLibrary("String_Node_Str");
    TabularCubeHandle cube = (TabularCubeHandle) libraryHandle.findCube("String_Node_Str");
    TabularCubeHandle newCube = (TabularCubeHandle) designHandle.getElementFactory().newElementFrom(cube, null);
    designHandle.getCubes().add(newCube);
    save();
    assertTrue(compareFile("String_Node_Str"));
    AccessControlHandle control = designHandle.getElementFactory().newAccessControl();
    control.addUserName("String_Node_Str");
    newCube.add(ICubeModel.ACCESS_CONTROLS_PROP, control);
    save();
    assertTrue(compareFile("String_Node_Str"));
    designHandle.getCommandStack().undo();
    LevelHandle level = designHandle.findLevel("String_Node_Str");
    ValueAccessControlHandle valueAccess = designHandle.getElementFactory().newValueAccessControl();
    valueAccess.addValue("String_Node_Str");
    level.add(ILevelModel.VALUE_ACCESS_CONTROLS_PROP, valueAccess);
    save();
    assertTrue(compareFile("String_Node_Str"));
    valueAccess.setPermission(DesignChoiceConstants.ACCESS_PERMISSION_ALLOW);
}

Output:
     TabularCubeHandle cube = (TabularCubeHandle) libraryHandle.findCube("String_Node_Str");
-    TabularCubeHandle newCube = (TabularCubeHandle) designHandle.getElementFactory().newElementFrom(cube, null);
+    TabularCubeHandle newCube = (TabularCubeHandle) designHandle.getElementFactory().newElementFrom(cube, "String_Node_Str");
     designHandle.getCubes().add(newCube);


Input:
private void openEditDialog() {
    StructuredSelection selection = (StructuredSelection) listViewer.getSelection();
    if (selection == null) {
        return;
    }
    FunctionEntity entity = (FunctionEntity) selection.getFirstElement();
    NewUDFFunctionDialog dialog = new NewUDFFunctionDialog(getShell(), entity);
    dialog.open();
    listViewer.refresh();
}

Output:
 private void openEditDialog() {
-    StructuredSelection selection = (StructuredSelection) listViewer.getSelection();
-    if (selection == null) {
+    StructuredSelection selection = (StructuredSelection) tableViewer.getSelection();
+    if (selection.isEmpty()) {
         return;


Input:
public int getStrLen(Record rec) {
    return lhs.getStrLen(rec) + rhs.getStrLen(rec);
}

Output:
 public int getStrLen(Record rec) {
-    return lhs.getStrLen(rec) + rhs.getStrLen(rec);
+    int ll = lhs.getStrLen(rec);
+    int rl = rhs.getStrLen(rec);
+    if (ll == VariableColumn.NULL_LEN) {
+        return rl;
+    }
+    if (rl == VariableColumn.NULL_LEN) {
+        return ll;
+    }
+    return ll + rl;
 }


Input:
public void test_link_in_style_partly() {
    ZBlock p = p("String_Node_Str");
    assertEquals("String_Node_Str", p.ele(0).getHref().getValue());
    assertEquals("String_Node_Str", p.ele(0).getText());
    assertTrue(p.ele(0).getStyle().getFont().isBold());
    assertTrue(p.ele(0).getStyle().getFont().isItalic());
    assertEquals("String_Node_Str", p.ele(1).getText());
}

Output:
 public void test_link_in_style_partly() {
-    ZBlock p = p("String_Node_Str");
+    ZBlock p = P("String_Node_Str");
     assertEquals("String_Node_Str", p.ele(0).getHref().getValue());


Input:
private boolean compareDescriptors() {
    Vector appVectorName = validNameSpaceDetails.get(APP_KEYS);
    Vector ebdVectorName = validNameSpaceDetails.get(EJBBUNDLE_KEYS);
    for (String key : allResourceDescriptors.keySet()) {
        CommonResourceValidator commonResourceValidator = allResourceDescriptors.get(key);
        Vector scopeVector = commonResourceValidator.getScope();
        String jndiName = commonResourceValidator.getJndiName();
        if (jndiName.contains(JNDI_COMP)) {
            for (int i = 0; i < scopeVector.size(); i++) {
                String scope = (String) scopeVector.get(i);
                for (int j = 0; j < appVectorName.size(); j++) {
                    if (scope.equals(appVectorName.get(j))) {
                        inValidJndiName = jndiName;
                        DOLUtils.getDefaultLogger().log(Level.SEVERE, "String_Node_Str", new Object[] { jndiName });
                        return false;
                    }
                }
                for (int j = 0; j < ebdVectorName.size(); j++) {
                    if (scope.equals(ebdVectorName.get(j))) {
                        inValidJndiName = jndiName;
                        DOLUtils.getDefaultLogger().log(Level.SEVERE, "String_Node_Str", new Object[] { jndiName });
                        return false;
                    }
                }
            }
        }
        if (jndiName.contains(JNDI_MODULE)) {
            for (int i = 0; i < scopeVector.size(); i++) {
                String scope = (String) scopeVector.get(i);
                for (int j = 0; j < appVectorName.size(); j++) {
                    if (scope.equals(appVectorName.get(j))) {
                        inValidJndiName = jndiName;
                        DOLUtils.getDefaultLogger().log(Level.SEVERE, "String_Node_Str", new Object[] { jndiName });
                        return false;
                    }
                }
            }
        }
        if (scopeVector.size() > 1) {
            if (jndiName.contains(JNDI_COMP)) {
                if (!compareVectorForComp(scopeVector, jndiName)) {
                    return false;
                }
            } else if (jndiName.contains(JNDI_MODULE)) {
                if (!compareVectorForModule(scopeVector, jndiName)) {
                    return false;
                }
            } else if (jndiName.contains(JNDI_APP)) {
                if (!compareVectorForApp(scopeVector, jndiName)) {
                    return false;
                }
            } else {
                try {
                    InitialContext ic = new InitialContext();
                    Object lookup = ic.lookup(jndiName);
                    if (lookup != null) {
                        return false;
                    }
                } catch (NamingException e) {
                    inValidJndiName = jndiName;
                    DOLUtils.getDefaultLogger().log(Level.SEVERE, "String_Node_Str", new Object[] { jndiName });
                }
            }
        }
    }
    return true;
}

Output:
                 try {
-                    InitialContext ic = new InitialContext();
-                    Object lookup = ic.lookup(jndiName);
-                    if (lookup != null) {
-                        return false;
+                    boolean selfDefining = ((commonResourceValidator.getDescriptor() instanceof JMSDestinationDefinitionDescriptor) || (commonResourceValidator.getDescriptor() instanceof DataSourceDefinitionDescriptor));
+                    if (!selfDefining) {
+                        InitialContext ic = new InitialContext();
+                        Object lookup = ic.lookup(jndiName);
+                        if (lookup != null) {
+                            return false;
+                        }
                     }


Input:
private String getPackageNameFromContainerPath(String containerPath) {
    int extensionIndex = containerPath.lastIndexOf("String_Node_Str");
    String extension = containerPath.substring(extensionIndex);
    if (extension.equals("String_Node_Str")) {
        return mPackageManager.getPackageArchiveInfo(containerPath, 0).packageName;
    }
    if (extension.equals("String_Node_Str")) {
        DexFile classesDexFile = null;
        String packageName;
        try {
            classesDexFile = new DexFile(containerPath);
            Enumeration<String> classesNames = classesDexFile.entries();
            String firstClassName = classesNames.nextElement().replaceAll(Pattern.quote(File.separator), "String_Node_Str");
            packageName = firstClassName.substring(0, firstClassName.lastIndexOf('.'));
        } catch (IOException e) {
            return null;
        } finally {
            if (classesDexFile != null) {
                try {
                    classesDexFile.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return packageName;
    }
    return null;
}

Output:
     if (extension.equals("String_Node_Str")) {
-        return mPackageManager.getPackageArchiveInfo(containerPath, 0).packageName;
+        if (mPackageManager.getPackageArchiveInfo(containerPath, 0) != null)
+            return mPackageManager.getPackageArchiveInfo(containerPath, 0).packageName;
+        return null;
     }


Input:
public static void framesToImage(int containerId, List<BufferedImage> ret, int startFrame, int stopFrame, List<Tag> allTags, List<Tag> controlTags, RECT displayRect, int totalFrameCount, Stack<Integer> visited) {
    for (int i = startFrame; i <= stopFrame; i++) {
        String key = "String_Node_Str" + i + "String_Node_Str" + containerId;
        if (frameCache.contains(key)) {
            BufferedImage g = (BufferedImage) frameCache.get(key);
            if (g == null) {
                break;
            }
            ret.add(g);
            startFrame++;
        } else {
            break;
        }
    }
    if (startFrame > stopFrame) {
        return;
    }
    if (totalFrameCount == 0) {
        return;
    }
    while (startFrame >= totalFrameCount) {
        startFrame -= totalFrameCount;
    }
    while (stopFrame >= totalFrameCount) {
        stopFrame -= totalFrameCount;
    }
    HashMap<Integer, CharacterTag> characters = new HashMap<>();
    for (Tag t : allTags) {
        if (t instanceof CharacterTag) {
            CharacterTag ch = (CharacterTag) t;
            characters.put(ch.getCharacterId(), ch);
        }
    }
    HashMap<Integer, Layer> layers = new HashMap<>();
    int maxDepth = 0;
    int f = 0;
    Color backgroundColor = new Color(0, 0, 0, 0);
    for (Tag t : controlTags) {
        if (t instanceof SetBackgroundColorTag) {
            SetBackgroundColorTag c = (SetBackgroundColorTag) t;
            backgroundColor = new Color(c.backgroundColor.red, c.backgroundColor.green, c.backgroundColor.blue);
        }
        if (t instanceof PlaceObjectTypeTag) {
            PlaceObjectTypeTag po = (PlaceObjectTypeTag) t;
            int depth = po.getDepth();
            if (depth > maxDepth) {
                maxDepth = depth;
            }
            if (!layers.containsKey(depth)) {
                layers.put(depth, new Layer());
            }
            Layer layer = layers.get(depth);
            int characterId = po.getCharacterId();
            if (characterId != -1) {
                layer.characterId = characterId;
            }
            layer.visible = po.isVisible();
            if (po.flagMove()) {
                MATRIX matrix2 = po.getMatrix();
                if (matrix2 != null) {
                    layer.matrix = matrix2;
                }
                String instanceName = po.getInstanceName();
                if (instanceName != null) {
                    layer.instanceName = instanceName;
                }
                CXFORM colorTransForm = po.getColorTransform();
                if (colorTransForm != null) {
                    layer.colorTransForm = colorTransForm;
                }
                CXFORMWITHALPHA colorTransFormAlpha = po.getColorTransformWithAlpha();
                if (colorTransFormAlpha != null) {
                    layer.colorTransFormAlpha = colorTransFormAlpha;
                }
                if (po.cacheAsBitmap()) {
                    layer.cacheAsBitmap = true;
                }
                int blendMode = po.getBlendMode();
                if (blendMode != 0) {
                    layer.blendMode = blendMode;
                }
                List<FILTER> filters = po.getFilters();
                if (filters != null) {
                    layer.filters = filters;
                }
                int ratio = po.getRatio();
                if (ratio != -1) {
                    layer.ratio = ratio;
                }
            } else {
                layer.matrix = po.getMatrix();
                layer.instanceName = po.getInstanceName();
                layer.colorTransForm = po.getColorTransform();
                layer.colorTransFormAlpha = po.getColorTransformWithAlpha();
                layer.cacheAsBitmap = po.cacheAsBitmap();
                layer.blendMode = po.getBlendMode();
                layer.filters = po.getFilters();
                layer.ratio = po.getRatio();
            }
        }
        if (t instanceof RemoveTag) {
            RemoveTag rt = (RemoveTag) t;
            layers.remove(rt.getDepth());
        }
        for (Layer l : layers.values()) {
            l.duration++;
        }
        if (t instanceof ShowFrameTag) {
            if (f > stopFrame) {
                break;
            }
            if ((f >= startFrame) && (f <= stopFrame)) {
                ret.add(frameToImage(containerId, maxDepth, layers, backgroundColor, characters, f, allTags, controlTags, displayRect, visited));
            }
            f++;
        }
    }
}

Output:
         if (frameCache.contains(key)) {
-            BufferedImage g = (BufferedImage) frameCache.get(key);
+            SerializableImage g = (SerializableImage) frameCache.get(key);
             if (g == null) {


Input:
public static int serializableBufferLength(ReusableBuffer data) {
    int len = data.capacity() + Integer.SIZE / 8;
    if (len % 4 > 0)
        len += 4 - (len % 4);
    return len;
}

Output:
 public static int serializableBufferLength(ReusableBuffer data) {
-    int len = data.capacity() + Integer.SIZE / 8;
+    int len = data.remaining() + Integer.SIZE / 8;
     if (len % 4 > 0)


Input:
public void run() {
    Toast.makeText(MainActivity.this, "String_Node_Str" + NasaDailyActivity.getComponentName(), Toast.LENGTH_SHORT).show();
}

Output:
 public void run() {
-    Toast.makeText(MainActivity.this, "String_Node_Str" + NasaDailyActivity.getComponentName(), Toast.LENGTH_SHORT).show();
+    Toast.makeText(MainActivity.this, "String_Node_Str" + NasaDailyActivity.getClass().getName(), Toast.LENGTH_SHORT).show();
 }


Input:
public BileBlightEffect copy() {
    return new BileBlightEffect();
}

Output:
 public BileBlightEffect copy() {
-    return new BileBlightEffect();
+    return new BileBlightEffect(this);
 }