Opcode (Beret 1.0.0-SNAPSHOT API)

java.lang.Object
- java.lang.Enum<Opcode>
- - net.caseif.beret.Opcode

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Opcode>
```
public enum Opcode
extends java.lang.Enum<Opcode>
```
An enumeration of all Java bytecode opcodes.

Enum Constant Summary

Enum Constants
Enum Constant and Description
`AALOAD` Loads an references from an array onto the stack.
`AASTORE` Stores a reference in an array.
`ACONST_NULL` Pushes a `null` references onto the stack.
`ALOAD` Loads a reference onto the stack from local variable `index`.
`ALOAD_0` Loads a reference onto the stack from local variable `0`.
`ALOAD_1` Loads a reference onto the stack from local variable `1`.
`ALOAD_2` Loads a reference onto the stack from local variable `2`.
`ALOAD_3` Loads a reference onto the stack from local variable `3`.
`ANEWARRAY` Creates a new array of length `count` and type `typeref`.
`ARETURN` Returns a reference from a method and clears the stack.
`ARRAYLENGTH` Replaces `arrayref` on the top of the stack with its length.
`ASTORE` Stores a reference into local variable `index`.
`ASTORE_0` Stores a references into local variable `0`.
`ASTORE_1` Stores a references into local variable `1`.
`ASTORE_2` Stores a references into local variable `2`.
`ASTORE_3` Stores a references into local variable `3`.
`ATHROW` Throws an error or exception and clears the stack save the reference to the Throwable at the top.
`BALOAD` Loads a byte or boolean value from an array.
`BASTORE` Stores a byte or boolean value into an array.
`BIPUSH` Pushes a byte onto the stack as an integer value.
`BREAKPOINT` Reserved for breakpoints in Java debuggers; should not appear in a class file.
`CALOAD` Loads a char from an array.
`CASTORE` Stores a char into an array.
`CHECKCAST` Checks whether `objectref` matches of the type of the class at `index` of the constant pool.
`D2F` Converts a double to a float.
`D2I` Converts a double to an integer.
`D2L` Converts a double to an long.
`DADD` Adds two doubles.
`DALOAD` Loads a double from an array.
`DASTORE` Stores a double into an array.
`DCMPG` Checks whether double `value1` is greater than double `value2`.
`DCMPL` Checks whether double `value1` is less than double `value2`.
`DCONST_0` Pushes the double constant `0.0` onto the stack.
`DCONST_1` Pushes the double constant `1.0` onto the stack.
`DDIV` Divides two doubles.
`DLOAD` Loads a double from local variable `index`.
`DLOAD_0` Loads a double from local variable `0`.
`DLOAD_1` Loads a double from local variable `1`.
`DLOAD_2` Loads a double from local variable `2`.
`DLOAD_3` Loads a double from local variable `3`.
`DMUL` Multiplies two doubles.
`DNEG` Negates a double.
`DREM` Gets the remainder from division between two doubles (modulus).
`DRETURN` Returns a double from a method and clears the stack.
`DSTORE` Stores double `value` into local variable `index`.
`DSTORE_0` Stores double `value` into local variable `0`.
`DSTORE_1` Stores double `value` into local variable `1`.
`DSTORE_2` Stores double `value` into local variable `2`.
`DSTORE_3` Stores double `value` into local variable `3`.
`DSUB` Subtracts a double from another.
`DUP` Duplicates the value on top of the stack.
`DUP_X1` Inserts a copy of the top value of the stack two values from the top.
`DUP_X2` Inserts a copy of the top value of the stack two (if `value2` is double or long, in which case it occupies the entry of `value3`) or three (if `value2` is neither a double or long) values from the top.
`DUP2` Duplicates the top two stack words (a word being two entries or 8 bytes).
`DUP2_X1` Duplicates the top two stack words and inserts them beneath the third word.
`DUP2_X2` Duplicates the top two stack words and inserts them beneath the fourth word.
`F2D` Converts a float to a double.
`F2I` Converts a float to an int.
`F2L` Converts a float to a long.
`FADD` Adds two floats.
`FALOAD` Loads a float from an array.
`FASTORE` Stores a float in an array.
`FCMPG` Checks whether float `value1` is greater than float `value2`.
`FCMPL` Checks whether float `value1` is less than float `value2`.
`FCONST_0` Pushes the float constant `0.0` onto the stack.
`FCONST_1` Pushes the float constant `1.0` onto the stack.
`FCONST_2` Pushes the float constant `2.0` onto the stack.
`FDIV` Divides two floats.
`FLOAD` Loads a float onto the stack from local variable `index`.
`FLOAD_0` Loads a float onto the stack from local variable `0`.
`FLOAD_1` Loads a float onto the stack from local variable `1`.
`FLOAD_2` Loads a float onto the stack from local variable `2`.
`FLOAD_3` Loads a float onto the stack from local variable `3`.
`FMUL` Multiplies two floats.
`FNEG` Negates a float.
`FREM` Gets the remainder from a division between two floats (modulus).
`FRETURN` Returns a float from a method.
`FSTORE` Stores a float in local variable `index`.
`FSTORE_0` Stores a float in local variable `0`.
`FSTORE_1` Stores a float in local variable `1`.
`FSTORE_2` Stores a float in local variable `2`.
`FSUB` Subtracts two floats.
`GETFIELD` Gets field `fieldref` of object `objectref`.
`GETSTATIC` Gets static field `fieldref` of object `objectref`.
`GOTO` Goes to instruction at `branchoffset`.
`GOTO_W` Goes to instruction at `branchoffset`.
`I2B` Converts an int to a byte.
`I2C` Converts an int to a byte.
`I2D` Converts an int to a character.
`I2F` Converts an int to a double.
`I2L` Converts an int to a long.
`I2S` Converts an int to a short.
`IADD` Adds two ints.
`IALOAD` Loads an int from an array.
`IAND` Performs a bitwise AND on two ints.
`IASTORE` Stores an int into an array.
`ICONST_0` Loads the int constant `0` onto the stack.
`ICONST_1` Loads the int constant `1` onto the stack.
`ICONST_2` Loads the int constant `2` onto the stack.
`ICONST_3` Loads the int constant `3` onto the stack.
`ICONST_4` Loads the int constant `4` onto the stack.
`ICONST_5` Loads the int constant `5` onto the stack.
`ICONST_M1` Loads the int constant `-1` onto the stack.
`IDIV` Divides two ints.
`IF_ACMPEQ` Branches to instruction at `branchoffset` if the two references are equal.
`IF_ACMPNE` Branches to instruction at `branchoffset` if the two references are not equal.
`IF_ICMPEQ` Branches to instruction at `branchoffset` if the two ints are equal.
`IF_ICMPGE` Branches to instruction at `branchoffset` if `value1` is greater than or equal to `value2`.
`IF_ICMPGT` Branches to instruction at `branchoffset` if `value1` is greater than `value2`.
`IF_ICMPLE` Branches to instruction at `branchoffset` if `value1` is less than or equal to `value2`.
`IF_ICMPLT` Branches to instruction at `branchoffset` if `value1` is less than `value2`.
`IF_ICMPNE` Branches to instruction at `branchoffset` if the two ints are not equal.
`IFEQ` Branches to instruction at `branchoffset` if `value` is equal to 0.
`IFGE` Branches to instruction at `branchoffset` if `value` is greater than or equal to 0.
`IFGT` Branches to instruction at `branchoffset` if `value` is greater than 0.
`IFLE` Branches to instruction at `branchoffset` if `value` is less than or equal to 0.
`IFLT` Branches to instruction at `branchoffset` if `value` is less than 0.
`IFNE` Branches to instruction at `branchoffset` if `value` is not equal to 0.
`IFNONNULL` Branches to instruction at `branchoffset` if `value` is not `null`.
`IFNULL` Branches to instruction at `branchoffset` if `value` is `null`.
`IINC` Increment local variable `index` by signed byte `const`.
`ILOAD` Loads int `value` from local variable `index`.
`ILOAD_0` Loads int `value` from local variable `0`.
`ILOAD_1` Loads int `value` from local variable `1`.
`ILOAD_2` Loads int `value` from local variable `2`.
`ILOAD_3` Loads int `value` from local variable `3`.
`IMPDEP1` Reserved for implementation-dependent operations within debuggers.
`IMPDEP2` Reserved for implementation-dependent operations within debuggers.
`IMUL` Multiplies two ints.
`INEG` Negates an int.
`INSTANCEOF` Determines if `objectref` is of the type referenced by `index`.
`INVOKEDYNAMIC` Invokes a dynamic method referenced by `index` and puts the result on the stack.
`INVOKEINTERFACE` Invokes an interface method on object `objectref` and puts the result on the stack.
`INVOKESPECIAL` Invokes an instance method on object `objectref` and puts the result on the stack.
`INVOKESTATIC` Invokes a static method on object `objectref` and puts the result on the stack.
`INVOKEVIRTUAL` Invokes a virtual method on object `objectref` and puts the result on the stack.
`IOR` Performs a bitwise int OR operation on the two values.
`IREM` Performs a logical int remainder operation on the two values.
`IRETURN` Returns an int from a method.
`ISHL` Performs an int shift left operation on the two values.
`ISHR` Performs an int arithmetic shift right operation on the two values.
`ISTORE` Stores int `value` into variable `index`.
`ISTORE_0` Stores int `value` into variable `0`.
`ISTORE_1` Stores int `value` into variable `1`.
`ISTORE_2` Stores int `value` into variable `2`.
`ISTORE_3` Stores int `value` into variable `3`.
`ISUB` Subtracts two ints.
`IUSHR` Performs an int logical shift right operation on the two values.
`IXOR` Performs an int XOR operation on the two values.
`JSR` Jumps to the instruction at `branchoffset` and places the current address on the stack.
`JSR_W` Jumps to the instruction at `branchoffset` and places the current address on the stack.
`L2D` Converts a long to a double.
`L2F` Converts a long to a float.
`L2I` Converts a long to an int.
`LADD` Adds two long values.
`LALOAD` Loads a long from an array.
`LAND` Performs a bitwise AND operation on two longs.
`LASTORE` Stores a long into an array.
`LCMP` Checks whether long `value1` is greater than long `value2`.
`LCONST_0` Pushes the long constant `0L` onto the stack.
`LCONST_1` Pushes the long constant `1L` onto the stack.
`LDC` Pushes a constant `index` (String, int, or float) from the constant pool onto the stack.
`LDC_W` Pushes a constant `index` (String, int, or float) from the constant pool onto the stack.
`LDC2_W` Pushes a constant `index` (double or long) from the constant pool onto the stack.
`LDIV` Divides two longs.
`LLOAD` Loads a long value onto the stack from local variable `index`.
`LLOAD_0` Loads a long value onto the stack from local variable `0`.
`LLOAD_1` Loads a long value onto the stack from local variable `1`.
`LLOAD_2` Loads a long value onto the stack from local variable `2`.
`LLOAD_3` Loads a long value onto the stack from local variable `3`.
`LMUL` Multiplies two longs.
`LNEG` Negates a long.
`LOOKUPSWITCH` TODO: I have no idea how this works at the moment.
`LOR` Performs a bitwise OR operation on two longs.
`LREM` Gets the remainder of division of two longs (modulus).
`LRETURN` Returns a long value from a method and clears the stack.
`LSHL` Performs a bitwise left shift operation of long `value1` by `value2` positions.
`LSHR` Performs a bitwise right shift operation of long `value2` by `value2` positions.
`LSTORE` Stores long `value` in local variable `index`.
`LSTORE_0` Stores long `value` in local variable `0`.
`LSTORE_1` Stores long `value` in local variable `1`.
`LSTORE_2` Stores long `value` in local variable `2`.
`LSTORE_3` Stores long `value` in local variable `3`.
`LSUB` Subtracts a long value from another.
`LUSHR` Performs a bitwise right shift operation of long `value2` by `value2` positions, unsigned.
`LXOR` Performs a bitwise XOR operation on two long values.
`MONITORENTER` Enters monitor state for an object (equivalent to start of `synchronized` block).
`MONITOREXIT` Exits monitor state for an object (equivalent to end of `synchronized` block).
`MULTIANEWARRAY` Creates a new array of `dimensions` with elements of type `classref`.
`NEW` Creates a new object of type `classref`.
`NEWARRAY` Creates a new array with `count` elements of primitive type `atype`.
`NOP` Performs no operation.
`POP` Discards the top value of the stack.
`POP2` Discards the top two values of the stack (or one, if it is of type `double` or `long`.
`PUTFIELD` Sets `fieldref` to `value` in `objectref` to `value`.
`PUTSTATIC` Sets static field `fieldref` to `value` in a class.
`RET` Continues execution from `address`.
`RETURN` Returns `void` from a method.
`SALOAD` Loads a short from an array.
`SASTORE` Stores a short in an array.
`SIPUSH` Pushes short `value` onto the stack.
`SWAP` Swaps the two top words of the stack, provided they are not `double` or `long`.
`TABLESWITCH` Continues execution from an address in the table at offset `index`.
`UNKNOWN` Unknown opcode.
`WIDE` TODO: research.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static Opcode`	`fromByte(byte byteCode)`
`int`	`getAdditionalBytes()` Returns the number of additional bytes which follow this `Opcode`.
`byte`	`getByteCode()` Returns the byte associated with this `Opcode`.
`static Opcode`	`valueOf(java.lang.String name)` Returns the enum constant of this type with the specified name.
`static Opcode[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

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 Opcode AALOAD
```
    Loads an references from an array onto the stack.
    Stack: arrayref, index -> value
  - AASTORE
```
public static final Opcode AASTORE
```
    Stores a reference in an array.
    Stack: arrayref, index, value -> ()
  - ACONST_NULL
```
public static final Opcode ACONST_NULL
```
    Pushes a null references onto the stack.
    Stack: () -> null
  - ALOAD
```
public static final Opcode ALOAD
```
    Loads a reference onto the stack from local variable index.
    Accepts: byte index
    
    Stack: () -> objectref
  - ALOAD_0
```
public static final Opcode ALOAD_0
```
    Loads a reference onto the stack from local variable 0.
    Stack: () -> objectref
  - ALOAD_1
```
public static final Opcode ALOAD_1
```
    Loads a reference onto the stack from local variable 1.
    Stack: () -> objectref
  - ALOAD_2
```
public static final Opcode ALOAD_2
```
    Loads a reference onto the stack from local variable 2.
    Stack: () -> objectref
  - ALOAD_3
```
public static final Opcode ALOAD_3
```
    Loads a reference onto the stack from local variable 3.
    Stack: () -> objectref
  - ANEWARRAY
```
public static final Opcode ANEWARRAY
```
    Creates a new array of length count and type typeref.
    Accepts: short typeref
    
    Stack: count -> arrayref
  - ARETURN
```
public static final Opcode ARETURN
```
    Returns a reference from a method and clears the stack.
    Stack: objectref -> [empty]
  - ARRAYLENGTH
```
public static final Opcode ARRAYLENGTH
```
    Replaces arrayref on the top of the stack with its length.
    Stack: arrayref -> length
  - ASTORE
```
public static final Opcode ASTORE
```
    Stores a reference into local variable index.
    Accepts: byte index
    
    Stack: objectref -> ()
  - ASTORE_0
```
public static final Opcode ASTORE_0
```
    Stores a references into local variable 0.
    Stack: objectref -> ()
  - ASTORE_1
```
public static final Opcode ASTORE_1
```
    Stores a references into local variable 1.
    Stack: objectref -> ()
  - ASTORE_2
```
public static final Opcode ASTORE_2
```
    Stores a references into local variable 2.
    Stack: objectref -> ()
  - ASTORE_3
```
public static final Opcode ASTORE_3
```
    Stores a references into local variable 3.
    Stack: objectref -> ()
  - ATHROW
```
public static final Opcode ATHROW
```
    Throws an error or exception and clears the stack save the reference to the Throwable at the top.
    Stack: objectref -> [empty], objectref
  - BALOAD
```
public static final Opcode BALOAD
```
    Loads a byte or boolean value from an array.
    Stack: arrayref, index -> value
  - BASTORE
```
public static final Opcode BASTORE
```
    Stores a byte or boolean value into an array.
    Stack: arrayref, index, value
  - BIPUSH
```
public static final Opcode BIPUSH
```
    Pushes a byte onto the stack as an integer value.
    Accepts: byte value
    
    Stack: () -> value
  - BREAKPOINT
```
public static final Opcode BREAKPOINT
```
    Reserved for breakpoints in Java debuggers; should not appear in a class file.
  - CALOAD
```
public static final Opcode CALOAD
```
    Loads a char from an array.
    Stack: arrayref, index -> value
  - CASTORE
```
public static final Opcode CASTORE
```
    Stores a char into an array.
    Stack: arrayref, index, value -> ()
  - CHECKCAST
```
public static final Opcode CHECKCAST
```
    Checks whether objectref matches of the type of the class at index of the constant pool.
    Accepts: short index
    
    Stack: objectref -> objectref
  - D2F
```
public static final Opcode D2F
```
    Converts a double to a float.
    Stack: value -> result
  - D2I
```
public static final Opcode D2I
```
    Converts a double to an integer.
    Stack: value -> result
  - D2L
```
public static final Opcode D2L
```
    Converts a double to an long.
    Stack: value -> result
  - DADD
```
public static final Opcode DADD
```
    Adds two doubles.
    Stack: value1, value2 -> result
  - DALOAD
```
public static final Opcode DALOAD
```
    Loads a double from an array.
    Stack: arrayref, index -> value
  - DASTORE
```
public static final Opcode DASTORE
```
    Stores a double into an array.
    Stack: arrayref, index, value -> ()
  - DCMPG
```
public static final Opcode DCMPG
```
    Checks whether double value1 is greater than double value2.
    Stack: value1, value2 -> result
  - DCMPL
```
public static final Opcode DCMPL
```
    Checks whether double value1 is less than double value2.
    Stack: value1, value2 -> result
  - DCONST_0
```
public static final Opcode DCONST_0
```
    Pushes the double constant 0.0 onto the stack.
    Stack: () -> 0.0
  - DCONST_1
```
public static final Opcode DCONST_1
```
    Pushes the double constant 1.0 onto the stack.
    Stack: () -> 1.0
  - DDIV
```
public static final Opcode DDIV
```
    Divides two doubles.
    Stack: value1, value2 -> result
  - DLOAD
```
public static final Opcode DLOAD
```
    Loads a double from local variable index.
    Accepts: byte index
    
    Stack: () -> value
  - DLOAD_0
```
public static final Opcode DLOAD_0
```
    Loads a double from local variable 0.
    Stack: () -> value
  - DLOAD_1
```
public static final Opcode DLOAD_1
```
    Loads a double from local variable 1.
    Stack: () -> value
  - DLOAD_2
```
public static final Opcode DLOAD_2
```
    Loads a double from local variable 2.
    Stack: () -> value
  - DLOAD_3
```
public static final Opcode DLOAD_3
```
    Loads a double from local variable 3.
    Stack: () -> value
  - DMUL
```
public static final Opcode DMUL
```
    Multiplies two doubles.
    Stack: value1, value2 -> result
  - DNEG
```
public static final Opcode DNEG
```
    Negates a double.
    Stack: value -> result
  - DREM
```
public static final Opcode DREM
```
    Gets the remainder from division between two doubles (modulus).
    Stack: value1, value2 -> result
  - DRETURN
```
public static final Opcode DRETURN
```
    Returns a double from a method and clears the stack.
    Stack: value -> [empty]
  - DSTORE
```
public static final Opcode DSTORE
```
    Stores double value into local variable index.
    Stack: value -> ()
  - DSTORE_0
```
public static final Opcode DSTORE_0
```
    Stores double value into local variable 0.
    Stack: value -> ()
  - DSTORE_1
```
public static final Opcode DSTORE_1
```
    Stores double value into local variable 1.
    Stack: value -> ()
  - DSTORE_2
```
public static final Opcode DSTORE_2
```
    Stores double value into local variable 2.
    Stack: value -> ()
  - DSTORE_3
```
public static final Opcode DSTORE_3
```
    Stores double value into local variable 3.
    Stack: value -> ()
  - DSUB
```
public static final Opcode DSUB
```
    Subtracts a double from another.
    Stack: value1, value2 -> result
  - DUP
```
public static final Opcode DUP
```
    Duplicates the value on top of the stack.
    Stack: value -> value, value
  - DUP_X1
```
public static final Opcode DUP_X1
```
    Inserts a copy of the top value of the stack two values from the top.
    Precondition: The top two values of the stack must not be of type double or long
    
    Stack: value1, value2 -> value2, value1, value2
  - DUP_X2
```
public static final Opcode DUP_X2
```
    Inserts a copy of the top value of the stack two (if value2 is double or long, in which case it occupies the entry of value3) or three (if value2 is neither a double or long) values from the top.
    Stack: value1, value2, value3 -> value3, value1, value2, value3
  - DUP2
```
public static final Opcode DUP2
```
    Duplicates the top two stack words (a word being two entries or 8 bytes).
    Stack: value1, value2 -> value1, value2, value1, value2
  - DUP2_X1
```
public static final Opcode DUP2_X1
```
    Duplicates the top two stack words and inserts them beneath the third word.
    Stack: value1, value2, value3 -> value2, value3, value1, value2, value3
  - DUP2_X2
```
public static final Opcode DUP2_X2
```
    Duplicates the top two stack words and inserts them beneath the fourth word.
    Stack: value1, value2, value3, value4 -> value3, value4, value1, value2, value3, value4
  - F2D
```
public static final Opcode F2D
```
    Converts a float to a double.
    Stack: value -> result
  - F2I
```
public static final Opcode F2I
```
    Converts a float to an int.
    Stack: value -> result
  - F2L
```
public static final Opcode F2L
```
    Converts a float to a long.
    Stack: value -> result
  - FADD
```
public static final Opcode FADD
```
    Adds two floats.
    Stack: value1, value2 -> result
  - FALOAD
```
public static final Opcode FALOAD
```
    Loads a float from an array.
    Stack: arrayref, index -> value
  - FASTORE
```
public static final Opcode FASTORE
```
    Stores a float in an array.
    Stack: arrayref, index, value -> ()
  - FCMPG
```
public static final Opcode FCMPG
```
    Checks whether float value1 is greater than float value2.
    Stack: value1, value2 -> result
  - FCMPL
```
public static final Opcode FCMPL
```
    Checks whether float value1 is less than float value2.
    Stack: value1, value2 -> result
  - FCONST_0
```
public static final Opcode FCONST_0
```
    Pushes the float constant 0.0 onto the stack.
    Stack: () -> 0.0f
  - FCONST_1
```
public static final Opcode FCONST_1
```
    Pushes the float constant 1.0 onto the stack.
    Stack: () -> 1.0f
  - FCONST_2
```
public static final Opcode FCONST_2
```
    Pushes the float constant 2.0 onto the stack.
    Stack: () -> 2.0f
  - FDIV
```
public static final Opcode FDIV
```
    Divides two floats.
    Stack: value1, value2 -> result
  - FLOAD
```
public static final Opcode FLOAD
```
    Loads a float onto the stack from local variable index.
    Accepts: byte index
    
    Stack: () -> value
  - FLOAD_0
```
public static final Opcode FLOAD_0
```
    Loads a float onto the stack from local variable 0.
    Accepts: byte index
    
    Stack: () -> value
  - FLOAD_1
```
public static final Opcode FLOAD_1
```
    Loads a float onto the stack from local variable 1.
    Accepts: byte index
    
    Stack: () -> value
  - FLOAD_2
```
public static final Opcode FLOAD_2
```
    Loads a float onto the stack from local variable 2.
    Accepts: byte index
    
    Stack: () -> value
  - FLOAD_3
```
public static final Opcode FLOAD_3
```
    Loads a float onto the stack from local variable 3.
    Accepts: byte index
    
    Stack: () -> value
  - FMUL
```
public static final Opcode FMUL
```
    Multiplies two floats.
    Stack: value1, value2 -> result
  - FNEG
```
public static final Opcode FNEG
```
    Negates a float.
    Stack: value -> result
  - FREM
```
public static final Opcode FREM
```
    Gets the remainder from a division between two floats (modulus).
    Stack: value1, value2 -> result
  - FRETURN
```
public static final Opcode FRETURN
```
    Returns a float from a method.
    Stack: value -> [empty]
  - FSTORE
```
public static final Opcode FSTORE
```
    Stores a float in local variable index.
    Accepts: byte index
    
    Stack: value -> ()
  - FSTORE_0
```
public static final Opcode FSTORE_0
```
    Stores a float in local variable 0.
    Stack: value -> ()
  - FSTORE_1
```
public static final Opcode FSTORE_1
```
    Stores a float in local variable 1.
    Stack: value -> ()
  - FSTORE_2
```
public static final Opcode FSTORE_2
```
    Stores a float in local variable 2.
    Stack: value -> ()
  - FSUB
```
public static final Opcode FSUB
```
    Subtracts two floats.
    Stack: value1, value2 -> result
  - GETFIELD
```
public static final Opcode GETFIELD
```
    Gets field fieldref of object objectref.
    Accepts: short fieldref
    
    Stack: objectref -> value
  - GETSTATIC
```
public static final Opcode GETSTATIC
```
    Gets static field fieldref of object objectref.
    Accepts: short fieldref
    
    Stack: () -> value
  - GOTO
```
public static final Opcode GOTO
```
    Goes to instruction at branchoffset.
    Accepts: short branchoffset
  - GOTO_W
```
public static final Opcode GOTO_W
```
    Goes to instruction at branchoffset.
    Accepts: int branchoffset
  - I2B
```
public static final Opcode I2B
```
    Converts an int to a byte.
    Stack: value -> result
  - I2C
```
public static final Opcode I2C
```
    Converts an int to a byte.
    Stack: value -> result
  - I2D
```
public static final Opcode I2D
```
    Converts an int to a character.
    Stack: value -> result
  - I2F
```
public static final Opcode I2F
```
    Converts an int to a double.
    Stack: value -> result
  - I2L
```
public static final Opcode I2L
```
    Converts an int to a long.
    Stack: value -> result
  - I2S
```
public static final Opcode I2S
```
    Converts an int to a short.
    Stack: value -> result
  - IADD
```
public static final Opcode IADD
```
    Adds two ints.
    Stack: value1, value2 -> result
  - IALOAD
```
public static final Opcode IALOAD
```
    Loads an int from an array.
    Stack: arrayref, index -> value
  - IAND
```
public static final Opcode IAND
```
    Performs a bitwise AND on two ints.
    Stack: value1, value2 -> result
  - IASTORE
```
public static final Opcode IASTORE
```
    Stores an int into an array.
    Stack: arrayref, index, value -> ()
  - ICONST_M1
```
public static final Opcode ICONST_M1
```
    Loads the int constant -1 onto the stack.
    Stack: () -> -1
  - ICONST_0
```
public static final Opcode ICONST_0
```
    Loads the int constant 0 onto the stack.
    Stack: () -> 0
  - ICONST_1
```
public static final Opcode ICONST_1
```
    Loads the int constant 1 onto the stack.
    Stack: () -> 1
  - ICONST_2
```
public static final Opcode ICONST_2
```
    Loads the int constant 2 onto the stack.
    Stack: () -> 2
  - ICONST_3
```
public static final Opcode ICONST_3
```
    Loads the int constant 3 onto the stack.
    Stack: () -> 3
  - ICONST_4
```
public static final Opcode ICONST_4
```
    Loads the int constant 4 onto the stack.
    Stack: () -> 4
  - ICONST_5
```
public static final Opcode ICONST_5
```
    Loads the int constant 5 onto the stack.
    Stack: () -> 5
  - IDIV
```
public static final Opcode IDIV
```
    Divides two ints.
    Stack: value1, value2 -> result
  - IF_ACMPEQ
```
public static final Opcode IF_ACMPEQ
```
    Branches to instruction at branchoffset if the two references are equal.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ACMPNE
```
public static final Opcode IF_ACMPNE
```
    Branches to instruction at branchoffset if the two references are not equal.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ICMPEQ
```
public static final Opcode IF_ICMPEQ
```
    Branches to instruction at branchoffset if the two ints are equal.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ICMPGE
```
public static final Opcode IF_ICMPGE
```
    Branches to instruction at branchoffset if value1 is greater than or equal to value2.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ICMPGT
```
public static final Opcode IF_ICMPGT
```
    Branches to instruction at branchoffset if value1 is greater than value2.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ICMPLE
```
public static final Opcode IF_ICMPLE
```
    Branches to instruction at branchoffset if value1 is less than or equal to value2.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ICMPLT
```
public static final Opcode IF_ICMPLT
```
    Branches to instruction at branchoffset if value1 is less than value2.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IF_ICMPNE
```
public static final Opcode IF_ICMPNE
```
    Branches to instruction at branchoffset if the two ints are not equal.
    Accepts: short branchoffset
    
    Stack: value1, value2 -> ()
  - IFEQ
```
public static final Opcode IFEQ
```
    Branches to instruction at branchoffset if value is equal to 0.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFGE
```
public static final Opcode IFGE
```
    Branches to instruction at branchoffset if value is greater than or equal to 0.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFGT
```
public static final Opcode IFGT
```
    Branches to instruction at branchoffset if value is greater than 0.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFLE
```
public static final Opcode IFLE
```
    Branches to instruction at branchoffset if value is less than or equal to 0.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFLT
```
public static final Opcode IFLT
```
    Branches to instruction at branchoffset if value is less than 0.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFNE
```
public static final Opcode IFNE
```
    Branches to instruction at branchoffset if value is not equal to 0.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFNONNULL
```
public static final Opcode IFNONNULL
```
    Branches to instruction at branchoffset if value is not null.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IFNULL
```
public static final Opcode IFNULL
```
    Branches to instruction at branchoffset if value is null.
    Accepts: short branchoffset
    
    Stack: value -> ()
  - IINC
```
public static final Opcode IINC
```
    Increment local variable index by signed byte const.
    Accepts: byte index, byte const
  - ILOAD
```
public static final Opcode ILOAD
```
    Loads int value from local variable index.
    Accepts: byte index
    
    Stack: () -> value
  - ILOAD_0
```
public static final Opcode ILOAD_0
```
    Loads int value from local variable 0.
    Accepts: byte index
    
    Stack: () -> value
  - ILOAD_1
```
public static final Opcode ILOAD_1
```
    Loads int value from local variable 1.
    Accepts: byte index
    
    Stack: () -> value
  - ILOAD_2
```
public static final Opcode ILOAD_2
```
    Loads int value from local variable 2.
    Accepts: byte index
    
    Stack: () -> value
  - ILOAD_3
```
public static final Opcode ILOAD_3
```
    Loads int value from local variable 3.
    Accepts: byte index
    
    Stack: () -> value
  - IMPDEP1
```
public static final Opcode IMPDEP1
```
    Reserved for implementation-dependent operations within debuggers. This instruction should not appear in any class file.
  - IMPDEP2
```
public static final Opcode IMPDEP2
```
    Reserved for implementation-dependent operations within debuggers. This instruction should not appear in any class file.
  - IMUL
```
public static final Opcode IMUL
```
    Multiplies two ints.
    Stack: value1, value2 -> result
  - INEG
```
public static final Opcode INEG
```
    Negates an int.
    Stack: value -> result
  - INSTANCEOF
```
public static final Opcode INSTANCEOF
```
    Determines if objectref is of the type referenced by index.
    Stack: short index
  - INVOKEDYNAMIC
```
public static final Opcode INVOKEDYNAMIC
```
    Invokes a dynamic method referenced by index and puts the result on the stack.
    Accepts: short index, 0, 0
    
    Stack: args... -> result
  - INVOKEINTERFACE
```
public static final Opcode INVOKEINTERFACE
```
    Invokes an interface method on object objectref and puts the result on the stack.
    Accepts: short index, count, 0
    
    Stack: objectref, args... -> result
  - INVOKESPECIAL
```
public static final Opcode INVOKESPECIAL
```
    Invokes an instance method on object objectref and puts the result on the stack.
    Accepts: short index, count, 0
    
    Stack: objectref, args... -> result
  - INVOKESTATIC
```
public static final Opcode INVOKESTATIC
```
    Invokes a static method on object objectref and puts the result on the stack.
    Accepts: short index, count, 0
    
    Stack: objectref, args... -> result
  - INVOKEVIRTUAL
```
public static final Opcode INVOKEVIRTUAL
```
    Invokes a virtual method on object objectref and puts the result on the stack.
    Accepts: short index, count, 0
    
    Stack: objectref, args... -> result
  - IOR
```
public static final Opcode IOR
```
    Performs a bitwise int OR operation on the two values.
    Stack: value1, value2 -> result
  - IREM
```
public static final Opcode IREM
```
    Performs a logical int remainder operation on the two values.
    Stack: value1, value2 -> result
  - IRETURN
```
public static final Opcode IRETURN
```
    Returns an int from a method.
    Stack: value -> [empty]
  - ISHL
```
public static final Opcode ISHL
```
    Performs an int shift left operation on the two values.
    Stack: value1, value2 -> result
  - ISHR
```
public static final Opcode ISHR
```
    Performs an int arithmetic shift right operation on the two values.
    Stack: value1, value2 -> result
  - ISTORE
```
public static final Opcode ISTORE
```
    Stores int value into variable index.
    Accepts: byte index
    
    Stack: value -> ()
  - ISTORE_0
```
public static final Opcode ISTORE_0
```
    Stores int value into variable 0.
    Accepts: byte index
    
    Stack: value -> ()
  - ISTORE_1
```
public static final Opcode ISTORE_1
```
    Stores int value into variable 1.
    Accepts: byte index
    
    Stack: value -> ()
  - ISTORE_2
```
public static final Opcode ISTORE_2
```
    Stores int value into variable 2.
    Accepts: byte index
    
    Stack: value -> ()
  - ISTORE_3
```
public static final Opcode ISTORE_3
```
    Stores int value into variable 3.
    Accepts: byte index
    
    Stack: value -> ()
  - ISUB
```
public static final Opcode ISUB
```
    Subtracts two ints.
    Stack: value2, value2 -> result
  - IUSHR
```
public static final Opcode IUSHR
```
    Performs an int logical shift right operation on the two values.
    Stack: value2, value2 -> result
  - IXOR
```
public static final Opcode IXOR
```
    Performs an int XOR operation on the two values.
    Stack: value2, value2 -> result
  - JSR
```
public static final Opcode JSR
```
    Jumps to the instruction at branchoffset and places the current address on the stack.
    Accepts: short branchoffset
    
    Stack: () -> address
  - JSR_W
```
public static final Opcode JSR_W
```
    Jumps to the instruction at branchoffset and places the current address on the stack.
    Accepts: int branchoffset
    
    Stack: () -> address
  - L2D
```
public static final Opcode L2D
```
    Converts a long to a double.
    Stack: value -> result
  - L2F
```
public static final Opcode L2F
```
    Converts a long to a float.
    Stack: value -> result
  - L2I
```
public static final Opcode L2I
```
    Converts a long to an int.
    Stack: value -> result
  - LADD
```
public static final Opcode LADD
```
    Adds two long values.
    Stack: value1, value2 -> result
  - LALOAD
```
public static final Opcode LALOAD
```
    Loads a long from an array.
    Stack: arrayref, index -> value
  - LAND
```
public static final Opcode LAND
```
    Performs a bitwise AND operation on two longs.
    Stack: value1, value2 -> result
  - LASTORE
```
public static final Opcode LASTORE
```
    Stores a long into an array.
    Stack: arrayref, index, value -> ()
  - LCMP
```
public static final Opcode LCMP
```
    Checks whether long value1 is greater than long value2.
    Stack: value1, value2 -> result
  - LCONST_0
```
public static final Opcode LCONST_0
```
    Pushes the long constant 0L onto the stack.
    Stack: () -> 0L
  - LCONST_1
```
public static final Opcode LCONST_1
```
    Pushes the long constant 1L onto the stack.
    Stack: () -> 1L
  - LDC
```
public static final Opcode LDC
```
    Pushes a constant index (String, int, or float) from the constant pool onto the stack.
    Accepts: byte index
    
    Stack: () -> value
  - LDC_W
```
public static final Opcode LDC_W
```
    Pushes a constant index (String, int, or float) from the constant pool onto the stack.
    Accepts: short index
    
    Stack: () -> value
  - LDC2_W
```
public static final Opcode LDC2_W
```
    Pushes a constant index (double or long) from the constant pool onto the stack.
    Accepts: index
    
    Stack: () -> value
  - LDIV
```
public static final Opcode LDIV
```
    Divides two longs.
    Stack: value1, value2 -> result
  - LLOAD
```
public static final Opcode LLOAD
```
    Loads a long value onto the stack from local variable index.
    Accepts: byte index
    
    Stack: () -> value
  - LLOAD_0
```
public static final Opcode LLOAD_0
```
    Loads a long value onto the stack from local variable 0.
    Stack: () -> value
  - LLOAD_1
```
public static final Opcode LLOAD_1
```
    Loads a long value onto the stack from local variable 1.
    Stack: () -> value
  - LLOAD_2
```
public static final Opcode LLOAD_2
```
    Loads a long value onto the stack from local variable 2.
    Stack: () -> value
  - LLOAD_3
```
public static final Opcode LLOAD_3
```
    Loads a long value onto the stack from local variable 3.
    Stack: () -> value
  - LMUL
```
public static final Opcode LMUL
```
    Multiplies two longs.
    Stack: value1, value2 -> result
  - LNEG
```
public static final Opcode LNEG
```
    Negates a long.
    Stack: value -> result
  - LOOKUPSWITCH
```
public static final Opcode LOOKUPSWITCH
```
    TODO: I have no idea how this works at the moment.
  - LOR
```
public static final Opcode LOR
```
    Performs a bitwise OR operation on two longs.
    Stack: value1, value2 -> result
  - LREM
```
public static final Opcode LREM
```
    Gets the remainder of division of two longs (modulus).
    Stack: value1, value2 -> result
  - LRETURN
```
public static final Opcode LRETURN
```
    Returns a long value from a method and clears the stack.
    Stack: value -> [empty]
  - LSHL
```
public static final Opcode LSHL
```
    Performs a bitwise left shift operation of long value1 by value2 positions.
    Stack: value1, value2 -> result
  - LSHR
```
public static final Opcode LSHR
```
    Performs a bitwise right shift operation of long value2 by value2 positions.
    Stack: value1, value2 -> result
  - LSTORE
```
public static final Opcode LSTORE
```
    Stores long value in local variable index.
    Accepts: byte index
    
    Stack: value -> ()
  - LSTORE_0
```
public static final Opcode LSTORE_0
```
    Stores long value in local variable 0.
    Stack: value -> ()
  - LSTORE_1
```
public static final Opcode LSTORE_1
```
    Stores long value in local variable 1.
    Stack: value -> ()
  - LSTORE_2
```
public static final Opcode LSTORE_2
```
    Stores long value in local variable 2.
    Stack: value -> ()
  - LSTORE_3
```
public static final Opcode LSTORE_3
```
    Stores long value in local variable 3.
    Stack: value -> ()
  - LSUB
```
public static final Opcode LSUB
```
    Subtracts a long value from another.
    Stack: value1, value2 -> result
  - LUSHR
```
public static final Opcode LUSHR
```
    Performs a bitwise right shift operation of long value2 by value2 positions, unsigned.
    Stack: value1, value2 -> result
  - LXOR
```
public static final Opcode LXOR
```
    Performs a bitwise XOR operation on two long values.
    Stack: value1, value2 -> result
  - MONITORENTER
```
public static final Opcode MONITORENTER
```
    Enters monitor state for an object (equivalent to start of synchronized block).
    Stack: objectref -> ()
  - MONITOREXIT
```
public static final Opcode MONITOREXIT
```
    Exits monitor state for an object (equivalent to end of synchronized block).
    Stack: objectref -> ()
  - MULTIANEWARRAY
```
public static final Opcode MULTIANEWARRAY
```
    Creates a new array of dimensions with elements of type classref. The size of each repsective dimension is defined by count1, count2, etc.
    Accepts: short classref, byte dimensions
    
    Stack: count1[, count2,...] -> arrayref
  - NEW
```
public static final Opcode NEW
```
    Creates a new object of type classref.
    Accepts: short classref
    
    Stack: () -> objectref
  - NEWARRAY
```
public static final Opcode NEWARRAY
```
    Creates a new array with count elements of primitive type atype.
    Accepts: byte atype
    
    Stack: count -> arrayref
  - NOP
```
public static final Opcode NOP
```
    Performs no operation.
  - POP
```
public static final Opcode POP
```
    Discards the top value of the stack.
    Stack: value -> ()
  - POP2
```
public static final Opcode POP2
```
    Discards the top two values of the stack (or one, if it is of type double or long.
    Stack: value1, value2 -> ()
  - PUTFIELD
```
public static final Opcode PUTFIELD
```
    Sets fieldref to value in objectref to value.
    Accepts: short fieldref
    
    Stack: objectref, value -> ()
  - PUTSTATIC
```
public static final Opcode PUTSTATIC
```
    Sets static field fieldref to value in a class.
    Accepts: short fieldref
    
    Stack: value -> ()
  - RET
```
public static final Opcode RET
```
    Continues execution from address.
    Accepts: byte index
  - RETURN
```
public static final Opcode RETURN
```
    Returns void from a method.
  - SALOAD
```
public static final Opcode SALOAD
```
    Loads a short from an array.
    Stack: arrayref, index -> value
  - SASTORE
```
public static final Opcode SASTORE
```
    Stores a short in an array.
    Stack: arrayref, index, value -> ()
  - SIPUSH
```
public static final Opcode SIPUSH
```
    Pushes short value onto the stack.
    Accepts: short value
    
    Stack: () -> value
  - SWAP
```
public static final Opcode SWAP
```
    Swaps the two top words of the stack, provided they are not double or long.
    Stack: value1, value2 -> value2, value1
  - TABLESWITCH
```
public static final Opcode TABLESWITCH
```
    Continues execution from an address in the table at offset index. TODO: Research this
    Accepts: TODO
    
    Stack: index -> ()
  - WIDE
```
public static final Opcode WIDE
```
    TODO: research.
  - UNKNOWN
```
public static final Opcode UNKNOWN
```
    Unknown opcode.
- Method Detail
  - values
```
public static Opcode[] 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 (Opcode c : Opcode.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static Opcode valueOf(java.lang.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:
    
    java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
    
    java.lang.NullPointerException - if the argument is null
  - getByteCode
```
public byte getByteCode()
```
    Returns the byte associated with this Opcode.
    
    Returns:
    
    The byte representing this Opcode.
  - getAdditionalBytes
```
public int getAdditionalBytes()
```
    Returns the number of additional bytes which follow this Opcode.
    
    Returns:
    
    The number of additional bytes which follow this Opcode
  - fromByte
```
public static Opcode fromByte(byte byteCode)
```

Enum Opcode

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

BREAKPOINT

CALOAD

CASTORE

CHECKCAST

D2F

D2I

D2L

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

F2D

F2I

F2L

FADD

FALOAD

FASTORE

FCMPG

FCMPL

FCONST_0

FCONST_1

FCONST_2

FDIV

FLOAD

FLOAD_0

FLOAD_1

FLOAD_2

FLOAD_3

FMUL