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
`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
`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)