Package: org.codehaus.groovy.runtime.typehandling

## [Java] Class NumberMathModificationInfo

- org.codehaus.groovy.runtime.typehandling.NumberMathModificationInfo

-     public class NumberMathModificationInfo
      extends Object

  Tracks modifications to arithmetic operations on numeric types.

  This class monitors which arithmetic operations have been modified for each numeric type (Byte, Short, Integer, Long, Float, Double). It maintains a set of standard operation names and provides a singleton instance for global tracking.

  Used internally by the Groovy compiler/runtime to detect when standard numeric operations have been overridden or modified, which may require special handling in code generation.

- - ### Field Summary

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

  - ### Methods Summary

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

  - ### Inherited Methods Summary

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

- - ### Field Detail

    - #### public boolean byte_and

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

    - #### public boolean byte_div

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

    - #### public boolean byte_intdiv

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

    - #### public boolean byte_leftShift

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

    - #### public boolean byte_minus

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

    - #### public boolean byte_mod

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

    - #### public boolean byte_multiply

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

    - #### public boolean byte_or

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

    - #### public boolean byte_plus

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

    - #### public boolean byte_remainder

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

    - #### public boolean byte_rightShift

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

    - #### public boolean byte_rightShiftUnsigned

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

    - #### public boolean byte_xor

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

    - #### public boolean double_and

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

    - #### public boolean double_div

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

    - #### public boolean double_intdiv

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

    - #### public boolean double_leftShift

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

    - #### public boolean double_minus

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

    - #### public boolean double_mod

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

    - #### public boolean double_multiply

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

    - #### public boolean double_or

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

    - #### public boolean double_plus

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

    - #### public boolean double_remainder

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

    - #### public boolean double_rightShift

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

    - #### public boolean double_rightShiftUnsigned

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

    - #### public boolean double_xor

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

    - #### public boolean float_and

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

    - #### public boolean float_div

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

    - #### public boolean float_intdiv

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

    - #### public boolean float_leftShift

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

    - #### public boolean float_minus

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

    - #### public boolean float_mod

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

    - #### public boolean float_multiply

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

    - #### public boolean float_or

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

    - #### public boolean float_plus

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

    - #### public boolean float_remainder

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

    - #### public boolean float_rightShift

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

    - #### public boolean float_rightShiftUnsigned

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

    - #### public boolean float_xor

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

    - #### public static final NumberMathModificationInfo instance

      Singleton instance of NumberMathModificationInfo.

    - #### public boolean int_and

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

    - #### public boolean int_div

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

    - #### public boolean int_intdiv

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

    - #### public boolean int_leftShift

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

    - #### public boolean int_minus

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

    - #### public boolean int_mod

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

    - #### public boolean int_multiply

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

    - #### public boolean int_or

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

    - #### public boolean int_plus

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

    - #### public boolean int_remainder

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

    - #### public boolean int_rightShift

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

    - #### public boolean int_rightShiftUnsigned

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

    - #### public boolean int_xor

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

    - #### public boolean long_and

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

    - #### public boolean long_div

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

    - #### public boolean long_intdiv

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

    - #### public boolean long_leftShift

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

    - #### public boolean long_minus

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

    - #### public boolean long_mod

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

    - #### public boolean long_multiply

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

    - #### public boolean long_or

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

    - #### public boolean long_plus

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

    - #### public boolean long_remainder

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

    - #### public boolean long_rightShift

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

    - #### public boolean long_rightShiftUnsigned

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

    - #### public boolean long_xor

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

    - #### public boolean short_and

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

    - #### public boolean short_div

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

    - #### public boolean short_intdiv

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

    - #### public boolean short_leftShift

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

    - #### public boolean short_minus

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

    - #### public boolean short_mod

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

    - #### public boolean short_multiply

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

    - #### public boolean short_or

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

    - #### public boolean short_plus

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

    - #### public boolean short_remainder

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

    - #### public boolean short_rightShift

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

    - #### public boolean short_rightShiftUnsigned

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

    - #### public boolean short_xor

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

  - ### Method Detail

    - #### public static int and(byte op1, byte op2)

      Performs bitwise AND on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise AND

    - #### public static int and(byte op1, short op2)

      Performs bitwise AND on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise AND

    - #### public static int and(byte op1, int op2)

      Performs bitwise AND on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise AND

    - #### public static long and(byte op1, long op2)

      Performs bitwise AND on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise AND

    - #### public static int and(short op1, byte op2)

      Performs bitwise AND on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise AND

    - #### public static int and(short op1, short op2)

      Performs bitwise AND on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise AND

    - #### public static int and(short op1, int op2)

      Performs bitwise AND on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise AND

    - #### public static long and(short op1, long op2)

      Performs bitwise AND on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise AND

    - #### public static int and(int op1, byte op2)

      Performs bitwise AND on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise AND

    - #### public static int and(int op1, short op2)

      Performs bitwise AND on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise AND

    - #### public static int and(int op1, int op2)

      Performs bitwise AND on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise AND

    - #### public static long and(int op1, long op2)

      Performs bitwise AND on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise AND

    - #### public static long and(long op1, byte op2)

      Performs bitwise AND on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise AND

    - #### public static long and(long op1, short op2)

      Performs bitwise AND on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise AND

    - #### public static long and(long op1, int op2)

      Performs bitwise AND on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise AND

    - #### public static long and(long op1, long op2)

      Performs bitwise AND on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise AND

    - #### public void checkIfStdMethod(MetaMethod method)

      Checks whether a method represents a modification to a standard numeric operation.

      Examines the method's declaring class, name, and parameter types to determine if it overrides a standard numeric operation.

      Parameters:
        `method` - the method to check

    - #### public static int div(byte op1, byte op2)

      Performs division on two numeric values (byte and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second byte operand
      Returns:
        the result of division

    - #### public static int div(byte op1, short op2)

      Performs division on two numeric values (byte and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second short operand
      Returns:
        the result of division

    - #### public static int div(byte op1, int op2)

      Performs division on two numeric values (byte and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second int operand
      Returns:
        the result of division

    - #### public static long div(byte op1, long op2)

      Performs division on two numeric values (byte and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second long operand
      Returns:
        the result of division

    - #### public static double div(byte op1, float op2)

      Performs division on two numeric values (byte and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second float operand
      Returns:
        the result of division

    - #### public static double div(byte op1, double op2)

      Performs division on two numeric values (byte and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second double operand
      Returns:
        the result of division

    - #### public static int div(short op1, byte op2)

      Performs division on two numeric values (short and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second byte operand
      Returns:
        the result of division

    - #### public static int div(short op1, short op2)

      Performs division on two numeric values (short and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second short operand
      Returns:
        the result of division

    - #### public static int div(short op1, int op2)

      Performs division on two numeric values (short and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second int operand
      Returns:
        the result of division

    - #### public static long div(short op1, long op2)

      Performs division on two numeric values (short and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second long operand
      Returns:
        the result of division

    - #### public static double div(short op1, float op2)

      Performs division on two numeric values (short and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second float operand
      Returns:
        the result of division

    - #### public static double div(short op1, double op2)

      Performs division on two numeric values (short and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second double operand
      Returns:
        the result of division

    - #### public static int div(int op1, byte op2)

      Performs division on two numeric values (int and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second byte operand
      Returns:
        the result of division

    - #### public static int div(int op1, short op2)

      Performs division on two numeric values (int and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second short operand
      Returns:
        the result of division

    - #### public static int div(int op1, int op2)

      Performs division on two numeric values (int and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second int operand
      Returns:
        the result of division

    - #### public static long div(int op1, long op2)

      Performs division on two numeric values (int and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second long operand
      Returns:
        the result of division

    - #### public static double div(int op1, float op2)

      Performs division on two numeric values (int and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second float operand
      Returns:
        the result of division

    - #### public static double div(int op1, double op2)

      Performs division on two numeric values (int and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second double operand
      Returns:
        the result of division

    - #### public static long div(long op1, byte op2)

      Performs division on two numeric values (long and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second byte operand
      Returns:
        the result of division

    - #### public static long div(long op1, short op2)

      Performs division on two numeric values (long and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second short operand
      Returns:
        the result of division

    - #### public static long div(long op1, int op2)

      Performs division on two numeric values (long and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second int operand
      Returns:
        the result of division

    - #### public static long div(long op1, long op2)

      Performs division on two numeric values (long and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second long operand
      Returns:
        the result of division

    - #### public static double div(long op1, float op2)

      Performs division on two numeric values (long and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second float operand
      Returns:
        the result of division

    - #### public static double div(long op1, double op2)

      Performs division on two numeric values (long and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second double operand
      Returns:
        the result of division

    - #### public static double div(float op1, byte op2)

      Performs division on two numeric values (float and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second byte operand
      Returns:
        the result of division

    - #### public static double div(float op1, short op2)

      Performs division on two numeric values (float and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second short operand
      Returns:
        the result of division

    - #### public static double div(float op1, int op2)

      Performs division on two numeric values (float and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second int operand
      Returns:
        the result of division

    - #### public static double div(float op1, long op2)

      Performs division on two numeric values (float and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second long operand
      Returns:
        the result of division

    - #### public static double div(float op1, float op2)

      Performs division on two numeric values (float and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second float operand
      Returns:
        the result of division

    - #### public static double div(float op1, double op2)

      Performs division on two numeric values (float and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second double operand
      Returns:
        the result of division

    - #### public static double div(double op1, byte op2)

      Performs division on two numeric values (double and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second byte operand
      Returns:
        the result of division

    - #### public static double div(double op1, short op2)

      Performs division on two numeric values (double and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second short operand
      Returns:
        the result of division

    - #### public static double div(double op1, int op2)

      Performs division on two numeric values (double and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second int operand
      Returns:
        the result of division

    - #### public static double div(double op1, long op2)

      Performs division on two numeric values (double and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second long operand
      Returns:
        the result of division

    - #### public static double div(double op1, float op2)

      Performs division on two numeric values (double and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second float operand
      Returns:
        the result of division

    - #### public static double div(double op1, double op2)

      Performs division on two numeric values (double and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second double operand
      Returns:
        the result of division

    - #### public static int intdiv(byte op1, byte op2)

      Performs integer division on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of integer division

    - #### public static int intdiv(byte op1, short op2)

      Performs integer division on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of integer division

    - #### public static int intdiv(byte op1, int op2)

      Performs integer division on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of integer division

    - #### public static long intdiv(byte op1, long op2)

      Performs integer division on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of integer division

    - #### public static int intdiv(short op1, byte op2)

      Performs integer division on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of integer division

    - #### public static int intdiv(short op1, short op2)

      Performs integer division on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of integer division

    - #### public static int intdiv(short op1, int op2)

      Performs integer division on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of integer division

    - #### public static long intdiv(short op1, long op2)

      Performs integer division on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of integer division

    - #### public static int intdiv(int op1, byte op2)

      Performs integer division on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of integer division

    - #### public static int intdiv(int op1, short op2)

      Performs integer division on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of integer division

    - #### public static int intdiv(int op1, int op2)

      Performs integer division on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of integer division

    - #### public static long intdiv(int op1, long op2)

      Performs integer division on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of integer division

    - #### public static long intdiv(long op1, byte op2)

      Performs integer division on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of integer division

    - #### public static long intdiv(long op1, short op2)

      Performs integer division on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of integer division

    - #### public static long intdiv(long op1, int op2)

      Performs integer division on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of integer division

    - #### public static long intdiv(long op1, long op2)

      Performs integer division on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of integer division

    - #### public static int leftShift(byte op1, byte op2)

      Performs left shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of left shift

    - #### public static int leftShift(byte op1, short op2)

      Performs left shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of left shift

    - #### public static int leftShift(byte op1, int op2)

      Performs left shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of left shift

    - #### public static long leftShift(byte op1, long op2)

      Performs left shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of left shift

    - #### public static int leftShift(short op1, byte op2)

      Performs left shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of left shift

    - #### public static int leftShift(short op1, short op2)

      Performs left shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of left shift

    - #### public static int leftShift(short op1, int op2)

      Performs left shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of left shift

    - #### public static long leftShift(short op1, long op2)

      Performs left shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of left shift

    - #### public static int leftShift(int op1, byte op2)

      Performs left shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of left shift

    - #### public static int leftShift(int op1, short op2)

      Performs left shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of left shift

    - #### public static int leftShift(int op1, int op2)

      Performs left shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of left shift

    - #### public static long leftShift(int op1, long op2)

      Performs left shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of left shift

    - #### public static long leftShift(long op1, byte op2)

      Performs left shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of left shift

    - #### public static long leftShift(long op1, short op2)

      Performs left shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of left shift

    - #### public static long leftShift(long op1, int op2)

      Performs left shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of left shift

    - #### public static long leftShift(long op1, long op2)

      Performs left shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of left shift

    - #### public static int minus(byte op1, byte op2)

      Performs subtraction on two numeric values (byte and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second byte operand
      Returns:
        the result of subtraction

    - #### public static int minus(byte op1, short op2)

      Performs subtraction on two numeric values (byte and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second short operand
      Returns:
        the result of subtraction

    - #### public static int minus(byte op1, int op2)

      Performs subtraction on two numeric values (byte and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second int operand
      Returns:
        the result of subtraction

    - #### public static long minus(byte op1, long op2)

      Performs subtraction on two numeric values (byte and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second long operand
      Returns:
        the result of subtraction

    - #### public static double minus(byte op1, float op2)

      Performs subtraction on two numeric values (byte and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second float operand
      Returns:
        the result of subtraction

    - #### public static double minus(byte op1, double op2)

      Performs subtraction on two numeric values (byte and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second double operand
      Returns:
        the result of subtraction

    - #### public static int minus(short op1, byte op2)

      Performs subtraction on two numeric values (short and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second byte operand
      Returns:
        the result of subtraction

    - #### public static int minus(short op1, short op2)

      Performs subtraction on two numeric values (short and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second short operand
      Returns:
        the result of subtraction

    - #### public static int minus(short op1, int op2)

      Performs subtraction on two numeric values (short and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second int operand
      Returns:
        the result of subtraction

    - #### public static long minus(short op1, long op2)

      Performs subtraction on two numeric values (short and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second long operand
      Returns:
        the result of subtraction

    - #### public static double minus(short op1, float op2)

      Performs subtraction on two numeric values (short and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second float operand
      Returns:
        the result of subtraction

    - #### public static double minus(short op1, double op2)

      Performs subtraction on two numeric values (short and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second double operand
      Returns:
        the result of subtraction

    - #### public static int minus(int op1, byte op2)

      Performs subtraction on two numeric values (int and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second byte operand
      Returns:
        the result of subtraction

    - #### public static int minus(int op1, short op2)

      Performs subtraction on two numeric values (int and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second short operand
      Returns:
        the result of subtraction

    - #### public static int minus(int op1, int op2)

      Performs subtraction on two numeric values (int and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second int operand
      Returns:
        the result of subtraction

    - #### public static long minus(int op1, long op2)

      Performs subtraction on two numeric values (int and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second long operand
      Returns:
        the result of subtraction

    - #### public static double minus(int op1, float op2)

      Performs subtraction on two numeric values (int and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second float operand
      Returns:
        the result of subtraction

    - #### public static double minus(int op1, double op2)

      Performs subtraction on two numeric values (int and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second double operand
      Returns:
        the result of subtraction

    - #### public static long minus(long op1, byte op2)

      Performs subtraction on two numeric values (long and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second byte operand
      Returns:
        the result of subtraction

    - #### public static long minus(long op1, short op2)

      Performs subtraction on two numeric values (long and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second short operand
      Returns:
        the result of subtraction

    - #### public static long minus(long op1, int op2)

      Performs subtraction on two numeric values (long and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second int operand
      Returns:
        the result of subtraction

    - #### public static long minus(long op1, long op2)

      Performs subtraction on two numeric values (long and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second long operand
      Returns:
        the result of subtraction

    - #### public static double minus(long op1, float op2)

      Performs subtraction on two numeric values (long and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second float operand
      Returns:
        the result of subtraction

    - #### public static double minus(long op1, double op2)

      Performs subtraction on two numeric values (long and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second double operand
      Returns:
        the result of subtraction

    - #### public static double minus(float op1, byte op2)

      Performs subtraction on two numeric values (float and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second byte operand
      Returns:
        the result of subtraction

    - #### public static double minus(float op1, short op2)

      Performs subtraction on two numeric values (float and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second short operand
      Returns:
        the result of subtraction

    - #### public static double minus(float op1, int op2)

      Performs subtraction on two numeric values (float and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second int operand
      Returns:
        the result of subtraction

    - #### public static double minus(float op1, long op2)

      Performs subtraction on two numeric values (float and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second long operand
      Returns:
        the result of subtraction

    - #### public static double minus(float op1, float op2)

      Performs subtraction on two numeric values (float and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second float operand
      Returns:
        the result of subtraction

    - #### public static double minus(float op1, double op2)

      Performs subtraction on two numeric values (float and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second double operand
      Returns:
        the result of subtraction

    - #### public static double minus(double op1, byte op2)

      Performs subtraction on two numeric values (double and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second byte operand
      Returns:
        the result of subtraction

    - #### public static double minus(double op1, short op2)

      Performs subtraction on two numeric values (double and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second short operand
      Returns:
        the result of subtraction

    - #### public static double minus(double op1, int op2)

      Performs subtraction on two numeric values (double and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second int operand
      Returns:
        the result of subtraction

    - #### public static double minus(double op1, long op2)

      Performs subtraction on two numeric values (double and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second long operand
      Returns:
        the result of subtraction

    - #### public static double minus(double op1, float op2)

      Performs subtraction on two numeric values (double and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second float operand
      Returns:
        the result of subtraction

    - #### public static double minus(double op1, double op2)

      Performs subtraction on two numeric values (double and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second double operand
      Returns:
        the result of subtraction

    - #### public static int mod(byte op1, byte op2)

      Performs modulo on two numeric values (byte and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second byte operand
      Returns:
        the result of modulo

    - #### public static int mod(byte op1, short op2)

      Performs modulo on two numeric values (byte and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second short operand
      Returns:
        the result of modulo

    - #### public static int mod(byte op1, int op2)

      Performs modulo on two numeric values (byte and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second int operand
      Returns:
        the result of modulo

    - #### public static long mod(byte op1, long op2)

      Performs modulo on two numeric values (byte and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second long operand
      Returns:
        the result of modulo

    - #### public static int mod(short op1, byte op2)

      Performs modulo on two numeric values (short and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second byte operand
      Returns:
        the result of modulo

    - #### public static int mod(short op1, short op2)

      Performs modulo on two numeric values (short and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second short operand
      Returns:
        the result of modulo

    - #### public static int mod(short op1, int op2)

      Performs modulo on two numeric values (short and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second int operand
      Returns:
        the result of modulo

    - #### public static long mod(short op1, long op2)

      Performs modulo on two numeric values (short and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second long operand
      Returns:
        the result of modulo

    - #### public static int mod(int op1, byte op2)

      Performs modulo on two numeric values (int and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second byte operand
      Returns:
        the result of modulo

    - #### public static int mod(int op1, short op2)

      Performs modulo on two numeric values (int and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second short operand
      Returns:
        the result of modulo

    - #### public static int mod(int op1, int op2)

      Performs modulo on two numeric values (int and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second int operand
      Returns:
        the result of modulo

    - #### public static long mod(int op1, long op2)

      Performs modulo on two numeric values (int and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second long operand
      Returns:
        the result of modulo

    - #### public static long mod(long op1, byte op2)

      Performs modulo on two numeric values (long and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second byte operand
      Returns:
        the result of modulo

    - #### public static long mod(long op1, short op2)

      Performs modulo on two numeric values (long and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second short operand
      Returns:
        the result of modulo

    - #### public static long mod(long op1, int op2)

      Performs modulo on two numeric values (long and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second int operand
      Returns:
        the result of modulo

    - #### public static long mod(long op1, long op2)

      Performs modulo on two numeric values (long and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second long operand
      Returns:
        the result of modulo

    - #### public static int multiply(byte op1, byte op2)

      Performs multiplication on two numeric values (byte and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second byte operand
      Returns:
        the result of multiplication

    - #### public static int multiply(byte op1, short op2)

      Performs multiplication on two numeric values (byte and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second short operand
      Returns:
        the result of multiplication

    - #### public static int multiply(byte op1, int op2)

      Performs multiplication on two numeric values (byte and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second int operand
      Returns:
        the result of multiplication

    - #### public static long multiply(byte op1, long op2)

      Performs multiplication on two numeric values (byte and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second long operand
      Returns:
        the result of multiplication

    - #### public static double multiply(byte op1, float op2)

      Performs multiplication on two numeric values (byte and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second float operand
      Returns:
        the result of multiplication

    - #### public static double multiply(byte op1, double op2)

      Performs multiplication on two numeric values (byte and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second double operand
      Returns:
        the result of multiplication

    - #### public static int multiply(short op1, byte op2)

      Performs multiplication on two numeric values (short and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second byte operand
      Returns:
        the result of multiplication

    - #### public static int multiply(short op1, short op2)

      Performs multiplication on two numeric values (short and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second short operand
      Returns:
        the result of multiplication

    - #### public static int multiply(short op1, int op2)

      Performs multiplication on two numeric values (short and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second int operand
      Returns:
        the result of multiplication

    - #### public static long multiply(short op1, long op2)

      Performs multiplication on two numeric values (short and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second long operand
      Returns:
        the result of multiplication

    - #### public static double multiply(short op1, float op2)

      Performs multiplication on two numeric values (short and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second float operand
      Returns:
        the result of multiplication

    - #### public static double multiply(short op1, double op2)

      Performs multiplication on two numeric values (short and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second double operand
      Returns:
        the result of multiplication

    - #### public static int multiply(int op1, byte op2)

      Performs multiplication on two numeric values (int and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second byte operand
      Returns:
        the result of multiplication

    - #### public static int multiply(int op1, short op2)

      Performs multiplication on two numeric values (int and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second short operand
      Returns:
        the result of multiplication

    - #### public static int multiply(int op1, int op2)

      Performs multiplication on two numeric values (int and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second int operand
      Returns:
        the result of multiplication

    - #### public static long multiply(int op1, long op2)

      Performs multiplication on two numeric values (int and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second long operand
      Returns:
        the result of multiplication

    - #### public static double multiply(int op1, float op2)

      Performs multiplication on two numeric values (int and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second float operand
      Returns:
        the result of multiplication

    - #### public static double multiply(int op1, double op2)

      Performs multiplication on two numeric values (int and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second double operand
      Returns:
        the result of multiplication

    - #### public static long multiply(long op1, byte op2)

      Performs multiplication on two numeric values (long and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second byte operand
      Returns:
        the result of multiplication

    - #### public static long multiply(long op1, short op2)

      Performs multiplication on two numeric values (long and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second short operand
      Returns:
        the result of multiplication

    - #### public static long multiply(long op1, int op2)

      Performs multiplication on two numeric values (long and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second int operand
      Returns:
        the result of multiplication

    - #### public static long multiply(long op1, long op2)

      Performs multiplication on two numeric values (long and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second long operand
      Returns:
        the result of multiplication

    - #### public static double multiply(long op1, float op2)

      Performs multiplication on two numeric values (long and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second float operand
      Returns:
        the result of multiplication

    - #### public static double multiply(long op1, double op2)

      Performs multiplication on two numeric values (long and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second double operand
      Returns:
        the result of multiplication

    - #### public static double multiply(float op1, byte op2)

      Performs multiplication on two numeric values (float and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second byte operand
      Returns:
        the result of multiplication

    - #### public static double multiply(float op1, short op2)

      Performs multiplication on two numeric values (float and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second short operand
      Returns:
        the result of multiplication

    - #### public static double multiply(float op1, int op2)

      Performs multiplication on two numeric values (float and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second int operand
      Returns:
        the result of multiplication

    - #### public static double multiply(float op1, long op2)

      Performs multiplication on two numeric values (float and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second long operand
      Returns:
        the result of multiplication

    - #### public static double multiply(float op1, float op2)

      Performs multiplication on two numeric values (float and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second float operand
      Returns:
        the result of multiplication

    - #### public static double multiply(float op1, double op2)

      Performs multiplication on two numeric values (float and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second double operand
      Returns:
        the result of multiplication

    - #### public static double multiply(double op1, byte op2)

      Performs multiplication on two numeric values (double and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second byte operand
      Returns:
        the result of multiplication

    - #### public static double multiply(double op1, short op2)

      Performs multiplication on two numeric values (double and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second short operand
      Returns:
        the result of multiplication

    - #### public static double multiply(double op1, int op2)

      Performs multiplication on two numeric values (double and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second int operand
      Returns:
        the result of multiplication

    - #### public static double multiply(double op1, long op2)

      Performs multiplication on two numeric values (double and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second long operand
      Returns:
        the result of multiplication

    - #### public static double multiply(double op1, float op2)

      Performs multiplication on two numeric values (double and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second float operand
      Returns:
        the result of multiplication

    - #### public static double multiply(double op1, double op2)

      Performs multiplication on two numeric values (double and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second double operand
      Returns:
        the result of multiplication

    - #### public static int or(byte op1, byte op2)

      Performs bitwise OR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise OR

    - #### public static int or(byte op1, short op2)

      Performs bitwise OR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise OR

    - #### public static int or(byte op1, int op2)

      Performs bitwise OR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise OR

    - #### public static long or(byte op1, long op2)

      Performs bitwise OR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise OR

    - #### public static int or(short op1, byte op2)

      Performs bitwise OR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise OR

    - #### public static int or(short op1, short op2)

      Performs bitwise OR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise OR

    - #### public static int or(short op1, int op2)

      Performs bitwise OR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise OR

    - #### public static long or(short op1, long op2)

      Performs bitwise OR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise OR

    - #### public static int or(int op1, byte op2)

      Performs bitwise OR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise OR

    - #### public static int or(int op1, short op2)

      Performs bitwise OR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise OR

    - #### public static int or(int op1, int op2)

      Performs bitwise OR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise OR

    - #### public static long or(int op1, long op2)

      Performs bitwise OR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise OR

    - #### public static long or(long op1, byte op2)

      Performs bitwise OR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise OR

    - #### public static long or(long op1, short op2)

      Performs bitwise OR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise OR

    - #### public static long or(long op1, int op2)

      Performs bitwise OR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise OR

    - #### public static long or(long op1, long op2)

      Performs bitwise OR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise OR

    - #### public static int plus(byte op1, byte op2)

      Performs addition on two numeric values (byte and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second byte operand
      Returns:
        the result of addition

    - #### public static int plus(byte op1, short op2)

      Performs addition on two numeric values (byte and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second short operand
      Returns:
        the result of addition

    - #### public static int plus(byte op1, int op2)

      Performs addition on two numeric values (byte and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second int operand
      Returns:
        the result of addition

    - #### public static long plus(byte op1, long op2)

      Performs addition on two numeric values (byte and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second long operand
      Returns:
        the result of addition

    - #### public static double plus(byte op1, float op2)

      Performs addition on two numeric values (byte and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second float operand
      Returns:
        the result of addition

    - #### public static double plus(byte op1, double op2)

      Performs addition on two numeric values (byte and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second double operand
      Returns:
        the result of addition

    - #### public static int plus(short op1, byte op2)

      Performs addition on two numeric values (short and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second byte operand
      Returns:
        the result of addition

    - #### public static int plus(short op1, short op2)

      Performs addition on two numeric values (short and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second short operand
      Returns:
        the result of addition

    - #### public static int plus(short op1, int op2)

      Performs addition on two numeric values (short and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second int operand
      Returns:
        the result of addition

    - #### public static long plus(short op1, long op2)

      Performs addition on two numeric values (short and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second long operand
      Returns:
        the result of addition

    - #### public static double plus(short op1, float op2)

      Performs addition on two numeric values (short and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second float operand
      Returns:
        the result of addition

    - #### public static double plus(short op1, double op2)

      Performs addition on two numeric values (short and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second double operand
      Returns:
        the result of addition

    - #### public static int plus(int op1, byte op2)

      Performs addition on two numeric values (int and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second byte operand
      Returns:
        the result of addition

    - #### public static int plus(int op1, short op2)

      Performs addition on two numeric values (int and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second short operand
      Returns:
        the result of addition

    - #### public static int plus(int op1, int op2)

      Performs addition on two numeric values (int and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second int operand
      Returns:
        the result of addition

    - #### public static long plus(int op1, long op2)

      Performs addition on two numeric values (int and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second long operand
      Returns:
        the result of addition

    - #### public static double plus(int op1, float op2)

      Performs addition on two numeric values (int and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second float operand
      Returns:
        the result of addition

    - #### public static double plus(int op1, double op2)

      Performs addition on two numeric values (int and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second double operand
      Returns:
        the result of addition

    - #### public static long plus(long op1, byte op2)

      Performs addition on two numeric values (long and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second byte operand
      Returns:
        the result of addition

    - #### public static long plus(long op1, short op2)

      Performs addition on two numeric values (long and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second short operand
      Returns:
        the result of addition

    - #### public static long plus(long op1, int op2)

      Performs addition on two numeric values (long and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second int operand
      Returns:
        the result of addition

    - #### public static long plus(long op1, long op2)

      Performs addition on two numeric values (long and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second long operand
      Returns:
        the result of addition

    - #### public static double plus(long op1, float op2)

      Performs addition on two numeric values (long and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second float operand
      Returns:
        the result of addition

    - #### public static double plus(long op1, double op2)

      Performs addition on two numeric values (long and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second double operand
      Returns:
        the result of addition

    - #### public static double plus(float op1, byte op2)

      Performs addition on two numeric values (float and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second byte operand
      Returns:
        the result of addition

    - #### public static double plus(float op1, short op2)

      Performs addition on two numeric values (float and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second short operand
      Returns:
        the result of addition

    - #### public static double plus(float op1, int op2)

      Performs addition on two numeric values (float and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second int operand
      Returns:
        the result of addition

    - #### public static double plus(float op1, long op2)

      Performs addition on two numeric values (float and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second long operand
      Returns:
        the result of addition

    - #### public static double plus(float op1, float op2)

      Performs addition on two numeric values (float and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second float operand
      Returns:
        the result of addition

    - #### public static double plus(float op1, double op2)

      Performs addition on two numeric values (float and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first float operand
        `op2` - the second double operand
      Returns:
        the result of addition

    - #### public static double plus(double op1, byte op2)

      Performs addition on two numeric values (double and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second byte operand
      Returns:
        the result of addition

    - #### public static double plus(double op1, short op2)

      Performs addition on two numeric values (double and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second short operand
      Returns:
        the result of addition

    - #### public static double plus(double op1, int op2)

      Performs addition on two numeric values (double and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second int operand
      Returns:
        the result of addition

    - #### public static double plus(double op1, long op2)

      Performs addition on two numeric values (double and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second long operand
      Returns:
        the result of addition

    - #### public static double plus(double op1, float op2)

      Performs addition on two numeric values (double and float).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second float operand
      Returns:
        the result of addition

    - #### public static double plus(double op1, double op2)

      Performs addition on two numeric values (double and double).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first double operand
        `op2` - the second double operand
      Returns:
        the result of addition

    - #### public static int remainder(byte op1, byte op2)

      Performs remainder on two numeric values (byte and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second byte operand
      Returns:
        the result of remainder

    - #### public static int remainder(byte op1, short op2)

      Performs remainder on two numeric values (byte and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second short operand
      Returns:
        the result of remainder

    - #### public static int remainder(byte op1, int op2)

      Performs remainder on two numeric values (byte and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second int operand
      Returns:
        the result of remainder

    - #### public static long remainder(byte op1, long op2)

      Performs remainder on two numeric values (byte and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first byte operand
        `op2` - the second long operand
      Returns:
        the result of remainder

    - #### public static int remainder(short op1, byte op2)

      Performs remainder on two numeric values (short and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second byte operand
      Returns:
        the result of remainder

    - #### public static int remainder(short op1, short op2)

      Performs remainder on two numeric values (short and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second short operand
      Returns:
        the result of remainder

    - #### public static int remainder(short op1, int op2)

      Performs remainder on two numeric values (short and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second int operand
      Returns:
        the result of remainder

    - #### public static long remainder(short op1, long op2)

      Performs remainder on two numeric values (short and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first short operand
        `op2` - the second long operand
      Returns:
        the result of remainder

    - #### public static int remainder(int op1, byte op2)

      Performs remainder on two numeric values (int and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second byte operand
      Returns:
        the result of remainder

    - #### public static int remainder(int op1, short op2)

      Performs remainder on two numeric values (int and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second short operand
      Returns:
        the result of remainder

    - #### public static int remainder(int op1, int op2)

      Performs remainder on two numeric values (int and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second int operand
      Returns:
        the result of remainder

    - #### public static long remainder(int op1, long op2)

      Performs remainder on two numeric values (int and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first int operand
        `op2` - the second long operand
      Returns:
        the result of remainder

    - #### public static long remainder(long op1, byte op2)

      Performs remainder on two numeric values (long and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second byte operand
      Returns:
        the result of remainder

    - #### public static long remainder(long op1, short op2)

      Performs remainder on two numeric values (long and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second short operand
      Returns:
        the result of remainder

    - #### public static long remainder(long op1, int op2)

      Performs remainder on two numeric values (long and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second int operand
      Returns:
        the result of remainder

    - #### public static long remainder(long op1, long op2)

      Performs remainder on two numeric values (long and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first long operand
        `op2` - the second long operand
      Returns:
        the result of remainder

    - #### public static int rightShift(byte op1, byte op2)

      Performs right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of right shift

    - #### public static int rightShift(byte op1, short op2)

      Performs right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of right shift

    - #### public static int rightShift(byte op1, int op2)

      Performs right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of right shift

    - #### public static long rightShift(byte op1, long op2)

      Performs right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of right shift

    - #### public static int rightShift(short op1, byte op2)

      Performs right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of right shift

    - #### public static int rightShift(short op1, short op2)

      Performs right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of right shift

    - #### public static int rightShift(short op1, int op2)

      Performs right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of right shift

    - #### public static long rightShift(short op1, long op2)

      Performs right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of right shift

    - #### public static int rightShift(int op1, byte op2)

      Performs right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of right shift

    - #### public static int rightShift(int op1, short op2)

      Performs right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of right shift

    - #### public static int rightShift(int op1, int op2)

      Performs right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of right shift

    - #### public static long rightShift(int op1, long op2)

      Performs right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of right shift

    - #### public static long rightShift(long op1, byte op2)

      Performs right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of right shift

    - #### public static long rightShift(long op1, short op2)

      Performs right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of right shift

    - #### public static long rightShift(long op1, int op2)

      Performs right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of right shift

    - #### public static long rightShift(long op1, long op2)

      Performs right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of right shift

    - #### public static int rightShiftUnsigned(byte op1, byte op2)

      Performs unsigned right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(byte op1, short op2)

      Performs unsigned right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(byte op1, int op2)

      Performs unsigned right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(byte op1, long op2)

      Performs unsigned right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(short op1, byte op2)

      Performs unsigned right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(short op1, short op2)

      Performs unsigned right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(short op1, int op2)

      Performs unsigned right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(short op1, long op2)

      Performs unsigned right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(int op1, byte op2)

      Performs unsigned right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(int op1, short op2)

      Performs unsigned right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of unsigned right shift

    - #### public static int rightShiftUnsigned(int op1, int op2)

      Performs unsigned right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(int op1, long op2)

      Performs unsigned right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(long op1, byte op2)

      Performs unsigned right shift on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(long op1, short op2)

      Performs unsigned right shift on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(long op1, int op2)

      Performs unsigned right shift on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of unsigned right shift

    - #### public static long rightShiftUnsigned(long op1, long op2)

      Performs unsigned right shift on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of unsigned right shift

    - #### public static int xor(byte op1, byte op2)

      Performs bitwise XOR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(byte op1, short op2)

      Performs bitwise XOR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(byte op1, int op2)

      Performs bitwise XOR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(byte op1, long op2)

      Performs bitwise XOR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(short op1, byte op2)

      Performs bitwise XOR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(short op1, short op2)

      Performs bitwise XOR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(short op1, int op2)

      Performs bitwise XOR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(short op1, long op2)

      Performs bitwise XOR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(int op1, byte op2)

      Performs bitwise XOR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(int op1, short op2)

      Performs bitwise XOR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise XOR

    - #### public static int xor(int op1, int op2)

      Performs bitwise XOR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(int op1, long op2)

      Performs bitwise XOR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(long op1, byte op2)

      Performs bitwise XOR on two numeric values (op1 and byte).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second byte operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(long op1, short op2)

      Performs bitwise XOR on two numeric values (op1 and short).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second short operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(long op1, int op2)

      Performs bitwise XOR on two numeric values (op1 and int).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second int operand
      Returns:
        the result of bitwise XOR

    - #### public static long xor(long op1, long op2)

      Performs bitwise XOR on two numeric values (op1 and long).

      Delegates to the fast path implementation if the operation has not been modified, otherwise invokes the overridden implementation through the meta-programming system.

      Parameters:
        `op1` - the first op1 operand
        `op2` - the second long operand
      Returns:
        the result of bitwise XOR