package gc;

import java.util.Arrays;
import ob.g;
import tb.b;

/* JADX INFO: loaded from: classes.dex */
public abstract class a {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final int[] f26335a = {0, 4, 1, 5};

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final int[] f26336b = {6, 2, 7, 3};

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final int[] f26337c = {8, 1, 1, 1, 1, 1, 1, 3};

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final int[] f26338d = {7, 1, 1, 3, 1, 1, 1, 2, 1};

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public static final int[] f26339e = {0, 180, 270, 90};

    public static int[] a(b bVar, int i10, int i11, int i12, int[] iArr, int[] iArr2) {
        Arrays.fill(iArr2, 0, iArr2.length, 0);
        int i13 = 0;
        while (bVar.b(i10, i11) && i10 > 0) {
            int i14 = i13 + 1;
            if (i13 >= 3) {
                break;
            }
            i10--;
            i13 = i14;
        }
        int length = iArr.length;
        int i15 = i10;
        int i16 = 0;
        boolean z10 = false;
        while (i10 < i12) {
            if (bVar.b(i10, i11) != z10) {
                iArr2[i16] = iArr2[i16] + 1;
            } else {
                if (i16 != length - 1) {
                    i16++;
                } else {
                    if (c(iArr2, iArr) < 0.42f) {
                        return new int[]{i15, i10};
                    }
                    i15 += iArr2[0] + iArr2[1];
                    int i17 = i16 - 1;
                    System.arraycopy(iArr2, 2, iArr2, 0, i17);
                    iArr2[i17] = 0;
                    iArr2[i16] = 0;
                    i16--;
                }
                iArr2[i16] = 1;
                z10 = !z10;
            }
            i10++;
        }
        if (i16 != length - 1 || c(iArr2, iArr) >= 0.42f) {
            return null;
        }
        return new int[]{i15, i10 - 1};
    }

    public static g[] b(b bVar, int i10, int i11, int i12, int i13, int i14, int[] iArr) {
        boolean z10;
        g[] gVarArr = new g[4];
        int[] iArr2 = new int[iArr.length];
        int i15 = i12;
        while (true) {
            if (i15 >= i10) {
                z10 = false;
                break;
            }
            int[] iArrA = a(bVar, i13, i15, i11, iArr, iArr2);
            if (iArrA != null) {
                int i16 = i15;
                int[] iArr3 = iArrA;
                while (i16 > 0) {
                    int i17 = i16 - 1;
                    int[] iArrA2 = a(bVar, i13, i17, i11, iArr, iArr2);
                    if (iArrA2 == null) {
                        break;
                    }
                    iArr3 = iArrA2;
                    i16 = i17;
                }
                float f10 = i16;
                gVarArr[0] = new g(iArr3[0], f10);
                gVarArr[1] = new g(iArr3[1], f10);
                z10 = true;
                i15 = i16;
            } else {
                i15 += 5;
            }
        }
        int i18 = i15 + 1;
        if (z10) {
            int[] iArr4 = {(int) gVarArr[0].f31472a, (int) gVarArr[1].f31472a};
            int i19 = i18;
            int i20 = 0;
            while (i19 < i10) {
                int[] iArrA3 = a(bVar, iArr4[0], i19, i11, iArr, iArr2);
                if (iArrA3 != null && Math.abs(iArr4[0] - iArrA3[0]) < 5 && Math.abs(iArr4[1] - iArrA3[1]) < 5) {
                    iArr4 = iArrA3;
                    i20 = 0;
                } else {
                    if (i20 > 25) {
                        break;
                    }
                    i20++;
                }
                i19++;
            }
            i18 = i19 - (i20 + 1);
            float f11 = i18;
            gVarArr[2] = new g(iArr4[0], f11);
            gVarArr[3] = new g(iArr4[1], f11);
        }
        if (i18 - i15 < i14) {
            Arrays.fill(gVarArr, (Object) null);
        }
        return gVarArr;
    }

    public static float c(int[] iArr, int[] iArr2) {
        int length = iArr.length;
        int i10 = 0;
        int i11 = 0;
        for (int i12 = 0; i12 < length; i12++) {
            i10 += iArr[i12];
            i11 += iArr2[i12];
        }
        if (i10 < i11) {
            return Float.POSITIVE_INFINITY;
        }
        float f10 = i10;
        float f11 = f10 / i11;
        float f12 = 0.8f * f11;
        float f13 = 0.0f;
        for (int i13 = 0; i13 < length; i13++) {
            float f14 = iArr2[i13] * f11;
            float f15 = iArr[i13];
            float f16 = f15 > f14 ? f15 - f14 : f14 - f15;
            if (f16 > f12) {
                return Float.POSITIVE_INFINITY;
            }
            f13 += f16;
        }
        return f13 / f10;
    }
}