ByteCodes (XApi - Bytecode Reader 0.4 API)

java.lang.Object
- java.lang.Enum<ByteCodes>
- - xapi.bytecode.api.ByteCodes

All Implemented Interfaces:

Serializable, Comparable<ByteCodes>, IsByteCode
```
public enum ByteCodes
extends Enum<ByteCodes>
implements IsByteCode
```

Enum Constant Summary

Enum Constants
Enum Constant and Description
`_goto` 2: branchbyte1, branchbyte2 [no change] goes to another instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`_instanceof` 2: indexbyte1, indexbyte2 objectref → result determines if an object objectref is of a given type, identified by class reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`_new` 2: indexbyte1, indexbyte2 → objectref create new object of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2)
`_return` → [empty] return void from method
`aaload` arrayref, index → value load onto the stack a reference from an array
`aastore` arrayref, index, value → store into a reference in an array
`aconst_null` → null push a null reference onto the stack
`aload` 1: index → objectref load a reference onto the stack from a local variable #index
`aload_0` → objectref load a reference onto the stack from local variable 0
`aload_1` → objectref load a reference onto the stack from local variable 1
`aload_2` → objectref load a reference onto the stack from local variable 2
`aload_3` → objectref load a reference onto the stack from local variable 3
`anewarray` 2: indexbyte1, indexbyte2 count → arrayref create a new array of references of length count and component type identified by the class reference index (indexbyte1 << 8 + indexbyte2) in the constant pool
`areturn` objectref → [empty] return a reference from a method
`arraylength` arrayref → length get the length of an array
`astore` 1: index objectref → store a reference into a local variable #index
`astore_0` objectref → store a reference into local variable 0
`astore_1` objectref → store a reference into local variable 1
`astore_2` objectref → store a reference into local variable 2
`astore_3` objectref → store a reference into local variable 3
`athrow` objectref → [empty], objectref throws an error or exception (notice that the rest of the stack is cleared, leaving only a reference to the Throwable)
`baload` arrayref, index → value load a byte or Boolean value from an array
`bastore` arrayref, index, value → store a byte or Boolean value into an array
`bipush` 10 1: byte → value push a byte onto the stack as an integer value
`breakpoint` reserved for breakpoints in Java debuggers; should not appear in any class file
`caload` arrayref, index → value load a char from an array
`castore` arrayref, index, value → store a char into an array
`checkcast` 2: indexbyte1, indexbyte2 objectref → objectref checks whether an objectref is of a certain type, the class reference of which is in the constant pool at index (indexbyte1 << 8 + indexbyte2)
`d2f` value → result convert a double to a float
`d2i` value → result convert a double to an int
`d2l` value → result convert a double to a long
`dadd` value1, value2 → result add two doubles
`daload` arrayref, index → value load a double from an array
`dastore` arrayref, index, value → store a double into an array
`dcmpg` value1, value2 → result compare two doubles
`dcmpl` value1, value2 → result compare two doubles
`dconst_0` → 0.0 push the constant 0.0 onto the stack
`dconst_1` → 1.0 push the constant 1.0 onto the stack
`ddiv` value1, value2 → result divide two doubles
`dload` 1: index → value load a double value from a local variable #index
`dload_0` → value load a double from local variable 0
`dload_1` → value load a double from local variable 1
`dload_2` → value load a double from local variable 2
`dload_3` → value load a double from local variable 3
`dmul` value1, value2 → result multiply two doubles
`dneg` value → result negate a double
`drem` value1, value2 → result get the remainder from a division between two doubles
`dreturn` value → [empty] return a double from a method
`dstore` 1: index value → store a double value into a local variable #index
`dstore_0` value → store a double into local variable 0
`dstore_1` value → store a double into local variable 1
`dstore_2` value → store a double into local variable 2
`dstore_3` value → store a double into local variable 3
`dsub` value1, value2 → result subtract a double from another
`dup` value → value, value duplicate the value on top of the stack
`dup_x1` value2, value1 → value1, value2, value1 insert a copy of the top value into the stack two values from the top.
`dup_x2` value3, value2, value1 → value1, value3, value2, value1 insert a copy of the top value into the stack two (if value2 is double or long it takes up the entry of value3, too) or three values (if value2 is neither double nor long) from the top
`dup2` {value2, value1} → {value2, value1}, {value2, value1} duplicate top two stack words (two values, if value1 is not double nor long; a single value, if value1 is double or long)
`dup2_x1` value3, {value2, value1} → {value2, value1}, value3, {value2, value1} duplicate two words and insert beneath third word (see explanation above)
`dup2_x2` {value4, value3}, {value2, value1} → {value2, value1}, {value4, value3}, {value2, value1} duplicate two words and insert beneath fourth word
`f2d` value → result convert a float to a double
`f2i` value → result convert a float to an int
`f2l` value → result convert a float to a long
`fadd` value1, value2 → result add two floats
`faload` arrayref, index → value load a float from an array
`fastore` arrayref, index, value → store a float in an array
`fcmpg` value1, value2 → result compare two floats
`fcmpl` value1, value2 → result compare two floats
`fconst_0` → 0.0f push 0.0f on the stack
`fconst_1` → 1.0f push 1.0f on the stack
`fconst_2` → 2.0f push 2.0f on the stack
`fdiv` value1, value2 → result divide two floats
`fload` 1: index → value load a float value from a local variable #index
`fload_0` → value load a float value from local variable 0
`fload_1` → value load a float value from local variable 1
`fload_2` → value load a float value from local variable 2
`fload_3` → value load a float value from local variable 3
`fmul` value1, value2 → result multiply two floats
`fneg` value → result negate a float
`frem` value1, value2 → result get the remainder from a division between two floats
`freturn` value → [empty] return a float
`fstore` 1: index value → store a float value into a local variable #index
`fstore_0` value → store a float value into local variable 0
`fstore_1` value → store a float value into local variable 1
`fstore_2` value → store a float value into local variable 2
`fstore_3` value → store a float value into local variable 3
`fsub` value1, value2 → result subtract two floats
`getfield` 2: index1, index2 objectref → value get a field value of an object objectref, where the field is identified by field reference in the constant pool index (index1 << 8 + index2)
`getstatic` 2: index1, index2 → value get a static field value of a class, where the field is identified by field reference in the constant pool index (index1 << 8 + index2)
`goto_w` 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 [no change] goes to another instruction at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4)
`i2b` value → result convert an int into a byte
`i2c` value → result convert an int into a character
`i2d` value → result convert an int into a double
`i2f` value → result convert an int into a float
`i2l` value → result convert an int into a long
`i2s` value → result convert an int into a short
`iadd` value1, value2 → result add two ints
`iaload` arrayref, index → value load an int from an array
`iand` value1, value2 → result perform a bitwise and on two integers
`iastore` arrayref, index, value → store an int into an array
`iconst_0` → 0 load the int value 0 onto the stack
`iconst_1` → 1 load the int value 1 onto the stack
`iconst_2` → 2 load the int value 2 onto the stack
`iconst_3` → 3 load the int value 3 onto the stack
`iconst_4` → 4 load the int value 4 onto the stack
`iconst_5` → 5 load the int value 5 onto the stack
`iconst_m1` → -1 load the int value -1 onto the stack
`idiv` value1, value2 → result divide two integers
`if_acmpeq` 2: branchbyte1, branchbyte2 value1, value2 → if references are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_acmpne` 2: branchbyte1, branchbyte2 value1, value2 → if references are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_icmpeq` 2: branchbyte1, branchbyte2 value1, value2 → if ints are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_icmpge` 2: branchbyte1, branchbyte2 value1, value2 → if value1 is greater than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_icmpgt` 2: branchbyte1, branchbyte2 value1, value2 → if value1 is greater than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_icmple` 2: branchbyte1, branchbyte2 value1, value2 → if value1 is less than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_icmplt` 2: branchbyte1, branchbyte2 value1, value2 → if value1 is less than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`if_icmpne` 2: branchbyte1, branchbyte2 value1, value2 → if ints are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifeq` 2: branchbyte1, branchbyte2 value → if value is 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifge` 2: branchbyte1, branchbyte2 value → if value is greater than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifgt` 2: branchbyte1, branchbyte2 value → if value is greater than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifle` 2: branchbyte1, branchbyte2 value → if value is less than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`iflt` 2: branchbyte1, branchbyte2 value → if value is less than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifne` 2: branchbyte1, branchbyte2 value → if value is not 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifnonnull` 2: branchbyte1, branchbyte2 value → if value is not null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`ifnull` 2: branchbyte1, branchbyte2 value → if value is null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
`iinc` 2: index, const [No change] increment local variable #index by signed byte const
`iload` 1: index → value load an int value from a local variable #index
`iload_0` → value load an int value from local variable 0
`iload_1` → value load an int value from local variable 1
`iload_2` → value load an int value from local variable 2
`iload_3` → value load an int value from local variable 3
`impdep1` reserved for implementation-dependent operations within debuggers; should not appear in any class file
`impdep2` reserved for implementation-dependent operations within debuggers; should not appear in any class file
`imul` value1, value2 → result multiply two integers
`ineg` value → result negate int
`invokedynamic` 4: indexbyte1, indexbyte2, 0, 0 [arg1, [arg2 ...]] → invokes a dynamic method identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`invokeinterface` 4: indexbyte1, indexbyte2, count, 0 objectref, [arg1, arg2, ...] → invokes an interface method on object objectref, where the interface method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`invokespecial` 2: indexbyte1, indexbyte2 objectref, [arg1, arg2, ...] → invoke instance method on object objectref, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`invokestatic` 2: indexbyte1, indexbyte2 [arg1, arg2, ...] → invoke a static method, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`invokevirtual` 2: indexbyte1, indexbyte2 objectref, [arg1, arg2, ...] → invoke virtual method on object objectref, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`ior` value1, value2 → result bitwise int or
`irem` value1, value2 → result logical int remainder
`ireturn` value → [empty] return an integer from a method
`ishl` value1, value2 → result int shift left
`ishr` value1, value2 → result int arithmetic shift right
`istore` 1: index value → store int value into variable #index
`istore_0` value → store int value into variable 0
`istore_1` value → store int value into variable 1
`istore_2` value → store int value into variable 2
`istore_3` value → store int value into variable 3
`isub` value1, value2 → result int subtract
`iushr` value1, value2 → result int logical shift right
`ixor` value1, value2 → result int xor
`jsr` 2: branchbyte1, branchbyte2 → address jump to subroutine at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2) and place the return address on the stack
`jsr_w` 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 → address jump to subroutine at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4) and place the return address on the stack
`l2d` value → result convert a long to a double
`l2f` value → result convert a long to a float
`l2i` value → result convert a long to a int
`ladd` value1, value2 → result add two longs
`laload` arrayref, index → value load a long from an array
`land` value1, value2 → result bitwise and of two longs
`lastore` arrayref, index, value → store a long to an array
`lcmp` value1, value2 → result compare two longs values
`lconst_0` → 0L push the long 0 onto the stack
`lconst_1` → 1L push the long 1 onto the stack
`ldc` 1: index → value push a constant #index from a constant pool (String, int or float) onto the stack
`ldc_w` 2: indexbyte1, indexbyte2 → value push a constant #index from a constant pool (String, int or float) onto the stack (wide index is constructed as indexbyte1 << 8 + indexbyte2)
`ldc2_w` 2: indexbyte1, indexbyte2 → value push a constant #index from a constant pool (double or long) onto the stack (wide index is constructed as indexbyte1 << 8 + indexbyte2)
`ldiv` value1, value2 → result divide two longs
`lload` 1: index → value load a long value from a local variable #index
`lload_0` → value load a long value from a local variable 0
`lload_1` → value load a long value from a local variable 1
`lload_2` → value load a long value from a local variable 2
`lload_3` → value load a long value from a local variable 3
`lmul` value1, value2 → result multiply two longs
`lneg` value → result negate a long
`lookupswitch` 4+: <0-3 bytes padding>, defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, npairs1, npairs2, npairs3, npairs4, match-offset pairs...
`lor` value1, value2 → result bitwise or of two longs
`lrem` value1, value2 → result remainder of division of two longs
`lreturn` value → [empty] return a long value
`lshl` value1, value2 → result bitwise shift left of a long value1 by value2 positions
`lshr` value1, value2 → result bitwise shift right of a long value1 by value2 positions
`lstore` 1: index value → store a long value in a local variable #index
`lstore_0` value → store a long value in a local variable 0
`lstore_1` value → store a long value in a local variable 1
`lstore_2` value → store a long value in a local variable 2
`lstore_3` value → store a long value in a local variable 3
`lsub` value1, value2 → result subtract two longs
`lushr` value1, value2 → result bitwise shift right of a long value1 by value2 positions, unsigned
`lxor` value1, value2 → result bitwise exclusive or of two longs
`monitorenter` objectref → enter monitor for object ("grab the lock" - start of synchronized() section)
`monitorexit` objectref → exit monitor for object ("release the lock" - end of synchronized() section)
`multianewarray` 3: indexbyte1, indexbyte2, dimensions count1, [count2,...] → arrayref create a new array of dimensions dimensions with elements of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2); the sizes of each dimension is identified by count1, [count2, etc.]
`newarray` 1: atype count → arrayref create new array with count elements of primitive type identified by atype
`nop` [No change] perform no operation
`pop` value → discard the top value on the stack
`pop2` {value2, value1} → discard the top two values on the stack (or one value, if it is a double or long)
`putfield` 2: indexbyte1, indexbyte2 objectref, value → set field to value in an object objectref, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`putstatic` 2: indexbyte1, indexbyte2 value → set static field to value in a class, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 + indexbyte2)
`ret` 1: index [No change] continue execution from address taken from a local variable #index (the asymmetry with jsr is intentional)
`saload` arrayref, index → value load short from array
`sastore` arrayref, index, value → store short to array
`sipush` : byte1, byte2 → value push a short onto the stack
`swap` value2, value1 → value1, value2 swaps two top words on the stack (note that value1 and value2 must not be double or long)
`tableswitch` 4+: [0-3 bytes padding], defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, lowbyte1, lowbyte2, lowbyte3, lowbyte4, highbyte1, highbyte2, highbyte3, highbyte4, jump offsets...
`wide` 3/5: opcode, indexbyte1, indexbyte2 or iinc, indexbyte1, indexbyte2, countbyte1, countbyte2 [same as for corresponding instructions] execute opcode, where opcode is either iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore, or ret, but assume the index is 16 bit; or execute iinc, where the index is 16 bits and the constant to increment by is a signed 16 bit short

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`code()`
`static ByteCodes`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static ByteCodes[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`int`	`width()`

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Enum Constant Detail
  - aaload
```
public static final ByteCodes aaload
```
    arrayref, index → value load onto the stack a reference from an array
  - aastore
```
public static final ByteCodes aastore
```
    arrayref, index, value → store into a reference in an array
  - aconst_null
```
public static final ByteCodes aconst_null
```
    → null push a null reference onto the stack
  - aload
```
public static final ByteCodes aload
```
    1: index → objectref load a reference onto the stack from a local variable #index
  - aload_0
```
public static final ByteCodes aload_0
```
    → objectref load a reference onto the stack from local variable 0
  - aload_1
```
public static final ByteCodes aload_1
```
    → objectref load a reference onto the stack from local variable 1
  - aload_2
```
public static final ByteCodes aload_2
```
    → objectref load a reference onto the stack from local variable 2
  - aload_3
```
public static final ByteCodes aload_3
```
    → objectref load a reference onto the stack from local variable 3
  - anewarray
```
public static final ByteCodes anewarray
```
    2: indexbyte1, indexbyte2 count → arrayref create a new array of references of length count and component type identified by the class reference index (indexbyte1 << 8 + indexbyte2) in the constant pool
  - areturn
```
public static final ByteCodes areturn
```
    objectref → [empty] return a reference from a method
  - arraylength
```
public static final ByteCodes arraylength
```
    arrayref → length get the length of an array
  - astore
```
public static final ByteCodes astore
```
    1: index objectref → store a reference into a local variable #index
  - astore_0
```
public static final ByteCodes astore_0
```
    objectref → store a reference into local variable 0
  - astore_1
```
public static final ByteCodes astore_1
```
    objectref → store a reference into local variable 1
  - astore_2
```
public static final ByteCodes astore_2
```
    objectref → store a reference into local variable 2
  - astore_3
```
public static final ByteCodes astore_3
```
    objectref → store a reference into local variable 3
  - athrow
```
public static final ByteCodes athrow
```
    objectref → [empty], objectref throws an error or exception (notice that the rest of the stack is cleared, leaving only a reference to the Throwable)
  - baload
```
public static final ByteCodes baload
```
    arrayref, index → value load a byte or Boolean value from an array
  - bastore
```
public static final ByteCodes bastore
```
    arrayref, index, value → store a byte or Boolean value into an array
  - bipush
```
public static final ByteCodes bipush
```
    10 1: byte → value push a byte onto the stack as an integer value
  - caload
```
public static final ByteCodes caload
```
    arrayref, index → value load a char from an array
  - castore
```
public static final ByteCodes castore
```
    arrayref, index, value → store a char into an array
  - checkcast
```
public static final ByteCodes checkcast
```
    2: indexbyte1, indexbyte2 objectref → objectref checks whether an objectref is of a certain type, the class reference of which is in the constant pool at index (indexbyte1 << 8 + indexbyte2)
  - dadd
```
public static final ByteCodes dadd
```
    value1, value2 → result add two doubles
  - daload
```
public static final ByteCodes daload
```
    arrayref, index → value load a double from an array
  - dastore
```
public static final ByteCodes dastore
```
    arrayref, index, value → store a double into an array
  - dcmpg
```
public static final ByteCodes dcmpg
```
    value1, value2 → result compare two doubles
  - dcmpl
```
public static final ByteCodes dcmpl
```
    value1, value2 → result compare two doubles
  - dconst_0
```
public static final ByteCodes dconst_0
```
    → 0.0 push the constant 0.0 onto the stack
  - dconst_1
```
public static final ByteCodes dconst_1
```
    → 1.0 push the constant 1.0 onto the stack
  - ddiv
```
public static final ByteCodes ddiv
```
    value1, value2 → result divide two doubles
  - dload
```
public static final ByteCodes dload
```
    1: index → value load a double value from a local variable #index
  - dload_0
```
public static final ByteCodes dload_0
```
    → value load a double from local variable 0
  - dload_1
```
public static final ByteCodes dload_1
```
    → value load a double from local variable 1
  - dload_2
```
public static final ByteCodes dload_2
```
    → value load a double from local variable 2
  - dload_3
```
public static final ByteCodes dload_3
```
    → value load a double from local variable 3
  - dmul
```
public static final ByteCodes dmul
```
    value1, value2 → result multiply two doubles
  - dneg
```
public static final ByteCodes dneg
```
    value → result negate a double
  - drem
```
public static final ByteCodes drem
```
    value1, value2 → result get the remainder from a division between two doubles
  - dreturn
```
public static final ByteCodes dreturn
```
    value → [empty] return a double from a method
  - dstore
```
public static final ByteCodes dstore
```
    1: index value → store a double value into a local variable #index
  - dstore_0
```
public static final ByteCodes dstore_0
```
    value → store a double into local variable 0
  - dstore_1
```
public static final ByteCodes dstore_1
```
    value → store a double into local variable 1
  - dstore_2
```
public static final ByteCodes dstore_2
```
    value → store a double into local variable 2
  - dstore_3
```
public static final ByteCodes dstore_3
```
    value → store a double into local variable 3
  - dsub
```
public static final ByteCodes dsub
```
    value1, value2 → result subtract a double from another
  - dup
```
public static final ByteCodes dup
```
    value → value, value duplicate the value on top of the stack
  - dup_x1
```
public static final ByteCodes dup_x1
```
    value2, value1 → value1, value2, value1 insert a copy of the top value into the stack two values from the top. value1 and value2 must not be of the type double or long.
  - dup_x2
```
public static final ByteCodes dup_x2
```
    value3, value2, value1 → value1, value3, value2, value1 insert a copy of the top value into the stack two (if value2 is double or long it takes up the entry of value3, too) or three values (if value2 is neither double nor long) from the top
  - dup2
```
public static final ByteCodes dup2
```
    {value2, value1} → {value2, value1}, {value2, value1} duplicate top two stack words (two values, if value1 is not double nor long; a single value, if value1 is double or long)
  - dup2_x1
```
public static final ByteCodes dup2_x1
```
    value3, {value2, value1} → {value2, value1}, value3, {value2, value1} duplicate two words and insert beneath third word (see explanation above)
  - dup2_x2
```
public static final ByteCodes dup2_x2
```
    {value4, value3}, {value2, value1} → {value2, value1}, {value4, value3}, {value2, value1} duplicate two words and insert beneath fourth word
  - fadd
```
public static final ByteCodes fadd
```
    value1, value2 → result add two floats
  - faload
```
public static final ByteCodes faload
```
    arrayref, index → value load a float from an array
  - fastore
```
public static final ByteCodes fastore
```
    arrayref, index, value → store a float in an array
  - fcmpg
```
public static final ByteCodes fcmpg
```
    value1, value2 → result compare two floats
  - fcmpl
```
public static final ByteCodes fcmpl
```
    value1, value2 → result compare two floats
  - fconst_0
```
public static final ByteCodes fconst_0
```
    → 0.0f push 0.0f on the stack
  - fconst_1
```
public static final ByteCodes fconst_1
```
    → 1.0f push 1.0f on the stack
  - fconst_2
```
public static final ByteCodes fconst_2
```
    → 2.0f push 2.0f on the stack
  - fdiv
```
public static final ByteCodes fdiv
```
    value1, value2 → result divide two floats
  - fload
```
public static final ByteCodes fload
```
    1: index → value load a float value from a local variable #index
  - fload_0
```
public static final ByteCodes fload_0
```
    → value load a float value from local variable 0
  - fload_1
```
public static final ByteCodes fload_1
```
    → value load a float value from local variable 1
  - fload_2
```
public static final ByteCodes fload_2
```
    → value load a float value from local variable 2
  - fload_3
```
public static final ByteCodes fload_3
```
    → value load a float value from local variable 3
  - fmul
```
public static final ByteCodes fmul
```
    value1, value2 → result multiply two floats
  - fneg
```
public static final ByteCodes fneg
```
    value → result negate a float
  - frem
```
public static final ByteCodes frem
```
    value1, value2 → result get the remainder from a division between two floats
  - freturn
```
public static final ByteCodes freturn
```
    value → [empty] return a float
  - fstore
```
public static final ByteCodes fstore
```
    1: index value → store a float value into a local variable #index
  - fstore_0
```
public static final ByteCodes fstore_0
```
    value → store a float value into local variable 0
  - fstore_1
```
public static final ByteCodes fstore_1
```
    value → store a float value into local variable 1
  - fstore_2
```
public static final ByteCodes fstore_2
```
    value → store a float value into local variable 2
  - fstore_3
```
public static final ByteCodes fstore_3
```
    value → store a float value into local variable 3
  - fsub
```
public static final ByteCodes fsub
```
    value1, value2 → result subtract two floats
  - getfield
```
public static final ByteCodes getfield
```
    2: index1, index2 objectref → value get a field value of an object objectref, where the field is identified by field reference in the constant pool index (index1 << 8 + index2)
  - getstatic
```
public static final ByteCodes getstatic
```
    2: index1, index2 → value get a static field value of a class, where the field is identified by field reference in the constant pool index (index1 << 8 + index2)
  - _goto
```
public static final ByteCodes _goto
```
    2: branchbyte1, branchbyte2 [no change] goes to another instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - goto_w
```
public static final ByteCodes goto_w
```
    4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 [no change] goes to another instruction at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4)
  - i2l
```
public static final ByteCodes i2l
```
    value → result convert an int into a long
  - i2f
```
public static final ByteCodes i2f
```
    value → result convert an int into a float
  - i2d
```
public static final ByteCodes i2d
```
    value → result convert an int into a double
  - l2i
```
public static final ByteCodes l2i
```
    value → result convert a long to a int
  - l2f
```
public static final ByteCodes l2f
```
    value → result convert a long to a float
  - l2d
```
public static final ByteCodes l2d
```
    value → result convert a long to a double
  - f2i
```
public static final ByteCodes f2i
```
    value → result convert a float to an int
  - f2l
```
public static final ByteCodes f2l
```
    value → result convert a float to a long
  - f2d
```
public static final ByteCodes f2d
```
    value → result convert a float to a double
  - d2i
```
public static final ByteCodes d2i
```
    value → result convert a double to an int
  - d2l
```
public static final ByteCodes d2l
```
    value → result convert a double to a long
  - d2f
```
public static final ByteCodes d2f
```
    value → result convert a double to a float
  - i2b
```
public static final ByteCodes i2b
```
    value → result convert an int into a byte
  - i2c
```
public static final ByteCodes i2c
```
    value → result convert an int into a character
  - i2s
```
public static final ByteCodes i2s
```
    value → result convert an int into a short
  - iadd
```
public static final ByteCodes iadd
```
    value1, value2 → result add two ints
  - iaload
```
public static final ByteCodes iaload
```
    arrayref, index → value load an int from an array
  - iand
```
public static final ByteCodes iand
```
    value1, value2 → result perform a bitwise and on two integers
  - iastore
```
public static final ByteCodes iastore
```
    arrayref, index, value → store an int into an array
  - iconst_m1
```
public static final ByteCodes iconst_m1
```
    → -1 load the int value -1 onto the stack
  - iconst_0
```
public static final ByteCodes iconst_0
```
    → 0 load the int value 0 onto the stack
  - iconst_1
```
public static final ByteCodes iconst_1
```
    → 1 load the int value 1 onto the stack
  - iconst_2
```
public static final ByteCodes iconst_2
```
    → 2 load the int value 2 onto the stack
  - iconst_3
```
public static final ByteCodes iconst_3
```
    → 3 load the int value 3 onto the stack
  - iconst_4
```
public static final ByteCodes iconst_4
```
    → 4 load the int value 4 onto the stack
  - iconst_5
```
public static final ByteCodes iconst_5
```
    → 5 load the int value 5 onto the stack
  - idiv
```
public static final ByteCodes idiv
```
    value1, value2 → result divide two integers
  - if_acmpeq
```
public static final ByteCodes if_acmpeq
```
    2: branchbyte1, branchbyte2 value1, value2 → if references are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_acmpne
```
public static final ByteCodes if_acmpne
```
    2: branchbyte1, branchbyte2 value1, value2 → if references are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_icmpeq
```
public static final ByteCodes if_icmpeq
```
    2: branchbyte1, branchbyte2 value1, value2 → if ints are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_icmpne
```
public static final ByteCodes if_icmpne
```
    2: branchbyte1, branchbyte2 value1, value2 → if ints are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_icmplt
```
public static final ByteCodes if_icmplt
```
    2: branchbyte1, branchbyte2 value1, value2 → if value1 is less than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_icmpge
```
public static final ByteCodes if_icmpge
```
    2: branchbyte1, branchbyte2 value1, value2 → if value1 is greater than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_icmpgt
```
public static final ByteCodes if_icmpgt
```
    2: branchbyte1, branchbyte2 value1, value2 → if value1 is greater than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - if_icmple
```
public static final ByteCodes if_icmple
```
    2: branchbyte1, branchbyte2 value1, value2 → if value1 is less than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifeq
```
public static final ByteCodes ifeq
```
    2: branchbyte1, branchbyte2 value → if value is 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifne
```
public static final ByteCodes ifne
```
    2: branchbyte1, branchbyte2 value → if value is not 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - iflt
```
public static final ByteCodes iflt
```
    2: branchbyte1, branchbyte2 value → if value is less than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifge
```
public static final ByteCodes ifge
```
    2: branchbyte1, branchbyte2 value → if value is greater than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifgt
```
public static final ByteCodes ifgt
```
    2: branchbyte1, branchbyte2 value → if value is greater than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifle
```
public static final ByteCodes ifle
```
    2: branchbyte1, branchbyte2 value → if value is less than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifnonnull
```
public static final ByteCodes ifnonnull
```
    2: branchbyte1, branchbyte2 value → if value is not null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - ifnull
```
public static final ByteCodes ifnull
```
    2: branchbyte1, branchbyte2 value → if value is null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
  - iinc
```
public static final ByteCodes iinc
```
    2: index, const [No change] increment local variable #index by signed byte const
  - iload
```
public static final ByteCodes iload
```
    1: index → value load an int value from a local variable #index
  - iload_0
```
public static final ByteCodes iload_0
```
    → value load an int value from local variable 0
  - iload_1
```
public static final ByteCodes iload_1
```
    → value load an int value from local variable 1
  - iload_2
```
public static final ByteCodes iload_2
```
    → value load an int value from local variable 2
  - iload_3
```
public static final ByteCodes iload_3
```
    → value load an int value from local variable 3
  - imul
```
public static final ByteCodes imul
```
    value1, value2 → result multiply two integers
  - ineg
```
public static final ByteCodes ineg
```
    value → result negate int
  - _instanceof
```
public static final ByteCodes _instanceof
```
    2: indexbyte1, indexbyte2 objectref → result determines if an object objectref is of a given type, identified by class reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - invokedynamic
```
public static final ByteCodes invokedynamic
```
    4: indexbyte1, indexbyte2, 0, 0 [arg1, [arg2 ...]] → invokes a dynamic method identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - invokeinterface
```
public static final ByteCodes invokeinterface
```
    4: indexbyte1, indexbyte2, count, 0 objectref, [arg1, arg2, ...] → invokes an interface method on object objectref, where the interface method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - invokespecial
```
public static final ByteCodes invokespecial
```
    2: indexbyte1, indexbyte2 objectref, [arg1, arg2, ...] → invoke instance method on object objectref, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - invokestatic
```
public static final ByteCodes invokestatic
```
    2: indexbyte1, indexbyte2 [arg1, arg2, ...] → invoke a static method, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - invokevirtual
```
public static final ByteCodes invokevirtual
```
    2: indexbyte1, indexbyte2 objectref, [arg1, arg2, ...] → invoke virtual method on object objectref, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - ior
```
public static final ByteCodes ior
```
    value1, value2 → result bitwise int or
  - irem
```
public static final ByteCodes irem
```
    value1, value2 → result logical int remainder
  - ireturn
```
public static final ByteCodes ireturn
```
    value → [empty] return an integer from a method
  - ishl
```
public static final ByteCodes ishl
```
    value1, value2 → result int shift left
  - ishr
```
public static final ByteCodes ishr
```
    value1, value2 → result int arithmetic shift right
  - istore
```
public static final ByteCodes istore
```
    1: index value → store int value into variable #index
  - istore_0
```
public static final ByteCodes istore_0
```
    value → store int value into variable 0
  - istore_1
```
public static final ByteCodes istore_1
```
    value → store int value into variable 1
  - istore_2
```
public static final ByteCodes istore_2
```
    value → store int value into variable 2
  - istore_3
```
public static final ByteCodes istore_3
```
    value → store int value into variable 3
  - isub
```
public static final ByteCodes isub
```
    value1, value2 → result int subtract
  - iushr
```
public static final ByteCodes iushr
```
    value1, value2 → result int logical shift right
  - ixor
```
public static final ByteCodes ixor
```
    value1, value2 → result int xor
  - jsr
```
public static final ByteCodes jsr
```
    2: branchbyte1, branchbyte2 → address jump to subroutine at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2) and place the return address on the stack
  - jsr_w
```
public static final ByteCodes jsr_w
```
    4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 → address jump to subroutine at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4) and place the return address on the stack
  - ladd
```
public static final ByteCodes ladd
```
    value1, value2 → result add two longs
  - laload
```
public static final ByteCodes laload
```
    arrayref, index → value load a long from an array
  - land
```
public static final ByteCodes land
```
    value1, value2 → result bitwise and of two longs
  - lastore
```
public static final ByteCodes lastore
```
    arrayref, index, value → store a long to an array
  - lcmp
```
public static final ByteCodes lcmp
```
    value1, value2 → result compare two longs values
  - lconst_0
```
public static final ByteCodes lconst_0
```
    → 0L push the long 0 onto the stack
  - lconst_1
```
public static final ByteCodes lconst_1
```
    → 1L push the long 1 onto the stack
  - ldc
```
public static final ByteCodes ldc
```
    1: index → value push a constant #index from a constant pool (String, int or float) onto the stack
  - ldc_w
```
public static final ByteCodes ldc_w
```
    2: indexbyte1, indexbyte2 → value push a constant #index from a constant pool (String, int or float) onto the stack (wide index is constructed as indexbyte1 << 8 + indexbyte2)
  - ldc2_w
```
public static final ByteCodes ldc2_w
```
    2: indexbyte1, indexbyte2 → value push a constant #index from a constant pool (double or long) onto the stack (wide index is constructed as indexbyte1 << 8 + indexbyte2)
  - ldiv
```
public static final ByteCodes ldiv
```
    value1, value2 → result divide two longs
  - lload
```
public static final ByteCodes lload
```
    1: index → value load a long value from a local variable #index
  - lload_0
```
public static final ByteCodes lload_0
```
    → value load a long value from a local variable 0
  - lload_1
```
public static final ByteCodes lload_1
```
    → value load a long value from a local variable 1
  - lload_2
```
public static final ByteCodes lload_2
```
    → value load a long value from a local variable 2
  - lload_3
```
public static final ByteCodes lload_3
```
    → value load a long value from a local variable 3
  - lmul
```
public static final ByteCodes lmul
```
    value1, value2 → result multiply two longs
  - lneg
```
public static final ByteCodes lneg
```
    value → result negate a long
  - lookupswitch
```
public static final ByteCodes lookupswitch
```
    4+: <0-3 bytes padding>, defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, npairs1, npairs2, npairs3, npairs4, match-offset pairs... key → a target address is looked up from a table using a key and execution continues from the instruction at that address
  - lor
```
public static final ByteCodes lor
```
    value1, value2 → result bitwise or of two longs
  - lrem
```
public static final ByteCodes lrem
```
    value1, value2 → result remainder of division of two longs
  - lreturn
```
public static final ByteCodes lreturn
```
    value → [empty] return a long value
  - lshl
```
public static final ByteCodes lshl
```
    value1, value2 → result bitwise shift left of a long value1 by value2 positions
  - lshr
```
public static final ByteCodes lshr
```
    value1, value2 → result bitwise shift right of a long value1 by value2 positions
  - lstore
```
public static final ByteCodes lstore
```
    1: index value → store a long value in a local variable #index
  - lstore_0
```
public static final ByteCodes lstore_0
```
    value → store a long value in a local variable 0
  - lstore_1
```
public static final ByteCodes lstore_1
```
    value → store a long value in a local variable 1
  - lstore_2
```
public static final ByteCodes lstore_2
```
    value → store a long value in a local variable 2
  - lstore_3
```
public static final ByteCodes lstore_3
```
    value → store a long value in a local variable 3
  - lsub
```
public static final ByteCodes lsub
```
    value1, value2 → result subtract two longs
  - lushr
```
public static final ByteCodes lushr
```
    value1, value2 → result bitwise shift right of a long value1 by value2 positions, unsigned
  - lxor
```
public static final ByteCodes lxor
```
    value1, value2 → result bitwise exclusive or of two longs
  - monitorenter
```
public static final ByteCodes monitorenter
```
    objectref → enter monitor for object ("grab the lock" - start of synchronized() section)
  - monitorexit
```
public static final ByteCodes monitorexit
```
    objectref → exit monitor for object ("release the lock" - end of synchronized() section)
  - multianewarray
```
public static final ByteCodes multianewarray
```
    3: indexbyte1, indexbyte2, dimensions count1, [count2,...] → arrayref create a new array of dimensions dimensions with elements of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2); the sizes of each dimension is identified by count1, [count2, etc.]
  - _new
```
public static final ByteCodes _new
```
    2: indexbyte1, indexbyte2 → objectref create new object of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2)
  - newarray
```
public static final ByteCodes newarray
```
    1: atype count → arrayref create new array with count elements of primitive type identified by atype
  - nop
```
public static final ByteCodes nop
```
    [No change] perform no operation
  - pop
```
public static final ByteCodes pop
```
    value → discard the top value on the stack
  - pop2
```
public static final ByteCodes pop2
```
    {value2, value1} → discard the top two values on the stack (or one value, if it is a double or long)
  - putfield
```
public static final ByteCodes putfield
```
    2: indexbyte1, indexbyte2 objectref, value → set field to value in an object objectref, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - putstatic
```
public static final ByteCodes putstatic
```
    2: indexbyte1, indexbyte2 value → set static field to value in a class, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 + indexbyte2)
  - ret
```
public static final ByteCodes ret
```
    1: index [No change] continue execution from address taken from a local variable #index (the asymmetry with jsr is intentional)
  - _return
```
public static final ByteCodes _return
```
    → [empty] return void from method
  - saload
```
public static final ByteCodes saload
```
    arrayref, index → value load short from array
  - sastore
```
public static final ByteCodes sastore
```
    arrayref, index, value → store short to array
  - sipush
```
public static final ByteCodes sipush
```
    : byte1, byte2 → value push a short onto the stack
  - swap
```
public static final ByteCodes swap
```
    value2, value1 → value1, value2 swaps two top words on the stack (note that value1 and value2 must not be double or long)
  - tableswitch
```
public static final ByteCodes tableswitch
```
    4+: [0-3 bytes padding], defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, lowbyte1, lowbyte2, lowbyte3, lowbyte4, highbyte1, highbyte2, highbyte3, highbyte4, jump offsets... index → continue execution from an address in the table at offset index
  - wide
```
public static final ByteCodes wide
```
    3/5: opcode, indexbyte1, indexbyte2 or iinc, indexbyte1, indexbyte2, countbyte1, countbyte2 [same as for corresponding instructions] execute opcode, where opcode is either iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore, or ret, but assume the index is 16 bit; or execute iinc, where the index is 16 bits and the constant to increment by is a signed 16 bit short
  - breakpoint
```
public static final ByteCodes breakpoint
```
    reserved for breakpoints in Java debuggers; should not appear in any class file
  - impdep1
```
public static final ByteCodes impdep1
```
    reserved for implementation-dependent operations within debuggers; should not appear in any class file
  - impdep2
```
public static final ByteCodes impdep2
```
    reserved for implementation-dependent operations within debuggers; should not appear in any class file
- Method Detail
  - values
```
public static ByteCodes[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (ByteCodes c : ByteCodes.values())
    System.out.println(c);
```
    Returns:
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static ByteCodes valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    name - the name of the enum constant to be returned.
    
    Returns:
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - code
```
public int code()
```
    Specified by:
    
    code in interface IsByteCode
  - width
```
public int width()
```
    Specified by:
    
    width in interface IsByteCode

Enum ByteCodes

Enum Constant Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

aaload

aastore

aconst_null

aload

aload_0

aload_1

aload_2

aload_3

anewarray

areturn

arraylength

astore

astore_0

astore_1

astore_2

astore_3

athrow

baload

bastore

bipush

caload

castore

checkcast

dadd

daload

dastore

dcmpg

dcmpl

dconst_0

dconst_1

ddiv

dload

dload_0

dload_1

dload_2

dload_3

dmul

dneg

drem

dreturn

dstore

dstore_0

dstore_1

dstore_2

dstore_3

dsub

dup

dup_x1

dup_x2

dup2

dup2_x1

dup2_x2

fadd

faload

fastore

fcmpg

fcmpl

fconst_0

fconst_1

fconst_2

fdiv

fload

fload_0

fload_1

fload_2

fload_3

fmul

fneg

frem

freturn

fstore

fstore_0

fstore_1

fstore_2