Input:
public static BraintreeFragment getMockFragment(Activity activity, String clientToken, Configuration configuration) {
    try {
        BraintreeFragment fragment = spy(BraintreeFragment.newInstance(activity, clientToken));
        doNothing().when(fragment).fetchConfiguration();
        when(fragment.getContext()).thenReturn(getTargetContext());
        when(fragment.getConfiguration()).thenReturn(configuration);
        getInstrumentation().waitForIdleSync();
        return fragment;
    } catch (InvalidArgumentException e) {
        fail(e.getMessage());
        return new BraintreeFragment();
    }
}

Output:
         doNothing().when(fragment).fetchConfiguration();
-        when(fragment.getContext()).thenReturn(getTargetContext());
+        when(fragment.getApplicationContext()).thenReturn(getTargetContext());
         when(fragment.getConfiguration()).thenReturn(configuration);


Input:
private static final int toStyle(String style) {
    if (style != null) {
        style = style.trim().toLowerCase();
        return "String_Node_Str".equals(style) ? DateFormat.SHORT : "String_Node_Str".equals(style) ? DateFormat.MEDIUM : "String_Node_Str".equals(style) ? DateFormat.LONG : "String_Node_Str".equals(style) ? DateFormat.FULL : -111;
    }
    return -111;
}

Output:
     if (style != null) {
-        style = style.trim().toLowerCase();
+        style = style.trim().toLowerCase(java.util.Locale.ENGLISH);
         return "String_Node_Str".equals(style) ? DateFormat.SHORT : "String_Node_Str".equals(style) ? DateFormat.MEDIUM : "String_Node_Str".equals(style) ? DateFormat.LONG : "String_Node_Str".equals(style) ? DateFormat.FULL : -111;


Input:
public void onAnimationEnd(Animator animation) {
    moreGroupImageView.setRotation(0);
    commitChange(deskSimple.getButtons());
}

Output:
     moreGroupImageView.setRotation(0);
-    commitChange(deskSimple.getButtons());
+    if (deskSimple.getButtons() != null && deskSimple.getButtons().size() > 0) {
+        commitChange(deskSimple.getSortedButtons());
+    }
 }


Input:
public static void writeFile(String fileName, String str) {
    try {
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
        out.println(str);
        out.close();
    } catch (IOException e) {
        LOGGER.info("String_Node_Str" + e);
    }
}

Output:
     try {
-        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+        PrintWriter out = new PrintWriter(fileName, "String_Node_Str");
         out.println(str);


Input:
public static String round(double source, int decimals) {
    if (decimals < 0)
        throw new IllegalArgumentException("String_Node_Str");
    if (decimals == 0) {
        return Long.toString((long) source);
    }
    int decimalLimiter = 1;
    for (byte i = 0; i < decimals; i++) decimalLimiter *= 10;
    double rounded = ((double) Math.round(source * decimalLimiter)) / decimalLimiter;
    String val = Double.toString(rounded);
    int dot = val.indexOf('.');
    if (dot == -1) {
        StringBuffer sb = new StringBuffer(val);
        sb.append('.');
        for (int i = 0; i < decimals; i++) sb.append('0');
        return sb.toString();
    } else {
        if (val.length() - (dot + decimals) > 0) {
            return val.substring(0, dot + decimals + 1);
        }
        StringBuffer sb = new StringBuffer(val);
        for (int i = val.length(); i <= dot + decimals; i++) sb.append('0');
        return sb.toString();
    }
}

Output:
     }
-    int decimalLimiter = 1;
-    for (byte i = 0; i < decimals; i++) decimalLimiter *= 10;
-    double rounded = ((double) Math.round(source * decimalLimiter)) / decimalLimiter;
+    double rounded = roundDouble(source, decimals);
     String val = Double.toString(rounded);


Input:
public void save() {
    load();
    options.setProperty("String_Node_Str", "String_Node_Str");
    if (simpleServerOptions.getBoolean("String_Node_Str")) {
        options.setProperty("String_Node_Str", "String_Node_Str");
    } else {
        options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    }
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
    super.save();
}

Output:
     options.setProperty("String_Node_Str", "String_Node_Str");
-    if (simpleServerOptions.getBoolean("String_Node_Str")) {
-        options.setProperty("String_Node_Str", "String_Node_Str");
-    } else {
-        options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));
-    }
+    options.setProperty("String_Node_Str", "String_Node_Str");
     options.setProperty("String_Node_Str", simpleServerOptions.get("String_Node_Str"));


Input:
private Token getToken(InputStream inputStream) throws IOException {
    if (ch == '\0') {
        ch = nextCharacter(inputStream);
    }
    skipWhitespace(inputStream);
    if (isLabelCharacter(ch)) {
        sb.setLength(0);
        do {
            sb.append(ch);
            ch = nextCharacter(inputStream);
        } while (isLabelCharacter(ch));
        return new Token(ID_TOKEN, sb.toString());
    } else if (ch == '=') {
        ch = nextCharacter(inputStream);
        skipWhitespace(inputStream);
        if (isValueCharacter(ch)) {
            sb.setLength(0);
            do {
                sb.append(ch);
                ch = nextCharacter(inputStream);
            } while (isValueCharacter(ch));
            return new Token(VALUE_TOKEN, sb.toString());
        }
    } else if (ch == '[') {
        ch = nextCharacter(inputStream);
        Token id = getToken(inputStream);
        ch = nextCharacter(inputStream);
        return new Token(SECTION_TOKEN, id.getValue());
    } else if (ch == '#') {
        do {
            ch = nextCharacter(inputStream);
        } while ("String_Node_Str".indexOf(ch) == -1);
        return getToken(inputStream);
    }
    return null;
}

Output:
             ch = nextCharacter(inputStream);
-        } while ("String_Node_Str".indexOf(ch) == -1);
+        } while (!isNewLineCharacter(ch));
         return getToken(inputStream);


Input:
protected boolean rightClick(FakePlayer player, int useItems) {
    if (useItems > 9)
        throw new IllegalArgumentException("String_Node_Str" + useItems + "String_Node_Str");
    ForgeDirection faceDir = getFacingDirection();
    int dx = faceDir.offsetX;
    int dy = faceDir.offsetY;
    int dz = faceDir.offsetZ;
    int x = xCoord + dx;
    int y = yCoord + dy;
    int z = zCoord + dz;
    player.setPosition(x, y, z);
    player.rotationPitch = faceDir.offsetY * -90;
    switch(faceDir) {
        case NORTH:
            player.rotationYaw = 180;
            break;
        case SOUTH:
            player.rotationYaw = 0;
            break;
        case WEST:
            player.rotationYaw = 90;
            break;
        case EAST:
            player.rotationYaw = -90;
    }
    try {
        PlayerInteractEvent event = ForgeEventFactory.onPlayerInteract(player, Action.RIGHT_CLICK_AIR, x, y, z, faceDir.ordinal(), worldObj);
        if (event.isCanceled())
            return false;
        Block block = worldObj.getBlock(x, y, z);
        List<EntityLivingBase> detectedEntities = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, AxisAlignedBB.getBoundingBox(x, y, z, x + 1, y + 1, z + 1));
        Entity entity = detectedEntities.isEmpty() ? null : detectedEntities.get(worldObj.rand.nextInt(detectedEntities.size()));
        if (entity != null) {
            for (int i = 0; i < useItems; i++) {
                player.inventory.currentItem = i;
                ItemStack stack = player.getCurrentEquippedItem();
                if (canDeployItem(stack) && stack.getItem().itemInteractionForEntity(stack, player, (EntityLivingBase) entity))
                    return true;
                if (entity instanceof EntityAnimal && ((EntityAnimal) entity).interact(player))
                    return true;
            }
        }
        for (int i = 0; i < useItems; i++) {
            player.inventory.currentItem = i;
            ItemStack stack = player.getCurrentEquippedItem();
            if (canDeployItem(stack) && stack.getItem().onItemUseFirst(stack, player, worldObj, x, y, z, faceDir.ordinal(), dx, dy, dz))
                return true;
        }
        for (int i = 0; i < useItems; i++) {
            player.inventory.currentItem = i;
            if (!worldObj.isAirBlock(x, y, x) && block.onBlockActivated(worldObj, x, y, z, player, faceDir.ordinal(), dx, dy, dz))
                return true;
        }
        for (int i = 0; i < useItems; i++) {
            player.inventory.currentItem = i;
            ItemStack stack = player.getCurrentEquippedItem();
            if (canDeployItem(stack) && stack.getItem().onItemUse(stack, player, worldObj, x, y, z, faceDir.ordinal(), dx, dy, dz))
                return true;
        }
        for (int i = 0; i < useItems; i++) {
            player.inventory.currentItem = i;
            ItemStack stack = player.getCurrentEquippedItem();
            if (canDeployItem(stack)) {
                ItemStack copy = stack.copy();
                stack.getItem().onItemRightClick(stack, worldObj, player);
                if (!copy.isItemEqual(stack))
                    return true;
            }
        }
        return false;
    } catch (Throwable e) {
        BluePower.log.error("String_Node_Str");
        e.printStackTrace();
        return true;
    }
}

Output:
             ItemStack stack = player.getCurrentEquippedItem();
-            if (canDeployItem(stack) && stack.getItem().onItemUseFirst(stack, player, worldObj, x, y, z, faceDir.ordinal(), dx, dy, dz))
+            if (canDeployItem(stack) && stack.getItem().onItemUseFirst(stack, player, worldObj, xCoord, yCoord, zCoord, faceDir.ordinal(), dx, dy, dz))
                 return true;


Input:
private static boolean isDirectAncestor(int currentIp, int ancestor, HashMap<Integer, List<Integer>> refs, List<Integer> visited) {
    do {
        if (currentIp == ancestor) {
            return true;
        }
        if (visited.contains(currentIp)) {
            return false;
        }
        visited.add(currentIp);
        if (refs.containsKey(currentIp)) {
            List<Integer> currentRefs = refs.get(currentIp);
            if ((currentRefs != null) && (!currentRefs.isEmpty())) {
                for (int i = 1; i < currentRefs.size(); i++) {
                    if (!isDirectAncestor(currentRefs.get(i), ancestor, refs, visited)) {
                        return false;
                    }
                }
                currentIp = currentRefs.get(0);
                continue;
            }
        }
        currentIp--;
    } while (currentIp >= 0);
    return false;
}

Output:
         if (visited.contains(currentIp)) {
-            return false;
+            return true;
         }


Input:
public Object extractData(final ResultSet rs) throws SQLException, DataAccessException {
    while (rs.next()) {
        try {
            final Geometry geom = wktReader.read(rs.getString("String_Node_Str"));
            if (!geom.isEmpty()) {
                ret.add(new IntersectionResult(rs.getString("String_Node_Str"), rs.getString("String_Node_Str"), (Point) geom));
            }
        } catch (final ParseException e) {
            throw new DataRetrievalFailureException("String_Node_Str");
        }
    }
    return null;
}

Output:
             if (!geom.isEmpty()) {
-                ret.add(new IntersectionResult(rs.getString("String_Node_Str"), rs.getString("String_Node_Str"), (Point) geom));
+                if (geom instanceof Point) {
+                    ret.add(new IntersectionResult(rs.getString("String_Node_Str"), rs.getString("String_Node_Str"), (Point) geom));
+                }
             }


Input:
public void setStatus(CellStatus status, boolean increasing) {
    super.setStatus(status, increasing);
    logger.info("String_Node_Str" + status + "String_Node_Str" + increasing);
    if (status == CellStatus.ACTIVE && increasing == true) {
        if (cellMoveListener != null) {
            cell.getComponent(MovableComponent.class).removeServerCellMoveListener(cellMoveListener);
            cellMoveListener = null;
        }
        if (avatarCharacter == null) {
            AvatarConfigComponent configComp = cell.getComponent(AvatarConfigComponent.class);
            AvatarConfigInfo avatarConfigInfo = null;
            if (configComp != null) {
                avatarConfigInfo = configComp.getAvatarConfigInfo();
            }
            logger.info("String_Node_Str" + avatarConfigInfo);
            pendingAvatar = loadAvatar(avatarConfigInfo);
        } else {
            ClientContextJME.getWorldManager().removeEntity(avatarCharacter);
            pendingAvatar = null;
        }
        logger.info("String_Node_Str");
        changeAvatar(pendingAvatar);
        if (cellMoveListener == null) {
            cellMoveListener = new CellMoveListener() {
                public void cellMoved(CellTransform transform, CellMoveSource source) {
                    if (source == CellMoveSource.REMOTE) {
                        if (avatarCharacter != null) {
                            if (avatarCharacter.getModelInst() == null) {
                                logger.severe("String_Node_Str");
                                Thread.dumpStack();
                                return;
                            }
                            avatarCharacter.getModelInst().setTransform(new PTransform(transform.getRotation(null), transform.getTranslation(null), new Vector3f(1, 1, 1)));
                        }
                    }
                }
            };
        }
        cell.getComponent(MovableComponent.class).addServerCellMoveListener(cellMoveListener);
    }
}

Output:
         if (cellMoveListener != null) {
-            cell.getComponent(MovableComponent.class).removeServerCellMoveListener(cellMoveListener);
+            MovableComponent mc = cell.getComponent(MovableComponent.class);
+            if (mc == null) {
+                logger.severe("String_Node_Str" + ((AvatarCell) cell).getName());
+            } else {
+                mc.removeServerCellMoveListener(cellMoveListener);
+            }
             cellMoveListener = null;


Input:
public void resetInheritedFacets(DocumentModel model) throws Exception {
    SchemaManager schemaManager = Framework.getService(SchemaManager.class);
    for (String inheritedFacet : getInheritedFacets(model.getFacets())) {
        CompositeType facetToReset = schemaManager.getFacet(inheritedFacet);
        for (Schema schemaToReset : facetToReset.getSchemas()) {
            for (Field fieldToReset : schemaToReset.getFields()) {
                model.setPropertyValue(fieldToReset.getName().toString(), null);
            }
        }
    }
}

Output:
         CompositeType facetToReset = schemaManager.getFacet(inheritedFacet);
-        for (Schema schemaToReset : facetToReset.getSchemas()) {
-            for (Field fieldToReset : schemaToReset.getFields()) {
-                model.setPropertyValue(fieldToReset.getName().toString(), null);
+        InheritedFacetDescriptor inheritedFacetDesc = inheritedFacets.get(inheritedFacet);
+        boolean isFacetInherited = false;
+        for (TransferLogic transferLogic : inheritedFacetDesc.transferLogicList) {
+            if (model.getType().equals(transferLogic.to)) {
+                isFacetInherited = true;
+                break;
+            }
+        }
+        if (isFacetInherited) {
+            for (Schema schemaToReset : facetToReset.getSchemas()) {
+                for (Field fieldToReset : schemaToReset.getFields()) {
+                    model.setPropertyValue(fieldToReset.getName().toString(), null);
+                }
             }


Input:
private AttributeMetadata buildAttributeMetadata(Class<?> configClass, Config config, Method configMethod) {
    if (config.value() == null || config.value().isEmpty()) {
        errors.add("String_Node_Str", configMethod.toGenericString());
        return null;
    }
    String description = null;
    if (configMethod.isAnnotationPresent(ConfigDescription.class)) {
        description = configMethod.getAnnotation(ConfigDescription.class).value();
    }
    String attributeName = configMethod.getName();
    if (attributeName.startsWith("String_Node_Str")) {
        attributeName = attributeName.substring(3);
        if (configMethod.getParameterTypes().length != 1) {
            errors.add("String_Node_Str", configMethod.toGenericString());
        }
        Method getter = null;
        try {
            getter = configClass.getMethod("String_Node_Str" + attributeName);
        } catch (Exception ignored) {
        }
        return new AttributeMetadata(configClass, attributeName, description, config.value(), getter, configMethod);
    } else if (attributeName.startsWith("String_Node_Str")) {
        attributeName = attributeName.substring(3);
        if (configMethod.getParameterTypes().length != 0) {
            errors.add("String_Node_Str", configMethod.toGenericString());
        }
        if (configMethod.getReturnType() == Void.TYPE) {
            errors.add("String_Node_Str", configMethod.toGenericString());
        }
        Method setter = findSetter(configClass, configMethod, attributeName);
        if (setter == null) {
            return null;
        }
        return new AttributeMetadata(configClass, attributeName, description, config.value(), configMethod, setter);
    } else if (attributeName.startsWith("String_Node_Str")) {
        attributeName = attributeName.substring(2);
        if (configMethod.getParameterTypes().length != 0) {
            errors.add("String_Node_Str", configMethod.toGenericString());
        }
        if (!configMethod.getReturnType().equals(boolean.class) && !configMethod.getReturnType().equals(Boolean.class)) {
            errors.add("String_Node_Str", configMethod.toGenericString());
        }
        Method setter = findSetter(configClass, configMethod, attributeName);
        if (setter == null) {
            return null;
        }
        return new AttributeMetadata(configClass, attributeName, description, config.value(), configMethod, setter);
    } else {
        errors.add("String_Node_Str", configMethod.toGenericString());
        return null;
    }
}

Output:
         }
-        Method setter = findSetter(configClass, configMethod, attributeName);
-        if (setter == null) {
-            return null;
+        Method setter = null;
+        if (!legacy) {
+            setter = findSetter(configClass, configMethod, attributeName);
+            if (setter == null) {
+                return null;
+            }
         }


Input:
public String stringize() {
    String content = "String_Node_Str";
    int contentLength = 0;
    if (m_payload != null) {
        content = Utility.byteArrayToString(m_payload);
        contentLength = m_payload.length;
    }
    return String.format("String_Node_Str", m_from, m_to, m_type, m_connId, m_seqNum, contentLength, content);
}

Output:
     }
-    return String.format("String_Node_Str", m_from, m_to, m_type, m_connId, m_seqNum, contentLength, content);
+    return String.format("String_Node_Str", m_from, m_to, m_type, m_connId, m_seqNum, m_minSeq, contentLength, content);
 }


Input:
private void handleTorch(TileData tile, Node pageNode) {
    String name = null;
    float angleY = 0;
    Vector3f position = Vector3f.ZERO;
    if (tile.getY() % 2 == 0 && tile.getX() % 2 != 0 && canPlaceTorch(tile.getX(), tile.getY() - 1)) {
        name = "String_Node_Str";
        angleY = -FastMath.HALF_PI;
        position = new Vector3f(0, TORCH_HEIGHT, -TILE_WIDTH / 2);
    } else if (tile.getX() % 2 == 0 && tile.getY() % 2 == 0 && canPlaceTorch(tile.getX() - 1, tile.getY())) {
        name = "String_Node_Str";
        position = new Vector3f(-TILE_WIDTH / 2, TORCH_HEIGHT, 0);
    } else if (tile.getY() % 2 == 0 && tile.getX() % 2 != 0 && canPlaceTorch(tile.getX(), tile.getY() + 1)) {
        name = "String_Node_Str";
        angleY = FastMath.HALF_PI;
        position = new Vector3f(0, TORCH_HEIGHT, TILE_WIDTH / 2);
    } else if (tile.getX() % 2 == 0 && tile.getY() % 2 == 0 && canPlaceTorch(tile.getX() + 1, tile.getY())) {
        name = "String_Node_Str";
        angleY = FastMath.PI;
        position = new Vector3f(TILE_WIDTH / 2, TORCH_HEIGHT, 0);
    }
    if (name != null) {
        Spatial spatial = AssetUtils.loadModel(assetManager, name);
        spatial.addControl(new TorchControl(kwdFile, assetManager, angleY));
        spatial.rotate(0, angleY, 0);
        spatial.move(position);
        AssetUtils.moveToTile(spatial, tile.getLocation());
        ((Node) getTileNode(tile.getLocation(), (Node) pageNode.getChild(WALL_INDEX))).attachChild(spatial);
    }
}

Output:
         spatial.rotate(0, angleY, 0);
-        spatial.move(position);
-        AssetUtils.moveToTile(spatial, tile.getLocation());
+        spatial.setLocalTranslation(WorldUtils.pointToVector3f(tile.getLocation()).addLocal(position));
         ((Node) getTileNode(tile.getLocation(), (Node) pageNode.getChild(WALL_INDEX))).attachChild(spatial);


Input:
public boolean validate() {
    cleanWarnings();
    cleanErrors();
    boolean valid = true;
    if (getId() == null) {
        addError("String_Node_Str");
        valid = false;
    }
    if (!hasDescriptor() && !hasBind()) {
        addError("String_Node_Str");
        valid = false;
    }
    if (hasBind()) {
        for (B bind : binds) {
            valid &= bind.validate();
            addWarning(bind.getWarnings());
            addError(bind.getErrors());
        }
    }
    if (hasDescriptor()) {
        for (D desc : descriptors) {
            valid &= desc.validate();
            addWarning(desc.getWarnings());
            addError(desc.getErrors());
        }
    }
    if (getDefaultDescriptor() != null) {
        if (!(getDefaultDescriptor().getParent() instanceof NCLDescriptorSwitch)) {
            addError("String_Node_Str");
            valid = false;
        } else if (((NCLDescriptorSwitch) getDefaultDescriptor().getParent()).compareTo(this) != 0) {
            addError("String_Node_Str");
            valid = false;
        }
    }
    return valid;
}

Output:
     }
-    if (!hasDescriptor() && !hasBind()) {
+    if (!hasDescriptor() || !hasBind()) {
         addError("String_Node_Str");


Input:
private File getResizedImage(final String realPath, final int initialWidth, final int initialHeight) {
    Bitmap photo = BitmapFactory.decodeFile(realPath);
    if (photo == null) {
        return null;
    }
    Bitmap scaledphoto = null;
    if (maxWidth == 0) {
        maxWidth = initialWidth;
    }
    if (maxHeight == 0) {
        maxHeight = initialHeight;
    }
    double widthRatio = (double) maxWidth / initialWidth;
    double heightRatio = (double) maxHeight / initialHeight;
    double ratio = (widthRatio < heightRatio) ? widthRatio : heightRatio;
    Matrix matrix = new Matrix();
    matrix.postRotate(angle);
    matrix.postScale((float) ratio, (float) ratio);
    ExifInterface exif;
    try {
        exif = new ExifInterface(realPath);
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
        if (orientation == 6) {
            matrix.postRotate(90);
        } else if (orientation == 3) {
            matrix.postRotate(180);
        } else if (orientation == 8) {
            matrix.postRotate(270);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    scaledphoto = Bitmap.createBitmap(photo, 0, 0, photo.getWidth(), photo.getHeight(), matrix, true);
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    scaledphoto.compress(Bitmap.CompressFormat.JPEG, quality, bytes);
    File f = createNewFile(false);
    FileOutputStream fo;
    try {
        fo = new FileOutputStream(f);
        try {
            fo.write(bytes.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    if (photo != null) {
        scaledphoto.recycle();
        photo.recycle();
        scaledphoto = null;
        photo = null;
    }
    return f;
}

Output:
 private File getResizedImage(final String realPath, final int initialWidth, final int initialHeight) {
-    Bitmap photo = BitmapFactory.decodeFile(realPath);
+    Options options = new BitmapFactory.Options();
+    options.inScaled = false;
+    Bitmap photo = BitmapFactory.decodeFile(realPath, options);
     if (photo == null) {


Input:
public static void generateGlueCodeForJNIMethod(VM_Assembler asm, VM_Method mth) {
    int offset;
    asm.emitSTAddrU(FP, -JNI_GLUE_FRAME_SIZE, FP);
    String mthName = mth.getName().toString();
    if ((mthName.startsWith("String_Node_Str") && mthName.endsWith("String_Node_Str")) || mthName.equals("String_Node_Str")) {
        offset = STACKFRAME_HEADER_SIZE + 3 * BYTES_IN_STACKSLOT;
        for (int i = 6; i <= 10; i++) {
            asm.emitSTAddr(i, offset, FP);
            offset += BYTES_IN_ADDRESS;
        }
        for (int i = 1; i <= 3; i++) {
            asm.emitSTFD(i, offset, FP);
            offset += BYTES_IN_DOUBLE;
        }
        offset = STACKFRAME_HEADER_SIZE + 0;
        for (int i = FIRST_OS_PARAMETER_GPR; i <= LAST_OS_PARAMETER_GPR; i++) {
            asm.emitSTAddr(i, offset, FP);
            offset += BYTES_IN_ADDRESS;
        }
        for (int i = FIRST_OS_PARAMETER_FPR; i <= LAST_OS_PARAMETER_FPR; i++) {
            asm.emitSTFD(i, offset, FP);
            offset += BYTES_IN_DOUBLE;
        }
    } else {
        convertParameterFromSVR4ToJava(asm, mth);
    }
    offset = STACKFRAME_HEADER_SIZE + JNI_GLUE_SAVED_VOL_SIZE;
    for (int i = FIRST_OS_NONVOLATILE_GPR; i < FIRST_NONVOLATILE_GPR; i++) {
        asm.emitSTAddr(i, offset, FP);
        offset += BYTES_IN_ADDRESS;
    }
    asm.emitLVAL(S0, INVISIBLE_METHOD_ID);
    asm.emitMFLR(REGISTER_ZERO);
    asm.emitSTW(S0, STACKFRAME_METHOD_ID_OFFSET, FP);
    asm.emitSTAddr(REGISTER_ZERO, JNI_GLUE_FRAME_SIZE + STACKFRAME_NEXT_INSTRUCTION_OFFSET, FP);
    asm.emitADDI(T0, -VM_Entrypoints.JNIExternalFunctionsField.getOffset(), T0);
    int retryLoop = asm.getMachineCodeIndex();
    asm.emitLAddr(PROCESSOR_REGISTER, VM_Entrypoints.JNIEnvSavedPRField.getOffset(), T0);
    asm.emitLAddr(JTOC, VM_Entrypoints.JNIEnvSavedJTOCField.getOffset(), T0);
    asm.emitLVAL(S1, VM_Entrypoints.vpStatusField.getOffset());
    asm.emitLWARX(S0, S1, PROCESSOR_REGISTER);
    asm.emitCMPI(S0, VM_Processor.BLOCKED_IN_NATIVE);
    VM_ForwardReference frBlocked = asm.emitForwardBC(EQ);
    asm.emitLVAL(S0, VM_Processor.IN_JAVA);
    asm.emitSTWCXr(S0, S1, PROCESSOR_REGISTER);
    asm.emitBC(NE, retryLoop);
    VM_ForwardReference frInJava = asm.emitForwardB();
    frBlocked.resolve(asm);
    offset = STACKFRAME_HEADER_SIZE;
    for (int i = FIRST_OS_PARAMETER_GPR; i <= LAST_OS_PARAMETER_GPR; i++) {
        asm.emitSTAddr(i, offset, FP);
        offset += BYTES_IN_ADDRESS;
    }
    for (int i = FIRST_OS_PARAMETER_FPR; i <= LAST_OS_VARARG_PARAMETER_FPR; i++) {
        asm.emitSTFD(i, offset, FP);
        offset += BYTES_IN_DOUBLE;
    }
    asm.emitLAddr(S1, VM_Entrypoints.the_boot_recordField.getOffset(), JTOC);
    asm.emitMR(PROCESSOR_REGISTER, JTOC);
    asm.emitLAddr(JTOC, VM_Entrypoints.sysTOCField.getOffset(), S1);
    asm.emitLAddr(KLUDGE_TI_REG, VM_Entrypoints.sysVirtualProcessorYieldIPField.getOffset(), S1);
    asm.emitMTLR(KLUDGE_TI_REG);
    asm.emitBCLRL();
    asm.emitMR(JTOC, PROCESSOR_REGISTER);
    offset = STACKFRAME_HEADER_SIZE;
    for (int i = FIRST_OS_PARAMETER_GPR; i <= LAST_OS_PARAMETER_GPR; i++) {
        asm.emitLAddr(i, offset, FP);
        offset += BYTES_IN_ADDRESS;
    }
    for (int i = FIRST_OS_PARAMETER_FPR; i <= LAST_OS_VARARG_PARAMETER_FPR; i++) {
        asm.emitLFD(i, offset, FP);
        offset += BYTES_IN_DOUBLE;
    }
    asm.emitB(retryLoop);
    frInJava.resolve(asm);
    asm.emitLAddr(S0, VM_Entrypoints.JNITopJavaFPField.getOffset(), T0);
    asm.emitSUBFC(S0, FP, S0);
    asm.emitSTW(S0, JNI_GLUE_FRAME_SIZE + JNI_GLUE_OFFSET_TO_PREV_JFRAME, FP);
    VM_ForwardReference frNormalPrologue = asm.emitForwardBL();
    asm.emitLAddr(T2, VM_Entrypoints.activeThreadField.getOffset(), PROCESSOR_REGISTER);
    asm.emitLAddr(T2, VM_Entrypoints.jniEnvField.getOffset(), T2);
    asm.emitLInt(T3, JNI_GLUE_FRAME_SIZE + JNI_GLUE_OFFSET_TO_PREV_JFRAME, FP);
    asm.emitADD(T3, FP, T3);
    asm.emitSTAddr(T3, VM_Entrypoints.JNITopJavaFPField.getOffset(), T2);
    asm.emitCMPAddrI(T3, VM_Constants.STACKFRAME_SENTINEL_FP.toInt());
    VM_ForwardReference fr4 = asm.emitForwardBC(EQ);
    asm.emitLAddr(S0, 0, T3);
    fr4.resolve(asm);
    asm.emitSTAddr(PROCESSOR_REGISTER, VM_Entrypoints.JNIEnvSavedPRField.getOffset(), T2);
    asm.emitLVAL(S0, VM_Processor.IN_NATIVE);
    asm.emitSTW(S0, VM_Entrypoints.vpStatusField.getOffset(), PROCESSOR_REGISTER);
    offset = STACKFRAME_HEADER_SIZE + JNI_GLUE_SAVED_VOL_SIZE;
    for (int i = FIRST_OS_NONVOLATILE_GPR; i < FIRST_NONVOLATILE_GPR; i++) {
        asm.emitLAddr(i, offset, FP);
        offset += BYTES_IN_ADDRESS;
    }
    asm.emitADDI(FP, JNI_GLUE_FRAME_SIZE, FP);
    asm.emitLAddr(T2, STACKFRAME_NEXT_INSTRUCTION_OFFSET, FP);
    asm.emitMTLR(T2);
    asm.emitBCLR();
    frNormalPrologue.resolve(asm);
}

Output:
     offset = STACKFRAME_HEADER_SIZE + JNI_GLUE_SAVED_VOL_SIZE;
-    for (int i = FIRST_OS_NONVOLATILE_GPR; i < FIRST_NONVOLATILE_GPR; i++) {
+    for (int i = FIRST_RVM_RESERVED_NV_GPR; i <= LAST_RVM_RESERVED_NV_GPR; i++) {
         asm.emitSTAddr(i, offset, FP);


Input:
public DataHandle getHandle(final ARXNode fnode) {
    currentNode = fnode;
    if ((currentNode != null) && (currentNode == lastNode)) {
        return this;
    }
    lastNode = currentNode;
    final Node node = new Node(new IDGenerator());
    node.setTransformation(fnode.getTransformation(), 0);
    if (currentNode.isChecked()) {
        node.setChecked();
    }
    checker.transformAndMarkOutliers(node);
    if (!currentNode.isChecked()) {
        currentNode.access().setChecked(true);
        if (node.isAnonymous()) {
            currentNode.access().setAnonymous();
        } else {
            currentNode.access().setNotAnonymous();
        }
        currentNode.access().setMaximumInformationLoss(node.getInformationLoss());
        currentNode.access().setMinimumInformationLoss(node.getInformationLoss());
        lattice.estimateInformationLoss();
    }
    createDataTypeArray();
    return this;
}

Output:
     lastNode = currentNode;
-    final Node node = new Node(new IDGenerator());
+    final Node node = new Node(0);
     node.setTransformation(fnode.getTransformation(), 0);


Input:
public void transform(Transformer transformer) {
    AbstractTransformer abstractTransformer = (AbstractTransformer) transformer;
    Ranking ranking = abstractTransformer.getRanking();
    RankingResultImpl rankingResult = new RankingResultImpl();
    rankingResult.transformer = transformer;
    rankingResult.ranking = ranking;
    Graph graph = Lookup.getDefault().lookup(GraphController.class).getModel().getGraph();
    if (ranking instanceof NodeRanking) {
        for (Node node : graph.getNodes().toArray()) {
            Object rank = ranking.getValue(node);
            Object result = null;
            if (rank != null) {
                float normalizedValue = ranking.normalize(rank);
                if (transformer.isInBounds(normalizedValue)) {
                    result = transformer.transform(node, normalizedValue);
                }
            }
            rankingResult.addResult(node, rank, result);
        }
    } else {
        for (Edge edge : graph.getEdges().toArray()) {
            Object rank = ranking.getValue(edge);
            Object result = null;
            if (rank != null) {
                float normalizedValue = ranking.normalize(rank);
                if (transformer.isInBounds(normalizedValue)) {
                    result = transformer.transform(edge, normalizedValue);
                }
            }
            rankingResult.addResult(edge, rank, result);
        }
    }
    rankingEventBus.publishResults(rankingResult);
}

Output:
     rankingResult.ranking = ranking;
-    Graph graph = Lookup.getDefault().lookup(GraphController.class).getModel().getGraph();
+    Graph graph = Lookup.getDefault().lookup(GraphController.class).getModel().getGraphVisible();
     if (ranking instanceof NodeRanking) {


Input:
public ArrayList getNoAccessTypePropertiesForClass(JavaClass cls, TypeInfo info) {
    ArrayList list = new ArrayList();
    if (cls == null) {
        return list;
    }
    ArrayList fieldProperties = getFieldPropertiesForClass(cls, info, false);
    ArrayList methodProperties = getPropertyPropertiesForClass(cls, info, false);
    for (int i = 0; i < fieldProperties.size(); i++) {
        Property next = (Property) fieldProperties.get(i);
        JavaHasAnnotations elem = next.getElement();
        if (hasJAXBAnnotations(elem)) {
            list.add(next);
        }
    }
    for (int i = 0; i < methodProperties.size(); i++) {
        Property next = (Property) methodProperties.get(i);
        JavaHasAnnotations elem = next.getElement();
        if (hasJAXBAnnotations(elem)) {
            list.add(next);
        }
    }
    return list;
}

Output:
         JavaHasAnnotations elem = next.getElement();
-        if (hasJAXBAnnotations(elem)) {
-            list.add(next);
+        if (!hasJAXBAnnotations(elem)) {
+            next.setTransient(true);
         }


Input:
public void onSaveInstanceState(Bundle outState) {
    outState.putInt("String_Node_Str", mPairsSpinner.getSelectedItemPosition());
}

Output:
 public void onSaveInstanceState(Bundle outState) {
-    outState.putInt("String_Node_Str", mPairsSpinner.getSelectedItemPosition());
+    if (mPairsSpinner != null) {
+        outState.putInt("String_Node_Str", mPairsSpinner.getSelectedItemPosition());
+    }
 }


Input:
Address getTarget(String name, Data key) {
    int blockId = getBlockId(key);
    Block block = mapBlocks.get(blockId);
    if (block == null) {
        if (isMaster() && !isSuperClient()) {
            block = getOrCreateBlock(blockId);
            block.owner = thisAddress;
        } else
            return null;
    }
    if (block.isMigrating())
        return null;
    if (block.owner == null)
        return null;
    if (block.owner.equals(thisAddress)) {
        if (block.isMigrating()) {
            if (name == null)
                return block.migrationAddress;
            CMap map = getMap(name);
            Record record = map.getRecord(key);
            if (record == null)
                return block.migrationAddress;
            else {
                Address recordOwner = record.getOwner();
                if (recordOwner == null)
                    return thisAddress;
                if ((!recordOwner.equals(thisAddress)) && (!recordOwner.equals(block.migrationAddress))) {
                    record.setOwner(thisAddress);
                }
                return record.getOwner();
            }
        }
    } else if (thisAddress.equals(block.migrationAddress)) {
        if (name == null)
            return thisAddress;
        CMap map = getMap(name);
        Record record = map.getRecord(key);
        if (record == null)
            return thisAddress;
        else
            return record.getOwner();
    }
    return block.owner;
}

Output:
             else {
-                Address recordOwner = record.getOwner();
+                Address recordOwner = record.owner;
                 if (recordOwner == null)


Input:
protected InputStream getLocalInputStreamForAsset(String name) {
    InputStream is = null;
    try {
        try {
            is = apkContext.getAssets().open(name);
        } catch (Exception e) {
            e.printStackTrace();
            is = getAssets().open(name);
        }
        if (is == null) {
            System.out.println("String_Node_Str");
            is = getAssets().open(name);
        }
        return is;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

Output:
         try {
-            is = apkContext.getAssets().open(name);
+            if (name.charAt(0) == '/')
+                is = new FileInputStream(new File(name));
+            else
+                is = apkContext.getAssets().open(name);
         } catch (Exception e) {


Input:
public String stringFromImage(Image image, QName schemaTypeQName, AbstractSession session) {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    try {
        String mimeType = null;
        if ((mimeType == null) || mimeType.startsWith("String_Node_Str")) {
            mimeType = "String_Node_Str";
        }
        Iterator itr = ImageIO.getImageWritersByMIMEType(mimeType);
        if (itr.hasNext()) {
            ImageWriter w = (ImageWriter) itr.next();
            w.setOutput(ImageIO.createImageOutputStream(outputStream));
            w.write(convertToBufferedImage(image));
            w.dispose();
        } else {
            throw new RuntimeException("String_Node_Str" + mimeType);
        }
        return ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).buildBase64StringFromBytes(outputStream.toByteArray());
    } catch (Exception ex) {
    }
    return null;
}

Output:
         } else {
-            throw new RuntimeException("String_Node_Str" + mimeType);
+            throw XMLMarshalException.noEncoderForMimeType(mimeType);
         }


Input:
private Timestamp stringToTimestamp(String stringValue) throws OdaException {
    testClosed();
    if (stringValue != null) {
        try {
            long timeMills = new Long(stringValue).longValue();
            return new Timestamp(timeMills);
        } catch (NumberFormatException e1) {
            try {
                java.util.Date date = DateUtil.toDate(stringValue);
                Timestamp timeStamp = new Timestamp(date.getTime());
                return timeStamp;
            } catch (OdaException oe) {
                this.wasNull = true;
                return null;
            }
        }
    }
    this.wasNull = true;
    return null;
}

Output:
         try {
-            long timeMills = new Long(stringValue).longValue();
-            return new Timestamp(timeMills);
-        } catch (NumberFormatException e1) {
+            stringValue = stringValue.replaceAll("String_Node_Str", "String_Node_Str").split("String_Node_Str")[0];
+            return Timestamp.valueOf(stringValue);
+        } catch (IllegalArgumentException e) {
             try {


Input:
public void handleReceived(ClientConnection connection) {
    TridentPlayer player = ((PlayerConnection) connection).getPlayer();
    this.location.setWorld(player.getWorld());
    Coordinates from = player.getLocation();
    Coordinates to = this.location;
    PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
    TridentServer.getInstance().getEventHandler().call(event);
    if (event.isIgnored()) {
        PacketPlayOutEntityTeleport cancel = new PacketPlayOutEntityTeleport();
        cancel.set("String_Node_Str", player.getId()).set("String_Node_Str", from).set("String_Node_Str", player.isOnGround());
        TridentPlayer.sendAll(cancel);
        return;
    }
    player.setLocation(to);
    Packet move = new PacketPlayOutEntityCompleteMove();
    TridentPlayer.sendAll(move);
}

Output:
     PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
-    TridentServer.getInstance().getEventHandler().call(event);
+    TridentServer.getInstance().eventHandler().call(event);
     if (event.isIgnored()) {


Input:
public DataSource getConfiguredDataSource(DerbyDbBackendConfiguration configuration, String poolName) {
    DataSource dataSource;
    if (configuration.embedded()) {
        EmbeddedDataSource embeddedDataSource = new EmbeddedDataSource();
        embeddedDataSource.setCreateDatabase("String_Node_Str");
        if (configuration.inMemory()) {
            embeddedDataSource.setDatabaseName("String_Node_Str" + configuration.getDbName());
        } else {
            embeddedDataSource.setDatabaseName(configuration.getDbName());
        }
        try {
            embeddedDataSource.getConnection();
        } catch (SQLException ex) {
            throw new SystemException(ex);
        }
        embeddedDataSource.setCreateDatabase(null);
        dataSource = embeddedDataSource;
    } else {
        ClientDataSource clientDataSource = new ClientDataSource();
        clientDataSource.setServerName(configuration.getDbHost());
        clientDataSource.setPortNumber(configuration.getDbPort());
        clientDataSource.setUser(configuration.getUsername());
        clientDataSource.setPassword(configuration.getPassword());
        if (configuration.inMemory()) {
            clientDataSource.setDatabaseName("String_Node_Str" + configuration.getDbName());
        } else {
            clientDataSource.setDatabaseName(configuration.getDbName());
        }
        dataSource = clientDataSource;
    }
    if (LOGGER.isTraceEnabled()) {
        try {
            dataSource.setLogWriter(LOGGER_WRITER);
        } catch (SQLException sqlException) {
            throw new SystemException(sqlException);
        }
    }
    Statement stat = null;
    ResultSet rs = null;
    Connection conn = null;
    try {
        conn = dataSource.getConnection();
        stat = conn.createStatement();
        rs = stat.executeQuery("String_Node_Str");
        rs.next();
    } catch (SQLException ex) {
        throw new SystemException(ex);
    } finally {
        try {
            if (rs != null)
                rs.close();
        } catch (SQLException ex) {
        }
        try {
            if (stat != null)
                stat.close();
        } catch (SQLException ex) {
        }
        try {
            if (conn != null)
                conn.close();
        } catch (SQLException ex) {
        }
    }
    return dataSource;
}

Output:
         }
-        try {
-            embeddedDataSource.getConnection();
+        try (Connection connection = embeddedDataSource.getConnection()) {
+            LOGGER.debug("String_Node_Str");
         } catch (SQLException ex) {


Input:
protected ColumnIndicator[] getPredefinedColumnIndicator() {
    IndicatorEnum[] allwedEnumes = new IndicatorEnum[5];
    allwedEnumes[0] = IndicatorEnum.CountsIndicatorEnum;
    allwedEnumes[1] = IndicatorEnum.MinValueIndicatorEnum;
    allwedEnumes[2] = IndicatorEnum.MaxValueIndicatorEnum;
    allwedEnumes[3] = IndicatorEnum.LowFrequencyIndicatorEnum;
    allwedEnumes[4] = IndicatorEnum.FrequencyIndicatorEnum;
    ColumnIndicator[] returnColumnIndicator = composePredefinedColumnIndicator(allwedEnumes);
    if (parameters != null) {
        for (ColumnIndicator columnIndicator : returnColumnIndicator) {
            for (Indicator indicator : columnIndicator.getIndicators()) {
                if (indicator instanceof FrequencyIndicator) {
                    indicator.setParameters(parameters);
                }
            }
        }
    }
    return returnColumnIndicator;
}

Output:
 protected ColumnIndicator[] getPredefinedColumnIndicator() {
-    IndicatorEnum[] allwedEnumes = new IndicatorEnum[5];
-    allwedEnumes[0] = IndicatorEnum.CountsIndicatorEnum;
-    allwedEnumes[1] = IndicatorEnum.MinValueIndicatorEnum;
-    allwedEnumes[2] = IndicatorEnum.MaxValueIndicatorEnum;
-    allwedEnumes[3] = IndicatorEnum.LowFrequencyIndicatorEnum;
-    allwedEnumes[4] = IndicatorEnum.FrequencyIndicatorEnum;
+    IndicatorEnum[] allwedEnumes = new IndicatorEnum[2];
+    allwedEnumes[0] = IndicatorEnum.LowFrequencyIndicatorEnum;
+    allwedEnumes[1] = IndicatorEnum.FrequencyIndicatorEnum;
     ColumnIndicator[] returnColumnIndicator = composePredefinedColumnIndicator(allwedEnumes);


Input:
public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
    Context context = holder.itemView.getContext();
    holder.itemView.setOnClickListener(new View.OnClickListener() {
        public void onClick(View view) {
            if (listener != null)
                listener.onClick(position);
        }
    });
    DrawerItem drawerItem = drawerItems.get(position);
    switch(drawerItem.getType()) {
        case HEADER:
            DrawerHeader drawerHeader = (DrawerHeader) drawerItem;
            if (drawerHeader.getUser() != null) {
                HeaderViewHolder headerViewHolder = (HeaderViewHolder) holder;
                String userFullName = drawerHeader.getUser().getLastName() == null || drawerHeader.getUser().getLastName().trim().isEmpty() ? drawerHeader.getUser().getName() : new StringBuilder().append(drawerHeader.getUser().getName()).append("String_Node_Str").append(drawerHeader.getUser().getLastName()).toString();
                headerViewHolder.userNameTextView.setText(userFullName);
                Picasso.with(context).load(drawerHeader.getUser().getPhotoUrl()).placeholder(R.drawable.ic_contact_picture).into(headerViewHolder.profileImageView);
            }
            break;
        case OPTION:
            DrawerOption drawerOption = (DrawerOption) drawerItem;
            OptionViewHolder optionViewHolder = (OptionViewHolder) holder;
            optionViewHolder.nameTextView.setText(drawerOption.getNameRes());
            if (selectedPosition != null && selectedPosition == position) {
                optionViewHolder.itemView.setBackgroundColor(context.getResources().getColor(R.color.selected_background));
                optionViewHolder.nameTextView.setTextColor(context.getResources().getColor(R.color.primary_selected_text));
                Drawable selectedIcon = context.getDrawable(drawerOption.getSelectedIconRes());
                selectedIcon.mutate().setColorFilter(context.getResources().getColor(R.color.selected_icon), PorterDuff.Mode.SRC_IN);
                optionViewHolder.iconImageView.setImageDrawable(selectedIcon);
            } else {
                optionViewHolder.itemView.setBackgroundColor(context.getResources().getColor(R.color.unselected_background));
                optionViewHolder.nameTextView.setTextColor(context.getResources().getColor(R.color.primary_text));
                optionViewHolder.iconImageView.setImageResource(drawerOption.getUnselectedIconRes());
            }
            break;
        case OPTION_HEADER:
            DrawerOptionHeader drawerOptionHeader = (DrawerOptionHeader) drawerItem;
            OptionHeaderViewHolder optionHeaderViewHolder = (OptionHeaderViewHolder) holder;
            optionHeaderViewHolder.nameTextView.setText(drawerOptionHeader.getNameRes());
            break;
    }
}

Output:
                 optionViewHolder.nameTextView.setTextColor(context.getResources().getColor(R.color.primary_selected_text));
-                Drawable selectedIcon = context.getDrawable(drawerOption.getSelectedIconRes());
+                Drawable selectedIcon = context.getResources().getDrawable(drawerOption.getSelectedIconRes());
                 selectedIcon.mutate().setColorFilter(context.getResources().getColor(R.color.selected_icon), PorterDuff.Mode.SRC_IN);


Input:
public String visitExecutable(ExecutableElement e, Void _) {
    StringBuilder buf = new StringBuilder();
    if (e.getKind() == ElementKind.CONSTRUCTOR)
        buf.append(e.getEnclosingElement().getSimpleName());
    else
        buf.append(e.getSimpleName());
    buf.append('(');
    boolean first = true;
    for (VariableElement p : e.getParameters()) {
        if (first)
            first = false;
        else
            buf.append(',');
        buf.append(p.asType().accept(ShortNameVisitor.INSTANCE, null));
    }
    buf.append(')');
    if (e.getKind() != ElementKind.CONSTRUCTOR) {
        buf.append(':');
        buf.append(e.getReturnType().accept(javadocErasure, null));
    }
    return buf.toString();
}

Output:
         buf.append(':');
-        buf.append(e.getReturnType().accept(javadocErasure, null));
+        buf.append(e.getReturnType().accept(ShortNameVisitor.INSTANCE, null));
     }


Input:
public void test() throws IOException {
    NodeInfo info = new NodeInfo("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", 1000000, 1000001, 0, new NodeGenericMetadata());
    NodeDependency dependency = new NodeDependency("String_Node_Str", info);
    assertEquals("String_Node_Str", dependency.getName());
    assertEquals(info, dependency.getNodeInfo());
    assertEquals("String_Node_Str", dependency.toString());
    ObjectMapper objectMapper = new ObjectMapper().registerModule(new AppStorageJsonModule());
    NodeDependency dependency2 = objectMapper.readValue(objectMapper.writeValueAsString(dependency), NodeDependency.class);
    assertEquals(dependency, dependency2);
}

Output:
     assertEquals("String_Node_Str", dependency.toString());
-    ObjectMapper objectMapper = new ObjectMapper().registerModule(new AppStorageJsonModule());
+    ObjectMapper objectMapper = JsonUtil.createObjectMapper().registerModule(new AppStorageJsonModule());
     NodeDependency dependency2 = objectMapper.readValue(objectMapper.writeValueAsString(dependency), NodeDependency.class);


Input:
protected Supplier<Operation> createOperationSupplier() {
    return new ReAuthenticationOperationSupplier(getUuid());
}

Output:
 protected Supplier<Operation> createOperationSupplier() {
-    return new ReAuthenticationOperationSupplier(getUuid());
+    return new ReAuthenticationOperationSupplier(getUuid(), clientMessage.getCorrelationId());
 }


Input:
public IClass getTheClass() {
    IClass iclass = tupleClasses[this.typeCount];
    if (iclass != null) {
        return iclass;
    }
    iclass = Package.dyvilTuple.resolveClass("String_Node_Str" + this.typeCount);
    tupleClasses[this.typeCount] = iclass;
    return iclass;
}

Output:
 public IClass getTheClass() {
-    IClass iclass = tupleClasses[this.typeCount];
-    if (iclass != null) {
-        return iclass;
-    }
-    iclass = Package.dyvilTuple.resolveClass("String_Node_Str" + this.typeCount);
-    tupleClasses[this.typeCount] = iclass;
-    return iclass;
+    return getTupleClass(this.typeCount);
 }


Input:
public MapFileHeader generateSaveHeader() {
    PreviewImageCreator previewImageCreator = new PreviewImageCreator(width, height, MapFileHeader.PREVIEW_IMAGE_SIZE, landscapeGrid.getPreviewImageDataSupplier());
    short[] bgImage = previewImageCreator.getPreviewImage();
    return new MapFileHeader(MapType.SAVED_SINGLE, "String_Node_Str", "String_Node_Str", width, height, (short) 1, (short) 1, new Date(), bgImage);
}

Output:
     short[] bgImage = previewImageCreator.getPreviewImage();
-    return new MapFileHeader(MapType.SAVED_SINGLE, "String_Node_Str", "String_Node_Str", width, height, (short) 1, (short) 1, new Date(), bgImage);
+    return new MapFileHeader(MapType.SAVED_SINGLE, mapName, mapId, "String_Node_Str", width, height, (short) 1, (short) 1, new Date(), bgImage);
 }


Input:
public void playerPortal(PlayerPortalEvent event) {
    this.plugin.log(Level.FINER, "String_Node_Str");
    PortalManager pm = this.plugin.getPortalManager();
    MVPortal portal = pm.isPortal(event.getPlayer(), event.getPlayer().getLocation());
    if (portal == null) {
        Location newLoc = SafeTTeleporter.findPortalBlockNextTo(event.getFrom());
        if (newLoc != null) {
            this.plugin.log(Level.FINER, "String_Node_Str");
            portal = pm.isPortal(event.getPlayer(), newLoc);
        }
    }
    if (portal != null) {
        this.plugin.log(Level.FINER, "String_Node_Str");
        MVDestination portalDest = portal.getDestination();
        if (portalDest != null && !(portalDest instanceof InvalidDestination)) {
            PortalPlayerSession ps = this.plugin.getPortalSession(event.getPlayer());
            if (!ps.allowTeleportViaCooldown(new Date())) {
                event.getPlayer().sendMessage(ps.getFriendlyRemainingTimeMessage());
                event.setCancelled(true);
                return;
            }
            TravelAgent agent = new MVTravelAgent(this.plugin.getCore(), portalDest, event.getPlayer());
            event.setTo(portalDest.getLocation(event.getPlayer()));
            if (portalDest.useSafeTeleporter()) {
                SafeTTeleporter teleporter = this.plugin.getCore().getTeleporter();
                event.setTo(teleporter.getSafeLocation(event.getPlayer(), portalDest));
            }
            event.setPortalTravelAgent(agent);
            event.useTravelAgent(true);
            MVPortalEvent portalEvent = new MVPortalEvent(portalDest, event.getPlayer(), agent);
            this.plugin.getServer().getPluginManager().callEvent(portalEvent);
            if (portalEvent.isCancelled()) {
                event.setCancelled(true);
                this.plugin.log(Level.FINE, "String_Node_Str");
                return;
            }
            this.plugin.log(Level.FINE, "String_Node_Str");
        } else if (!this.plugin.getMainConfig().getBoolean("String_Node_Str", false)) {
            event.getPlayer().sendMessage("String_Node_Str" + ChatColor.RED + "String_Node_Str" + ChatColor.RED + "String_Node_Str");
            event.setCancelled(true);
        }
    }
}

Output:
     if (portal == null) {
-        Location newLoc = SafeTTeleporter.findPortalBlockNextTo(event.getFrom());
+        Location newLoc = this.plugin.getCore().getSafeTTeleporter().findPortalBlockNextTo(event.getFrom());
         if (newLoc != null) {


Input:
public String getItemStackDisplayName(ItemStack par1ItemStack) {
    int itemDamage = par1ItemStack.getItemDamage();
    return MoleculeEnum.getById(itemDamage).name();
}

Output:
     int itemDamage = par1ItemStack.getItemDamage();
-    return MoleculeEnum.getById(itemDamage).name();
+    return MinechemHelper.getLocalString(MoleculeEnum.getById(itemDamage).getUnlocalizedName());
 }


Input:
public void setTypeMappingInfos(TypeMappingInfo[] newTypes) throws Exception {
    typeMappingInfos = newTypes;
    jaxbContext = new org.eclipse.persistence.jaxb.JAXBContextFactory().createContext(newTypes, null, Thread.currentThread().getContextClassLoader());
    jaxbMarshaller = jaxbContext.createMarshaller();
    jaxbUnmarshaller = jaxbContext.createUnmarshaller();
}

Output:
     typeMappingInfos = newTypes;
-    jaxbContext = new org.eclipse.persistence.jaxb.JAXBContextFactory().createContext(newTypes, null, Thread.currentThread().getContextClassLoader());
+    jaxbContext = new org.eclipse.persistence.jaxb.JAXBContextFactory().createContext(newTypes, getProperties(), Thread.currentThread().getContextClassLoader());
     jaxbMarshaller = jaxbContext.createMarshaller();


Input:
public void testSimpleChildDeployment() throws Exception {
    Verticle verticle = new MyAsyncVerticle(f -> {
        Context parentContext = vertx.currentContext();
        Verticle child1 = new MyAsyncVerticle(f2 -> {
            Context childContext = vertx.currentContext();
            assertNotSame(parentContext, childContext);
            f2.setResult(null);
            testComplete();
        }, null);
        vertx.deployVerticleInstance(child1, new DeploymentOptions(), ar -> {
            assertTrue(ar.succeeded());
        });
        f.setResult(null);
    }, null);
    vertx.deployVerticleInstance(verticle, new DeploymentOptions(), ar -> {
        assertTrue(ar.succeeded());
    });
    await();
}

Output:
             testComplete();
-        }, null);
+        }, f2 -> f2.setResult(null));
         vertx.deployVerticleInstance(child1, new DeploymentOptions(), ar -> {


Input:
private void setBranchName(IOseeBranch branch) {
    if (branch != null) {
        String branchName = branch.getName();
        String[] currentItems = this.branchSelectCombo.getItems();
        int selectionIndex = -1;
        for (int i = 0; i < currentItems.length; i++) {
            if (currentItems[i].equals(branchName)) {
                selectionIndex = i;
            }
        }
        if (selectionIndex < 0) {
            int oldLength = currentItems.length;
            String[] newItems = new String[oldLength + 1];
            System.arraycopy(currentItems, 0, newItems, 0, oldLength);
            newItems[oldLength] = branchName;
            this.branchSelectCombo.setItems(newItems);
            selectionIndex = oldLength;
            branchSelectCombo.setData(branch.getName(), branch);
            branchSelectCombo.setData(branch.getIdString(), branch);
        }
        this.branchSelectCombo.select(selectionIndex);
    }
}

Output:
     if (branch != null) {
-        String branchName = branch.getName();
+        String branchName = BranchManager.getBranchName(branch);
         String[] currentItems = this.branchSelectCombo.getItems();


Input:
public void start(AcceptsOneWidget container, EventBus eventBus) {
    this.container = container;
    this.clientFactory.getShellView().hideDetail();
    this.clientFactory.getDetailView().setPresenter(this);
    this.clientFactory.getShellView().getContentView().setContentTitle(TITLE);
    LoadingAnimationView view = this.clientFactory.getLoadingAnimationView();
    container.setWidget(view);
    doSearch(URL.decode(place.getSearch()), new SearchRange(0, pageSize));
}

Output:
     this.clientFactory.getShellView().hideDetail();
-    this.clientFactory.getDetailView().setPresenter(this);
+    this.clientFactory.getShellView().getDetailView().setPresenter(this);
     this.clientFactory.getShellView().getContentView().setContentTitle(TITLE);


Input:
public static void main(String[] args) throws IOException {
    while (!order.isClosed()) {
        int cost;
        String continueChoice;
        do {
            System.out.print("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            int choice = Integer.parseInt(reader.readLine());
            cost = priceOnProducts.get(choice);
            System.out.print("String_Node_Str");
            int count = Integer.parseInt(reader.readLine());
            order.setTotalCost(cost * count);
            System.out.print("String_Node_Str");
            continueChoice = reader.readLine();
        } while (continueChoice.equalsIgnoreCase("String_Node_Str"));
        if (strategy == null) {
            System.out.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            String paymentMethod = reader.readLine();
            if (paymentMethod.equals("String_Node_Str")) {
                strategy = new PayByPayPal();
            } else if (paymentMethod.equals("String_Node_Str")) {
                strategy = new PayByCreditCard();
            }
            order.processOrder(strategy);
        }
        System.out.print("String_Node_Str" + order.getTotalCost() + "String_Node_Str");
        String proceed = reader.readLine();
        if (proceed.equalsIgnoreCase("String_Node_Str")) {
            if (strategy.pay(order.getTotalCost())) {
                System.out.println("String_Node_Str");
            } else {
                System.out.println("String_Node_Str");
            }
            order.setClosed();
        }
    }
}

Output:
                 strategy = new PayByPayPal();
-            } else if (paymentMethod.equals("String_Node_Str")) {
+            } else {
                 strategy = new PayByCreditCard();


Input:
private void checkLogPartitionKey(Set<String> problemKeys) {
    if (!isValidPartitionKey(cConf.get(Constants.Logging.LOG_PUBLISH_PARTITION_KEY))) {
        problemKeys.add(Constants.Logging.LOG_PUBLISH_PARTITION_KEY);
    }
}

Output:
 private void checkLogPartitionKey(Set<String> problemKeys) {
-    if (!isValidPartitionKey(cConf.get(Constants.Logging.LOG_PUBLISH_PARTITION_KEY))) {
-        problemKeys.add(Constants.Logging.LOG_PUBLISH_PARTITION_KEY);
-    }
+    validatePartitionKey(Constants.Logging.LOG_PUBLISH_PARTITION_KEY, problemKeys);
 }


Input:
void publishMetrics() {
    if (currentThread() != owner) {
        return;
    }
    owner.bytesTransceived += bytesWritten.get() - bytesReadLastPublish;
    owner.framesTransceived += normalFramesWritten.get() - normalFramesReadLastPublish;
    owner.priorityFramesTransceived += priorityFramesWritten.get() - priorityFramesReadLastPublish;
    owner.processCount += processCount.get() - processCountLastPublish;
    bytesReadLastPublish = bytesWritten.get();
    normalFramesReadLastPublish = normalFramesWritten.get();
    priorityFramesReadLastPublish = priorityFramesWritten.get();
    processCountLastPublish = processCount.get();
}

Output:
     }
-    owner.bytesTransceived += bytesWritten.get() - bytesReadLastPublish;
-    owner.framesTransceived += normalFramesWritten.get() - normalFramesReadLastPublish;
-    owner.priorityFramesTransceived += priorityFramesWritten.get() - priorityFramesReadLastPublish;
+    owner.bytesTransceived += bytesWritten.get() - bytesWrittenLastPublish;
+    owner.framesTransceived += normalFramesWritten.get() - normalFramesWrittenLastPublish;
+    owner.priorityFramesTransceived += priorityFramesWritten.get() - priorityFramesWrittenLastPublish;
     owner.processCount += processCount.get() - processCountLastPublish;


Input:
public void onPause() {
    super.onPause();
    presenter.dropView();
    if (onDropViewAction == OnDropViewAction.DESTROY_PRESENTER || (onDropViewAction == OnDropViewAction.DESTROY_PRESENTER_IF_FINISHING && getActivity().isFinishing()))
        destroyPresenter();
}

Output:
     super.onPause();
-    presenter.dropView();
-    if (onDropViewAction == OnDropViewAction.DESTROY_PRESENTER || (onDropViewAction == OnDropViewAction.DESTROY_PRESENTER_IF_FINISHING && getActivity().isFinishing()))
-        destroyPresenter();
+    dropView(getActivity());
 }


Input:
public synchronized void processingStarted(RequestStartedSignal signal) {
    LttngSyntEventRequest request = signal.getRequest();
    if (request != null) {
        waitCursor(true);
        TmfTimeRange trange = null;
        trange = request.getRange();
        boolean clearData = request.isclearDataInd();
        ModelUpdatePrep(trange, clearData);
    }
}

Output:
         boolean clearData = request.isclearDataInd();
-        ModelUpdatePrep(trange, clearData);
+        modelUpdatePrep(trange, clearData);
     }


Input:
public WcetCost computeWCET(String key, Segment segment, StaticCacheApproximation cacheMode) throws InvalidFlowFactException, LpSolveException {
    IPETSolver<SuperGraphEdge> ipetSolver = buildIpetProblem(project, key, segment, ipetConfig);
    setExecutionCost(segment, ipetSolver);
    Set<SuperGraphEdge> missEdges = new HashSet<SuperGraphEdge>();
    if (project.getWCETProcessorModel().hasMethodCache()) {
        switch(cacheMode) {
            case ALWAYS_HIT:
                break;
            case ALWAYS_MISS:
                missEdges = methodCacheAnalysis.addMissAlwaysCost(segment, ipetSolver);
                break;
            case ALL_FIT_SIMPLE:
                missEdges = methodCacheAnalysis.addMissOnceCost(segment, ipetSolver);
                break;
            case ALL_FIT_REGIONS:
                missEdges = methodCacheAnalysis.addMissOnceConstraints(segment, ipetSolver);
                break;
            case GLOBAL_ALL_FIT:
                missEdges = methodCacheAnalysis.addGlobalAllFitConstraints(segment, ipetSolver);
                break;
        }
    }
    Map<SuperGraphEdge, Long> flowMap = new HashMap<SuperGraphEdge, Long>();
    long _start = System.currentTimeMillis();
    double relaxedCost = ipetSolver.solve(null, false);
    long _time_rlp = System.currentTimeMillis() - _start;
    double ilpCost = ipetSolver.solve(flowMap);
    long _time_ilp = System.currentTimeMillis() - _start;
    WCETTool.logger.info(String.format("String_Node_Str", _time_rlp, Math.round(relaxedCost), Math.round(ilpCost), _time_ilp));
    WcetCost cost = new WcetCost();
    for (Entry<SuperGraphEdge, Long> flowEntry : flowMap.entrySet()) {
        SuperGraphEdge edge = flowEntry.getKey();
        long edgeCost = ipetSolver.getEdgeCost(edge);
        long flowCost = edgeCost * flowEntry.getValue();
        if (missEdges.contains(edge)) {
            if (WCETTool.logger.isTraceEnabled() && flowEntry.getValue() > 0) {
                WCETTool.logger.trace("String_Node_Str" + edge + "String_Node_Str" + flowCost + "String_Node_Str" + flowEntry.getValue() + "String_Node_Str" + edgeCost + "String_Node_Str");
            }
            cost.addCacheCost(flowCost);
        } else {
            if (WCETTool.logger.isTraceEnabled() && flowEntry.getValue() > 0) {
                WCETTool.logger.trace("String_Node_Str" + edge + "String_Node_Str" + flowCost);
            }
            cost.addNonLocalCost(flowCost);
        }
    }
    if (Double.isInfinite(ilpCost)) {
        throw new AssertionError("String_Node_Str");
    }
    long objValue = (long) (ilpCost + 0.5);
    if (cost.getCost() != objValue) {
        throw new AssertionError("String_Node_Str" + objValue + "String_Node_Str" + cost.getCost());
    }
    return cost;
}

Output:
 public WcetCost computeWCET(String key, Segment segment, StaticCacheApproximation cacheMode) throws InvalidFlowFactException, LpSolveException {
-    IPETSolver<SuperGraphEdge> ipetSolver = buildIpetProblem(project, key, segment, ipetConfig);
+    String problemId = formatProblemName(key, segment.getEntryMethods().toString());
+    IPETSolver<SuperGraphEdge> ipetSolver = buildIpetProblem(project, problemId, segment, ipetConfig);
     setExecutionCost(segment, ipetSolver);


Input:
public void readEntityFromNBT(NBTTagCompound compound) {
    super.readEntityFromNBT(compound);
    if (compound.hasKey("String_Node_Str")) {
        this.setGemCut(compound.getInteger("String_Node_Str"));
        this.setGemPlacement(compound.getInteger("String_Node_Str"));
    } else {
        this.convertGems(compound.getInteger("String_Node_Str"));
    }
    if (!this.isGemPlacementDefined() || !this.isCorrectGemPlacement()) {
        int placementIndex = this.rand.nextInt(this.placements.size());
        this.setGemPlacement(this.placements.get(placementIndex).id);
    }
    if (!this.isGemCutDefined() || !this.isCorrectGemCut()) {
        int cutIndex = this.rand.nextInt(this.cuts.size());
        this.setGemCut(this.cuts.get(cutIndex).id);
    }
    this.applyGemPlacementBuffs();
    this.setHasVisor(compound.getBoolean("String_Node_Str"));
    if (compound.hasKey("String_Node_Str")) {
        this.setInsigniaColor(compound.getInteger("String_Node_Str"));
    } else {
        this.setInsigniaColor(12);
    }
    this.setHairStyle(compound.getInteger("String_Node_Str"));
    this.setDefective(compound.getBoolean("String_Node_Str"));
    this.setPrimary(compound.getBoolean("String_Node_Str"));
    NBTTagList fusionMembers = compound.getTagList("String_Node_Str", 10);
    for (int i = 0; i < fusionMembers.tagCount(); ++i) {
        this.fusionMembers.add(fusionMembers.getCompoundTagAt(i));
    }
    this.setFusionCount(compound.getInteger("String_Node_Str"));
    this.setFusionPlacements(compound.getString("String_Node_Str"));
    this.setSpecial(compound.getInteger("String_Node_Str"));
    String ownerId;
    if (compound.hasKey("String_Node_Str", 8)) {
        ownerId = compound.getString("String_Node_Str");
    } else {
        String tempId = compound.getString("String_Node_Str");
        ownerId = PreYggdrasilConverter.convertMobOwnerIfNeeded(this.getServer(), tempId);
    }
    if (!ownerId.isEmpty()) {
        this.setOwnerId(UUID.fromString(ownerId));
    }
    String leaderId;
    if (compound.hasKey("String_Node_Str", 8)) {
        leaderId = compound.getString("String_Node_Str");
    } else {
        String tempId = compound.getString("String_Node_Str");
        leaderId = PreYggdrasilConverter.convertMobOwnerIfNeeded(this.getServer(), tempId);
    }
    if (!leaderId.isEmpty()) {
        this.setLeader(UUID.fromString(leaderId));
    }
    NBTTagList owners = compound.getTagList("String_Node_Str", 10);
    for (int i = 0; i < owners.tagCount(); ++i) {
        NBTTagCompound nbt = owners.getCompoundTagAt(i);
        String jointId;
        if (nbt.hasKey("String_Node_Str", 8)) {
            jointId = nbt.getString("String_Node_Str");
        } else {
            String tempId = nbt.getString("String_Node_Str");
            jointId = PreYggdrasilConverter.convertMobOwnerIfNeeded(this.getServer(), tempId);
        }
        if (!jointId.isEmpty()) {
            this.jointOwners.add(UUID.fromString(jointId));
        }
    }
    if (compound.hasKey("String_Node_Str") && compound.hasKey("String_Node_Str") && compound.hasKey("String_Node_Str")) {
        this.restPosition = new BlockPos(compound.getDouble("String_Node_Str"), compound.getDouble("String_Node_Str"), compound.getDouble("String_Node_Str"));
    }
    if (this.stayAI != null) {
        this.stayAI.setSitting(compound.getBoolean("String_Node_Str"));
    }
    this.isSitting = compound.getBoolean("String_Node_Str");
    this.servitude = compound.getInteger("String_Node_Str");
    this.fallbackServitude = compound.getInteger("String_Node_Str");
    this.timeUntilBetrayal = compound.getInteger("String_Node_Str");
    this.wantsToFuse = compound.getBoolean("String_Node_Str");
    if (compound.hasKey("String_Node_Str")) {
        this.pitch = compound.getFloat("String_Node_Str");
    } else {
        this.pitch = 0.7F + (this.rand.nextFloat() / 2);
    }
    if (compound.hasKey("String_Node_Str")) {
        this.setDimensionOfCreation(compound.getInteger("String_Node_Str"));
    } else {
        this.setDimensionOfCreation(this.dimension);
    }
    this.setAttackAI();
}

Output:
     }
-    if (!this.isGemPlacementDefined() || !this.isCorrectGemPlacement()) {
-        int placementIndex = this.rand.nextInt(this.placements.size());
-        this.setGemPlacement(this.placements.get(placementIndex).id);
-    }
-    if (!this.isGemCutDefined() || !this.isCorrectGemCut()) {
-        int cutIndex = this.rand.nextInt(this.cuts.size());
-        this.setGemCut(this.cuts.get(cutIndex).id);
+    if (!this.isGemPlacementDefined() || !this.isGemCutDefined() || !this.isCorrectCutPlacement()) {
+        this.setNewCutPlacement();
     }


Input:
public void clicked(InputEvent event, float x, float y) {
    SceneScreen scnScr = (SceneScreen) ui.getScreen(Screens.SCENE_SCREEN);
    Recorder r = scnScr.getRecorder();
    if (!r.isPlaying()) {
        r.load(recordings.getSelected());
        r.setPlaying(true);
        ui.setCurrentScreen(Screens.SCENE_SCREEN);
    } else {
        r.setPlaying(false);
        ui.setCurrentScreen(Screens.SCENE_SCREEN);
    }
}

Output:
     if (!r.isPlaying()) {
-        r.load(recordings.getSelected());
+        r.setFilename(recordings.getSelected());
+        r.load();
         r.setPlaying(true);


Input:
public RequestBuilder requestCharset(Charset charset) {
    requestCharset = charset;
    return this;
}

Output:
 public RequestBuilder requestCharset(Charset charset) {
-    requestCharset = charset;
+    this.charset = charset;
     return this;


Input:
public int getMinExpandHeight() {
    if (mIsSummaryWithChildren && !mOnKeyguard) {
        return mChildrenContainer.getMinExpandHeight();
    }
    return getMinHeight();
}

Output:
 public int getMinExpandHeight() {
-    if (mIsSummaryWithChildren && !mOnKeyguard) {
-        return mChildrenContainer.getMinExpandHeight();
+    if (mIsSummaryWithChildren && !mShowingPublic) {
+        return mChildrenContainer.getMinExpandHeight(mOnKeyguard);
     }


Input:
public DepTreebank getTreebank(int numTrees) {
    DepTreebank treebank = new DepTreebank();
    for (int i = 0; i < numTrees; i++) {
        ProjDepTreeNode wall = new ProjDepTreeNode(WallDepTreeNode.WALL_LABEL);
        recursivelyGenerate(wall);
        treebank.add(new DepTree(wall));
    }
    return treebank;
}

Output:
     for (int i = 0; i < numTrees; i++) {
-        ProjDepTreeNode wall = new ProjDepTreeNode(WallDepTreeNode.WALL_LABEL);
+        ProjDepTreeNode wall = new ProjWallDepTreeNode();
         recursivelyGenerate(wall);


Input:
public void enter(GameContainer container, StateBasedGame game) throws SlickException {
    UI.enter();
    if (beatmap == null || beatmap.objects == null)
        throw new RuntimeException("String_Node_Str");
    previousScores = ScoreDB.getMapScores(beatmap);
    lastRankUpdateTime = -1000;
    if (previousScores != null)
        currentRank = previousScores.length;
    scoreboardVisible = true;
    currentScoreboardAlpha = 0f;
    FrameBufferCache.getInstance().freeMap();
    if (restart != Restart.FALSE) {
        if (isReplay) {
            previousMods = GameMod.getModState();
            GameMod.loadModState(replay.mods);
        }
        data.setGameplay(true);
        if (restart == Restart.NEW) {
            loadImages();
            setMapModifiers();
            retries = 0;
        } else if (restart == Restart.MANUAL) {
            retries++;
        } else if (restart == Restart.REPLAY)
            retries = 0;
        gameObjects = new GameObject[beatmap.objects.length];
        playbackSpeed = PlaybackSpeed.NORMAL;
        resetGameData();
        if (!beatmap.timingPoints.isEmpty()) {
            TimingPoint timingPoint = beatmap.timingPoints.get(0);
            if (!timingPoint.isInherited()) {
                setBeatLength(timingPoint, true);
                timingPointIndex++;
            }
        }
        Color[] combo = beatmap.getComboColors();
        for (int i = 0; i < beatmap.objects.length; i++) {
            HitObject hitObject = beatmap.objects[i];
            boolean comboEnd = false;
            if (i + 1 >= beatmap.objects.length || beatmap.objects[i + 1].isNewCombo())
                comboEnd = true;
            Color color = combo[hitObject.getComboIndex()];
            int hitObjectTime = hitObject.getTime();
            while (timingPointIndex < beatmap.timingPoints.size()) {
                TimingPoint timingPoint = beatmap.timingPoints.get(timingPointIndex);
                if (timingPoint.getTime() > hitObjectTime)
                    break;
                setBeatLength(timingPoint, false);
                timingPointIndex++;
            }
            try {
                if (hitObject.isCircle())
                    gameObjects[i] = new Circle(hitObject, this, data, color, comboEnd);
                else if (hitObject.isSlider())
                    gameObjects[i] = new Slider(hitObject, this, data, color, comboEnd);
                else if (hitObject.isSpinner())
                    gameObjects[i] = new Spinner(hitObject, this, data);
            } catch (Exception e) {
                ErrorHandler.error(String.format("String_Node_Str", hitObject.getTypeName(), i, hitObject.toString()), e, true);
                gameObjects[i] = new DummyObject(hitObject);
                continue;
            }
        }
        calculateStacks();
        timingPointIndex = 0;
        beatLengthBase = beatLength = 1;
        if (!beatmap.timingPoints.isEmpty()) {
            TimingPoint timingPoint = beatmap.timingPoints.get(0);
            if (!timingPoint.isInherited()) {
                setBeatLength(timingPoint, true);
                timingPointIndex++;
            }
        }
        if (GameMod.AUTO.isActive() || isReplay)
            UI.getCursor().show();
        if (isReplay) {
            replayX = container.getWidth() / 2;
            replayY = container.getHeight() / 2;
            replayKeyPressed = false;
            replaySkipTime = -1;
            for (replayIndex = 0; replayIndex < replay.frames.length; replayIndex++) {
                ReplayFrame frame = replay.frames[replayIndex];
                if (frame.getY() < 0) {
                    if (frame.getTime() >= 0 && replayIndex > 0)
                        replaySkipTime = frame.getTime();
                } else if (frame.getTime() == 0) {
                    replayX = frame.getScaledX();
                    replayY = frame.getScaledY();
                    replayKeyPressed = frame.isKeyPressed();
                } else
                    break;
            }
        } else {
            lastKeysPressed = ReplayFrame.KEY_NONE;
            replaySkipTime = -1;
            replayFrames = new LinkedList<ReplayFrame>();
            replayFrames.add(new ReplayFrame(0, 0, input.getMouseX(), input.getMouseY(), 0));
        }
        leadInTime = beatmap.audioLeadIn + approachTime;
        restart = Restart.FALSE;
        MusicController.play(false);
        MusicController.setPosition(0);
        MusicController.setPitch(GameMod.getSpeedMultiplier());
        MusicController.pause();
        SoundController.mute(false);
    }
    skipButton.resetHover();
    if (isReplay || GameMod.AUTO.isActive())
        playbackSpeed.getButton().resetHover();
    MusicController.setPitch(GameMod.getSpeedMultiplier() * playbackSpeed.getModifier());
}

Output:
         throw new RuntimeException("String_Node_Str");
-    previousScores = ScoreDB.getMapScores(beatmap);
+    previousScores = ScoreDB.getMapScores(beatmap, replay == null ? null : replay.getReplayFilename());
     lastRankUpdateTime = -1000;


Input:
public static ClusterMonitor getClusterMonitor(Cluster cluster) throws PolicyValidationException, PartitionValidationException {
    if (null == cluster) {
        return null;
    }
    String autoscalePolicyName = cluster.getAutoscalePolicyName();
    String deploymentPolicyName = cluster.getDeploymentPolicyName();
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str" + deploymentPolicyName);
        log.debug("String_Node_Str" + autoscalePolicyName);
    }
    AutoscalePolicy policy = PolicyManager.getInstance().getAutoscalePolicy(autoscalePolicyName);
    DeploymentPolicy deploymentPolicy = PolicyManager.getInstance().getDeploymentPolicy(deploymentPolicyName);
    if (deploymentPolicy == null) {
        String msg = "String_Node_Str" + deploymentPolicyName;
        log.error(msg);
        throw new PolicyValidationException(msg);
    }
    Partition[] allPartitions = deploymentPolicy.getAllPartitions();
    if (allPartitions == null) {
        String msg = "String_Node_Str" + deploymentPolicyName;
        log.error(msg);
        throw new PolicyValidationException(msg);
    }
    CloudControllerClient.getInstance().validateDeploymentPolicy(cluster.getServiceName(), deploymentPolicy);
    ClusterMonitor clusterMonitor = new ClusterMonitor(cluster.getClusterId(), cluster.getServiceName(), deploymentPolicy, policy);
    for (PartitionGroup partitionGroup : deploymentPolicy.getPartitionGroups()) {
        NetworkPartitionContext networkPartitionContext = new NetworkPartitionContext(partitionGroup.getId());
        for (Partition partition : partitionGroup.getPartitions()) {
            PartitionContext partitionContext = new PartitionContext(partition);
            partitionContext.setServiceName(cluster.getServiceName());
            partitionContext.setProperties(cluster.getProperties());
            partitionContext.setNetworkPartitionId(partitionGroup.getId());
            for (Member member : cluster.getMembers()) {
                String memberId = member.getMemberId();
                if (member.getPartitionId().equalsIgnoreCase(partition.getId())) {
                    MemberContext memberContext = new MemberContext();
                    memberContext.setClusterId(member.getClusterId());
                    memberContext.setMemberId(memberId);
                    memberContext.setPartition(partition);
                    if (MemberStatus.Activated.equals(member.getStatus())) {
                        partitionContext.addActiveMember(memberContext);
                        partitionContext.incrementCurrentActiveMemberCount(1);
                    } else if (MemberStatus.Created.equals(member.getStatus()) || MemberStatus.Starting.equals(member.getStatus())) {
                        partitionContext.addPendingMember(memberContext);
                    } else if (MemberStatus.Suspended.equals(member.getStatus())) {
                        partitionContext.addFaultyMember(memberId);
                    }
                    partitionContext.addMemberStatsContext(new MemberStatsContext(memberId));
                    if (log.isInfoEnabled()) {
                        log.info(String.format("String_Node_Str", memberId));
                    }
                }
            }
            networkPartitionContext.addPartitionContext(partitionContext);
            if (log.isInfoEnabled()) {
                log.info(String.format("String_Node_Str", partitionContext.getPartitionId()));
            }
        }
        clusterMonitor.addNetworkPartitionCtxt(networkPartitionContext);
        if (log.isInfoEnabled()) {
            log.info(String.format("String_Node_Str", networkPartitionContext.getId()));
        }
    }
    java.util.Properties props = cluster.getProperties();
    if (props.containsKey(Constants.LOAD_BALANCER_REF)) {
        String value = props.getProperty(Constants.LOAD_BALANCER_REF);
        clusterMonitor.setLbReferenceType(value);
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str" + value);
        }
    }
    log.info("String_Node_Str" + clusterMonitor.toString());
    return clusterMonitor;
}

Output:
     for (PartitionGroup partitionGroup : deploymentPolicy.getPartitionGroups()) {
-        NetworkPartitionContext networkPartitionContext = new NetworkPartitionContext(partitionGroup.getId());
+        NetworkPartitionContext networkPartitionContext = new NetworkPartitionContext(partitionGroup.getId(), partitionGroup.getPartitionAlgo());
         for (Partition partition : partitionGroup.getPartitions()) {


Input:
private void removeAllRows() throws SQLException {
    PageBtree root = getPage(rootPageId);
    store.logUndo(root, root.data);
    root.freeChildren();
    root = PageBtreeLeaf.create(this, rootPageId, PageBtree.ROOT);
    store.removeRecord(rootPageId);
    store.update(root);
    rowCount = 0;
}

Output:
     PageBtree root = getPage(rootPageId);
-    store.logUndo(root, root.data);
-    root.freeChildren();
+    root.freeRecursive();
     root = PageBtreeLeaf.create(this, rootPageId, PageBtree.ROOT);


Input:
private void doSecurity() {
    dashboardService.addWidgetToDashboard(new DashboardWidget("String_Node_Str"));
}

Output:
 private void doSecurity() {
-    dashboardService.addWidgetToDashboard(new DashboardWidget("String_Node_Str"));
+    DashboardWidget newWidget = new DashboardWidget("String_Node_Str");
+    configureFixedWidgets(newWidget);
+    newWidget.setTitle("String_Node_Str");
+    newWidget.setSeriesField("String_Node_Str");
+    dashboardService.addWidgetToDashboard(newWidget);
 }


Input:
private void updateChart() {
    recalculateGapThreshold(0);
    if (hasSecondaryYAxis) {
        recalculateGapThreshold(1);
    }
    chart.getXYPlot().getRangeAxis(0).configure();
    if (chart.getLegend() == null) {
        int seriesCount = chart.getXYPlot().getDataset(0).getSeriesCount();
        if (hasSecondaryYAxis) {
            seriesCount += chart.getXYPlot().getDataset(1).getSeriesCount();
            NumberAxis a = (NumberAxis) chart.getXYPlot().getRangeAxis(1);
            a.configure();
        }
        if (seriesCount > 1) {
            addLegend();
        }
    }
}

Output:
     }
-    chart.getXYPlot().getRangeAxis(0).configure();
+    chart.getXYPlot().configureRangeAxes();
     if (chart.getLegend() == null) {


Input:
public void create_self_referencing_maintainer_sso_auth_only_invalid_token() {
    try {
        RestTest.target(getPort(), "String_Node_Str").request().cookie("String_Node_Str", "String_Node_Str").post(Entity.entity(whoisObjectMapper.mapRpslObjects(FormattedClientAttributeMapper.class, SSO_ONLY_MNT), MediaType.APPLICATION_XML), WhoisResources.class);
        fail();
    } catch (NotAuthorizedException e) {
        final WhoisResources whoisResources = RestTest.mapClientException(e);
        RestTest.assertErrorCount(whoisResources, 2);
        RestTest.assertErrorMessage(whoisResources, 0, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
        RestTest.assertErrorMessage(whoisResources, 1, "String_Node_Str", "String_Node_Str");
    }
}

Output:
         final WhoisResources whoisResources = RestTest.mapClientException(e);
-        RestTest.assertErrorCount(whoisResources, 2);
+        RestTest.assertErrorCount(whoisResources, 1);
         RestTest.assertErrorMessage(whoisResources, 0, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");


Input:
public XMLObjectReferenceMapping generateXMLObjectReferenceMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo, JavaClass referenceClass) {
    XMLObjectReferenceMapping mapping = new XMLObjectReferenceMapping();
    mapping.setAttributeName(property.getPropertyName());
    if (property.isSetReadOnly()) {
        mapping.setIsReadOnly(property.isReadOnly());
    }
    if (property.isSetWriteOnly()) {
        mapping.setIsWriteOnly(property.isWriteOnly());
    }
    if (property.isMethodProperty()) {
        if (property.getGetMethodName() == null) {
            String paramTypeAsString = property.getType().getName();
            mapping.setAttributeAccessor(new JAXBSetMethodAttributeAccessor(paramTypeAsString, helper.getClassLoader()));
            mapping.setIsReadOnly(true);
            mapping.setSetMethodName(property.getSetMethodName());
        } else if (property.getSetMethodName() == null) {
            mapping.setGetMethodName(property.getGetMethodName());
            mapping.setIsWriteOnly(true);
        } else {
            mapping.setSetMethodName(property.getSetMethodName());
            mapping.setGetMethodName(property.getGetMethodName());
        }
    }
    mapping.setReferenceClassName(referenceClass.getQualifiedName());
    if (property.isSetXmlJoinNodes()) {
        for (XmlJoinNode xmlJoinNode : property.getXmlJoinNodes().getXmlJoinNode()) {
            validateJoinNode(descriptor.getJavaClassName(), property, xmlJoinNode.getReferencedXmlPath(), referenceClass);
            mapping.addSourceToTargetKeyFieldAssociation(xmlJoinNode.getXmlPath(), xmlJoinNode.getReferencedXmlPath());
        }
    } else {
        String tgtXPath = null;
        TypeInfo referenceType = typeInfo.get(referenceClass.getQualifiedName());
        if (null != referenceType && referenceType.isIDSet()) {
            Property prop = referenceType.getIDProperty();
            tgtXPath = getXPathForField(prop, namespaceInfo, !prop.isAttribute()).getXPath();
        }
        XMLField srcXPath;
        if (property.getXmlPath() != null) {
            srcXPath = new XMLField(property.getXmlPath());
        } else {
            srcXPath = getXPathForField(property, namespaceInfo, true);
        }
        mapping.addSourceToTargetKeyFieldAssociation(srcXPath.getXPath(), tgtXPath);
    }
    if (property.getInverseReferencePropertyName() != null) {
        mapping.getInverseReferenceMapping().setAttributeName(property.getInverseReferencePropertyName());
        JavaClass backPointerPropertyType = null;
        if (property.getInverseReferencePropertyGetMethodName() != null && property.getInverseReferencePropertySetMethodName() != null && !property.getInverseReferencePropertyGetMethodName().equals("String_Node_Str") && !property.getInverseReferencePropertySetMethodName().equals("String_Node_Str")) {
            mapping.getInverseReferenceMapping().setGetMethodName(property.getInverseReferencePropertySetMethodName());
            mapping.getInverseReferenceMapping().setSetMethodName(property.getInverseReferencePropertySetMethodName());
            JavaMethod getMethod = referenceClass.getDeclaredMethod(mapping.getInverseReferenceMapping().getGetMethodName(), new JavaClass[] {});
            if (getMethod != null) {
                backPointerPropertyType = getMethod.getReturnType();
            }
        } else {
            JavaField backpointerField = referenceClass.getDeclaredField(property.getInverseReferencePropertyName());
            if (backpointerField != null) {
                backPointerPropertyType = backpointerField.getResolvedType();
            }
        }
        if (isCollectionType(backPointerPropertyType)) {
            mapping.getInverseReferenceMapping().setContainerPolicy(ContainerPolicy.buildDefaultPolicy());
        }
    }
    return mapping;
}

Output:
         }
-        if (isCollectionType(backPointerPropertyType)) {
+        if (helper.isCollectionType(backPointerPropertyType)) {
             mapping.getInverseReferenceMapping().setContainerPolicy(ContainerPolicy.buildDefaultPolicy());


Input:
public ArrayList<Property> getPropertyPropertiesForClass(JavaClass cls, TypeInfo info, boolean onlyPublic) {
    ArrayList<Property> properties = new ArrayList<Property>();
    if (cls == null) {
        return properties;
    }
    ArrayList<JavaMethod> propertyMethods = new ArrayList<JavaMethod>();
    for (JavaMethod next : new ArrayList<JavaMethod>(cls.getDeclaredMethods())) {
        if ((next.getName().startsWith("String_Node_Str") && next.getName().length() > 3) || (next.getName().startsWith("String_Node_Str") && next.getName().length() > 2)) {
            int modifiers = next.getModifiers();
            if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers) && ((onlyPublic && Modifier.isPublic(next.getModifiers())) || !onlyPublic)) {
                propertyMethods.add(next);
            }
        } else if ((next.getName().startsWith("String_Node_Str") && next.getName().length() > 3)) {
            int modifiers = next.getModifiers();
            if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers) && ((onlyPublic && Modifier.isPublic(next.getModifiers())) || !onlyPublic)) {
                propertyMethods.add(next);
            }
        }
    }
    ArrayList<String> propertyNames = new ArrayList<String>();
    for (int i = 0; i < propertyMethods.size(); i++) {
        boolean isPropertyTransient = false;
        JavaMethod nextMethod = propertyMethods.get(i);
        String propertyName = "String_Node_Str";
        JavaMethod getMethod;
        JavaMethod setMethod;
        JavaMethod propertyMethod = null;
        if (!nextMethod.getName().startsWith("String_Node_Str")) {
            if (nextMethod.getName().startsWith("String_Node_Str")) {
                propertyName = nextMethod.getName().substring(3);
            } else if (nextMethod.getName().startsWith("String_Node_Str")) {
                propertyName = nextMethod.getName().substring(2);
            }
            getMethod = nextMethod;
            String setMethodName = "String_Node_Str" + propertyName;
            propertyName = Introspector.decapitalize(propertyName);
            JavaClass[] paramTypes = { (JavaClass) getMethod.getReturnType() };
            setMethod = cls.getDeclaredMethod(setMethodName, paramTypes);
            if (setMethod != null && !setMethod.getAnnotations().isEmpty()) {
                if (!helper.isAnnotationPresent(setMethod, XmlTransient.class)) {
                    propertyMethod = setMethod;
                } else {
                    isPropertyTransient = true;
                }
            } else {
                if (!helper.isAnnotationPresent(getMethod, XmlTransient.class)) {
                    propertyMethod = getMethod;
                } else {
                    isPropertyTransient = true;
                }
            }
        } else {
            propertyName = nextMethod.getName().substring(3);
            setMethod = nextMethod;
            String getMethodName = "String_Node_Str" + propertyName;
            getMethod = cls.getDeclaredMethod(getMethodName, new JavaClass[] {});
            if (getMethod == null) {
                getMethodName = "String_Node_Str" + propertyName;
                getMethod = cls.getDeclaredMethod(getMethodName, new JavaClass[] {});
            }
            if (getMethod != null && !getMethod.getAnnotations().isEmpty()) {
                if (!helper.isAnnotationPresent(getMethod, XmlTransient.class)) {
                    propertyMethod = getMethod;
                } else {
                    isPropertyTransient = true;
                }
            } else {
                if (!helper.isAnnotationPresent(setMethod, XmlTransient.class)) {
                    propertyMethod = setMethod;
                } else {
                    isPropertyTransient = true;
                }
            }
            propertyName = Introspector.decapitalize(propertyName);
        }
        JavaClass ptype = null;
        if (getMethod != null) {
            ptype = (JavaClass) getMethod.getReturnType();
        } else {
            ptype = setMethod.getParameterTypes()[0];
        }
        if (!propertyNames.contains(propertyName)) {
            propertyNames.add(propertyName);
            Property property = buildNewProperty(info, cls, propertyMethod, propertyName, ptype);
            property.setTransient(isPropertyTransient);
            if (getMethod != null) {
                property.setGetMethodName(getMethod.getName());
            }
            if (setMethod != null) {
                property.setSetMethodName(setMethod.getName());
            }
            property.setMethodProperty(true);
            if (!helper.isAnnotationPresent(property.getElement(), XmlTransient.class)) {
                properties.add(property);
            } else {
                List<String> propOrderList = Arrays.asList(info.getPropOrder());
                if (propOrderList.contains(propertyName)) {
                    throw JAXBException.transientInProporder(propertyName);
                }
                property.setTransient(true);
            }
        }
    }
    Collections.sort(properties, new PropertyComparitor());
    return properties;
}

Output:
             }
-        } else if ((next.getName().startsWith("String_Node_Str") && next.getName().length() > 3)) {
+        } else if (next.getName().startsWith("String_Node_Str") && next.getName().length() > 3 && next.getParameterTypes().length == 1) {
             int modifiers = next.getModifiers();


Input:
public void process(Node externs, Node root) {
    if (addExtern) {
        addExternForGlobalSymbolNamespace();
    }
    NodeTraversal.traverse(compiler, root, new RewriteGlobalFunctionStatementsToVarAssignmentsCallback());
    List<Callback> nonMutatingPasses = new ArrayList<>();
    nonMutatingPasses.add(new FindCrossModuleNamesCallback());
    nonMutatingPasses.add(new FindNamesReferencingThis());
    CombinedCompilerPass.traverse(compiler, root, nonMutatingPasses);
    NodeTraversal.traverse(compiler, root, new RewriteScopeCallback());
    NodeTraversal.traverse(compiler, root, new RemoveGlobalVarCallback());
    NodeTraversal.traverse(compiler, root, new MakeExternsReferenceWindowExplicitly());
}

Output:
     CombinedCompilerPass.traverse(compiler, root, nonMutatingPasses);
-    NodeTraversal.traverse(compiler, root, new RewriteScopeCallback());
+    RewriteScopeCallback rewriteScope = new RewriteScopeCallback();
+    NodeTraversal.traverse(compiler, root, rewriteScope);
     NodeTraversal.traverse(compiler, root, new RemoveGlobalVarCallback());


Input:
private List<Description> buildDescriptionFromStories() {
    JUnitDescriptionGenerator gen = new JUnitDescriptionGenerator(junitStories.stepsFactory().createCandidateSteps());
    StoryRunner storyRunner = new StoryRunner();
    List<Description> storyDescriptions = new ArrayList<Description>();
    storyDescriptions.add(Description.createTestDescription(Object.class, "String_Node_Str"));
    numberOfTestCases++;
    for (String storyPath : storyPaths) {
        Story parseStory = storyRunner.storyOfPath(configuration, storyPath);
        Description descr = gen.createDescriptionFrom(parseStory);
        storyDescriptions.add(descr);
    }
    storyDescriptions.add(Description.createTestDescription(Object.class, "String_Node_Str"));
    numberOfTestCases++;
    numberOfTestCases += gen.getTestCases();
    return storyDescriptions;
}

Output:
 private List<Description> buildDescriptionFromStories() {
-    JUnitDescriptionGenerator gen = new JUnitDescriptionGenerator(junitStories.stepsFactory().createCandidateSteps());
+    JUnitDescriptionGenerator gen = new JUnitDescriptionGenerator(candidateSteps);
     StoryRunner storyRunner = new StoryRunner();


Input:
public void setNullValue(Object object, CoreSession session) {
    Object value = xmlBinaryDataMapping.getObjectValue(null, (Session) session);
    xmlBinaryDataMapping.setAttributeValueInObject(object, value);
}

Output:
 public void setNullValue(Object object, CoreSession session) {
-    Object value = xmlBinaryDataMapping.getObjectValue(null, (Session) session);
+    Object value = xmlBinaryDataMapping.getObjectValue(null, session);
     xmlBinaryDataMapping.setAttributeValueInObject(object, value);


Input:
public void addTransformed(Class<?> clazz) {
    transformed.put(clazz, Boolean.TRUE);
}

Output:
 public void addTransformed(Class<?> clazz) {
-    transformed.put(clazz, Boolean.TRUE);
+    transformed.put(clazz, EXIST);
 }


Input:
private void saveReceiveItems(List<ReceiveItem> receiveItems) {
    GenericDao<ReceiveItem> receiveItemDao = new GenericDao<>(ReceiveItem.class, context);
    for (ReceiveItem receiveItem : receiveItems) {
        receiveItemDao.create(receiveItem);
        stockService.increaseStockLevelFor(receiveItem.getCommodity(), receiveItem.getQuantityReceived(), receiveItem.created());
        commoditySnapshotService.add(receiveItem);
    }
    alertsService.updateLowStockAlerts();
}

Output:
         receiveItemDao.create(receiveItem);
-        stockService.increaseStockLevelFor(receiveItem.getCommodity(), receiveItem.getQuantityReceived(), receiveItem.created());
+        commoditySnapshotService.add(stockService.increaseStockLevelFor(receiveItem.getCommodity(), receiveItem.getQuantityReceived(), receiveItem.created()), true);
         commoditySnapshotService.add(receiveItem);