package defpackage;

import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.Arrays;

/* JADX INFO: renamed from: ˈˌ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public class C1054 implements Serializable, Comparable {

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public static final C1054 f4543 = new C1054(new byte[0]);

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public final byte[] f4544;

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public transient String f4545;

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public transient int f4546;

    public C1054(byte[] bArr) {
        this.f4544 = bArr;
    }

    /* JADX INFO: renamed from: ᵪᵹᵥᵻ, reason: contains not printable characters */
    public static C1054 m3451(C1054 c1054, int i, int i2, int i3) {
        if ((i3 & 1) != 0) {
            i = 0;
        }
        if ((i3 & 2) != 0) {
            i2 = c1054.mo3458();
        }
        return c1054.mo3457(i, i2);
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public static int m3452(C1054 c1054, C1054 c10542) {
        int iMo3458 = c1054.mo3458();
        c1054.getClass();
        return c1054.mo3468(iMo3458, c10542.mo3465());
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static int m3453(C1054 c1054, C1054 c10542) {
        c1054.getClass();
        return c1054.mo3461(0, c10542.mo3465());
    }

    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof C1054) {
            C1054 c1054 = (C1054) obj;
            int iMo3458 = c1054.mo3458();
            byte[] bArr = this.f4544;
            if (iMo3458 == bArr.length && c1054.mo3466(0, 0, bArr.length, bArr)) {
                return true;
            }
        }
        return false;
    }

    public int hashCode() {
        int i = this.f4546;
        if (i != 0) {
            return i;
        }
        int iHashCode = Arrays.hashCode(this.f4544);
        this.f4546 = iHashCode;
        return iHashCode;
    }

    public String toString() {
        byte b;
        int i;
        C1054 c1054 = this;
        byte[] bArr = c1054.f4544;
        if (bArr.length == 0) {
            return "[size=0]";
        }
        int length = bArr.length;
        int i2 = 0;
        int i3 = 0;
        int i4 = 0;
        loop0: while (true) {
            if (i2 >= length) {
                break;
            }
            byte b2 = bArr[i2];
            if (b2 >= 0) {
                int i5 = i4 + 1;
                if (i4 == 64) {
                    break;
                }
                if ((b2 != 10 && b2 != 13 && ((b2 >= 0 && b2 < 32) || (127 <= b2 && b2 < 160))) || b2 == 65533) {
                    break;
                }
                i3 += b2 < 65536 ? 1 : 2;
                i2++;
                while (true) {
                    i4 = i5;
                    if (i2 < length && (b = bArr[i2]) >= 0) {
                        i2++;
                        i5 = i4 + 1;
                        if (i4 == 64) {
                            break loop0;
                        }
                        if ((b != 10 && b != 13 && ((b >= 0 && b < 32) || (127 <= b && b < 160))) || b == 65533) {
                            break loop0;
                        }
                        i3 += b < 65536 ? 1 : 2;
                    } else {
                        break;
                    }
                }
            } else if ((b2 >> 5) == -2) {
                int i6 = i2 + 1;
                if (length > i6) {
                    byte b3 = bArr[i6];
                    if ((b3 & 192) == 128) {
                        int i7 = (b3 ^ 3968) ^ (b2 << 6);
                        if (i7 >= 128) {
                            i = i4 + 1;
                            if (i4 == 64) {
                                break;
                            }
                            if ((i7 != 10 && i7 != 13 && ((i7 >= 0 && i7 < 32) || (127 <= i7 && i7 < 160))) || i7 == 65533) {
                                break;
                            }
                            i3 += i7 < 65536 ? 1 : 2;
                            i2 += 2;
                            i4 = i;
                        } else if (i4 != 64) {
                            break;
                        }
                    } else if (i4 != 64) {
                        break;
                    }
                } else if (i4 != 64) {
                    break;
                }
            } else if ((b2 >> 4) == -2) {
                int i8 = i2 + 2;
                if (length > i8) {
                    byte b4 = bArr[i2 + 1];
                    if ((b4 & 192) == 128) {
                        byte b5 = bArr[i8];
                        if ((b5 & 192) == 128) {
                            int i9 = ((b5 ^ (-123008)) ^ (b4 << 6)) ^ (b2 << 12);
                            if (i9 < 2048) {
                                if (i4 != 64) {
                                    break;
                                }
                            } else if (55296 > i9 || i9 >= 57344) {
                                i = i4 + 1;
                                if (i4 == 64) {
                                    break;
                                }
                                if ((i9 != 10 && i9 != 13 && ((i9 >= 0 && i9 < 32) || (127 <= i9 && i9 < 160))) || i9 == 65533) {
                                    break;
                                }
                                i3 += i9 < 65536 ? 1 : 2;
                                i2 += 3;
                                i4 = i;
                            } else if (i4 != 64) {
                                break;
                            }
                        } else if (i4 != 64) {
                            break;
                        }
                    } else if (i4 != 64) {
                        break;
                    }
                } else if (i4 != 64) {
                    break;
                }
            } else if ((b2 >> 3) == -2) {
                int i10 = i2 + 3;
                if (length > i10) {
                    byte b6 = bArr[i2 + 1];
                    if ((b6 & 192) == 128) {
                        byte b7 = bArr[i2 + 2];
                        if ((b7 & 192) == 128) {
                            byte b8 = bArr[i10];
                            if ((b8 & 192) == 128) {
                                int i11 = (((b8 ^ 3678080) ^ (b7 << 6)) ^ (b6 << 12)) ^ (b2 << 18);
                                if (i11 > 1114111) {
                                    if (i4 != 64) {
                                        break;
                                    }
                                } else if (55296 > i11 || i11 >= 57344) {
                                    if (i11 >= 65536) {
                                        i = i4 + 1;
                                        if (i4 == 64) {
                                            break;
                                        }
                                        if ((i11 != 10 && i11 != 13 && ((i11 >= 0 && i11 < 32) || (127 <= i11 && i11 < 160))) || i11 == 65533) {
                                            break;
                                        }
                                        i3 += i11 < 65536 ? 1 : 2;
                                        i2 += 4;
                                        i4 = i;
                                    } else if (i4 != 64) {
                                        break;
                                    }
                                } else if (i4 != 64) {
                                    break;
                                }
                            } else if (i4 != 64) {
                                break;
                            }
                        } else if (i4 != 64) {
                            break;
                        }
                    } else if (i4 != 64) {
                        break;
                    }
                } else if (i4 != 64) {
                    break;
                }
            } else if (i4 != 64) {
                break;
            }
        }
        i3 = -1;
        if (i3 != -1) {
            String strM3463 = c1054.m3463();
            String strM11138 = AbstractC5498.m11138(AbstractC5498.m11138(AbstractC5498.m11138(strM3463.substring(0, i3), "\\", "\\\\", false), "\n", "\\n", false), "\r", "\\r", false);
            if (i3 >= strM3463.length()) {
                return "[text=" + strM11138 + ']';
            }
            return "[size=" + bArr.length + " text=" + strM11138 + "…]";
        }
        if (bArr.length <= 64) {
            return "[hex=" + c1054.mo3467() + ']';
        }
        StringBuilder sb = new StringBuilder("[size=");
        sb.append(bArr.length);
        sb.append(" hex=");
        if (64 > bArr.length) {
            ᵕᵩʽᵲ.ᵵᵽ(bArr.length, 41, "endIndex > length(");
            return null;
        }
        if (64 != bArr.length) {
            c1054 = new C1054(AbstractC3761.m8423(bArr, 0, 64));
        }
        sb.append(c1054.mo3467());
        sb.append("…]");
        return sb.toString();
    }

    @Override // java.lang.Comparable
    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final int compareTo(C1054 c1054) {
        int iMo3458 = mo3458();
        int iMo34582 = c1054.mo3458();
        int iMin = Math.min(iMo3458, iMo34582);
        for (int i = 0; i < iMin; i++) {
            int iMo3456 = mo3456(i) & 255;
            int iMo34562 = c1054.mo3456(i) & 255;
            if (iMo3456 != iMo34562) {
                return iMo3456 < iMo34562 ? -1 : 1;
            }
        }
        if (iMo3458 == iMo34582) {
            return 0;
        }
        return iMo3458 < iMo34582 ? -1 : 1;
    }

    /* JADX INFO: renamed from: ˊᵙᵾᵲ, reason: contains not printable characters */
    public void mo3455(C4903 c4903, int i) {
        c4903.write(this.f4544, 0, i);
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public byte mo3456(int i) {
        return this.f4544[i];
    }

    /* JADX INFO: renamed from: ˋˈ, reason: contains not printable characters */
    public C1054 mo3457(int i, int i2) {
        if (i < 0) {
            ᵕᵩʽᵲ.ᵮᵣᵗˈ("beginIndex < 0");
            return null;
        }
        byte[] bArr = this.f4544;
        if (i2 > bArr.length) {
            ᵕᵩʽᵲ.ᵵᵽ(bArr.length, 41, "endIndex > length(");
            return null;
        }
        if (i2 - i >= 0) {
            return (i == 0 && i2 == bArr.length) ? this : new C1054(AbstractC3761.m8423(bArr, i, i2));
        }
        ᵕᵩʽᵲ.ᵮᵣᵗˈ("endIndex < beginIndex");
        return null;
    }

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public int mo3458() {
        return this.f4544.length;
    }

    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public String mo3459(Charset charset) {
        return new String(this.f4544, charset);
    }

    /* JADX INFO: renamed from: ᵟᵹᵙ, reason: contains not printable characters */
    public C1054 mo3460() {
        int i = 0;
        while (true) {
            byte[] bArr = this.f4544;
            if (i >= bArr.length) {
                return this;
            }
            byte b = bArr[i];
            if (b >= 65 && b <= 90) {
                byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
                bArrCopyOf[i] = (byte) (b + 32);
                for (int i2 = i + 1; i2 < bArrCopyOf.length; i2++) {
                    byte b2 = bArrCopyOf[i2];
                    if (b2 >= 65 && b2 <= 90) {
                        bArrCopyOf[i2] = (byte) (b2 + 32);
                    }
                }
                return new C1054(bArrCopyOf);
            }
            i++;
        }
    }

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public int mo3461(int i, byte[] bArr) {
        byte[] bArr2 = this.f4544;
        int length = bArr2.length - bArr.length;
        int iMax = Math.max(i, 0);
        if (iMax > length) {
            return -1;
        }
        while (!ᵻᵪ.ʽˈˋ(bArr2, iMax, bArr, 0, bArr.length)) {
            if (iMax == length) {
                return -1;
            }
            iMax++;
        }
        return iMax;
    }

    /* JADX INFO: renamed from: ᵮᵣᵗˈ, reason: contains not printable characters */
    public boolean mo3462(int i, C1054 c1054, int i2) {
        return c1054.mo3466(0, i, i2, this.f4544);
    }

    /* JADX INFO: renamed from: ᵱʡˏ, reason: contains not printable characters */
    public final String m3463() {
        String str = this.f4545;
        if (str != null) {
            return str;
        }
        String str2 = new String(mo3465(), AbstractC4490.f17115);
        this.f4545 = str2;
        return str2;
    }

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public String mo3464() {
        byte[] bArr = AbstractC4538.f17263;
        byte[] bArr2 = this.f4544;
        byte[] bArr3 = new byte[((bArr2.length + 2) / 3) * 4];
        int length = bArr2.length - (bArr2.length % 3);
        int i = 0;
        int i2 = 0;
        while (i < length) {
            byte b = bArr2[i];
            int i3 = i + 2;
            byte b2 = bArr2[i + 1];
            i += 3;
            byte b3 = bArr2[i3];
            bArr3[i2] = bArr[(b & 255) >> 2];
            bArr3[i2 + 1] = bArr[((b & 3) << 4) | ((b2 & 255) >> 4)];
            int i4 = i2 + 3;
            bArr3[i2 + 2] = bArr[((b2 & 15) << 2) | ((b3 & 255) >> 6)];
            i2 += 4;
            bArr3[i4] = bArr[b3 & 63];
        }
        int length2 = bArr2.length - length;
        if (length2 == 1) {
            byte b4 = bArr2[i];
            bArr3[i2] = bArr[(b4 & 255) >> 2];
            bArr3[i2 + 1] = bArr[(b4 & 3) << 4];
            bArr3[i2 + 2] = 61;
            bArr3[i2 + 3] = 61;
        } else if (length2 == 2) {
            int i5 = i + 1;
            byte b5 = bArr2[i];
            byte b6 = bArr2[i5];
            bArr3[i2] = bArr[(b5 & 255) >> 2];
            bArr3[i2 + 1] = bArr[((b5 & 3) << 4) | ((b6 & 255) >> 4)];
            bArr3[i2 + 2] = bArr[(b6 & 15) << 2];
            bArr3[i2 + 3] = 61;
        }
        return new String(bArr3, AbstractC4490.f17115);
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public byte[] mo3465() {
        return this.f4544;
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public boolean mo3466(int i, int i2, int i3, byte[] bArr) {
        if (i < 0) {
            return false;
        }
        byte[] bArr2 = this.f4544;
        return i <= bArr2.length - i3 && i2 >= 0 && i2 <= bArr.length - i3 && ᵻᵪ.ʽˈˋ(bArr2, i, bArr, i2, i3);
    }

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public String mo3467() {
        byte[] bArr = this.f4544;
        char[] cArr = new char[bArr.length * 2];
        int i = 0;
        for (byte b : bArr) {
            int i2 = i + 1;
            char[] cArr2 = ᵥˇᵛˎ.ʽˈˋ;
            cArr[i] = cArr2[(b >> 4) & 15];
            i += 2;
            cArr[i2] = cArr2[b & 15];
        }
        return new String(cArr);
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public int mo3468(int i, byte[] bArr) {
        byte[] bArr2 = this.f4544;
        for (int iMin = Math.min(i, bArr2.length - bArr.length); -1 < iMin; iMin--) {
            if (ᵻᵪ.ʽˈˋ(bArr2, iMin, bArr, 0, bArr.length)) {
                return iMin;
            }
        }
        return -1;
    }
}