package defpackage;

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

/* renamed from: ᵎᵢ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public class C2185 implements Serializable, Comparable {

    /* renamed from: ᵾᵬ, reason: contains not printable characters */
    public static final C2185 f8597 = new C2185(new byte[0]);

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public transient int f8598;

    /* renamed from: ᵧᵾˀˈ, reason: contains not printable characters */
    public final byte[] f8599;

    /* renamed from: ᵿʗᵝʽ, reason: contains not printable characters */
    public transient String f8600;

    public C2185(byte[] bArr) {
        this.f8599 = bArr;
    }

    /* renamed from: ˏˋٴ, reason: contains not printable characters */
    public static int m5833(C2185 c2185, C2185 c21852) {
        c2185.getClass();
        return c2185.mo5836(0, c21852.mo5839());
    }

    /* renamed from: ᵳٴᵶ, reason: contains not printable characters */
    public static C2185 m5834(C2185 c2185, int i, int i2, int i3) {
        if ((i3 & 1) != 0) {
            i = 0;
        }
        if ((i3 & 2) != 0) {
            i2 = c2185.mo5840();
        }
        return c2185.mo5844(i, i2);
    }

    /* renamed from: ᵶᵷᵕ, reason: contains not printable characters */
    public static int m5835(C2185 c2185, C2185 c21852) {
        int iMo5840 = c2185.mo5840();
        c2185.getClass();
        return c2185.mo5841(iMo5840, c21852.mo5839());
    }

    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof C2185) {
            C2185 c2185 = (C2185) obj;
            int iMo5840 = c2185.mo5840();
            byte[] bArr = this.f8599;
            if (iMo5840 == bArr.length && c2185.mo5848(0, 0, bArr.length, bArr)) {
                return true;
            }
        }
        return false;
    }

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

    public String toString() {
        byte b;
        int i;
        C2185 c2185 = this;
        byte[] bArr = c2185.f8599;
        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) || (Byte.MAX_VALUE <= 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) || (Byte.MAX_VALUE <= 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 strM5842 = c2185.m5842();
            String strM2048 = AbstractC0436.m2048(AbstractC0436.m2048(AbstractC0436.m2048(strM5842.substring(0, i3), "\\", "\\\\", false), "\n", "\\n", false), "\r", "\\r", false);
            if (i3 >= strM5842.length()) {
                return "[text=" + strM2048 + ']';
            }
            return "[size=" + bArr.length + " text=" + strM2048 + "…]";
        }
        if (bArr.length <= 64) {
            return "[hex=" + c2185.mo5850() + ']';
        }
        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) {
            c2185 = new C2185(AbstractC1658.m4731(bArr, 0, 64));
        }
        sb.append(c2185.mo5850());
        sb.append("…]");
        return sb.toString();
    }

    /* renamed from: ˇʼʤˎ, reason: contains not printable characters */
    public int mo5836(int i, byte[] bArr) {
        byte[] bArr2 = this.f8599;
        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;
    }

    /* renamed from: ˌʾˀ, reason: contains not printable characters */
    public C2185 mo5837() {
        int i = 0;
        while (true) {
            byte[] bArr = this.f8599;
            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 C2185(bArrCopyOf);
            }
            i++;
        }
    }

    /* renamed from: ˌᵜᵹᵩ, reason: contains not printable characters */
    public boolean mo5838(int i, C2185 c2185, int i2) {
        return c2185.mo5848(0, i, i2, this.f8599);
    }

    /* renamed from: ˎˏʜʾ, reason: contains not printable characters */
    public byte[] mo5839() {
        return this.f8599;
    }

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public int mo5840() {
        return this.f8599.length;
    }

    /* renamed from: ᵝᵵᵺ, reason: contains not printable characters */
    public int mo5841(int i, byte[] bArr) {
        byte[] bArr2 = this.f8599;
        for (int iMin = Math.min(i, bArr2.length - bArr.length); -1 < iMin; iMin--) {
            if (ᵩʛʽ.ᵴᵳ(bArr2, iMin, bArr, 0, bArr.length)) {
                return iMin;
            }
        }
        return -1;
    }

    /* renamed from: ᵡʠ, reason: contains not printable characters */
    public final String m5842() {
        String str = this.f8600;
        if (str != null) {
            return str;
        }
        String str2 = new String(mo5839(), AbstractC2356.f9221);
        this.f8600 = str2;
        return str2;
    }

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public String mo5843() {
        byte[] bArr = AbstractC3540.f13274;
        byte[] bArr2 = this.f8599;
        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, AbstractC2356.f9221);
    }

    /* renamed from: ᵪʩ, reason: contains not printable characters */
    public C2185 mo5844(int i, int i2) {
        if (i < 0) {
            ᵹˉᵞ.ˌᵜᵹᵩ("beginIndex < 0");
            return null;
        }
        byte[] bArr = this.f8599;
        if (i2 > bArr.length) {
            ᵹˉᵞ.ˏˋٴ(bArr.length, 41, "endIndex > length(");
            return null;
        }
        if (i2 - i >= 0) {
            return (i == 0 && i2 == bArr.length) ? this : new C2185(AbstractC1658.m4731(bArr, i, i2));
        }
        ᵹˉᵞ.ˌᵜᵹᵩ("endIndex < beginIndex");
        return null;
    }

    /* renamed from: ᵯٴᵦ, reason: contains not printable characters */
    public String mo5845(Charset charset) {
        return new String(this.f8599, charset);
    }

    @Override // java.lang.Comparable
    /* renamed from: ᵴᵳ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final int compareTo(C2185 c2185) {
        int iMo5840 = mo5840();
        int iMo58402 = c2185.mo5840();
        int iMin = Math.min(iMo5840, iMo58402);
        for (int i = 0; i < iMin; i++) {
            int iMo5849 = mo5849(i) & 255;
            int iMo58492 = c2185.mo5849(i) & 255;
            if (iMo5849 != iMo58492) {
                return iMo5849 < iMo58492 ? -1 : 1;
            }
        }
        if (iMo5840 == iMo58402) {
            return 0;
        }
        return iMo5840 < iMo58402 ? -1 : 1;
    }

    /* renamed from: ᵸʓᵠ, reason: contains not printable characters */
    public void mo5847(C0963 c0963, int i) {
        c0963.write(this.f8599, 0, i);
    }

    /* renamed from: ᵸˑ, reason: contains not printable characters */
    public boolean mo5848(int i, int i2, int i3, byte[] bArr) {
        if (i < 0) {
            return false;
        }
        byte[] bArr2 = this.f8599;
        return i <= bArr2.length - i3 && i2 >= 0 && i2 <= bArr.length - i3 && ᵩʛʽ.ᵴᵳ(bArr2, i, bArr, i2, i3);
    }

    /* renamed from: ᵹᵝᵶ, reason: contains not printable characters */
    public byte mo5849(int i) {
        return this.f8599[i];
    }

    /* renamed from: ᵻᵢﹳᵰ, reason: contains not printable characters */
    public String mo5850() {
        byte[] bArr = this.f8599;
        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);
    }
}