bundleplugin/src/main/java/aQute/bnd/osgi/OpCodes.java

package aQute.bnd.osgi;

public class OpCodes {
	final static short	nop				= 0x00;			// [No change]
															// performs
															// no
	// operation
	final static short	aconst_null		= 0x01;			// ? null pushes a
															// null
	// reference onto the stack
	final static short	iconst_m1		= 0x02;			// ? -1 loads the
															// int
															// value -1
	// onto the stack
	final static short	iconst_0		= 0x03;			// ? 0 loads the int
															// value 0
	// onto the stack
	final static short	iconst_1		= 0x04;			// ? 1 loads the int
															// value 1
	// onto the stack
	final static short	iconst_2		= 0x05;			// ? 2 loads the int
															// value 2
	// onto the stack
	final static short	iconst_3		= 0x06;			// ? 3 loads the int
															// value 3
	// onto the stack
	final static short	iconst_4		= 0x07;			// ? 4 loads the int
															// value 4
	// onto the stack
	final static short	iconst_5		= 0x08;			// ? 5 loads the int
															// value 5
	// onto the stack
	final static short	lconst_0		= 0x09;			// ? 0L pushes the
															// long
															// 0 onto
	// the stack
	final static short	bipush			= 0x10;			// byte ? value
															// pushes a
															// byte
	// onto the stack as an integer
	// value
	final static short	sipush			= 0x11;			// byte1, byte2 ?
															// value
															// pushes a
	// signed integer (byte1 << 8 +
	// byte2) onto the stack
	final static short	ldc				= 0x12;			// index ? value
															// pushes
															// a
	// constant #index from a
	// constant pool (String, int,
	// float or class type) onto the
	// stack
	final static short	ldc_w			= 0x13;			// indexbyte1,
															// indexbyte2 ?
	// value pushes a constant
	// #index from a constant pool
	// (String, int, float or class
	// type) onto the stack (wide
	// index is constructed as
	// indexbyte1 << 8 + indexbyte2)
	final static short	ldc2_w			= 0x14;			// indexbyte1,
															// indexbyte2 ?
	// value pushes a constant
	// #index from a constant pool
	// (double or long) onto the
	// stack (wide index is
	// constructed as indexbyte1 <<
	// 8 + indexbyte2)
	final static short	iload			= 0x15;			// index ? value
															// loads
															// an int
	// value from a variable #index
	final static short	lload			= 0x16;			// index ? value
															// load a
															// long
	// value from a local variable
	// #index
	final static short	fload			= 0x17;			// index ? value
															// loads a
															// float
	// value from a local variable
	// #index
	final static short	dload			= 0x18;			// index ? value
															// loads a
															// double
	// value from a local variable
	// #index
	final static short	aload			= 0x19;			// index ? objectref
															// loads a
	// reference onto the stack from
	// a local variable #index
	final static short	lload_2			= 0x20;			// ? value load a
															// long
															// value
	// from a local variable 2
	final static short	lload_3			= 0x21;			// ? value load a
															// long
															// value
	// from a local variable 3
	final static short	fload_0			= 0x22;			// ? value loads a
															// float
															// value
	// from local variable 0
	final static short	fload_1			= 0x23;			// ? value loads a
															// float
															// value
	// from local variable 1
	final static short	fload_2			= 0x24;			// ? value loads a
															// float
															// value
	// from local variable 2
	final static short	fload_3			= 0x25;			// ? value loads a
															// float
															// value
	// from local variable 3
	final static short	dload_0			= 0x26;			// ? value loads a
															// double from
	// local variable 0
	final static short	dload_1			= 0x27;			// ? value loads a
															// double from
	// local variable 1
	final static short	dload_2			= 0x28;			// ? value loads a
															// double from
	// local variable 2
	final static short	dload_3			= 0x29;			// ? value loads a
															// double from
	// local variable 3
	final static short	faload			= 0x30;			// arrayref, index ?
															// value loads
	// a float from an array
	final static short	daload			= 0x31;			// arrayref, index ?
															// value loads
	// a double from an array
	final static short	aaload			= 0x32;			// arrayref, index ?
															// value loads
	// onto the stack a reference
	// from an array
	final static short	baload			= 0x33;			// arrayref, index ?
															// value loads
	// a byte or Boolean value from
	// an array
	final static short	caload			= 0x34;			// arrayref, index ?
															// value loads
	// a char from an array
	final static short	saload			= 0x35;			// arrayref, index ?
															// value load
	// short from array
	final static short	istore			= 0x36;			// index value ?
															// store
															// int value
	// into variable #index
	final static short	lstore			= 0x37;			// index value ?
															// store a
															// long
	// value in a local variable
	// #index
	final static short	fstore			= 0x38;			// index value ?
															// stores
															// a float
	// value into a local variable
	// #index
	final static short	dstore			= 0x39;			// index value ?
															// stores
															// a double
	// value into a local variable
	// #index
	final static short	lstore_1		= 0x40;			// value ? store a
															// long
															// value in
	// a local variable 1
	final static short	lstore_2		= 0x41;			// value ? store a
															// long
															// value in
	// a local variable 2
	final static short	lstore_3		= 0x42;			// value ? store a
															// long
															// value in
	// a local variable 3
	final static short	fstore_0		= 0x43;			// value ? stores a
															// float value
	// into local variable 0
	final static short	fstore_1		= 0x44;			// value ? stores a
															// float value
	// into local variable 1
	final static short	fstore_2		= 0x45;			// value ? stores a
															// float value
	// into local variable 2
	final static short	fstore_3		= 0x46;			// value ? stores a
															// float value
	// into local variable 3
	final static short	dstore_0		= 0x47;			// value ? stores a
															// double into
	// local variable 0
	final static short	dstore_1		= 0x48;			// value ? stores a
															// double into
	// local variable 1
	final static short	dstore_2		= 0x49;			// value ? stores a
															// double into
	// local variable 2
	final static short	lastore			= 0x50;			// arrayref, index,
															// value ?
	// store a long to an array
	final static short	fastore			= 0x51;			// arreyref, index,
															// value ?
	// stores a float in an array
	final static short	dastore			= 0x52;			// arrayref, index,
															// value ?
	// stores a double into an array
	final static short	aastore			= 0x53;			// arrayref, index,
															// value ?
	// stores into a reference to an
	// array
	final static short	bastore			= 0x54;			// arrayref, index,
															// value ?
	// stores a byte or Boolean
	// value into an array
	final static short	castore			= 0x55;			// arrayref, index,
															// value ?
	// stores a char into an array
	final static short	sastore			= 0x56;			// arrayref, index,
															// value ?
	// store short to array
	final static short	pop				= 0x57;			// value ? discards
															// the
															// top
	// value on the stack
	final static short	pop2			= 0x58;			// {value2, value1}
															// ?
															// discards
	// the top two values on the
	// stack (or one value, if it is
	// a double or long)
	final static short	dup				= 0x59;			// value ? value,
															// value
	// duplicates the value on top
	// of the stack
	final static short	iadd			= 0x60;			// value1, value2 ?
															// result adds
	// two ints together
	final static short	ladd			= 0x61;			// value1, value2 ?
															// result add
	// two longs
	final static short	fadd			= 0x62;			// value1, value2 ?
															// result adds
	// two floats
	final static short	dadd			= 0x63;			// value1, value2 ?
															// result adds
	// two doubles
	final static short	isub			= 0x64;			// value1, value2 ?
															// result int
	// subtract
	final static short	lsub			= 0x65;			// value1, value2 ?
															// result
	// subtract two longs
	final static short	fsub			= 0x66;			// value1, value2 ?
															// result
	// subtracts two floats
	final static short	dsub			= 0x67;			// value1, value2 ?
															// result
	// subtracts a double from
	// another
	final static short	imul			= 0x68;			// value1, value2 ?
															// result
	// multiply two integers
	final static short	lmul			= 0x69;			// value1, value2 ?
															// result
	// multiplies two longs
	final static short	irem			= 0x70;			// value1, value2 ?
															// result
	// logical int remainder
	final static short	lrem			= 0x71;			// value1, value2 ?
															// result
	// remainder of division of two
	// longs
	final static short	frem			= 0x72;			// value1, value2 ?
															// result gets
	// the remainder from a division
	// between two floats
	final static short	drem			= 0x73;			// value1, value2 ?
															// result gets
	// the remainder from a division
	// between two doubles
	final static short	ineg			= 0x74;			// value ? result
															// negate
															// int
	final static short	lneg			= 0x75;			// value ? result
															// negates a long
	final static short	fneg			= 0x76;			// value ? result
															// negates a
	// float
	final static short	dneg			= 0x77;			// value ? result
															// negates a
	// double
	final static short	ishl			= 0x78;			// value1, value2 ?
															// result int
	// shift left
	final static short	lshl			= 0x79;			// value1, value2 ?
															// result
	// bitwise shift left of a long
	// value1 by value2 positions
	final static short	ior				= 0x80;			// value1, value2 ?
															// result
	// logical int or
	final static short	lor				= 0x81;			// value1, value2 ?
															// result
	// bitwise or of two longs
	final static short	ixor			= 0x82;			// value1, value2 ?
															// result int
	// xor
	final static short	lxor			= 0x83;			// value1, value2 ?
															// result
	// bitwise exclusive or of two
	// longs
	final static short	iinc			= 0x84;			// index, const [No
															// change]
	// increment local variable
	// #index by signed byte const
	final static short	i2l				= 0x85;			// value ? result
															// converts an
	// int into a long
	final static short	i2f				= 0x86;			// value ? result
															// converts an
	// int into a float
	final static short	i2d				= 0x87;			// value ? result
															// converts an
	// int into a double
	final static short	l2i				= 0x88;			// value ? result
															// converts a
	// long to an int
	final static short	l2f				= 0x89;			// value ? result
															// converts a
	// long to a float
	final static short	d2f				= 0x90;			// value ? result
															// converts a
	// double to a float
	final static short	i2b				= 0x91;			// value ? result
															// converts an
	// int into a byte
	final static short	i2c				= 0x92;			// value ? result
															// converts an
	// int into a character
	final static short	i2s				= 0x93;			// value ? result
															// converts an
	// int into a short
	final static short	lcmp			= 0x94;			// value1, value2 ?
															// result
	// compares two longs values
	final static short	fcmpl			= 0x95;			// value1, value2 ?
															// result
	// compares two floats
	final static short	fcmpg			= 0x96;			// value1, value2 ?
															// result
	// compares two floats
	final static short	dcmpl			= 0x97;			// value1, value2 ?
															// result
	// compares two doubles
	final static short	dcmpg			= 0x98;			// value1, value2 ?
															// result
	// compares two doubles
	final static short	ifeq			= 0x99;			// branchbyte1,
															// branchbyte2
	// value ? if value is 0, branch
	// to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	lconst_1		= 0x0a;			// ? 1L pushes the
															// long
															// 1 onto
	// the stack
	final static short	fconst_0		= 0x0b;			// ? 0.0f pushes
															// 0.0f on
															// the
	// stack
	final static short	fconst_1		= 0x0c;			// ? 1.0f pushes
															// 1.0f on
															// the
	// stack
	final static short	fconst_2		= 0x0d;			// ? 2.0f pushes
															// 2.0f on
															// the
	// stack
	final static short	dconst_0		= 0x0e;			// ? 0.0 pushes the
															// constant 0.0
	// onto the stack
	final static short	dconst_1		= 0x0f;			// ? 1.0 pushes the
															// constant 1.0
	// onto the stack
	final static short	iload_0			= 0x1a;			// ? value loads an
															// int
															// value
	// from variable 0
	final static short	iload_1			= 0x1b;			// ? value loads an
															// int
															// value
	// from variable 1
	final static short	iload_2			= 0x1c;			// ? value loads an
															// int
															// value
	// from variable 2
	final static short	iload_3			= 0x1d;			// ? value loads an
															// int
															// value
	// from variable 3
	final static short	lload_0			= 0x1e;			// ? value load a
															// long
															// value
	// from a local variable 0
	final static short	lload_1			= 0x1f;			// ? value load a
															// long
															// value
	// from a local variable 1
	final static short	aload_0			= 0x2a;			// ? objectref loads
															// a
															// reference
	// onto the stack from local
	// variable 0
	final static short	aload_1			= 0x2b;			// ? objectref loads
															// a
															// reference
	// onto the stack from local
	// variable 1
	final static short	aload_2			= 0x2c;			// ? objectref loads
															// a
															// reference
	// onto the stack from local
	// variable 2
	final static short	aload_3			= 0x2d;			// ? objectref loads
															// a
															// reference
	// onto the stack from local
	// variable 3
	final static short	iaload			= 0x2e;			// arrayref, index ?
															// value loads
	// an int from an array
	final static short	laload			= 0x2f;			// arrayref, index ?
															// value load
	// a long from an array
	final static short	astore			= 0x3a;			// index objectref ?
															// stores a
	// reference into a local
	// variable #index
	final static short	istore_0		= 0x3b;			// value ? store int
															// value into
	// variable 0
	final static short	istore_1		= 0x3c;			// value ? store int
															// value into
	// variable 1
	final static short	istore_2		= 0x3d;			// value ? store int
															// value into
	// variable 2
	final static short	istore_3		= 0x3e;			// value ? store int
															// value into
	// variable 3
	final static short	lstore_0		= 0x3f;			// value ? store a
															// long
															// value in
	// a local variable 0
	final static short	dstore_3		= 0x4a;			// value ? stores a
															// double into
	// local variable 3
	final static short	astore_0		= 0x4b;			// objectref ?
															// stores a
	// reference into local variable
	// 0
	final static short	astore_1		= 0x4c;			// objectref ?
															// stores a
	// reference into local variable
	// 1
	final static short	astore_2		= 0x4d;			// objectref ?
															// stores a
	// reference into local variable
	// 2
	final static short	astore_3		= 0x4e;			// objectref ?
															// stores a
	// reference into local variable
	// 3
	final static short	iastore			= 0x4f;			// arrayref, index,
															// value ?
	// stores an int into an array
	final static short	dup_x1			= 0x5a;			// value2, value1 ?
															// value1,
	// value2, value1 inserts a copy
	// of the top value into the
	// stack two values from the top
	final static short	dup_x2			= 0x5b;			// value3, value2,
															// value1 ?
	// value1, value3, value2,
	// value1 inserts a copy of the
	// top value into the stack two
	// (if value2 is double or long
	// it takes up the entry of
	// value3, too) or three values
	// (if value2 is neither double
	// nor long) from the top
	final static short	dup2			= 0x5c;			// {value2, value1}
															// ?
															// {value2,
	// value1}, {value2, value1}
	// duplicate top two stack words
	// (two values, if value1 is not
	// double nor long; a single
	// value, if value1 is double or
	// long)
	final static short	dup2_x1			= 0x5d;			// value3, {value2,
															// value1} ?
	// {value2, value1}, value3,
	// {value2, value1} duplicate
	// two words and insert beneath
	// third word (see explanation
	// above)
	final static short	dup2_x2			= 0x5e;			// {value4, value3},
															// {value2,
	// value1} ? {value2, value1},
	// {value4, value3}, {value2,
	// value1} duplicate two words
	// and insert beneath fourth
	// word
	final static short	swap			= 0x5f;			// value2, value1 ?
															// value1,
	// value2 swaps two top words on
	// the stack (note that value1
	// and value2 must not be double
	// or long)
	final static short	fmul			= 0x6a;			// value1, value2 ?
															// result
	// multiplies two floats
	final static short	dmul			= 0x6b;			// value1, value2 ?
															// result
	// multiplies two doubles
	final static short	idiv			= 0x6c;			// value1, value2 ?
															// result
	// divides two integers
	final static short	ldiv			= 0x6d;			// value1, value2 ?
															// result
	// divide two longs
	final static short	fdiv			= 0x6e;			// value1, value2 ?
															// result
	// divides two floats
	final static short	ddiv			= 0x6f;			// value1, value2 ?
															// result
	// divides two doubles
	final static short	ishr			= 0x7a;			// value1, value2 ?
															// result int
	// shift right
	final static short	lshr			= 0x7b;			// value1, value2 ?
															// result
	// bitwise shift right of a long
	// value1 by value2 positions
	final static short	iushr			= 0x7c;			// value1, value2 ?
															// result int
	// shift right
	final static short	lushr			= 0x7d;			// value1, value2 ?
															// result
	// bitwise shift right of a long
	// value1 by value2 positions,
	// unsigned
	final static short	iand			= 0x7e;			// value1, value2 ?
															// result
	// performs a logical and on two
	// integers
	final static short	land			= 0x7f;			// value1, value2 ?
															// result
	// bitwise and of two longs
	final static short	l2d				= 0x8a;			// value ? result
															// converts a
	// long to a double
	final static short	f2i				= 0x8b;			// value ? result
															// converts a
	// float to an int
	final static short	f2l				= 0x8c;			// value ? result
															// converts a
	// float to a long
	final static short	f2d				= 0x8d;			// value ? result
															// converts a
	// float to a double
	final static short	d2i				= 0x8e;			// value ? result
															// converts a
	// double to an int
	final static short	d2l				= 0x8f;			// value ? result
															// converts a
	// double to a long
	final static short	ifne			= 0x9a;			// branchbyte1,
															// branchbyte2
	// value ? if value is not 0,
	// branch to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	iflt			= 0x9b;			// branchbyte1,
															// branchbyte2
	// value ? if value is less than
	// 0, branch to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	ifge			= 0x9c;			// branchbyte1,
															// branchbyte2
	// value ? if value is greater
	// than or equal to 0, branch to
	// instruction at branchoffset
	// (signed short constructed
	// from unsigned bytes
	// branchbyte1 << 8 +
	// branchbyte2)
	final static short	ifgt			= 0x9d;			// branchbyte1,
															// branchbyte2
	// value ? if value is greater
	// than 0, branch to instruction
	// at branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	ifle			= 0x9e;			// branchbyte1,
															// branchbyte2
	// value ? if value is less than
	// or equal to 0, branch to
	// instruction at branchoffset
	// (signed short constructed
	// from unsigned bytes
	// branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_icmpeq		= 0x9f;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if ints are
	// equal, branch to instruction
	// at branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_icmpne		= 0xa0;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if ints are
	// not equal, branch to
	// instruction at branchoffset
	// (signed short constructed
	// from unsigned bytes
	// branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_icmplt		= 0xa1;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if value1 is
	// less than value2, branch to
	// instruction at branchoffset
	// (signed short constructed
	// from unsigned bytes
	// branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_icmpge		= 0xa2;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if value1 is
	// greater than or equal to
	// value2, branch to instruction
	// at branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_icmpgt		= 0xa3;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if value1 is
	// greater than value2, branch
	// to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_icmple		= 0xa4;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if value1 is
	// less than or equal to value2,
	// branch to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_acmpeq		= 0xa5;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if
	// references are equal, branch
	// to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	if_acmpne		= 0xa6;			// branchbyte1,
															// branchbyte2
	// value1, value2 ? if
	// references are not equal,
	// branch to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	goto_			= 0xa7;			// branchbyte1,
															// branchbyte2 [no
	// change] goes to another
	// instruction at branchoffset
	// (signed short constructed
	// from unsigned bytes
	// branchbyte1 << 8 +
	// branchbyte2)
	final static short	jsr				= 0xa8;			// branchbyte1,
															// branchbyte2 ?
	// address jump to subroutine at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2) and place the
	// return address on the stack
	final static short	ret				= 0xa9;			// index [No change]
															// continue
	// execution from address taken
	// from a local variable #index
	// (the asymmetry with jsr is
	// intentional)
	final static short	tableswitch		= 0xaa;			// [0-3 bytes
															// padding],
	// defaultbyte1, defaultbyte2,
	// defaultbyte3, defaultbyte4,
	// lowbyte1, lowbyte2, lowbyte3,
	// lowbyte4, highbyte1,
	// highbyte2, highbyte3,
	// highbyte4, jump offsets...
	// index ? continue execution
	// from an address in the table
	// at offset index
	final static short	lookupswitch	= 0xab;			// <0-3 bytes
															// padding>,
	// defaultbyte1, defaultbyte2,
	// defaultbyte3, defaultbyte4,
	// npairs1, npairs2, npairs3,
	// npairs4, match-offset
	// pairs... key ? a target
	// address is looked up from a
	// table using a key and
	// execution continues from the
	// instruction at that address
	final static short	ireturn			= 0xac;			// value ? [empty]
															// returns an
	// integer from a method
	final static short	lreturn			= 0xad;			// value ? [empty]
															// returns a
	// long value
	final static short	freturn			= 0xae;			// value ? [empty]
															// returns a
	// float
	final static short	dreturn			= 0xaf;			// value ? [empty]
															// returns a
	// double from a method
	final static short	areturn			= 0xb0;			// objectref ?
															// [empty]
															// returns a
	// reference from a method
	final static short	return_			= 0xb1;			// ? [empty] return
															// void
															// from
	// method
	final static short	getstatic		= 0xb2;			// index1, index2 ?
															// value gets a
	// static field value of a
	// class, where the field is
	// identified by field reference
	// in the constant pool index
	// (index1 << 8 + index2)
	final static short	putstatic		= 0xb3;			// indexbyte1,
															// indexbyte2 value
	// ? set static field to value
	// in a class, where the field
	// is identified by a field
	// reference index in constant
	// pool (indexbyte1 << 8 +
	// indexbyte2)
	final static short	getfield		= 0xb4;			// index1, index2
															// objectref ?
	// value gets a field value of
	// an object objectref, where
	// the field is identified by
	// field reference in the
	// constant pool index (index1
	// << 8 + index2)
	final static short	putfield		= 0xb5;			// indexbyte1,
															// indexbyte2
	// objectref, value ? set field
	// to value in an object
	// objectref, where the field is
	// identified by a field
	// reference index in constant
	// pool (indexbyte1 << 8 +
	// indexbyte2)
	final static short	invokevirtual	= 0xb6;			// indexbyte1,
															// indexbyte2
	// objectref, [arg1, arg2, ...]
	// ? invoke virtual method on
	// object objectref, where the
	// method is identified by
	// method reference index in
	// constant pool (indexbyte1 <<
	// 8 + indexbyte2)
	final static short	invokespecial	= 0xb7;			// indexbyte1,
															// indexbyte2
	// objectref, [arg1, arg2, ...]
	// ? invoke instance method on
	// object objectref, where the
	// method is identified by
	// method reference index in
	// constant pool (indexbyte1 <<
	// 8 + indexbyte2)
	final static short	invokestatic	= 0xb8;			// indexbyte1,
															// indexbyte2 [arg1,
	// arg2, ...] ? invoke a static
	// method, where the method is
	// identified by method
	// reference index in constant
	// pool (indexbyte1 << 8 +
	// indexbyte2)
	final static short	invokeinterface	= 0xb9;			// indexbyte1,
															// indexbyte2,
	// count, 0 objectref, [arg1,
	// arg2, ...] ? invokes an
	// interface method on object
	// objectref, where the
	// interface method is
	// identified by method
	// reference index in constant
	// pool (indexbyte1 << 8 +
	// indexbyte2)
	final static short	xxxunusedxxx	= 0xba;			// this opcode is
															// reserved "for
	// historical reasons"
	final static short	new_			= 0xbb;			// indexbyte1,
															// indexbyte2 ?
	// objectref creates new object
	// of type identified by class
	// reference in constant pool
	// index (indexbyte1 << 8 +
	// indexbyte2)
	final static short	newarray		= 0xbc;			// atype count ?
															// arrayref
	// creates new array with count
	// elements of primitive type
	// identified by atype
	final static short	anewarray		= 0xbd;			// indexbyte1,
															// indexbyte2 count
	// ? arrayref creates a new
	// array of references of length
	// count and component type
	// identified by the class
	// reference index (indexbyte1
	// << 8 + indexbyte2) in the
	// constant pool
	final static short	arraylength		= 0xbe;			// arrayref ? length
															// gets the
	// length of an array
	final static short	athrow			= 0xbf;			// objectref ?
															// [empty],
	// objectref throws an error or
	// exception (notice that the
	// rest of the stack is cleared,
	// leaving only a reference to
	// the Throwable)
	final static short	checkcast		= 0xc0;			// indexbyte1,
															// indexbyte2
	// objectref ? objectref checks
	// whether an objectref is of a
	// certain type, the class
	// reference of which is in the
	// constant pool at index
	// (indexbyte1 << 8 +
	// indexbyte2)
	final static short	instanceof_		= 0xc1;			// indexbyte1,
															// indexbyte2
	// objectref ? result determines
	// if an object objectref is of
	// a given type, identified by
	// class reference index in
	// constant pool (indexbyte1 <<
	// 8 + indexbyte2)
	final static short	monitorenter	= 0xc2;			// objectref ? enter
															// monitor for
	// object ("grab the lock" -
	// start of synchronized()
	// section)
	final static short	monitorexit		= 0xc3;			// objectref ? exit
															// monitor for
	// object ("release the lock" -
	// end of synchronized()
	// section)
	final static short	wide			= 0xc4;			// opcode,
															// indexbyte1,
	// indexbyte2
	final static short	multianewarray	= 0xc5;			// indexbyte1,
															// indexbyte2,
	// dimensions count1,
	// [count2,...] ? arrayref
	// create a new array of
	// dimensions dimensions with
	// elements of type identified
	// by class reference in
	// constant pool index
	// (indexbyte1 << 8 +
	// indexbyte2); the sizes of
	// each dimension is identified
	// by count1, [count2, etc]
	final static short	ifnull			= 0xc6;			// branchbyte1,
															// branchbyte2
	// value ? if value is null,
	// branch to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	ifnonnull		= 0xc7;			// branchbyte1,
															// branchbyte2
	// value ? if value is not null,
	// branch to instruction at
	// branchoffset (signed short
	// constructed from unsigned
	// bytes branchbyte1 << 8 +
	// branchbyte2)
	final static short	goto_w			= 0xc8;			// branchbyte1,
															// branchbyte2,
	// branchbyte3, branchbyte4 [no
	// change] goes to another
	// instruction at branchoffset
	// (signed int constructed from
	// unsigned bytes branchbyte1 <<
	// 24 + branchbyte2 << 16 +
	// branchbyte3 << 8 +
	// branchbyte4)
	final static short	jsr_w			= 0xc9;			// branchbyte1,
															// branchbyte2,
	// branchbyte3, branchbyte4 ?
	// address jump to subroutine at
	// branchoffset (signed int
	// constructed from unsigned
	// bytes branchbyte1 << 24 +
	// branchbyte2 << 16 +
	// branchbyte3 << 8 +
	// branchbyte4) and place the
	// return address on the stack
	final static short	breakpoint		= 0xca;			// reserved for
															// breakpoints in
	// Java debuggers; should not
	// appear in any class file
	final static short	impdep1			= 0xfe;			// reserved for
	// implementation-dependent
	// operations within debuggers;
	// should not appear in any
	// class file
	final static short	impdep2			= 0xff;			// reserved for
	// implementation-dependent
	// operations within debuggers;
	// should not appear in any
	// class file

	final static byte	OFFSETS[]		= new byte[256];

	static {
		OFFSETS[bipush] = 1; // byte ? value pushes a byte onto the
		// stack as an integer value
		OFFSETS[sipush] = 2; // byte1, byte2 ? value pushes a signed
		// integer (byte1 << 8 + byte2) onto the
		// stack
		OFFSETS[ldc] = 1; // index ? value pushes a constant
		// #index from a constant pool (String,
		// int, float or class type) onto the
		// stack
		OFFSETS[ldc_w] = 2; // indexbyte1, indexbyte2 ? value pushes
		// a constant #index from a constant
		// pool (String, int, float or class
		// type) onto the stack (wide index is
		// constructed as indexbyte1 << 8 +
		// indexbyte2)
		OFFSETS[ldc2_w] = 2; // indexbyte1, indexbyte2 ? value pushes
		// a constant #index from a constant
		// pool (double or long) onto the stack
		// (wide index is constructed as
		// indexbyte1 << 8 + indexbyte2)
		OFFSETS[iload] = 1; // index ? value loads an int value from
		// a variable #index
		OFFSETS[lload] = 1; // index ? value load a long value from
		// a local variable #index
		OFFSETS[fload] = 1; // index ? value loads a float value
		// from a local variable #index
		OFFSETS[dload] = 1; // index ? value loads a double value
		// from a local variable #index
		OFFSETS[aload] = 1; // index ? objectref loads a reference
		// onto the stack from a local variable
		// #index
		OFFSETS[istore] = 1; // index value ? store int value into
		// variable #index
		OFFSETS[lstore] = 1; // index value ? store a long value in a
		// local variable #index
		OFFSETS[fstore] = 1; // index value ? stores a float value
		// into a local variable #index
		OFFSETS[dstore] = 1; // index value ? stores a double value
		// into a local variable #index
		OFFSETS[iinc] = 2; // index, const [No change] increment
		// local variable #index by signed byte
		// const
		OFFSETS[ifeq] = 2; // branchbyte1, branchbyte2 value ? if
		// value is 0, branch to instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[astore] = 1; // index objectref ? stores a reference
		// into a local variable #index
		OFFSETS[ifne] = 2; // branchbyte1, branchbyte2 value ? if
		// value is not 0, branch to instruction
		// at branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[iflt] = 2; // branchbyte1, branchbyte2 value ? if
		// value is less than 0, branch to
		// instruction at branchoffset (signed
		// short constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[ifge] = 2; // branchbyte1, branchbyte2 value ? if
		// value is greater than or equal to 0,
		// branch to instruction at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2)
		OFFSETS[ifgt] = 2; // branchbyte1, branchbyte2 value ? if
		// value is greater than 0, branch to
		// instruction at branchoffset (signed
		// short constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[ifle] = 2; // branchbyte1, branchbyte2 value ? if
		// value is less than or equal to 0,
		// branch to instruction at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2)
		OFFSETS[if_icmpeq] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if ints are equal,
		// branch to instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[if_icmpne] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if ints are not equal,
		// branch to instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[if_icmplt] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if value1 is less than
		// value2, branch to instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[if_icmpge] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if value1 is greater
		// than or equal to value2, branch
		// to instruction at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2)
		OFFSETS[if_icmpgt] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if value1 is greater
		// than value2, branch to
		// instruction at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2)
		OFFSETS[if_icmple] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if value1 is less than
		// or equal to value2, branch to
		// instruction at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2)
		OFFSETS[if_acmpeq] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if references are equal,
		// branch to instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[if_acmpne] = 2; // branchbyte1, branchbyte2 value1,
		// value2 ? if references are not
		// equal, branch to instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[goto_] = 2; // branchbyte1, branchbyte2 [no change]
		// goes to another instruction at
		// branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[jsr] = 2; // branchbyte1, branchbyte2 ? address
		// jump to subroutine at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2) and place the return
		// address on the stack
		OFFSETS[ret] = 1; // index [No change] continue execution
		// from address taken from a local
		// variable #index (the asymmetry with
		// jsr is intentional)
		OFFSETS[tableswitch] = -1; // [0-3 bytes padding],
		// defaultbyte1, defaultbyte2,
		// defaultbyte3, defaultbyte4,
		// lowbyte1, lowbyte2, lowbyte3,
		// lowbyte4, highbyte1,
		// highbyte2, highbyte3,
		// highbyte4, jump offsets...
		// index ? continue execution
		// from an address in the table
		// at offset index
		OFFSETS[lookupswitch] = -1; // <0-3 bytes padding>,
		// defaultbyte1, defaultbyte2,
		// defaultbyte3, defaultbyte4,
		// npairs1, npairs2, npairs3,
		// npairs4, match-offset
		// pairs... key ? a target
		// address is looked up from a
		// table using a key and
		// execution continues from the
		// instruction at that address
		OFFSETS[getstatic] = 2; // index1, index2 ? value gets a
		// static field value of a class,
		// where the field is identified by
		// field reference in the constant
		// pool index (index1 << 8 + index2)
		OFFSETS[putstatic] = 2; // indexbyte1, indexbyte2 value ?
		// set static field to value in a
		// class, where the field is
		// identified by a field reference
		// index in constant pool
		// (indexbyte1 << 8 + indexbyte2)
		OFFSETS[getfield] = 2; // index1, index2 objectref ? value
		// gets a field value of an object
		// objectref, where the field is
		// identified by field reference in
		// the constant pool index (index1
		// << 8 + index2)
		OFFSETS[putfield] = 2; // indexbyte1, indexbyte2 objectref,
		// value ? set field to value in an
		// object objectref, where the field
		// is identified by a field
		// reference index in constant pool
		// (indexbyte1 << 8 + indexbyte2)
		OFFSETS[invokevirtual] = 2; // indexbyte1, indexbyte2
		// objectref, [arg1, arg2, ...]
		// ? invoke virtual method on
		// object objectref, where the
		// method is identified by
		// method reference index in
		// constant pool (indexbyte1 <<
		// 8 + indexbyte2)
		OFFSETS[invokespecial] = 2; // indexbyte1, indexbyte2
		// objectref, [arg1, arg2, ...]
		// ? invoke instance method on
		// object objectref, where the
		// method is identified by
		// method reference index in
		// constant pool (indexbyte1 <<
		// 8 + indexbyte2)
		OFFSETS[invokestatic] = 2; // indexbyte1, indexbyte2 [arg1,
		// arg2, ...] ? invoke a static
		// method, where the method is
		// identified by method
		// reference index in constant
		// pool (indexbyte1 << 8 +
		// indexbyte2)
		OFFSETS[invokeinterface] = 2; // indexbyte1, indexbyte2,
		// count, 0 objectref,
		// [arg1, arg2, ...] ?
		// invokes an interface
		// method on object
		// objectref, where the
		// interface method is
		// identified by method
		// reference index in
		// constant pool (indexbyte1
		// << 8 + indexbyte2)
		OFFSETS[new_] = 2; // indexbyte1, indexbyte2 ? objectref
		// creates new object of type identified
		// by class reference in constant pool
		// index (indexbyte1 << 8 + indexbyte2)
		OFFSETS[newarray] = 1; // atype count ? arrayref creates
		// new array with count elements of
		// primitive type identified by
		// atype
		OFFSETS[anewarray] = 2; // indexbyte1, indexbyte2 count ?
		// arrayref creates a new array of
		// references of length count and
		// component type identified by the
		// class reference index (indexbyte1
		// << 8 + indexbyte2) in the
		// constant pool
		OFFSETS[checkcast] = 2; // indexbyte1, indexbyte2 objectref
		// ? objectref checks whether an
		// objectref is of a certain type,
		// the class reference of which is
		// in the constant pool at index
		// (indexbyte1 << 8 + indexbyte2)
		OFFSETS[instanceof_] = 2; // indexbyte1, indexbyte2 objectref
		// ? result determines if an object
		// objectref is of a given type,
		// identified by class reference
		// index in constant pool
		// (indexbyte1 << 8 + indexbyte2)
		OFFSETS[wide] = 3; // opcode, indexbyte1, indexbyte2
		OFFSETS[multianewarray] = 3; // indexbyte1, indexbyte2,
		// dimensions count1,
		// [count2,...] ? arrayref
		// create a new array of
		// dimensions dimensions with
		// elements of type identified
		// by class reference in
		// constant pool index
		// (indexbyte1 << 8 +
		// indexbyte2); the sizes of
		// each dimension is identified
		// by count1, [count2, etc]
		OFFSETS[ifnull] = 2; // branchbyte1, branchbyte2 value ? if
		// value is null, branch to instruction
		// at branchoffset (signed short
		// constructed from unsigned bytes
		// branchbyte1 << 8 + branchbyte2)
		OFFSETS[ifnonnull] = 2; // branchbyte1, branchbyte2 value ?
		// if value is not null, branch to
		// instruction at branchoffset
		// (signed short constructed from
		// unsigned bytes branchbyte1 << 8 +
		// branchbyte2)
		OFFSETS[goto_w] = 4; // branchbyte1, branchbyte2,
		// branchbyte3, branchbyte4 [no change]
		// goes to another instruction at
		// branchoffset (signed int constructed
		// from unsigned bytes branchbyte1 << 24
		// + branchbyte2 << 16 + branchbyte3 <<
		// 8 + branchbyte4)
		OFFSETS[jsr_w] = 4; // branchbyte1, branchbyte2,
		// branchbyte3, branchbyte4 ? address
		// jump to subroutine at branchoffset
		// (signed int constructed from unsigned
		// bytes branchbyte1 << 24 + branchbyte2
		// << 16 + branchbyte3 << 8 +
		// branchbyte4) and place the return
		// address on the stack
	}

}