discord-jadx/app/src/main/java/okio/ByteString.java

package okio;

import b.i.a.f.e.o.f;
import d0.g0.c;
import d0.g0.t;
import d0.t.j;
import d0.z.d.m;
import g0.e;
import g0.z.b;
import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.util.Arrays;
import kotlin.jvm.internal.DefaultConstructorMarker;
/* compiled from: ByteString.kt */
public class ByteString implements Serializable, Comparable<ByteString> {
    public static final ByteString j = new ByteString(new byte[0]);
    public static final a k = new a(null);
    private static final long serialVersionUID = 1;
    private final byte[] data;
    public transient int l;
    public transient String m;

    /* compiled from: ByteString.kt */
    public static final class a {
        public a(DefaultConstructorMarker defaultConstructorMarker) {
        }

        public static ByteString d(a aVar, byte[] bArr, int i, int i2, int i3) {
            if ((i3 & 1) != 0) {
                i = 0;
            }
            if ((i3 & 2) != 0) {
                i2 = bArr.length;
            }
            m.checkParameterIsNotNull(bArr, "$this$toByteString");
            f.A((long) bArr.length, (long) i, (long) i2);
            return new ByteString(j.copyOfRange(bArr, i, i2 + i));
        }

        public final ByteString a(String str) {
            m.checkParameterIsNotNull(str, "$this$decodeHex");
            if (str.length() % 2 == 0) {
                int length = str.length() / 2;
                byte[] bArr = new byte[length];
                for (int i = 0; i < length; i++) {
                    int i2 = i * 2;
                    bArr[i] = (byte) (b.a(str.charAt(i2 + 1)) + (b.a(str.charAt(i2)) << 4));
                }
                return new ByteString(bArr);
            }
            throw new IllegalArgumentException(b.d.b.a.a.v("Unexpected hex string: ", str).toString());
        }

        public final ByteString b(String str, Charset charset) {
            m.checkParameterIsNotNull(str, "$this$encode");
            m.checkParameterIsNotNull(charset, "charset");
            byte[] bytes = str.getBytes(charset);
            m.checkExpressionValueIsNotNull(bytes, "(this as java.lang.String).getBytes(charset)");
            return new ByteString(bytes);
        }

        public final ByteString c(String str) {
            m.checkParameterIsNotNull(str, "$this$encodeUtf8");
            m.checkParameterIsNotNull(str, "$this$asUtf8ToByteArray");
            byte[] bytes = str.getBytes(c.a);
            m.checkExpressionValueIsNotNull(bytes, "(this as java.lang.String).getBytes(charset)");
            ByteString byteString = new ByteString(bytes);
            byteString.m = str;
            return byteString;
        }
    }

    public ByteString(byte[] bArr) {
        m.checkParameterIsNotNull(bArr, "data");
        this.data = bArr;
    }

    public static final ByteString h(String str) {
        m.checkParameterIsNotNull(str, "$this$encodeUtf8");
        m.checkParameterIsNotNull(str, "$this$asUtf8ToByteArray");
        byte[] bytes = str.getBytes(c.a);
        m.checkExpressionValueIsNotNull(bytes, "(this as java.lang.String).getBytes(charset)");
        ByteString byteString = new ByteString(bytes);
        byteString.m = str;
        return byteString;
    }

    private final void readObject(ObjectInputStream objectInputStream) throws IOException {
        int readInt = objectInputStream.readInt();
        m.checkParameterIsNotNull(objectInputStream, "$this$readByteString");
        int i = 0;
        if (readInt >= 0) {
            byte[] bArr = new byte[readInt];
            while (i < readInt) {
                int read = objectInputStream.read(bArr, i, readInt - i);
                if (read != -1) {
                    i += read;
                } else {
                    throw new EOFException();
                }
            }
            ByteString byteString = new ByteString(bArr);
            Field declaredField = ByteString.class.getDeclaredField("data");
            m.checkExpressionValueIsNotNull(declaredField, "field");
            declaredField.setAccessible(true);
            declaredField.set(this, byteString.data);
            return;
        }
        throw new IllegalArgumentException(b.d.b.a.a.p("byteCount < 0: ", readInt).toString());
    }

    private final void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
        objectOutputStream.writeInt(this.data.length);
        objectOutputStream.write(this.data);
    }

    /* JADX DEBUG: Method arguments types fixed to match base method, original types: [java.lang.Object] */
    /* JADX WARNING: Removed duplicated region for block: B:8:0x0030 A[RETURN, SYNTHETIC] */
    /* JADX WARNING: Removed duplicated region for block: B:9:0x0032 A[ORIG_RETURN, RETURN, SYNTHETIC] */
    @Override // java.lang.Comparable
    public int compareTo(ByteString byteString) {
        ByteString byteString2 = byteString;
        m.checkParameterIsNotNull(byteString2, "other");
        int j2 = j();
        int j3 = byteString2.j();
        int min = Math.min(j2, j3);
        for (int i = 0; i < min; i++) {
            int m = m(i) & 255;
            int m2 = byteString2.m(i) & 255;
            if (m != m2) {
                return m < m2 ? -1 : 1;
            }
        }
        if (j2 == j3) {
            return 0;
        }
        if (j2 < j3) {
        }
    }

    @Override // java.lang.Object
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof ByteString) {
            ByteString byteString = (ByteString) obj;
            int j2 = byteString.j();
            byte[] bArr = this.data;
            if (j2 == bArr.length && byteString.o(0, bArr, 0, bArr.length)) {
                return true;
            }
        }
        return false;
    }

    public String f() {
        byte[] bArr = this.data;
        byte[] bArr2 = g0.a.a;
        byte[] bArr3 = g0.a.a;
        m.checkParameterIsNotNull(bArr, "$this$encodeBase64");
        m.checkParameterIsNotNull(bArr3, "map");
        byte[] bArr4 = new byte[(((bArr.length + 2) / 3) * 4)];
        int length = bArr.length - (bArr.length % 3);
        int i = 0;
        int i2 = 0;
        while (i < length) {
            int i3 = i + 1;
            byte b2 = bArr[i];
            int i4 = i3 + 1;
            byte b3 = bArr[i3];
            int i5 = i4 + 1;
            byte b4 = bArr[i4];
            int i6 = i2 + 1;
            bArr4[i2] = bArr3[(b2 & 255) >> 2];
            int i7 = i6 + 1;
            bArr4[i6] = bArr3[((b2 & 3) << 4) | ((b3 & 255) >> 4)];
            int i8 = i7 + 1;
            bArr4[i7] = bArr3[((b3 & 15) << 2) | ((b4 & 255) >> 6)];
            i2 = i8 + 1;
            bArr4[i8] = bArr3[b4 & 63];
            i = i5;
        }
        int length2 = bArr.length - length;
        if (length2 == 1) {
            byte b5 = bArr[i];
            int i9 = i2 + 1;
            bArr4[i2] = bArr3[(b5 & 255) >> 2];
            int i10 = i9 + 1;
            bArr4[i9] = bArr3[(b5 & 3) << 4];
            byte b6 = (byte) 61;
            bArr4[i10] = b6;
            bArr4[i10 + 1] = b6;
        } else if (length2 == 2) {
            int i11 = i + 1;
            byte b7 = bArr[i];
            byte b8 = bArr[i11];
            int i12 = i2 + 1;
            bArr4[i2] = bArr3[(b7 & 255) >> 2];
            int i13 = i12 + 1;
            bArr4[i12] = bArr3[((b7 & 3) << 4) | ((b8 & 255) >> 4)];
            bArr4[i13] = bArr3[(b8 & 15) << 2];
            bArr4[i13 + 1] = (byte) 61;
        }
        m.checkParameterIsNotNull(bArr4, "$this$toUtf8String");
        return new String(bArr4, c.a);
    }

    public ByteString g(String str) {
        m.checkParameterIsNotNull(str, "algorithm");
        byte[] digest = MessageDigest.getInstance(str).digest(this.data);
        m.checkExpressionValueIsNotNull(digest, "MessageDigest.getInstance(algorithm).digest(data)");
        return new ByteString(digest);
    }

    @Override // java.lang.Object
    public int hashCode() {
        int i = this.l;
        if (i != 0) {
            return i;
        }
        int hashCode = Arrays.hashCode(this.data);
        this.l = hashCode;
        return hashCode;
    }

    public final byte[] i() {
        return this.data;
    }

    public int j() {
        return this.data.length;
    }

    public String k() {
        byte[] bArr = this.data;
        char[] cArr = new char[(bArr.length * 2)];
        int i = 0;
        for (byte b2 : bArr) {
            int i2 = i + 1;
            char[] cArr2 = b.a;
            cArr[i] = cArr2[(b2 >> 4) & 15];
            i = i2 + 1;
            cArr[i2] = cArr2[b2 & 15];
        }
        return new String(cArr);
    }

    public byte[] l() {
        return this.data;
    }

    public byte m(int i) {
        return this.data[i];
    }

    public boolean n(int i, ByteString byteString, int i2, int i3) {
        m.checkParameterIsNotNull(byteString, "other");
        return byteString.o(i2, this.data, i, i3);
    }

    public boolean o(int i, byte[] bArr, int i2, int i3) {
        m.checkParameterIsNotNull(bArr, "other");
        if (i >= 0) {
            byte[] bArr2 = this.data;
            if (i <= bArr2.length - i3 && i2 >= 0 && i2 <= bArr.length - i3 && f.g(bArr2, i, bArr, i2, i3)) {
                return true;
            }
        }
        return false;
    }

    public ByteString p() {
        byte b2;
        int i = 0;
        while (true) {
            byte[] bArr = this.data;
            if (i >= bArr.length) {
                return this;
            }
            byte b3 = bArr[i];
            byte b4 = (byte) 65;
            if (b3 < b4 || b3 > (b2 = (byte) 90)) {
                i++;
            } else {
                byte[] copyOf = Arrays.copyOf(bArr, bArr.length);
                m.checkExpressionValueIsNotNull(copyOf, "java.util.Arrays.copyOf(this, size)");
                copyOf[i] = (byte) (b3 + 32);
                for (int i2 = i + 1; i2 < copyOf.length; i2++) {
                    byte b5 = copyOf[i2];
                    if (b5 >= b4 && b5 <= b2) {
                        copyOf[i2] = (byte) (b5 + 32);
                    }
                }
                return new ByteString(copyOf);
            }
        }
    }

    public String q() {
        String str = this.m;
        if (str != null) {
            return str;
        }
        byte[] l = l();
        m.checkParameterIsNotNull(l, "$this$toUtf8String");
        String str2 = new String(l, c.a);
        this.m = str2;
        return str2;
    }

    public void r(OutputStream outputStream) throws IOException {
        m.checkParameterIsNotNull(outputStream, "out");
        outputStream.write(this.data);
    }

    public void s(e eVar, int i, int i2) {
        m.checkParameterIsNotNull(eVar, "buffer");
        m.checkParameterIsNotNull(this, "$this$commonWrite");
        m.checkParameterIsNotNull(eVar, "buffer");
        eVar.S(this.data, i, i2);
    }

    /* JADX WARNING: Code restructure failed: missing block: B:101:0x0120, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:127:0x015e, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:133:0x0171, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:139:0x0182, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:145:0x0191, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:148:0x01a7, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:151:0x01af, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:154:0x01b6, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:177:0x01eb, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:178:0x01ee, code lost:
        r5 = -1;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:51:0x0089, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:57:0x009a, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:60:0x00a5, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:83:0x00e3, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:89:0x00f6, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:95:0x0105, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    /* JADX WARNING: Code restructure failed: missing block: B:98:0x0117, code lost:
        if (r4 == 64) goto L_0x01ef;
     */
    @Override // java.lang.Object
    public String toString() {
        byte[] bArr = this.data;
        if (bArr.length == 0) {
            return "[size=0]";
        }
        int length = bArr.length;
        int i = 0;
        int i2 = 0;
        int i3 = 0;
        loop0:
        while (true) {
            if (i >= length) {
                break;
            }
            byte b2 = bArr[i];
            if (b2 >= 0) {
                int i4 = i2 + 1;
                if (i2 == 64) {
                    break;
                }
                if (!(b2 == 10 || b2 == 13)) {
                    if ((b2 >= 0 && 31 >= b2) || (Byte.MAX_VALUE <= b2 && 159 >= b2)) {
                        break;
                    }
                }
                if (b2 == 65533) {
                    break;
                }
                i3 += b2 < 65536 ? 1 : 2;
                i++;
                while (true) {
                    i2 = i4;
                    if (i >= length || bArr[i] < 0) {
                        break;
                    }
                    int i5 = i + 1;
                    byte b3 = bArr[i];
                    i4 = i2 + 1;
                    if (i2 == 64) {
                        break loop0;
                    }
                    if (!(b3 == 10 || b3 == 13)) {
                        if ((b3 >= 0 && 31 >= b3) || (Byte.MAX_VALUE <= b3 && 159 >= b3)) {
                            break loop0;
                        }
                    }
                    if (b3 == 65533) {
                        break loop0;
                    }
                    i3 += b3 < 65536 ? 1 : 2;
                    i = i5;
                }
            } else if ((b2 >> 5) == -2) {
                int i6 = i + 1;
                if (length > i6) {
                    byte b4 = bArr[i];
                    byte b5 = bArr[i6];
                    if ((b5 & 192) == 128) {
                        int i7 = (b5 ^ 3968) ^ (b4 << 6);
                        if (i7 >= 128) {
                            int i8 = i2 + 1;
                            if (i2 == 64) {
                                break;
                            }
                            if (!(i7 == 10 || i7 == 13)) {
                                if ((i7 >= 0 && 31 >= i7) || (127 <= i7 && 159 >= i7)) {
                                    break;
                                }
                            }
                            if (i7 == 65533) {
                                break;
                            }
                            i3 += i7 < 65536 ? 1 : 2;
                            i += 2;
                            i2 = i8;
                        }
                    }
                }
            } else if ((b2 >> 4) == -2) {
                int i9 = i + 2;
                if (length > i9) {
                    byte b6 = bArr[i];
                    byte b7 = bArr[i + 1];
                    if ((b7 & 192) == 128) {
                        byte b8 = bArr[i9];
                        if ((b8 & 192) == 128) {
                            int i10 = ((b8 ^ -123008) ^ (b7 << 6)) ^ (b6 << 12);
                            if (i10 >= 2048) {
                                if (55296 > i10 || 57343 < i10) {
                                    int i11 = i2 + 1;
                                    if (i2 == 64) {
                                        break;
                                    }
                                    if (!(i10 == 10 || i10 == 13)) {
                                        if ((i10 >= 0 && 31 >= i10) || (127 <= i10 && 159 >= i10)) {
                                            break;
                                        }
                                    }
                                    if (i10 == 65533) {
                                        break;
                                    }
                                    i3 += i10 < 65536 ? 1 : 2;
                                    i += 3;
                                    i2 = i11;
                                }
                            }
                        }
                    }
                }
            } else if ((b2 >> 3) == -2) {
                int i12 = i + 3;
                if (length > i12) {
                    byte b9 = bArr[i];
                    byte b10 = bArr[i + 1];
                    if ((b10 & 192) == 128) {
                        byte b11 = bArr[i + 2];
                        if ((b11 & 192) == 128) {
                            byte b12 = bArr[i12];
                            if ((b12 & 192) == 128) {
                                int i13 = (((b12 ^ 3678080) ^ (b11 << 6)) ^ (b10 << 12)) ^ (b9 << 18);
                                if (i13 <= 1114111) {
                                    if (55296 > i13 || 57343 < i13) {
                                        if (i13 >= 65536) {
                                            int i14 = i2 + 1;
                                            if (i2 == 64) {
                                                break;
                                            }
                                            if (!(i13 == 10 || i13 == 13)) {
                                                if ((i13 >= 0 && 31 >= i13) || (127 <= i13 && 159 >= i13)) {
                                                    break;
                                                }
                                            }
                                            if (i13 == 65533) {
                                                break;
                                            }
                                            i3 += i13 < 65536 ? 1 : 2;
                                            i += 4;
                                            i2 = i14;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if (i3 != -1) {
            String q = q();
            String substring = q.substring(0, i3);
            m.checkExpressionValueIsNotNull(substring, "(this as java.lang.Strin…ing(startIndex, endIndex)");
            String replace$default = t.replace$default(t.replace$default(t.replace$default(substring, "\\", "\\\\", false, 4, (Object) null), "\n", "\\n", false, 4, (Object) null), "\r", "\\r", false, 4, (Object) null);
            if (i3 < q.length()) {
                StringBuilder R = b.d.b.a.a.R("[size=");
                R.append(this.data.length);
                R.append(" text=");
                R.append(replace$default);
                R.append("…]");
                return R.toString();
            }
            return "[text=" + replace$default + ']';
        } else if (this.data.length <= 64) {
            StringBuilder R2 = b.d.b.a.a.R("[hex=");
            R2.append(k());
            R2.append(']');
            return R2.toString();
        } else {
            StringBuilder R3 = b.d.b.a.a.R("[size=");
            R3.append(this.data.length);
            R3.append(" hex=");
            byte[] bArr2 = this.data;
            if (64 <= bArr2.length) {
                R3.append((64 == bArr2.length ? this : new ByteString(j.copyOfRange(bArr2, 0, 64))).k());
                R3.append("…]");
                return R3.toString();
            }
            throw new IllegalArgumentException(b.d.b.a.a.z(b.d.b.a.a.R("endIndex > length("), this.data.length, ')').toString());
        }
    }
}