public class Test {

    public static final int N = 400;

    public static long instanceCount=-9L;
    public static int iFld=22806;
    public static volatile short sFld=599;
    public static float fFld=2.910F;
    public static byte byFld=28;

    public static long vMeth_check_sum = 0;
    public static long vMeth1_check_sum = 0;
    public static long vMeth2_check_sum = 0;

    public static void vMeth2() {

        boolean b1=false;
        long l=-1713258388L;
        int i8=-8, i9=-1, i10=-209, i11=3, i12=-234, i13=-24199, i14=-6, iArr1[]=new int[N];
        byte by1=-121;

        FuzzerUtils.init(iArr1, 121);

        b1 = b1;
        Test.iFld <<= (int)l;
        Test.iFld = (int)l;
        Test.iFld -= Test.iFld;
        switch (((Test.iFld >>> 1) % 7) + 9) {
        case 9:
        case 10:
            Test.instanceCount += 56982L;
        case 11:
            for (i8 = 171; i8 > 10; --i8) {
                for (i10 = 1; i10 < 10; ++i10) {
                    for (i12 = 1; 2 > i12; i12++) {
                        Test.fFld += i8;
                        try {
                            i13 = (iArr1[i12 + 1] % -7378);
                            i13 = (208715823 / i11);
                            Test.iFld = (i12 / iArr1[i12]);
                        } catch (ArithmeticException a_e) {}
                        Test.iFld += Test.iFld;
                        i9 += i12;
                        Test.iFld += (int)(-207L + (i12 * i12));
                        if (b1) break;
                    }
                }
            }
        case 12:
            Test.iFld >>= Test.iFld;
            break;
        case 13:
            l += i11;
        case 14:
            by1 &= by1;
            break;
        case 15:
            iArr1[(i14 >>> 1) % N] = (int)Test.fFld;
            break;
        }
        vMeth2_check_sum += (b1 ? 1 : 0) + l + i8 + i9 + i10 + i11 + i12 + i13 + by1 + i14 +
            FuzzerUtils.checkSum(iArr1);
    }

    public static void vMeth1(int i, int i1) {

        int i2=222, i3=-148, i4=-54963, i5=237, i6=-13, i7=-14, iArr[]=new int[N];
        byte by=60;
        boolean b=true;
        long l1=53412L;

        FuzzerUtils.init(iArr, 173);

        Test.instanceCount += (long)((-(Test.fFld - Test.instanceCount)) + Test.instanceCount);
        for (i2 = 2; i2 < 176; ++i2) {
            for (i4 = i2; i4 < 9; ++i4) {
                iArr[i4 - 1] *= Integer.reverseBytes(i - -41544);
                for (i6 = 1; i6 < 1; ++i6) {
                    switch (((i2 % 8) * 5) + 30) {
                    case 57:
                        i7 += i6;
                        i7 ^= (int)((Test.instanceCount &= i3) + ((Test.instanceCount - i5) + 31.34716));
                        Test.instanceCount += i6;
                        break;
                    case 61:
                        i5 += (((i6 * i5) + i2) - i4);
                        Test.instanceCount = by;
                        i1 -= i1;
                    case 66:
                        if ((b = (3 < (++Test.iFld))) && b) continue;
                        i1 += 27708;
                    case 34:
                        Test.sFld += (short)(i6 * Test.fFld);
                        break;
                    case 47:
                        Test.instanceCount >>= Test.instanceCount;
                    case 54:
                        vMeth2();
                        break;
                    case 59:
                        i5 >>= (int)l1;
                        break;
                    case 43:
                    }
                }
            }
        }
        vMeth1_check_sum += i + i1 + i2 + i3 + i4 + i5 + i6 + i7 + by + (b ? 1 : 0) + l1 + FuzzerUtils.checkSum(iArr);
    }

    public static void vMeth() {

        int i15=-59402, i16=-8;

        Test.sFld -= (short)Test.iFld;
        vMeth1(Test.iFld, Test.iFld);
        for (i15 = 18; i15 < 364; ++i15) {
            i16 = (int)Test.instanceCount;
        }
        vMeth_check_sum += i15 + i16;
    }

    public void mainTest(String[] strArr1) {

        short s=24357;
        int i17=63, i18=14, i19=-158, i20=-9, i21=142, i22=-5, i23=193, i24=-47, i25=9, i26=11, iArr2[]=new int[N];
        boolean b2=false;
        double d=21.49084, d1=-81.49133;
        long lArr[]=new long[N], lArr1[]=new long[N];

        FuzzerUtils.init(lArr, -217L);
        FuzzerUtils.init(lArr1, -430584428L);
        FuzzerUtils.init(iArr2, 38534);

        Test.iFld = (int)((lArr[(-52662 >>> 1) % N]--) * s);
        vMeth();
        lArr = lArr1;
        for (i17 = 6; i17 < 252; ++i17) {
            for (i19 = 3; i19 < 102; ++i19) {
                try {
                    i20 = (Test.iFld % Test.iFld);
                    Test.iFld = (iArr2[i19] % -48);
                    i20 = (32 % iArr2[i17]);
                } catch (ArithmeticException a_e) {}
                for (i21 = i17; i21 < 2; i21++) {
                    if (b2) {
                        iArr2[i21] = 117;
                    } else {
                        Test.iFld += (i21 * i21);
                        Test.sFld = (short)i18;
                        iArr2[i21 - 1] += s;
                    }
                    d *= 13;
                    iArr2[i17 - 1] <<= i17;
                    Test.iFld = 14;
                    if (b2) continue;
                }
                Test.instanceCount = i18;
                i22 = i17;
            }
            i20 += (i17 | i21);
            for (i23 = 4; i23 < 102; ++i23) {
                i25 = Test.byFld;
                i25 += i21;
                i25 += (int)Test.instanceCount;
                i24 = i25;
                i22 += (-196 + (i23 * i23));
                for (d1 = i23; d1 < 2; d1++) {
                    try {
                        i25 = (103 / i18);
                        iArr2[i23] = (i18 / -238);
                        i25 = (iArr2[i23] % i25);
                    } catch (ArithmeticException a_e) {}
                    i25 += i24;
                    Test.instanceCount += Test.sFld;
                    if (b2) break;
                }
            }
        }

        FuzzerUtils.out.println("s i17 i18 = " + s + "," + i17 + "," + i18);
        FuzzerUtils.out.println("i19 i20 i21 = " + i19 + "," + i20 + "," + i21);
        FuzzerUtils.out.println("i22 b2 d = " + i22 + "," + (b2 ? 1 : 0) + "," + Double.doubleToLongBits(d));
        FuzzerUtils.out.println("i23 i24 i25 = " + i23 + "," + i24 + "," + i25);
        FuzzerUtils.out.println("d1 i26 lArr = " + Double.doubleToLongBits(d1) + "," + i26 + "," +
            FuzzerUtils.checkSum(lArr));
        FuzzerUtils.out.println("lArr1 iArr2 Test = " + FuzzerUtils.checkSum(lArr1) + "," +
            FuzzerUtils.checkSum(iArr2) + "," + Test.instanceCount);

        FuzzerUtils.out.println("Test.instanceCount Test.iFld Test.sFld = " + Test.instanceCount +
            "," + Test.iFld + "," + Test.sFld);
        FuzzerUtils.out.println("Test.fFld Test.byFld Test = " + Float.floatToIntBits(Test.fFld) +
            "," + Test.byFld + "," + Test.instanceCount);

        FuzzerUtils.out.println("vMeth2_check_sum: " + vMeth2_check_sum);
        FuzzerUtils.out.println("vMeth1_check_sum: " + vMeth1_check_sum);
        FuzzerUtils.out.println("vMeth_check_sum: " + vMeth_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());
         }
    }
}