NumberMathModificationInfo (Groovy 2.4.14)
Date: 2018-02-24

org.codehaus.groovy.runtime.typehandling

## Class NumberMathModificationInfo

- java.lang.Object
- - org.codehaus.groovy.runtime.typehandling.NumberMathModificationInfo

-     public class NumberMathModificationInfo
      extends java.lang.Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `boolean` | `byte_and`
    `boolean` | `byte_div`
    `boolean` | `byte_intdiv`
    `boolean` | `byte_leftShift`
    `boolean` | `byte_minus`
    `boolean` | `byte_mod`
    `boolean` | `byte_multiply`
    `boolean` | `byte_or`
    `boolean` | `byte_plus`
    `boolean` | `byte_rightShift`
    `boolean` | `byte_rightShiftUnsigned`
    `boolean` | `byte_xor`
    `boolean` | `double_and`
    `boolean` | `double_div`
    `boolean` | `double_intdiv`
    `boolean` | `double_leftShift`
    `boolean` | `double_minus`
    `boolean` | `double_mod`
    `boolean` | `double_multiply`
    `boolean` | `double_or`
    `boolean` | `double_plus`
    `boolean` | `double_rightShift`
    `boolean` | `double_rightShiftUnsigned`
    `boolean` | `double_xor`
    `boolean` | `float_and`
    `boolean` | `float_div`
    `boolean` | `float_intdiv`
    `boolean` | `float_leftShift`
    `boolean` | `float_minus`
    `boolean` | `float_mod`
    `boolean` | `float_multiply`
    `boolean` | `float_or`
    `boolean` | `float_plus`
    `boolean` | `float_rightShift`
    `boolean` | `float_rightShiftUnsigned`
    `boolean` | `float_xor`
    `static NumberMathModificationInfo` | `instance`
    `boolean` | `int_and`
    `boolean` | `int_div`
    `boolean` | `int_intdiv`
    `boolean` | `int_leftShift`
    `boolean` | `int_minus`
    `boolean` | `int_mod`
    `boolean` | `int_multiply`
    `boolean` | `int_or`
    `boolean` | `int_plus`
    `boolean` | `int_rightShift`
    `boolean` | `int_rightShiftUnsigned`
    `boolean` | `int_xor`
    `boolean` | `long_and`
    `boolean` | `long_div`
    `boolean` | `long_intdiv`
    `boolean` | `long_leftShift`
    `boolean` | `long_minus`
    `boolean` | `long_mod`
    `boolean` | `long_multiply`
    `boolean` | `long_or`
    `boolean` | `long_plus`
    `boolean` | `long_rightShift`
    `boolean` | `long_rightShiftUnsigned`
    `boolean` | `long_xor`
    `boolean` | `short_and`
    `boolean` | `short_div`
    `boolean` | `short_intdiv`
    `boolean` | `short_leftShift`
    `boolean` | `short_minus`
    `boolean` | `short_mod`
    `boolean` | `short_multiply`
    `boolean` | `short_or`
    `boolean` | `short_plus`
    `boolean` | `short_rightShift`
    `boolean` | `short_rightShiftUnsigned`
    `boolean` | `short_xor`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static int` | `and(byte op1, byte op2)`
    `static int` | `and(byte op1, int op2)`
    `static long` | `and(byte op1, long op2)`
    `static int` | `and(byte op1, short op2)`
    `static int` | `and(int op1, byte op2)`
    `static int` | `and(int op1, int op2)`
    `static long` | `and(int op1, long op2)`
    `static int` | `and(int op1, short op2)`
    `static long` | `and(long op1, byte op2)`
    `static long` | `and(long op1, int op2)`
    `static long` | `and(long op1, long op2)`
    `static long` | `and(long op1, short op2)`
    `static int` | `and(short op1, byte op2)`
    `static int` | `and(short op1, int op2)`
    `static long` | `and(short op1, long op2)`
    `static int` | `and(short op1, short op2)`
    `void` | `checkIfStdMethod(MetaMethod method)`
    `static int` | `div(byte op1, byte op2)`
    `static double` | `div(byte op1, double op2)`
    `static double` | `div(byte op1, float op2)`
    `static int` | `div(byte op1, int op2)`
    `static long` | `div(byte op1, long op2)`
    `static int` | `div(byte op1, short op2)`
    `static double` | `div(double op1, byte op2)`
    `static double` | `div(double op1, double op2)`
    `static double` | `div(double op1, float op2)`
    `static double` | `div(double op1, int op2)`
    `static double` | `div(double op1, long op2)`
    `static double` | `div(double op1, short op2)`
    `static double` | `div(float op1, byte op2)`
    `static double` | `div(float op1, double op2)`
    `static double` | `div(float op1, float op2)`
    `static double` | `div(float op1, int op2)`
    `static double` | `div(float op1, long op2)`
    `static double` | `div(float op1, short op2)`
    `static int` | `div(int op1, byte op2)`
    `static double` | `div(int op1, double op2)`
    `static double` | `div(int op1, float op2)`
    `static int` | `div(int op1, int op2)`
    `static long` | `div(int op1, long op2)`
    `static int` | `div(int op1, short op2)`
    `static long` | `div(long op1, byte op2)`
    `static double` | `div(long op1, double op2)`
    `static double` | `div(long op1, float op2)`
    `static long` | `div(long op1, int op2)`
    `static long` | `div(long op1, long op2)`
    `static long` | `div(long op1, short op2)`
    `static int` | `div(short op1, byte op2)`
    `static double` | `div(short op1, double op2)`
    `static double` | `div(short op1, float op2)`
    `static int` | `div(short op1, int op2)`
    `static long` | `div(short op1, long op2)`
    `static int` | `div(short op1, short op2)`
    `static int` | `intdiv(byte op1, byte op2)`
    `static int` | `intdiv(byte op1, int op2)`
    `static long` | `intdiv(byte op1, long op2)`
    `static int` | `intdiv(byte op1, short op2)`
    `static int` | `intdiv(int op1, byte op2)`
    `static int` | `intdiv(int op1, int op2)`
    `static long` | `intdiv(int op1, long op2)`
    `static int` | `intdiv(int op1, short op2)`
    `static long` | `intdiv(long op1, byte op2)`
    `static long` | `intdiv(long op1, int op2)`
    `static long` | `intdiv(long op1, long op2)`
    `static long` | `intdiv(long op1, short op2)`
    `static int` | `intdiv(short op1, byte op2)`
    `static int` | `intdiv(short op1, int op2)`
    `static long` | `intdiv(short op1, long op2)`
    `static int` | `intdiv(short op1, short op2)`
    `static int` | `leftShift(byte op1, byte op2)`
    `static int` | `leftShift(byte op1, int op2)`
    `static long` | `leftShift(byte op1, long op2)`
    `static int` | `leftShift(byte op1, short op2)`
    `static int` | `leftShift(int op1, byte op2)`
    `static int` | `leftShift(int op1, int op2)`
    `static long` | `leftShift(int op1, long op2)`
    `static int` | `leftShift(int op1, short op2)`
    `static long` | `leftShift(long op1, byte op2)`
    `static long` | `leftShift(long op1, int op2)`
    `static long` | `leftShift(long op1, long op2)`
    `static long` | `leftShift(long op1, short op2)`
    `static int` | `leftShift(short op1, byte op2)`
    `static int` | `leftShift(short op1, int op2)`
    `static long` | `leftShift(short op1, long op2)`
    `static int` | `leftShift(short op1, short op2)`
    `static int` | `minus(byte op1, byte op2)`
    `static double` | `minus(byte op1, double op2)`
    `static double` | `minus(byte op1, float op2)`
    `static int` | `minus(byte op1, int op2)`
    `static long` | `minus(byte op1, long op2)`
    `static int` | `minus(byte op1, short op2)`
    `static double` | `minus(double op1, byte op2)`
    `static double` | `minus(double op1, double op2)`
    `static double` | `minus(double op1, float op2)`
    `static double` | `minus(double op1, int op2)`
    `static double` | `minus(double op1, long op2)`
    `static double` | `minus(double op1, short op2)`
    `static double` | `minus(float op1, byte op2)`
    `static double` | `minus(float op1, double op2)`
    `static double` | `minus(float op1, float op2)`
    `static double` | `minus(float op1, int op2)`
    `static double` | `minus(float op1, long op2)`
    `static double` | `minus(float op1, short op2)`
    `static int` | `minus(int op1, byte op2)`
    `static double` | `minus(int op1, double op2)`
    `static double` | `minus(int op1, float op2)`
    `static int` | `minus(int op1, int op2)`
    `static long` | `minus(int op1, long op2)`
    `static int` | `minus(int op1, short op2)`
    `static long` | `minus(long op1, byte op2)`
    `static double` | `minus(long op1, double op2)`
    `static double` | `minus(long op1, float op2)`
    `static long` | `minus(long op1, int op2)`
    `static long` | `minus(long op1, long op2)`
    `static long` | `minus(long op1, short op2)`
    `static int` | `minus(short op1, byte op2)`
    `static double` | `minus(short op1, double op2)`
    `static double` | `minus(short op1, float op2)`
    `static int` | `minus(short op1, int op2)`
    `static long` | `minus(short op1, long op2)`
    `static int` | `minus(short op1, short op2)`
    `static int` | `mod(byte op1, byte op2)`
    `static int` | `mod(byte op1, int op2)`
    `static long` | `mod(byte op1, long op2)`
    `static int` | `mod(byte op1, short op2)`
    `static int` | `mod(int op1, byte op2)`
    `static int` | `mod(int op1, int op2)`
    `static long` | `mod(int op1, long op2)`
    `static int` | `mod(int op1, short op2)`
    `static long` | `mod(long op1, byte op2)`
    `static long` | `mod(long op1, int op2)`
    `static long` | `mod(long op1, long op2)`
    `static long` | `mod(long op1, short op2)`
    `static int` | `mod(short op1, byte op2)`
    `static int` | `mod(short op1, int op2)`
    `static long` | `mod(short op1, long op2)`
    `static int` | `mod(short op1, short op2)`
    `static int` | `multiply(byte op1, byte op2)`
    `static double` | `multiply(byte op1, double op2)`
    `static double` | `multiply(byte op1, float op2)`
    `static int` | `multiply(byte op1, int op2)`
    `static long` | `multiply(byte op1, long op2)`
    `static int` | `multiply(byte op1, short op2)`
    `static double` | `multiply(double op1, byte op2)`
    `static double` | `multiply(double op1, double op2)`
    `static double` | `multiply(double op1, float op2)`
    `static double` | `multiply(double op1, int op2)`
    `static double` | `multiply(double op1, long op2)`
    `static double` | `multiply(double op1, short op2)`
    `static double` | `multiply(float op1, byte op2)`
    `static double` | `multiply(float op1, double op2)`
    `static double` | `multiply(float op1, float op2)`
    `static double` | `multiply(float op1, int op2)`
    `static double` | `multiply(float op1, long op2)`
    `static double` | `multiply(float op1, short op2)`
    `static int` | `multiply(int op1, byte op2)`
    `static double` | `multiply(int op1, double op2)`
    `static double` | `multiply(int op1, float op2)`
    `static int` | `multiply(int op1, int op2)`
    `static long` | `multiply(int op1, long op2)`
    `static int` | `multiply(int op1, short op2)`
    `static long` | `multiply(long op1, byte op2)`
    `static double` | `multiply(long op1, double op2)`
    `static double` | `multiply(long op1, float op2)`
    `static long` | `multiply(long op1, int op2)`
    `static long` | `multiply(long op1, long op2)`
    `static long` | `multiply(long op1, short op2)`
    `static int` | `multiply(short op1, byte op2)`
    `static double` | `multiply(short op1, double op2)`
    `static double` | `multiply(short op1, float op2)`
    `static int` | `multiply(short op1, int op2)`
    `static long` | `multiply(short op1, long op2)`
    `static int` | `multiply(short op1, short op2)`
    `static int` | `or(byte op1, byte op2)`
    `static int` | `or(byte op1, int op2)`
    `static long` | `or(byte op1, long op2)`
    `static int` | `or(byte op1, short op2)`
    `static int` | `or(int op1, byte op2)`
    `static int` | `or(int op1, int op2)`
    `static long` | `or(int op1, long op2)`
    `static int` | `or(int op1, short op2)`
    `static long` | `or(long op1, byte op2)`
    `static long` | `or(long op1, int op2)`
    `static long` | `or(long op1, long op2)`
    `static long` | `or(long op1, short op2)`
    `static int` | `or(short op1, byte op2)`
    `static int` | `or(short op1, int op2)`
    `static long` | `or(short op1, long op2)`
    `static int` | `or(short op1, short op2)`
    `static int` | `plus(byte op1, byte op2)`
    `static double` | `plus(byte op1, double op2)`
    `static double` | `plus(byte op1, float op2)`
    `static int` | `plus(byte op1, int op2)`
    `static long` | `plus(byte op1, long op2)`
    `static int` | `plus(byte op1, short op2)`
    `static double` | `plus(double op1, byte op2)`
    `static double` | `plus(double op1, double op2)`
    `static double` | `plus(double op1, float op2)`
    `static double` | `plus(double op1, int op2)`
    `static double` | `plus(double op1, long op2)`
    `static double` | `plus(double op1, short op2)`
    `static double` | `plus(float op1, byte op2)`
    `static double` | `plus(float op1, double op2)`
    `static double` | `plus(float op1, float op2)`
    `static double` | `plus(float op1, int op2)`
    `static double` | `plus(float op1, long op2)`
    `static double` | `plus(float op1, short op2)`
    `static int` | `plus(int op1, byte op2)`
    `static double` | `plus(int op1, double op2)`
    `static double` | `plus(int op1, float op2)`
    `static int` | `plus(int op1, int op2)`
    `static long` | `plus(int op1, long op2)`
    `static int` | `plus(int op1, short op2)`
    `static long` | `plus(long op1, byte op2)`
    `static double` | `plus(long op1, double op2)`
    `static double` | `plus(long op1, float op2)`
    `static long` | `plus(long op1, int op2)`
    `static long` | `plus(long op1, long op2)`
    `static long` | `plus(long op1, short op2)`
    `static int` | `plus(short op1, byte op2)`
    `static double` | `plus(short op1, double op2)`
    `static double` | `plus(short op1, float op2)`
    `static int` | `plus(short op1, int op2)`
    `static long` | `plus(short op1, long op2)`
    `static int` | `plus(short op1, short op2)`
    `static int` | `rightShift(byte op1, byte op2)`
    `static int` | `rightShift(byte op1, int op2)`
    `static long` | `rightShift(byte op1, long op2)`
    `static int` | `rightShift(byte op1, short op2)`
    `static int` | `rightShift(int op1, byte op2)`
    `static int` | `rightShift(int op1, int op2)`
    `static long` | `rightShift(int op1, long op2)`
    `static int` | `rightShift(int op1, short op2)`
    `static long` | `rightShift(long op1, byte op2)`
    `static long` | `rightShift(long op1, int op2)`
    `static long` | `rightShift(long op1, long op2)`
    `static long` | `rightShift(long op1, short op2)`
    `static int` | `rightShift(short op1, byte op2)`
    `static int` | `rightShift(short op1, int op2)`
    `static long` | `rightShift(short op1, long op2)`
    `static int` | `rightShift(short op1, short op2)`
    `static int` | `rightShiftUnsigned(byte op1, byte op2)`
    `static int` | `rightShiftUnsigned(byte op1, int op2)`
    `static long` | `rightShiftUnsigned(byte op1, long op2)`
    `static int` | `rightShiftUnsigned(byte op1, short op2)`
    `static int` | `rightShiftUnsigned(int op1, byte op2)`
    `static int` | `rightShiftUnsigned(int op1, int op2)`
    `static long` | `rightShiftUnsigned(int op1, long op2)`
    `static int` | `rightShiftUnsigned(int op1, short op2)`
    `static long` | `rightShiftUnsigned(long op1, byte op2)`
    `static long` | `rightShiftUnsigned(long op1, int op2)`
    `static long` | `rightShiftUnsigned(long op1, long op2)`
    `static long` | `rightShiftUnsigned(long op1, short op2)`
    `static int` | `rightShiftUnsigned(short op1, byte op2)`
    `static int` | `rightShiftUnsigned(short op1, int op2)`
    `static long` | `rightShiftUnsigned(short op1, long op2)`
    `static int` | `rightShiftUnsigned(short op1, short op2)`
    `static int` | `xor(byte op1, byte op2)`
    `static int` | `xor(byte op1, int op2)`
    `static long` | `xor(byte op1, long op2)`
    `static int` | `xor(byte op1, short op2)`
    `static int` | `xor(int op1, byte op2)`
    `static int` | `xor(int op1, int op2)`
    `static long` | `xor(int op1, long op2)`
    `static int` | `xor(int op1, short op2)`
    `static long` | `xor(long op1, byte op2)`
    `static long` | `xor(long op1, int op2)`
    `static long` | `xor(long op1, long op2)`
    `static long` | `xor(long op1, short op2)`
    `static int` | `xor(short op1, byte op2)`
    `static int` | `xor(short op1, int op2)`
    `static long` | `xor(short op1, long op2)`
    `static int` | `xor(short op1, short op2)`

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

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

- - ### Field Detail

    - #### instance

          public static final NumberMathModificationInfo instance

    - #### byte_plus

          public boolean byte_plus

    - #### short_plus

          public boolean short_plus

    - #### int_plus

          public boolean int_plus

    - #### long_plus

          public boolean long_plus

    - #### float_plus

          public boolean float_plus

    - #### double_plus

          public boolean double_plus

    - #### byte_minus

          public boolean byte_minus

    - #### short_minus

          public boolean short_minus

    - #### int_minus

          public boolean int_minus

    - #### long_minus

          public boolean long_minus

    - #### float_minus

          public boolean float_minus

    - #### double_minus

          public boolean double_minus

    - #### byte_multiply

          public boolean byte_multiply

    - #### short_multiply

          public boolean short_multiply

    - #### int_multiply

          public boolean int_multiply

    - #### long_multiply

          public boolean long_multiply

    - #### float_multiply

          public boolean float_multiply

    - #### double_multiply

          public boolean double_multiply

    - #### byte_div

          public boolean byte_div

    - #### short_div

          public boolean short_div

    - #### int_div

          public boolean int_div

    - #### long_div

          public boolean long_div

    - #### float_div

          public boolean float_div

    - #### double_div

          public boolean double_div

    - #### byte_or

          public boolean byte_or

    - #### short_or

          public boolean short_or

    - #### int_or

          public boolean int_or

    - #### long_or

          public boolean long_or

    - #### float_or

          public boolean float_or

    - #### double_or

          public boolean double_or

    - #### byte_and

          public boolean byte_and

    - #### short_and

          public boolean short_and

    - #### int_and

          public boolean int_and

    - #### long_and

          public boolean long_and

    - #### float_and

          public boolean float_and

    - #### double_and

          public boolean double_and

    - #### byte_xor

          public boolean byte_xor

    - #### short_xor

          public boolean short_xor

    - #### int_xor

          public boolean int_xor

    - #### long_xor

          public boolean long_xor

    - #### float_xor

          public boolean float_xor

    - #### double_xor

          public boolean double_xor

    - #### byte_intdiv

          public boolean byte_intdiv

    - #### short_intdiv

          public boolean short_intdiv

    - #### int_intdiv

          public boolean int_intdiv

    - #### long_intdiv

          public boolean long_intdiv

    - #### float_intdiv

          public boolean float_intdiv

    - #### double_intdiv

          public boolean double_intdiv

    - #### byte_mod

          public boolean byte_mod

    - #### short_mod

          public boolean short_mod

    - #### int_mod

          public boolean int_mod

    - #### long_mod

          public boolean long_mod

    - #### float_mod

          public boolean float_mod

    - #### double_mod

          public boolean double_mod

    - #### byte_leftShift

          public boolean byte_leftShift

    - #### short_leftShift

          public boolean short_leftShift

    - #### int_leftShift

          public boolean int_leftShift

    - #### long_leftShift

          public boolean long_leftShift

    - #### float_leftShift

          public boolean float_leftShift

    - #### double_leftShift

          public boolean double_leftShift

    - #### byte_rightShift

          public boolean byte_rightShift

    - #### short_rightShift

          public boolean short_rightShift

    - #### int_rightShift

          public boolean int_rightShift

    - #### long_rightShift

          public boolean long_rightShift

    - #### float_rightShift

          public boolean float_rightShift

    - #### double_rightShift

          public boolean double_rightShift

    - #### byte_rightShiftUnsigned

          public boolean byte_rightShiftUnsigned

    - #### short_rightShiftUnsigned

          public boolean short_rightShiftUnsigned

    - #### int_rightShiftUnsigned

          public boolean int_rightShiftUnsigned

    - #### long_rightShiftUnsigned

          public boolean long_rightShiftUnsigned

    - #### float_rightShiftUnsigned

          public boolean float_rightShiftUnsigned

    - #### double_rightShiftUnsigned

          public boolean double_rightShiftUnsigned

  - ### Method Detail

    - #### checkIfStdMethod

          public void checkIfStdMethod(MetaMethod method)

    - #### plus

          public static int plus(byte op1,
                                 byte op2)

    - #### plus

          public static int plus(byte op1,
                                 short op2)

    - #### plus

          public static int plus(byte op1,
                                 int op2)

    - #### plus

          public static long plus(byte op1,
                                  long op2)

    - #### plus

          public static double plus(byte op1,
                                    float op2)

    - #### plus

          public static double plus(byte op1,
                                    double op2)

    - #### plus

          public static int plus(short op1,
                                 byte op2)

    - #### plus

          public static int plus(short op1,
                                 short op2)

    - #### plus

          public static int plus(short op1,
                                 int op2)

    - #### plus

          public static long plus(short op1,
                                  long op2)

    - #### plus

          public static double plus(short op1,
                                    float op2)

    - #### plus

          public static double plus(short op1,
                                    double op2)

    - #### plus

          public static int plus(int op1,
                                 byte op2)

    - #### plus

          public static int plus(int op1,
                                 short op2)

    - #### plus

          public static int plus(int op1,
                                 int op2)

    - #### plus

          public static long plus(int op1,
                                  long op2)

    - #### plus

          public static double plus(int op1,
                                    float op2)

    - #### plus

          public static double plus(int op1,
                                    double op2)

    - #### plus

          public static long plus(long op1,
                                  byte op2)

    - #### plus

          public static long plus(long op1,
                                  short op2)

    - #### plus

          public static long plus(long op1,
                                  int op2)

    - #### plus

          public static long plus(long op1,
                                  long op2)

    - #### plus

          public static double plus(long op1,
                                    float op2)

    - #### plus

          public static double plus(long op1,
                                    double op2)

    - #### plus

          public static double plus(float op1,
                                    byte op2)

    - #### plus

          public static double plus(float op1,
                                    short op2)

    - #### plus

          public static double plus(float op1,
                                    int op2)

    - #### plus

          public static double plus(float op1,
                                    long op2)

    - #### plus

          public static double plus(float op1,
                                    float op2)

    - #### plus

          public static double plus(float op1,
                                    double op2)

    - #### plus

          public static double plus(double op1,
                                    byte op2)

    - #### plus

          public static double plus(double op1,
                                    short op2)

    - #### plus

          public static double plus(double op1,
                                    int op2)

    - #### plus

          public static double plus(double op1,
                                    long op2)

    - #### plus

          public static double plus(double op1,
                                    float op2)

    - #### plus

          public static double plus(double op1,
                                    double op2)

    - #### minus

          public static int minus(byte op1,
                                  byte op2)

    - #### minus

          public static int minus(byte op1,
                                  short op2)

    - #### minus

          public static int minus(byte op1,
                                  int op2)

    - #### minus

          public static long minus(byte op1,
                                   long op2)

    - #### minus

          public static double minus(byte op1,
                                     float op2)

    - #### minus

          public static double minus(byte op1,
                                     double op2)

    - #### minus

          public static int minus(short op1,
                                  byte op2)

    - #### minus

          public static int minus(short op1,
                                  short op2)

    - #### minus

          public static int minus(short op1,
                                  int op2)

    - #### minus

          public static long minus(short op1,
                                   long op2)

    - #### minus

          public static double minus(short op1,
                                     float op2)

    - #### minus

          public static double minus(short op1,
                                     double op2)

    - #### minus

          public static int minus(int op1,
                                  byte op2)

    - #### minus

          public static int minus(int op1,
                                  short op2)

    - #### minus

          public static int minus(int op1,
                                  int op2)

    - #### minus

          public static long minus(int op1,
                                   long op2)

    - #### minus

          public static double minus(int op1,
                                     float op2)

    - #### minus

          public static double minus(int op1,
                                     double op2)

    - #### minus

          public static long minus(long op1,
                                   byte op2)

    - #### minus

          public static long minus(long op1,
                                   short op2)

    - #### minus

          public static long minus(long op1,
                                   int op2)

    - #### minus

          public static long minus(long op1,
                                   long op2)

    - #### minus

          public static double minus(long op1,
                                     float op2)

    - #### minus

          public static double minus(long op1,
                                     double op2)

    - #### minus

          public static double minus(float op1,
                                     byte op2)

    - #### minus

          public static double minus(float op1,
                                     short op2)

    - #### minus

          public static double minus(float op1,
                                     int op2)

    - #### minus

          public static double minus(float op1,
                                     long op2)

    - #### minus

          public static double minus(float op1,
                                     float op2)

    - #### minus

          public static double minus(float op1,
                                     double op2)

    - #### minus

          public static double minus(double op1,
                                     byte op2)

    - #### minus

          public static double minus(double op1,
                                     short op2)

    - #### minus

          public static double minus(double op1,
                                     int op2)

    - #### minus

          public static double minus(double op1,
                                     long op2)

    - #### minus

          public static double minus(double op1,
                                     float op2)

    - #### minus

          public static double minus(double op1,
                                     double op2)

    - #### multiply

          public static int multiply(byte op1,
                                     byte op2)

    - #### multiply

          public static int multiply(byte op1,
                                     short op2)

    - #### multiply

          public static int multiply(byte op1,
                                     int op2)

    - #### multiply

          public static long multiply(byte op1,
                                      long op2)

    - #### multiply

          public static double multiply(byte op1,
                                        float op2)

    - #### multiply

          public static double multiply(byte op1,
                                        double op2)

    - #### multiply

          public static int multiply(short op1,
                                     byte op2)

    - #### multiply

          public static int multiply(short op1,
                                     short op2)

    - #### multiply

          public static int multiply(short op1,
                                     int op2)

    - #### multiply

          public static long multiply(short op1,
                                      long op2)

    - #### multiply

          public static double multiply(short op1,
                                        float op2)

    - #### multiply

          public static double multiply(short op1,
                                        double op2)

    - #### multiply

          public static int multiply(int op1,
                                     byte op2)

    - #### multiply

          public static int multiply(int op1,
                                     short op2)

    - #### multiply

          public static int multiply(int op1,
                                     int op2)

    - #### multiply

          public static long multiply(int op1,
                                      long op2)

    - #### multiply

          public static double multiply(int op1,
                                        float op2)

    - #### multiply

          public static double multiply(int op1,
                                        double op2)

    - #### multiply

          public static long multiply(long op1,
                                      byte op2)

    - #### multiply

          public static long multiply(long op1,
                                      short op2)

    - #### multiply

          public static long multiply(long op1,
                                      int op2)

    - #### multiply

          public static long multiply(long op1,
                                      long op2)

    - #### multiply

          public static double multiply(long op1,
                                        float op2)

    - #### multiply

          public static double multiply(long op1,
                                        double op2)

    - #### multiply

          public static double multiply(float op1,
                                        byte op2)

    - #### multiply

          public static double multiply(float op1,
                                        short op2)

    - #### multiply

          public static double multiply(float op1,
                                        int op2)

    - #### multiply

          public static double multiply(float op1,
                                        long op2)

    - #### multiply

          public static double multiply(float op1,
                                        float op2)

    - #### multiply

          public static double multiply(float op1,
                                        double op2)

    - #### multiply

          public static double multiply(double op1,
                                        byte op2)

    - #### multiply

          public static double multiply(double op1,
                                        short op2)

    - #### multiply

          public static double multiply(double op1,
                                        int op2)

    - #### multiply

          public static double multiply(double op1,
                                        long op2)

    - #### multiply

          public static double multiply(double op1,
                                        float op2)

    - #### multiply

          public static double multiply(double op1,
                                        double op2)

    - #### div

          public static int div(byte op1,
                                byte op2)

    - #### div

          public static int div(byte op1,
                                short op2)

    - #### div

          public static int div(byte op1,
                                int op2)

    - #### div

          public static long div(byte op1,
                                 long op2)

    - #### div

          public static double div(byte op1,
                                   float op2)

    - #### div

          public static double div(byte op1,
                                   double op2)

    - #### div

          public static int div(short op1,
                                byte op2)

    - #### div

          public static int div(short op1,
                                short op2)

    - #### div

          public static int div(short op1,
                                int op2)

    - #### div

          public static long div(short op1,
                                 long op2)

    - #### div

          public static double div(short op1,
                                   float op2)

    - #### div

          public static double div(short op1,
                                   double op2)

    - #### div

          public static int div(int op1,
                                byte op2)

    - #### div

          public static int div(int op1,
                                short op2)

    - #### div

          public static int div(int op1,
                                int op2)

    - #### div

          public static long div(int op1,
                                 long op2)

    - #### div

          public static double div(int op1,
                                   float op2)

    - #### div

          public static double div(int op1,
                                   double op2)

    - #### div

          public static long div(long op1,
                                 byte op2)

    - #### div

          public static long div(long op1,
                                 short op2)

    - #### div

          public static long div(long op1,
                                 int op2)

    - #### div

          public static long div(long op1,
                                 long op2)

    - #### div

          public static double div(long op1,
                                   float op2)

    - #### div

          public static double div(long op1,
                                   double op2)

    - #### div

          public static double div(float op1,
                                   byte op2)

    - #### div

          public static double div(float op1,
                                   short op2)

    - #### div

          public static double div(float op1,
                                   int op2)

    - #### div

          public static double div(float op1,
                                   long op2)

    - #### div

          public static double div(float op1,
                                   float op2)

    - #### div

          public static double div(float op1,
                                   double op2)

    - #### div

          public static double div(double op1,
                                   byte op2)

    - #### div

          public static double div(double op1,
                                   short op2)

    - #### div

          public static double div(double op1,
                                   int op2)

    - #### div

          public static double div(double op1,
                                   long op2)

    - #### div

          public static double div(double op1,
                                   float op2)

    - #### div

          public static double div(double op1,
                                   double op2)

    - #### or

          public static int or(byte op1,
                               byte op2)

    - #### or

          public static int or(byte op1,
                               short op2)

    - #### or

          public static int or(byte op1,
                               int op2)

    - #### or

          public static long or(byte op1,
                                long op2)

    - #### or

          public static int or(short op1,
                               byte op2)

    - #### or

          public static int or(short op1,
                               short op2)

    - #### or

          public static int or(short op1,
                               int op2)

    - #### or

          public static long or(short op1,
                                long op2)

    - #### or

          public static int or(int op1,
                               byte op2)

    - #### or

          public static int or(int op1,
                               short op2)

    - #### or

          public static int or(int op1,
                               int op2)

    - #### or

          public static long or(int op1,
                                long op2)

    - #### or

          public static long or(long op1,
                                byte op2)

    - #### or

          public static long or(long op1,
                                short op2)

    - #### or

          public static long or(long op1,
                                int op2)

    - #### or

          public static long or(long op1,
                                long op2)

    - #### and

          public static int and(byte op1,
                                byte op2)

    - #### and

          public static int and(byte op1,
                                short op2)

    - #### and

          public static int and(byte op1,
                                int op2)

    - #### and

          public static long and(byte op1,
                                 long op2)

    - #### and

          public static int and(short op1,
                                byte op2)

    - #### and

          public static int and(short op1,
                                short op2)

    - #### and

          public static int and(short op1,
                                int op2)

    - #### and

          public static long and(short op1,
                                 long op2)

    - #### and

          public static int and(int op1,
                                byte op2)

    - #### and

          public static int and(int op1,
                                short op2)

    - #### and

          public static int and(int op1,
                                int op2)

    - #### and

          public static long and(int op1,
                                 long op2)

    - #### and

          public static long and(long op1,
                                 byte op2)

    - #### and

          public static long and(long op1,
                                 short op2)

    - #### and

          public static long and(long op1,
                                 int op2)

    - #### and

          public static long and(long op1,
                                 long op2)

    - #### xor

          public static int xor(byte op1,
                                byte op2)

    - #### xor

          public static int xor(byte op1,
                                short op2)

    - #### xor

          public static int xor(byte op1,
                                int op2)

    - #### xor

          public static long xor(byte op1,
                                 long op2)

    - #### xor

          public static int xor(short op1,
                                byte op2)

    - #### xor

          public static int xor(short op1,
                                short op2)

    - #### xor

          public static int xor(short op1,
                                int op2)

    - #### xor

          public static long xor(short op1,
                                 long op2)

    - #### xor

          public static int xor(int op1,
                                byte op2)

    - #### xor

          public static int xor(int op1,
                                short op2)

    - #### xor

          public static int xor(int op1,
                                int op2)

    - #### xor

          public static long xor(int op1,
                                 long op2)

    - #### xor

          public static long xor(long op1,
                                 byte op2)

    - #### xor

          public static long xor(long op1,
                                 short op2)

    - #### xor

          public static long xor(long op1,
                                 int op2)

    - #### xor

          public static long xor(long op1,
                                 long op2)

    - #### intdiv

          public static int intdiv(byte op1,
                                   byte op2)

    - #### intdiv

          public static int intdiv(byte op1,
                                   short op2)

    - #### intdiv

          public static int intdiv(byte op1,
                                   int op2)

    - #### intdiv

          public static long intdiv(byte op1,
                                    long op2)

    - #### intdiv

          public static int intdiv(short op1,
                                   byte op2)

    - #### intdiv

          public static int intdiv(short op1,
                                   short op2)

    - #### intdiv

          public static int intdiv(short op1,
                                   int op2)

    - #### intdiv

          public static long intdiv(short op1,
                                    long op2)

    - #### intdiv

          public static int intdiv(int op1,
                                   byte op2)

    - #### intdiv

          public static int intdiv(int op1,
                                   short op2)

    - #### intdiv

          public static int intdiv(int op1,
                                   int op2)

    - #### intdiv

          public static long intdiv(int op1,
                                    long op2)

    - #### intdiv

          public static long intdiv(long op1,
                                    byte op2)

    - #### intdiv

          public static long intdiv(long op1,
                                    short op2)

    - #### intdiv

          public static long intdiv(long op1,
                                    int op2)

    - #### intdiv

          public static long intdiv(long op1,
                                    long op2)

    - #### mod

          public static int mod(byte op1,
                                byte op2)

    - #### mod

          public static int mod(byte op1,
                                short op2)

    - #### mod

          public static int mod(byte op1,
                                int op2)

    - #### mod

          public static long mod(byte op1,
                                 long op2)

    - #### mod

          public static int mod(short op1,
                                byte op2)

    - #### mod

          public static int mod(short op1,
                                short op2)

    - #### mod

          public static int mod(short op1,
                                int op2)

    - #### mod

          public static long mod(short op1,
                                 long op2)

    - #### mod

          public static int mod(int op1,
                                byte op2)

    - #### mod

          public static int mod(int op1,
                                short op2)

    - #### mod

          public static int mod(int op1,
                                int op2)

    - #### mod

          public static long mod(int op1,
                                 long op2)

    - #### mod

          public static long mod(long op1,
                                 byte op2)

    - #### mod

          public static long mod(long op1,
                                 short op2)

    - #### mod

          public static long mod(long op1,
                                 int op2)

    - #### mod

          public static long mod(long op1,
                                 long op2)

    - #### leftShift

          public static int leftShift(byte op1,
                                      byte op2)

    - #### leftShift

          public static int leftShift(byte op1,
                                      short op2)

    - #### leftShift

          public static int leftShift(byte op1,
                                      int op2)

    - #### leftShift

          public static long leftShift(byte op1,
                                       long op2)

    - #### leftShift

          public static int leftShift(short op1,
                                      byte op2)

    - #### leftShift

          public static int leftShift(short op1,
                                      short op2)

    - #### leftShift

          public static int leftShift(short op1,
                                      int op2)

    - #### leftShift

          public static long leftShift(short op1,
                                       long op2)

    - #### leftShift

          public static int leftShift(int op1,
                                      byte op2)

    - #### leftShift

          public static int leftShift(int op1,
                                      short op2)

    - #### leftShift

          public static int leftShift(int op1,
                                      int op2)

    - #### leftShift

          public static long leftShift(int op1,
                                       long op2)

    - #### leftShift

          public static long leftShift(long op1,
                                       byte op2)

    - #### leftShift

          public static long leftShift(long op1,
                                       short op2)

    - #### leftShift

          public static long leftShift(long op1,
                                       int op2)

    - #### leftShift

          public static long leftShift(long op1,
                                       long op2)

    - #### rightShift

          public static int rightShift(byte op1,
                                       byte op2)

    - #### rightShift

          public static int rightShift(byte op1,
                                       short op2)

    - #### rightShift

          public static int rightShift(byte op1,
                                       int op2)

    - #### rightShift

          public static long rightShift(byte op1,
                                        long op2)

    - #### rightShift

          public static int rightShift(short op1,
                                       byte op2)

    - #### rightShift

          public static int rightShift(short op1,
                                       short op2)

    - #### rightShift

          public static int rightShift(short op1,
                                       int op2)

    - #### rightShift

          public static long rightShift(short op1,
                                        long op2)

    - #### rightShift

          public static int rightShift(int op1,
                                       byte op2)

    - #### rightShift

          public static int rightShift(int op1,
                                       short op2)

    - #### rightShift

          public static int rightShift(int op1,
                                       int op2)

    - #### rightShift

          public static long rightShift(int op1,
                                        long op2)

    - #### rightShift

          public static long rightShift(long op1,
                                        byte op2)

    - #### rightShift

          public static long rightShift(long op1,
                                        short op2)

    - #### rightShift

          public static long rightShift(long op1,
                                        int op2)

    - #### rightShift

          public static long rightShift(long op1,
                                        long op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(byte op1,
                                               byte op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(byte op1,
                                               short op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(byte op1,
                                               int op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(byte op1,
                                                long op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(short op1,
                                               byte op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(short op1,
                                               short op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(short op1,
                                               int op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(short op1,
                                                long op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(int op1,
                                               byte op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(int op1,
                                               short op2)

    - #### rightShiftUnsigned

          public static int rightShiftUnsigned(int op1,
                                               int op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(int op1,
                                                long op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(long op1,
                                                byte op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(long op1,
                                                short op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(long op1,
                                                int op2)

    - #### rightShiftUnsigned

          public static long rightShiftUnsigned(long op1,
                                                long op2)