Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/okio/SegmentedByteString.java

@@ -0,0 +1,245 @@
+package okio;
+
+import java.util.Arrays;
+
+/* loaded from: classes5.dex */
+public final class SegmentedByteString extends ByteString {
+    public final transient int[] directory;
+    public final transient byte[][] segments;
+
+    public SegmentedByteString(Buffer buffer, int i) {
+        super(null);
+        Util.checkOffsetAndCount(buffer.size, 0L, i);
+        Segment segment = buffer.head;
+        int i2 = 0;
+        int i3 = 0;
+        int i4 = 0;
+        while (i3 < i) {
+            int i5 = segment.limit;
+            int i6 = segment.pos;
+            if (i5 != i6) {
+                i3 += i5 - i6;
+                i4++;
+                segment = segment.next;
+            } else {
+                throw new AssertionError("s.limit == s.pos");
+            }
+        }
+        this.segments = new byte[i4][];
+        this.directory = new int[i4 * 2];
+        Segment segment2 = buffer.head;
+        int i7 = 0;
+        while (i2 < i) {
+            byte[][] bArr = this.segments;
+            bArr[i7] = segment2.data;
+            int i8 = segment2.limit;
+            int i9 = segment2.pos;
+            i2 += i8 - i9;
+            if (i2 > i) {
+                i2 = i;
+            }
+            int[] iArr = this.directory;
+            iArr[i7] = i2;
+            iArr[bArr.length + i7] = i9;
+            segment2.shared = true;
+            i7++;
+            segment2 = segment2.next;
+        }
+    }
+
+    @Override // okio.ByteString
+    public String utf8() {
+        return toByteString().utf8();
+    }
+
+    @Override // okio.ByteString
+    public String base64() {
+        return toByteString().base64();
+    }
+
+    @Override // okio.ByteString
+    public String hex() {
+        return toByteString().hex();
+    }
+
+    @Override // okio.ByteString
+    public ByteString toAsciiLowercase() {
+        return toByteString().toAsciiLowercase();
+    }
+
+    @Override // okio.ByteString
+    public ByteString md5() {
+        return toByteString().md5();
+    }
+
+    @Override // okio.ByteString
+    public ByteString sha256() {
+        return toByteString().sha256();
+    }
+
+    @Override // okio.ByteString
+    public ByteString substring(int i, int i2) {
+        return toByteString().substring(i, i2);
+    }
+
+    @Override // okio.ByteString
+    public byte getByte(int i) {
+        Util.checkOffsetAndCount(this.directory[this.segments.length - 1], i, 1L);
+        int segment = segment(i);
+        int i2 = segment == 0 ? 0 : this.directory[segment - 1];
+        int[] iArr = this.directory;
+        byte[][] bArr = this.segments;
+        return bArr[segment][(i - i2) + iArr[bArr.length + segment]];
+    }
+
+    public final int segment(int i) {
+        int binarySearch = Arrays.binarySearch(this.directory, 0, this.segments.length, i + 1);
+        return binarySearch >= 0 ? binarySearch : ~binarySearch;
+    }
+
+    @Override // okio.ByteString
+    public int size() {
+        return this.directory[this.segments.length - 1];
+    }
+
+    @Override // okio.ByteString
+    public byte[] toByteArray() {
+        int[] iArr = this.directory;
+        byte[][] bArr = this.segments;
+        byte[] bArr2 = new byte[iArr[bArr.length - 1]];
+        int length = bArr.length;
+        int i = 0;
+        int i2 = 0;
+        while (i < length) {
+            int[] iArr2 = this.directory;
+            int i3 = iArr2[length + i];
+            int i4 = iArr2[i];
+            System.arraycopy(this.segments[i], i3, bArr2, i2, i4 - i2);
+            i++;
+            i2 = i4;
+        }
+        return bArr2;
+    }
+
+    @Override // okio.ByteString
+    public void write(Buffer buffer) {
+        int length = this.segments.length;
+        int i = 0;
+        int i2 = 0;
+        while (i < length) {
+            int[] iArr = this.directory;
+            int i3 = iArr[length + i];
+            int i4 = iArr[i];
+            Segment segment = new Segment(this.segments[i], i3, (i3 + i4) - i2, true, false);
+            Segment segment2 = buffer.head;
+            if (segment2 == null) {
+                segment.prev = segment;
+                segment.next = segment;
+                buffer.head = segment;
+            } else {
+                segment2.prev.push(segment);
+            }
+            i++;
+            i2 = i4;
+        }
+        buffer.size += i2;
+    }
+
+    @Override // okio.ByteString
+    public boolean rangeEquals(int i, ByteString byteString, int i2, int i3) {
+        if (i < 0 || i > size() - i3) {
+            return false;
+        }
+        int segment = segment(i);
+        while (i3 > 0) {
+            int i4 = segment == 0 ? 0 : this.directory[segment - 1];
+            int min = Math.min(i3, ((this.directory[segment] - i4) + i4) - i);
+            int[] iArr = this.directory;
+            byte[][] bArr = this.segments;
+            if (!byteString.rangeEquals(i2, bArr[segment], (i - i4) + iArr[bArr.length + segment], min)) {
+                return false;
+            }
+            i += min;
+            i2 += min;
+            i3 -= min;
+            segment++;
+        }
+        return true;
+    }
+
+    @Override // okio.ByteString
+    public boolean rangeEquals(int i, byte[] bArr, int i2, int i3) {
+        if (i < 0 || i > size() - i3 || i2 < 0 || i2 > bArr.length - i3) {
+            return false;
+        }
+        int segment = segment(i);
+        while (i3 > 0) {
+            int i4 = segment == 0 ? 0 : this.directory[segment - 1];
+            int min = Math.min(i3, ((this.directory[segment] - i4) + i4) - i);
+            int[] iArr = this.directory;
+            byte[][] bArr2 = this.segments;
+            if (!Util.arrayRangeEquals(bArr2[segment], (i - i4) + iArr[bArr2.length + segment], bArr, i2, min)) {
+                return false;
+            }
+            i += min;
+            i2 += min;
+            i3 -= min;
+            segment++;
+        }
+        return true;
+    }
+
+    public final ByteString toByteString() {
+        return new ByteString(toByteArray());
+    }
+
+    @Override // okio.ByteString
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof ByteString) {
+            ByteString byteString = (ByteString) obj;
+            if (byteString.size() == size() && rangeEquals(0, byteString, 0, size())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // okio.ByteString
+    public int hashCode() {
+        int i = this.hashCode;
+        if (i != 0) {
+            return i;
+        }
+        int length = this.segments.length;
+        int i2 = 0;
+        int i3 = 1;
+        int i4 = 0;
+        while (i2 < length) {
+            byte[] bArr = this.segments[i2];
+            int[] iArr = this.directory;
+            int i5 = iArr[length + i2];
+            int i6 = iArr[i2];
+            int i7 = (i6 - i4) + i5;
+            while (i5 < i7) {
+                i3 = (i3 * 31) + bArr[i5];
+                i5++;
+            }
+            i2++;
+            i4 = i6;
+        }
+        this.hashCode = i3;
+        return i3;
+    }
+
+    @Override // okio.ByteString
+    public String toString() {
+        return toByteString().toString();
+    }
+
+    private Object writeReplace() {
+        return toByteString();
+    }
+}