Uses of Interface
jef.dna.util.BytesCountable

Packages that use BytesCountable
jef.dna.attributes   
jef.dna.attributes.impl   
jef.dna.instructions   
jef.dna.instructions.impl   
 

Uses of BytesCountable in jef.dna.attributes
 

Subinterfaces of BytesCountable in jef.dna.attributes
 interface Attribute
          This is the ancestor of all the interfaces implemented by those classes representing the Attributes entities.
 interface CodeAttribute
          The Code class represents a Code Attribute as defined by the JVM Class file Specification: The Code attribute is a variable-length attribute used in the attributes table of method_info structures.
 interface ConstantValueAttribute
          The ConstantValue class represents a ConstantValue Attribute as defined by the JVM Class file Specification: The ConstantValue attribute is a fixed-length attribute used in the attributes table of the field_info structures.
 interface DeprecatedAttribute
          Class representing a Deprecated Attribute.
 interface EnclosingMethodAttribute
          This interface represents the EnclosingMethod attribute defined by the Java class file specification.
 interface ExceptionAttribute
          Class representing an Exception Attribute.
 interface ExceptionsAttribute
          Class representing an Exception Attribute.
 interface ExceptionTableEntry
          Class representing an ExceptionTable generic entry.
 interface InnerClassesAttribute
          Class representing an Inner Classes Attribute.
 interface InnerClassesTableEntry
          Class representing an Inner Classes instance's table entry.
 interface LineNumberTableAttribute
          Class representing a Line Number Table Attribute.
 interface LineNumberTableEntry
          Class representing a Line Number Table instance's entry.
 interface LocalVariableTableAttribute
          Class representing a Local Variable Table Attribute.
 interface LocalVariableTableEntry
          Class representing a Local Variable instance's table entry.
 interface SignatureAttribute
          The Signature attribute is an optional fixed-length attribute in the attributes table of the ClassFile (�4.2), field_info (�4.6) and method_info (�4.7)structures.
 interface SourceDebugExtensionAttribute
           
 interface SourceFileAttribute
          Class representing a Source File Attribute.
 interface SyntheticAttribute
          Class representing a Synthetic Attribute.
 

Uses of BytesCountable in jef.dna.attributes.impl
 

Classes in jef.dna.attributes.impl that implement BytesCountable
 class Code
          The Code class represents a Code Attribute as defined by the JVM Class file Specification.
 class ConstantValue
           
 class DeprecatedAttribute
          Class representing a Deprecated Attribute.
 class EnclosingMethod
           
 class ExceptionAttr
          Class representing an Exception Attribute.
 class ExceptionTableEntry
          Class representing an ExceptionTable generic entry.
 class GenericAttribute
          Ancestor class for every Attribute class.
 class InnerClasses
          Class representing an Inner Classes Attribute.
 class InnerClassesTableEntry
          Class representing an Inner Classes instance's table entry.
 class LineNumberTableAttribute
          Class representing a Line Number Table Attribute.
 class LineNumberTableEntry
          Class representing a Line Number Table instance's entry.
 class LocalVariableTableAttribute
          Class representing a Local Variable Table Attribute.
 class LocalVariableTableEntry
          Class representing a Local Variable instance's table entry.
 class Signature
           
 class SourceDebugExtension
           
 class SourceFileAttribute
          Class representing a Source File Attribute.
 class SyntheticAttribute
          Class representing a Synthetic Attribute.
 

Uses of BytesCountable in jef.dna.instructions
 

Subinterfaces of BytesCountable in jef.dna.instructions
 interface Instruction
          This interface has to be implemented by every class representing a Java bytecode instruction
 interface InstructionRefsCpt
          This interface has to be implemented by every class representing a Java bytecode instruction which refers to the constant pool table.
 

Uses of BytesCountable in jef.dna.instructions.impl
 

Classes in jef.dna.instructions.impl that implement BytesCountable
 class AALoad
          This class maps the AALOAD bytecode instruction which loads a reference from an array.
 class AAStore
          This class maps the AASTORE bytecode instruction which stores a reference to an array.
 class AConst_Null
          This class maps the AACONST_NULL bytecode instruction which pushes null onto the operant stack.
 class ALoad
          This class maps the ALOAD bytecode instruction which loads a reference from a local variable.
 class ALoad_0
          This class maps the ALOAD_0 bytecode instruction which loads a reference from a local variable stored at the position 0 of the local variable array of the current frame.
 class ALoad_1
          This class maps the ALOAD_1 bytecode instruction which loads a reference from a local variable stored at the position 1 of the local variable array of the current frame.
 class ALoad_2
          This class maps the ALOAD_2 bytecode instruction which loads a reference from a local variable stored at the position 2 of the local variable array of the current frame.
 class ALoad_3
          This class maps the ALOAD_3 bytecode instruction which loads a reference from a local variable stored at the position 3 of the local variable array of the current frame.
 class ANewArray
          This class maps the ANEWARRAY bytecode instruction.
 class AReturn
          This class maps the ARETURN bytecode instruction which returns a reference from a method
 class ArrayLength
          This class maps the ARRAYLENGTH bytecode instruction which returns the length of an array.
 class AStore
          This class maps the ASTORE bytecode instruction which stores a reference into a local variable
 class AStore_0
          This class maps the ASTORE bytecode instruction which store a reference into a local variable. 0 is the index in the local variable array of the current frame
 class AStore_1
          This class maps the ASTORE bytecode instruction which store a reference into a local variable. 1 is the index in the local variable array of the current frame
 class AStore_2
          This class maps the ASTORE_2 bytecode instruction which store a reference into a local variable. 2 is the index in the local variable array of the current frame
 class AStore_3
          This class maps the ASTORE_3 bytecode instruction which store a reference into a local variable. 3 is the index in the local variable array of the current frame
 class AThrow
          This class maps the ATHROW bytecode instruction which is used to throw an exception or an error
 class BALoad
          This class maps the BALOAD bytecode instruction which loads a byte or a boolean from an array.
 class BAStore
          This class maps the BASTORE bytecode instruction which stores a byte or a boolean to an array.
 class BiPush
          This class maps the BIPUSH bytecode instruction which pushes a byte onto the stack.
 class CALoad
          This class maps the CALOAD bytecode instruction which loads a char from an array.
 class CAStore
          This class maps the CASTORE bytecode instruction which stores a char to an array.
 class CheckCast
          This class maps the CHECKCAST bytecode instruction which checks whether the object referenced by the reference on the top of the stack can be casted to the type represented by the constant pool table entry at index indexbyte1<<8|indexbyte2.
 class D2f
          This class maps the D2F bytecode instruction which converts a double to float.
 class D2i
          This class maps the D2I bytecode instruction which converts a double to integer.
 class D2l
          This class maps the D2L bytecode instruction which converts a double to long.
 class DAdd
          This class maps the DADD bytecode instruction which adds two operands of type double stored on the top of the stack.
 class DALoad
          This class maps the DALOAD bytecode instruction which loads a double from an array.
 class DAStore
          This class maps the DASTORE bytecode instruction which stores a double to an array.
 class DCmpg
          This class maps the DCMPG bytecode instruction which compares two doubles took from the top of the stack.
 class DCmpl
          This class maps the DCMPG bytecode instruction which compares two doubles took from the top of the stack.
 class DConst_0
          This class maps the DCONST_0 bytecode instruction which pushes the double constant 0.0 on to the operand stack.
 class DConst_1
          This class maps the DCONST_1 bytecode instruction which pushes the double constant 1.0 on to the operand stack.
 class DDiv
          This class maps the DDIV bytecode instruction which divides the two doubles popped out from the operand stack and pushes back the result.
 class DLoad
          This class maps the DLOAD bytecode instruction which loads a double from the index specified as parameter (operand).
 class DLoad_0
          This class maps the DLOAD_0 bytecode instruction which loads a double from the local variable array of the current frame at index 0.
 class DLoad_1
          This class maps the DLOAD_1 bytecode instruction which loads a double from the local variable array of the current frame at index 1.
 class DLoad_2
          This class maps the DLOAD_2 bytecode instruction which loads a double from the local variable array of the current frame at index 2.
 class DLoad_3
          This class maps the DLOAD_3 bytecode instruction which loads a double from the local variable array of the current frame at index 3.
 class DMul
          This class maps the DMUL bytecode instruction which multiplies two doubles popped from the operand stack, and pushes the result onto the operand stack.
 class DNeg
          This class maps the DNEG bytecode instruction which negates a double.
 class DRem
          This class maps the DREM bytecode instruction which computes the reminder of the truncationg division of the two doubles popped from the operand stack.
 class DReturn
          This class maps the DRETURN bytecode instruction which returns a double popping it from the operand stack.
 class DStore
          This class maps the DSTORE bytecode instruction which stores a double popped from the operand stack into a variable whose index is specified as operand.
 class DStore_0
          This class maps the DSTORE_0 bytecode instruction which stores a double popped from the operand stack into the index 0 of the local variable array.
 class DStore_1
          This class maps the DSTORE_1 bytecode instruction which stores a double popped from the operand stack into the index 1 of the local variable array.
 class DStore_2
          This class maps the DSTORE_2 bytecode instruction which stores a double popped from the operand stack into the index 2 of the local variable array.
 class DStore_3
          This class maps the DSTORE_3 bytecode instruction which stores a double popped from the operand stack into the index 3 of the local variable array.
 class DSub
          This class maps the DSUB bytecode instruction which subtracts the first double popped from the operand stack from the second one, and pushes the result onto the operand stack.
 class Dup
          This class maps the DUP bytecode instruction which duplicates the value found at the top of the operand stack, and pushes the copy of the top of it: as a result at the top of the operans stack there will be two equal doubles.
 class Dup_X1
          This class maps the DUP_X1 bytecode instruction which duplicates the top value on the operand stack and insert the duplicated value two values down in the operand stack.
 class Dup_X2
          This class maps the DUP_X2 bytecode instruction which duplicates the top value on the operand stack and insert the duplicated value two or three values down in the operand stack.
 class Dup2
          This class maps the DUP2 bytecode instruction which duplicates the top one or two values on the operand stack and push the duplicated value or values back onto the operand stack in the original order.
 class Dup2_X1
          This class maps the DUP2_X1 bytecode instruction which duplicates the top one or two values on the operand stack and insert the duplicated values, in the original order, one value beneath the original value or values in the operand stack.
 class Dup2_X2
          This class maps the DUP2_X2 bytecode instruction which duplicates the top one or two values on the operand stack and insert the duplicated values, in the original order, into the operand stack.
 class F2d
          This class maps the F2D bytecode instruction which converts a float popped from the operand stack into a double and places it on the top of the operand stack.
 class F2i
          This class maps the F2I bytecode instruction which converts a float popped from the operand stack into an integer and places it on the top of the operand stack.
 class F2l
          This class maps the F2L bytecode instruction which converts a float popped from the operand stack into a long and places it on the top of the operand stack.
 class FAdd
          This class maps the FADD bytecode instruction which adds two float values.
 class FALoad
          This class maps the FALOAD bytecode instruction which loads a float from an array.
 class FAStore
          This class maps the FASTORE bytecode instruction which stores a float to an array.
 class FCmpg
          This class maps the FCMPG bytecode instruction which preforms a comparison between two float values.
 class FCmpl
          This class maps the FCMPL bytecode instruction which preforms a comparison between two float values.
 class FConst_0
          This class maps the FCONST_0 bytecode instruction which pushes the constant long 0 onto the operand stack.
 class FConst_1
          This class maps the FCONST_1 bytecode instruction which pushes the constant long 1 onto the operand stack.
 class FConst_2
          This class maps the FCONST_2 bytecode instruction which pushes the constant long 2 onto the operand stack.
 class FDiv
          This class maps the FDIV bytecode instruction which divides two floats popped from the top two positions of the operand stack and pushes back the result.
 class FLoad
          This class maps the FLOAD bytecode instruction which loads a float value from a local variable whose index is provided as parameter.
 class FLoad_0
          This class maps the FLOAD_0 bytecode instruction which loads a float value from the position 0 of the local variable array of the current frame.
 class FLoad_1
          This class maps the FLOAD_1 bytecode instruction which loads a float value from the position 1 of the local variable array of the current frame.
 class FLoad_2
          This class maps the FLOAD_2 bytecode instruction which loads a float value from the position 2 of the local variable array of the current frame.
 class FLoad_3
          This class maps the FLOAD_3 bytecode instruction which loads a float value from the position 3 of the local variable array of the current frame.
 class FMul
          This class maps the FMUL bytecode instruction which multiplies two floats popped from the operand stack.
 class FNeg
          This class maps the FNEG bytecode instruction which negates the float value popped from the top of the operans stack.
 class FRem
          This class maps the FREM bytecode instruction which computes the reminder of the division of the first element taken from the operand stack by the second one.
 class FReturn
          This class maps the FRETURN bytecode instruction which is needed in order to return a float value from a method.
 class FStore
          This class maps the FSTORE bytecode instruction which stores a float value popped from the operand stack into a local variable whose index has to be provided as parameter to the FSTORE instruction.
 class FStore_0
          This class maps the FSTORE_0 bytecode instruction which stores a float value popped from the operand stack into the local variable array of the current frame at index 0.
 class FStore_1
          This class maps the FSTORE_1 bytecode instruction which stores a float value popped from the operand stack into the local variable array of the current frame at index 1.
 class FStore_2
          This class maps the FSTORE_2 bytecode instruction which stores a float value popped from the operand stack into the local variable array of the current frame at index 2.
 class FStore_3
          This class maps the FSTORE_3 bytecode instruction which stores a float value popped from the operand stack into the local variable array of the current frame at index 3.
 class FSub
          This class maps the FSUB bytecode instruction which subtracts the first value popped from the operand stack from the second one, and pushes the result back onto the operand stack.
 class GetField
          This class maps the GETFIELD bytecode instruction which fetches field from object.
 class GetStatic
          This class maps the GETSTATIC bytecode instruction which gets static field from class.
 class Goto
          This class maps the GOTO bytecode instruction which branches always.
 class Goto_W
          This class maps the GOTO_W bytecode instruction which branches always (wide index).
 class I2b
          This class maps the I2B bytecode instruction which converts an int popped from the operand stack, to a byte.
 class I2c
          This class maps the I2C bytecode instruction which converts an int popped from the operand stack, to a char.
 class I2d
          This class maps the I2D bytecode instruction which converts an int popped from the operand stack to a double.
 class I2f
          This class maps the I2F bytecode instruction which converts an int popped from the operand stack to a float.
 class I2l
          This class maps the I2L bytecode instruction which converts an int popped from the operand stack to a long.
 class I2s
          This class maps the I2S bytecode instruction which converts an int popped from the operand stack, to a short.
 class IAdd
          This class maps the IADD bytecode instruction which adds two ints took from the operand stack.
 class IALoad
          This class maps the IALOAD bytecode instruction which loads an int from the position, specified by the first entry of the operand stack, of the array referenced by the second entry of the operand stack.
 class IAnd
          This class maps the IAND bytecode instruction which performs a bitwise and operation of the first two int popped from the operand stack.
 class IAStore
          This class maps the IASTORE bytecode instruction which stores an int into the array referenced by the second entry of the operand stack a the index given by the first entry of the operand stack.
 class IConst_0
          This class maps the ICONST_0 bytecode instruction which pushes the costant 0 onto the operand stack.
 class IConst_1
          This class maps the ICONST_1 bytecode instruction which pushes the costant 1 onto the operand stack.
 class IConst_2
          This class maps the ICONST_2 bytecode instruction which pushes the costant 2 onto the operand stack.
 class IConst_3
          This class maps the ICONST_3 bytecode instruction which pushes the costant 3 onto the operand stack.
 class IConst_4
          This class maps the ICONST_4 bytecode instruction which pushes the costant 4 onto the operand stack.
 class IConst_5
          This class maps the ICONST_5 bytecode instruction which pushes the costant 5 onto the operand stack.
 class IConst_M1
          This class maps the ICONST_M1 bytecode instruction which pushes the costant -1 onto the operand stack.
 class IDiv
          This class maps the IDIV bytecode instruction which divides the second entry of the operand stack by the first one, and pushes the result back on top of the operand stack.
 class If_ACmpEq
          This class maps the IFACMPEQ bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the first two values popped from the operand stack equal.
 class If_ACmpNe
          This class maps the IFACMPLNE bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the first two values popped from the operand stack don't equal.
 class IF_ICmpeq
          This class maps the IF_ICMPEQ bytecode instruction which compares the first two ints popped from the operand stack.
 class IF_ICmpge
          This class maps the IF_ICMPGE bytecode instruction which compares the first two ints popped from the operand stack.
 class IF_ICmpgt
          This class maps the IF_ICMPGT bytecode instruction which compares the first two ints popped from the operand stack.
 class IF_ICmple
          This class maps the IF_ICMPLE bytecode instruction which compares the first two ints popped from the operand stack.
 class IF_ICmplt
          This class maps the IF_ICMPLT bytecode instruction which compares the first two ints popped from the operand stack.
 class IF_ICmpne
          This class maps the IF_ICMPNE bytecode instruction which compares the first two ints popped from the operand stack.
 class Ifeq
          This class maps the IFEQ bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the value popped from the operand stack equals 0.
 class Ifge
          This class maps the IFGE bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the value popped from the operand stack is greater than or equals 0.
 class Ifgt
          This class maps the IFGT bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the value popped from the operand stack is greater than 0.
 class Ifle
          This class maps the IFLE bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the value popped from the operand stack is less than or equals 0.
 class Iflt
          This class maps the IFLT bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the value popped from the operand stack is less than 0.
 class Ifne
          This class maps the IFNE bytecode instruction which branches to the offset obtained starting from the two required operands, if and only if the value popped from the operand stack does not equal 0.
 class IfNoNull
          This class maps the IFNONNULL bytecode instruction which branches to the specified offset if and only if the value of type reference popped from the operand stack is not null.
 class IfNull
          This class maps the IFNULL bytecode instruction which behaves exactly like the ifnonnull instruction, but the jump happens if and only if the reference popped from the operand stack is null rether then non null.
 class IInc
          This class maps the IINC bytecode instruction which increments the int referenced by the first IINC parameter (this is an index into the local variable array of the current frame) by a constant given as second paramenter of the bytecode instruction.
 class ILoad
          This class maps the ILOAD bytecode instruction which loads an int from the local variable array of the current frame, at the index specified as parameter of the instruction.
 class ILoad_0
          This class maps the ILOAD_0 bytecode instruction which loads an int from the index 0 of the local variable array of the current frame.
 class ILoad_1
          This class maps the ILOAD_1 bytecode instruction which loads an int from the index 1 of the local variable array of the current frame.
 class ILoad_2
          This class maps the ILOAD_2 bytecode instruction which loads an int from the index 2 of the local variable array of the current frame.
 class ILoad_3
          This class maps the ILOAD_3 bytecode instruction which loads an int from the index 3 of the local variable array of the current frame.
 class IMul
          This class maps the IMUL bytecode instruction which multiplies the first two ints popped from the operand stack and pushes back the result.
 class INeg
          This class maps the INEG bytecode instruction which performs the arithmetical negation of the int popped from the operand stack, and pushes back the result.
 class InstanceOf
          This class maps the INSTANCEPF bytecode instruction which determines if the object references by the address popped from the operand stack is of the type given by the entry of the runtime constantpool addressed by the two bytes required as parameter for this instruction.
 class InstructionAncestor
          This class is the ancestor of all the concrete instruction classes, and provides all these methods common to every instruction.
 class InstructionAncestorRefsCpt
          This class is the ancestor of all the concrete instruction classes referring the constant pool table.
 class InstructionRefsCpt16
          This class is the ancestor of all the concrete instruction classes referring the constant pool table with 16 bits index.
 class InstructionRefsCpt8
          This class is the ancestor of all the concrete instruction classes referring the constant pool table with 8 bits index.
 class InvokeInterface
          This class maps the INVOKEINTERFACE bytecode instruction which invokes an interface method.
 class InvokeSpecial
          This class maps the INVOKESPECIAL bytecode instruction which invokes instance initialization, private and super class methods.
 class InvokeStatic
          This class maps the INVOKESTATIC bytecode instruction which invokes static methods.
 class InvokeVirtual
          This class maps the INVOKEVIRTUAL bytecode instruction which invokes instance methods.
 class IOr
          This class maps the IOR bytecode instruction which performs the boolean or of the first two ints popped from the operand stack.
 class IRem
          This class maps the IREM bytecode instruction which calculates the reminder of the division of the second entry of the operand stack by the first one.
 class IReturn
          This class maps the IRETURN bytecode instruction which is used to return an int from a method.
 class IShl
          This class maps the ISHL bytecode instruction which shifts left the second entry of the operand stack by s bit positions, where s is the value of the low 5 bits of the first entry of the operand stack.
 class IShr
          This class maps the ISHR bytecode instruction which shifts right the second entry of the operand stack by s bit positions, where s is the value of the low 5 bits of the first entry of the operand stack.
 class IStore
          This class maps the ISTORE bytecode instruction which stores an int popped from the operand stack into a local variable whose address points to an entry of the local variable array of the current frame.
 class IStore_0
          This class maps the ISTORE_0 bytecode instruction which stores an int value popped from the operand stack into the local variable array of the current frame at index 0.
 class IStore_1
          This class maps the ISTORE_1 bytecode instruction which stores an int value popped from the operand stack into the local variable array of the current frame at index 1.
 class IStore_2
          This class maps the ISTORE_2 bytecode instruction which stores an int value popped from the operand stack into the local variable array of the current frame at index 2.
 class IStore_3
          This class maps the ISTORE_3 bytecode instruction which stores an int value popped from the operand stack into the local variable array of the current frame at index 3.
 class ISub
          This class maps the ISUB bytecode instruction which subtracts the first value popped from the operand stack from the second one, and pushes the result back onto the operand stack.
 class Iushr
          This class maps the IUSHR bytecode instruction.
 class IXOr
          This class maps the IXOR bytecode instruction which performs the boolean xor over the first two values popped from the operand stack.
 class Jsr
          This class maps the JSR bytecode instruction which jumps to subroutine.
 class Jsr_W
          This class maps the JSR_W bytecode instruction which jumps to subroutine (wide index).
 class L2d
          This class maps the L2D bytecode instruction which converts a long to a double.
 class L2f
          This class maps the L2F bytecode instruction which converts a long to a float.
 class L2i
          This class maps the L2I bytecode instruction which converts a long to an int.
 class LAdd
          This class maps the LADD bytecode instruction which adds two longs took from the operand stack.
 class LALoad
          This class maps the LALOAD bytecode instruction which loads a long from the position specified by the first entry of the operand stack of the array referenced by the second entry of the operand stack.
 class LAnd
          This class maps the LAND bytecode instruction which performs a bitwise and operation of the first two longs popped from the operand stack.
 class LAStore
          This class maps the LASTORE bytecode instruction which stores a long to an array.
 class Lcmp
          This class maps the LCMP bytecode instruction which compares the first two longs popped from thr operand stack.
 class LConst_0
          This class maps the LCONST_0 bytecode instruction which pushes a 0 long constant onto the operand stack.
 class LConst_1
          This class maps the LCONST_0 bytecode instruction which pushes a 1 long constant onto the operand stack.
 class Ldc
          This class maps the LDC bytecode instruction which pushes into the operand stack a value taken from the runtime constant pool of the current class at the index specified by the only one argument of the LDC instruction.
 class Ldc_W
          This class maps the LDC_W bytecode instruction which pushes into the operand stack a value taken from the runtime constant pool of the current class at the index specified by the two arguments of the LDC instruction.
 class Ldc2_W
          This class maps the LDC_2W bytecode instruction which pushes into the operand stack a long or double taken from the runtime constant pool of the current class at the index specified by the two arguments of the LDC instruction.
 class LDiv
          This class maps the LDIV bytecode instruction which divides the second entry of the operand stack by the first one, and pushes the result back on top of the operand stack.
 class LLoad
          This class maps the LLOAD bytecode instruction which loads a long value from a local variable whose index is provided as parameter.
 class LLoad_0
          This class maps the LLOAD_0 bytecode instruction which loads a long value from the position 0 of the local variable array of the current frame.
 class LLoad_1
          This class maps the LLOAD_1 bytecode instruction which loads a long value from the position 1 of the local variable array of the current frame.
 class LLoad_2
          This class maps the LLOAD_2 bytecode instruction which loads a long value from the position 2 of the local variable array of the current frame.
 class LLoad_3
          This class maps the LLOAD_3 bytecode instruction which loads a long value from the position 3 of the local variable array of the current frame.
 class LMul
          This class maps the LMUL bytecode instruction which multiplies the first two longs popped from the operand stack and pushes back the result.
 class LNeg
          This class maps the LNEG bytecode instruction which performs the arithmetical negation of the long popped from the operand stack, and pushes back the result.
 class LookupSwitch
          This class maps the LOOKUPSWITCH bytecode instruction.
 class LOr
          This class maps the LOR bytecode instruction which performs the boolean or of the first two longs popped from the operand stack.
 class LRem
          This class maps the LREM bytecode instruction which calculates the reminder of the division of the second entry of the operand stack by the first one.
 class LReturn
          This class maps the LRETURN bytecode instruction which is used to return an int from a method.
 class LShl
          This class maps the LSHL bytecode instruction which shifts left the second entry of the operand stack by s bit positions, where s is the value of the low 5 bits of the first entry of the operand stack.
 class LShr
          This class maps the LSHR bytecode instruction which shifts right the second entry of the operand stack by s bit positions, where s is the value of the low 5 bits of the first entry of the operand stack.
 class LStore
          This class maps the LSTORE bytecode instruction which stores a long popped from the operand stack into a local variable whose address points to an entry of the local variable array of the current frame.
 class LStore_0
          This class maps the LSTORE_0 bytecode instruction which stores an long value popped from the operand stack into the local variable array of the current frame at index 0.
 class LStore_1
          This class maps the LSTORE_1 bytecode instruction which stores an long value popped from the operand stack into the local variable array of the current frame at index 1.
 class LStore_2
          This class maps the LSTORE_2 bytecode instruction which stores an long value popped from the operand stack into the local variable array of the current frame at index 2.
 class LStore_3
          This class maps the LSTORE_3 bytecode instruction which stores an long value popped from the operand stack into the local variable array of the current frame at index 3.
 class LSub
          This class maps the LSUB bytecode instruction which subtracts the first value popped from the operand stack from the second one, and pushes the result back onto the operand stack.
 class Lushr
          This class maps the LUSHR bytecode instruction.
 class LXOr
          This class maps the LXOR bytecode instruction which performs the boolean xor over the first two values popped from the operand stack.
 class MonitorEnter
          This class maps the MONITORENTER bytecode instruction which enters monitor for object.
 class MonitorExit
          This class maps the MONITOREXIT bytecode instruction which exit monitor for object.
 class MultiANewArray
          This class maps the MULTIANEWARRAY bytecode instruction which creates new multidimensional array.
 class New
          This class maps the NEW bytecode instruction which is used to instantiate a new object.
 class NewArray
          This class maps the NEW bytecode instruction which creates a new array whose dimension is given by the first value popped from the operand stack.
 class Nop
          This class maps the NOP bytecode instruction which does nothing.
 class Pop
          This class maps the POP bytecode instruction which pop the top value from the operand stack.
 class Pop2
          This class maps the POP2 bytecode instruction which pop the top one or two values from the operand stack.
 class PutField
          This class maps the PUTFIELD bytecode instruction which set field in object.
 class PutStatic
          This class maps the PUTSTATIC bytecode instruction which set static field in class.
 class Ret
          This class maps the RET bytecode instruction which returns from a subruotine.
 class Return
          This class maps the RETURN bytecode instruction which returns void from a method.
 class SALoad
          This class maps the SALOAD bytecode instruction which loads short from array.
 class SAStore
          This class maps the SASTORE bytecode instruction which stores into short array.
 class SiPush
          This class maps the SIPUSH bytecode instruction which pushes short.
 class Swap
          This class maps the SWAP bytecode instruction which swap the top two values on the operand stack.
 class TableSwitch
          This class maps the TABLESWITVH bytecode instruction which accesses jump table by index and jump.
 class Wide
          This class maps the WIDE bytecode instruction which extends local variable index by additional bytes.