NumberMathModificationInfo (Groovy 6.0.0-alpha-2)

org.codehaus.groovy.runtime.typehandling.NumberMathModificationInfo

```
public class NumberMathModificationInfo
extends Object
```
Tracks modifications to arithmetic operations on numeric types.
This class monitors which arithmetic operations have been modified for each numeric type (Byte, Short, Integer, Long, Float, Double). It maintains a set of standard operation names and provides a singleton instance for global tracking.
Used internally by the Groovy compiler/runtime to detect when standard numeric operations have been overridden or modified, which may require special handling in code generation.

Field Summary

Fields
Modifiers	Name	Description
`boolean`	`byte_and`	Flags indicating whether the bitwise AND (&) operation has been modified for Byte type.
`boolean`	`byte_div`	Flags indicating whether the divide (/) operation has been modified for Byte type.
`boolean`	`byte_intdiv`	Flags indicating whether the integer division (//) operation has been modified for Byte type.
`boolean`	`byte_leftShift`	Flags indicating whether the left shift (<<) operation has been modified for Byte type.
`boolean`	`byte_minus`	Flags indicating whether the minus (-) operation has been modified for Byte type.
`boolean`	`byte_mod`	Flags indicating whether the modulo (%) operation has been modified for Byte type.
`boolean`	`byte_multiply`	Flags indicating whether the multiply (*) operation has been modified for Byte type.
`boolean`	`byte_or`	Flags indicating whether the bitwise OR (\|) operation has been modified for Byte type.
`boolean`	`byte_plus`	Flags indicating whether the plus (+) operation has been modified for each numeric type.
`boolean`	`byte_remainder`	Flags indicating whether the remainder operation has been modified for Byte type.
`boolean`	`byte_rightShift`	Flags indicating whether the right shift (>>) operation has been modified for Byte type.
`boolean`	`byte_rightShiftUnsigned`	Flags indicating whether the unsigned right shift (>>>) operation has been modified for Byte type.
`boolean`	`byte_xor`	Flags indicating whether the bitwise XOR (^) operation has been modified for Byte type.
`boolean`	`double_and`	Flags indicating whether the bitwise AND (&) operation has been modified for Double type.
`boolean`	`double_div`	Flags indicating whether the divide (/) operation has been modified for Double type.
`boolean`	`double_intdiv`	Flags indicating whether the integer division (//) operation has been modified for Double type.
`boolean`	`double_leftShift`	Flags indicating whether the left shift (<<) operation has been modified for Double type.
`boolean`	`double_minus`	Flags indicating whether the minus (-) operation has been modified for Double type.
`boolean`	`double_mod`	Flags indicating whether the modulo (%) operation has been modified for Double type.
`boolean`	`double_multiply`	Flags indicating whether the multiply (*) operation has been modified for Double type.
`boolean`	`double_or`	Flags indicating whether the bitwise OR (\|) operation has been modified for Double type.
`boolean`	`double_plus`	Flags indicating whether the plus (+) operation has been modified for Double type.
`boolean`	`double_remainder`	Flags indicating whether the remainder operation has been modified for Double type.
`boolean`	`double_rightShift`	Flags indicating whether the right shift (>>) operation has been modified for Double type.
`boolean`	`double_rightShiftUnsigned`	Flags indicating whether the unsigned right shift (>>>) operation has been modified for Double type.
`boolean`	`double_xor`	Flags indicating whether the bitwise XOR (^) operation has been modified for Double type.
`boolean`	`float_and`	Flags indicating whether the bitwise AND (&) operation has been modified for Float type.
`boolean`	`float_div`	Flags indicating whether the divide (/) operation has been modified for Float type.
`boolean`	`float_intdiv`	Flags indicating whether the integer division (//) operation has been modified for Float type.
`boolean`	`float_leftShift`	Flags indicating whether the left shift (<<) operation has been modified for Float type.
`boolean`	`float_minus`	Flags indicating whether the minus (-) operation has been modified for Float type.
`boolean`	`float_mod`	Flags indicating whether the modulo (%) operation has been modified for Float type.
`boolean`	`float_multiply`	Flags indicating whether the multiply (*) operation has been modified for Float type.
`boolean`	`float_or`	Flags indicating whether the bitwise OR (\|) operation has been modified for Float type.
`boolean`	`float_plus`	Flags indicating whether the plus (+) operation has been modified for Float type.
`boolean`	`float_remainder`	Flags indicating whether the remainder operation has been modified for Float type.
`boolean`	`float_rightShift`	Flags indicating whether the right shift (>>) operation has been modified for Float type.
`boolean`	`float_rightShiftUnsigned`	Flags indicating whether the unsigned right shift (>>>) operation has been modified for Float type.
`boolean`	`float_xor`	Flags indicating whether the bitwise XOR (^) operation has been modified for Float type.
`static NumberMathModificationInfo`	`instance`	Singleton instance of NumberMathModificationInfo.
`boolean`	`int_and`	Flags indicating whether the bitwise AND (&) operation has been modified for Integer type.
`boolean`	`int_div`	Flags indicating whether the divide (/) operation has been modified for Integer type.
`boolean`	`int_intdiv`	Flags indicating whether the integer division (//) operation has been modified for Integer type.
`boolean`	`int_leftShift`	Flags indicating whether the left shift (<<) operation has been modified for Integer type.
`boolean`	`int_minus`	Flags indicating whether the minus (-) operation has been modified for Integer type.
`boolean`	`int_mod`	Flags indicating whether the modulo (%) operation has been modified for Integer type.
`boolean`	`int_multiply`	Flags indicating whether the multiply (*) operation has been modified for Integer type.
`boolean`	`int_or`	Flags indicating whether the bitwise OR (\|) operation has been modified for Integer type.
`boolean`	`int_plus`	Flags indicating whether the plus (+) operation has been modified for Integer type.
`boolean`	`int_remainder`	Flags indicating whether the remainder operation has been modified for Integer type.
`boolean`	`int_rightShift`	Flags indicating whether the right shift (>>) operation has been modified for Integer type.
`boolean`	`int_rightShiftUnsigned`	Flags indicating whether the unsigned right shift (>>>) operation has been modified for Integer type.
`boolean`	`int_xor`	Flags indicating whether the bitwise XOR (^) operation has been modified for Integer type.
`boolean`	`long_and`	Flags indicating whether the bitwise AND (&) operation has been modified for Long type.
`boolean`	`long_div`	Flags indicating whether the divide (/) operation has been modified for Long type.
`boolean`	`long_intdiv`	Flags indicating whether the integer division (//) operation has been modified for Long type.
`boolean`	`long_leftShift`	Flags indicating whether the left shift (<<) operation has been modified for Long type.
`boolean`	`long_minus`	Flags indicating whether the minus (-) operation has been modified for Long type.
`boolean`	`long_mod`	Flags indicating whether the modulo (%) operation has been modified for Long type.
`boolean`	`long_multiply`	Flags indicating whether the multiply (*) operation has been modified for Long type.
`boolean`	`long_or`	Flags indicating whether the bitwise OR (\|) operation has been modified for Long type.
`boolean`	`long_plus`	Flags indicating whether the plus (+) operation has been modified for Long type.
`boolean`	`long_remainder`	Flags indicating whether the remainder operation has been modified for Long type.
`boolean`	`long_rightShift`	Flags indicating whether the right shift (>>) operation has been modified for Long type.
`boolean`	`long_rightShiftUnsigned`	Flags indicating whether the unsigned right shift (>>>) operation has been modified for Long type.
`boolean`	`long_xor`	Flags indicating whether the bitwise XOR (^) operation has been modified for Long type.
`boolean`	`short_and`	Flags indicating whether the bitwise AND (&) operation has been modified for Short type.
`boolean`	`short_div`	Flags indicating whether the divide (/) operation has been modified for Short type.
`boolean`	`short_intdiv`	Flags indicating whether the integer division (//) operation has been modified for Short type.
`boolean`	`short_leftShift`	Flags indicating whether the left shift (<<) operation has been modified for Short type.
`boolean`	`short_minus`	Flags indicating whether the minus (-) operation has been modified for Short type.
`boolean`	`short_mod`	Flags indicating whether the modulo (%) operation has been modified for Short type.
`boolean`	`short_multiply`	Flags indicating whether the multiply (*) operation has been modified for Short type.
`boolean`	`short_or`	Flags indicating whether the bitwise OR (\|) operation has been modified for Short type.
`boolean`	`short_plus`	Flags indicating whether the plus (+) operation has been modified for Short type.
`boolean`	`short_remainder`	Flags indicating whether the remainder operation has been modified for Short type.
`boolean`	`short_rightShift`	Flags indicating whether the right shift (>>) operation has been modified for Short type.
`boolean`	`short_rightShiftUnsigned`	Flags indicating whether the unsigned right shift (>>>) operation has been modified for Short type.
`boolean`	`short_xor`	Flags indicating whether the bitwise XOR (^) operation has been modified for Short type.

Methods Summary

Methods
Type Params	Return Type	Name and description
	`public static int`	`and(byte op1, byte op2)` Performs bitwise AND on two numeric values (op1 and byte).
	`public static int`	`and(byte op1, short op2)` Performs bitwise AND on two numeric values (op1 and short).
	`public static int`	`and(byte op1, int op2)` Performs bitwise AND on two numeric values (op1 and int).
	`public static long`	`and(byte op1, long op2)` Performs bitwise AND on two numeric values (op1 and long).
	`public static int`	`and(short op1, byte op2)` Performs bitwise AND on two numeric values (op1 and byte).
	`public static int`	`and(short op1, short op2)` Performs bitwise AND on two numeric values (op1 and short).
	`public static int`	`and(short op1, int op2)` Performs bitwise AND on two numeric values (op1 and int).
	`public static long`	`and(short op1, long op2)` Performs bitwise AND on two numeric values (op1 and long).
	`public static int`	`and(int op1, byte op2)` Performs bitwise AND on two numeric values (op1 and byte).
	`public static int`	`and(int op1, short op2)` Performs bitwise AND on two numeric values (op1 and short).
	`public static int`	`and(int op1, int op2)` Performs bitwise AND on two numeric values (op1 and int).
	`public static long`	`and(int op1, long op2)` Performs bitwise AND on two numeric values (op1 and long).
	`public static long`	`and(long op1, byte op2)` Performs bitwise AND on two numeric values (op1 and byte).
	`public static long`	`and(long op1, short op2)` Performs bitwise AND on two numeric values (op1 and short).
	`public static long`	`and(long op1, int op2)` Performs bitwise AND on two numeric values (op1 and int).
	`public static long`	`and(long op1, long op2)` Performs bitwise AND on two numeric values (op1 and long).
	`public void`	`checkIfStdMethod(MetaMethod method)` Checks whether a method represents a modification to a standard numeric operation.
	`public static int`	`div(byte op1, byte op2)` Performs division on two numeric values (byte and byte).
	`public static int`	`div(byte op1, short op2)` Performs division on two numeric values (byte and short).
	`public static int`	`div(byte op1, int op2)` Performs division on two numeric values (byte and int).
	`public static long`	`div(byte op1, long op2)` Performs division on two numeric values (byte and long).
	`public static double`	`div(byte op1, float op2)` Performs division on two numeric values (byte and float).
	`public static double`	`div(byte op1, double op2)` Performs division on two numeric values (byte and double).
	`public static int`	`div(short op1, byte op2)` Performs division on two numeric values (short and byte).
	`public static int`	`div(short op1, short op2)` Performs division on two numeric values (short and short).
	`public static int`	`div(short op1, int op2)` Performs division on two numeric values (short and int).
	`public static long`	`div(short op1, long op2)` Performs division on two numeric values (short and long).
	`public static double`	`div(short op1, float op2)` Performs division on two numeric values (short and float).
	`public static double`	`div(short op1, double op2)` Performs division on two numeric values (short and double).
	`public static int`	`div(int op1, byte op2)` Performs division on two numeric values (int and byte).
	`public static int`	`div(int op1, short op2)` Performs division on two numeric values (int and short).
	`public static int`	`div(int op1, int op2)` Performs division on two numeric values (int and int).
	`public static long`	`div(int op1, long op2)` Performs division on two numeric values (int and long).
	`public static double`	`div(int op1, float op2)` Performs division on two numeric values (int and float).
	`public static double`	`div(int op1, double op2)` Performs division on two numeric values (int and double).
	`public static long`	`div(long op1, byte op2)` Performs division on two numeric values (long and byte).
	`public static long`	`div(long op1, short op2)` Performs division on two numeric values (long and short).
	`public static long`	`div(long op1, int op2)` Performs division on two numeric values (long and int).
	`public static long`	`div(long op1, long op2)` Performs division on two numeric values (long and long).
	`public static double`	`div(long op1, float op2)` Performs division on two numeric values (long and float).
	`public static double`	`div(long op1, double op2)` Performs division on two numeric values (long and double).
	`public static double`	`div(float op1, byte op2)` Performs division on two numeric values (float and byte).
	`public static double`	`div(float op1, short op2)` Performs division on two numeric values (float and short).
	`public static double`	`div(float op1, int op2)` Performs division on two numeric values (float and int).
	`public static double`	`div(float op1, long op2)` Performs division on two numeric values (float and long).
	`public static double`	`div(float op1, float op2)` Performs division on two numeric values (float and float).
	`public static double`	`div(float op1, double op2)` Performs division on two numeric values (float and double).
	`public static double`	`div(double op1, byte op2)` Performs division on two numeric values (double and byte).
	`public static double`	`div(double op1, short op2)` Performs division on two numeric values (double and short).
	`public static double`	`div(double op1, int op2)` Performs division on two numeric values (double and int).
	`public static double`	`div(double op1, long op2)` Performs division on two numeric values (double and long).
	`public static double`	`div(double op1, float op2)` Performs division on two numeric values (double and float).
	`public static double`	`div(double op1, double op2)` Performs division on two numeric values (double and double).
	`public static int`	`intdiv(byte op1, byte op2)` Performs integer division on two numeric values (op1 and byte).
	`public static int`	`intdiv(byte op1, short op2)` Performs integer division on two numeric values (op1 and short).
	`public static int`	`intdiv(byte op1, int op2)` Performs integer division on two numeric values (op1 and int).
	`public static long`	`intdiv(byte op1, long op2)` Performs integer division on two numeric values (op1 and long).
	`public static int`	`intdiv(short op1, byte op2)` Performs integer division on two numeric values (op1 and byte).
	`public static int`	`intdiv(short op1, short op2)` Performs integer division on two numeric values (op1 and short).
	`public static int`	`intdiv(short op1, int op2)` Performs integer division on two numeric values (op1 and int).
	`public static long`	`intdiv(short op1, long op2)` Performs integer division on two numeric values (op1 and long).
	`public static int`	`intdiv(int op1, byte op2)` Performs integer division on two numeric values (op1 and byte).
	`public static int`	`intdiv(int op1, short op2)` Performs integer division on two numeric values (op1 and short).
	`public static int`	`intdiv(int op1, int op2)` Performs integer division on two numeric values (op1 and int).
	`public static long`	`intdiv(int op1, long op2)` Performs integer division on two numeric values (op1 and long).
	`public static long`	`intdiv(long op1, byte op2)` Performs integer division on two numeric values (op1 and byte).
	`public static long`	`intdiv(long op1, short op2)` Performs integer division on two numeric values (op1 and short).
	`public static long`	`intdiv(long op1, int op2)` Performs integer division on two numeric values (op1 and int).
	`public static long`	`intdiv(long op1, long op2)` Performs integer division on two numeric values (op1 and long).
	`public static int`	`leftShift(byte op1, byte op2)` Performs left shift on two numeric values (op1 and byte).
	`public static int`	`leftShift(byte op1, short op2)` Performs left shift on two numeric values (op1 and short).
	`public static int`	`leftShift(byte op1, int op2)` Performs left shift on two numeric values (op1 and int).
	`public static long`	`leftShift(byte op1, long op2)` Performs left shift on two numeric values (op1 and long).
	`public static int`	`leftShift(short op1, byte op2)` Performs left shift on two numeric values (op1 and byte).
	`public static int`	`leftShift(short op1, short op2)` Performs left shift on two numeric values (op1 and short).
	`public static int`	`leftShift(short op1, int op2)` Performs left shift on two numeric values (op1 and int).
	`public static long`	`leftShift(short op1, long op2)` Performs left shift on two numeric values (op1 and long).
	`public static int`	`leftShift(int op1, byte op2)` Performs left shift on two numeric values (op1 and byte).
	`public static int`	`leftShift(int op1, short op2)` Performs left shift on two numeric values (op1 and short).
	`public static int`	`leftShift(int op1, int op2)` Performs left shift on two numeric values (op1 and int).
	`public static long`	`leftShift(int op1, long op2)` Performs left shift on two numeric values (op1 and long).
	`public static long`	`leftShift(long op1, byte op2)` Performs left shift on two numeric values (op1 and byte).
	`public static long`	`leftShift(long op1, short op2)` Performs left shift on two numeric values (op1 and short).
	`public static long`	`leftShift(long op1, int op2)` Performs left shift on two numeric values (op1 and int).
	`public static long`	`leftShift(long op1, long op2)` Performs left shift on two numeric values (op1 and long).
	`public static int`	`minus(byte op1, byte op2)` Performs subtraction on two numeric values (byte and byte).
	`public static int`	`minus(byte op1, short op2)` Performs subtraction on two numeric values (byte and short).
	`public static int`	`minus(byte op1, int op2)` Performs subtraction on two numeric values (byte and int).
	`public static long`	`minus(byte op1, long op2)` Performs subtraction on two numeric values (byte and long).
	`public static double`	`minus(byte op1, float op2)` Performs subtraction on two numeric values (byte and float).
	`public static double`	`minus(byte op1, double op2)` Performs subtraction on two numeric values (byte and double).
	`public static int`	`minus(short op1, byte op2)` Performs subtraction on two numeric values (short and byte).
	`public static int`	`minus(short op1, short op2)` Performs subtraction on two numeric values (short and short).
	`public static int`	`minus(short op1, int op2)` Performs subtraction on two numeric values (short and int).
	`public static long`	`minus(short op1, long op2)` Performs subtraction on two numeric values (short and long).
	`public static double`	`minus(short op1, float op2)` Performs subtraction on two numeric values (short and float).
	`public static double`	`minus(short op1, double op2)` Performs subtraction on two numeric values (short and double).
	`public static int`	`minus(int op1, byte op2)` Performs subtraction on two numeric values (int and byte).
	`public static int`	`minus(int op1, short op2)` Performs subtraction on two numeric values (int and short).
	`public static int`	`minus(int op1, int op2)` Performs subtraction on two numeric values (int and int).
	`public static long`	`minus(int op1, long op2)` Performs subtraction on two numeric values (int and long).
	`public static double`	`minus(int op1, float op2)` Performs subtraction on two numeric values (int and float).
	`public static double`	`minus(int op1, double op2)` Performs subtraction on two numeric values (int and double).
	`public static long`	`minus(long op1, byte op2)` Performs subtraction on two numeric values (long and byte).
	`public static long`	`minus(long op1, short op2)` Performs subtraction on two numeric values (long and short).
	`public static long`	`minus(long op1, int op2)` Performs subtraction on two numeric values (long and int).
	`public static long`	`minus(long op1, long op2)` Performs subtraction on two numeric values (long and long).
	`public static double`	`minus(long op1, float op2)` Performs subtraction on two numeric values (long and float).
	`public static double`	`minus(long op1, double op2)` Performs subtraction on two numeric values (long and double).
	`public static double`	`minus(float op1, byte op2)` Performs subtraction on two numeric values (float and byte).
	`public static double`	`minus(float op1, short op2)` Performs subtraction on two numeric values (float and short).
	`public static double`	`minus(float op1, int op2)` Performs subtraction on two numeric values (float and int).
	`public static double`	`minus(float op1, long op2)` Performs subtraction on two numeric values (float and long).
	`public static double`	`minus(float op1, float op2)` Performs subtraction on two numeric values (float and float).
	`public static double`	`minus(float op1, double op2)` Performs subtraction on two numeric values (float and double).
	`public static double`	`minus(double op1, byte op2)` Performs subtraction on two numeric values (double and byte).
	`public static double`	`minus(double op1, short op2)` Performs subtraction on two numeric values (double and short).
	`public static double`	`minus(double op1, int op2)` Performs subtraction on two numeric values (double and int).
	`public static double`	`minus(double op1, long op2)` Performs subtraction on two numeric values (double and long).
	`public static double`	`minus(double op1, float op2)` Performs subtraction on two numeric values (double and float).
	`public static double`	`minus(double op1, double op2)` Performs subtraction on two numeric values (double and double).
	`public static int`	`mod(byte op1, byte op2)` Performs modulo on two numeric values (byte and byte).
	`public static int`	`mod(byte op1, short op2)` Performs modulo on two numeric values (byte and short).
	`public static int`	`mod(byte op1, int op2)` Performs modulo on two numeric values (byte and int).
	`public static long`	`mod(byte op1, long op2)` Performs modulo on two numeric values (byte and long).
	`public static int`	`mod(short op1, byte op2)` Performs modulo on two numeric values (short and byte).
	`public static int`	`mod(short op1, short op2)` Performs modulo on two numeric values (short and short).
	`public static int`	`mod(short op1, int op2)` Performs modulo on two numeric values (short and int).
	`public static long`	`mod(short op1, long op2)` Performs modulo on two numeric values (short and long).
	`public static int`	`mod(int op1, byte op2)` Performs modulo on two numeric values (int and byte).
	`public static int`	`mod(int op1, short op2)` Performs modulo on two numeric values (int and short).
	`public static int`	`mod(int op1, int op2)` Performs modulo on two numeric values (int and int).
	`public static long`	`mod(int op1, long op2)` Performs modulo on two numeric values (int and long).
	`public static long`	`mod(long op1, byte op2)` Performs modulo on two numeric values (long and byte).
	`public static long`	`mod(long op1, short op2)` Performs modulo on two numeric values (long and short).
	`public static long`	`mod(long op1, int op2)` Performs modulo on two numeric values (long and int).
	`public static long`	`mod(long op1, long op2)` Performs modulo on two numeric values (long and long).
	`public static int`	`multiply(byte op1, byte op2)` Performs multiplication on two numeric values (byte and byte).
	`public static int`	`multiply(byte op1, short op2)` Performs multiplication on two numeric values (byte and short).
	`public static int`	`multiply(byte op1, int op2)` Performs multiplication on two numeric values (byte and int).
	`public static long`	`multiply(byte op1, long op2)` Performs multiplication on two numeric values (byte and long).
	`public static double`	`multiply(byte op1, float op2)` Performs multiplication on two numeric values (byte and float).
	`public static double`	`multiply(byte op1, double op2)` Performs multiplication on two numeric values (byte and double).
	`public static int`	`multiply(short op1, byte op2)` Performs multiplication on two numeric values (short and byte).
	`public static int`	`multiply(short op1, short op2)` Performs multiplication on two numeric values (short and short).
	`public static int`	`multiply(short op1, int op2)` Performs multiplication on two numeric values (short and int).
	`public static long`	`multiply(short op1, long op2)` Performs multiplication on two numeric values (short and long).
	`public static double`	`multiply(short op1, float op2)` Performs multiplication on two numeric values (short and float).
	`public static double`	`multiply(short op1, double op2)` Performs multiplication on two numeric values (short and double).
	`public static int`	`multiply(int op1, byte op2)` Performs multiplication on two numeric values (int and byte).
	`public static int`	`multiply(int op1, short op2)` Performs multiplication on two numeric values (int and short).
	`public static int`	`multiply(int op1, int op2)` Performs multiplication on two numeric values (int and int).
	`public static long`	`multiply(int op1, long op2)` Performs multiplication on two numeric values (int and long).
	`public static double`	`multiply(int op1, float op2)` Performs multiplication on two numeric values (int and float).
	`public static double`	`multiply(int op1, double op2)` Performs multiplication on two numeric values (int and double).
	`public static long`	`multiply(long op1, byte op2)` Performs multiplication on two numeric values (long and byte).
	`public static long`	`multiply(long op1, short op2)` Performs multiplication on two numeric values (long and short).
	`public static long`	`multiply(long op1, int op2)` Performs multiplication on two numeric values (long and int).
	`public static long`	`multiply(long op1, long op2)` Performs multiplication on two numeric values (long and long).
	`public static double`	`multiply(long op1, float op2)` Performs multiplication on two numeric values (long and float).
	`public static double`	`multiply(long op1, double op2)` Performs multiplication on two numeric values (long and double).
	`public static double`	`multiply(float op1, byte op2)` Performs multiplication on two numeric values (float and byte).
	`public static double`	`multiply(float op1, short op2)` Performs multiplication on two numeric values (float and short).
	`public static double`	`multiply(float op1, int op2)` Performs multiplication on two numeric values (float and int).
	`public static double`	`multiply(float op1, long op2)` Performs multiplication on two numeric values (float and long).
	`public static double`	`multiply(float op1, float op2)` Performs multiplication on two numeric values (float and float).
	`public static double`	`multiply(float op1, double op2)` Performs multiplication on two numeric values (float and double).
	`public static double`	`multiply(double op1, byte op2)` Performs multiplication on two numeric values (double and byte).
	`public static double`	`multiply(double op1, short op2)` Performs multiplication on two numeric values (double and short).
	`public static double`	`multiply(double op1, int op2)` Performs multiplication on two numeric values (double and int).
	`public static double`	`multiply(double op1, long op2)` Performs multiplication on two numeric values (double and long).
	`public static double`	`multiply(double op1, float op2)` Performs multiplication on two numeric values (double and float).
	`public static double`	`multiply(double op1, double op2)` Performs multiplication on two numeric values (double and double).
	`public static int`	`or(byte op1, byte op2)` Performs bitwise OR on two numeric values (op1 and byte).
	`public static int`	`or(byte op1, short op2)` Performs bitwise OR on two numeric values (op1 and short).
	`public static int`	`or(byte op1, int op2)` Performs bitwise OR on two numeric values (op1 and int).
	`public static long`	`or(byte op1, long op2)` Performs bitwise OR on two numeric values (op1 and long).
	`public static int`	`or(short op1, byte op2)` Performs bitwise OR on two numeric values (op1 and byte).
	`public static int`	`or(short op1, short op2)` Performs bitwise OR on two numeric values (op1 and short).
	`public static int`	`or(short op1, int op2)` Performs bitwise OR on two numeric values (op1 and int).
	`public static long`	`or(short op1, long op2)` Performs bitwise OR on two numeric values (op1 and long).
	`public static int`	`or(int op1, byte op2)` Performs bitwise OR on two numeric values (op1 and byte).
	`public static int`	`or(int op1, short op2)` Performs bitwise OR on two numeric values (op1 and short).
	`public static int`	`or(int op1, int op2)` Performs bitwise OR on two numeric values (op1 and int).
	`public static long`	`or(int op1, long op2)` Performs bitwise OR on two numeric values (op1 and long).
	`public static long`	`or(long op1, byte op2)` Performs bitwise OR on two numeric values (op1 and byte).
	`public static long`	`or(long op1, short op2)` Performs bitwise OR on two numeric values (op1 and short).
	`public static long`	`or(long op1, int op2)` Performs bitwise OR on two numeric values (op1 and int).
	`public static long`	`or(long op1, long op2)` Performs bitwise OR on two numeric values (op1 and long).
	`public static int`	`plus(byte op1, byte op2)` Performs addition on two numeric values (byte and byte).
	`public static int`	`plus(byte op1, short op2)` Performs addition on two numeric values (byte and short).
	`public static int`	`plus(byte op1, int op2)` Performs addition on two numeric values (byte and int).
	`public static long`	`plus(byte op1, long op2)` Performs addition on two numeric values (byte and long).
	`public static double`	`plus(byte op1, float op2)` Performs addition on two numeric values (byte and float).
	`public static double`	`plus(byte op1, double op2)` Performs addition on two numeric values (byte and double).
	`public static int`	`plus(short op1, byte op2)` Performs addition on two numeric values (short and byte).
	`public static int`	`plus(short op1, short op2)` Performs addition on two numeric values (short and short).
	`public static int`	`plus(short op1, int op2)` Performs addition on two numeric values (short and int).
	`public static long`	`plus(short op1, long op2)` Performs addition on two numeric values (short and long).
	`public static double`	`plus(short op1, float op2)` Performs addition on two numeric values (short and float).
	`public static double`	`plus(short op1, double op2)` Performs addition on two numeric values (short and double).
	`public static int`	`plus(int op1, byte op2)` Performs addition on two numeric values (int and byte).
	`public static int`	`plus(int op1, short op2)` Performs addition on two numeric values (int and short).
	`public static int`	`plus(int op1, int op2)` Performs addition on two numeric values (int and int).
	`public static long`	`plus(int op1, long op2)` Performs addition on two numeric values (int and long).
	`public static double`	`plus(int op1, float op2)` Performs addition on two numeric values (int and float).
	`public static double`	`plus(int op1, double op2)` Performs addition on two numeric values (int and double).
	`public static long`	`plus(long op1, byte op2)` Performs addition on two numeric values (long and byte).
	`public static long`	`plus(long op1, short op2)` Performs addition on two numeric values (long and short).
	`public static long`	`plus(long op1, int op2)` Performs addition on two numeric values (long and int).
	`public static long`	`plus(long op1, long op2)` Performs addition on two numeric values (long and long).
	`public static double`	`plus(long op1, float op2)` Performs addition on two numeric values (long and float).
	`public static double`	`plus(long op1, double op2)` Performs addition on two numeric values (long and double).
	`public static double`	`plus(float op1, byte op2)` Performs addition on two numeric values (float and byte).
	`public static double`	`plus(float op1, short op2)` Performs addition on two numeric values (float and short).
	`public static double`	`plus(float op1, int op2)` Performs addition on two numeric values (float and int).
	`public static double`	`plus(float op1, long op2)` Performs addition on two numeric values (float and long).
	`public static double`	`plus(float op1, float op2)` Performs addition on two numeric values (float and float).
	`public static double`	`plus(float op1, double op2)` Performs addition on two numeric values (float and double).
	`public static double`	`plus(double op1, byte op2)` Performs addition on two numeric values (double and byte).
	`public static double`	`plus(double op1, short op2)` Performs addition on two numeric values (double and short).
	`public static double`	`plus(double op1, int op2)` Performs addition on two numeric values (double and int).
	`public static double`	`plus(double op1, long op2)` Performs addition on two numeric values (double and long).
	`public static double`	`plus(double op1, float op2)` Performs addition on two numeric values (double and float).
	`public static double`	`plus(double op1, double op2)` Performs addition on two numeric values (double and double).
	`public static int`	`remainder(byte op1, byte op2)` Performs remainder on two numeric values (byte and byte).
	`public static int`	`remainder(byte op1, short op2)` Performs remainder on two numeric values (byte and short).
	`public static int`	`remainder(byte op1, int op2)` Performs remainder on two numeric values (byte and int).
	`public static long`	`remainder(byte op1, long op2)` Performs remainder on two numeric values (byte and long).
	`public static int`	`remainder(short op1, byte op2)` Performs remainder on two numeric values (short and byte).
	`public static int`	`remainder(short op1, short op2)` Performs remainder on two numeric values (short and short).
	`public static int`	`remainder(short op1, int op2)` Performs remainder on two numeric values (short and int).
	`public static long`	`remainder(short op1, long op2)` Performs remainder on two numeric values (short and long).
	`public static int`	`remainder(int op1, byte op2)` Performs remainder on two numeric values (int and byte).
	`public static int`	`remainder(int op1, short op2)` Performs remainder on two numeric values (int and short).
	`public static int`	`remainder(int op1, int op2)` Performs remainder on two numeric values (int and int).
	`public static long`	`remainder(int op1, long op2)` Performs remainder on two numeric values (int and long).
	`public static long`	`remainder(long op1, byte op2)` Performs remainder on two numeric values (long and byte).
	`public static long`	`remainder(long op1, short op2)` Performs remainder on two numeric values (long and short).
	`public static long`	`remainder(long op1, int op2)` Performs remainder on two numeric values (long and int).
	`public static long`	`remainder(long op1, long op2)` Performs remainder on two numeric values (long and long).
	`public static int`	`rightShift(byte op1, byte op2)` Performs right shift on two numeric values (op1 and byte).
	`public static int`	`rightShift(byte op1, short op2)` Performs right shift on two numeric values (op1 and short).
	`public static int`	`rightShift(byte op1, int op2)` Performs right shift on two numeric values (op1 and int).
	`public static long`	`rightShift(byte op1, long op2)` Performs right shift on two numeric values (op1 and long).
	`public static int`	`rightShift(short op1, byte op2)` Performs right shift on two numeric values (op1 and byte).
	`public static int`	`rightShift(short op1, short op2)` Performs right shift on two numeric values (op1 and short).
	`public static int`	`rightShift(short op1, int op2)` Performs right shift on two numeric values (op1 and int).
	`public static long`	`rightShift(short op1, long op2)` Performs right shift on two numeric values (op1 and long).
	`public static int`	`rightShift(int op1, byte op2)` Performs right shift on two numeric values (op1 and byte).
	`public static int`	`rightShift(int op1, short op2)` Performs right shift on two numeric values (op1 and short).
	`public static int`	`rightShift(int op1, int op2)` Performs right shift on two numeric values (op1 and int).
	`public static long`	`rightShift(int op1, long op2)` Performs right shift on two numeric values (op1 and long).
	`public static long`	`rightShift(long op1, byte op2)` Performs right shift on two numeric values (op1 and byte).
	`public static long`	`rightShift(long op1, short op2)` Performs right shift on two numeric values (op1 and short).
	`public static long`	`rightShift(long op1, int op2)` Performs right shift on two numeric values (op1 and int).
	`public static long`	`rightShift(long op1, long op2)` Performs right shift on two numeric values (op1 and long).
	`public static int`	`rightShiftUnsigned(byte op1, byte op2)` Performs unsigned right shift on two numeric values (op1 and byte).
	`public static int`	`rightShiftUnsigned(byte op1, short op2)` Performs unsigned right shift on two numeric values (op1 and short).
	`public static int`	`rightShiftUnsigned(byte op1, int op2)` Performs unsigned right shift on two numeric values (op1 and int).
	`public static long`	`rightShiftUnsigned(byte op1, long op2)` Performs unsigned right shift on two numeric values (op1 and long).
	`public static int`	`rightShiftUnsigned(short op1, byte op2)` Performs unsigned right shift on two numeric values (op1 and byte).
	`public static int`	`rightShiftUnsigned(short op1, short op2)` Performs unsigned right shift on two numeric values (op1 and short).
	`public static int`	`rightShiftUnsigned(short op1, int op2)` Performs unsigned right shift on two numeric values (op1 and int).
	`public static long`	`rightShiftUnsigned(short op1, long op2)` Performs unsigned right shift on two numeric values (op1 and long).
	`public static int`	`rightShiftUnsigned(int op1, byte op2)` Performs unsigned right shift on two numeric values (op1 and byte).
	`public static int`	`rightShiftUnsigned(int op1, short op2)` Performs unsigned right shift on two numeric values (op1 and short).
	`public static int`	`rightShiftUnsigned(int op1, int op2)` Performs unsigned right shift on two numeric values (op1 and int).
	`public static long`	`rightShiftUnsigned(int op1, long op2)` Performs unsigned right shift on two numeric values (op1 and long).
	`public static long`	`rightShiftUnsigned(long op1, byte op2)` Performs unsigned right shift on two numeric values (op1 and byte).
	`public static long`	`rightShiftUnsigned(long op1, short op2)` Performs unsigned right shift on two numeric values (op1 and short).
	`public static long`	`rightShiftUnsigned(long op1, int op2)` Performs unsigned right shift on two numeric values (op1 and int).
	`public static long`	`rightShiftUnsigned(long op1, long op2)` Performs unsigned right shift on two numeric values (op1 and long).
	`public static int`	`xor(byte op1, byte op2)` Performs bitwise XOR on two numeric values (op1 and byte).
	`public static int`	`xor(byte op1, short op2)` Performs bitwise XOR on two numeric values (op1 and short).
	`public static int`	`xor(byte op1, int op2)` Performs bitwise XOR on two numeric values (op1 and int).
	`public static long`	`xor(byte op1, long op2)` Performs bitwise XOR on two numeric values (op1 and long).
	`public static int`	`xor(short op1, byte op2)` Performs bitwise XOR on two numeric values (op1 and byte).
	`public static int`	`xor(short op1, short op2)` Performs bitwise XOR on two numeric values (op1 and short).
	`public static int`	`xor(short op1, int op2)` Performs bitwise XOR on two numeric values (op1 and int).
	`public static long`	`xor(short op1, long op2)` Performs bitwise XOR on two numeric values (op1 and long).
	`public static int`	`xor(int op1, byte op2)` Performs bitwise XOR on two numeric values (op1 and byte).
	`public static int`	`xor(int op1, short op2)` Performs bitwise XOR on two numeric values (op1 and short).
	`public static int`	`xor(int op1, int op2)` Performs bitwise XOR on two numeric values (op1 and int).
	`public static long`	`xor(int op1, long op2)` Performs bitwise XOR on two numeric values (op1 and long).
	`public static long`	`xor(long op1, byte op2)` Performs bitwise XOR on two numeric values (op1 and byte).
	`public static long`	`xor(long op1, short op2)` Performs bitwise XOR on two numeric values (op1 and short).
	`public static long`	`xor(long op1, int op2)` Performs bitwise XOR on two numeric values (op1 and int).
	`public static long`	`xor(long op1, long op2)` Performs bitwise XOR on two numeric values (op1 and long).

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class Object`	`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- Field Detail
  - public boolean byte_and
    
    Flags indicating whether the bitwise AND (&) operation has been modified for Byte type.
  - public boolean byte_div
    
    Flags indicating whether the divide (/) operation has been modified for Byte type.
  - public boolean byte_intdiv
    
    Flags indicating whether the integer division (//) operation has been modified for Byte type.
  - public boolean byte_leftShift
    
    Flags indicating whether the left shift (<<) operation has been modified for Byte type.
  - public boolean byte_minus
    
    Flags indicating whether the minus (-) operation has been modified for Byte type.
  - public boolean byte_mod
    
    Flags indicating whether the modulo (%) operation has been modified for Byte type.
  - public boolean byte_multiply
    
    Flags indicating whether the multiply (*) operation has been modified for Byte type.
  - public boolean byte_or
    
    Flags indicating whether the bitwise OR (|) operation has been modified for Byte type.
  - public boolean byte_plus
    
    Flags indicating whether the plus (+) operation has been modified for each numeric type.
  - public boolean byte_remainder
    
    Flags indicating whether the remainder operation has been modified for Byte type.
  - public boolean byte_rightShift
    
    Flags indicating whether the right shift (>>) operation has been modified for Byte type.
  - public boolean byte_rightShiftUnsigned
    
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Byte type.
  - public boolean byte_xor
    
    Flags indicating whether the bitwise XOR (^) operation has been modified for Byte type.
  - public boolean double_and
    
    Flags indicating whether the bitwise AND (&) operation has been modified for Double type.
  - public boolean double_div
    
    Flags indicating whether the divide (/) operation has been modified for Double type.
  - public boolean double_intdiv
    
    Flags indicating whether the integer division (//) operation has been modified for Double type.
  - public boolean double_leftShift
    
    Flags indicating whether the left shift (<<) operation has been modified for Double type.
  - public boolean double_minus
    
    Flags indicating whether the minus (-) operation has been modified for Double type.
  - public boolean double_mod
    
    Flags indicating whether the modulo (%) operation has been modified for Double type.
  - public boolean double_multiply
    
    Flags indicating whether the multiply (*) operation has been modified for Double type.
  - public boolean double_or
    
    Flags indicating whether the bitwise OR (|) operation has been modified for Double type.
  - public boolean double_plus
    
    Flags indicating whether the plus (+) operation has been modified for Double type.
  - public boolean double_remainder
    
    Flags indicating whether the remainder operation has been modified for Double type.
  - public boolean double_rightShift
    
    Flags indicating whether the right shift (>>) operation has been modified for Double type.
  - public boolean double_rightShiftUnsigned
    
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Double type.
  - public boolean double_xor
    
    Flags indicating whether the bitwise XOR (^) operation has been modified for Double type.
  - public boolean float_and
    
    Flags indicating whether the bitwise AND (&) operation has been modified for Float type.
  - public boolean float_div
    
    Flags indicating whether the divide (/) operation has been modified for Float type.
  - public boolean float_intdiv
    
    Flags indicating whether the integer division (//) operation has been modified for Float type.
  - public boolean float_leftShift
    
    Flags indicating whether the left shift (<<) operation has been modified for Float type.
  - public boolean float_minus
    
    Flags indicating whether the minus (-) operation has been modified for Float type.
  - public boolean float_mod
    
    Flags indicating whether the modulo (%) operation has been modified for Float type.
  - public boolean float_multiply
    
    Flags indicating whether the multiply (*) operation has been modified for Float type.
  - public boolean float_or
    
    Flags indicating whether the bitwise OR (|) operation has been modified for Float type.
  - public boolean float_plus
    
    Flags indicating whether the plus (+) operation has been modified for Float type.
  - public boolean float_remainder
    
    Flags indicating whether the remainder operation has been modified for Float type.
  - public boolean float_rightShift
    
    Flags indicating whether the right shift (>>) operation has been modified for Float type.
  - public boolean float_rightShiftUnsigned
    
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Float type.
  - public boolean float_xor
    
    Flags indicating whether the bitwise XOR (^) operation has been modified for Float type.
  - public static final NumberMathModificationInfo instance
    
    Singleton instance of NumberMathModificationInfo.
  - public boolean int_and
    
    Flags indicating whether the bitwise AND (&) operation has been modified for Integer type.
  - public boolean int_div
    
    Flags indicating whether the divide (/) operation has been modified for Integer type.
  - public boolean int_intdiv
    
    Flags indicating whether the integer division (//) operation has been modified for Integer type.
  - public boolean int_leftShift
    
    Flags indicating whether the left shift (<<) operation has been modified for Integer type.
  - public boolean int_minus
    
    Flags indicating whether the minus (-) operation has been modified for Integer type.
  - public boolean int_mod
    
    Flags indicating whether the modulo (%) operation has been modified for Integer type.
  - public boolean int_multiply
    
    Flags indicating whether the multiply (*) operation has been modified for Integer type.
  - public boolean int_or
    
    Flags indicating whether the bitwise OR (|) operation has been modified for Integer type.
  - public boolean int_plus
    
    Flags indicating whether the plus (+) operation has been modified for Integer type.
  - public boolean int_remainder
    
    Flags indicating whether the remainder operation has been modified for Integer type.
  - public boolean int_rightShift
    
    Flags indicating whether the right shift (>>) operation has been modified for Integer type.
  - public boolean int_rightShiftUnsigned
    
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Integer type.
  - public boolean int_xor
    
    Flags indicating whether the bitwise XOR (^) operation has been modified for Integer type.
  - public boolean long_and
    
    Flags indicating whether the bitwise AND (&) operation has been modified for Long type.
  - public boolean long_div
    
    Flags indicating whether the divide (/) operation has been modified for Long type.
  - public boolean long_intdiv
    
    Flags indicating whether the integer division (//) operation has been modified for Long type.
  - public boolean long_leftShift
    
    Flags indicating whether the left shift (<<) operation has been modified for Long type.
  - public boolean long_minus
    
    Flags indicating whether the minus (-) operation has been modified for Long type.
  - public boolean long_mod
    
    Flags indicating whether the modulo (%) operation has been modified for Long type.
  - public boolean long_multiply
    
    Flags indicating whether the multiply (*) operation has been modified for Long type.
  - public boolean long_or
    
    Flags indicating whether the bitwise OR (|) operation has been modified for Long type.
  - public boolean long_plus
    
    Flags indicating whether the plus (+) operation has been modified for Long type.
  - public boolean long_remainder
    
    Flags indicating whether the remainder operation has been modified for Long type.
  - public boolean long_rightShift
    
    Flags indicating whether the right shift (>>) operation has been modified for Long type.
  - public boolean long_rightShiftUnsigned
    
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Long type.
  - public boolean long_xor
    
    Flags indicating whether the bitwise XOR (^) operation has been modified for Long type.
  - public boolean short_and
    
    Flags indicating whether the bitwise AND (&) operation has been modified for Short type.
  - public boolean short_div
    
    Flags indicating whether the divide (/) operation has been modified for Short type.
  - public boolean short_intdiv
    
    Flags indicating whether the integer division (//) operation has been modified for Short type.
  - public boolean short_leftShift
    
    Flags indicating whether the left shift (<<) operation has been modified for Short type.
  - public boolean short_minus
    
    Flags indicating whether the minus (-) operation has been modified for Short type.
  - public boolean short_mod
    
    Flags indicating whether the modulo (%) operation has been modified for Short type.
  - public boolean short_multiply
    
    Flags indicating whether the multiply (*) operation has been modified for Short type.
  - public boolean short_or
    
    Flags indicating whether the bitwise OR (|) operation has been modified for Short type.
  - public boolean short_plus
    
    Flags indicating whether the plus (+) operation has been modified for Short type.
  - public boolean short_remainder
    
    Flags indicating whether the remainder operation has been modified for Short type.
  - public boolean short_rightShift
    
    Flags indicating whether the right shift (>>) operation has been modified for Short type.
  - public boolean short_rightShiftUnsigned
    
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Short type.
  - public boolean short_xor
    
    Flags indicating whether the bitwise XOR (^) operation has been modified for Short type.
- Method Detail
  - public static int and(byte op1, byte op2)
    
    Performs bitwise AND on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise AND
  - public static int and(byte op1, short op2)
    
    Performs bitwise AND on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise AND
  - public static int and(byte op1, int op2)
    
    Performs bitwise AND on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise AND
  - public static long and(byte op1, long op2)
    
    Performs bitwise AND on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise AND
  - public static int and(short op1, byte op2)
    
    Performs bitwise AND on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise AND
  - public static int and(short op1, short op2)
    
    Performs bitwise AND on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise AND
  - public static int and(short op1, int op2)
    
    Performs bitwise AND on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise AND
  - public static long and(short op1, long op2)
    
    Performs bitwise AND on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise AND
  - public static int and(int op1, byte op2)
    
    Performs bitwise AND on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise AND
  - public static int and(int op1, short op2)
    
    Performs bitwise AND on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise AND
  - public static int and(int op1, int op2)
    
    Performs bitwise AND on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise AND
  - public static long and(int op1, long op2)
    
    Performs bitwise AND on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise AND
  - public static long and(long op1, byte op2)
    
    Performs bitwise AND on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise AND
  - public static long and(long op1, short op2)
    
    Performs bitwise AND on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise AND
  - public static long and(long op1, int op2)
    
    Performs bitwise AND on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise AND
  - public static long and(long op1, long op2)
    
    Performs bitwise AND on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise AND
  - public void checkIfStdMethod(MetaMethod method)
    
    Checks whether a method represents a modification to a standard numeric operation.
    Examines the method's declaring class, name, and parameter types to determine if it overrides a standard numeric operation.
    Parameters:
    method - the method to check
  - public static int div(byte op1, byte op2)
    
    Performs division on two numeric values (byte and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second byte operand
    Returns:
    the result of division
  - public static int div(byte op1, short op2)
    
    Performs division on two numeric values (byte and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second short operand
    Returns:
    the result of division
  - public static int div(byte op1, int op2)
    
    Performs division on two numeric values (byte and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second int operand
    Returns:
    the result of division
  - public static long div(byte op1, long op2)
    
    Performs division on two numeric values (byte and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second long operand
    Returns:
    the result of division
  - public static double div(byte op1, float op2)
    
    Performs division on two numeric values (byte and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second float operand
    Returns:
    the result of division
  - public static double div(byte op1, double op2)
    
    Performs division on two numeric values (byte and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second double operand
    Returns:
    the result of division
  - public static int div(short op1, byte op2)
    
    Performs division on two numeric values (short and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second byte operand
    Returns:
    the result of division
  - public static int div(short op1, short op2)
    
    Performs division on two numeric values (short and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second short operand
    Returns:
    the result of division
  - public static int div(short op1, int op2)
    
    Performs division on two numeric values (short and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second int operand
    Returns:
    the result of division
  - public static long div(short op1, long op2)
    
    Performs division on two numeric values (short and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second long operand
    Returns:
    the result of division
  - public static double div(short op1, float op2)
    
    Performs division on two numeric values (short and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second float operand
    Returns:
    the result of division
  - public static double div(short op1, double op2)
    
    Performs division on two numeric values (short and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second double operand
    Returns:
    the result of division
  - public static int div(int op1, byte op2)
    
    Performs division on two numeric values (int and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second byte operand
    Returns:
    the result of division
  - public static int div(int op1, short op2)
    
    Performs division on two numeric values (int and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second short operand
    Returns:
    the result of division
  - public static int div(int op1, int op2)
    
    Performs division on two numeric values (int and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second int operand
    Returns:
    the result of division
  - public static long div(int op1, long op2)
    
    Performs division on two numeric values (int and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second long operand
    Returns:
    the result of division
  - public static double div(int op1, float op2)
    
    Performs division on two numeric values (int and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second float operand
    Returns:
    the result of division
  - public static double div(int op1, double op2)
    
    Performs division on two numeric values (int and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second double operand
    Returns:
    the result of division
  - public static long div(long op1, byte op2)
    
    Performs division on two numeric values (long and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second byte operand
    Returns:
    the result of division
  - public static long div(long op1, short op2)
    
    Performs division on two numeric values (long and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second short operand
    Returns:
    the result of division
  - public static long div(long op1, int op2)
    
    Performs division on two numeric values (long and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second int operand
    Returns:
    the result of division
  - public static long div(long op1, long op2)
    
    Performs division on two numeric values (long and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second long operand
    Returns:
    the result of division
  - public static double div(long op1, float op2)
    
    Performs division on two numeric values (long and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second float operand
    Returns:
    the result of division
  - public static double div(long op1, double op2)
    
    Performs division on two numeric values (long and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second double operand
    Returns:
    the result of division
  - public static double div(float op1, byte op2)
    
    Performs division on two numeric values (float and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second byte operand
    Returns:
    the result of division
  - public static double div(float op1, short op2)
    
    Performs division on two numeric values (float and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second short operand
    Returns:
    the result of division
  - public static double div(float op1, int op2)
    
    Performs division on two numeric values (float and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second int operand
    Returns:
    the result of division
  - public static double div(float op1, long op2)
    
    Performs division on two numeric values (float and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second long operand
    Returns:
    the result of division
  - public static double div(float op1, float op2)
    
    Performs division on two numeric values (float and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second float operand
    Returns:
    the result of division
  - public static double div(float op1, double op2)
    
    Performs division on two numeric values (float and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second double operand
    Returns:
    the result of division
  - public static double div(double op1, byte op2)
    
    Performs division on two numeric values (double and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second byte operand
    Returns:
    the result of division
  - public static double div(double op1, short op2)
    
    Performs division on two numeric values (double and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second short operand
    Returns:
    the result of division
  - public static double div(double op1, int op2)
    
    Performs division on two numeric values (double and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second int operand
    Returns:
    the result of division
  - public static double div(double op1, long op2)
    
    Performs division on two numeric values (double and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second long operand
    Returns:
    the result of division
  - public static double div(double op1, float op2)
    
    Performs division on two numeric values (double and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second float operand
    Returns:
    the result of division
  - public static double div(double op1, double op2)
    
    Performs division on two numeric values (double and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second double operand
    Returns:
    the result of division
  - public static int intdiv(byte op1, byte op2)
    
    Performs integer division on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of integer division
  - public static int intdiv(byte op1, short op2)
    
    Performs integer division on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of integer division
  - public static int intdiv(byte op1, int op2)
    
    Performs integer division on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of integer division
  - public static long intdiv(byte op1, long op2)
    
    Performs integer division on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of integer division
  - public static int intdiv(short op1, byte op2)
    
    Performs integer division on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of integer division
  - public static int intdiv(short op1, short op2)
    
    Performs integer division on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of integer division
  - public static int intdiv(short op1, int op2)
    
    Performs integer division on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of integer division
  - public static long intdiv(short op1, long op2)
    
    Performs integer division on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of integer division
  - public static int intdiv(int op1, byte op2)
    
    Performs integer division on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of integer division
  - public static int intdiv(int op1, short op2)
    
    Performs integer division on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of integer division
  - public static int intdiv(int op1, int op2)
    
    Performs integer division on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of integer division
  - public static long intdiv(int op1, long op2)
    
    Performs integer division on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of integer division
  - public static long intdiv(long op1, byte op2)
    
    Performs integer division on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of integer division
  - public static long intdiv(long op1, short op2)
    
    Performs integer division on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of integer division
  - public static long intdiv(long op1, int op2)
    
    Performs integer division on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of integer division
  - public static long intdiv(long op1, long op2)
    
    Performs integer division on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of integer division
  - public static int leftShift(byte op1, byte op2)
    
    Performs left shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of left shift
  - public static int leftShift(byte op1, short op2)
    
    Performs left shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of left shift
  - public static int leftShift(byte op1, int op2)
    
    Performs left shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of left shift
  - public static long leftShift(byte op1, long op2)
    
    Performs left shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of left shift
  - public static int leftShift(short op1, byte op2)
    
    Performs left shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of left shift
  - public static int leftShift(short op1, short op2)
    
    Performs left shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of left shift
  - public static int leftShift(short op1, int op2)
    
    Performs left shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of left shift
  - public static long leftShift(short op1, long op2)
    
    Performs left shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of left shift
  - public static int leftShift(int op1, byte op2)
    
    Performs left shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of left shift
  - public static int leftShift(int op1, short op2)
    
    Performs left shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of left shift
  - public static int leftShift(int op1, int op2)
    
    Performs left shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of left shift
  - public static long leftShift(int op1, long op2)
    
    Performs left shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of left shift
  - public static long leftShift(long op1, byte op2)
    
    Performs left shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of left shift
  - public static long leftShift(long op1, short op2)
    
    Performs left shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of left shift
  - public static long leftShift(long op1, int op2)
    
    Performs left shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of left shift
  - public static long leftShift(long op1, long op2)
    
    Performs left shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of left shift
  - public static int minus(byte op1, byte op2)
    
    Performs subtraction on two numeric values (byte and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second byte operand
    Returns:
    the result of subtraction
  - public static int minus(byte op1, short op2)
    
    Performs subtraction on two numeric values (byte and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second short operand
    Returns:
    the result of subtraction
  - public static int minus(byte op1, int op2)
    
    Performs subtraction on two numeric values (byte and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second int operand
    Returns:
    the result of subtraction
  - public static long minus(byte op1, long op2)
    
    Performs subtraction on two numeric values (byte and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second long operand
    Returns:
    the result of subtraction
  - public static double minus(byte op1, float op2)
    
    Performs subtraction on two numeric values (byte and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second float operand
    Returns:
    the result of subtraction
  - public static double minus(byte op1, double op2)
    
    Performs subtraction on two numeric values (byte and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second double operand
    Returns:
    the result of subtraction
  - public static int minus(short op1, byte op2)
    
    Performs subtraction on two numeric values (short and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second byte operand
    Returns:
    the result of subtraction
  - public static int minus(short op1, short op2)
    
    Performs subtraction on two numeric values (short and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second short operand
    Returns:
    the result of subtraction
  - public static int minus(short op1, int op2)
    
    Performs subtraction on two numeric values (short and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second int operand
    Returns:
    the result of subtraction
  - public static long minus(short op1, long op2)
    
    Performs subtraction on two numeric values (short and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second long operand
    Returns:
    the result of subtraction
  - public static double minus(short op1, float op2)
    
    Performs subtraction on two numeric values (short and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second float operand
    Returns:
    the result of subtraction
  - public static double minus(short op1, double op2)
    
    Performs subtraction on two numeric values (short and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second double operand
    Returns:
    the result of subtraction
  - public static int minus(int op1, byte op2)
    
    Performs subtraction on two numeric values (int and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second byte operand
    Returns:
    the result of subtraction
  - public static int minus(int op1, short op2)
    
    Performs subtraction on two numeric values (int and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second short operand
    Returns:
    the result of subtraction
  - public static int minus(int op1, int op2)
    
    Performs subtraction on two numeric values (int and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second int operand
    Returns:
    the result of subtraction
  - public static long minus(int op1, long op2)
    
    Performs subtraction on two numeric values (int and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second long operand
    Returns:
    the result of subtraction
  - public static double minus(int op1, float op2)
    
    Performs subtraction on two numeric values (int and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second float operand
    Returns:
    the result of subtraction
  - public static double minus(int op1, double op2)
    
    Performs subtraction on two numeric values (int and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second double operand
    Returns:
    the result of subtraction
  - public static long minus(long op1, byte op2)
    
    Performs subtraction on two numeric values (long and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second byte operand
    Returns:
    the result of subtraction
  - public static long minus(long op1, short op2)
    
    Performs subtraction on two numeric values (long and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second short operand
    Returns:
    the result of subtraction
  - public static long minus(long op1, int op2)
    
    Performs subtraction on two numeric values (long and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second int operand
    Returns:
    the result of subtraction
  - public static long minus(long op1, long op2)
    
    Performs subtraction on two numeric values (long and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second long operand
    Returns:
    the result of subtraction
  - public static double minus(long op1, float op2)
    
    Performs subtraction on two numeric values (long and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second float operand
    Returns:
    the result of subtraction
  - public static double minus(long op1, double op2)
    
    Performs subtraction on two numeric values (long and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second double operand
    Returns:
    the result of subtraction
  - public static double minus(float op1, byte op2)
    
    Performs subtraction on two numeric values (float and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second byte operand
    Returns:
    the result of subtraction
  - public static double minus(float op1, short op2)
    
    Performs subtraction on two numeric values (float and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second short operand
    Returns:
    the result of subtraction
  - public static double minus(float op1, int op2)
    
    Performs subtraction on two numeric values (float and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second int operand
    Returns:
    the result of subtraction
  - public static double minus(float op1, long op2)
    
    Performs subtraction on two numeric values (float and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second long operand
    Returns:
    the result of subtraction
  - public static double minus(float op1, float op2)
    
    Performs subtraction on two numeric values (float and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second float operand
    Returns:
    the result of subtraction
  - public static double minus(float op1, double op2)
    
    Performs subtraction on two numeric values (float and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second double operand
    Returns:
    the result of subtraction
  - public static double minus(double op1, byte op2)
    
    Performs subtraction on two numeric values (double and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second byte operand
    Returns:
    the result of subtraction
  - public static double minus(double op1, short op2)
    
    Performs subtraction on two numeric values (double and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second short operand
    Returns:
    the result of subtraction
  - public static double minus(double op1, int op2)
    
    Performs subtraction on two numeric values (double and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second int operand
    Returns:
    the result of subtraction
  - public static double minus(double op1, long op2)
    
    Performs subtraction on two numeric values (double and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second long operand
    Returns:
    the result of subtraction
  - public static double minus(double op1, float op2)
    
    Performs subtraction on two numeric values (double and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second float operand
    Returns:
    the result of subtraction
  - public static double minus(double op1, double op2)
    
    Performs subtraction on two numeric values (double and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second double operand
    Returns:
    the result of subtraction
  - public static int mod(byte op1, byte op2)
    
    Performs modulo on two numeric values (byte and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second byte operand
    Returns:
    the result of modulo
  - public static int mod(byte op1, short op2)
    
    Performs modulo on two numeric values (byte and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second short operand
    Returns:
    the result of modulo
  - public static int mod(byte op1, int op2)
    
    Performs modulo on two numeric values (byte and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second int operand
    Returns:
    the result of modulo
  - public static long mod(byte op1, long op2)
    
    Performs modulo on two numeric values (byte and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second long operand
    Returns:
    the result of modulo
  - public static int mod(short op1, byte op2)
    
    Performs modulo on two numeric values (short and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second byte operand
    Returns:
    the result of modulo
  - public static int mod(short op1, short op2)
    
    Performs modulo on two numeric values (short and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second short operand
    Returns:
    the result of modulo
  - public static int mod(short op1, int op2)
    
    Performs modulo on two numeric values (short and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second int operand
    Returns:
    the result of modulo
  - public static long mod(short op1, long op2)
    
    Performs modulo on two numeric values (short and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second long operand
    Returns:
    the result of modulo
  - public static int mod(int op1, byte op2)
    
    Performs modulo on two numeric values (int and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second byte operand
    Returns:
    the result of modulo
  - public static int mod(int op1, short op2)
    
    Performs modulo on two numeric values (int and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second short operand
    Returns:
    the result of modulo
  - public static int mod(int op1, int op2)
    
    Performs modulo on two numeric values (int and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second int operand
    Returns:
    the result of modulo
  - public static long mod(int op1, long op2)
    
    Performs modulo on two numeric values (int and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second long operand
    Returns:
    the result of modulo
  - public static long mod(long op1, byte op2)
    
    Performs modulo on two numeric values (long and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second byte operand
    Returns:
    the result of modulo
  - public static long mod(long op1, short op2)
    
    Performs modulo on two numeric values (long and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second short operand
    Returns:
    the result of modulo
  - public static long mod(long op1, int op2)
    
    Performs modulo on two numeric values (long and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second int operand
    Returns:
    the result of modulo
  - public static long mod(long op1, long op2)
    
    Performs modulo on two numeric values (long and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second long operand
    Returns:
    the result of modulo
  - public static int multiply(byte op1, byte op2)
    
    Performs multiplication on two numeric values (byte and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second byte operand
    Returns:
    the result of multiplication
  - public static int multiply(byte op1, short op2)
    
    Performs multiplication on two numeric values (byte and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second short operand
    Returns:
    the result of multiplication
  - public static int multiply(byte op1, int op2)
    
    Performs multiplication on two numeric values (byte and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second int operand
    Returns:
    the result of multiplication
  - public static long multiply(byte op1, long op2)
    
    Performs multiplication on two numeric values (byte and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second long operand
    Returns:
    the result of multiplication
  - public static double multiply(byte op1, float op2)
    
    Performs multiplication on two numeric values (byte and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second float operand
    Returns:
    the result of multiplication
  - public static double multiply(byte op1, double op2)
    
    Performs multiplication on two numeric values (byte and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second double operand
    Returns:
    the result of multiplication
  - public static int multiply(short op1, byte op2)
    
    Performs multiplication on two numeric values (short and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second byte operand
    Returns:
    the result of multiplication
  - public static int multiply(short op1, short op2)
    
    Performs multiplication on two numeric values (short and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second short operand
    Returns:
    the result of multiplication
  - public static int multiply(short op1, int op2)
    
    Performs multiplication on two numeric values (short and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second int operand
    Returns:
    the result of multiplication
  - public static long multiply(short op1, long op2)
    
    Performs multiplication on two numeric values (short and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second long operand
    Returns:
    the result of multiplication
  - public static double multiply(short op1, float op2)
    
    Performs multiplication on two numeric values (short and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second float operand
    Returns:
    the result of multiplication
  - public static double multiply(short op1, double op2)
    
    Performs multiplication on two numeric values (short and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second double operand
    Returns:
    the result of multiplication
  - public static int multiply(int op1, byte op2)
    
    Performs multiplication on two numeric values (int and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second byte operand
    Returns:
    the result of multiplication
  - public static int multiply(int op1, short op2)
    
    Performs multiplication on two numeric values (int and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second short operand
    Returns:
    the result of multiplication
  - public static int multiply(int op1, int op2)
    
    Performs multiplication on two numeric values (int and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second int operand
    Returns:
    the result of multiplication
  - public static long multiply(int op1, long op2)
    
    Performs multiplication on two numeric values (int and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second long operand
    Returns:
    the result of multiplication
  - public static double multiply(int op1, float op2)
    
    Performs multiplication on two numeric values (int and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second float operand
    Returns:
    the result of multiplication
  - public static double multiply(int op1, double op2)
    
    Performs multiplication on two numeric values (int and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second double operand
    Returns:
    the result of multiplication
  - public static long multiply(long op1, byte op2)
    
    Performs multiplication on two numeric values (long and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second byte operand
    Returns:
    the result of multiplication
  - public static long multiply(long op1, short op2)
    
    Performs multiplication on two numeric values (long and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second short operand
    Returns:
    the result of multiplication
  - public static long multiply(long op1, int op2)
    
    Performs multiplication on two numeric values (long and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second int operand
    Returns:
    the result of multiplication
  - public static long multiply(long op1, long op2)
    
    Performs multiplication on two numeric values (long and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second long operand
    Returns:
    the result of multiplication
  - public static double multiply(long op1, float op2)
    
    Performs multiplication on two numeric values (long and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second float operand
    Returns:
    the result of multiplication
  - public static double multiply(long op1, double op2)
    
    Performs multiplication on two numeric values (long and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second double operand
    Returns:
    the result of multiplication
  - public static double multiply(float op1, byte op2)
    
    Performs multiplication on two numeric values (float and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second byte operand
    Returns:
    the result of multiplication
  - public static double multiply(float op1, short op2)
    
    Performs multiplication on two numeric values (float and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second short operand
    Returns:
    the result of multiplication
  - public static double multiply(float op1, int op2)
    
    Performs multiplication on two numeric values (float and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second int operand
    Returns:
    the result of multiplication
  - public static double multiply(float op1, long op2)
    
    Performs multiplication on two numeric values (float and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second long operand
    Returns:
    the result of multiplication
  - public static double multiply(float op1, float op2)
    
    Performs multiplication on two numeric values (float and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second float operand
    Returns:
    the result of multiplication
  - public static double multiply(float op1, double op2)
    
    Performs multiplication on two numeric values (float and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second double operand
    Returns:
    the result of multiplication
  - public static double multiply(double op1, byte op2)
    
    Performs multiplication on two numeric values (double and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second byte operand
    Returns:
    the result of multiplication
  - public static double multiply(double op1, short op2)
    
    Performs multiplication on two numeric values (double and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second short operand
    Returns:
    the result of multiplication
  - public static double multiply(double op1, int op2)
    
    Performs multiplication on two numeric values (double and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second int operand
    Returns:
    the result of multiplication
  - public static double multiply(double op1, long op2)
    
    Performs multiplication on two numeric values (double and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second long operand
    Returns:
    the result of multiplication
  - public static double multiply(double op1, float op2)
    
    Performs multiplication on two numeric values (double and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second float operand
    Returns:
    the result of multiplication
  - public static double multiply(double op1, double op2)
    
    Performs multiplication on two numeric values (double and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second double operand
    Returns:
    the result of multiplication
  - public static int or(byte op1, byte op2)
    
    Performs bitwise OR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise OR
  - public static int or(byte op1, short op2)
    
    Performs bitwise OR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise OR
  - public static int or(byte op1, int op2)
    
    Performs bitwise OR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise OR
  - public static long or(byte op1, long op2)
    
    Performs bitwise OR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise OR
  - public static int or(short op1, byte op2)
    
    Performs bitwise OR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise OR
  - public static int or(short op1, short op2)
    
    Performs bitwise OR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise OR
  - public static int or(short op1, int op2)
    
    Performs bitwise OR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise OR
  - public static long or(short op1, long op2)
    
    Performs bitwise OR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise OR
  - public static int or(int op1, byte op2)
    
    Performs bitwise OR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise OR
  - public static int or(int op1, short op2)
    
    Performs bitwise OR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise OR
  - public static int or(int op1, int op2)
    
    Performs bitwise OR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise OR
  - public static long or(int op1, long op2)
    
    Performs bitwise OR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise OR
  - public static long or(long op1, byte op2)
    
    Performs bitwise OR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise OR
  - public static long or(long op1, short op2)
    
    Performs bitwise OR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise OR
  - public static long or(long op1, int op2)
    
    Performs bitwise OR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise OR
  - public static long or(long op1, long op2)
    
    Performs bitwise OR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise OR
  - public static int plus(byte op1, byte op2)
    
    Performs addition on two numeric values (byte and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second byte operand
    Returns:
    the result of addition
  - public static int plus(byte op1, short op2)
    
    Performs addition on two numeric values (byte and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second short operand
    Returns:
    the result of addition
  - public static int plus(byte op1, int op2)
    
    Performs addition on two numeric values (byte and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second int operand
    Returns:
    the result of addition
  - public static long plus(byte op1, long op2)
    
    Performs addition on two numeric values (byte and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second long operand
    Returns:
    the result of addition
  - public static double plus(byte op1, float op2)
    
    Performs addition on two numeric values (byte and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second float operand
    Returns:
    the result of addition
  - public static double plus(byte op1, double op2)
    
    Performs addition on two numeric values (byte and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second double operand
    Returns:
    the result of addition
  - public static int plus(short op1, byte op2)
    
    Performs addition on two numeric values (short and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second byte operand
    Returns:
    the result of addition
  - public static int plus(short op1, short op2)
    
    Performs addition on two numeric values (short and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second short operand
    Returns:
    the result of addition
  - public static int plus(short op1, int op2)
    
    Performs addition on two numeric values (short and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second int operand
    Returns:
    the result of addition
  - public static long plus(short op1, long op2)
    
    Performs addition on two numeric values (short and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second long operand
    Returns:
    the result of addition
  - public static double plus(short op1, float op2)
    
    Performs addition on two numeric values (short and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second float operand
    Returns:
    the result of addition
  - public static double plus(short op1, double op2)
    
    Performs addition on two numeric values (short and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second double operand
    Returns:
    the result of addition
  - public static int plus(int op1, byte op2)
    
    Performs addition on two numeric values (int and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second byte operand
    Returns:
    the result of addition
  - public static int plus(int op1, short op2)
    
    Performs addition on two numeric values (int and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second short operand
    Returns:
    the result of addition
  - public static int plus(int op1, int op2)
    
    Performs addition on two numeric values (int and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second int operand
    Returns:
    the result of addition
  - public static long plus(int op1, long op2)
    
    Performs addition on two numeric values (int and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second long operand
    Returns:
    the result of addition
  - public static double plus(int op1, float op2)
    
    Performs addition on two numeric values (int and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second float operand
    Returns:
    the result of addition
  - public static double plus(int op1, double op2)
    
    Performs addition on two numeric values (int and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second double operand
    Returns:
    the result of addition
  - public static long plus(long op1, byte op2)
    
    Performs addition on two numeric values (long and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second byte operand
    Returns:
    the result of addition
  - public static long plus(long op1, short op2)
    
    Performs addition on two numeric values (long and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second short operand
    Returns:
    the result of addition
  - public static long plus(long op1, int op2)
    
    Performs addition on two numeric values (long and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second int operand
    Returns:
    the result of addition
  - public static long plus(long op1, long op2)
    
    Performs addition on two numeric values (long and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second long operand
    Returns:
    the result of addition
  - public static double plus(long op1, float op2)
    
    Performs addition on two numeric values (long and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second float operand
    Returns:
    the result of addition
  - public static double plus(long op1, double op2)
    
    Performs addition on two numeric values (long and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second double operand
    Returns:
    the result of addition
  - public static double plus(float op1, byte op2)
    
    Performs addition on two numeric values (float and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second byte operand
    Returns:
    the result of addition
  - public static double plus(float op1, short op2)
    
    Performs addition on two numeric values (float and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second short operand
    Returns:
    the result of addition
  - public static double plus(float op1, int op2)
    
    Performs addition on two numeric values (float and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second int operand
    Returns:
    the result of addition
  - public static double plus(float op1, long op2)
    
    Performs addition on two numeric values (float and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second long operand
    Returns:
    the result of addition
  - public static double plus(float op1, float op2)
    
    Performs addition on two numeric values (float and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second float operand
    Returns:
    the result of addition
  - public static double plus(float op1, double op2)
    
    Performs addition on two numeric values (float and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first float operand
    op2 - the second double operand
    Returns:
    the result of addition
  - public static double plus(double op1, byte op2)
    
    Performs addition on two numeric values (double and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second byte operand
    Returns:
    the result of addition
  - public static double plus(double op1, short op2)
    
    Performs addition on two numeric values (double and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second short operand
    Returns:
    the result of addition
  - public static double plus(double op1, int op2)
    
    Performs addition on two numeric values (double and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second int operand
    Returns:
    the result of addition
  - public static double plus(double op1, long op2)
    
    Performs addition on two numeric values (double and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second long operand
    Returns:
    the result of addition
  - public static double plus(double op1, float op2)
    
    Performs addition on two numeric values (double and float).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second float operand
    Returns:
    the result of addition
  - public static double plus(double op1, double op2)
    
    Performs addition on two numeric values (double and double).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first double operand
    op2 - the second double operand
    Returns:
    the result of addition
  - public static int remainder(byte op1, byte op2)
    
    Performs remainder on two numeric values (byte and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second byte operand
    Returns:
    the result of remainder
  - public static int remainder(byte op1, short op2)
    
    Performs remainder on two numeric values (byte and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second short operand
    Returns:
    the result of remainder
  - public static int remainder(byte op1, int op2)
    
    Performs remainder on two numeric values (byte and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second int operand
    Returns:
    the result of remainder
  - public static long remainder(byte op1, long op2)
    
    Performs remainder on two numeric values (byte and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first byte operand
    op2 - the second long operand
    Returns:
    the result of remainder
  - public static int remainder(short op1, byte op2)
    
    Performs remainder on two numeric values (short and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second byte operand
    Returns:
    the result of remainder
  - public static int remainder(short op1, short op2)
    
    Performs remainder on two numeric values (short and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second short operand
    Returns:
    the result of remainder
  - public static int remainder(short op1, int op2)
    
    Performs remainder on two numeric values (short and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second int operand
    Returns:
    the result of remainder
  - public static long remainder(short op1, long op2)
    
    Performs remainder on two numeric values (short and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first short operand
    op2 - the second long operand
    Returns:
    the result of remainder
  - public static int remainder(int op1, byte op2)
    
    Performs remainder on two numeric values (int and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second byte operand
    Returns:
    the result of remainder
  - public static int remainder(int op1, short op2)
    
    Performs remainder on two numeric values (int and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second short operand
    Returns:
    the result of remainder
  - public static int remainder(int op1, int op2)
    
    Performs remainder on two numeric values (int and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second int operand
    Returns:
    the result of remainder
  - public static long remainder(int op1, long op2)
    
    Performs remainder on two numeric values (int and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first int operand
    op2 - the second long operand
    Returns:
    the result of remainder
  - public static long remainder(long op1, byte op2)
    
    Performs remainder on two numeric values (long and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second byte operand
    Returns:
    the result of remainder
  - public static long remainder(long op1, short op2)
    
    Performs remainder on two numeric values (long and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second short operand
    Returns:
    the result of remainder
  - public static long remainder(long op1, int op2)
    
    Performs remainder on two numeric values (long and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second int operand
    Returns:
    the result of remainder
  - public static long remainder(long op1, long op2)
    
    Performs remainder on two numeric values (long and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first long operand
    op2 - the second long operand
    Returns:
    the result of remainder
  - public static int rightShift(byte op1, byte op2)
    
    Performs right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of right shift
  - public static int rightShift(byte op1, short op2)
    
    Performs right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of right shift
  - public static int rightShift(byte op1, int op2)
    
    Performs right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of right shift
  - public static long rightShift(byte op1, long op2)
    
    Performs right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of right shift
  - public static int rightShift(short op1, byte op2)
    
    Performs right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of right shift
  - public static int rightShift(short op1, short op2)
    
    Performs right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of right shift
  - public static int rightShift(short op1, int op2)
    
    Performs right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of right shift
  - public static long rightShift(short op1, long op2)
    
    Performs right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of right shift
  - public static int rightShift(int op1, byte op2)
    
    Performs right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of right shift
  - public static int rightShift(int op1, short op2)
    
    Performs right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of right shift
  - public static int rightShift(int op1, int op2)
    
    Performs right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of right shift
  - public static long rightShift(int op1, long op2)
    
    Performs right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of right shift
  - public static long rightShift(long op1, byte op2)
    
    Performs right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of right shift
  - public static long rightShift(long op1, short op2)
    
    Performs right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of right shift
  - public static long rightShift(long op1, int op2)
    
    Performs right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of right shift
  - public static long rightShift(long op1, long op2)
    
    Performs right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of right shift
  - public static int rightShiftUnsigned(byte op1, byte op2)
    
    Performs unsigned right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(byte op1, short op2)
    
    Performs unsigned right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(byte op1, int op2)
    
    Performs unsigned right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(byte op1, long op2)
    
    Performs unsigned right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(short op1, byte op2)
    
    Performs unsigned right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(short op1, short op2)
    
    Performs unsigned right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(short op1, int op2)
    
    Performs unsigned right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(short op1, long op2)
    
    Performs unsigned right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(int op1, byte op2)
    
    Performs unsigned right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(int op1, short op2)
    
    Performs unsigned right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of unsigned right shift
  - public static int rightShiftUnsigned(int op1, int op2)
    
    Performs unsigned right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(int op1, long op2)
    
    Performs unsigned right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(long op1, byte op2)
    
    Performs unsigned right shift on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(long op1, short op2)
    
    Performs unsigned right shift on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(long op1, int op2)
    
    Performs unsigned right shift on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of unsigned right shift
  - public static long rightShiftUnsigned(long op1, long op2)
    
    Performs unsigned right shift on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of unsigned right shift
  - public static int xor(byte op1, byte op2)
    
    Performs bitwise XOR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise XOR
  - public static int xor(byte op1, short op2)
    
    Performs bitwise XOR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise XOR
  - public static int xor(byte op1, int op2)
    
    Performs bitwise XOR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise XOR
  - public static long xor(byte op1, long op2)
    
    Performs bitwise XOR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise XOR
  - public static int xor(short op1, byte op2)
    
    Performs bitwise XOR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise XOR
  - public static int xor(short op1, short op2)
    
    Performs bitwise XOR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise XOR
  - public static int xor(short op1, int op2)
    
    Performs bitwise XOR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise XOR
  - public static long xor(short op1, long op2)
    
    Performs bitwise XOR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise XOR
  - public static int xor(int op1, byte op2)
    
    Performs bitwise XOR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise XOR
  - public static int xor(int op1, short op2)
    
    Performs bitwise XOR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise XOR
  - public static int xor(int op1, int op2)
    
    Performs bitwise XOR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise XOR
  - public static long xor(int op1, long op2)
    
    Performs bitwise XOR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise XOR
  - public static long xor(long op1, byte op2)
    
    Performs bitwise XOR on two numeric values (op1 and byte).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second byte operand
    Returns:
    the result of bitwise XOR
  - public static long xor(long op1, short op2)
    
    Performs bitwise XOR on two numeric values (op1 and short).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second short operand
    Returns:
    the result of bitwise XOR
  - public static long xor(long op1, int op2)
    
    Performs bitwise XOR on two numeric values (op1 and int).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second int operand
    Returns:
    the result of bitwise XOR
  - public static long xor(long op1, long op2)
    
    Performs bitwise XOR on two numeric values (op1 and long).
    Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.
    Parameters:
    op1 - the first op1 operand
    op2 - the second long operand
    Returns:
    the result of bitwise XOR

Summary:
Field
Method

| Detail:
Field
Method

[Java] Class NumberMathModificationInfo

Field Summary

Methods Summary

Inherited Methods Summary

Field Detail

public boolean byte_and

public boolean byte_div

public boolean byte_intdiv

public boolean byte_leftShift

public boolean byte_minus

public boolean byte_mod

public boolean byte_multiply

public boolean byte_or

public boolean byte_plus

public boolean byte_remainder

public boolean byte_rightShift

public boolean byte_rightShiftUnsigned

public boolean byte_xor

public boolean double_and

public boolean double_div

public boolean double_intdiv

public boolean double_leftShift

public boolean double_minus

public boolean double_mod

public boolean double_multiply

public boolean double_or

public boolean double_plus

public boolean double_remainder

public boolean double_rightShift

public boolean double_rightShiftUnsigned

public boolean double_xor

public boolean float_and

public boolean float_div

public boolean float_intdiv

public boolean float_leftShift

public boolean float_minus

public boolean float_mod

public boolean float_multiply

public boolean float_or

public boolean float_plus

public boolean float_remainder

public boolean float_rightShift

public boolean float_rightShiftUnsigned

public boolean float_xor

public static final NumberMathModificationInfo instance

public boolean int_and

public boolean int_div

public boolean int_intdiv

public boolean int_leftShift

public boolean int_minus

public boolean int_mod

public boolean int_multiply

public boolean int_or

public boolean int_plus

public boolean int_remainder

public boolean int_rightShift

public boolean int_rightShiftUnsigned

public boolean int_xor

public boolean long_and

public boolean long_div

public boolean long_intdiv

public boolean long_leftShift

public boolean long_minus

public boolean long_mod

public boolean long_multiply

public boolean long_or

public boolean long_plus

public boolean long_remainder

public boolean long_rightShift

public boolean long_rightShiftUnsigned

public boolean long_xor

public boolean short_and

public boolean short_div

public boolean short_intdiv

public boolean short_leftShift

public boolean short_minus

public boolean short_mod

public boolean short_multiply

public boolean short_or

public boolean short_plus