// Generated by Java* Fuzzer test generator (1.0.001). Sun Nov 13 01:05:49 2022
public class Test {

    public static final int N = 400;

    public static long instanceCount=-46772L;
    public static volatile byte byFld=82;
    public volatile boolean bFld=false;
    public static float fFld=-24.842F;
    public static long lArrFld[][]=new long[N][N];
    public static byte byArrFld[]=new byte[N];

    static {
        FuzzerUtils.init(Test.lArrFld, -2339645201000428571L);
        FuzzerUtils.init(Test.byArrFld, (byte)-4);
    }

    public static long iMeth_check_sum = 0;
    public static long vMeth_check_sum = 0;
    public static long iMeth1_check_sum = 0;

    public static int iMeth1() {

        int i5=-149, i6=104, i8=11;
        long l1=-1902956491953737938L;
        float f1=1.107F;

        for (i5 = 1; 142 > i5; ++i5) {
            int i7=10;
            Test.lArrFld = Test.lArrFld;
            i6 *= (int)Test.instanceCount;
            i6 += i5;
            Test.instanceCount -= i7;
            i7 += i5;
            for (l1 = i5; l1 < 11; l1++) {
                f1 *= Test.byFld;
                if (i8 != 0) {
                }
                i8 -= i8;
                Test.instanceCount = i5;
                i7 += i6;
                f1 += 4;
            }
            i6 = (int)f1;
            i8 += (i5 ^ i8);
        }
        long meth_res = i5 + i6 + l1 + i8 + Float.floatToIntBits(f1);
        iMeth1_check_sum += meth_res;
        return (int)meth_res;
    }

    public static void vMeth(boolean b, boolean b1) {

        int i2=-198, i3=4435, i9=-36417, i10=59, i11=9, iArr1[]=new int[N];
        short s=-5343;
        float f2=15.538F;

        FuzzerUtils.init(iArr1, 11);

        i2 += (i2--);
        i3 = 1;
        do {
            b = (b1 || ((i2 = (int)Test.instanceCount) < (s + i2)));
            Test.instanceCount += (Test.instanceCount--);
            Test.instanceCount <<= iMeth1();
            if (b1) {
                i2 &= (int)Test.instanceCount;
                for (i9 = 1; i9 < 7; ++i9) {
                    i10 = i2;
                }
                switch ((i3 % 1) + 9) {
                case 9:
                    i11 = 1;
                    do {
                        f2 = f2;
                        f2 = Test.instanceCount;
                        i10 &= i11;
                        i2 += i11;
                    } while (++i11 < 7);
                    break;
                default:
                    s += (short)(((i3 * i2) + i11) - i10);
                }
            } else if (b) {
                f2 += i3;
            }
        } while (++i3 < 225);
        vMeth_check_sum += (b ? 1 : 0) + (b1 ? 1 : 0) + i2 + i3 + s + i9 + i10 + i11 + Float.floatToIntBits(f2) +
            FuzzerUtils.checkSum(iArr1);
    }

    public int iMeth() {

        long l=-4L;
        int i1=-206, i12=-65145, i13=-79, i14=32, i15=9, iArr[]=new int[N];
        float f=15.40F;
        double d=1.85704;

        FuzzerUtils.init(iArr, 52971);

        for (l = 5; l < 281; ++l) {
            iArr[(int)(l)] = (int)((Integer.reverseBytes(i1) + (Test.byFld + 4)) * (-f));
            vMeth(bFld, bFld);
            i12 = 1;
            do {
                i1 -= (int)l;
                for (i13 = (int)(l); i13 < 1; ++i13) {
                    i1 %= 27192;
                    f -= i15;
                    Test.instanceCount = l;
                    iArr[(int)(l - 1)] = i12;
                }
            } while (++i12 < 6);
            i1 += (int)(l ^ i15);
            d = i14;
            if (bFld) continue;
            i14 += (int)(((l * i1) + f) - l);
            iArr = FuzzerUtils.int1array(N, (int)-11);
        }
        long meth_res = l + i1 + Float.floatToIntBits(f) + i12 + i13 + i14 + i15 + Double.doubleToLongBits(d) +
            FuzzerUtils.checkSum(iArr);
        iMeth_check_sum += meth_res;
        return (int)meth_res;
    }

    public void mainTest(String[] strArr1) {

        int i=-29313, i16=-11, i17=43456, i18=-2, i19=33314, i20=-33542, iArr2[]=new int[N];
        long l2=-6L;
        float fArr[]=new float[N];

        FuzzerUtils.init(fArr, -2.457F);
        FuzzerUtils.init(iArr2, -33102);

        i = (iMeth() - -71);
        i16 = 1;
        do {
            fArr[i16 + 1] -= i;
            i -= i16;
            Test.instanceCount = i16;
            i ^= (int)Test.instanceCount;
        } while (++i16 < 130);
        for (l2 = 9; 300 > l2; l2++) {
            switch ((int)((l2 % 1) + 113)) {
            case 113:
                if (bFld) {
                    for (i18 = 86; i18 > l2; i18--) {
                        i17 -= i17;
                        i17 = 8;
                        i19 &= i19;
                        i20 = 1;
                        while (++i20 < 1) {
                            float f3=126.257F;
                            i17 = 27050;
                            i19 <<= i16;
                            Test.instanceCount += i16;
                            iArr2[i20 + 1] -= 8;
                            switch (((i >>> 1) % 6) + 76) {
                            case 76:
                                i17 += i19;
                                break;
                            case 77:
                                iArr2[(int)(l2 - 1)] = i18;
                                break;
                            case 78:
                                i17 += (((i20 * i) + l2) - i);
                                break;
                            case 79:
                                i19 -= (int)l2;
                                break;
                            case 80:
                                i ^= (int)Test.instanceCount;
                                i >>= (int)Test.instanceCount;
                                fArr[i18] = i16;
                                iArr2[i18] = (int)l2;
                                break;
                            case 81:
                                f3 += i16;
                                break;
                            }
                            Test.instanceCount -= (long)f3;
                            i19 += i20;
                        }
                    }
                } else if (bFld) {
                    Test.fFld = i20;
                } else if (true) {
                    Test.byArrFld[(int)(l2 - 1)] = (byte)i17;
                }
                break;
            }
        }

        FuzzerUtils.out.println("i i16 l2 = " + i + "," + i16 + "," + l2);
        FuzzerUtils.out.println("i17 i18 i19 = " + i17 + "," + i18 + "," + i19);
        FuzzerUtils.out.println("i20 fArr iArr2 = " + i20 + "," + Double.doubleToLongBits(FuzzerUtils.checkSum(fArr)) +
            "," + FuzzerUtils.checkSum(iArr2));

        FuzzerUtils.out.println("Test.instanceCount Test.byFld bFld = " + Test.instanceCount + "," + Test.byFld + "," +
            (bFld ? 1 : 0));
        FuzzerUtils.out.println("Test.fFld Test.lArrFld Test.byArrFld = " + Float.floatToIntBits(Test.fFld) + "," +
            FuzzerUtils.checkSum(Test.lArrFld) + "," + FuzzerUtils.checkSum(Test.byArrFld));

        FuzzerUtils.out.println("iMeth1_check_sum: " + iMeth1_check_sum);
        FuzzerUtils.out.println("vMeth_check_sum: " + vMeth_check_sum);
        FuzzerUtils.out.println("iMeth_check_sum: " + iMeth_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());
         }
    }
}
///////////////////////////////////////////////////////////////////////
//DEBUG  Test ->  Test
//DEBUG  main ->  main
//DEBUG  mainTest ->  mainTest
//DEBUG  iMeth ->  iMeth mainTest
//DEBUG  vMeth ->  vMeth iMeth mainTest
//DEBUG  iMeth1 ->  iMeth1 vMeth iMeth mainTest
//DEBUG  Depth = 3
//DEBUG  Classes = 1
//DEBUG  static objects = {}