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.