ADD week 5

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ArrayReadWriteBuf.java

@@ -0,0 +1,225 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.util.Arrays;
+import kotlin.UByte;
+
+/* loaded from: classes.dex */
+public class ArrayReadWriteBuf implements ReadWriteBuf {
+    private byte[] buffer;
+    private int writePos;
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public byte[] data() {
+        return this.buffer;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf, androidx.emoji2.text.flatbuffer.ReadBuf
+    public int limit() {
+        return this.writePos;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public int writePosition() {
+        return this.writePos;
+    }
+
+    public ArrayReadWriteBuf() {
+        this(10);
+    }
+
+    public ArrayReadWriteBuf(int i) {
+        this(new byte[i]);
+    }
+
+    public ArrayReadWriteBuf(byte[] bArr) {
+        this.buffer = bArr;
+        this.writePos = 0;
+    }
+
+    public ArrayReadWriteBuf(byte[] bArr, int i) {
+        this.buffer = bArr;
+        this.writePos = i;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public boolean getBoolean(int i) {
+        return this.buffer[i] != 0;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public byte get(int i) {
+        return this.buffer[i];
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public short getShort(int i) {
+        byte[] bArr = this.buffer;
+        return (short) ((bArr[i] & UByte.MAX_VALUE) | (bArr[i + 1] << 8));
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public int getInt(int i) {
+        byte[] bArr = this.buffer;
+        return (bArr[i] & UByte.MAX_VALUE) | (bArr[i + 3] << 24) | ((bArr[i + 2] & UByte.MAX_VALUE) << 16) | ((bArr[i + 1] & UByte.MAX_VALUE) << 8);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public long getLong(int i) {
+        byte[] bArr = this.buffer;
+        int i2 = i + 6;
+        return (bArr[i] & 255) | ((bArr[i + 1] & 255) << 8) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 24) | ((bArr[i + 4] & 255) << 32) | ((bArr[i + 5] & 255) << 40) | ((bArr[i2] & 255) << 48) | (bArr[i + 7] << 56);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public float getFloat(int i) {
+        return Float.intBitsToFloat(getInt(i));
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public double getDouble(int i) {
+        return Double.longBitsToDouble(getLong(i));
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public String getString(int i, int i2) {
+        return Utf8Safe.decodeUtf8Array(this.buffer, i, i2);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putBoolean(boolean z) {
+        setBoolean(this.writePos, z);
+        this.writePos++;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void put(byte[] bArr, int i, int i2) {
+        set(this.writePos, bArr, i, i2);
+        this.writePos += i2;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void put(byte b) {
+        set(this.writePos, b);
+        this.writePos++;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putShort(short s) {
+        setShort(this.writePos, s);
+        this.writePos += 2;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putInt(int i) {
+        setInt(this.writePos, i);
+        this.writePos += 4;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putLong(long j) {
+        setLong(this.writePos, j);
+        this.writePos += 8;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putFloat(float f) {
+        setFloat(this.writePos, f);
+        this.writePos += 4;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putDouble(double d) {
+        setDouble(this.writePos, d);
+        this.writePos += 8;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setBoolean(int i, boolean z) {
+        set(i, z ? (byte) 1 : (byte) 0);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void set(int i, byte b) {
+        requestCapacity(i + 1);
+        this.buffer[i] = b;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void set(int i, byte[] bArr, int i2, int i3) {
+        requestCapacity((i3 - i2) + i);
+        System.arraycopy(bArr, i2, this.buffer, i, i3);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setShort(int i, short s) {
+        requestCapacity(i + 2);
+        byte[] bArr = this.buffer;
+        bArr[i] = (byte) (s & 255);
+        bArr[i + 1] = (byte) ((s >> 8) & 255);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setInt(int i, int i2) {
+        requestCapacity(i + 4);
+        byte[] bArr = this.buffer;
+        bArr[i] = (byte) (i2 & 255);
+        bArr[i + 1] = (byte) ((i2 >> 8) & 255);
+        bArr[i + 2] = (byte) ((i2 >> 16) & 255);
+        bArr[i + 3] = (byte) ((i2 >> 24) & 255);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setLong(int i, long j) {
+        requestCapacity(i + 8);
+        int i2 = (int) j;
+        byte[] bArr = this.buffer;
+        bArr[i] = (byte) (i2 & 255);
+        bArr[i + 1] = (byte) ((i2 >> 8) & 255);
+        bArr[i + 2] = (byte) ((i2 >> 16) & 255);
+        bArr[i + 3] = (byte) ((i2 >> 24) & 255);
+        int i3 = (int) (j >> 32);
+        bArr[i + 4] = (byte) (i3 & 255);
+        bArr[i + 5] = (byte) ((i3 >> 8) & 255);
+        bArr[i + 6] = (byte) ((i3 >> 16) & 255);
+        bArr[i + 7] = (byte) ((i3 >> 24) & 255);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setFloat(int i, float f) {
+        requestCapacity(i + 4);
+        int floatToRawIntBits = Float.floatToRawIntBits(f);
+        byte[] bArr = this.buffer;
+        bArr[i] = (byte) (floatToRawIntBits & 255);
+        bArr[i + 1] = (byte) ((floatToRawIntBits >> 8) & 255);
+        bArr[i + 2] = (byte) ((floatToRawIntBits >> 16) & 255);
+        bArr[i + 3] = (byte) ((floatToRawIntBits >> 24) & 255);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setDouble(int i, double d) {
+        requestCapacity(i + 8);
+        long doubleToRawLongBits = Double.doubleToRawLongBits(d);
+        int i2 = (int) doubleToRawLongBits;
+        byte[] bArr = this.buffer;
+        bArr[i] = (byte) (i2 & 255);
+        bArr[i + 1] = (byte) ((i2 >> 8) & 255);
+        bArr[i + 2] = (byte) ((i2 >> 16) & 255);
+        bArr[i + 3] = (byte) ((i2 >> 24) & 255);
+        int i3 = (int) (doubleToRawLongBits >> 32);
+        bArr[i + 4] = (byte) (i3 & 255);
+        bArr[i + 5] = (byte) ((i3 >> 8) & 255);
+        bArr[i + 6] = (byte) ((i3 >> 16) & 255);
+        bArr[i + 7] = (byte) ((i3 >> 24) & 255);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public boolean requestCapacity(int i) {
+        byte[] bArr = this.buffer;
+        if (bArr.length > i) {
+            return true;
+        }
+        int length = bArr.length;
+        this.buffer = Arrays.copyOf(bArr, length + (length >> 1));
+        return true;
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/BaseVector.java

@@ -0,0 +1,40 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public class BaseVector {
+    protected ByteBuffer bb;
+    private int element_size;
+    private int length;
+    private int vector;
+
+    protected int __element(int i) {
+        return this.vector + (i * this.element_size);
+    }
+
+    protected int __vector() {
+        return this.vector;
+    }
+
+    public int length() {
+        return this.length;
+    }
+
+    protected void __reset(int i, int i2, ByteBuffer byteBuffer) {
+        this.bb = byteBuffer;
+        if (byteBuffer != null) {
+            this.vector = i;
+            this.length = byteBuffer.getInt(i - 4);
+            this.element_size = i2;
+        } else {
+            this.vector = 0;
+            this.length = 0;
+            this.element_size = 0;
+        }
+    }
+
+    public void reset() {
+        __reset(0, 0, null);
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/BooleanVector.java

@@ -0,0 +1,15 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class BooleanVector extends BaseVector {
+    public BooleanVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 1, byteBuffer);
+        return this;
+    }
+
+    public boolean get(int i) {
+        return this.bb.get(__element(i)) != 0;
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ByteBufferReadWriteBuf.java

@@ -0,0 +1,164 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public class ByteBufferReadWriteBuf implements ReadWriteBuf {
+    private final ByteBuffer buffer;
+
+    public ByteBufferReadWriteBuf(ByteBuffer byteBuffer) {
+        this.buffer = byteBuffer;
+        byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public boolean getBoolean(int i) {
+        return get(i) != 0;
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public byte get(int i) {
+        return this.buffer.get(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public short getShort(int i) {
+        return this.buffer.getShort(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public int getInt(int i) {
+        return this.buffer.getInt(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public long getLong(int i) {
+        return this.buffer.getLong(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public float getFloat(int i) {
+        return this.buffer.getFloat(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public double getDouble(int i) {
+        return this.buffer.getDouble(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public String getString(int i, int i2) {
+        return Utf8Safe.decodeUtf8Buffer(this.buffer, i, i2);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    public byte[] data() {
+        return this.buffer.array();
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putBoolean(boolean z) {
+        this.buffer.put(z ? (byte) 1 : (byte) 0);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void put(byte[] bArr, int i, int i2) {
+        this.buffer.put(bArr, i, i2);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void put(byte b) {
+        this.buffer.put(b);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putShort(short s) {
+        this.buffer.putShort(s);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putInt(int i) {
+        this.buffer.putInt(i);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putLong(long j) {
+        this.buffer.putLong(j);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putFloat(float f) {
+        this.buffer.putFloat(f);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void putDouble(double d) {
+        this.buffer.putDouble(d);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setBoolean(int i, boolean z) {
+        set(i, z ? (byte) 1 : (byte) 0);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void set(int i, byte b) {
+        requestCapacity(i + 1);
+        this.buffer.put(i, b);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void set(int i, byte[] bArr, int i2, int i3) {
+        requestCapacity((i3 - i2) + i);
+        int position = this.buffer.position();
+        this.buffer.position(i);
+        this.buffer.put(bArr, i2, i3);
+        this.buffer.position(position);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setShort(int i, short s) {
+        requestCapacity(i + 2);
+        this.buffer.putShort(i, s);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setInt(int i, int i2) {
+        requestCapacity(i + 4);
+        this.buffer.putInt(i, i2);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setLong(int i, long j) {
+        requestCapacity(i + 8);
+        this.buffer.putLong(i, j);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setFloat(int i, float f) {
+        requestCapacity(i + 4);
+        this.buffer.putFloat(i, f);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public void setDouble(int i, double d) {
+        requestCapacity(i + 8);
+        this.buffer.putDouble(i, d);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public int writePosition() {
+        return this.buffer.position();
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf, androidx.emoji2.text.flatbuffer.ReadBuf
+    public int limit() {
+        return this.buffer.limit();
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.ReadWriteBuf
+    public boolean requestCapacity(int i) {
+        return i <= this.buffer.limit();
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ByteBufferUtil.java

@@ -0,0 +1,16 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public class ByteBufferUtil {
+    public static int getSizePrefix(ByteBuffer byteBuffer) {
+        return byteBuffer.getInt(byteBuffer.position());
+    }
+
+    public static ByteBuffer removeSizePrefix(ByteBuffer byteBuffer) {
+        ByteBuffer duplicate = byteBuffer.duplicate();
+        duplicate.position(duplicate.position() + 4);
+        return duplicate;
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ByteVector.java

@@ -0,0 +1,20 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import kotlin.UByte;
+
+/* loaded from: classes.dex */
+public final class ByteVector extends BaseVector {
+    public ByteVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 1, byteBuffer);
+        return this;
+    }
+
+    public byte get(int i) {
+        return this.bb.get(__element(i));
+    }
+
+    public int getAsUnsigned(int i) {
+        return get(i) & UByte.MAX_VALUE;
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/Constants.java

@@ -0,0 +1,16 @@
+package androidx.emoji2.text.flatbuffer;
+
+/* loaded from: classes.dex */
+public class Constants {
+    static final int FILE_IDENTIFIER_LENGTH = 4;
+    static final int SIZEOF_BYTE = 1;
+    static final int SIZEOF_DOUBLE = 8;
+    static final int SIZEOF_FLOAT = 4;
+    static final int SIZEOF_INT = 4;
+    static final int SIZEOF_LONG = 8;
+    static final int SIZEOF_SHORT = 2;
+    public static final int SIZE_PREFIX_LENGTH = 4;
+
+    public static void FLATBUFFERS_1_12_0() {
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/DoubleVector.java

@@ -0,0 +1,15 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class DoubleVector extends BaseVector {
+    public DoubleVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 8, byteBuffer);
+        return this;
+    }
+
+    public double get(int i) {
+        return this.bb.getDouble(__element(i));
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/FlatBufferBuilder.java

@@ -0,0 +1,615 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+import kotlin.UByte;
+
+/* loaded from: classes.dex */
+public class FlatBufferBuilder {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    ByteBuffer bb;
+    ByteBufferFactory bb_factory;
+    boolean finished;
+    boolean force_defaults;
+    int minalign;
+    boolean nested;
+    int num_vtables;
+    int object_start;
+    int space;
+    final Utf8 utf8;
+    int vector_num_elems;
+    int[] vtable;
+    int vtable_in_use;
+    int[] vtables;
+
+    public static abstract class ByteBufferFactory {
+        public abstract ByteBuffer newByteBuffer(int i);
+
+        public void releaseByteBuffer(ByteBuffer byteBuffer) {
+        }
+    }
+
+    public FlatBufferBuilder forceDefaults(boolean z) {
+        this.force_defaults = z;
+        return this;
+    }
+
+    public FlatBufferBuilder(int i, ByteBufferFactory byteBufferFactory) {
+        this(i, byteBufferFactory, null, Utf8.getDefault());
+    }
+
+    public FlatBufferBuilder(int i, ByteBufferFactory byteBufferFactory, ByteBuffer byteBuffer, Utf8 utf8) {
+        this.minalign = 1;
+        this.vtable = null;
+        this.vtable_in_use = 0;
+        this.nested = false;
+        this.finished = false;
+        this.vtables = new int[16];
+        this.num_vtables = 0;
+        this.vector_num_elems = 0;
+        this.force_defaults = false;
+        i = i <= 0 ? 1 : i;
+        this.bb_factory = byteBufferFactory;
+        if (byteBuffer != null) {
+            this.bb = byteBuffer;
+            byteBuffer.clear();
+            this.bb.order(ByteOrder.LITTLE_ENDIAN);
+        } else {
+            this.bb = byteBufferFactory.newByteBuffer(i);
+        }
+        this.utf8 = utf8;
+        this.space = this.bb.capacity();
+    }
+
+    public FlatBufferBuilder(int i) {
+        this(i, HeapByteBufferFactory.INSTANCE, null, Utf8.getDefault());
+    }
+
+    public FlatBufferBuilder() {
+        this(1024);
+    }
+
+    public FlatBufferBuilder(ByteBuffer byteBuffer, ByteBufferFactory byteBufferFactory) {
+        this(byteBuffer.capacity(), byteBufferFactory, byteBuffer, Utf8.getDefault());
+    }
+
+    public FlatBufferBuilder(ByteBuffer byteBuffer) {
+        this(byteBuffer, new HeapByteBufferFactory());
+    }
+
+    public FlatBufferBuilder init(ByteBuffer byteBuffer, ByteBufferFactory byteBufferFactory) {
+        this.bb_factory = byteBufferFactory;
+        this.bb = byteBuffer;
+        byteBuffer.clear();
+        this.bb.order(ByteOrder.LITTLE_ENDIAN);
+        this.minalign = 1;
+        this.space = this.bb.capacity();
+        this.vtable_in_use = 0;
+        this.nested = false;
+        this.finished = false;
+        this.object_start = 0;
+        this.num_vtables = 0;
+        this.vector_num_elems = 0;
+        return this;
+    }
+
+    public static final class HeapByteBufferFactory extends ByteBufferFactory {
+        public static final HeapByteBufferFactory INSTANCE = new HeapByteBufferFactory();
+
+        @Override // androidx.emoji2.text.flatbuffer.FlatBufferBuilder.ByteBufferFactory
+        public ByteBuffer newByteBuffer(int i) {
+            return ByteBuffer.allocate(i).order(ByteOrder.LITTLE_ENDIAN);
+        }
+    }
+
+    public static boolean isFieldPresent(Table table, int i) {
+        return table.__offset(i) != 0;
+    }
+
+    public void clear() {
+        this.space = this.bb.capacity();
+        this.bb.clear();
+        this.minalign = 1;
+        while (true) {
+            int i = this.vtable_in_use;
+            if (i <= 0) {
+                this.vtable_in_use = 0;
+                this.nested = false;
+                this.finished = false;
+                this.object_start = 0;
+                this.num_vtables = 0;
+                this.vector_num_elems = 0;
+                return;
+            }
+            int[] iArr = this.vtable;
+            int i2 = i - 1;
+            this.vtable_in_use = i2;
+            iArr[i2] = 0;
+        }
+    }
+
+    static ByteBuffer growByteBuffer(ByteBuffer byteBuffer, ByteBufferFactory byteBufferFactory) {
+        int capacity = byteBuffer.capacity();
+        if (((-1073741824) & capacity) != 0) {
+            throw new AssertionError("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+        }
+        int i = capacity == 0 ? 1 : capacity << 1;
+        byteBuffer.position(0);
+        ByteBuffer newByteBuffer = byteBufferFactory.newByteBuffer(i);
+        newByteBuffer.position(newByteBuffer.clear().capacity() - capacity);
+        newByteBuffer.put(byteBuffer);
+        return newByteBuffer;
+    }
+
+    public int offset() {
+        return this.bb.capacity() - this.space;
+    }
+
+    public void pad(int i) {
+        for (int i2 = 0; i2 < i; i2++) {
+            ByteBuffer byteBuffer = this.bb;
+            int i3 = this.space - 1;
+            this.space = i3;
+            byteBuffer.put(i3, (byte) 0);
+        }
+    }
+
+    public void prep(int i, int i2) {
+        if (i > this.minalign) {
+            this.minalign = i;
+        }
+        int i3 = ((~((this.bb.capacity() - this.space) + i2)) + 1) & (i - 1);
+        while (this.space < i3 + i + i2) {
+            int capacity = this.bb.capacity();
+            ByteBuffer byteBuffer = this.bb;
+            ByteBuffer growByteBuffer = growByteBuffer(byteBuffer, this.bb_factory);
+            this.bb = growByteBuffer;
+            if (byteBuffer != growByteBuffer) {
+                this.bb_factory.releaseByteBuffer(byteBuffer);
+            }
+            this.space += this.bb.capacity() - capacity;
+        }
+        pad(i3);
+    }
+
+    public void putBoolean(boolean z) {
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - 1;
+        this.space = i;
+        byteBuffer.put(i, z ? (byte) 1 : (byte) 0);
+    }
+
+    public void putByte(byte b) {
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - 1;
+        this.space = i;
+        byteBuffer.put(i, b);
+    }
+
+    public void putShort(short s) {
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - 2;
+        this.space = i;
+        byteBuffer.putShort(i, s);
+    }
+
+    public void putInt(int i) {
+        ByteBuffer byteBuffer = this.bb;
+        int i2 = this.space - 4;
+        this.space = i2;
+        byteBuffer.putInt(i2, i);
+    }
+
+    public void putLong(long j) {
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - 8;
+        this.space = i;
+        byteBuffer.putLong(i, j);
+    }
+
+    public void putFloat(float f) {
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - 4;
+        this.space = i;
+        byteBuffer.putFloat(i, f);
+    }
+
+    public void putDouble(double d) {
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - 8;
+        this.space = i;
+        byteBuffer.putDouble(i, d);
+    }
+
+    public void addBoolean(boolean z) {
+        prep(1, 0);
+        putBoolean(z);
+    }
+
+    public void addByte(byte b) {
+        prep(1, 0);
+        putByte(b);
+    }
+
+    public void addShort(short s) {
+        prep(2, 0);
+        putShort(s);
+    }
+
+    public void addInt(int i) {
+        prep(4, 0);
+        putInt(i);
+    }
+
+    public void addLong(long j) {
+        prep(8, 0);
+        putLong(j);
+    }
+
+    public void addFloat(float f) {
+        prep(4, 0);
+        putFloat(f);
+    }
+
+    public void addDouble(double d) {
+        prep(8, 0);
+        putDouble(d);
+    }
+
+    public void addOffset(int i) {
+        prep(4, 0);
+        putInt((offset() - i) + 4);
+    }
+
+    public void startVector(int i, int i2, int i3) {
+        notNested();
+        this.vector_num_elems = i2;
+        int i4 = i * i2;
+        prep(4, i4);
+        prep(i3, i4);
+        this.nested = true;
+    }
+
+    public int endVector() {
+        if (!this.nested) {
+            throw new AssertionError("FlatBuffers: endVector called without startVector");
+        }
+        this.nested = false;
+        putInt(this.vector_num_elems);
+        return offset();
+    }
+
+    public ByteBuffer createUnintializedVector(int i, int i2, int i3) {
+        int i4 = i * i2;
+        startVector(i, i2, i3);
+        ByteBuffer byteBuffer = this.bb;
+        int i5 = this.space - i4;
+        this.space = i5;
+        byteBuffer.position(i5);
+        ByteBuffer order = this.bb.slice().order(ByteOrder.LITTLE_ENDIAN);
+        order.limit(i4);
+        return order;
+    }
+
+    public int createVectorOfTables(int[] iArr) {
+        notNested();
+        startVector(4, iArr.length, 4);
+        for (int length = iArr.length - 1; length >= 0; length--) {
+            addOffset(iArr[length]);
+        }
+        return endVector();
+    }
+
+    public <T extends Table> int createSortedVectorOfTables(T t, int[] iArr) {
+        t.sortTables(iArr, this.bb);
+        return createVectorOfTables(iArr);
+    }
+
+    public int createString(CharSequence charSequence) {
+        int encodedLength = this.utf8.encodedLength(charSequence);
+        addByte((byte) 0);
+        startVector(1, encodedLength, 1);
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - encodedLength;
+        this.space = i;
+        byteBuffer.position(i);
+        this.utf8.encodeUtf8(charSequence, this.bb);
+        return endVector();
+    }
+
+    public int createString(ByteBuffer byteBuffer) {
+        int remaining = byteBuffer.remaining();
+        addByte((byte) 0);
+        startVector(1, remaining, 1);
+        ByteBuffer byteBuffer2 = this.bb;
+        int i = this.space - remaining;
+        this.space = i;
+        byteBuffer2.position(i);
+        this.bb.put(byteBuffer);
+        return endVector();
+    }
+
+    public int createByteVector(byte[] bArr) {
+        int length = bArr.length;
+        startVector(1, length, 1);
+        ByteBuffer byteBuffer = this.bb;
+        int i = this.space - length;
+        this.space = i;
+        byteBuffer.position(i);
+        this.bb.put(bArr);
+        return endVector();
+    }
+
+    public int createByteVector(byte[] bArr, int i, int i2) {
+        startVector(1, i2, 1);
+        ByteBuffer byteBuffer = this.bb;
+        int i3 = this.space - i2;
+        this.space = i3;
+        byteBuffer.position(i3);
+        this.bb.put(bArr, i, i2);
+        return endVector();
+    }
+
+    public int createByteVector(ByteBuffer byteBuffer) {
+        int remaining = byteBuffer.remaining();
+        startVector(1, remaining, 1);
+        ByteBuffer byteBuffer2 = this.bb;
+        int i = this.space - remaining;
+        this.space = i;
+        byteBuffer2.position(i);
+        this.bb.put(byteBuffer);
+        return endVector();
+    }
+
+    public void finished() {
+        if (!this.finished) {
+            throw new AssertionError("FlatBuffers: you can only access the serialized buffer after it has been finished by FlatBufferBuilder.finish().");
+        }
+    }
+
+    public void notNested() {
+        if (this.nested) {
+            throw new AssertionError("FlatBuffers: object serialization must not be nested.");
+        }
+    }
+
+    public void Nested(int i) {
+        if (i != offset()) {
+            throw new AssertionError("FlatBuffers: struct must be serialized inline.");
+        }
+    }
+
+    public void startTable(int i) {
+        notNested();
+        int[] iArr = this.vtable;
+        if (iArr == null || iArr.length < i) {
+            this.vtable = new int[i];
+        }
+        this.vtable_in_use = i;
+        Arrays.fill(this.vtable, 0, i, 0);
+        this.nested = true;
+        this.object_start = offset();
+    }
+
+    public void addBoolean(int i, boolean z, boolean z2) {
+        if (this.force_defaults || z != z2) {
+            addBoolean(z);
+            slot(i);
+        }
+    }
+
+    public void addByte(int i, byte b, int i2) {
+        if (this.force_defaults || b != i2) {
+            addByte(b);
+            slot(i);
+        }
+    }
+
+    public void addShort(int i, short s, int i2) {
+        if (this.force_defaults || s != i2) {
+            addShort(s);
+            slot(i);
+        }
+    }
+
+    public void addInt(int i, int i2, int i3) {
+        if (this.force_defaults || i2 != i3) {
+            addInt(i2);
+            slot(i);
+        }
+    }
+
+    public void addLong(int i, long j, long j2) {
+        if (this.force_defaults || j != j2) {
+            addLong(j);
+            slot(i);
+        }
+    }
+
+    public void addFloat(int i, float f, double d) {
+        if (this.force_defaults || f != d) {
+            addFloat(f);
+            slot(i);
+        }
+    }
+
+    public void addDouble(int i, double d, double d2) {
+        if (this.force_defaults || d != d2) {
+            addDouble(d);
+            slot(i);
+        }
+    }
+
+    public void addOffset(int i, int i2, int i3) {
+        if (this.force_defaults || i2 != i3) {
+            addOffset(i2);
+            slot(i);
+        }
+    }
+
+    public void addStruct(int i, int i2, int i3) {
+        if (i2 != i3) {
+            Nested(i2);
+            slot(i);
+        }
+    }
+
+    public void slot(int i) {
+        this.vtable[i] = offset();
+    }
+
+    public int endTable() {
+        int i;
+        if (this.vtable == null || !this.nested) {
+            throw new AssertionError("FlatBuffers: endTable called without startTable");
+        }
+        addInt(0);
+        int offset = offset();
+        int i2 = this.vtable_in_use - 1;
+        while (i2 >= 0 && this.vtable[i2] == 0) {
+            i2--;
+        }
+        for (int i3 = i2; i3 >= 0; i3--) {
+            int i4 = this.vtable[i3];
+            addShort((short) (i4 != 0 ? offset - i4 : 0));
+        }
+        addShort((short) (offset - this.object_start));
+        addShort((short) ((i2 + 3) * 2));
+        int i5 = 0;
+        loop2: while (true) {
+            if (i5 >= this.num_vtables) {
+                i = 0;
+                break;
+            }
+            int capacity = this.bb.capacity() - this.vtables[i5];
+            int i6 = this.space;
+            short s = this.bb.getShort(capacity);
+            if (s == this.bb.getShort(i6)) {
+                for (int i7 = 2; i7 < s; i7 += 2) {
+                    if (this.bb.getShort(capacity + i7) != this.bb.getShort(i6 + i7)) {
+                        break;
+                    }
+                }
+                i = this.vtables[i5];
+                break loop2;
+            }
+            i5++;
+        }
+        if (i != 0) {
+            int capacity2 = this.bb.capacity() - offset;
+            this.space = capacity2;
+            this.bb.putInt(capacity2, i - offset);
+        } else {
+            int i8 = this.num_vtables;
+            int[] iArr = this.vtables;
+            if (i8 == iArr.length) {
+                this.vtables = Arrays.copyOf(iArr, i8 * 2);
+            }
+            int[] iArr2 = this.vtables;
+            int i9 = this.num_vtables;
+            this.num_vtables = i9 + 1;
+            iArr2[i9] = offset();
+            ByteBuffer byteBuffer = this.bb;
+            byteBuffer.putInt(byteBuffer.capacity() - offset, offset() - offset);
+        }
+        this.nested = false;
+        return offset;
+    }
+
+    public void required(int i, int i2) {
+        int capacity = this.bb.capacity() - i;
+        if (this.bb.getShort((capacity - this.bb.getInt(capacity)) + i2) != 0) {
+            return;
+        }
+        throw new AssertionError("FlatBuffers: field " + i2 + " must be set");
+    }
+
+    protected void finish(int i, boolean z) {
+        prep(this.minalign, (z ? 4 : 0) + 4);
+        addOffset(i);
+        if (z) {
+            addInt(this.bb.capacity() - this.space);
+        }
+        this.bb.position(this.space);
+        this.finished = true;
+    }
+
+    public void finish(int i) {
+        finish(i, false);
+    }
+
+    public void finishSizePrefixed(int i) {
+        finish(i, true);
+    }
+
+    protected void finish(int i, String str, boolean z) {
+        prep(this.minalign, (z ? 4 : 0) + 8);
+        if (str.length() != 4) {
+            throw new AssertionError("FlatBuffers: file identifier must be length 4");
+        }
+        for (int i2 = 3; i2 >= 0; i2--) {
+            addByte((byte) str.charAt(i2));
+        }
+        finish(i, z);
+    }
+
+    public void finish(int i, String str) {
+        finish(i, str, false);
+    }
+
+    public void finishSizePrefixed(int i, String str) {
+        finish(i, str, true);
+    }
+
+    public ByteBuffer dataBuffer() {
+        finished();
+        return this.bb;
+    }
+
+    @Deprecated
+    private int dataStart() {
+        finished();
+        return this.space;
+    }
+
+    public byte[] sizedByteArray(int i, int i2) {
+        finished();
+        byte[] bArr = new byte[i2];
+        this.bb.position(i);
+        this.bb.get(bArr);
+        return bArr;
+    }
+
+    public byte[] sizedByteArray() {
+        return sizedByteArray(this.space, this.bb.capacity() - this.space);
+    }
+
+    public InputStream sizedInputStream() {
+        finished();
+        ByteBuffer duplicate = this.bb.duplicate();
+        duplicate.position(this.space);
+        duplicate.limit(this.bb.capacity());
+        return new ByteBufferBackedInputStream(duplicate);
+    }
+
+    static class ByteBufferBackedInputStream extends InputStream {
+        ByteBuffer buf;
+
+        public ByteBufferBackedInputStream(ByteBuffer byteBuffer) {
+            this.buf = byteBuffer;
+        }
+
+        @Override // java.io.InputStream
+        public int read() throws IOException {
+            try {
+                return this.buf.get() & UByte.MAX_VALUE;
+            } catch (BufferUnderflowException unused) {
+                return -1;
+            }
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/FlexBuffers.java

@@ -0,0 +1,846 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import kotlin.UByte;
+import kotlin.UShort;
+import kotlin.text.Typography;
+
+/* loaded from: classes.dex */
+public class FlexBuffers {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private static final ReadBuf EMPTY_BB = new ArrayReadWriteBuf(new byte[]{0}, 1);
+    public static final int FBT_BLOB = 25;
+    public static final int FBT_BOOL = 26;
+    public static final int FBT_FLOAT = 3;
+    public static final int FBT_INDIRECT_FLOAT = 8;
+    public static final int FBT_INDIRECT_INT = 6;
+    public static final int FBT_INDIRECT_UINT = 7;
+    public static final int FBT_INT = 1;
+    public static final int FBT_KEY = 4;
+    public static final int FBT_MAP = 9;
+    public static final int FBT_NULL = 0;
+    public static final int FBT_STRING = 5;
+    public static final int FBT_UINT = 2;
+    public static final int FBT_VECTOR = 10;
+    public static final int FBT_VECTOR_BOOL = 36;
+    public static final int FBT_VECTOR_FLOAT = 13;
+    public static final int FBT_VECTOR_FLOAT2 = 18;
+    public static final int FBT_VECTOR_FLOAT3 = 21;
+    public static final int FBT_VECTOR_FLOAT4 = 24;
+    public static final int FBT_VECTOR_INT = 11;
+    public static final int FBT_VECTOR_INT2 = 16;
+    public static final int FBT_VECTOR_INT3 = 19;
+    public static final int FBT_VECTOR_INT4 = 22;
+    public static final int FBT_VECTOR_KEY = 14;
+    public static final int FBT_VECTOR_STRING_DEPRECATED = 15;
+    public static final int FBT_VECTOR_UINT = 12;
+    public static final int FBT_VECTOR_UINT2 = 17;
+    public static final int FBT_VECTOR_UINT3 = 20;
+    public static final int FBT_VECTOR_UINT4 = 23;
+
+    static boolean isTypeInline(int i) {
+        return i <= 3 || i == 26;
+    }
+
+    static boolean isTypedVector(int i) {
+        return (i >= 11 && i <= 15) || i == 36;
+    }
+
+    static boolean isTypedVectorElementType(int i) {
+        return (i >= 1 && i <= 4) || i == 26;
+    }
+
+    static int toTypedVector(int i, int i2) {
+        if (i2 == 0) {
+            return i + 10;
+        }
+        if (i2 == 2) {
+            return i + 15;
+        }
+        if (i2 == 3) {
+            return i + 18;
+        }
+        if (i2 != 4) {
+            return 0;
+        }
+        return i + 21;
+    }
+
+    static int toTypedVectorElementType(int i) {
+        return i - 10;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static int indirect(ReadBuf readBuf, int i, int i2) {
+        return (int) (i - readUInt(readBuf, i, i2));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static long readUInt(ReadBuf readBuf, int i, int i2) {
+        if (i2 == 1) {
+            return Unsigned.byteToUnsignedInt(readBuf.get(i));
+        }
+        if (i2 == 2) {
+            return Unsigned.shortToUnsignedInt(readBuf.getShort(i));
+        }
+        if (i2 == 4) {
+            return Unsigned.intToUnsignedLong(readBuf.getInt(i));
+        }
+        if (i2 != 8) {
+            return -1L;
+        }
+        return readBuf.getLong(i);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static int readInt(ReadBuf readBuf, int i, int i2) {
+        return (int) readLong(readBuf, i, i2);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static long readLong(ReadBuf readBuf, int i, int i2) {
+        int i3;
+        if (i2 == 1) {
+            i3 = readBuf.get(i);
+        } else if (i2 == 2) {
+            i3 = readBuf.getShort(i);
+        } else {
+            if (i2 != 4) {
+                if (i2 != 8) {
+                    return -1L;
+                }
+                return readBuf.getLong(i);
+            }
+            i3 = readBuf.getInt(i);
+        }
+        return i3;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static double readDouble(ReadBuf readBuf, int i, int i2) {
+        if (i2 == 4) {
+            return readBuf.getFloat(i);
+        }
+        if (i2 != 8) {
+            return -1.0d;
+        }
+        return readBuf.getDouble(i);
+    }
+
+    @Deprecated
+    public static Reference getRoot(ByteBuffer byteBuffer) {
+        return getRoot(byteBuffer.hasArray() ? new ArrayReadWriteBuf(byteBuffer.array(), byteBuffer.limit()) : new ByteBufferReadWriteBuf(byteBuffer));
+    }
+
+    public static Reference getRoot(ReadBuf readBuf) {
+        int limit = readBuf.limit();
+        byte b = readBuf.get(limit - 1);
+        int i = limit - 2;
+        return new Reference(readBuf, i - b, b, Unsigned.byteToUnsignedInt(readBuf.get(i)));
+    }
+
+    public static class Reference {
+        private static final Reference NULL_REFERENCE = new Reference(FlexBuffers.EMPTY_BB, 0, 1, 0);
+        private ReadBuf bb;
+        private int byteWidth;
+        private int end;
+        private int parentWidth;
+        private int type;
+
+        public int getType() {
+            return this.type;
+        }
+
+        public boolean isBlob() {
+            return this.type == 25;
+        }
+
+        public boolean isBoolean() {
+            return this.type == 26;
+        }
+
+        public boolean isFloat() {
+            int i = this.type;
+            return i == 3 || i == 8;
+        }
+
+        public boolean isInt() {
+            int i = this.type;
+            return i == 1 || i == 6;
+        }
+
+        public boolean isKey() {
+            return this.type == 4;
+        }
+
+        public boolean isMap() {
+            return this.type == 9;
+        }
+
+        public boolean isNull() {
+            return this.type == 0;
+        }
+
+        public boolean isString() {
+            return this.type == 5;
+        }
+
+        public boolean isUInt() {
+            int i = this.type;
+            return i == 2 || i == 7;
+        }
+
+        public boolean isVector() {
+            int i = this.type;
+            return i == 10 || i == 9;
+        }
+
+        Reference(ReadBuf readBuf, int i, int i2, int i3) {
+            this(readBuf, i, i2, 1 << (i3 & 3), i3 >> 2);
+        }
+
+        Reference(ReadBuf readBuf, int i, int i2, int i3, int i4) {
+            this.bb = readBuf;
+            this.end = i;
+            this.parentWidth = i2;
+            this.byteWidth = i3;
+            this.type = i4;
+        }
+
+        public boolean isNumeric() {
+            return isIntOrUInt() || isFloat();
+        }
+
+        public boolean isIntOrUInt() {
+            return isInt() || isUInt();
+        }
+
+        public boolean isTypedVector() {
+            return FlexBuffers.isTypedVector(this.type);
+        }
+
+        public int asInt() {
+            long readUInt;
+            int i = this.type;
+            if (i == 1) {
+                return FlexBuffers.readInt(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 2) {
+                readUInt = FlexBuffers.readUInt(this.bb, this.end, this.parentWidth);
+            } else {
+                if (i == 3) {
+                    return (int) FlexBuffers.readDouble(this.bb, this.end, this.parentWidth);
+                }
+                if (i == 5) {
+                    return Integer.parseInt(asString());
+                }
+                if (i == 6) {
+                    ReadBuf readBuf = this.bb;
+                    return FlexBuffers.readInt(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+                }
+                if (i != 7) {
+                    if (i == 8) {
+                        ReadBuf readBuf2 = this.bb;
+                        return (int) FlexBuffers.readDouble(readBuf2, FlexBuffers.indirect(readBuf2, this.end, this.parentWidth), this.byteWidth);
+                    }
+                    if (i == 10) {
+                        return asVector().size();
+                    }
+                    if (i != 26) {
+                        return 0;
+                    }
+                    return FlexBuffers.readInt(this.bb, this.end, this.parentWidth);
+                }
+                ReadBuf readBuf3 = this.bb;
+                readUInt = FlexBuffers.readUInt(readBuf3, FlexBuffers.indirect(readBuf3, this.end, this.parentWidth), this.parentWidth);
+            }
+            return (int) readUInt;
+        }
+
+        public long asUInt() {
+            int i = this.type;
+            if (i == 2) {
+                return FlexBuffers.readUInt(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 1) {
+                return FlexBuffers.readLong(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 3) {
+                return (long) FlexBuffers.readDouble(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 10) {
+                return asVector().size();
+            }
+            if (i == 26) {
+                return FlexBuffers.readInt(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 5) {
+                return Long.parseLong(asString());
+            }
+            if (i == 6) {
+                ReadBuf readBuf = this.bb;
+                return FlexBuffers.readLong(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+            }
+            if (i == 7) {
+                ReadBuf readBuf2 = this.bb;
+                return FlexBuffers.readUInt(readBuf2, FlexBuffers.indirect(readBuf2, this.end, this.parentWidth), this.byteWidth);
+            }
+            if (i != 8) {
+                return 0L;
+            }
+            ReadBuf readBuf3 = this.bb;
+            return (long) FlexBuffers.readDouble(readBuf3, FlexBuffers.indirect(readBuf3, this.end, this.parentWidth), this.parentWidth);
+        }
+
+        public long asLong() {
+            int i = this.type;
+            if (i == 1) {
+                return FlexBuffers.readLong(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 2) {
+                return FlexBuffers.readUInt(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 3) {
+                return (long) FlexBuffers.readDouble(this.bb, this.end, this.parentWidth);
+            }
+            if (i == 5) {
+                try {
+                    return Long.parseLong(asString());
+                } catch (NumberFormatException unused) {
+                    return 0L;
+                }
+            }
+            if (i == 6) {
+                ReadBuf readBuf = this.bb;
+                return FlexBuffers.readLong(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+            }
+            if (i == 7) {
+                ReadBuf readBuf2 = this.bb;
+                return FlexBuffers.readUInt(readBuf2, FlexBuffers.indirect(readBuf2, this.end, this.parentWidth), this.parentWidth);
+            }
+            if (i == 8) {
+                ReadBuf readBuf3 = this.bb;
+                return (long) FlexBuffers.readDouble(readBuf3, FlexBuffers.indirect(readBuf3, this.end, this.parentWidth), this.byteWidth);
+            }
+            if (i == 10) {
+                return asVector().size();
+            }
+            if (i != 26) {
+                return 0L;
+            }
+            return FlexBuffers.readInt(this.bb, this.end, this.parentWidth);
+        }
+
+        public double asFloat() {
+            int i = this.type;
+            if (i == 3) {
+                return FlexBuffers.readDouble(this.bb, this.end, this.parentWidth);
+            }
+            if (i != 1) {
+                if (i != 2) {
+                    if (i == 5) {
+                        return Double.parseDouble(asString());
+                    }
+                    if (i == 6) {
+                        ReadBuf readBuf = this.bb;
+                        return FlexBuffers.readInt(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+                    }
+                    if (i == 7) {
+                        ReadBuf readBuf2 = this.bb;
+                        return FlexBuffers.readUInt(readBuf2, FlexBuffers.indirect(readBuf2, this.end, this.parentWidth), this.byteWidth);
+                    }
+                    if (i == 8) {
+                        ReadBuf readBuf3 = this.bb;
+                        return FlexBuffers.readDouble(readBuf3, FlexBuffers.indirect(readBuf3, this.end, this.parentWidth), this.byteWidth);
+                    }
+                    if (i == 10) {
+                        return asVector().size();
+                    }
+                    if (i != 26) {
+                        return 0.0d;
+                    }
+                }
+                return FlexBuffers.readUInt(this.bb, this.end, this.parentWidth);
+            }
+            return FlexBuffers.readInt(this.bb, this.end, this.parentWidth);
+        }
+
+        public Key asKey() {
+            if (isKey()) {
+                ReadBuf readBuf = this.bb;
+                return new Key(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+            }
+            return Key.empty();
+        }
+
+        public String asString() {
+            if (isString()) {
+                int indirect = FlexBuffers.indirect(this.bb, this.end, this.parentWidth);
+                ReadBuf readBuf = this.bb;
+                int i = this.byteWidth;
+                return this.bb.getString(indirect, (int) FlexBuffers.readUInt(readBuf, indirect - i, i));
+            }
+            if (!isKey()) {
+                return "";
+            }
+            int indirect2 = FlexBuffers.indirect(this.bb, this.end, this.byteWidth);
+            int i2 = indirect2;
+            while (this.bb.get(i2) != 0) {
+                i2++;
+            }
+            return this.bb.getString(indirect2, i2 - indirect2);
+        }
+
+        public Map asMap() {
+            if (isMap()) {
+                ReadBuf readBuf = this.bb;
+                return new Map(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+            }
+            return Map.empty();
+        }
+
+        public Vector asVector() {
+            if (isVector()) {
+                ReadBuf readBuf = this.bb;
+                return new Vector(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+            }
+            int i = this.type;
+            if (i == 15) {
+                ReadBuf readBuf2 = this.bb;
+                return new TypedVector(readBuf2, FlexBuffers.indirect(readBuf2, this.end, this.parentWidth), this.byteWidth, 4);
+            }
+            if (FlexBuffers.isTypedVector(i)) {
+                ReadBuf readBuf3 = this.bb;
+                return new TypedVector(readBuf3, FlexBuffers.indirect(readBuf3, this.end, this.parentWidth), this.byteWidth, FlexBuffers.toTypedVectorElementType(this.type));
+            }
+            return Vector.empty();
+        }
+
+        public Blob asBlob() {
+            if (isBlob() || isString()) {
+                ReadBuf readBuf = this.bb;
+                return new Blob(readBuf, FlexBuffers.indirect(readBuf, this.end, this.parentWidth), this.byteWidth);
+            }
+            return Blob.empty();
+        }
+
+        public boolean asBoolean() {
+            return isBoolean() ? this.bb.get(this.end) != 0 : asUInt() != 0;
+        }
+
+        public String toString() {
+            return toString(new StringBuilder(128)).toString();
+        }
+
+        StringBuilder toString(StringBuilder sb) {
+            int i = this.type;
+            if (i != 36) {
+                switch (i) {
+                    case 0:
+                        sb.append("null");
+                        return sb;
+                    case 1:
+                    case 6:
+                        sb.append(asLong());
+                        return sb;
+                    case 2:
+                    case 7:
+                        sb.append(asUInt());
+                        return sb;
+                    case 3:
+                    case 8:
+                        sb.append(asFloat());
+                        return sb;
+                    case 4:
+                        Key asKey = asKey();
+                        sb.append(Typography.quote);
+                        StringBuilder key = asKey.toString(sb);
+                        key.append(Typography.quote);
+                        return key;
+                    case 5:
+                        sb.append(Typography.quote);
+                        sb.append(asString());
+                        sb.append(Typography.quote);
+                        return sb;
+                    case 9:
+                        return asMap().toString(sb);
+                    case 10:
+                        return asVector().toString(sb);
+                    case 11:
+                    case 12:
+                    case 13:
+                    case 14:
+                    case 15:
+                        break;
+                    case 16:
+                    case 17:
+                    case 18:
+                    case 19:
+                    case 20:
+                    case 21:
+                    case 22:
+                    case 23:
+                    case 24:
+                        throw new FlexBufferException("not_implemented:" + this.type);
+                    case 25:
+                        return asBlob().toString(sb);
+                    case 26:
+                        sb.append(asBoolean());
+                        return sb;
+                    default:
+                        return sb;
+                }
+            }
+            sb.append(asVector());
+            return sb;
+        }
+    }
+
+    private static abstract class Object {
+        ReadBuf bb;
+        int byteWidth;
+        int end;
+
+        public abstract StringBuilder toString(StringBuilder sb);
+
+        Object(ReadBuf readBuf, int i, int i2) {
+            this.bb = readBuf;
+            this.end = i;
+            this.byteWidth = i2;
+        }
+
+        public String toString() {
+            return toString(new StringBuilder(128)).toString();
+        }
+    }
+
+    private static abstract class Sized extends Object {
+        protected final int size;
+
+        public int size() {
+            return this.size;
+        }
+
+        Sized(ReadBuf readBuf, int i, int i2) {
+            super(readBuf, i, i2);
+            this.size = FlexBuffers.readInt(this.bb, i - i2, i2);
+        }
+    }
+
+    public static class Blob extends Sized {
+        static final /* synthetic */ boolean $assertionsDisabled = false;
+        static final Blob EMPTY = new Blob(FlexBuffers.EMPTY_BB, 1, 1);
+
+        public static Blob empty() {
+            return EMPTY;
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Sized
+        public /* bridge */ /* synthetic */ int size() {
+            return super.size();
+        }
+
+        Blob(ReadBuf readBuf, int i, int i2) {
+            super(readBuf, i, i2);
+        }
+
+        public ByteBuffer data() {
+            ByteBuffer wrap = ByteBuffer.wrap(this.bb.data());
+            wrap.position(this.end);
+            wrap.limit(this.end + size());
+            return wrap.asReadOnlyBuffer().slice();
+        }
+
+        public byte[] getBytes() {
+            int size = size();
+            byte[] bArr = new byte[size];
+            for (int i = 0; i < size; i++) {
+                bArr[i] = this.bb.get(this.end + i);
+            }
+            return bArr;
+        }
+
+        public byte get(int i) {
+            return this.bb.get(this.end + i);
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public String toString() {
+            return this.bb.getString(this.end, size());
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public StringBuilder toString(StringBuilder sb) {
+            sb.append(Typography.quote);
+            sb.append(this.bb.getString(this.end, size()));
+            sb.append(Typography.quote);
+            return sb;
+        }
+    }
+
+    public static class Key extends Object {
+        private static final Key EMPTY = new Key(FlexBuffers.EMPTY_BB, 0, 0);
+
+        public static Key empty() {
+            return EMPTY;
+        }
+
+        Key(ReadBuf readBuf, int i, int i2) {
+            super(readBuf, i, i2);
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public StringBuilder toString(StringBuilder sb) {
+            sb.append(toString());
+            return sb;
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public String toString() {
+            int i = this.end;
+            while (this.bb.get(i) != 0) {
+                i++;
+            }
+            return this.bb.getString(this.end, i - this.end);
+        }
+
+        int compareTo(byte[] bArr) {
+            byte b;
+            byte b2;
+            int i = this.end;
+            int i2 = 0;
+            do {
+                b = this.bb.get(i);
+                b2 = bArr[i2];
+                if (b == 0) {
+                    return b - b2;
+                }
+                i++;
+                i2++;
+                if (i2 == bArr.length) {
+                    return b - b2;
+                }
+            } while (b == b2);
+            return b - b2;
+        }
+
+        public boolean equals(java.lang.Object obj) {
+            if (!(obj instanceof Key)) {
+                return false;
+            }
+            Key key = (Key) obj;
+            return key.end == this.end && key.byteWidth == this.byteWidth;
+        }
+
+        public int hashCode() {
+            return this.end ^ this.byteWidth;
+        }
+    }
+
+    public static class Map extends Vector {
+        private static final Map EMPTY_MAP = new Map(FlexBuffers.EMPTY_BB, 1, 1);
+
+        public static Map empty() {
+            return EMPTY_MAP;
+        }
+
+        Map(ReadBuf readBuf, int i, int i2) {
+            super(readBuf, i, i2);
+        }
+
+        public Reference get(String str) {
+            return get(str.getBytes(StandardCharsets.UTF_8));
+        }
+
+        public Reference get(byte[] bArr) {
+            KeyVector keys = keys();
+            int size = keys.size();
+            int binarySearch = binarySearch(keys, bArr);
+            if (binarySearch >= 0 && binarySearch < size) {
+                return get(binarySearch);
+            }
+            return Reference.NULL_REFERENCE;
+        }
+
+        public KeyVector keys() {
+            int i = this.end - (this.byteWidth * 3);
+            return new KeyVector(new TypedVector(this.bb, FlexBuffers.indirect(this.bb, i, this.byteWidth), FlexBuffers.readInt(this.bb, i + this.byteWidth, this.byteWidth), 4));
+        }
+
+        public Vector values() {
+            return new Vector(this.bb, this.end, this.byteWidth);
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Vector, androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public StringBuilder toString(StringBuilder sb) {
+            sb.append("{ ");
+            KeyVector keys = keys();
+            int size = size();
+            Vector values = values();
+            for (int i = 0; i < size; i++) {
+                sb.append(Typography.quote);
+                sb.append(keys.get(i).toString());
+                sb.append("\" : ");
+                sb.append(values.get(i).toString());
+                if (i != size - 1) {
+                    sb.append(", ");
+                }
+            }
+            sb.append(" }");
+            return sb;
+        }
+
+        private int binarySearch(KeyVector keyVector, byte[] bArr) {
+            int size = keyVector.size() - 1;
+            int i = 0;
+            while (i <= size) {
+                int i2 = (i + size) >>> 1;
+                int compareTo = keyVector.get(i2).compareTo(bArr);
+                if (compareTo < 0) {
+                    i = i2 + 1;
+                } else {
+                    if (compareTo <= 0) {
+                        return i2;
+                    }
+                    size = i2 - 1;
+                }
+            }
+            return -(i + 1);
+        }
+    }
+
+    public static class Vector extends Sized {
+        private static final Vector EMPTY_VECTOR = new Vector(FlexBuffers.EMPTY_BB, 1, 1);
+
+        public static Vector empty() {
+            return EMPTY_VECTOR;
+        }
+
+        public boolean isEmpty() {
+            return this == EMPTY_VECTOR;
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Sized
+        public /* bridge */ /* synthetic */ int size() {
+            return super.size();
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public /* bridge */ /* synthetic */ String toString() {
+            return super.toString();
+        }
+
+        Vector(ReadBuf readBuf, int i, int i2) {
+            super(readBuf, i, i2);
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Object
+        public StringBuilder toString(StringBuilder sb) {
+            sb.append("[ ");
+            int size = size();
+            for (int i = 0; i < size; i++) {
+                get(i).toString(sb);
+                if (i != size - 1) {
+                    sb.append(", ");
+                }
+            }
+            sb.append(" ]");
+            return sb;
+        }
+
+        public Reference get(int i) {
+            long size = size();
+            long j = i;
+            if (j >= size) {
+                return Reference.NULL_REFERENCE;
+            }
+            return new Reference(this.bb, this.end + (i * this.byteWidth), this.byteWidth, Unsigned.byteToUnsignedInt(this.bb.get((int) (this.end + (size * this.byteWidth) + j))));
+        }
+    }
+
+    public static class TypedVector extends Vector {
+        private static final TypedVector EMPTY_VECTOR = new TypedVector(FlexBuffers.EMPTY_BB, 1, 1, 1);
+        private final int elemType;
+
+        public static TypedVector empty() {
+            return EMPTY_VECTOR;
+        }
+
+        public int getElemType() {
+            return this.elemType;
+        }
+
+        public boolean isEmptyVector() {
+            return this == EMPTY_VECTOR;
+        }
+
+        TypedVector(ReadBuf readBuf, int i, int i2, int i3) {
+            super(readBuf, i, i2);
+            this.elemType = i3;
+        }
+
+        @Override // androidx.emoji2.text.flatbuffer.FlexBuffers.Vector
+        public Reference get(int i) {
+            if (i >= size()) {
+                return Reference.NULL_REFERENCE;
+            }
+            return new Reference(this.bb, this.end + (i * this.byteWidth), this.byteWidth, 1, this.elemType);
+        }
+    }
+
+    public static class KeyVector {
+        private final TypedVector vec;
+
+        KeyVector(TypedVector typedVector) {
+            this.vec = typedVector;
+        }
+
+        public Key get(int i) {
+            if (i >= size()) {
+                return Key.EMPTY;
+            }
+            return new Key(this.vec.bb, FlexBuffers.indirect(this.vec.bb, this.vec.end + (i * this.vec.byteWidth), this.vec.byteWidth), 1);
+        }
+
+        public int size() {
+            return this.vec.size();
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            sb.append('[');
+            for (int i = 0; i < this.vec.size(); i++) {
+                this.vec.get(i).toString(sb);
+                if (i != this.vec.size() - 1) {
+                    sb.append(", ");
+                }
+            }
+            sb.append("]");
+            return sb.toString();
+        }
+    }
+
+    public static class FlexBufferException extends RuntimeException {
+        FlexBufferException(String str) {
+            super(str);
+        }
+    }
+
+    static class Unsigned {
+        static int byteToUnsignedInt(byte b) {
+            return b & UByte.MAX_VALUE;
+        }
+
+        static long intToUnsignedLong(int i) {
+            return i & 4294967295L;
+        }
+
+        static int shortToUnsignedInt(short s) {
+            return s & UShort.MAX_VALUE;
+        }
+
+        Unsigned() {
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/FlexBuffersBuilder.java

@@ -0,0 +1,531 @@
+package androidx.emoji2.text.flatbuffer;
+
+import androidx.emoji2.text.flatbuffer.FlexBuffers;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+
+/* loaded from: classes.dex */
+public class FlexBuffersBuilder {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    public static final int BUILDER_FLAG_NONE = 0;
+    public static final int BUILDER_FLAG_SHARE_ALL = 7;
+    public static final int BUILDER_FLAG_SHARE_KEYS = 1;
+    public static final int BUILDER_FLAG_SHARE_KEYS_AND_STRINGS = 3;
+    public static final int BUILDER_FLAG_SHARE_KEY_VECTORS = 4;
+    public static final int BUILDER_FLAG_SHARE_STRINGS = 2;
+    private static final int WIDTH_16 = 1;
+    private static final int WIDTH_32 = 2;
+    private static final int WIDTH_64 = 3;
+    private static final int WIDTH_8 = 0;
+    private final ReadWriteBuf bb;
+    private boolean finished;
+    private final int flags;
+    private Comparator<Value> keyComparator;
+    private final HashMap<String, Integer> keyPool;
+    private final ArrayList<Value> stack;
+    private final HashMap<String, Integer> stringPool;
+
+    public ReadWriteBuf getBuffer() {
+        return this.bb;
+    }
+
+    public FlexBuffersBuilder(int i) {
+        this(new ArrayReadWriteBuf(i), 1);
+    }
+
+    public FlexBuffersBuilder() {
+        this(256);
+    }
+
+    @Deprecated
+    public FlexBuffersBuilder(ByteBuffer byteBuffer, int i) {
+        this(new ArrayReadWriteBuf(byteBuffer.array()), i);
+    }
+
+    public FlexBuffersBuilder(ReadWriteBuf readWriteBuf, int i) {
+        this.stack = new ArrayList<>();
+        this.keyPool = new HashMap<>();
+        this.stringPool = new HashMap<>();
+        this.finished = false;
+        this.keyComparator = new Comparator<Value>() { // from class: androidx.emoji2.text.flatbuffer.FlexBuffersBuilder.1
+            @Override // java.util.Comparator
+            public int compare(Value value, Value value2) {
+                byte b;
+                byte b2;
+                int i2 = value.key;
+                int i3 = value2.key;
+                do {
+                    b = FlexBuffersBuilder.this.bb.get(i2);
+                    b2 = FlexBuffersBuilder.this.bb.get(i3);
+                    if (b == 0) {
+                        return b - b2;
+                    }
+                    i2++;
+                    i3++;
+                } while (b == b2);
+                return b - b2;
+            }
+        };
+        this.bb = readWriteBuf;
+        this.flags = i;
+    }
+
+    public FlexBuffersBuilder(ByteBuffer byteBuffer) {
+        this(byteBuffer, 1);
+    }
+
+    public void putBoolean(boolean z) {
+        putBoolean(null, z);
+    }
+
+    public void putBoolean(String str, boolean z) {
+        this.stack.add(Value.bool(putKey(str), z));
+    }
+
+    private int putKey(String str) {
+        if (str == null) {
+            return -1;
+        }
+        int writePosition = this.bb.writePosition();
+        if ((this.flags & 1) != 0) {
+            Integer num = this.keyPool.get(str);
+            if (num == null) {
+                byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
+                this.bb.put(bytes, 0, bytes.length);
+                this.bb.put((byte) 0);
+                this.keyPool.put(str, Integer.valueOf(writePosition));
+                return writePosition;
+            }
+            return num.intValue();
+        }
+        byte[] bytes2 = str.getBytes(StandardCharsets.UTF_8);
+        this.bb.put(bytes2, 0, bytes2.length);
+        this.bb.put((byte) 0);
+        this.keyPool.put(str, Integer.valueOf(writePosition));
+        return writePosition;
+    }
+
+    public void putInt(int i) {
+        putInt((String) null, i);
+    }
+
+    public void putInt(String str, int i) {
+        putInt(str, i);
+    }
+
+    public void putInt(String str, long j) {
+        int putKey = putKey(str);
+        if (-128 <= j && j <= 127) {
+            this.stack.add(Value.int8(putKey, (int) j));
+            return;
+        }
+        if (-32768 <= j && j <= 32767) {
+            this.stack.add(Value.int16(putKey, (int) j));
+        } else if (-2147483648L <= j && j <= 2147483647L) {
+            this.stack.add(Value.int32(putKey, (int) j));
+        } else {
+            this.stack.add(Value.int64(putKey, j));
+        }
+    }
+
+    public void putInt(long j) {
+        putInt((String) null, j);
+    }
+
+    public void putUInt(int i) {
+        putUInt(null, i);
+    }
+
+    public void putUInt(long j) {
+        putUInt(null, j);
+    }
+
+    public void putUInt64(BigInteger bigInteger) {
+        putUInt64(null, bigInteger.longValue());
+    }
+
+    private void putUInt64(String str, long j) {
+        this.stack.add(Value.uInt64(putKey(str), j));
+    }
+
+    private void putUInt(String str, long j) {
+        Value uInt64;
+        int putKey = putKey(str);
+        int widthUInBits = widthUInBits(j);
+        if (widthUInBits == 0) {
+            uInt64 = Value.uInt8(putKey, (int) j);
+        } else if (widthUInBits == 1) {
+            uInt64 = Value.uInt16(putKey, (int) j);
+        } else if (widthUInBits == 2) {
+            uInt64 = Value.uInt32(putKey, (int) j);
+        } else {
+            uInt64 = Value.uInt64(putKey, j);
+        }
+        this.stack.add(uInt64);
+    }
+
+    public void putFloat(float f) {
+        putFloat((String) null, f);
+    }
+
+    public void putFloat(String str, float f) {
+        this.stack.add(Value.float32(putKey(str), f));
+    }
+
+    public void putFloat(double d) {
+        putFloat((String) null, d);
+    }
+
+    public void putFloat(String str, double d) {
+        this.stack.add(Value.float64(putKey(str), d));
+    }
+
+    public int putString(String str) {
+        return putString(null, str);
+    }
+
+    public int putString(String str, String str2) {
+        long j;
+        int putKey = putKey(str);
+        if ((this.flags & 2) != 0) {
+            Integer num = this.stringPool.get(str2);
+            if (num == null) {
+                Value writeString = writeString(putKey, str2);
+                this.stringPool.put(str2, Integer.valueOf((int) writeString.iValue));
+                this.stack.add(writeString);
+                j = writeString.iValue;
+            } else {
+                this.stack.add(Value.blob(putKey, num.intValue(), 5, widthUInBits(str2.length())));
+                return num.intValue();
+            }
+        } else {
+            Value writeString2 = writeString(putKey, str2);
+            this.stack.add(writeString2);
+            j = writeString2.iValue;
+        }
+        return (int) j;
+    }
+
+    private Value writeString(int i, String str) {
+        return writeBlob(i, str.getBytes(StandardCharsets.UTF_8), 5, true);
+    }
+
+    static int widthUInBits(long j) {
+        if (j <= FlexBuffers.Unsigned.byteToUnsignedInt((byte) -1)) {
+            return 0;
+        }
+        if (j <= FlexBuffers.Unsigned.shortToUnsignedInt((short) -1)) {
+            return 1;
+        }
+        return j <= FlexBuffers.Unsigned.intToUnsignedLong(-1) ? 2 : 3;
+    }
+
+    private Value writeBlob(int i, byte[] bArr, int i2, boolean z) {
+        int widthUInBits = widthUInBits(bArr.length);
+        writeInt(bArr.length, align(widthUInBits));
+        int writePosition = this.bb.writePosition();
+        this.bb.put(bArr, 0, bArr.length);
+        if (z) {
+            this.bb.put((byte) 0);
+        }
+        return Value.blob(i, writePosition, i2, widthUInBits);
+    }
+
+    private int align(int i) {
+        int i2 = 1 << i;
+        int paddingBytes = Value.paddingBytes(this.bb.writePosition(), i2);
+        while (true) {
+            int i3 = paddingBytes - 1;
+            if (paddingBytes == 0) {
+                return i2;
+            }
+            this.bb.put((byte) 0);
+            paddingBytes = i3;
+        }
+    }
+
+    private void writeInt(long j, int i) {
+        if (i == 1) {
+            this.bb.put((byte) j);
+            return;
+        }
+        if (i == 2) {
+            this.bb.putShort((short) j);
+        } else if (i == 4) {
+            this.bb.putInt((int) j);
+        } else {
+            if (i != 8) {
+                return;
+            }
+            this.bb.putLong(j);
+        }
+    }
+
+    public int putBlob(byte[] bArr) {
+        return putBlob(null, bArr);
+    }
+
+    public int putBlob(String str, byte[] bArr) {
+        Value writeBlob = writeBlob(putKey(str), bArr, 25, false);
+        this.stack.add(writeBlob);
+        return (int) writeBlob.iValue;
+    }
+
+    public int startVector() {
+        return this.stack.size();
+    }
+
+    public int endVector(String str, int i, boolean z, boolean z2) {
+        Value createVector = createVector(putKey(str), i, this.stack.size() - i, z, z2, null);
+        while (this.stack.size() > i) {
+            this.stack.remove(r10.size() - 1);
+        }
+        this.stack.add(createVector);
+        return (int) createVector.iValue;
+    }
+
+    public ByteBuffer finish() {
+        int align = align(this.stack.get(0).elemWidth(this.bb.writePosition(), 0));
+        writeAny(this.stack.get(0), align);
+        this.bb.put(this.stack.get(0).storedPackedType());
+        this.bb.put((byte) align);
+        this.finished = true;
+        return ByteBuffer.wrap(this.bb.data(), 0, this.bb.writePosition());
+    }
+
+    private Value createVector(int i, int i2, int i3, boolean z, boolean z2, Value value) {
+        int i4;
+        int i5;
+        int i6 = i3;
+        long j = i6;
+        int max = Math.max(0, widthUInBits(j));
+        if (value != null) {
+            max = Math.max(max, value.elemWidth(this.bb.writePosition(), 0));
+            i4 = 3;
+        } else {
+            i4 = 1;
+        }
+        int i7 = 4;
+        int i8 = max;
+        for (int i9 = i2; i9 < this.stack.size(); i9++) {
+            i8 = Math.max(i8, this.stack.get(i9).elemWidth(this.bb.writePosition(), i9 + i4));
+            if (z && i9 == i2) {
+                i7 = this.stack.get(i9).type;
+                if (!FlexBuffers.isTypedVectorElementType(i7)) {
+                    throw new FlexBuffers.FlexBufferException("TypedVector does not support this element type");
+                }
+            }
+        }
+        int i10 = i2;
+        int align = align(i8);
+        if (value != null) {
+            writeOffset(value.iValue, align);
+            writeInt(1 << value.minBitWidth, align);
+        }
+        if (!z2) {
+            writeInt(j, align);
+        }
+        int writePosition = this.bb.writePosition();
+        for (int i11 = i10; i11 < this.stack.size(); i11++) {
+            writeAny(this.stack.get(i11), align);
+        }
+        if (!z) {
+            while (i10 < this.stack.size()) {
+                this.bb.put(this.stack.get(i10).storedPackedType(i8));
+                i10++;
+            }
+        }
+        if (value != null) {
+            i5 = 9;
+        } else if (z) {
+            if (!z2) {
+                i6 = 0;
+            }
+            i5 = FlexBuffers.toTypedVector(i7, i6);
+        } else {
+            i5 = 10;
+        }
+        return new Value(i, i5, i8, writePosition);
+    }
+
+    private void writeOffset(long j, int i) {
+        writeInt((int) (this.bb.writePosition() - j), i);
+    }
+
+    private void writeAny(Value value, int i) {
+        int i2 = value.type;
+        if (i2 != 0 && i2 != 1 && i2 != 2) {
+            if (i2 == 3) {
+                writeDouble(value.dValue, i);
+                return;
+            } else if (i2 != 26) {
+                writeOffset(value.iValue, i);
+                return;
+            }
+        }
+        writeInt(value.iValue, i);
+    }
+
+    private void writeDouble(double d, int i) {
+        if (i == 4) {
+            this.bb.putFloat((float) d);
+        } else if (i == 8) {
+            this.bb.putDouble(d);
+        }
+    }
+
+    public int startMap() {
+        return this.stack.size();
+    }
+
+    public int endMap(String str, int i) {
+        int putKey = putKey(str);
+        ArrayList<Value> arrayList = this.stack;
+        Collections.sort(arrayList.subList(i, arrayList.size()), this.keyComparator);
+        Value createVector = createVector(putKey, i, this.stack.size() - i, false, false, createKeyVector(i, this.stack.size() - i));
+        while (this.stack.size() > i) {
+            this.stack.remove(r0.size() - 1);
+        }
+        this.stack.add(createVector);
+        return (int) createVector.iValue;
+    }
+
+    private Value createKeyVector(int i, int i2) {
+        long j = i2;
+        int max = Math.max(0, widthUInBits(j));
+        int i3 = i;
+        while (i3 < this.stack.size()) {
+            i3++;
+            max = Math.max(max, Value.elemWidth(4, 0, this.stack.get(i3).key, this.bb.writePosition(), i3));
+        }
+        int align = align(max);
+        writeInt(j, align);
+        int writePosition = this.bb.writePosition();
+        while (i < this.stack.size()) {
+            int i4 = this.stack.get(i).key;
+            writeOffset(this.stack.get(i).key, align);
+            i++;
+        }
+        return new Value(-1, FlexBuffers.toTypedVector(4, 0), max, writePosition);
+    }
+
+    private static class Value {
+        static final /* synthetic */ boolean $assertionsDisabled = false;
+        final double dValue;
+        long iValue;
+        int key;
+        final int minBitWidth;
+        final int type;
+
+        private static byte packedType(int i, int i2) {
+            return (byte) (i | (i2 << 2));
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static int paddingBytes(int i, int i2) {
+            return ((~i) + 1) & (i2 - 1);
+        }
+
+        Value(int i, int i2, int i3, long j) {
+            this.key = i;
+            this.type = i2;
+            this.minBitWidth = i3;
+            this.iValue = j;
+            this.dValue = Double.MIN_VALUE;
+        }
+
+        Value(int i, int i2, int i3, double d) {
+            this.key = i;
+            this.type = i2;
+            this.minBitWidth = i3;
+            this.dValue = d;
+            this.iValue = Long.MIN_VALUE;
+        }
+
+        static Value bool(int i, boolean z) {
+            return new Value(i, 26, 0, z ? 1L : 0L);
+        }
+
+        static Value blob(int i, int i2, int i3, int i4) {
+            return new Value(i, i3, i4, i2);
+        }
+
+        static Value int8(int i, int i2) {
+            return new Value(i, 1, 0, i2);
+        }
+
+        static Value int16(int i, int i2) {
+            return new Value(i, 1, 1, i2);
+        }
+
+        static Value int32(int i, int i2) {
+            return new Value(i, 1, 2, i2);
+        }
+
+        static Value int64(int i, long j) {
+            return new Value(i, 1, 3, j);
+        }
+
+        static Value uInt8(int i, int i2) {
+            return new Value(i, 2, 0, i2);
+        }
+
+        static Value uInt16(int i, int i2) {
+            return new Value(i, 2, 1, i2);
+        }
+
+        static Value uInt32(int i, int i2) {
+            return new Value(i, 2, 2, i2);
+        }
+
+        static Value uInt64(int i, long j) {
+            return new Value(i, 2, 3, j);
+        }
+
+        static Value float32(int i, float f) {
+            return new Value(i, 3, 2, f);
+        }
+
+        static Value float64(int i, double d) {
+            return new Value(i, 3, 3, d);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public byte storedPackedType() {
+            return storedPackedType(0);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public byte storedPackedType(int i) {
+            return packedType(storedWidth(i), this.type);
+        }
+
+        private int storedWidth(int i) {
+            return FlexBuffers.isTypeInline(this.type) ? Math.max(this.minBitWidth, i) : this.minBitWidth;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public int elemWidth(int i, int i2) {
+            return elemWidth(this.type, this.minBitWidth, this.iValue, i, i2);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static int elemWidth(int i, int i2, long j, int i3, int i4) {
+            if (FlexBuffers.isTypeInline(i)) {
+                return i2;
+            }
+            for (int i5 = 1; i5 <= 32; i5 *= 2) {
+                int widthUInBits = FlexBuffersBuilder.widthUInBits((int) (((paddingBytes(i3, i5) + i3) + (i4 * i5)) - j));
+                if ((1 << widthUInBits) == i5) {
+                    return widthUInBits;
+                }
+            }
+            return 3;
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/FloatVector.java

@@ -0,0 +1,15 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class FloatVector extends BaseVector {
+    public FloatVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 4, byteBuffer);
+        return this;
+    }
+
+    public float get(int i) {
+        return this.bb.getFloat(__element(i));
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/IntVector.java

@@ -0,0 +1,19 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class IntVector extends BaseVector {
+    public IntVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 4, byteBuffer);
+        return this;
+    }
+
+    public int get(int i) {
+        return this.bb.getInt(__element(i));
+    }
+
+    public long getAsUnsigned(int i) {
+        return get(i) & 4294967295L;
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/LongVector.java

@@ -0,0 +1,15 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class LongVector extends BaseVector {
+    public LongVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 8, byteBuffer);
+        return this;
+    }
+
+    public long get(int i) {
+        return this.bb.getLong(__element(i));
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/MetadataItem.java

@@ -0,0 +1,185 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public final class MetadataItem extends Table {
+    public static void ValidateVersion() {
+        Constants.FLATBUFFERS_1_12_0();
+    }
+
+    public static MetadataItem getRootAsMetadataItem(ByteBuffer byteBuffer) {
+        return getRootAsMetadataItem(byteBuffer, new MetadataItem());
+    }
+
+    public static MetadataItem getRootAsMetadataItem(ByteBuffer byteBuffer, MetadataItem metadataItem) {
+        byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
+        return metadataItem.__assign(byteBuffer.getInt(byteBuffer.position()) + byteBuffer.position(), byteBuffer);
+    }
+
+    public void __init(int i, ByteBuffer byteBuffer) {
+        __reset(i, byteBuffer);
+    }
+
+    public MetadataItem __assign(int i, ByteBuffer byteBuffer) {
+        __init(i, byteBuffer);
+        return this;
+    }
+
+    public int id() {
+        int __offset = __offset(4);
+        if (__offset != 0) {
+            return this.bb.getInt(__offset + this.bb_pos);
+        }
+        return 0;
+    }
+
+    public boolean emojiStyle() {
+        int __offset = __offset(6);
+        return (__offset == 0 || this.bb.get(__offset + this.bb_pos) == 0) ? false : true;
+    }
+
+    public short sdkAdded() {
+        int __offset = __offset(8);
+        if (__offset != 0) {
+            return this.bb.getShort(__offset + this.bb_pos);
+        }
+        return (short) 0;
+    }
+
+    public short compatAdded() {
+        int __offset = __offset(10);
+        if (__offset != 0) {
+            return this.bb.getShort(__offset + this.bb_pos);
+        }
+        return (short) 0;
+    }
+
+    public short width() {
+        int __offset = __offset(12);
+        if (__offset != 0) {
+            return this.bb.getShort(__offset + this.bb_pos);
+        }
+        return (short) 0;
+    }
+
+    public short height() {
+        int __offset = __offset(14);
+        if (__offset != 0) {
+            return this.bb.getShort(__offset + this.bb_pos);
+        }
+        return (short) 0;
+    }
+
+    public int codepoints(int i) {
+        int __offset = __offset(16);
+        if (__offset != 0) {
+            return this.bb.getInt(__vector(__offset) + (i * 4));
+        }
+        return 0;
+    }
+
+    public int codepointsLength() {
+        int __offset = __offset(16);
+        if (__offset != 0) {
+            return __vector_len(__offset);
+        }
+        return 0;
+    }
+
+    public IntVector codepointsVector() {
+        return codepointsVector(new IntVector());
+    }
+
+    public IntVector codepointsVector(IntVector intVector) {
+        int __offset = __offset(16);
+        if (__offset != 0) {
+            return intVector.__assign(__vector(__offset), this.bb);
+        }
+        return null;
+    }
+
+    public ByteBuffer codepointsAsByteBuffer() {
+        return __vector_as_bytebuffer(16, 4);
+    }
+
+    public ByteBuffer codepointsInByteBuffer(ByteBuffer byteBuffer) {
+        return __vector_in_bytebuffer(byteBuffer, 16, 4);
+    }
+
+    public static int createMetadataItem(FlatBufferBuilder flatBufferBuilder, int i, boolean z, short s, short s2, short s3, short s4, int i2) {
+        flatBufferBuilder.startTable(7);
+        addCodepoints(flatBufferBuilder, i2);
+        addId(flatBufferBuilder, i);
+        addHeight(flatBufferBuilder, s4);
+        addWidth(flatBufferBuilder, s3);
+        addCompatAdded(flatBufferBuilder, s2);
+        addSdkAdded(flatBufferBuilder, s);
+        addEmojiStyle(flatBufferBuilder, z);
+        return endMetadataItem(flatBufferBuilder);
+    }
+
+    public static void startMetadataItem(FlatBufferBuilder flatBufferBuilder) {
+        flatBufferBuilder.startTable(7);
+    }
+
+    public static void addId(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.addInt(0, i, 0);
+    }
+
+    public static void addEmojiStyle(FlatBufferBuilder flatBufferBuilder, boolean z) {
+        flatBufferBuilder.addBoolean(1, z, false);
+    }
+
+    public static void addSdkAdded(FlatBufferBuilder flatBufferBuilder, short s) {
+        flatBufferBuilder.addShort(2, s, 0);
+    }
+
+    public static void addCompatAdded(FlatBufferBuilder flatBufferBuilder, short s) {
+        flatBufferBuilder.addShort(3, s, 0);
+    }
+
+    public static void addWidth(FlatBufferBuilder flatBufferBuilder, short s) {
+        flatBufferBuilder.addShort(4, s, 0);
+    }
+
+    public static void addHeight(FlatBufferBuilder flatBufferBuilder, short s) {
+        flatBufferBuilder.addShort(5, s, 0);
+    }
+
+    public static void addCodepoints(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.addOffset(6, i, 0);
+    }
+
+    public static int createCodepointsVector(FlatBufferBuilder flatBufferBuilder, int[] iArr) {
+        flatBufferBuilder.startVector(4, iArr.length, 4);
+        for (int length = iArr.length - 1; length >= 0; length--) {
+            flatBufferBuilder.addInt(iArr[length]);
+        }
+        return flatBufferBuilder.endVector();
+    }
+
+    public static void startCodepointsVector(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.startVector(4, i, 4);
+    }
+
+    public static int endMetadataItem(FlatBufferBuilder flatBufferBuilder) {
+        return flatBufferBuilder.endTable();
+    }
+
+    public static final class Vector extends BaseVector {
+        public Vector __assign(int i, int i2, ByteBuffer byteBuffer) {
+            __reset(i, i2, byteBuffer);
+            return this;
+        }
+
+        public MetadataItem get(int i) {
+            return get(new MetadataItem(), i);
+        }
+
+        public MetadataItem get(MetadataItem metadataItem, int i) {
+            return metadataItem.__assign(MetadataItem.__indirect(__element(i), this.bb), this.bb);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/MetadataList.java

@@ -0,0 +1,149 @@
+package androidx.emoji2.text.flatbuffer;
+
+import androidx.emoji2.text.flatbuffer.MetadataItem;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public final class MetadataList extends Table {
+    public static void ValidateVersion() {
+        Constants.FLATBUFFERS_1_12_0();
+    }
+
+    public static MetadataList getRootAsMetadataList(ByteBuffer byteBuffer) {
+        return getRootAsMetadataList(byteBuffer, new MetadataList());
+    }
+
+    public static MetadataList getRootAsMetadataList(ByteBuffer byteBuffer, MetadataList metadataList) {
+        byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
+        return metadataList.__assign(byteBuffer.getInt(byteBuffer.position()) + byteBuffer.position(), byteBuffer);
+    }
+
+    public void __init(int i, ByteBuffer byteBuffer) {
+        __reset(i, byteBuffer);
+    }
+
+    public MetadataList __assign(int i, ByteBuffer byteBuffer) {
+        __init(i, byteBuffer);
+        return this;
+    }
+
+    public int version() {
+        int __offset = __offset(4);
+        if (__offset != 0) {
+            return this.bb.getInt(__offset + this.bb_pos);
+        }
+        return 0;
+    }
+
+    public MetadataItem list(int i) {
+        return list(new MetadataItem(), i);
+    }
+
+    public MetadataItem list(MetadataItem metadataItem, int i) {
+        int __offset = __offset(6);
+        if (__offset != 0) {
+            return metadataItem.__assign(__indirect(__vector(__offset) + (i * 4)), this.bb);
+        }
+        return null;
+    }
+
+    public int listLength() {
+        int __offset = __offset(6);
+        if (__offset != 0) {
+            return __vector_len(__offset);
+        }
+        return 0;
+    }
+
+    public MetadataItem.Vector listVector() {
+        return listVector(new MetadataItem.Vector());
+    }
+
+    public MetadataItem.Vector listVector(MetadataItem.Vector vector) {
+        int __offset = __offset(6);
+        if (__offset != 0) {
+            return vector.__assign(__vector(__offset), 4, this.bb);
+        }
+        return null;
+    }
+
+    public String sourceSha() {
+        int __offset = __offset(8);
+        if (__offset != 0) {
+            return __string(__offset + this.bb_pos);
+        }
+        return null;
+    }
+
+    public ByteBuffer sourceShaAsByteBuffer() {
+        return __vector_as_bytebuffer(8, 1);
+    }
+
+    public ByteBuffer sourceShaInByteBuffer(ByteBuffer byteBuffer) {
+        return __vector_in_bytebuffer(byteBuffer, 8, 1);
+    }
+
+    public static int createMetadataList(FlatBufferBuilder flatBufferBuilder, int i, int i2, int i3) {
+        flatBufferBuilder.startTable(3);
+        addSourceSha(flatBufferBuilder, i3);
+        addList(flatBufferBuilder, i2);
+        addVersion(flatBufferBuilder, i);
+        return endMetadataList(flatBufferBuilder);
+    }
+
+    public static void startMetadataList(FlatBufferBuilder flatBufferBuilder) {
+        flatBufferBuilder.startTable(3);
+    }
+
+    public static void addVersion(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.addInt(0, i, 0);
+    }
+
+    public static void addList(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.addOffset(1, i, 0);
+    }
+
+    public static int createListVector(FlatBufferBuilder flatBufferBuilder, int[] iArr) {
+        flatBufferBuilder.startVector(4, iArr.length, 4);
+        for (int length = iArr.length - 1; length >= 0; length--) {
+            flatBufferBuilder.addOffset(iArr[length]);
+        }
+        return flatBufferBuilder.endVector();
+    }
+
+    public static void startListVector(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.startVector(4, i, 4);
+    }
+
+    public static void addSourceSha(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.addOffset(2, i, 0);
+    }
+
+    public static int endMetadataList(FlatBufferBuilder flatBufferBuilder) {
+        return flatBufferBuilder.endTable();
+    }
+
+    public static void finishMetadataListBuffer(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.finish(i);
+    }
+
+    public static void finishSizePrefixedMetadataListBuffer(FlatBufferBuilder flatBufferBuilder, int i) {
+        flatBufferBuilder.finishSizePrefixed(i);
+    }
+
+    public static final class Vector extends BaseVector {
+        public Vector __assign(int i, int i2, ByteBuffer byteBuffer) {
+            __reset(i, i2, byteBuffer);
+            return this;
+        }
+
+        public MetadataList get(int i) {
+            return get(new MetadataList(), i);
+        }
+
+        public MetadataList get(MetadataList metadataList, int i) {
+            return metadataList.__assign(MetadataList.__indirect(__element(i), this.bb), this.bb);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ReadBuf.java

@@ -0,0 +1,24 @@
+package androidx.emoji2.text.flatbuffer;
+
+/* loaded from: classes.dex */
+interface ReadBuf {
+    byte[] data();
+
+    byte get(int i);
+
+    boolean getBoolean(int i);
+
+    double getDouble(int i);
+
+    float getFloat(int i);
+
+    int getInt(int i);
+
+    long getLong(int i);
+
+    short getShort(int i);
+
+    String getString(int i, int i2);
+
+    int limit();
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ReadWriteBuf.java

@@ -0,0 +1,43 @@
+package androidx.emoji2.text.flatbuffer;
+
+/* loaded from: classes.dex */
+interface ReadWriteBuf extends ReadBuf {
+    @Override // androidx.emoji2.text.flatbuffer.ReadBuf
+    int limit();
+
+    void put(byte b);
+
+    void put(byte[] bArr, int i, int i2);
+
+    void putBoolean(boolean z);
+
+    void putDouble(double d);
+
+    void putFloat(float f);
+
+    void putInt(int i);
+
+    void putLong(long j);
+
+    void putShort(short s);
+
+    boolean requestCapacity(int i);
+
+    void set(int i, byte b);
+
+    void set(int i, byte[] bArr, int i2, int i3);
+
+    void setBoolean(int i, boolean z);
+
+    void setDouble(int i, double d);
+
+    void setFloat(int i, float f);
+
+    void setInt(int i, int i2);
+
+    void setLong(int i, long j);
+
+    void setShort(int i, short s);
+
+    int writePosition();
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/ShortVector.java

@@ -0,0 +1,20 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import kotlin.UShort;
+
+/* loaded from: classes.dex */
+public final class ShortVector extends BaseVector {
+    public ShortVector __assign(int i, ByteBuffer byteBuffer) {
+        __reset(i, 2, byteBuffer);
+        return this;
+    }
+
+    public short get(int i) {
+        return this.bb.getShort(__element(i));
+    }
+
+    public int getAsUnsigned(int i) {
+        return get(i) & UShort.MAX_VALUE;
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/StringVector.java

@@ -0,0 +1,17 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class StringVector extends BaseVector {
+    private Utf8 utf8 = Utf8.getDefault();
+
+    public StringVector __assign(int i, int i2, ByteBuffer byteBuffer) {
+        __reset(i, i2, byteBuffer);
+        return this;
+    }
+
+    public String get(int i) {
+        return Table.__string(__element(i), this.bb, this.utf8);
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/Struct.java

@@ -0,0 +1,22 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public class Struct {
+    protected ByteBuffer bb;
+    protected int bb_pos;
+
+    protected void __reset(int i, ByteBuffer byteBuffer) {
+        this.bb = byteBuffer;
+        if (byteBuffer != null) {
+            this.bb_pos = i;
+        } else {
+            this.bb_pos = 0;
+        }
+    }
+
+    public void __reset() {
+        __reset(0, null);
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/Table.java

@@ -0,0 +1,174 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+import java.util.Comparator;
+
+/* loaded from: classes.dex */
+public class Table {
+    protected ByteBuffer bb;
+    protected int bb_pos;
+    Utf8 utf8 = Utf8.getDefault();
+    private int vtable_size;
+    private int vtable_start;
+
+    public ByteBuffer getByteBuffer() {
+        return this.bb;
+    }
+
+    protected int keysCompare(Integer num, Integer num2, ByteBuffer byteBuffer) {
+        return 0;
+    }
+
+    protected int __offset(int i) {
+        if (i < this.vtable_size) {
+            return this.bb.getShort(this.vtable_start + i);
+        }
+        return 0;
+    }
+
+    protected static int __offset(int i, int i2, ByteBuffer byteBuffer) {
+        int capacity = byteBuffer.capacity() - i2;
+        return byteBuffer.getShort((i + capacity) - byteBuffer.getInt(capacity)) + capacity;
+    }
+
+    protected int __indirect(int i) {
+        return i + this.bb.getInt(i);
+    }
+
+    protected static int __indirect(int i, ByteBuffer byteBuffer) {
+        return i + byteBuffer.getInt(i);
+    }
+
+    protected String __string(int i) {
+        return __string(i, this.bb, this.utf8);
+    }
+
+    protected static String __string(int i, ByteBuffer byteBuffer, Utf8 utf8) {
+        int i2 = i + byteBuffer.getInt(i);
+        return utf8.decodeUtf8(byteBuffer, i2 + 4, byteBuffer.getInt(i2));
+    }
+
+    protected int __vector_len(int i) {
+        int i2 = i + this.bb_pos;
+        return this.bb.getInt(i2 + this.bb.getInt(i2));
+    }
+
+    protected int __vector(int i) {
+        int i2 = i + this.bb_pos;
+        return i2 + this.bb.getInt(i2) + 4;
+    }
+
+    protected ByteBuffer __vector_as_bytebuffer(int i, int i2) {
+        int __offset = __offset(i);
+        if (__offset == 0) {
+            return null;
+        }
+        ByteBuffer order = this.bb.duplicate().order(ByteOrder.LITTLE_ENDIAN);
+        int __vector = __vector(__offset);
+        order.position(__vector);
+        order.limit(__vector + (__vector_len(__offset) * i2));
+        return order;
+    }
+
+    protected ByteBuffer __vector_in_bytebuffer(ByteBuffer byteBuffer, int i, int i2) {
+        int __offset = __offset(i);
+        if (__offset == 0) {
+            return null;
+        }
+        int __vector = __vector(__offset);
+        byteBuffer.rewind();
+        byteBuffer.limit((__vector_len(__offset) * i2) + __vector);
+        byteBuffer.position(__vector);
+        return byteBuffer;
+    }
+
+    protected Table __union(Table table, int i) {
+        return __union(table, i, this.bb);
+    }
+
+    protected static Table __union(Table table, int i, ByteBuffer byteBuffer) {
+        table.__reset(__indirect(i, byteBuffer), byteBuffer);
+        return table;
+    }
+
+    protected static boolean __has_identifier(ByteBuffer byteBuffer, String str) {
+        if (str.length() != 4) {
+            throw new AssertionError("FlatBuffers: file identifier must be length 4");
+        }
+        for (int i = 0; i < 4; i++) {
+            if (str.charAt(i) != ((char) byteBuffer.get(byteBuffer.position() + 4 + i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    protected void sortTables(int[] iArr, final ByteBuffer byteBuffer) {
+        Integer[] numArr = new Integer[iArr.length];
+        for (int i = 0; i < iArr.length; i++) {
+            numArr[i] = Integer.valueOf(iArr[i]);
+        }
+        Arrays.sort(numArr, new Comparator<Integer>() { // from class: androidx.emoji2.text.flatbuffer.Table.1
+            @Override // java.util.Comparator
+            public int compare(Integer num, Integer num2) {
+                return Table.this.keysCompare(num, num2, byteBuffer);
+            }
+        });
+        for (int i2 = 0; i2 < iArr.length; i2++) {
+            iArr[i2] = numArr[i2].intValue();
+        }
+    }
+
+    protected static int compareStrings(int i, int i2, ByteBuffer byteBuffer) {
+        int i3 = i + byteBuffer.getInt(i);
+        int i4 = i2 + byteBuffer.getInt(i2);
+        int i5 = byteBuffer.getInt(i3);
+        int i6 = byteBuffer.getInt(i4);
+        int i7 = i3 + 4;
+        int i8 = i4 + 4;
+        int min = Math.min(i5, i6);
+        for (int i9 = 0; i9 < min; i9++) {
+            int i10 = i9 + i7;
+            int i11 = i9 + i8;
+            if (byteBuffer.get(i10) != byteBuffer.get(i11)) {
+                return byteBuffer.get(i10) - byteBuffer.get(i11);
+            }
+        }
+        return i5 - i6;
+    }
+
+    protected static int compareStrings(int i, byte[] bArr, ByteBuffer byteBuffer) {
+        int i2 = i + byteBuffer.getInt(i);
+        int i3 = byteBuffer.getInt(i2);
+        int length = bArr.length;
+        int i4 = i2 + 4;
+        int min = Math.min(i3, length);
+        for (int i5 = 0; i5 < min; i5++) {
+            int i6 = i5 + i4;
+            if (byteBuffer.get(i6) != bArr[i5]) {
+                return byteBuffer.get(i6) - bArr[i5];
+            }
+        }
+        return i3 - length;
+    }
+
+    protected void __reset(int i, ByteBuffer byteBuffer) {
+        this.bb = byteBuffer;
+        if (byteBuffer == null) {
+            this.bb_pos = 0;
+            this.vtable_start = 0;
+            this.vtable_size = 0;
+        } else {
+            this.bb_pos = i;
+            int i2 = i - byteBuffer.getInt(i);
+            this.vtable_start = i2;
+            this.vtable_size = this.bb.getShort(i2);
+        }
+    }
+
+    public void __reset() {
+        __reset(0, null);
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/UnionVector.java

@@ -0,0 +1,15 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class UnionVector extends BaseVector {
+    public UnionVector __assign(int i, int i2, ByteBuffer byteBuffer) {
+        __reset(i, i2, byteBuffer);
+        return this;
+    }
+
+    public Table get(Table table, int i) {
+        return Table.__union(table, __element(i), this.bb);
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/Utf8.java

@@ -0,0 +1,94 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public abstract class Utf8 {
+    private static Utf8 DEFAULT;
+
+    public static void setDefault(Utf8 utf8) {
+        DEFAULT = utf8;
+    }
+
+    public abstract String decodeUtf8(ByteBuffer byteBuffer, int i, int i2);
+
+    public abstract void encodeUtf8(CharSequence charSequence, ByteBuffer byteBuffer);
+
+    public abstract int encodedLength(CharSequence charSequence);
+
+    public static Utf8 getDefault() {
+        if (DEFAULT == null) {
+            DEFAULT = new Utf8Safe();
+        }
+        return DEFAULT;
+    }
+
+    static class DecodeUtil {
+        private static char highSurrogate(int i) {
+            return (char) ((i >>> 10) + 55232);
+        }
+
+        private static boolean isNotTrailingByte(byte b) {
+            return b > -65;
+        }
+
+        static boolean isOneByte(byte b) {
+            return b >= 0;
+        }
+
+        static boolean isThreeBytes(byte b) {
+            return b < -16;
+        }
+
+        static boolean isTwoBytes(byte b) {
+            return b < -32;
+        }
+
+        private static char lowSurrogate(int i) {
+            return (char) ((i & 1023) + 56320);
+        }
+
+        private static int trailingByteValue(byte b) {
+            return b & 63;
+        }
+
+        DecodeUtil() {
+        }
+
+        static void handleOneByte(byte b, char[] cArr, int i) {
+            cArr[i] = (char) b;
+        }
+
+        static void handleTwoBytes(byte b, byte b2, char[] cArr, int i) throws IllegalArgumentException {
+            if (b < -62) {
+                throw new IllegalArgumentException("Invalid UTF-8: Illegal leading byte in 2 bytes utf");
+            }
+            if (isNotTrailingByte(b2)) {
+                throw new IllegalArgumentException("Invalid UTF-8: Illegal trailing byte in 2 bytes utf");
+            }
+            cArr[i] = (char) (((b & 31) << 6) | trailingByteValue(b2));
+        }
+
+        static void handleThreeBytes(byte b, byte b2, byte b3, char[] cArr, int i) throws IllegalArgumentException {
+            if (isNotTrailingByte(b2) || ((b == -32 && b2 < -96) || ((b == -19 && b2 >= -96) || isNotTrailingByte(b3)))) {
+                throw new IllegalArgumentException("Invalid UTF-8");
+            }
+            cArr[i] = (char) (((b & 15) << 12) | (trailingByteValue(b2) << 6) | trailingByteValue(b3));
+        }
+
+        static void handleFourBytes(byte b, byte b2, byte b3, byte b4, char[] cArr, int i) throws IllegalArgumentException {
+            if (isNotTrailingByte(b2) || (((b << 28) + (b2 + 112)) >> 30) != 0 || isNotTrailingByte(b3) || isNotTrailingByte(b4)) {
+                throw new IllegalArgumentException("Invalid UTF-8");
+            }
+            int trailingByteValue = ((b & 7) << 18) | (trailingByteValue(b2) << 12) | (trailingByteValue(b3) << 6) | trailingByteValue(b4);
+            cArr[i] = highSurrogate(trailingByteValue);
+            cArr[i + 1] = lowSurrogate(trailingByteValue);
+        }
+    }
+
+    static class UnpairedSurrogateException extends IllegalArgumentException {
+        UnpairedSurrogateException(int i, int i2) {
+            super("Unpaired surrogate at index " + i + " of " + i2);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/Utf8Old.java

@@ -0,0 +1,85 @@
+package androidx.emoji2.text.flatbuffer;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.StandardCharsets;
+import java.util.function.Supplier;
+
+/* loaded from: classes.dex */
+public class Utf8Old extends Utf8 {
+    private static final ThreadLocal<Cache> CACHE;
+
+    /* JADX INFO: Access modifiers changed from: private */
+    static class Cache {
+        CharSequence lastInput = null;
+        ByteBuffer lastOutput = null;
+        final CharsetEncoder encoder = StandardCharsets.UTF_8.newEncoder();
+        final CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
+
+        Cache() {
+        }
+    }
+
+    static {
+        ThreadLocal<Cache> withInitial;
+        withInitial = ThreadLocal.withInitial(new Supplier() { // from class: androidx.emoji2.text.flatbuffer.Utf8Old$$ExternalSyntheticLambda1
+            @Override // java.util.function.Supplier
+            public final Object get() {
+                return Utf8Old.lambda$static$0();
+            }
+        });
+        CACHE = withInitial;
+    }
+
+    static /* synthetic */ Cache lambda$static$0() {
+        return new Cache();
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.Utf8
+    public int encodedLength(CharSequence charSequence) {
+        Cache cache = CACHE.get();
+        int length = (int) (charSequence.length() * cache.encoder.maxBytesPerChar());
+        if (cache.lastOutput == null || cache.lastOutput.capacity() < length) {
+            cache.lastOutput = ByteBuffer.allocate(Math.max(128, length));
+        }
+        cache.lastOutput.clear();
+        cache.lastInput = charSequence;
+        CoderResult encode = cache.encoder.encode(charSequence instanceof CharBuffer ? (CharBuffer) charSequence : CharBuffer.wrap(charSequence), cache.lastOutput, true);
+        if (encode.isError()) {
+            try {
+                encode.throwException();
+            } catch (CharacterCodingException e) {
+                throw new IllegalArgumentException("bad character encoding", e);
+            }
+        }
+        cache.lastOutput.flip();
+        return cache.lastOutput.remaining();
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.Utf8
+    public void encodeUtf8(CharSequence charSequence, ByteBuffer byteBuffer) {
+        Cache cache = CACHE.get();
+        if (cache.lastInput != charSequence) {
+            encodedLength(charSequence);
+        }
+        byteBuffer.put(cache.lastOutput);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.Utf8
+    public String decodeUtf8(ByteBuffer byteBuffer, int i, int i2) {
+        CharsetDecoder charsetDecoder = CACHE.get().decoder;
+        charsetDecoder.reset();
+        ByteBuffer duplicate = byteBuffer.duplicate();
+        duplicate.position(i);
+        duplicate.limit(i + i2);
+        try {
+            return charsetDecoder.decode(duplicate).toString();
+        } catch (CharacterCodingException e) {
+            throw new IllegalArgumentException("Bad encoding", e);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/emoji2/text/flatbuffer/Utf8Safe.java

@@ -0,0 +1,309 @@
+package androidx.emoji2.text.flatbuffer;
+
+import androidx.emoji2.text.flatbuffer.Utf8;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class Utf8Safe extends Utf8 {
+    private static int computeEncodedLength(CharSequence charSequence) {
+        int length = charSequence.length();
+        int i = 0;
+        while (i < length && charSequence.charAt(i) < 128) {
+            i++;
+        }
+        int i2 = length;
+        while (true) {
+            if (i < length) {
+                char charAt = charSequence.charAt(i);
+                if (charAt >= 2048) {
+                    i2 += encodedLengthGeneral(charSequence, i);
+                    break;
+                }
+                i2 += (127 - charAt) >>> 31;
+                i++;
+            } else {
+                break;
+            }
+        }
+        if (i2 >= length) {
+            return i2;
+        }
+        throw new IllegalArgumentException("UTF-8 length does not fit in int: " + (i2 + 4294967296L));
+    }
+
+    private static int encodedLengthGeneral(CharSequence charSequence, int i) {
+        int length = charSequence.length();
+        int i2 = 0;
+        while (i < length) {
+            char charAt = charSequence.charAt(i);
+            if (charAt < 2048) {
+                i2 += (127 - charAt) >>> 31;
+            } else {
+                i2 += 2;
+                if (55296 <= charAt && charAt <= 57343) {
+                    if (Character.codePointAt(charSequence, i) < 65536) {
+                        throw new UnpairedSurrogateException(i, length);
+                    }
+                    i++;
+                }
+            }
+            i++;
+        }
+        return i2;
+    }
+
+    public static String decodeUtf8Array(byte[] bArr, int i, int i2) {
+        if ((i | i2 | ((bArr.length - i) - i2)) < 0) {
+            throw new ArrayIndexOutOfBoundsException(String.format("buffer length=%d, index=%d, size=%d", Integer.valueOf(bArr.length), Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+        int i3 = i + i2;
+        char[] cArr = new char[i2];
+        int i4 = 0;
+        while (i < i3) {
+            byte b = bArr[i];
+            if (!Utf8.DecodeUtil.isOneByte(b)) {
+                break;
+            }
+            i++;
+            Utf8.DecodeUtil.handleOneByte(b, cArr, i4);
+            i4++;
+        }
+        int i5 = i4;
+        while (i < i3) {
+            int i6 = i + 1;
+            byte b2 = bArr[i];
+            if (Utf8.DecodeUtil.isOneByte(b2)) {
+                int i7 = i5 + 1;
+                Utf8.DecodeUtil.handleOneByte(b2, cArr, i5);
+                while (i6 < i3) {
+                    byte b3 = bArr[i6];
+                    if (!Utf8.DecodeUtil.isOneByte(b3)) {
+                        break;
+                    }
+                    i6++;
+                    Utf8.DecodeUtil.handleOneByte(b3, cArr, i7);
+                    i7++;
+                }
+                i5 = i7;
+                i = i6;
+            } else if (Utf8.DecodeUtil.isTwoBytes(b2)) {
+                if (i6 >= i3) {
+                    throw new IllegalArgumentException("Invalid UTF-8");
+                }
+                i += 2;
+                Utf8.DecodeUtil.handleTwoBytes(b2, bArr[i6], cArr, i5);
+                i5++;
+            } else if (Utf8.DecodeUtil.isThreeBytes(b2)) {
+                if (i6 >= i3 - 1) {
+                    throw new IllegalArgumentException("Invalid UTF-8");
+                }
+                int i8 = i + 2;
+                i += 3;
+                Utf8.DecodeUtil.handleThreeBytes(b2, bArr[i6], bArr[i8], cArr, i5);
+                i5++;
+            } else {
+                if (i6 >= i3 - 2) {
+                    throw new IllegalArgumentException("Invalid UTF-8");
+                }
+                byte b4 = bArr[i6];
+                int i9 = i + 3;
+                byte b5 = bArr[i + 2];
+                i += 4;
+                Utf8.DecodeUtil.handleFourBytes(b2, b4, b5, bArr[i9], cArr, i5);
+                i5 += 2;
+            }
+        }
+        return new String(cArr, 0, i5);
+    }
+
+    public static String decodeUtf8Buffer(ByteBuffer byteBuffer, int i, int i2) {
+        if ((i | i2 | ((byteBuffer.limit() - i) - i2)) < 0) {
+            throw new ArrayIndexOutOfBoundsException(String.format("buffer limit=%d, index=%d, limit=%d", Integer.valueOf(byteBuffer.limit()), Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+        int i3 = i + i2;
+        char[] cArr = new char[i2];
+        int i4 = 0;
+        while (i < i3) {
+            byte b = byteBuffer.get(i);
+            if (!Utf8.DecodeUtil.isOneByte(b)) {
+                break;
+            }
+            i++;
+            Utf8.DecodeUtil.handleOneByte(b, cArr, i4);
+            i4++;
+        }
+        int i5 = i4;
+        while (i < i3) {
+            int i6 = i + 1;
+            byte b2 = byteBuffer.get(i);
+            if (Utf8.DecodeUtil.isOneByte(b2)) {
+                int i7 = i5 + 1;
+                Utf8.DecodeUtil.handleOneByte(b2, cArr, i5);
+                while (i6 < i3) {
+                    byte b3 = byteBuffer.get(i6);
+                    if (!Utf8.DecodeUtil.isOneByte(b3)) {
+                        break;
+                    }
+                    i6++;
+                    Utf8.DecodeUtil.handleOneByte(b3, cArr, i7);
+                    i7++;
+                }
+                i5 = i7;
+                i = i6;
+            } else if (Utf8.DecodeUtil.isTwoBytes(b2)) {
+                if (i6 >= i3) {
+                    throw new IllegalArgumentException("Invalid UTF-8");
+                }
+                i += 2;
+                Utf8.DecodeUtil.handleTwoBytes(b2, byteBuffer.get(i6), cArr, i5);
+                i5++;
+            } else if (Utf8.DecodeUtil.isThreeBytes(b2)) {
+                if (i6 >= i3 - 1) {
+                    throw new IllegalArgumentException("Invalid UTF-8");
+                }
+                int i8 = i + 2;
+                i += 3;
+                Utf8.DecodeUtil.handleThreeBytes(b2, byteBuffer.get(i6), byteBuffer.get(i8), cArr, i5);
+                i5++;
+            } else {
+                if (i6 >= i3 - 2) {
+                    throw new IllegalArgumentException("Invalid UTF-8");
+                }
+                byte b4 = byteBuffer.get(i6);
+                int i9 = i + 3;
+                byte b5 = byteBuffer.get(i + 2);
+                i += 4;
+                Utf8.DecodeUtil.handleFourBytes(b2, b4, b5, byteBuffer.get(i9), cArr, i5);
+                i5 += 2;
+            }
+        }
+        return new String(cArr, 0, i5);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.Utf8
+    public int encodedLength(CharSequence charSequence) {
+        return computeEncodedLength(charSequence);
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.Utf8
+    public String decodeUtf8(ByteBuffer byteBuffer, int i, int i2) throws IllegalArgumentException {
+        if (byteBuffer.hasArray()) {
+            return decodeUtf8Array(byteBuffer.array(), byteBuffer.arrayOffset() + i, i2);
+        }
+        return decodeUtf8Buffer(byteBuffer, i, i2);
+    }
+
+    private static void encodeUtf8Buffer(CharSequence charSequence, ByteBuffer byteBuffer) {
+        int length = charSequence.length();
+        int position = byteBuffer.position();
+        int i = 0;
+        while (i < length) {
+            try {
+                char charAt = charSequence.charAt(i);
+                if (charAt >= 128) {
+                    break;
+                }
+                byteBuffer.put(position + i, (byte) charAt);
+                i++;
+            } catch (IndexOutOfBoundsException unused) {
+                throw new ArrayIndexOutOfBoundsException("Failed writing " + charSequence.charAt(i) + " at index " + (byteBuffer.position() + Math.max(i, (position - byteBuffer.position()) + 1)));
+            }
+        }
+        if (i == length) {
+            byteBuffer.position(position + i);
+            return;
+        }
+        position += i;
+        while (i < length) {
+            char charAt2 = charSequence.charAt(i);
+            if (charAt2 < 128) {
+                byteBuffer.put(position, (byte) charAt2);
+            } else if (charAt2 < 2048) {
+                int i2 = position + 1;
+                try {
+                    byteBuffer.put(position, (byte) ((charAt2 >>> 6) | 192));
+                    byteBuffer.put(i2, (byte) ((charAt2 & '?') | 128));
+                    position = i2;
+                } catch (IndexOutOfBoundsException unused2) {
+                    position = i2;
+                    throw new ArrayIndexOutOfBoundsException("Failed writing " + charSequence.charAt(i) + " at index " + (byteBuffer.position() + Math.max(i, (position - byteBuffer.position()) + 1)));
+                }
+            } else if (charAt2 < 55296 || 57343 < charAt2) {
+                int i3 = position + 1;
+                byteBuffer.put(position, (byte) ((charAt2 >>> '\f') | 224));
+                position += 2;
+                byteBuffer.put(i3, (byte) (((charAt2 >>> 6) & 63) | 128));
+                byteBuffer.put(position, (byte) ((charAt2 & '?') | 128));
+            } else {
+                int i4 = i + 1;
+                if (i4 != length) {
+                    try {
+                        char charAt3 = charSequence.charAt(i4);
+                        if (Character.isSurrogatePair(charAt2, charAt3)) {
+                            int codePoint = Character.toCodePoint(charAt2, charAt3);
+                            int i5 = position + 1;
+                            try {
+                                byteBuffer.put(position, (byte) ((codePoint >>> 18) | 240));
+                                int i6 = position + 2;
+                                try {
+                                    byteBuffer.put(i5, (byte) (((codePoint >>> 12) & 63) | 128));
+                                    position += 3;
+                                    byteBuffer.put(i6, (byte) (((codePoint >>> 6) & 63) | 128));
+                                    byteBuffer.put(position, (byte) ((codePoint & 63) | 128));
+                                    i = i4;
+                                } catch (IndexOutOfBoundsException unused3) {
+                                    i = i4;
+                                    position = i6;
+                                    throw new ArrayIndexOutOfBoundsException("Failed writing " + charSequence.charAt(i) + " at index " + (byteBuffer.position() + Math.max(i, (position - byteBuffer.position()) + 1)));
+                                }
+                            } catch (IndexOutOfBoundsException unused4) {
+                                position = i5;
+                                i = i4;
+                                throw new ArrayIndexOutOfBoundsException("Failed writing " + charSequence.charAt(i) + " at index " + (byteBuffer.position() + Math.max(i, (position - byteBuffer.position()) + 1)));
+                            }
+                        } else {
+                            i = i4;
+                        }
+                    } catch (IndexOutOfBoundsException unused5) {
+                    }
+                }
+                throw new UnpairedSurrogateException(i, length);
+            }
+            i++;
+            position++;
+        }
+        byteBuffer.position(position);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:12:0x001d, code lost:
+    
+        return r9 + r0;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static int encodeUtf8Array(java.lang.CharSequence r7, byte[] r8, int r9, int r10) {
+        /*
+            Method dump skipped, instructions count: 251
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.emoji2.text.flatbuffer.Utf8Safe.encodeUtf8Array(java.lang.CharSequence, byte[], int, int):int");
+    }
+
+    @Override // androidx.emoji2.text.flatbuffer.Utf8
+    public void encodeUtf8(CharSequence charSequence, ByteBuffer byteBuffer) {
+        if (byteBuffer.hasArray()) {
+            int arrayOffset = byteBuffer.arrayOffset();
+            byteBuffer.position(encodeUtf8Array(charSequence, byteBuffer.array(), byteBuffer.position() + arrayOffset, byteBuffer.remaining()) - arrayOffset);
+        } else {
+            encodeUtf8Buffer(charSequence, byteBuffer);
+        }
+    }
+
+    static class UnpairedSurrogateException extends IllegalArgumentException {
+        UnpairedSurrogateException(int i, int i2) {
+            super("Unpaired surrogate at index " + i + " of " + i2);
+        }
+    }
+}