package io.netty.handler.codec.compression;

/* JADX INFO: loaded from: classes.dex */
final class Bzip2DivSufSort {
    private static final int BUCKET_A_SIZE = 256;
    private static final int BUCKET_B_SIZE = 65536;
    private static final int INSERTIONSORT_THRESHOLD = 8;
    private static final int[] LOG_2_TABLE = {-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
    private static final int SS_BLOCKSIZE = 1024;
    private static final int STACK_SIZE = 64;
    private final int[] SA;
    private final byte[] T;
    private final int n;

    private static class PartitionResult {
        final int first;
        final int last;

        PartitionResult(int i2, int i3) {
            this.first = i2;
            this.last = i3;
        }
    }

    private static class StackEntry {
        final int a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final int f4319b;

        /* JADX INFO: renamed from: c, reason: collision with root package name */
        final int f4320c;

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        final int f4321d;

        StackEntry(int i2, int i3, int i4, int i5) {
            this.a = i2;
            this.f4319b = i3;
            this.f4320c = i4;
            this.f4321d = i5;
        }
    }

    private static class TRBudget {
        int budget;
        int chance;

        TRBudget(int i2, int i3) {
            this.budget = i2;
            this.chance = i3;
        }

        boolean update(int i2, int i3) {
            int i4 = this.budget - i3;
            this.budget = i4;
            if (i4 <= 0) {
                int i5 = this.chance - 1;
                this.chance = i5;
                if (i5 == 0) {
                    return false;
                }
                this.budget = i4 + i2;
            }
            return true;
        }
    }

    Bzip2DivSufSort(byte[] bArr, int[] iArr, int i2) {
        this.T = bArr;
        this.SA = iArr;
        this.n = i2;
    }

    private static int BUCKET_B(int i2, int i3) {
        return i2 | (i3 << 8);
    }

    private static int BUCKET_BSTAR(int i2, int i3) {
        return (i2 << 8) | i3;
    }

    private int constructBWT(int[] iArr, int[] iArr2) {
        byte[] bArr = this.T;
        int[] iArr3 = this.SA;
        int i2 = this.n;
        int i3 = 254;
        int i4 = 0;
        int i5 = 0;
        while (i3 >= 0) {
            int i6 = i3 + 1;
            int i7 = iArr2[BUCKET_BSTAR(i3, i6)];
            int i8 = -1;
            int i9 = 0;
            for (int i10 = iArr[i6]; i7 <= i10; i10--) {
                int i11 = iArr3[i10];
                if (i11 >= 0) {
                    int i12 = i11 - 1;
                    if (i12 < 0) {
                        i12 = i2 - 1;
                    }
                    int i13 = bArr[i12] & 255;
                    if (i13 <= i3) {
                        iArr3[i10] = ~i11;
                        if (i12 > 0 && (bArr[i12 - 1] & 255) > i13) {
                            i12 = ~i12;
                        }
                        if (i8 == i13) {
                            i9--;
                            iArr3[i9] = i12;
                        } else {
                            if (i8 >= 0) {
                                iArr2[BUCKET_B(i8, i3)] = i9;
                            }
                            i9 = iArr2[BUCKET_B(i13, i3)] - 1;
                            iArr3[i9] = i12;
                            i8 = i13;
                        }
                    }
                } else {
                    iArr3[i10] = ~i11;
                }
            }
            i3--;
            i4 = i9;
            i5 = i8;
        }
        int i14 = -1;
        for (int i15 = 0; i15 < i2; i15++) {
            int i16 = iArr3[i15];
            if (i16 >= 0) {
                int i17 = i16 - 1;
                if (i17 < 0) {
                    i17 = i2 - 1;
                }
                int i18 = bArr[i17] & 255;
                if (i18 >= (bArr[i17 + 1] & 255)) {
                    if (i17 > 0 && (bArr[i17 - 1] & 255) < i18) {
                        i17 = ~i17;
                    }
                    if (i18 == i5) {
                        i4++;
                        iArr3[i4] = i17;
                    } else {
                        if (i5 != -1) {
                            iArr[i5] = i4;
                        }
                        i4 = iArr[i18] + 1;
                        iArr3[i4] = i17;
                        i5 = i18;
                    }
                }
            } else {
                i16 = ~i16;
            }
            if (i16 == 0) {
                iArr3[i15] = bArr[i2 - 1];
                i14 = i15;
            } else {
                iArr3[i15] = bArr[i16 - 1];
            }
        }
        return i14;
    }

    private static int getIDX(int i2) {
        return i2 >= 0 ? i2 : ~i2;
    }

    /* JADX WARN: Removed duplicated region for block: B:121:0x01be A[SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:122:0x0134 A[SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:59:0x0104  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:71:0x0128 -> B:56:0x00fc). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private void lsIntroSort(int r21, int r22, int r23, int r24, int r25) {
        /*
            Method dump skipped, instruction units count: 462
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.handler.codec.compression.Bzip2DivSufSort.lsIntroSort(int, int, int, int, int):void");
    }

    private void lsSort(int i2, int i3, int i4) {
        int i5;
        int[] iArr = this.SA;
        int i6 = i4 + i2;
        while (true) {
            int i7 = 0;
            if ((-i3) >= iArr[0]) {
                return;
            }
            int i8 = 0;
            int i9 = 0;
            do {
                int i10 = iArr[i9];
                if (i10 < 0) {
                    i9 -= i10;
                    i8 += i10;
                } else {
                    if (i8 != 0) {
                        iArr[i9 + i8] = i8;
                        i5 = 0;
                    } else {
                        i5 = i8;
                    }
                    int i11 = iArr[i10 + i2] + 1;
                    lsIntroSort(i2, i6, i2 + i3, i9, i11);
                    i8 = i5;
                    i9 = i11;
                }
            } while (i9 < i3);
            if (i8 != 0) {
                iArr[i9 + i8] = i8;
            }
            int i12 = i6 - i2;
            if (i3 < i12) {
                do {
                    int i13 = iArr[i7];
                    if (i13 < 0) {
                        i7 -= i13;
                    } else {
                        int i14 = iArr[i13 + i2] + 1;
                        while (i7 < i14) {
                            iArr[iArr[i7] + i2] = i7;
                            i7++;
                        }
                        i7 = i14;
                    }
                } while (i7 < i3);
                return;
            }
            i6 += i12;
        }
    }

    private void lsUpdateGroup(int i2, int i3, int i4) {
        int[] iArr = this.SA;
        while (i3 < i4) {
            if (iArr[i3] >= 0) {
                int i5 = i3;
                do {
                    iArr[iArr[i5] + i2] = i5;
                    i5++;
                    if (i5 >= i4) {
                        break;
                    }
                } while (iArr[i5] >= 0);
                iArr[i3] = i3 - i5;
                if (i4 <= i5) {
                    return;
                } else {
                    i3 = i5;
                }
            }
            int i6 = i3;
            do {
                iArr[i6] = ~iArr[i6];
                i6++;
            } while (iArr[i6] < 0);
            do {
                iArr[iArr[i3] + i2] = i6;
                i3++;
            } while (i3 <= i6);
            i3 = i6 + 1;
        }
    }

    private int sortTypeBstar(int[] iArr, int[] iArr2) {
        boolean z;
        int i2;
        boolean z2;
        int i3;
        int i4;
        int i5;
        int i6;
        int[] iArr3;
        int i7;
        int i8;
        int i9;
        int i10;
        int i11;
        int i12;
        int i13;
        int i14;
        byte[] bArr = this.T;
        int[] iArr4 = this.SA;
        int i15 = this.n;
        int[] iArr5 = new int[BUCKET_A_SIZE];
        int i16 = 1;
        while (true) {
            z = false;
            i2 = 255;
            if (i16 >= i15) {
                break;
            }
            int i17 = i16 - 1;
            if (bArr[i17] == bArr[i16]) {
                i16++;
            } else if ((bArr[i17] & 255) > (bArr[i16] & 255)) {
                z2 = false;
            }
        }
        z2 = true;
        int i18 = i15 - 1;
        int i19 = bArr[i18] & 255;
        int i20 = bArr[0] & 255;
        if (i19 < i20 || (bArr[i18] == bArr[0] && z2)) {
            if (z2) {
                int iBUCKET_B = BUCKET_B(i19, i20);
                iArr2[iBUCKET_B] = iArr2[iBUCKET_B] + 1;
                i3 = i15;
            } else {
                int iBUCKET_BSTAR = BUCKET_BSTAR(i19, i20);
                iArr2[iBUCKET_BSTAR] = iArr2[iBUCKET_BSTAR] + 1;
                i3 = i15 - 1;
                iArr4[i3] = i18;
            }
            i4 = i18 - 1;
            while (i4 >= 0) {
                int i21 = bArr[i4] & 255;
                int i22 = bArr[i4 + 1] & 255;
                if (i21 <= i22) {
                    int iBUCKET_B2 = BUCKET_B(i21, i22);
                    iArr2[iBUCKET_B2] = iArr2[iBUCKET_B2] + 1;
                    i4--;
                }
            }
        } else {
            i3 = i15;
            i4 = i18;
        }
        while (i4 >= 0) {
            do {
                int i23 = bArr[i4] & 255;
                iArr[i23] = iArr[i23] + 1;
                i4--;
                if (i4 < 0) {
                    break;
                }
            } while ((bArr[i4] & 255) >= (bArr[i4 + 1] & 255));
            if (i4 >= 0) {
                int iBUCKET_BSTAR2 = BUCKET_BSTAR(bArr[i4] & 255, bArr[i4 + 1] & 255);
                iArr2[iBUCKET_BSTAR2] = iArr2[iBUCKET_BSTAR2] + 1;
                i3--;
                iArr4[i3] = i4;
                while (true) {
                    i4--;
                    if (i4 < 0 || (i13 = bArr[i4] & 255) > (i14 = bArr[i4 + 1] & 255)) {
                        break;
                    }
                    int iBUCKET_B3 = BUCKET_B(i13, i14);
                    iArr2[iBUCKET_B3] = iArr2[iBUCKET_B3] + 1;
                }
            }
        }
        int i24 = i15 - i3;
        if (i24 == 0) {
            for (int i25 = 0; i25 < i15; i25++) {
                iArr4[i25] = i25;
            }
            return 0;
        }
        int i26 = 0;
        int i27 = 0;
        int i28 = -1;
        while (i26 < BUCKET_A_SIZE) {
            int i29 = iArr[i26] + i28;
            iArr[i26] = i28 + i27;
            int i30 = i29 + iArr2[BUCKET_B(i26, i26)];
            int i31 = i26 + 1;
            for (int i32 = i31; i32 < BUCKET_A_SIZE; i32++) {
                i27 += iArr2[BUCKET_BSTAR(i26, i32)];
                iArr2[(i26 << 8) | i32] = i27;
                i30 += iArr2[BUCKET_B(i26, i32)];
            }
            i26 = i31;
            i28 = i30;
        }
        int i33 = i15 - i24;
        for (int i34 = i24 - 2; i34 >= 0; i34--) {
            int i35 = iArr4[i33 + i34];
            int iBUCKET_BSTAR3 = BUCKET_BSTAR(bArr[i35] & 255, bArr[i35 + 1] & 255);
            int i36 = iArr2[iBUCKET_BSTAR3] - 1;
            iArr2[iBUCKET_BSTAR3] = i36;
            iArr4[i36] = i34;
        }
        int i37 = iArr4[(i33 + i24) - 1];
        int iBUCKET_BSTAR4 = BUCKET_BSTAR(bArr[i37] & 255, bArr[i37 + 1] & 255);
        int i38 = iArr2[iBUCKET_BSTAR4] - 1;
        iArr2[iBUCKET_BSTAR4] = i38;
        int i39 = i24 - 1;
        iArr4[i38] = i39;
        int i40 = i15 - (i24 * 2);
        if (i40 <= BUCKET_A_SIZE) {
            i5 = BUCKET_A_SIZE;
            iArr3 = iArr5;
            i6 = 0;
        } else {
            i5 = i40;
            i6 = i24;
            iArr3 = iArr4;
        }
        int i41 = i24;
        int i42 = 255;
        while (i41 > 0) {
            int i43 = i41;
            int i44 = i2;
            while (i42 < i44) {
                int i45 = iArr2[BUCKET_BSTAR(i42, i44)];
                if (1 < i43 - i45) {
                    boolean z3 = iArr4[i45] == i39 ? true : z;
                    i9 = i44;
                    i10 = i42;
                    i11 = i39;
                    i12 = i24;
                    subStringSort(i33, i45, i43, iArr3, i6, i5, 2, z3, i15);
                } else {
                    i9 = i44;
                    i10 = i42;
                    i11 = i39;
                    i12 = i24;
                }
                i44 = i9 - 1;
                i24 = i12;
                i43 = i45;
                i42 = i10;
                i39 = i11;
                z = false;
            }
            i42--;
            i41 = i43;
            i2 = 255;
            z = false;
        }
        int i46 = i39;
        int i47 = i24;
        while (i39 >= 0) {
            if (iArr4[i39] >= 0) {
                int i48 = i39;
                do {
                    iArr4[i47 + iArr4[i48]] = i48;
                    i48--;
                    if (i48 < 0) {
                        break;
                    }
                } while (iArr4[i48] >= 0);
                iArr4[i48 + 1] = i48 - i39;
                if (i48 <= 0) {
                    break;
                }
                i39 = i48;
            }
            int i49 = i39;
            do {
                int i50 = ~iArr4[i49];
                iArr4[i49] = i50;
                iArr4[i47 + i50] = i39;
                i49--;
            } while (iArr4[i49] < 0);
            iArr4[i47 + iArr4[i49]] = i39;
            i39 = i49 - 1;
        }
        trSort(i47, i47, 1);
        if ((bArr[i18] & 255) < (bArr[0] & 255) || (bArr[i18] == bArr[0] && z2)) {
            if (z2) {
                i7 = i47;
            } else {
                i7 = i47 - 1;
                iArr4[iArr4[i47 + i7]] = i18;
            }
            i8 = i18 - 1;
            while (i8 >= 0 && (bArr[i8] & 255) <= (bArr[i8 + 1] & 255)) {
                i8--;
            }
        } else {
            i7 = i47;
            i8 = i18;
        }
        while (i8 >= 0) {
            do {
                i8--;
                if (i8 < 0) {
                    break;
                }
            } while ((bArr[i8] & 255) >= (bArr[i8 + 1] & 255));
            if (i8 >= 0) {
                i7--;
                iArr4[iArr4[i47 + i7]] = i8;
                do {
                    i8--;
                    if (i8 >= 0) {
                    }
                } while ((bArr[i8] & 255) <= (bArr[i8 + 1] & 255));
            }
        }
        int i51 = i46;
        for (int i52 = 255; i52 >= 0; i52--) {
            for (int i53 = 255; i52 < i53; i53--) {
                int i54 = i18 - iArr2[BUCKET_B(i52, i53)];
                iArr2[BUCKET_B(i52, i53)] = i18 + 1;
                int i55 = iArr2[BUCKET_BSTAR(i52, i53)];
                i18 = i54;
                while (i55 <= i51) {
                    iArr4[i18] = iArr4[i51];
                    i18--;
                    i51--;
                }
            }
            int i56 = i18 - iArr2[BUCKET_B(i52, i52)];
            iArr2[BUCKET_B(i52, i52)] = i18 + 1;
            if (i52 < 255) {
                iArr2[BUCKET_BSTAR(i52, i52 + 1)] = i56 + 1;
            }
            i18 = iArr[i52];
        }
        return i47;
    }

    private static void ssBlockSwap(int[] iArr, int i2, int[] iArr2, int i3, int i4) {
        while (i4 > 0) {
            swapElements(iArr, i2, iArr2, i3);
            i4--;
            i2++;
            i3++;
        }
    }

    private int ssCompare(int i2, int i3, int i4) {
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i5 = iArr[i2 + 1] + 2;
        int i6 = iArr[i3 + 1] + 2;
        int i7 = iArr[i2] + i4;
        int i8 = i4 + iArr[i3];
        while (i7 < i5 && i8 < i6 && bArr[i7] == bArr[i8]) {
            i7++;
            i8++;
        }
        if (i7 >= i5) {
            return i8 < i6 ? -1 : 0;
        }
        if (i8 < i6) {
            return (bArr[i7] & 255) - (bArr[i8] & 255);
        }
        return 1;
    }

    private int ssCompareLast(int i2, int i3, int i4, int i5, int i6) {
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i7 = iArr[i3] + i5;
        int i8 = i5 + iArr[i4];
        int i9 = iArr[i4 + 1] + 2;
        while (i7 < i6 && i8 < i9 && bArr[i7] == bArr[i8]) {
            i7++;
            i8++;
        }
        if (i7 < i6) {
            if (i8 < i9) {
                return (bArr[i7] & 255) - (bArr[i8] & 255);
            }
            return 1;
        }
        if (i8 == i9) {
            return 1;
        }
        int i10 = i7 % i6;
        int i11 = iArr[i2] + 2;
        while (i10 < i11 && i8 < i9 && bArr[i10] == bArr[i8]) {
            i10++;
            i8++;
        }
        if (i10 >= i11) {
            return i8 < i9 ? -1 : 0;
        }
        if (i8 < i9) {
            return (bArr[i10] & 255) - (bArr[i8] & 255);
        }
        return 1;
    }

    private void ssFixdown(int i2, int i3, int i4, int i5, int i6) {
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i7 = iArr[i4 + i5];
        int i8 = bArr[iArr[i3 + i7] + i2] & 255;
        while (true) {
            int i9 = (i5 * 2) + 1;
            if (i9 >= i6) {
                break;
            }
            int i10 = i9 + 1;
            int i11 = bArr[iArr[iArr[i4 + i9] + i3] + i2] & 255;
            int i12 = bArr[iArr[iArr[i4 + i10] + i3] + i2] & 255;
            if (i11 < i12) {
                i9 = i10;
                i11 = i12;
            }
            if (i11 <= i8) {
                break;
            }
            iArr[i5 + i4] = iArr[i4 + i9];
            i5 = i9;
        }
        iArr[i4 + i5] = i7;
    }

    private void ssHeapSort(int i2, int i3, int i4, int i5) {
        int i6;
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i7 = i5 % 2;
        if (i7 == 0) {
            int i8 = i5 - 1;
            int i9 = (i8 / 2) + i4;
            int i10 = i4 + i8;
            if ((bArr[iArr[iArr[i9] + i3] + i2] & 255) < (bArr[iArr[iArr[i10] + i3] + i2] & 255)) {
                swapElements(iArr, i10, iArr, i9);
            }
            i6 = i8;
        } else {
            i6 = i5;
        }
        for (int i11 = (i6 / 2) - 1; i11 >= 0; i11--) {
            ssFixdown(i2, i3, i4, i11, i6);
        }
        if (i7 == 0) {
            swapElements(iArr, i4, iArr, i4 + i6);
            ssFixdown(i2, i3, i4, 0, i6);
        }
        for (int i12 = i6 - 1; i12 > 0; i12--) {
            int i13 = iArr[i4];
            int i14 = i4 + i12;
            iArr[i4] = iArr[i14];
            ssFixdown(i2, i3, i4, 0, i12);
            iArr[i14] = i13;
        }
    }

    private void ssInsertionSort(int i2, int i3, int i4, int i5) {
        int iSsCompare;
        int[] iArr = this.SA;
        for (int i6 = i4 - 2; i3 <= i6; i6--) {
            int i7 = iArr[i6];
            int i8 = i6 + 1;
            do {
                iSsCompare = ssCompare(i2 + i7, iArr[i8] + i2, i5);
                if (iSsCompare <= 0) {
                    break;
                }
                do {
                    iArr[i8 - 1] = iArr[i8];
                    i8++;
                    if (i8 >= i4) {
                        break;
                    }
                } while (iArr[i8] < 0);
            } while (i4 > i8);
            if (iSsCompare == 0) {
                iArr[i8] = ~iArr[i8];
            }
            iArr[i8 - 1] = i7;
        }
    }

    private static int ssLog(int i2) {
        return (65280 & i2) != 0 ? LOG_2_TABLE[(i2 >> 8) & 255] + 8 : LOG_2_TABLE[i2 & 255];
    }

    private int ssMedian3(int i2, int i3, int i4, int i5, int i6) {
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i7 = bArr[iArr[iArr[i4] + i3] + i2] & 255;
        int i8 = bArr[iArr[iArr[i5] + i3] + i2] & 255;
        int i9 = bArr[i2 + iArr[i3 + iArr[i6]]] & 255;
        if (i7 <= i8) {
            i5 = i4;
            i4 = i5;
            i8 = i7;
            i7 = i8;
        }
        return i7 > i9 ? i8 > i9 ? i5 : i6 : i4;
    }

    private int ssMedian5(int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
        int i9;
        int i10;
        int i11;
        int i12;
        int i13;
        int i14;
        int i15;
        int i16;
        int i17;
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i18 = bArr[iArr[iArr[i4] + i3] + i2] & 255;
        int i19 = bArr[iArr[iArr[i5] + i3] + i2] & 255;
        int i20 = bArr[iArr[iArr[i6] + i3] + i2] & 255;
        int i21 = bArr[iArr[iArr[i7] + i3] + i2] & 255;
        int i22 = bArr[iArr[iArr[i8] + i3] + i2] & 255;
        if (i19 > i20) {
            i9 = i6;
            i10 = i19;
            i11 = i5;
        } else {
            i9 = i5;
            i10 = i20;
            i20 = i19;
            i11 = i6;
        }
        if (i21 > i22) {
            i13 = i22;
            i12 = i21;
            i15 = i7;
            i14 = i8;
        } else {
            i12 = i22;
            i13 = i21;
            i14 = i7;
            i15 = i8;
        }
        if (i20 > i13) {
            int i23 = i11;
            i11 = i15;
            i15 = i23;
            int i24 = i12;
            i12 = i10;
            i10 = i24;
        } else {
            i9 = i14;
            i20 = i13;
        }
        if (i18 > i10) {
            i16 = i18;
            i17 = i4;
        } else {
            i16 = i10;
            i10 = i18;
            i17 = i11;
            i11 = i4;
        }
        if (i10 > i20) {
            i9 = i11;
            i20 = i10;
        } else {
            i15 = i17;
            i12 = i16;
        }
        return i12 > i20 ? i9 : i15;
    }

    private void ssMerge(int i2, int i3, int i4, int i5, int[] iArr, int i6, int i7, int i8) {
        int i9;
        int i10;
        int i11;
        int i12;
        int i13;
        int[] iArr2 = this.SA;
        StackEntry[] stackEntryArr = new StackEntry[64];
        int i14 = i3;
        int i15 = i4;
        int i16 = i5;
        int i17 = 0;
        int i18 = 0;
        while (true) {
            int i19 = i16 - i15;
            if (i19 <= i7) {
                if (i14 >= i15 || i15 >= i16) {
                    i9 = i16;
                } else {
                    i9 = i16;
                    ssMergeBackward(i2, iArr, i6, i14, i15, i16, i8);
                }
                if ((i17 & 1) != 0) {
                    ssMergeCheckEqual(i2, i8, i14);
                }
                if ((i17 & 2) != 0) {
                    ssMergeCheckEqual(i2, i8, i9);
                }
                if (i18 == 0) {
                    return;
                }
                i18--;
                StackEntry stackEntry = stackEntryArr[i18];
                i14 = stackEntry.a;
                i15 = stackEntry.f4319b;
                i16 = stackEntry.f4320c;
                i10 = stackEntry.f4321d;
            } else {
                int i20 = i16;
                int i21 = i15 - i14;
                if (i21 <= i7) {
                    if (i14 < i15) {
                        ssMergeForward(i2, iArr, i6, i14, i15, i20, i8);
                    }
                    if ((i17 & 1) != 0) {
                        ssMergeCheckEqual(i2, i8, i14);
                    }
                    if ((i17 & 2) != 0) {
                        ssMergeCheckEqual(i2, i8, i20);
                    }
                    if (i18 == 0) {
                        return;
                    }
                    i18--;
                    StackEntry stackEntry2 = stackEntryArr[i18];
                    i14 = stackEntry2.a;
                    i15 = stackEntry2.f4319b;
                    i16 = stackEntry2.f4320c;
                    i10 = stackEntry2.f4321d;
                } else {
                    int iMin = Math.min(i21, i19);
                    int i22 = iMin >> 1;
                    int i23 = 0;
                    while (iMin > 0) {
                        if (ssCompare(getIDX(iArr2[i15 + i23 + i22]) + i2, getIDX(iArr2[((i15 - i23) - i22) - 1]) + i2, i8) < 0) {
                            i23 += i22 + 1;
                            i22 -= (iMin & 1) ^ 1;
                        }
                        iMin = i22;
                        i22 = iMin >> 1;
                    }
                    if (i23 > 0) {
                        int i24 = i15 - i23;
                        ssBlockSwap(iArr2, i24, iArr2, i15, i23);
                        int i25 = i15 + i23;
                        if (i25 < i20) {
                            if (iArr2[i25] < 0) {
                                i13 = i15;
                                while (iArr2[i13 - 1] < 0) {
                                    i13--;
                                }
                                iArr2[i25] = ~iArr2[i25];
                            } else {
                                i13 = i15;
                            }
                            i11 = i15;
                            while (iArr2[i11] < 0) {
                                i11++;
                            }
                            i16 = i13;
                            i12 = 1;
                        } else {
                            i11 = i15;
                            i16 = i11;
                            i12 = 0;
                        }
                        if (i16 - i14 <= i20 - i11) {
                            stackEntryArr[i18] = new StackEntry(i11, i25, i20, (i12 & 1) | (i17 & 2));
                            i17 &= 1;
                            i15 = i24;
                            i18++;
                        } else {
                            if (i16 == i15 && i15 == i11) {
                                i12 <<= 1;
                            }
                            stackEntryArr[i18] = new StackEntry(i14, i24, i16, (i17 & 1) | (i12 & 2));
                            i17 = (i17 & 2) | (i12 & 1);
                            i15 = i25;
                            i18++;
                            i14 = i11;
                            i16 = i20;
                        }
                    } else {
                        if ((i17 & 1) != 0) {
                            ssMergeCheckEqual(i2, i8, i14);
                        }
                        ssMergeCheckEqual(i2, i8, i15);
                        if ((i17 & 2) != 0) {
                            ssMergeCheckEqual(i2, i8, i20);
                        }
                        if (i18 == 0) {
                            return;
                        }
                        i18--;
                        StackEntry stackEntry3 = stackEntryArr[i18];
                        i14 = stackEntry3.a;
                        i15 = stackEntry3.f4319b;
                        i16 = stackEntry3.f4320c;
                        i10 = stackEntry3.f4321d;
                    }
                }
            }
            i17 = i10;
        }
    }

    private void ssMergeBackward(int i2, int[] iArr, int i3, int i4, int i5, int i6, int i7) {
        int i8;
        int i9;
        int i10;
        int i11;
        int i12;
        int i13;
        int i14;
        int i15;
        int i16;
        int i17;
        int i18;
        int i19;
        int i20;
        int i21;
        int i22;
        int i23;
        int[] iArr2 = this.SA;
        int i24 = i6 - i5;
        ssBlockSwap(iArr, i3, iArr2, i5, i24);
        int i25 = (i3 + i24) - 1;
        if (iArr[i25] < 0) {
            i8 = i2 + (~iArr[i25]);
            i9 = 1;
        } else {
            i8 = i2 + iArr[i25];
            i9 = 0;
        }
        int i26 = i5 - 1;
        if (iArr2[i26] < 0) {
            i9 |= 2;
            i10 = ~iArr2[i26];
        } else {
            i10 = iArr2[i26];
        }
        int i27 = i2 + i10;
        int i28 = i6 - 1;
        int i29 = iArr2[i28];
        while (true) {
            int iSsCompare = ssCompare(i8, i27, i7);
            if (iSsCompare > 0) {
                if ((i9 & 1) != 0) {
                    while (true) {
                        i12 = i28 - 1;
                        iArr2[i28] = iArr[i25];
                        i13 = i25 - 1;
                        iArr[i25] = iArr2[i12];
                        if (iArr[i13] >= 0) {
                            break;
                        }
                        i25 = i13;
                        i28 = i12;
                    }
                    i9 ^= 1;
                    i25 = i13;
                    i28 = i12;
                }
                int i30 = i28 - 1;
                iArr2[i28] = iArr[i25];
                if (i25 <= i3) {
                    iArr[i25] = i29;
                    return;
                }
                int i31 = i25 - 1;
                iArr[i25] = iArr2[i30];
                if (iArr[i31] < 0) {
                    i9 |= 1;
                    i11 = ~iArr[i31];
                } else {
                    i11 = iArr[i31];
                }
                int i32 = i2 + i11;
                i25 = i31;
                i28 = i30;
                i8 = i32;
            } else if (iSsCompare < 0) {
                if ((i9 & 2) != 0) {
                    while (true) {
                        i15 = i28 - 1;
                        iArr2[i28] = iArr2[i26];
                        i16 = i26 - 1;
                        iArr2[i26] = iArr2[i15];
                        if (iArr2[i16] >= 0) {
                            break;
                        }
                        i26 = i16;
                        i28 = i15;
                    }
                    i9 ^= 2;
                    i26 = i16;
                    i28 = i15;
                }
                int i33 = i28 - 1;
                iArr2[i28] = iArr2[i26];
                int i34 = i26 - 1;
                iArr2[i26] = iArr2[i33];
                if (i34 < i4) {
                    while (i3 < i25) {
                        int i35 = i33 - 1;
                        iArr2[i33] = iArr[i25];
                        iArr[i25] = iArr2[i35];
                        i33 = i35;
                        i25--;
                    }
                    iArr2[i33] = iArr[i25];
                    iArr[i25] = i29;
                    return;
                }
                if (iArr2[i34] < 0) {
                    i9 |= 2;
                    i14 = ~iArr2[i34];
                } else {
                    i14 = iArr2[i34];
                }
                i27 = i2 + i14;
                i26 = i34;
                i28 = i33;
            } else {
                if ((i9 & 1) != 0) {
                    while (true) {
                        i22 = i28 - 1;
                        iArr2[i28] = iArr[i25];
                        i23 = i25 - 1;
                        iArr[i25] = iArr2[i22];
                        if (iArr[i23] >= 0) {
                            break;
                        }
                        i25 = i23;
                        i28 = i22;
                    }
                    i9 ^= 1;
                    i25 = i23;
                    i28 = i22;
                }
                int i36 = i28 - 1;
                iArr2[i28] = ~iArr[i25];
                if (i25 <= i3) {
                    iArr[i25] = i29;
                    return;
                }
                int i37 = i25 - 1;
                iArr[i25] = iArr2[i36];
                if ((i9 & 2) != 0) {
                    while (true) {
                        i20 = i36 - 1;
                        iArr2[i36] = iArr2[i26];
                        i21 = i26 - 1;
                        iArr2[i26] = iArr2[i20];
                        if (iArr2[i21] >= 0) {
                            break;
                        }
                        i26 = i21;
                        i36 = i20;
                    }
                    i9 ^= 2;
                    i26 = i21;
                    i36 = i20;
                }
                int i38 = i36 - 1;
                iArr2[i36] = iArr2[i26];
                int i39 = i26 - 1;
                iArr2[i26] = iArr2[i38];
                if (i39 < i4) {
                    while (i3 < i37) {
                        int i40 = i38 - 1;
                        iArr2[i38] = iArr[i37];
                        iArr[i37] = iArr2[i40];
                        i38 = i40;
                        i37--;
                    }
                    iArr2[i38] = iArr[i37];
                    iArr[i37] = i29;
                    return;
                }
                if (iArr[i37] < 0) {
                    i18 = i9 | 1;
                    i17 = i2 + (~iArr[i37]);
                } else {
                    int i41 = i9;
                    i17 = i2 + iArr[i37];
                    i18 = i41;
                }
                if (iArr2[i39] < 0) {
                    i18 |= 2;
                    i19 = ~iArr2[i39];
                } else {
                    i19 = iArr2[i39];
                }
                i27 = i2 + i19;
                int i42 = i17;
                i9 = i18;
                i26 = i39;
                i8 = i42;
                i25 = i37;
                i28 = i38;
            }
        }
    }

    private void ssMergeCheckEqual(int i2, int i3, int i4) {
        int[] iArr = this.SA;
        if (iArr[i4] < 0 || ssCompare(getIDX(iArr[i4 - 1]) + i2, i2 + iArr[i4], i3) != 0) {
            return;
        }
        iArr[i4] = ~iArr[i4];
    }

    private void ssMergeForward(int i2, int[] iArr, int i3, int i4, int i5, int i6, int i7) {
        int i8;
        int[] iArr2 = this.SA;
        int i9 = i5 - i4;
        int i10 = (i3 + i9) - 1;
        ssBlockSwap(iArr, i3, iArr2, i4, i9);
        int i11 = iArr2[i4];
        while (true) {
            int iSsCompare = ssCompare(iArr[i3] + i2, iArr2[i5] + i2, i7);
            if (iSsCompare < 0) {
                while (true) {
                    i8 = i4 + 1;
                    iArr2[i4] = iArr[i3];
                    if (i10 <= i3) {
                        iArr[i3] = i11;
                        return;
                    }
                    int i12 = i3 + 1;
                    iArr[i3] = iArr2[i8];
                    if (iArr[i12] >= 0) {
                        i3 = i12;
                        break;
                    } else {
                        i3 = i12;
                        i4 = i8;
                    }
                }
            } else if (iSsCompare > 0) {
                while (true) {
                    i8 = i4 + 1;
                    iArr2[i4] = iArr2[i5];
                    int i13 = i5 + 1;
                    iArr2[i5] = iArr2[i8];
                    if (i6 <= i13) {
                        while (i3 < i10) {
                            int i14 = i8 + 1;
                            iArr2[i8] = iArr[i3];
                            iArr[i3] = iArr2[i14];
                            i8 = i14;
                            i3++;
                        }
                        iArr2[i8] = iArr[i3];
                        iArr[i3] = i11;
                        return;
                    }
                    if (iArr2[i13] >= 0) {
                        i5 = i13;
                        break;
                    } else {
                        i5 = i13;
                        i4 = i8;
                    }
                }
            } else {
                iArr2[i5] = ~iArr2[i5];
                while (true) {
                    int i15 = i4 + 1;
                    iArr2[i4] = iArr[i3];
                    if (i10 <= i3) {
                        iArr[i3] = i11;
                        return;
                    }
                    int i16 = i3 + 1;
                    iArr[i3] = iArr2[i15];
                    if (iArr[i16] >= 0) {
                        while (true) {
                            int i17 = i15 + 1;
                            iArr2[i15] = iArr2[i5];
                            int i18 = i5 + 1;
                            iArr2[i5] = iArr2[i17];
                            if (i6 <= i18) {
                                while (i16 < i10) {
                                    int i19 = i17 + 1;
                                    iArr2[i17] = iArr[i16];
                                    iArr[i16] = iArr2[i19];
                                    i16++;
                                    i17 = i19;
                                }
                                iArr2[i17] = iArr[i16];
                                iArr[i16] = i11;
                                return;
                            }
                            if (iArr2[i18] >= 0) {
                                i5 = i18;
                                i4 = i17;
                                i3 = i16;
                                break;
                            }
                            i5 = i18;
                            i15 = i17;
                        }
                    } else {
                        i3 = i16;
                        i4 = i15;
                    }
                }
            }
            i4 = i8;
        }
    }

    private void ssMultiKeyIntroSort(int i2, int i3, int i4, int i5) {
        int iSsLog;
        int i6;
        int i7;
        int i8;
        int i9;
        Bzip2DivSufSort bzip2DivSufSort = this;
        int[] iArr = bzip2DivSufSort.SA;
        byte[] bArr = bzip2DivSufSort.T;
        StackEntry[] stackEntryArr = new StackEntry[64];
        int i10 = -1;
        int i11 = i5;
        int iSsLog2 = ssLog(i4 - i3);
        int i12 = 0;
        int i13 = 0;
        int iSsSubstringPartition = i3;
        int i14 = i4;
        while (true) {
            int i15 = i14 - iSsSubstringPartition;
            if (i15 <= 8) {
                if (1 < i15) {
                    bzip2DivSufSort.ssInsertionSort(i2, iSsSubstringPartition, i14, i11);
                }
                if (i12 == 0) {
                    return;
                }
                i12--;
                StackEntry stackEntry = stackEntryArr[i12];
                int i16 = stackEntry.a;
                int i17 = stackEntry.f4319b;
                int i18 = stackEntry.f4320c;
                iSsLog2 = stackEntry.f4321d;
                iSsSubstringPartition = i16;
                i14 = i17;
                i11 = i18;
            } else {
                int i19 = iSsLog2 - 1;
                if (iSsLog2 == 0) {
                    bzip2DivSufSort.ssHeapSort(i11, i2, iSsSubstringPartition, i15);
                }
                if (i19 < 0) {
                    int i20 = bArr[iArr[iArr[iSsSubstringPartition] + i2] + i11] & 255;
                    int iSsSubstringPartition2 = iSsSubstringPartition;
                    iSsSubstringPartition++;
                    while (iSsSubstringPartition < i14) {
                        i13 = bArr[iArr[iArr[iSsSubstringPartition] + i2] + i11] & 255;
                        if (i13 != i20) {
                            if (1 < iSsSubstringPartition - iSsSubstringPartition2) {
                                break;
                            }
                            iSsSubstringPartition2 = iSsSubstringPartition;
                            i20 = i13;
                        }
                        iSsSubstringPartition++;
                    }
                    if ((bArr[(iArr[iArr[iSsSubstringPartition2] + i2] + i11) - 1] & 255) < i20) {
                        iSsSubstringPartition2 = bzip2DivSufSort.ssSubstringPartition(i2, iSsSubstringPartition2, iSsSubstringPartition, i11);
                    }
                    int i21 = iSsSubstringPartition - iSsSubstringPartition2;
                    int i22 = i14 - iSsSubstringPartition;
                    if (i21 <= i22) {
                        if (1 < i21) {
                            stackEntryArr[i12] = new StackEntry(iSsSubstringPartition, i14, i11, i10);
                            i11++;
                            iSsLog = ssLog(i21);
                            i12++;
                            int i23 = iSsLog;
                            i14 = iSsSubstringPartition;
                            iSsSubstringPartition = iSsSubstringPartition2;
                            iSsLog2 = i23;
                        } else {
                            iSsLog2 = i10;
                        }
                    } else if (1 < i22) {
                        stackEntryArr[i12] = new StackEntry(iSsSubstringPartition2, iSsSubstringPartition, i11 + 1, ssLog(i21));
                        iSsLog2 = i10;
                        i12++;
                    } else {
                        i11++;
                        iSsLog = ssLog(i21);
                        int i232 = iSsLog;
                        i14 = iSsSubstringPartition;
                        iSsSubstringPartition = iSsSubstringPartition2;
                        iSsLog2 = i232;
                    }
                } else {
                    int iSsPivot = bzip2DivSufSort.ssPivot(i11, i2, iSsSubstringPartition, i14);
                    int i24 = bArr[iArr[iArr[iSsPivot] + i2] + i11] & 255;
                    swapElements(iArr, iSsSubstringPartition, iArr, iSsPivot);
                    int i25 = iSsSubstringPartition + 1;
                    while (i25 < i14) {
                        i13 = bArr[iArr[iArr[i25] + i2] + i11] & 255;
                        if (i13 != i24) {
                            break;
                        } else {
                            i25++;
                        }
                    }
                    if (i25 >= i14 || i13 >= i24) {
                        i6 = i13;
                        i7 = i25;
                    } else {
                        i6 = i13;
                        i7 = i25;
                        while (true) {
                            i25++;
                            if (i25 >= i14 || (i6 = bArr[iArr[iArr[i25] + i2] + i11] & 255) > i24) {
                                break;
                            } else if (i6 == i24) {
                                swapElements(iArr, i25, iArr, i7);
                                i7++;
                            }
                        }
                    }
                    int i26 = i14 - 1;
                    while (i25 < i26) {
                        i6 = bArr[iArr[iArr[i26] + i2] + i11] & 255;
                        if (i6 != i24) {
                            break;
                        } else {
                            i26--;
                        }
                    }
                    if (i25 < i26 && i6 > i24) {
                        int i27 = i6;
                        int i28 = i26;
                        while (true) {
                            i26 += i10;
                            if (i25 >= i26) {
                                i8 = i28;
                                i6 = i27;
                                break;
                            }
                            int i29 = bArr[i11 + iArr[i2 + iArr[i26]]] & 255;
                            if (i29 < i24) {
                                int i30 = i28;
                                i6 = i29;
                                i8 = i30;
                                break;
                            } else {
                                if (i29 == i24) {
                                    swapElements(iArr, i26, iArr, i28);
                                    i28--;
                                }
                                i27 = i29;
                                i10 = -1;
                            }
                        }
                    } else {
                        i8 = i26;
                    }
                    while (i25 < i26) {
                        swapElements(iArr, i25, iArr, i26);
                        while (true) {
                            i25++;
                            if (i25 >= i26 || (i6 = bArr[iArr[iArr[i25] + i2] + i11] & 255) > i24) {
                                break;
                            } else if (i6 == i24) {
                                swapElements(iArr, i25, iArr, i7);
                                i7++;
                            }
                        }
                        while (true) {
                            i26--;
                            if (i25 >= i26 || (i6 = bArr[iArr[iArr[i26] + i2] + i11] & 255) < i24) {
                                break;
                            } else if (i6 == i24) {
                                swapElements(iArr, i26, iArr, i8);
                                i8--;
                            }
                        }
                    }
                    if (i7 <= i8) {
                        int i31 = i25 - 1;
                        int i32 = i6;
                        int i33 = i7 - iSsSubstringPartition;
                        int i34 = i25 - i7;
                        if (i33 > i34) {
                            i33 = i34;
                        }
                        int i35 = iSsSubstringPartition;
                        int i36 = i25;
                        int i37 = i25 - i33;
                        while (i33 > 0) {
                            swapElements(iArr, i35, iArr, i37);
                            i33--;
                            i35++;
                            i37++;
                        }
                        int i38 = i8 - i31;
                        int i39 = (i14 - i8) - 1;
                        if (i38 <= i39) {
                            i39 = i38;
                        }
                        int i40 = i14 - i39;
                        int i41 = i36;
                        while (i39 > 0) {
                            swapElements(iArr, i41, iArr, i40);
                            i39--;
                            i41++;
                            i40++;
                        }
                        int i42 = iSsSubstringPartition + i34;
                        int i43 = i14 - i38;
                        int iSsSubstringPartition3 = i24 <= (bArr[(iArr[iArr[i42] + i2] + i11) + (-1)] & 255) ? i42 : bzip2DivSufSort.ssSubstringPartition(i2, i42, i43, i11);
                        int i44 = i42 - iSsSubstringPartition;
                        int i45 = i14 - i43;
                        if (i44 <= i45) {
                            int i46 = i43 - iSsSubstringPartition3;
                            if (i45 <= i46) {
                                int i47 = i12 + 1;
                                stackEntryArr[i12] = new StackEntry(iSsSubstringPartition3, i43, i11 + 1, ssLog(i46));
                                i12 = i47 + 1;
                                i9 = i19;
                                stackEntryArr[i47] = new StackEntry(i43, i14, i11, i9);
                            } else {
                                i9 = i19;
                                if (i44 <= i46) {
                                    int i48 = i12 + 1;
                                    stackEntryArr[i12] = new StackEntry(i43, i14, i11, i9);
                                    i12 = i48 + 1;
                                    stackEntryArr[i48] = new StackEntry(iSsSubstringPartition3, i43, i11 + 1, ssLog(i46));
                                } else {
                                    int i49 = i12 + 1;
                                    stackEntryArr[i12] = new StackEntry(i43, i14, i11, i9);
                                    i12 = i49 + 1;
                                    stackEntryArr[i49] = new StackEntry(iSsSubstringPartition, i42, i11, i9);
                                    i11++;
                                    i14 = i43;
                                    i10 = -1;
                                    iSsLog2 = ssLog(i46);
                                    iSsSubstringPartition = iSsSubstringPartition3;
                                    i13 = i32;
                                }
                            }
                            i13 = i32;
                            i14 = i42;
                            iSsLog2 = i9;
                        } else {
                            i9 = i19;
                            int i50 = i43 - iSsSubstringPartition3;
                            if (i44 <= i50) {
                                int i51 = i12 + 1;
                                stackEntryArr[i12] = new StackEntry(iSsSubstringPartition3, i43, i11 + 1, ssLog(i50));
                                i12 = i51 + 1;
                                stackEntryArr[i51] = new StackEntry(iSsSubstringPartition, i42, i11, i9);
                            } else if (i45 <= i50) {
                                int i52 = i12 + 1;
                                stackEntryArr[i12] = new StackEntry(iSsSubstringPartition, i42, i11, i9);
                                i12 = i52 + 1;
                                stackEntryArr[i52] = new StackEntry(iSsSubstringPartition3, i43, i11 + 1, ssLog(i50));
                            } else {
                                int i53 = i12 + 1;
                                stackEntryArr[i12] = new StackEntry(iSsSubstringPartition, i42, i11, i9);
                                i12 = i53 + 1;
                                stackEntryArr[i53] = new StackEntry(i43, i14, i11, i9);
                                i11++;
                                i14 = i43;
                                iSsSubstringPartition = iSsSubstringPartition3;
                                i10 = -1;
                                i13 = i32;
                                iSsLog2 = ssLog(i50);
                                bzip2DivSufSort = this;
                            }
                            bzip2DivSufSort = this;
                            i13 = i32;
                            iSsSubstringPartition = i43;
                            iSsLog2 = i9;
                        }
                    } else {
                        int i54 = i6;
                        int i55 = i19 + 1;
                        if ((bArr[(iArr[iArr[iSsSubstringPartition] + i2] + i11) - 1] & 255) < i24) {
                            bzip2DivSufSort = this;
                            iSsSubstringPartition = bzip2DivSufSort.ssSubstringPartition(i2, iSsSubstringPartition, i14, i11);
                            iSsLog2 = ssLog(i14 - iSsSubstringPartition);
                        } else {
                            bzip2DivSufSort = this;
                            iSsLog2 = i55;
                        }
                        i11++;
                        i13 = i54;
                    }
                    i10 = -1;
                }
            }
        }
    }

    private int ssPivot(int i2, int i3, int i4, int i5) {
        int i6 = i5 - i4;
        int i7 = i4 + (i6 / 2);
        if (i6 <= 512) {
            if (i6 <= 32) {
                return ssMedian3(i2, i3, i4, i7, i5 - 1);
            }
            int i8 = i6 >> 2;
            int i9 = i5 - 1;
            return ssMedian5(i2, i3, i4, i4 + i8, i7, i9 - i8, i9);
        }
        int i10 = i6 >> 3;
        int i11 = i10 << 1;
        int i12 = i5 - 1;
        return ssMedian3(i2, i3, ssMedian3(i2, i3, i4, i4 + i10, i4 + i11), ssMedian3(i2, i3, i7 - i10, i7, i7 + i10), ssMedian3(i2, i3, i12 - i11, i12 - i10, i12));
    }

    private int ssSubstringPartition(int i2, int i3, int i4, int i5) {
        int[] iArr = this.SA;
        int i6 = i3 - 1;
        while (true) {
            i6++;
            if (i6 >= i4 || iArr[iArr[i6] + i2] + i5 < iArr[iArr[i6] + i2 + 1] + 1) {
                do {
                    i4--;
                    if (i6 >= i4) {
                        break;
                    }
                } while (iArr[iArr[i4] + i2] + i5 < iArr[iArr[i4] + i2 + 1] + 1);
                if (i4 <= i6) {
                    break;
                }
                int i7 = ~iArr[i4];
                iArr[i4] = iArr[i6];
                iArr[i6] = i7;
            } else {
                iArr[i6] = ~iArr[i6];
            }
        }
        if (i3 < i6) {
            iArr[i3] = ~iArr[i3];
        }
        return i6;
    }

    private void subStringSort(int i2, int i3, int i4, int[] iArr, int i5, int i6, int i7, boolean z, int i8) {
        int i9;
        int i10;
        int[] iArr2;
        int[] iArr3 = this.SA;
        int i11 = z ? i3 + 1 : i3;
        int i12 = 0;
        int i13 = i11;
        while (true) {
            int i14 = i13 + 1024;
            if (i14 >= i4) {
                break;
            }
            ssMultiKeyIntroSort(i2, i13, i14, i7);
            int i15 = i4 - i14;
            if (i15 <= i6) {
                iArr2 = iArr;
                i10 = i5;
                i9 = i6;
            } else {
                i9 = i15;
                i10 = i14;
                iArr2 = iArr3;
            }
            int i16 = i13;
            int i17 = 1024;
            int i18 = i12;
            while ((i18 & 1) != 0) {
                int i19 = i16 - i17;
                ssMerge(i2, i19, i16, i16 + i17, iArr2, i10, i9, i7);
                i17 <<= 1;
                i18 >>>= 1;
                i16 = i19;
                i14 = i14;
            }
            i12++;
            i13 = i14;
        }
        ssMultiKeyIntroSort(i2, i13, i4, i7);
        int i20 = i13;
        int i21 = 1024;
        for (int i22 = i12; i22 != 0; i22 >>= 1) {
            if ((i22 & 1) != 0) {
                int i23 = i20 - i21;
                ssMerge(i2, i23, i20, i4, iArr, i5, i6, i7);
                i20 = i23;
            }
            i21 <<= 1;
        }
        if (z) {
            int i24 = iArr3[i11 - 1];
            int iSsCompareLast = 1;
            while (i11 < i4 && (iArr3[i11] < 0 || (iSsCompareLast = ssCompareLast(i2, i2 + i24, i2 + iArr3[i11], i7, i8)) > 0)) {
                iArr3[i11 - 1] = iArr3[i11];
                i11++;
            }
            if (iSsCompareLast == 0) {
                iArr3[i11] = ~iArr3[i11];
            }
            iArr3[i11 - 1] = i24;
        }
    }

    private static void swapElements(int[] iArr, int i2, int[] iArr2, int i3) {
        int i4 = iArr[i2];
        iArr[i2] = iArr2[i3];
        iArr2[i3] = i4;
    }

    private void trCopy(int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
        int[] iArr = this.SA;
        int i9 = i6 - 1;
        int i10 = i5 - 1;
        while (i4 <= i10) {
            int i11 = iArr[i4] - i8;
            if (i11 < 0) {
                i11 += i3 - i2;
            }
            int i12 = i2 + i11;
            if (iArr[i12] == i9) {
                i10++;
                iArr[i10] = i11;
                iArr[i12] = i10;
            }
            i4++;
        }
        int i13 = i7 - 1;
        int i14 = i10 + 1;
        while (i14 < i6) {
            int i15 = iArr[i13] - i8;
            if (i15 < 0) {
                i15 += i3 - i2;
            }
            int i16 = i2 + i15;
            if (iArr[i16] == i9) {
                i6--;
                iArr[i6] = i15;
                iArr[i16] = i6;
            }
            i13--;
        }
    }

    private void trFixdown(int i2, int i3, int i4, int i5, int i6, int i7) {
        int[] iArr = this.SA;
        int i8 = iArr[i5 + i6];
        int iTrGetC = trGetC(i2, i3, i4, i8);
        while (true) {
            int i9 = (i6 * 2) + 1;
            if (i9 >= i7) {
                break;
            }
            int i10 = i9 + 1;
            int iTrGetC2 = trGetC(i2, i3, i4, iArr[i5 + i9]);
            int iTrGetC3 = trGetC(i2, i3, i4, iArr[i5 + i10]);
            if (iTrGetC2 < iTrGetC3) {
                i9 = i10;
                iTrGetC2 = iTrGetC3;
            }
            if (iTrGetC2 <= iTrGetC) {
                break;
            }
            iArr[i6 + i5] = iArr[i5 + i9];
            i6 = i9;
        }
        iArr[i5 + i6] = i8;
    }

    private int trGetC(int i2, int i3, int i4, int i5) {
        int i6 = i3 + i5;
        return i6 < i4 ? this.SA[i6] : this.SA[i2 + (((i3 - i2) + i5) % (i4 - i2))];
    }

    private void trHeapSort(int i2, int i3, int i4, int i5, int i6) {
        int i7;
        int[] iArr = this.SA;
        int i8 = i6 % 2;
        if (i8 == 0) {
            int i9 = i6 - 1;
            int i10 = (i9 / 2) + i5;
            int i11 = i5 + i9;
            if (trGetC(i2, i3, i4, iArr[i10]) < trGetC(i2, i3, i4, iArr[i11])) {
                swapElements(iArr, i11, iArr, i10);
            }
            i7 = i9;
        } else {
            i7 = i6;
        }
        for (int i12 = (i7 / 2) - 1; i12 >= 0; i12--) {
            trFixdown(i2, i3, i4, i5, i12, i7);
        }
        if (i8 == 0) {
            swapElements(iArr, i5, iArr, i5 + i7);
            trFixdown(i2, i3, i4, i5, 0, i7);
        }
        for (int i13 = i7 - 1; i13 > 0; i13--) {
            int i14 = iArr[i5];
            int i15 = i5 + i13;
            iArr[i5] = iArr[i15];
            trFixdown(i2, i3, i4, i5, 0, i13);
            iArr[i15] = i14;
        }
    }

    private void trInsertionSort(int i2, int i3, int i4, int i5, int i6) {
        int iTrGetC;
        int[] iArr = this.SA;
        for (int i7 = i5 + 1; i7 < i6; i7++) {
            int i8 = iArr[i7];
            int i9 = i7 - 1;
            do {
                iTrGetC = trGetC(i2, i3, i4, i8) - trGetC(i2, i3, i4, iArr[i9]);
                if (iTrGetC >= 0) {
                    break;
                }
                do {
                    iArr[i9 + 1] = iArr[i9];
                    i9--;
                    if (i5 > i9) {
                        break;
                    }
                } while (iArr[i9] < 0);
            } while (i9 >= i5);
            if (iTrGetC == 0) {
                iArr[i9] = ~iArr[i9];
            }
            iArr[i9 + 1] = i8;
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:86:0x01e9, code lost:
    
        r8 = r21;
     */
    /* JADX WARN: Removed duplicated region for block: B:138:0x02c9  */
    /* JADX WARN: Removed duplicated region for block: B:154:0x02fa  */
    /* JADX WARN: Removed duplicated region for block: B:280:0x04e3 A[SYNTHETIC] */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:150:0x02ee -> B:135:0x02c1). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private void trIntroSort(int r22, int r23, int r24, int r25, int r26, io.netty.handler.codec.compression.Bzip2DivSufSort.TRBudget r27, int r28) {
        /*
            Method dump skipped, instruction units count: 1302
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.handler.codec.compression.Bzip2DivSufSort.trIntroSort(int, int, int, int, int, io.netty.handler.codec.compression.Bzip2DivSufSort$TRBudget, int):void");
    }

    private static int trLog(int i2) {
        return ((-65536) & i2) != 0 ? ((-16777216) & i2) != 0 ? LOG_2_TABLE[(i2 >> 24) & 255] + 24 : LOG_2_TABLE[(i2 >> 16) & 271] : (65280 & i2) != 0 ? LOG_2_TABLE[(i2 >> 8) & 255] + 8 : LOG_2_TABLE[i2 & 255];
    }

    private int trMedian3(int i2, int i3, int i4, int i5, int i6, int i7) {
        int[] iArr = this.SA;
        int iTrGetC = trGetC(i2, i3, i4, iArr[i5]);
        int iTrGetC2 = trGetC(i2, i3, i4, iArr[i6]);
        int iTrGetC3 = trGetC(i2, i3, i4, iArr[i7]);
        if (iTrGetC <= iTrGetC2) {
            i6 = i5;
            i5 = i6;
            iTrGetC2 = iTrGetC;
            iTrGetC = iTrGetC2;
        }
        return iTrGetC > iTrGetC3 ? iTrGetC2 > iTrGetC3 ? i6 : i7 : i5;
    }

    private int trMedian5(int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) {
        int[] iArr = this.SA;
        int iTrGetC = trGetC(i2, i3, i4, iArr[i5]);
        int iTrGetC2 = trGetC(i2, i3, i4, iArr[i6]);
        int iTrGetC3 = trGetC(i2, i3, i4, iArr[i7]);
        int iTrGetC4 = trGetC(i2, i3, i4, iArr[i8]);
        int iTrGetC5 = trGetC(i2, i3, i4, iArr[i9]);
        if (iTrGetC2 > iTrGetC3) {
            i7 = i6;
            i6 = i7;
            iTrGetC3 = iTrGetC2;
            iTrGetC2 = iTrGetC3;
        }
        if (iTrGetC4 > iTrGetC5) {
            iTrGetC4 = iTrGetC5;
            iTrGetC5 = iTrGetC4;
        } else {
            i9 = i8;
            i8 = i9;
        }
        if (iTrGetC2 > iTrGetC4) {
            int i10 = iTrGetC3;
            iTrGetC3 = iTrGetC5;
            iTrGetC5 = i10;
            int i11 = i8;
            i8 = i7;
            i7 = i11;
        } else {
            i6 = i9;
            iTrGetC2 = iTrGetC4;
        }
        if (iTrGetC > iTrGetC3) {
            int i12 = i7;
            i7 = i5;
            i5 = i12;
            int i13 = iTrGetC3;
            iTrGetC3 = iTrGetC;
            iTrGetC = i13;
        }
        if (iTrGetC > iTrGetC2) {
            i6 = i5;
            iTrGetC2 = iTrGetC;
        } else {
            i8 = i7;
            iTrGetC5 = iTrGetC3;
        }
        return iTrGetC5 > iTrGetC2 ? i6 : i8;
    }

    private PartitionResult trPartition(int i2, int i3, int i4, int i5, int i6, int i7) {
        int i8;
        int i9;
        int iTrGetC;
        int iTrGetC2;
        int iTrGetC3;
        int[] iArr = this.SA;
        int iTrGetC4 = 0;
        int i10 = i5;
        while (i10 < i6) {
            iTrGetC4 = trGetC(i2, i3, i4, iArr[i10]);
            if (iTrGetC4 != i7) {
                break;
            }
            i10++;
        }
        if (i10 >= i6 || iTrGetC4 >= i7) {
            i8 = i10;
        } else {
            i8 = i10;
            while (true) {
                i10++;
                if (i10 >= i6 || (iTrGetC4 = trGetC(i2, i3, i4, iArr[i10])) > i7) {
                    break;
                }
                if (iTrGetC4 == i7) {
                    swapElements(iArr, i10, iArr, i8);
                    i8++;
                }
            }
        }
        int i11 = i6 - 1;
        while (i10 < i11) {
            iTrGetC4 = trGetC(i2, i3, i4, iArr[i11]);
            if (iTrGetC4 != i7) {
                break;
            }
            i11--;
        }
        if (i10 >= i11 || iTrGetC4 <= i7) {
            i9 = i11;
        } else {
            i9 = i11;
            while (true) {
                i11--;
                if (i10 >= i11 || (iTrGetC3 = trGetC(i2, i3, i4, iArr[i11])) < i7) {
                    break;
                }
                if (iTrGetC3 == i7) {
                    swapElements(iArr, i11, iArr, i9);
                    i9--;
                }
            }
        }
        while (i10 < i11) {
            swapElements(iArr, i10, iArr, i11);
            while (true) {
                i10++;
                if (i10 >= i11 || (iTrGetC2 = trGetC(i2, i3, i4, iArr[i10])) > i7) {
                    break;
                }
                if (iTrGetC2 == i7) {
                    swapElements(iArr, i10, iArr, i8);
                    i8++;
                }
            }
            while (true) {
                i11--;
                if (i10 >= i11 || (iTrGetC = trGetC(i2, i3, i4, iArr[i11])) < i7) {
                    break;
                }
                if (iTrGetC == i7) {
                    swapElements(iArr, i11, iArr, i9);
                    i9--;
                }
            }
        }
        if (i8 <= i9) {
            int i12 = i10 - 1;
            int i13 = i8 - i5;
            int i14 = i10 - i8;
            if (i13 > i14) {
                i13 = i14;
            }
            int i15 = i10 - i13;
            int i16 = i5;
            while (i13 > 0) {
                swapElements(iArr, i16, iArr, i15);
                i13--;
                i16++;
                i15++;
            }
            int i17 = i9 - i12;
            int i18 = (i6 - i9) - 1;
            if (i17 <= i18) {
                i18 = i17;
            }
            int i19 = i6 - i18;
            while (i18 > 0) {
                swapElements(iArr, i10, iArr, i19);
                i18--;
                i10++;
                i19++;
            }
            i5 += i14;
            i6 -= i17;
        }
        return new PartitionResult(i5, i6);
    }

    private int trPivot(int i2, int i3, int i4, int i5, int i6) {
        int i7 = i6 - i5;
        int i8 = i5 + (i7 / 2);
        if (i7 <= 512) {
            if (i7 <= 32) {
                return trMedian3(i2, i3, i4, i5, i8, i6 - 1);
            }
            int i9 = i7 >> 2;
            int i10 = i6 - 1;
            return trMedian5(i2, i3, i4, i5, i5 + i9, i8, i10 - i9, i10);
        }
        int i11 = i7 >> 3;
        int i12 = i11 << 1;
        int i13 = i6 - 1;
        return trMedian3(i2, i3, i4, trMedian3(i2, i3, i4, i5, i5 + i11, i5 + i12), trMedian3(i2, i3, i4, i8 - i11, i8, i8 + i11), trMedian3(i2, i3, i4, i13 - i12, i13 - i11, i13));
    }

    private void trSort(int i2, int i3, int i4) {
        int[] iArr = this.SA;
        if ((-i3) < iArr[0]) {
            TRBudget tRBudget = new TRBudget(i3, ((trLog(i3) * 2) / 3) + 1);
            int i5 = 0;
            do {
                int i6 = iArr[i5];
                if (i6 < 0) {
                    i5 -= i6;
                } else {
                    int i7 = iArr[i2 + i6] + 1;
                    if (1 < i7 - i5) {
                        trIntroSort(i2, i2 + i4, i2 + i3, i5, i7, tRBudget, i3);
                        if (tRBudget.chance == 0) {
                            if (i5 > 0) {
                                iArr[0] = -i5;
                            }
                            lsSort(i2, i3, i4);
                            return;
                        }
                    }
                    i5 = i7;
                }
            } while (i5 < i3);
        }
    }

    public int bwt() {
        int[] iArr = this.SA;
        byte[] bArr = this.T;
        int i2 = this.n;
        int[] iArr2 = new int[BUCKET_A_SIZE];
        int[] iArr3 = new int[BUCKET_B_SIZE];
        if (i2 == 0) {
            return 0;
        }
        if (i2 == 1) {
            iArr[0] = bArr[0];
            return 0;
        }
        if (sortTypeBstar(iArr2, iArr3) > 0) {
            return constructBWT(iArr2, iArr3);
        }
        return 0;
    }
}