public class Test {

    public static final int N = 400;

    public static long instanceCount=13L;
    public int iFld=-152;
    public static int iFld1=34446;
    public static boolean bFld=false;
    public volatile double dFld=-1.3764;

    public static long dMeth_check_sum = 0;
    public static long vMeth_check_sum = 0;
    public static long lMeth_check_sum = 0;

    public static long lMeth() {


        Test.iFld1 = Test.iFld1;
        long meth_res = 0;
        lMeth_check_sum += meth_res;
        return (long)meth_res;
    }

    public static void vMeth(int i1) {

        int i2=-4, i3=39613, i4=-21170, iArr1[][]=new int[N][N];
        double d=-1.68386;
        float f=-1.753F;
        boolean b=false;
        long lArr[]=new long[N];

        FuzzerUtils.init(iArr1, 181);
        FuzzerUtils.init(lArr, -12L);

        for (i2 = 372; i2 > 12; i2 -= 2) {
            iArr1[i2][i2] |= (int)(++lArr[i2 + 1]);
            Test.instanceCount += (((i2 & -59627) * (Test.instanceCount * i2)) - (-lMeth()));
            i4 = 1;
            while ((i4 += 3) < 9) {
                d -= Test.iFld1;
                Test.iFld1 += (((i4 * Test.iFld1) + f) - Test.instanceCount);
                f += Test.iFld1;
                d -= i1;
                i1 = i4;
                i3 <<= -3;
                i3 += i4;
            }
            if (b) {
                Test.iFld1 += (int)d;
                d += Test.iFld1;
                iArr1[i2] = iArr1[i2];
            } else {
                f += (((i2 * f) + Test.instanceCount) - i1);
            }
        }
        vMeth_check_sum += i1 + i2 + i3 + i4 + Double.doubleToLongBits(d) + Float.floatToIntBits(f) + (b ? 1 : 0) +
            FuzzerUtils.checkSum(iArr1) + FuzzerUtils.checkSum(lArr);
    }

    public static double dMeth(long l, int i) {

        int i5=12, i6=-54771, i7=-62730, i8=-154, i9=-14, iArr[][]=new int[N][N];
        boolean b1=true;

        FuzzerUtils.init(iArr, 14);

        iArr[(i >>> 1) % N][(i >>> 1) % N] /= (int)(((Test.instanceCount = (12 + (l - i))) << l) | 1);
        vMeth(i);
        Test.instanceCount += -205;
        iArr[(-1 >>> 1) % N][(-58876 >>> 1) % N] = -43;
        for (i5 = 13; i5 < 233; ++i5) {
            float f1=-77.312F;
            if (b1) {
                if (b1) {
                    f1 += i6;
                    l += l;
                } else {
                    for (i7 = 1; i7 < 7; ++i7) {
                        i >>>= 3569;
                        try {
                            Test.iFld1 = (3414 / i8);
                            i9 = (i8 % i8);
                            Test.iFld1 = (23433 / i);
                        } catch (ArithmeticException a_e) {}
                        l &= -51;
                    }
                }
                Test.iFld1 = i9;
                f1 = i8;
            }
        }
        long meth_res = l + i + i5 + i6 + (b1 ? 1 : 0) + i7 + i8 + i9 + FuzzerUtils.checkSum(iArr);
        dMeth_check_sum += meth_res;
        return (double)meth_res;
    }

    public void mainTest(String[] strArr1) {

        long l1=-458141585L;
        int i10=-53, i11=251, i12=242, i14=-8, i15=0, i16=-11869, i17=-9304, i18=23654, i19=-208, iArr2[]=new int[N],
            iArr3[]=new int[N];
        byte by=-88;
        short sArr[]=new short[N];
        float fArr[][]=new float[N][N];

        FuzzerUtils.init(sArr, (short)-32705);
        FuzzerUtils.init(iArr2, -38615);
        FuzzerUtils.init(fArr, 1.409F);
        FuzzerUtils.init(iArr3, 0);

        sArr[(iFld >>> 1) % N] = (short)((iFld++) + dMeth(-14L, 24));
        Test.bFld = true;
        for (l1 = 7; l1 < 328; ++l1) {
            iArr2[(int)(l1 - 1)] >>= Test.iFld1;
        }
        Test.iFld1 = Test.iFld1;
        for (i11 = 15; i11 < 342; i11++) {
            i10 = (int)dFld;
        }
        if (Test.bFld) {
            iFld += i10;
            for (int i13 : iArr2) {
                float f2=-20.464F;
                switch ((((iFld >>> 1) % 7) * 5) + 40) {
                case 69:
                case 46:
                case 65:
                    i12 >>= iFld;
                    for (i14 = 3; i14 < 63; i14++) {
                        fArr[i14] = fArr[i14 + 1];
                        i12 += (int)(8.184F + (i14 * i14));
                    }
                    Test.instanceCount *= i13;
                    break;
                case 47:
                case 55:
                    for (i16 = 1; i16 < 63; ++i16) {
                        Test.iFld1 /= 88;
                        switch ((i16 % 2) + 98) {
                        case 98:
                            for (i18 = 1; i18 < 2; i18++) {
                                Test.instanceCount = i17;
                                Test.instanceCount = i17;
                                iArr2[i16 + 1] <<= i16;
                                by -= (byte)-102;
                                Test.instanceCount += Test.instanceCount;
                                i19 = i13;
                                switch (((i16 % 1) * 5) + 2) {
                                case 6:
                                default:
                                    i10 = 3;
                                    Test.instanceCount = iFld;
                                    Test.instanceCount = i13;
                                }
                            }
                        case 99:
                            iArr2[i16] >>>= i18;
                            break;
                        }
                    }
                    break;
                case 53:
                    i17 = (int)f2;
                    break;
                case 71:
                    iArr3[(i10 >>> 1) % N] = 31722;
                    break;
                }
            }
        }

        FuzzerUtils.out.println("l1 i10 i11 = " + l1 + "," + i10 + "," + i11);
        FuzzerUtils.out.println("i12 i14 i15 = " + i12 + "," + i14 + "," + i15);
        FuzzerUtils.out.println("i16 i17 i18 = " + i16 + "," + i17 + "," + i18);
        FuzzerUtils.out.println("i19 by sArr = " + i19 + "," + by + "," + FuzzerUtils.checkSum(sArr));
        FuzzerUtils.out.println("iArr2 fArr iArr3 = " + FuzzerUtils.checkSum(iArr2) + "," +
            Double.doubleToLongBits(FuzzerUtils.checkSum(fArr)) + "," + FuzzerUtils.checkSum(iArr3));
        FuzzerUtils.out.println("Test = " + Test.instanceCount);

        FuzzerUtils.out.println("Test.instanceCount iFld Test.iFld1 = " + Test.instanceCount + "," +
            iFld + "," + Test.iFld1);
        FuzzerUtils.out.println("Test.bFld dFld Test = " + (Test.bFld ? 1 : 0) + "," +
            Double.doubleToLongBits(dFld) + "," + Test.instanceCount);

        FuzzerUtils.out.println("lMeth_check_sum: " + lMeth_check_sum);
        FuzzerUtils.out.println("vMeth_check_sum: " + vMeth_check_sum);
        FuzzerUtils.out.println("dMeth_check_sum: " + dMeth_check_sum);
    }
    public static void main(String[] strArr) {

        try {
            Test _instance = new Test();
            for (int i = 0; i < 10; i++ ) {
                _instance.mainTest(strArr);
            }
         } catch (Exception ex) {
            FuzzerUtils.out.println(ex.getClass().getCanonicalName());
         }
    }
}