package io.netty.handler.codec.compression;

import com.seewo.libmcuservice.constant.IMcuConstants;

/* 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 i, int i2) {
            this.first = i;
            this.last = i2;
        }
    }

    private static class StackEntry {

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

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

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

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

        StackEntry(int i, int i2, int i3, int i4) {
            this.f3327a = i;
            this.f3328b = i2;
            this.f3329c = i3;
            this.f3330d = i4;
        }
    }

    private static class TRBudget {
        int budget;
        int chance;

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

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

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

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

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

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

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

    /* 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 i, int i2, int i3) {
        int i4;
        int[] iArr = this.SA;
        int i5 = i3 + i;
        while (true) {
            int i6 = 0;
            if ((-i2) >= iArr[0]) {
                return;
            }
            int i7 = 0;
            int i8 = 0;
            do {
                int i9 = iArr[i8];
                if (i9 < 0) {
                    i8 -= i9;
                    i7 += i9;
                } else {
                    if (i7 != 0) {
                        iArr[i8 + i7] = i7;
                        i4 = 0;
                    } else {
                        i4 = i7;
                    }
                    int i10 = iArr[i9 + i] + 1;
                    lsIntroSort(i, i5, i + i2, i8, i10);
                    i7 = i4;
                    i8 = i10;
                }
            } while (i8 < i2);
            if (i7 != 0) {
                iArr[i8 + i7] = i7;
            }
            int i11 = i5 - i;
            if (i2 < i11) {
                do {
                    int i12 = iArr[i6];
                    if (i12 < 0) {
                        i6 -= i12;
                    } else {
                        int i13 = iArr[i12 + i] + 1;
                        while (i6 < i13) {
                            iArr[iArr[i6] + i] = i6;
                            i6++;
                        }
                        i6 = i13;
                    }
                } while (i6 < i2);
                return;
            }
            i5 += i11;
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /* 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 i) {
        return ((-65536) & i) != 0 ? ((-16777216) & i) != 0 ? LOG_2_TABLE[(i >> 24) & 255] + 24 : LOG_2_TABLE[(i >> 16) & 271] : (65280 & i) != 0 ? LOG_2_TABLE[(i >> 8) & 255] + 8 : LOG_2_TABLE[i & 255];
    }

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

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

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

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

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

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