// Generated by Java* Fuzzer test generator (1.0.001). Tue Oct 15 19:36:21 2024
// Use '-Dtest_generator_rng_seed=53726329254166855054235693276701781937 to re-generate the same test code
public class Test {

    public static final int N = 400;

    public static long instanceCount=528L;
    public static double dFld=2.71829;
    public static int iFld=-168;
    public float fFld=0.107F;
    public static double dFld1=0.127514;
    public byte byArrFld[]=new byte[N];

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

    public static float fMeth(long l1) {

        int i3=18240, i4=12, i5=232;
        float f=-2.872F;
        boolean b=true;
        byte byArr[]=new byte[N];

        FuzzerUtils.init(byArr, (byte)-113);

        i3 = 1;
        do {
            switch (((i3 % 5) * 5) + 93) {
            case 114:
                Test.dFld -= i3;
                break;
            case 106:
                switch ((i3 % 3) + 40) {
                case 40:
                    for (i4 = 1; i4 < 9; ++i4) {
                        if (b) {
                            l1 += i4;
                            Test.dFld += i4;
                            i5 ^= i3;
                        } else if (true) {
                            i5 += (i4 | (long)f);
                            i5 += (int)Test.dFld;
                            Test.dFld += Test.instanceCount;
                        } else {
                            Test.dFld += i5;
                            i5 += (int)-83.983F;
                        }
                        i5 += (i4 ^ i4);
                    }
                case 41:
                    Test.dFld *= f;
                case 42:
                    byArr = byArr;
                    break;
                default:
                    i5 /= (int)(i3 | 1);
                }
                break;
            case 102:
                i5 = i5;
            case 96:
            case 113:
                i5 = i4;
                break;
            default:
                Test.dFld = i3;
            }
        } while (++i3 < 178);
        long meth_res = l1 + i3 + i4 + i5 + Float.floatToIntBits(f) + (b ? 1 : 0) + FuzzerUtils.checkSum(byArr);
        fMeth_check_sum += meth_res;
        return (float)meth_res;
    }

    public static int iMeth(int i2) {

        short s=18772;
        int i6=-10683, i7=-552, i8=7, i9=4069, i10=16, iArr[]=new int[N];
        double dArr[]=new double[N];
        float fArr[]=new float[N];

        FuzzerUtils.init(dArr, -1.94773);
        FuzzerUtils.init(fArr, -118.511F);
        FuzzerUtils.init(iArr, 58480);

        i2 *= (int)((Math.max(i2, i2) - (i2 - s)) * fMeth(-3850037967L));
        for (i6 = 4; i6 < 282; ++i6) {
            dArr[i6 - 1] += i2;
            switch (((i6 % 1) * 5) + 30) {
            case 32:
                fArr[i6 - 1] *= i7;
                break;
            }
            i7 += i7;
            Test.instanceCount = Test.instanceCount;
            i8 = 1;
            while (++i8 < 6) {
                i2 = i7;
                i2 = (int)Test.instanceCount;
                iArr[i6] *= i8;
                i9 = 1;
                do {
                    i10 |= s;
                } while (++i9 < 1);
                i7 -= i10;
                Test.instanceCount += (((i8 * i6) + i8) - Test.instanceCount);
            }
        }
        long meth_res = i2 + s + i6 + i7 + i8 + i9 + i10 + Double.doubleToLongBits(FuzzerUtils.checkSum(dArr)) +
            Double.doubleToLongBits(FuzzerUtils.checkSum(fArr)) + FuzzerUtils.checkSum(iArr);
        iMeth_check_sum += meth_res;
        return (int)meth_res;
    }

    public static void vMeth(long l, int i, int i1) {

        int i11=734, i12=7124, iArr1[]=new int[N];

        FuzzerUtils.init(iArr1, -2);

        l = (iMeth(i1) * i1);
        iArr1 = iArr1;
        for (i11 = 3; i11 < 141; ++i11) {
            i1 += (((i11 * l) + i11) - i1);
        }
        vMeth_check_sum += l + i + i1 + i11 + i12 + FuzzerUtils.checkSum(iArr1);
    }

    public void mainTest(String[] strArr1) {

        boolean b1=true;
        float f1=39.333F, fArr1[][]=new float[N][N];
        int i13=2, i14=160, i15=-64119, i16=0, i17=60279, i18=4, iArr2[][]=new int[N][N];
        byte by=93;
        short s1=-1916;
        long lArr[][]=new long[N][N];

        FuzzerUtils.init(fArr1, 120.661F);
        FuzzerUtils.init(lArr, 1183220109639952741L);
        FuzzerUtils.init(iArr2, -100);

        vMeth(Test.instanceCount, Test.iFld, -2);
        b1 = b1;
        for (f1 = 282; 9 < f1; f1 -= 3) {
            Test.instanceCount >>= i13;
            fArr1 = fArr1;
            i13 = i13;
            Test.instanceCount = (long)Test.dFld;
        }
        for (i14 = 5; i14 < 273; ++i14) {
            i15 = i13;
            i16 = 1;
            while (++i16 < 94) {
                lArr[i16 - 1][i16 - 1] %= ((long)(Test.dFld) | 1);
                switch ((((i14 >>> 1) % 10) * 5) + 14) {
                case 25:
                    i17 = 1;
                    do {
                        by += (byte)i13;
                        by += (byte)-3937403518L;
                        iArr2 = iArr2;
                        i13 *= i15;
                        switch (((i16 % 6) * 5) + 106) {
                        case 130:
                            s1 -= (short)5L;
                            Test.instanceCount += -82L;
                            break;
                        case 122:
                            if (b1) continue;
                            s1 += (short)(((i17 * s1) + Test.instanceCount) - Test.instanceCount);
                            i13 += (i17 | by);
                            i15 += (((i17 * i16) + i15) - Test.instanceCount);
                            break;
                        case 125:
                            switch ((i14 % 5) + 84) {
                            case 84:
                                fFld = -63.529F;
                                i13 += (i17 * i17);
                                if (b1) {
                                    i13 += (((i17 * i15) + i17) - Test.instanceCount);
                                    iArr2[i16 + 1][i17 - 1] *= i13;
                                } else if (b1) {
                                    i15 += (((i17 * i18) + i13) - i13);
                                }
                                break;
                            case 85:
                                lArr[i16][i17] = Test.iFld;
                            case 86:
                                s1 += (short)(i17 * i17);
                                break;
                            case 87:
                                Test.instanceCount += (long)Test.dFld1;
                            case 88:
                                fArr1[i16][i17 - 1] *= 16586;
                                break;
                            }
                            break;
                        case 119:
                            Test.instanceCount = i16;
                        case 116:
                            i18 = (int)Test.instanceCount;
                            break;
                        case 126:
                            i15 -= (int)Test.instanceCount;
                            break;
                        default:
                            s1 >>>= (short)i14;
                        }
                    } while (++i17 < 1);
                    break;
                case 16:
                    Test.iFld = -5;
                    break;
                case 27:
                    Test.iFld = Test.iFld;
                    break;
                case 43:
                    byArrFld[i16 + 1] = (byte)i17;
                case 41:
                    i18 = Test.iFld;
                    break;
                case 46:
                    Test.instanceCount += (i16 + Test.instanceCount);
                case 53:
                    i15 += i17;
                    break;
                case 28:
                    iArr2[i14][i14] *= i18;
                case 61:
                    Test.instanceCount = Test.instanceCount;
                    break;
                case 51:
                    fFld -= 13;
                    break;
                default:
                    Test.iFld += i16;
                }
            }
        }

        FuzzerUtils.out.println("b1 f1 i13 = " + (b1 ? 1 : 0) + "," + Float.floatToIntBits(f1) + "," + i13);
        FuzzerUtils.out.println("i14 i15 i16 = " + i14 + "," + i15 + "," + i16);
        FuzzerUtils.out.println("i17 by s1 = " + i17 + "," + by + "," + s1);
        FuzzerUtils.out.println("i18 fArr1 lArr = " + i18 + "," + Double.doubleToLongBits(FuzzerUtils.checkSum(fArr1))
            + "," + FuzzerUtils.checkSum(lArr));
        FuzzerUtils.out.println("iArr2 = " + FuzzerUtils.checkSum(iArr2));

        FuzzerUtils.out.println("Test.instanceCount Test.dFld Test.iFld = " + Test.instanceCount + "," +
            Double.doubleToLongBits(Test.dFld) + "," + Test.iFld);
        FuzzerUtils.out.println("fFld Test.dFld1 byArrFld = " + Float.floatToIntBits(fFld) + "," +
            Double.doubleToLongBits(Test.dFld1) + "," + FuzzerUtils.checkSum(byArrFld));

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