Package org.codehaus.groovy.runtime.typehandling

# Class NumberMathModificationInfo

java.lang.Object
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
  Modifier and Type
  Field
  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 final 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.

- ## Method Summary

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

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### instance

    public static final NumberMathModificationInfo instance
    Singleton instance of NumberMathModificationInfo.

  - ### byte_plus

    public boolean byte_plus
    Flags indicating whether the plus (+) operation has been modified for each numeric type.

  - ### short_plus

    public boolean short_plus
    Flags indicating whether the plus (+) operation has been modified for Short type.

  - ### int_plus

    public boolean int_plus
    Flags indicating whether the plus (+) operation has been modified for Integer type.

  - ### long_plus

    public boolean long_plus
    Flags indicating whether the plus (+) operation has been modified for Long type.

  - ### float_plus

    public boolean float_plus
    Flags indicating whether the plus (+) operation has been modified for Float type.

  - ### double_plus

    public boolean double_plus
    Flags indicating whether the plus (+) operation has been modified for Double type.

  - ### byte_minus

    public boolean byte_minus
    Flags indicating whether the minus (-) operation has been modified for Byte type.

  - ### short_minus

    public boolean short_minus
    Flags indicating whether the minus (-) operation has been modified for Short type.

  - ### int_minus

    public boolean int_minus
    Flags indicating whether the minus (-) operation has been modified for Integer type.

  - ### long_minus

    public boolean long_minus
    Flags indicating whether the minus (-) operation has been modified for Long type.

  - ### float_minus

    public boolean float_minus
    Flags indicating whether the minus (-) operation has been modified for Float type.

  - ### double_minus

    public boolean double_minus
    Flags indicating whether the minus (-) operation has been modified for Double type.

  - ### byte_multiply

    public boolean byte_multiply
    Flags indicating whether the multiply (*) operation has been modified for Byte type.

  - ### short_multiply

    public boolean short_multiply
    Flags indicating whether the multiply (*) operation has been modified for Short type.

  - ### int_multiply

    public boolean int_multiply
    Flags indicating whether the multiply (*) operation has been modified for Integer type.

  - ### long_multiply

    public boolean long_multiply
    Flags indicating whether the multiply (*) operation has been modified for Long type.

  - ### float_multiply

    public boolean float_multiply
    Flags indicating whether the multiply (*) operation has been modified for Float type.

  - ### double_multiply

    public boolean double_multiply
    Flags indicating whether the multiply (*) operation has been modified for Double type.

  - ### byte_div

    public boolean byte_div
    Flags indicating whether the divide (/) operation has been modified for Byte type.

  - ### short_div

    public boolean short_div
    Flags indicating whether the divide (/) operation has been modified for Short type.

  - ### int_div

    public boolean int_div
    Flags indicating whether the divide (/) operation has been modified for Integer type.

  - ### long_div

    public boolean long_div
    Flags indicating whether the divide (/) operation has been modified for Long type.

  - ### float_div

    public boolean float_div
    Flags indicating whether the divide (/) operation has been modified for Float type.

  - ### double_div

    public boolean double_div
    Flags indicating whether the divide (/) operation has been modified for Double type.

  - ### byte_or

    public boolean byte_or
    Flags indicating whether the bitwise OR (|) operation has been modified for Byte type.

  - ### short_or

    public boolean short_or
    Flags indicating whether the bitwise OR (|) operation has been modified for Short type.

  - ### int_or

    public boolean int_or
    Flags indicating whether the bitwise OR (|) operation has been modified for Integer type.

  - ### long_or

    public boolean long_or
    Flags indicating whether the bitwise OR (|) operation has been modified for Long type.

  - ### float_or

    public boolean float_or
    Flags indicating whether the bitwise OR (|) operation has been modified for Float type.

  - ### double_or

    public boolean double_or
    Flags indicating whether the bitwise OR (|) operation has been modified for Double type.

  - ### byte_and

    public boolean byte_and
    Flags indicating whether the bitwise AND (&) operation has been modified for Byte type.

  - ### short_and

    public boolean short_and
    Flags indicating whether the bitwise AND (&) operation has been modified for Short type.

  - ### int_and

    public boolean int_and
    Flags indicating whether the bitwise AND (&) operation has been modified for Integer type.

  - ### long_and

    public boolean long_and
    Flags indicating whether the bitwise AND (&) operation has been modified for Long type.

  - ### float_and

    public boolean float_and
    Flags indicating whether the bitwise AND (&) operation has been modified for Float type.

  - ### double_and

    public boolean double_and
    Flags indicating whether the bitwise AND (&) operation has been modified for Double type.

  - ### byte_xor

    public boolean byte_xor
    Flags indicating whether the bitwise XOR (^) operation has been modified for Byte type.

  - ### short_xor

    public boolean short_xor
    Flags indicating whether the bitwise XOR (^) operation has been modified for Short type.

  - ### int_xor

    public boolean int_xor
    Flags indicating whether the bitwise XOR (^) operation has been modified for Integer type.

  - ### long_xor

    public boolean long_xor
    Flags indicating whether the bitwise XOR (^) operation has been modified for Long type.

  - ### float_xor

    public boolean float_xor
    Flags indicating whether the bitwise XOR (^) operation has been modified for Float type.

  - ### double_xor

    public boolean double_xor
    Flags indicating whether the bitwise XOR (^) operation has been modified for Double type.

  - ### byte_intdiv

    public boolean byte_intdiv
    Flags indicating whether the integer division (//) operation has been modified for Byte type.

  - ### short_intdiv

    public boolean short_intdiv
    Flags indicating whether the integer division (//) operation has been modified for Short type.

  - ### int_intdiv

    public boolean int_intdiv
    Flags indicating whether the integer division (//) operation has been modified for Integer type.

  - ### long_intdiv

    public boolean long_intdiv
    Flags indicating whether the integer division (//) operation has been modified for Long type.

  - ### float_intdiv

    public boolean float_intdiv
    Flags indicating whether the integer division (//) operation has been modified for Float type.

  - ### double_intdiv

    public boolean double_intdiv
    Flags indicating whether the integer division (//) operation has been modified for Double type.

  - ### byte_mod

    public boolean byte_mod
    Flags indicating whether the modulo (%) operation has been modified for Byte type.

  - ### short_mod

    public boolean short_mod
    Flags indicating whether the modulo (%) operation has been modified for Short type.

  - ### int_mod

    public boolean int_mod
    Flags indicating whether the modulo (%) operation has been modified for Integer type.

  - ### long_mod

    public boolean long_mod
    Flags indicating whether the modulo (%) operation has been modified for Long type.

  - ### float_mod

    public boolean float_mod
    Flags indicating whether the modulo (%) operation has been modified for Float type.

  - ### double_mod

    public boolean double_mod
    Flags indicating whether the modulo (%) operation has been modified for Double type.

  - ### byte_remainder

    public boolean byte_remainder
    Flags indicating whether the remainder operation has been modified for Byte type.

  - ### short_remainder

    public boolean short_remainder
    Flags indicating whether the remainder operation has been modified for Short type.

  - ### int_remainder

    public boolean int_remainder
    Flags indicating whether the remainder operation has been modified for Integer type.

  - ### long_remainder

    public boolean long_remainder
    Flags indicating whether the remainder operation has been modified for Long type.

  - ### float_remainder

    public boolean float_remainder
    Flags indicating whether the remainder operation has been modified for Float type.

  - ### double_remainder

    public boolean double_remainder
    Flags indicating whether the remainder operation has been modified for Double type.

  - ### byte_leftShift

    public boolean byte_leftShift
    Flags indicating whether the left shift (<<) operation has been modified for Byte type.

  - ### short_leftShift

    public boolean short_leftShift
    Flags indicating whether the left shift (<<) operation has been modified for Short type.

  - ### int_leftShift

    public boolean int_leftShift
    Flags indicating whether the left shift (<<) operation has been modified for Integer type.

  - ### long_leftShift

    public boolean long_leftShift
    Flags indicating whether the left shift (<<) operation has been modified for Long type.

  - ### float_leftShift

    public boolean float_leftShift
    Flags indicating whether the left shift (<<) operation has been modified for Float type.

  - ### double_leftShift

    public boolean double_leftShift
    Flags indicating whether the left shift (<<) operation has been modified for Double type.

  - ### byte_rightShift

    public boolean byte_rightShift
    Flags indicating whether the right shift (>>) operation has been modified for Byte type.

  - ### short_rightShift

    public boolean short_rightShift
    Flags indicating whether the right shift (>>) operation has been modified for Short type.

  - ### int_rightShift

    public boolean int_rightShift
    Flags indicating whether the right shift (>>) operation has been modified for Integer type.

  - ### long_rightShift

    public boolean long_rightShift
    Flags indicating whether the right shift (>>) operation has been modified for Long type.

  - ### float_rightShift

    public boolean float_rightShift
    Flags indicating whether the right shift (>>) operation has been modified for Float type.

  - ### double_rightShift

    public boolean double_rightShift
    Flags indicating whether the right shift (>>) operation has been modified for Double type.

  - ### byte_rightShiftUnsigned

    public boolean byte_rightShiftUnsigned
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Byte type.

  - ### short_rightShiftUnsigned

    public boolean short_rightShiftUnsigned
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Short type.

  - ### int_rightShiftUnsigned

    public boolean int_rightShiftUnsigned
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Integer type.

  - ### long_rightShiftUnsigned

    public boolean long_rightShiftUnsigned
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Long type.

  - ### float_rightShiftUnsigned

    public boolean float_rightShiftUnsigned
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Float type.

  - ### double_rightShiftUnsigned

    public boolean double_rightShiftUnsigned
    Flags indicating whether the unsigned right shift (>>>) operation has been modified for Double type.

- ## Method Details

  - ### checkIfStdMethod

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### plus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### minus

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### multiply

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### div

    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

  - ### or

    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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### and

    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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### xor

    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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### intdiv

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### mod

    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

  - ### remainder

    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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### 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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### leftShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShift

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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

  - ### rightShiftUnsigned

    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