Initial commit

sources/gnu/trove/CanonicalEquality.java

@@ -0,0 +1,7 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+class CanonicalEquality<T> implements Equality<T> {
+    CanonicalEquality() {
+    }
+}

sources/gnu/trove/Equality.java

@@ -0,0 +1,9 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface Equality<T> {
+    static {
+        new CanonicalEquality();
+        new IdentityEquality();
+    }
+}

sources/gnu/trove/HashFunctions.java

@@ -0,0 +1,28 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public final class HashFunctions {
+    public static int a(double d) {
+        long doubleToLongBits = Double.doubleToLongBits(d);
+        return (int) (doubleToLongBits ^ (doubleToLongBits >>> 32));
+    }
+
+    public static int a(int i) {
+        return i;
+    }
+
+    public static int a(long j) {
+        return (int) (j ^ (j >> 32));
+    }
+
+    public static int a(float f) {
+        return Float.floatToIntBits(f * 6.6360896E8f);
+    }
+
+    public static int a(Object obj) {
+        if (obj == null) {
+            return 0;
+        }
+        return obj.hashCode();
+    }
+}

sources/gnu/trove/IdentityEquality.java

@@ -0,0 +1,7 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+class IdentityEquality<T> implements Equality<T> {
+    IdentityEquality() {
+    }
+}

sources/gnu/trove/PrimeFinder.java

@@ -0,0 +1,20 @@
+package gnu.trove;
+
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public final class PrimeFinder {
+    private static final int[] a = {Integer.MAX_VALUE, 5, 11, 23, 47, 97, 197, 397, 797, 1597, 3203, 6421, 12853, 25717, 51437, 102877, 205759, 411527, 823117, 1646237, 3292489, 6584983, 13169977, 26339969, 52679969, 105359939, 210719881, 421439783, 842879579, 1685759167, 433, 877, 1759, 3527, 7057, 14143, 28289, 56591, 113189, 226379, 452759, 905551, 1811107, 3622219, 7244441, 14488931, 28977863, 57955739, 115911563, 231823147, 463646329, 927292699, 1854585413, 953, 1907, 3821, 7643, 15287, 30577, 61169, 122347, 244703, 489407, 978821, 1957651, 3915341, 7830701, 15661423, 31322867, 62645741, 125291483, 250582987, 501165979, 1002331963, 2004663929, 1039, 2081, 4177, 8363, 16729, 33461, 66923, 133853, 267713, 535481, 1070981, 2141977, 4283963, 8567929, 17135863, 34271747, 68543509, 137087021, 274174111, 548348231, 1096696463, 31, 67, 137, 277, 557, 1117, 2237, 4481, 8963, 17929, 35863, 71741, 143483, 286973, 573953, 1147921, 2295859, 4591721, 9183457, 18366923, 36733847, 73467739, 146935499, 293871013, 587742049, 1175484103, 599, 1201, 2411, 4831, 9677, 19373, 38747, 77509, 155027, 310081, 620171, 1240361, 2480729, 4961459, 9922933, 19845871, 39691759, 79383533, 158767069, 317534141, 635068283, 1270136683, 311, 631, 1277, 2557, 5119, 10243, 20507, 41017, 82037, 164089, 328213, 656429, 1312867, 2625761, 5251529, 10503061, 21006137, 42012281, 84024581, 168049163, 336098327, 672196673, 1344393353, 3, 7, 17, 37, 79, 163, 331, 673, 1361, 2729, 5471, 10949, 21911, 43853, 87719, 175447, 350899, 701819, 1403641, 2807303, 5614657, 11229331, 22458671, 44917381, 89834777, 179669557, 359339171, 718678369, 1437356741, 43, 89, 179, 359, 719, 1439, 2879, 5779, 11579, 23159, 46327, 92657, 185323, 370661, 741337, 1482707, 2965421, 5930887, 11861791, 23723597, 47447201, 94894427, 189788857, 379577741, 759155483, 1518310967, 379, 761, 1523, 3049, 6101, 12203, 24407, 48817, 97649, 195311, 390647, 781301, 1562611, 3125257, 6250537, 12501169, 25002389, 50004791, 100009607, 200019221, 400038451, 800076929, 1600153859};
+
+    static {
+        Arrays.sort(a);
+    }
+
+    public static int a(int i) {
+        int binarySearch = Arrays.binarySearch(a, i);
+        if (binarySearch < 0) {
+            binarySearch = (-binarySearch) - 1;
+        }
+        return a[binarySearch];
+    }
+}

sources/gnu/trove/SerializationProcedure.java

@@ -0,0 +1,512 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+class SerializationProcedure implements TDoubleByteProcedure, TDoubleDoubleProcedure, TDoubleFloatProcedure, TDoubleIntProcedure, TDoubleLongProcedure, TDoubleObjectProcedure, TDoubleProcedure, TFloatByteProcedure, TFloatDoubleProcedure, TFloatFloatProcedure, TFloatIntProcedure, TFloatLongProcedure, TFloatObjectProcedure, TFloatProcedure, TIntByteProcedure, TIntDoubleProcedure, TIntFloatProcedure, TIntIntProcedure, TIntLongProcedure, TIntObjectProcedure, TIntProcedure, TByteByteProcedure, TByteDoubleProcedure, TByteFloatProcedure, TByteIntProcedure, TByteLongProcedure, TByteObjectProcedure, TByteProcedure, TLongByteProcedure, TLongDoubleProcedure, TLongFloatProcedure, TLongIntProcedure, TLongLongProcedure, TLongObjectProcedure, TLongProcedure, TObjectByteProcedure, TObjectDoubleProcedure, TObjectFloatProcedure, TObjectIntProcedure, TObjectLongProcedure, TObjectObjectProcedure, TObjectProcedure {
+    private final ObjectOutputStream a;
+    IOException b;
+
+    SerializationProcedure(ObjectOutputStream objectOutputStream) {
+        this.a = objectOutputStream;
+    }
+
+    @Override // gnu.trove.TIntProcedure
+    public boolean a(int i) {
+        try {
+            this.a.writeInt(i);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectProcedure
+    public boolean execute(Object obj) {
+        try {
+            this.a.writeObject(obj);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteProcedure
+    public boolean a(byte b) {
+        try {
+            this.a.writeByte(b);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleProcedure
+    public boolean a(double d) {
+        try {
+            this.a.writeDouble(d);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongProcedure
+    public boolean a(long j) {
+        try {
+            this.a.writeLong(j);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatProcedure
+    public boolean a(float f) {
+        try {
+            this.a.writeFloat(f);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectObjectProcedure
+    public boolean a(Object obj, Object obj2) {
+        try {
+            this.a.writeObject(obj);
+            this.a.writeObject(obj2);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectIntProcedure
+    public boolean a(Object obj, int i) {
+        try {
+            this.a.writeObject(obj);
+            this.a.writeInt(i);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectByteProcedure
+    public boolean a(Object obj, byte b) {
+        try {
+            this.a.writeObject(obj);
+            this.a.writeByte(b);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectLongProcedure
+    public boolean a(Object obj, long j) {
+        try {
+            this.a.writeObject(obj);
+            this.a.writeLong(j);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectDoubleProcedure
+    public boolean a(Object obj, double d) {
+        try {
+            this.a.writeObject(obj);
+            this.a.writeDouble(d);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TObjectFloatProcedure
+    public boolean a(Object obj, float f) {
+        try {
+            this.a.writeObject(obj);
+            this.a.writeFloat(f);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TIntObjectProcedure
+    public boolean a(int i, Object obj) {
+        try {
+            this.a.writeInt(i);
+            this.a.writeObject(obj);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TIntIntProcedure
+    public boolean a(int i, int i2) {
+        try {
+            this.a.writeInt(i);
+            this.a.writeInt(i2);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TIntLongProcedure
+    public boolean a(int i, long j) {
+        try {
+            this.a.writeInt(i);
+            this.a.writeLong(j);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TIntDoubleProcedure
+    public boolean a(int i, double d) {
+        try {
+            this.a.writeInt(i);
+            this.a.writeDouble(d);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TIntFloatProcedure
+    public boolean a(int i, float f) {
+        try {
+            this.a.writeInt(i);
+            this.a.writeFloat(f);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteByteProcedure
+    public boolean a(byte b, byte b2) {
+        try {
+            this.a.writeByte(b);
+            this.a.writeByte(b2);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteObjectProcedure
+    public boolean a(byte b, Object obj) {
+        try {
+            this.a.writeByte(b);
+            this.a.writeObject(obj);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteIntProcedure
+    public boolean a(byte b, int i) {
+        try {
+            this.a.writeByte(b);
+            this.a.writeInt(i);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteLongProcedure
+    public boolean a(byte b, long j) {
+        try {
+            this.a.writeByte(b);
+            this.a.writeLong(j);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteDoubleProcedure
+    public boolean a(byte b, double d) {
+        try {
+            this.a.writeByte(b);
+            this.a.writeDouble(d);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TByteFloatProcedure
+    public boolean a(byte b, float f) {
+        try {
+            this.a.writeByte(b);
+            this.a.writeFloat(f);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongObjectProcedure
+    public boolean a(long j, Object obj) {
+        try {
+            this.a.writeLong(j);
+            this.a.writeObject(obj);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongIntProcedure
+    public boolean a(long j, int i) {
+        try {
+            this.a.writeLong(j);
+            this.a.writeInt(i);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongLongProcedure
+    public boolean a(long j, long j2) {
+        try {
+            this.a.writeLong(j);
+            this.a.writeLong(j2);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongDoubleProcedure
+    public boolean a(long j, double d) {
+        try {
+            this.a.writeLong(j);
+            this.a.writeDouble(d);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongFloatProcedure
+    public boolean a(long j, float f) {
+        try {
+            this.a.writeLong(j);
+            this.a.writeFloat(f);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleObjectProcedure
+    public boolean a(double d, Object obj) {
+        try {
+            this.a.writeDouble(d);
+            this.a.writeObject(obj);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleIntProcedure
+    public boolean a(double d, int i) {
+        try {
+            this.a.writeDouble(d);
+            this.a.writeInt(i);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleLongProcedure
+    public boolean a(double d, long j) {
+        try {
+            this.a.writeDouble(d);
+            this.a.writeLong(j);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleDoubleProcedure
+    public boolean a(double d, double d2) {
+        try {
+            this.a.writeDouble(d);
+            this.a.writeDouble(d2);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleFloatProcedure
+    public boolean a(double d, float f) {
+        try {
+            this.a.writeDouble(d);
+            this.a.writeFloat(f);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatObjectProcedure
+    public boolean a(float f, Object obj) {
+        try {
+            this.a.writeFloat(f);
+            this.a.writeObject(obj);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatIntProcedure
+    public boolean a(float f, int i) {
+        try {
+            this.a.writeFloat(f);
+            this.a.writeInt(i);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatLongProcedure
+    public boolean a(float f, long j) {
+        try {
+            this.a.writeFloat(f);
+            this.a.writeLong(j);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatDoubleProcedure
+    public boolean a(float f, double d) {
+        try {
+            this.a.writeFloat(f);
+            this.a.writeDouble(d);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatFloatProcedure
+    public boolean a(float f, float f2) {
+        try {
+            this.a.writeFloat(f);
+            this.a.writeFloat(f2);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleByteProcedure
+    public boolean a(double d, byte b) {
+        try {
+            this.a.writeDouble(d);
+            this.a.writeByte(b);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TFloatByteProcedure
+    public boolean a(float f, byte b) {
+        try {
+            this.a.writeFloat(f);
+            this.a.writeByte(b);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TIntByteProcedure
+    public boolean a(int i, byte b) {
+        try {
+            this.a.writeInt(i);
+            this.a.writeByte(b);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+
+    @Override // gnu.trove.TLongByteProcedure
+    public boolean a(long j, byte b) {
+        try {
+            this.a.writeLong(j);
+            this.a.writeByte(b);
+            return true;
+        } catch (IOException e) {
+            this.b = e;
+            return false;
+        }
+    }
+}

sources/gnu/trove/TByteArrayList.java

@@ -0,0 +1,530 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Random;
+
+/* loaded from: classes2.dex */
+public class TByteArrayList implements Serializable, Cloneable {
+    protected static final int DEFAULT_CAPACITY = 4;
+    protected transient byte[] _data;
+    protected transient int _pos;
+
+    public TByteArrayList() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        this._data = new byte[readInt];
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readByte());
+            readInt = i;
+        }
+    }
+
+    private void swap(int i, int i2) {
+        byte[] bArr = this._data;
+        byte b = bArr[i];
+        bArr[i] = bArr[i2];
+        bArr[i2] = b;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(size());
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public void add(byte b) {
+        ensureCapacity(this._pos + 1);
+        byte[] bArr = this._data;
+        int i = this._pos;
+        this._pos = i + 1;
+        bArr[i] = b;
+    }
+
+    public int binarySearch(byte b) {
+        return binarySearch(b, 0, this._pos);
+    }
+
+    public void clear() {
+        this._data = null;
+        this._pos = 0;
+    }
+
+    public Object clone() {
+        byte[] bArr = null;
+        try {
+            TByteArrayList tByteArrayList = (TByteArrayList) super.clone();
+            try {
+                if (this._data != null) {
+                    bArr = (byte[]) this._data.clone();
+                }
+                tByteArrayList._data = bArr;
+                return tByteArrayList;
+            } catch (CloneNotSupportedException unused) {
+                return tByteArrayList;
+            }
+        } catch (CloneNotSupportedException unused2) {
+            return null;
+        }
+    }
+
+    public boolean contains(byte b) {
+        return lastIndexOf(b) >= 0;
+    }
+
+    public void ensureCapacity(int i) {
+        if (this._data == null) {
+            this._data = new byte[Math.max(4, i)];
+        }
+        byte[] bArr = this._data;
+        if (i > bArr.length) {
+            byte[] bArr2 = new byte[Math.max(bArr.length << 1, i)];
+            byte[] bArr3 = this._data;
+            System.arraycopy(bArr3, 0, bArr2, 0, bArr3.length);
+            this._data = bArr2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof TByteArrayList)) {
+            return false;
+        }
+        TByteArrayList tByteArrayList = (TByteArrayList) obj;
+        if (tByteArrayList.size() != size()) {
+            return false;
+        }
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (this._data[i2] != tByteArrayList._data[i2]) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public void fill(byte b) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, 0, this._pos, b);
+    }
+
+    public boolean forEach(TByteProcedure tByteProcedure) {
+        for (int i = 0; i < this._pos; i++) {
+            if (!tByteProcedure.a(this._data[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachDescending(TByteProcedure tByteProcedure) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (!tByteProcedure.a(this._data[i2])) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public byte get(int i) {
+        if (i < this._pos) {
+            return this._data[i];
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public byte getQuick(int i) {
+        return this._data[i];
+    }
+
+    public byte getSet(int i, byte b) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        byte[] bArr = this._data;
+        byte b2 = bArr[i];
+        bArr[i] = b;
+        return b2;
+    }
+
+    public TByteArrayList grep(TByteProcedure tByteProcedure) {
+        TByteArrayList tByteArrayList = new TByteArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (tByteProcedure.a(this._data[i])) {
+                tByteArrayList.add(this._data[i]);
+            }
+        }
+        return tByteArrayList;
+    }
+
+    public int hashCode() {
+        int i = this._pos;
+        int i2 = 0;
+        while (true) {
+            int i3 = i - 1;
+            if (i <= 0) {
+                return i2;
+            }
+            byte b = this._data[i3];
+            HashFunctions.a((int) b);
+            i2 += b;
+            i = i3;
+        }
+    }
+
+    public int indexOf(byte b) {
+        return indexOf(0, b);
+    }
+
+    public void insert(int i, byte b) {
+        int i2 = this._pos;
+        if (i == i2) {
+            add(b);
+            return;
+        }
+        ensureCapacity(i2 + 1);
+        byte[] bArr = this._data;
+        System.arraycopy(bArr, i, bArr, i + 1, this._pos - i);
+        this._data[i] = b;
+        this._pos++;
+    }
+
+    public TByteArrayList inverseGrep(TByteProcedure tByteProcedure) {
+        TByteArrayList tByteArrayList = new TByteArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (!tByteProcedure.a(this._data[i])) {
+                tByteArrayList.add(this._data[i]);
+            }
+        }
+        return tByteArrayList;
+    }
+
+    public boolean isEmpty() {
+        return this._pos == 0;
+    }
+
+    public int lastIndexOf(byte b) {
+        return lastIndexOf(this._pos, b);
+    }
+
+    public byte max() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find maximum of an empty list");
+        }
+        byte[] bArr = this._data;
+        int i = this._pos;
+        byte b = bArr[i - 1];
+        int i2 = i - 1;
+        while (true) {
+            int i3 = i2 - 1;
+            if (i2 <= 0) {
+                return b;
+            }
+            b = (byte) Math.max((int) b, (int) this._data[this._pos]);
+            i2 = i3;
+        }
+    }
+
+    public byte min() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find minimum of an empty list");
+        }
+        byte[] bArr = this._data;
+        int i = this._pos;
+        byte b = bArr[i - 1];
+        int i2 = i - 1;
+        while (true) {
+            int i3 = i2 - 1;
+            if (i2 <= 0) {
+                return b;
+            }
+            b = (byte) Math.min((int) b, (int) this._data[this._pos]);
+            i2 = i3;
+        }
+    }
+
+    public byte remove(int i) {
+        byte b = get(i);
+        remove(i, 1);
+        return b;
+    }
+
+    public void reset() {
+        fill((byte) 0);
+        this._pos = 0;
+    }
+
+    public void resetQuick() {
+        this._pos = 0;
+    }
+
+    public void reverse() {
+        reverse(0, this._pos);
+    }
+
+    public void set(int i, byte b) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        this._data[i] = b;
+    }
+
+    public void setQuick(int i, byte b) {
+        this._data[i] = b;
+    }
+
+    public void shuffle(Random random) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 1) {
+                return;
+            }
+            swap(i2, random.nextInt(i2));
+            i = i2;
+        }
+    }
+
+    public int size() {
+        return this._pos;
+    }
+
+    public void sort() {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, 0, this._pos);
+    }
+
+    public byte[] toNativeArray() {
+        return toNativeArray(0, this._pos);
+    }
+
+    public String toString() {
+        final StringBuffer stringBuffer = new StringBuffer("{");
+        forEach(new TByteProcedure(this) { // from class: gnu.trove.TByteArrayList.1
+            @Override // gnu.trove.TByteProcedure
+            public boolean a(byte b) {
+                stringBuffer.append((int) b);
+                stringBuffer.append(", ");
+                return true;
+            }
+        });
+        stringBuffer.append("}");
+        return stringBuffer.toString();
+    }
+
+    public void transformValues(TByteFunction tByteFunction) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return;
+            }
+            byte[] bArr = this._data;
+            bArr[i2] = tByteFunction.a(bArr[i2]);
+            i = i2;
+        }
+    }
+
+    public void trimToSize() {
+        byte[] bArr = this._data;
+        if (bArr == null || bArr.length <= size()) {
+            return;
+        }
+        byte[] bArr2 = new byte[size()];
+        toNativeArray(bArr2, 0, bArr2.length);
+        this._data = bArr2;
+    }
+
+    public TByteArrayList(int i) {
+        this._data = new byte[i];
+        this._pos = 0;
+    }
+
+    public int binarySearch(byte b, int i, int i2) {
+        if (i < 0) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        if (i2 > this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i2);
+        }
+        int i3 = i2 - 1;
+        while (i <= i3) {
+            int i4 = (i + i3) >> 1;
+            byte b2 = this._data[i4];
+            if (b2 < b) {
+                i = i4 + 1;
+            } else {
+                if (b2 <= b) {
+                    return i4;
+                }
+                i3 = i4 - 1;
+            }
+        }
+        return -(i + 1);
+    }
+
+    public void fill(int i, int i2, byte b) {
+        if (i2 > this._pos) {
+            ensureCapacity(i2);
+            this._pos = i2;
+        }
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, i, i2, b);
+    }
+
+    public int indexOf(int i, byte b) {
+        while (i < this._pos) {
+            if (this._data[i] == b) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public int lastIndexOf(int i, byte b) {
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return -1;
+            }
+            if (this._data[i2] == b) {
+                return i2;
+            }
+            i = i2;
+        }
+    }
+
+    public void reverse(int i, int i2) {
+        if (i == i2) {
+            return;
+        }
+        if (i > i2) {
+            throw new IllegalArgumentException("from cannot be greater than to");
+        }
+        for (int i3 = i2 - 1; i < i3; i3--) {
+            swap(i, i3);
+            i++;
+        }
+    }
+
+    public void sort(int i, int i2) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, i, i2);
+    }
+
+    public byte[] toNativeArray(int i, int i2) {
+        byte[] bArr = new byte[i2];
+        toNativeArray(bArr, i, i2);
+        return bArr;
+    }
+
+    public void add(byte[] bArr) {
+        add(bArr, 0, bArr.length);
+    }
+
+    public void clear(int i) {
+        this._data = new byte[i];
+        this._pos = 0;
+    }
+
+    public void remove(int i, int i2) {
+        int i3;
+        if (i >= 0 && i < (i3 = this._pos)) {
+            if (i == 0) {
+                byte[] bArr = this._data;
+                System.arraycopy(bArr, i2, bArr, 0, i3 - i2);
+            } else if (i3 - i2 != i) {
+                byte[] bArr2 = this._data;
+                int i4 = i + i2;
+                System.arraycopy(bArr2, i4, bArr2, i, i3 - i4);
+            }
+            this._pos -= i2;
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void add(byte[] bArr, int i, int i2) {
+        ensureCapacity(this._pos + i2);
+        System.arraycopy(bArr, i, this._data, this._pos, i2);
+        this._pos += i2;
+    }
+
+    public void set(int i, byte[] bArr) {
+        set(i, bArr, 0, bArr.length);
+    }
+
+    public void toNativeArray(byte[] bArr, int i, int i2) {
+        if (i2 == 0) {
+            return;
+        }
+        if (i >= 0 && i < this._pos) {
+            System.arraycopy(this._data, i, bArr, 0, i2);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public TByteArrayList(byte[] bArr) {
+        this(Math.max(bArr.length, 4));
+        add(bArr);
+    }
+
+    public void set(int i, byte[] bArr, int i2, int i3) {
+        if (i >= 0 && i + i3 <= this._pos) {
+            System.arraycopy(this._data, i, bArr, i2, i3);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void insert(int i, byte[] bArr) {
+        insert(i, bArr, 0, bArr.length);
+    }
+
+    public void insert(int i, byte[] bArr, int i2, int i3) {
+        int i4 = this._pos;
+        if (i == i4) {
+            add(bArr, i2, i3);
+            return;
+        }
+        ensureCapacity(i4 + i3);
+        byte[] bArr2 = this._data;
+        System.arraycopy(bArr2, i, bArr2, i + i3, this._pos - i);
+        System.arraycopy(bArr, i2, this._data, i, i3);
+        this._pos += i3;
+    }
+}

sources/gnu/trove/TByteByteHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TByteByteHashMap extends TByteHash {
+    protected transient byte[] _values;
+
+    private static final class EqProcedure implements TByteByteProcedure {
+        private final TByteByteHashMap a;
+
+        EqProcedure(TByteByteHashMap tByteByteHashMap) {
+            this.a = tByteByteHashMap;
+        }
+
+        private static boolean b(byte b, byte b2) {
+            return b == b2;
+        }
+
+        @Override // gnu.trove.TByteByteProcedure
+        public final boolean a(byte b, byte b2) {
+            return this.a.index(b) >= 0 && b(b2, this.a.get(b));
+        }
+    }
+
+    private final class HashProcedure implements TByteByteProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteByteProcedure
+        public final boolean a(byte b, byte b2) {
+            int i = this.a;
+            int computeHashCode = TByteByteHashMap.this._hashingStrategy.computeHashCode(b);
+            HashFunctions.a((int) b2);
+            this.a = i + (computeHashCode ^ b2);
+            return true;
+        }
+    }
+
+    public TByteByteHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readByte(), objectInputStream.readByte());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(byte b, byte b2) {
+        int index = index(b);
+        if (index < 0) {
+            return false;
+        }
+        byte[] bArr = this._values;
+        bArr[index] = (byte) (bArr[index] + b2);
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        byte[] bArr2 = this._values;
+        if (bArr2 == null) {
+            return;
+        }
+        byte[] bArr3 = this._states;
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            bArr2[i] = 0;
+            bArr3[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteByteHashMap tByteByteHashMap = (TByteByteHashMap) super.clone();
+        byte[] bArr = this._values;
+        tByteByteHashMap._values = bArr == null ? null : (byte[]) bArr.clone();
+        return tByteByteHashMap;
+    }
+
+    public boolean containsKey(byte b) {
+        return contains(b);
+    }
+
+    public boolean containsValue(byte b) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && b == bArr2[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteByteHashMap)) {
+            return false;
+        }
+        TByteByteHashMap tByteByteHashMap = (TByteByteHashMap) obj;
+        if (tByteByteHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tByteByteHashMap));
+    }
+
+    public boolean forEachEntry(TByteByteProcedure tByteByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteByteProcedure.a(bArr2[i], bArr3[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TByteProcedure tByteProcedure) {
+        return forEach(tByteProcedure);
+    }
+
+    public boolean forEachValue(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteProcedure.a(bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public byte get(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        return this._values[index];
+    }
+
+    public byte[] getValues() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._values;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(byte b) {
+        return adjustValue(b, (byte) 1);
+    }
+
+    public TByteByteIterator iterator() {
+        return new TByteByteIterator(this);
+    }
+
+    public byte[] keys() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public byte put(byte b, byte b2) {
+        boolean z;
+        byte b3;
+        int insertionIndex = insertionIndex(b);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            b3 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            b3 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b4 = bArr[insertionIndex];
+        this._set[insertionIndex] = b;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = b2;
+        if (z) {
+            postInsertHook(b4 == 0);
+        }
+        return b3;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        byte[] bArr2 = this._values;
+        byte[] bArr3 = this._states;
+        this._set = new byte[i];
+        this._values = new byte[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr3[i2] == 1) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._values[insertionIndex] = bArr2[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public byte remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        byte b2 = this._values[index];
+        removeAt(index);
+        return b2;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TByteByteProcedure tByteByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tByteByteProcedure.a(bArr2[i], bArr3[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TByteByteProcedure(this) { // from class: gnu.trove.TByteByteHashMap.1
+            @Override // gnu.trove.TByteByteProcedure
+            public boolean a(byte b, byte b2) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                sb.append('=');
+                sb.append((int) b2);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TByteFunction tByteFunction) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                bArr2[i] = tByteFunction.a(bArr2[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TByteByteHashMap(int i) {
+        super(i);
+    }
+
+    public TByteByteHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TByteByteHashMap(TByteHashingStrategy tByteHashingStrategy) {
+        super(tByteHashingStrategy);
+    }
+
+    public TByteByteHashMap(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, tByteHashingStrategy);
+    }
+
+    public TByteByteHashMap(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f, tByteHashingStrategy);
+    }
+}

sources/gnu/trove/TByteByteIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TByteByteIterator extends TPrimitiveIterator {
+    public TByteByteIterator(TByteByteHashMap tByteByteHashMap) {
+        super(tByteByteHashMap);
+    }
+}

sources/gnu/trove/TByteByteProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteByteProcedure {
+    boolean a(byte b, byte b2);
+}

sources/gnu/trove/TByteDoubleHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TByteDoubleHashMap extends TByteHash {
+    protected transient double[] _values;
+
+    private static final class EqProcedure implements TByteDoubleProcedure {
+        private final TByteDoubleHashMap a;
+
+        EqProcedure(TByteDoubleHashMap tByteDoubleHashMap) {
+            this.a = tByteDoubleHashMap;
+        }
+
+        private static boolean a(double d, double d2) {
+            return d == d2;
+        }
+
+        @Override // gnu.trove.TByteDoubleProcedure
+        public final boolean a(byte b, double d) {
+            return this.a.index(b) >= 0 && a(d, this.a.get(b));
+        }
+    }
+
+    private final class HashProcedure implements TByteDoubleProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteDoubleProcedure
+        public final boolean a(byte b, double d) {
+            this.a += TByteDoubleHashMap.this._hashingStrategy.computeHashCode(b) ^ HashFunctions.a(d);
+            return true;
+        }
+    }
+
+    public TByteDoubleHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readByte(), objectInputStream.readDouble());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(byte b, double d) {
+        int index = index(b);
+        if (index < 0) {
+            return false;
+        }
+        double[] dArr = this._values;
+        dArr[index] = dArr[index] + d;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        double[] dArr = this._values;
+        if (dArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            dArr[i] = 0.0d;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteDoubleHashMap tByteDoubleHashMap = (TByteDoubleHashMap) super.clone();
+        double[] dArr = this._values;
+        tByteDoubleHashMap._values = dArr == null ? null : (double[]) dArr.clone();
+        return tByteDoubleHashMap;
+    }
+
+    public boolean containsKey(byte b) {
+        return contains(b);
+    }
+
+    public boolean containsValue(double d) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && d == dArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteDoubleHashMap)) {
+            return false;
+        }
+        TByteDoubleHashMap tByteDoubleHashMap = (TByteDoubleHashMap) obj;
+        if (tByteDoubleHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tByteDoubleHashMap));
+    }
+
+    public boolean forEachEntry(TByteDoubleProcedure tByteDoubleProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteDoubleProcedure.a(bArr2[i], dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TByteProcedure tByteProcedure) {
+        return forEach(tByteProcedure);
+    }
+
+    public boolean forEachValue(TDoubleProcedure tDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleProcedure.a(dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public double get(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0.0d;
+        }
+        return this._values[index];
+    }
+
+    public double[] getValues() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(byte b) {
+        return adjustValue(b, 1.0d);
+    }
+
+    public TByteDoubleIterator iterator() {
+        return new TByteDoubleIterator(this);
+    }
+
+    public byte[] keys() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public double put(byte b, double d) {
+        double d2;
+        boolean z;
+        int insertionIndex = insertionIndex(b);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            d2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            d2 = 0.0d;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b2 = bArr[insertionIndex];
+        this._set[insertionIndex] = b;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = d;
+        if (z) {
+            postInsertHook(b2 == 0);
+        }
+        return d2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        double[] dArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new byte[i];
+        this._values = new double[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._values[insertionIndex] = dArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public double remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0.0d;
+        }
+        double d = this._values[index];
+        removeAt(index);
+        return d;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0d;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TByteDoubleProcedure tByteDoubleProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        double[] dArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tByteDoubleProcedure.a(bArr2[i], dArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new double[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TByteDoubleProcedure(this) { // from class: gnu.trove.TByteDoubleHashMap.1
+            @Override // gnu.trove.TByteDoubleProcedure
+            public boolean a(byte b, double d) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                sb.append('=');
+                sb.append(d);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TDoubleFunction tDoubleFunction) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                dArr[i] = tDoubleFunction.a(dArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TByteDoubleHashMap(int i) {
+        super(i);
+    }
+
+    public TByteDoubleHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TByteDoubleHashMap(TByteHashingStrategy tByteHashingStrategy) {
+        super(tByteHashingStrategy);
+    }
+
+    public TByteDoubleHashMap(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, tByteHashingStrategy);
+    }
+
+    public TByteDoubleHashMap(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f, tByteHashingStrategy);
+    }
+}

sources/gnu/trove/TByteDoubleIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TByteDoubleIterator extends TPrimitiveIterator {
+    public TByteDoubleIterator(TByteDoubleHashMap tByteDoubleHashMap) {
+        super(tByteDoubleHashMap);
+    }
+}

sources/gnu/trove/TByteDoubleProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteDoubleProcedure {
+    boolean a(byte b, double d);
+}

sources/gnu/trove/TByteFloatHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TByteFloatHashMap extends TByteHash {
+    protected transient float[] _values;
+
+    private static final class EqProcedure implements TByteFloatProcedure {
+        private final TByteFloatHashMap a;
+
+        EqProcedure(TByteFloatHashMap tByteFloatHashMap) {
+            this.a = tByteFloatHashMap;
+        }
+
+        private static boolean a(float f, float f2) {
+            return f == f2;
+        }
+
+        @Override // gnu.trove.TByteFloatProcedure
+        public final boolean a(byte b, float f) {
+            return this.a.index(b) >= 0 && a(f, this.a.get(b));
+        }
+    }
+
+    private final class HashProcedure implements TByteFloatProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteFloatProcedure
+        public final boolean a(byte b, float f) {
+            this.a += TByteFloatHashMap.this._hashingStrategy.computeHashCode(b) ^ HashFunctions.a(f);
+            return true;
+        }
+    }
+
+    public TByteFloatHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readByte(), objectInputStream.readFloat());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(byte b, float f) {
+        int index = index(b);
+        if (index < 0) {
+            return false;
+        }
+        float[] fArr = this._values;
+        fArr[index] = fArr[index] + f;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        float[] fArr = this._values;
+        if (fArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            fArr[i] = 0.0f;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteFloatHashMap tByteFloatHashMap = (TByteFloatHashMap) super.clone();
+        float[] fArr = this._values;
+        tByteFloatHashMap._values = fArr == null ? null : (float[]) fArr.clone();
+        return tByteFloatHashMap;
+    }
+
+    public boolean containsKey(byte b) {
+        return contains(b);
+    }
+
+    public boolean containsValue(float f) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && f == fArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteFloatHashMap)) {
+            return false;
+        }
+        TByteFloatHashMap tByteFloatHashMap = (TByteFloatHashMap) obj;
+        if (tByteFloatHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tByteFloatHashMap));
+    }
+
+    public boolean forEachEntry(TByteFloatProcedure tByteFloatProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteFloatProcedure.a(bArr2[i], fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TByteProcedure tByteProcedure) {
+        return forEach(tByteProcedure);
+    }
+
+    public boolean forEachValue(TFloatProcedure tFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatProcedure.a(fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public float get(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0.0f;
+        }
+        return this._values[index];
+    }
+
+    public float[] getValues() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(byte b) {
+        return adjustValue(b, 1.0f);
+    }
+
+    public TByteFloatIterator iterator() {
+        return new TByteFloatIterator(this);
+    }
+
+    public byte[] keys() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public float put(byte b, float f) {
+        boolean z;
+        float f2;
+        int insertionIndex = insertionIndex(b);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            f2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            f2 = 0.0f;
+        }
+        byte[] bArr = this._states;
+        byte b2 = bArr[insertionIndex];
+        this._set[insertionIndex] = b;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = f;
+        if (z) {
+            postInsertHook(b2 == 0);
+        }
+        return f2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        float[] fArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new byte[i];
+        this._values = new float[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._values[insertionIndex] = fArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public float remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0.0f;
+        }
+        float f = this._values[index];
+        removeAt(index);
+        return f;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0f;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TByteFloatProcedure tByteFloatProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        float[] fArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tByteFloatProcedure.a(bArr2[i], fArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new float[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TByteFloatProcedure(this) { // from class: gnu.trove.TByteFloatHashMap.1
+            @Override // gnu.trove.TByteFloatProcedure
+            public boolean a(byte b, float f) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                sb.append('=');
+                sb.append(f);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TFloatFunction tFloatFunction) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                fArr[i] = tFloatFunction.a(fArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TByteFloatHashMap(int i) {
+        super(i);
+    }
+
+    public TByteFloatHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TByteFloatHashMap(TByteHashingStrategy tByteHashingStrategy) {
+        super(tByteHashingStrategy);
+    }
+
+    public TByteFloatHashMap(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, tByteHashingStrategy);
+    }
+
+    public TByteFloatHashMap(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f, tByteHashingStrategy);
+    }
+}

sources/gnu/trove/TByteFloatIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TByteFloatIterator extends TPrimitiveIterator {
+    public TByteFloatIterator(TByteFloatHashMap tByteFloatHashMap) {
+        super(tByteFloatHashMap);
+    }
+}

sources/gnu/trove/TByteFloatProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteFloatProcedure {
+    boolean a(byte b, float f);
+}

sources/gnu/trove/TByteFunction.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteFunction {
+    byte a(byte b);
+}

sources/gnu/trove/TByteHash.java

@@ -0,0 +1,150 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public abstract class TByteHash extends TPrimitiveHash implements TByteHashingStrategy {
+    protected final TByteHashingStrategy _hashingStrategy;
+    protected transient byte[] _set;
+
+    public TByteHash() {
+        this._hashingStrategy = this;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteHash tByteHash = (TByteHash) super.clone();
+        byte[] bArr = this._set;
+        tByteHash._set = bArr == null ? null : (byte[]) bArr.clone();
+        return tByteHash;
+    }
+
+    @Override // gnu.trove.TByteHashingStrategy
+    public final int computeHashCode(byte b) {
+        HashFunctions.a((int) b);
+        return b;
+    }
+
+    public boolean contains(byte b) {
+        return index(b) >= 0;
+    }
+
+    public boolean forEach(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteProcedure.a(bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    protected int index(byte b) {
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return -1;
+        }
+        byte[] bArr2 = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(b) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] != 0 && (bArr[i] == 2 || bArr2[i] != b)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (bArr[i] == 0 || (bArr[i] != 2 && bArr2[i] == b)) {
+                    break;
+                }
+            }
+        }
+        if (bArr[i] == 0) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(byte b) {
+        if (this._set == null) {
+            setUp(6);
+        }
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(b) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] == 0) {
+            return i;
+        }
+        if (bArr[i] == 1 && bArr2[i] == b) {
+            return (-i) - 1;
+        }
+        int i2 = (computeHashCode % (length - 2)) + 1;
+        do {
+            i -= i2;
+            if (i < 0) {
+                i += length;
+            }
+            if (bArr[i] != 1) {
+                break;
+            }
+        } while (bArr2[i] != b);
+        if (bArr[i] != 2) {
+            return bArr[i] == 1 ? (-i) - 1 : i;
+        }
+        int i3 = i;
+        while (bArr[i3] != 0 && (bArr[i3] == 2 || bArr2[i3] != b)) {
+            i3 -= i2;
+            if (i3 < 0) {
+                i3 += length;
+            }
+        }
+        return bArr[i3] == 1 ? (-i3) - 1 : i;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._set[i] = 0;
+        super.removeAt(i);
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._set = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public TByteHash(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TByteHash(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TByteHash(TByteHashingStrategy tByteHashingStrategy) {
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+
+    public TByteHash(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+
+    public TByteHash(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+}

sources/gnu/trove/TByteHashSet.java

@@ -0,0 +1,282 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public class TByteHashSet extends TByteHash {
+
+    private final class HashProcedure implements TByteProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteProcedure
+        public final boolean a(byte b) {
+            this.a += TByteHashSet.this._hashingStrategy.computeHashCode(b);
+            return true;
+        }
+    }
+
+    public TByteHashSet() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readByte());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean add(byte b) {
+        int insertionIndex = insertionIndex(b);
+        if (insertionIndex < 0) {
+            return false;
+        }
+        byte[] bArr = this._states;
+        byte b2 = bArr[insertionIndex];
+        this._set[insertionIndex] = b;
+        bArr[insertionIndex] = 1;
+        postInsertHook(b2 == 0);
+        return true;
+    }
+
+    public boolean addAll(byte[] bArr) {
+        int length = bArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (add(bArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        byte[] bArr2 = this._states;
+        if (bArr2 == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    public boolean containsAll(byte[] bArr) {
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (!contains(bArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteHashSet)) {
+            return false;
+        }
+        final TByteHashSet tByteHashSet = (TByteHashSet) obj;
+        if (tByteHashSet.size() != size()) {
+            return false;
+        }
+        return forEach(new TByteProcedure(this) { // from class: gnu.trove.TByteHashSet.1
+            @Override // gnu.trove.TByteProcedure
+            public final boolean a(byte b) {
+                return tByteHashSet.contains(b);
+            }
+        });
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEach(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public TByteIterator iterator() {
+        return new TByteIterator(this);
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        byte[] bArr2 = this._states;
+        this._set = new byte[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public boolean remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return false;
+        }
+        removeAt(index);
+        return true;
+    }
+
+    public boolean removeAll(byte[] bArr) {
+        int length = bArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (remove(bArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean retainAll(byte[] bArr) {
+        Arrays.sort(bArr);
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        boolean z = false;
+        if (bArr2 != null) {
+            int length = bArr2.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i] != 1 || Arrays.binarySearch(bArr, bArr2[i]) >= 0) {
+                    length = i;
+                } else {
+                    remove(bArr2[i]);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    public byte[] toArray() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEach(new TByteProcedure(this) { // from class: gnu.trove.TByteHashSet.2
+            @Override // gnu.trove.TByteProcedure
+            public boolean a(byte b) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                return true;
+            }
+        });
+        sb.append(']');
+        sb.insert(0, '[');
+        return sb.toString();
+    }
+
+    public TByteHashSet(int i) {
+        super(i);
+    }
+
+    public TByteHashSet(int i, float f) {
+        super(i, f);
+    }
+
+    public TByteHashSet(byte[] bArr) {
+        this(bArr.length);
+        addAll(bArr);
+    }
+
+    public TByteHashSet(TByteHashingStrategy tByteHashingStrategy) {
+        super(tByteHashingStrategy);
+    }
+
+    public TByteHashSet(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, tByteHashingStrategy);
+    }
+
+    public TByteHashSet(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f, tByteHashingStrategy);
+    }
+
+    public TByteHashSet(byte[] bArr, TByteHashingStrategy tByteHashingStrategy) {
+        this(bArr.length, tByteHashingStrategy);
+        addAll(bArr);
+    }
+}

sources/gnu/trove/TByteHashingStrategy.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+import java.io.Serializable;
+
+/* loaded from: classes2.dex */
+public interface TByteHashingStrategy extends Serializable {
+    int computeHashCode(byte b);
+}

sources/gnu/trove/TByteIntHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TByteIntHashMap extends TByteHash {
+    protected transient int[] _values;
+
+    private static final class EqProcedure implements TByteIntProcedure {
+        private final TByteIntHashMap a;
+
+        EqProcedure(TByteIntHashMap tByteIntHashMap) {
+            this.a = tByteIntHashMap;
+        }
+
+        private static boolean a(int i, int i2) {
+            return i == i2;
+        }
+
+        @Override // gnu.trove.TByteIntProcedure
+        public final boolean a(byte b, int i) {
+            return this.a.index(b) >= 0 && a(i, this.a.get(b));
+        }
+    }
+
+    private final class HashProcedure implements TByteIntProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteIntProcedure
+        public final boolean a(byte b, int i) {
+            int i2 = this.a;
+            int computeHashCode = TByteIntHashMap.this._hashingStrategy.computeHashCode(b);
+            HashFunctions.a(i);
+            this.a = i2 + (computeHashCode ^ i);
+            return true;
+        }
+    }
+
+    public TByteIntHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readByte(), objectInputStream.readInt());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(byte b, int i) {
+        int index = index(b);
+        if (index < 0) {
+            return false;
+        }
+        int[] iArr = this._values;
+        iArr[index] = iArr[index] + i;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        int[] iArr = this._values;
+        if (iArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            iArr[i] = 0;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteIntHashMap tByteIntHashMap = (TByteIntHashMap) super.clone();
+        int[] iArr = this._values;
+        tByteIntHashMap._values = iArr == null ? null : (int[]) iArr.clone();
+        return tByteIntHashMap;
+    }
+
+    public boolean containsKey(byte b) {
+        return contains(b);
+    }
+
+    public boolean containsValue(int i) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i2] == 1 && i == iArr[i2]) {
+                return true;
+            }
+            length = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteIntHashMap)) {
+            return false;
+        }
+        TByteIntHashMap tByteIntHashMap = (TByteIntHashMap) obj;
+        if (tByteIntHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tByteIntHashMap));
+    }
+
+    public boolean forEachEntry(TByteIntProcedure tByteIntProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteIntProcedure.a(bArr2[i], iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TByteProcedure tByteProcedure) {
+        return forEach(tByteProcedure);
+    }
+
+    public boolean forEachValue(TIntProcedure tIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntProcedure.a(iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public int get(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0;
+        }
+        return this._values[index];
+    }
+
+    public int[] getValues() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(byte b) {
+        return adjustValue(b, 1);
+    }
+
+    public TByteIntIterator iterator() {
+        return new TByteIntIterator(this);
+    }
+
+    public byte[] keys() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public int put(byte b, int i) {
+        boolean z;
+        int i2;
+        int insertionIndex = insertionIndex(b);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            i2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            i2 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b2 = bArr[insertionIndex];
+        this._set[insertionIndex] = b;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = i;
+        if (z) {
+            postInsertHook(b2 == 0);
+        }
+        return i2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        int[] iArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new byte[i];
+        this._values = new int[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._values[insertionIndex] = iArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public int remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0;
+        }
+        int i = this._values[index];
+        removeAt(index);
+        return i;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TByteIntProcedure tByteIntProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        int[] iArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tByteIntProcedure.a(bArr2[i], iArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new int[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TByteIntProcedure(this) { // from class: gnu.trove.TByteIntHashMap.1
+            @Override // gnu.trove.TByteIntProcedure
+            public boolean a(byte b, int i) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                sb.append('=');
+                sb.append(i);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TIntFunction tIntFunction) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                iArr[i] = tIntFunction.a(iArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TByteIntHashMap(int i) {
+        super(i);
+    }
+
+    public TByteIntHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TByteIntHashMap(TByteHashingStrategy tByteHashingStrategy) {
+        super(tByteHashingStrategy);
+    }
+
+    public TByteIntHashMap(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, tByteHashingStrategy);
+    }
+
+    public TByteIntHashMap(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f, tByteHashingStrategy);
+    }
+}

sources/gnu/trove/TByteIntIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TByteIntIterator extends TPrimitiveIterator {
+    public TByteIntIterator(TByteIntHashMap tByteIntHashMap) {
+        super(tByteIntHashMap);
+    }
+}

sources/gnu/trove/TByteIntProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteIntProcedure {
+    boolean a(byte b, int i);
+}

sources/gnu/trove/TByteIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TByteIterator extends TPrimitiveIterator {
+    public TByteIterator(TByteHash tByteHash) {
+        super(tByteHash);
+    }
+}

sources/gnu/trove/TByteLongHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TByteLongHashMap extends TByteHash {
+    protected transient long[] _values;
+
+    private static final class EqProcedure implements TByteLongProcedure {
+        private final TByteLongHashMap a;
+
+        EqProcedure(TByteLongHashMap tByteLongHashMap) {
+            this.a = tByteLongHashMap;
+        }
+
+        private static boolean a(long j, long j2) {
+            return j == j2;
+        }
+
+        @Override // gnu.trove.TByteLongProcedure
+        public final boolean a(byte b, long j) {
+            return this.a.index(b) >= 0 && a(j, this.a.get(b));
+        }
+    }
+
+    private final class HashProcedure implements TByteLongProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteLongProcedure
+        public final boolean a(byte b, long j) {
+            this.a += TByteLongHashMap.this._hashingStrategy.computeHashCode(b) ^ HashFunctions.a(j);
+            return true;
+        }
+    }
+
+    public TByteLongHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readByte(), objectInputStream.readLong());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(byte b, long j) {
+        int index = index(b);
+        if (index < 0) {
+            return false;
+        }
+        long[] jArr = this._values;
+        jArr[index] = jArr[index] + j;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        long[] jArr = this._values;
+        if (jArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            jArr[i] = 0;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TByteLongHashMap tByteLongHashMap = (TByteLongHashMap) super.clone();
+        long[] jArr = this._values;
+        tByteLongHashMap._values = jArr == null ? null : (long[]) jArr.clone();
+        return tByteLongHashMap;
+    }
+
+    public boolean containsKey(byte b) {
+        return contains(b);
+    }
+
+    public boolean containsValue(long j) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && j == jArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteLongHashMap)) {
+            return false;
+        }
+        TByteLongHashMap tByteLongHashMap = (TByteLongHashMap) obj;
+        if (tByteLongHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tByteLongHashMap));
+    }
+
+    public boolean forEachEntry(TByteLongProcedure tByteLongProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        long[] jArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteLongProcedure.a(bArr2[i], jArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TByteProcedure tByteProcedure) {
+        return forEach(tByteProcedure);
+    }
+
+    public boolean forEachValue(TLongProcedure tLongProcedure) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tLongProcedure.a(jArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public long get(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0L;
+        }
+        return this._values[index];
+    }
+
+    public long[] getValues() {
+        long[] jArr = new long[size()];
+        long[] jArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    jArr[i] = jArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return jArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(byte b) {
+        return adjustValue(b, 1L);
+    }
+
+    public TByteLongIterator iterator() {
+        return new TByteLongIterator(this);
+    }
+
+    public byte[] keys() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public long put(byte b, long j) {
+        long j2;
+        boolean z;
+        int insertionIndex = insertionIndex(b);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            j2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            j2 = 0;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b2 = bArr[insertionIndex];
+        this._set[insertionIndex] = b;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = j;
+        if (z) {
+            postInsertHook(b2 == 0);
+        }
+        return j2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        long[] jArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new byte[i];
+        this._values = new long[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._values[insertionIndex] = jArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public long remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return 0L;
+        }
+        long j = this._values[index];
+        removeAt(index);
+        return j;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TByteLongProcedure tByteLongProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._set;
+        long[] jArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tByteLongProcedure.a(bArr2[i], jArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TByteHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new long[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TByteLongProcedure(this) { // from class: gnu.trove.TByteLongHashMap.1
+            @Override // gnu.trove.TByteLongProcedure
+            public boolean a(byte b, long j) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                sb.append('=');
+                sb.append(j);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TLongFunction tLongFunction) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                jArr[i] = tLongFunction.a(jArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TByteLongHashMap(int i) {
+        super(i);
+    }
+
+    public TByteLongHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TByteLongHashMap(TByteHashingStrategy tByteHashingStrategy) {
+        super(tByteHashingStrategy);
+    }
+
+    public TByteLongHashMap(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, tByteHashingStrategy);
+    }
+
+    public TByteLongHashMap(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f, tByteHashingStrategy);
+    }
+}

sources/gnu/trove/TByteLongIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TByteLongIterator extends TPrimitiveIterator {
+    public TByteLongIterator(TByteLongHashMap tByteLongHashMap) {
+        super(tByteLongHashMap);
+    }
+}

sources/gnu/trove/TByteLongProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteLongProcedure {
+    boolean a(byte b, long j);
+}

sources/gnu/trove/TByteObjectHashMap.java

@@ -0,0 +1,521 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TByteObjectHashMap<V> extends THash implements TByteHashingStrategy {
+    protected final TByteHashingStrategy _hashingStrategy;
+    protected transient byte[] _set;
+    protected transient V[] _values;
+
+    private final class HashProcedure implements TByteObjectProcedure<V> {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TByteObjectProcedure
+        public final boolean a(byte b, V v) {
+            this.a += TByteObjectHashMap.this._hashingStrategy.computeHashCode(b) ^ HashFunctions.a(v);
+            return true;
+        }
+    }
+
+    public TByteObjectHashMap() {
+        this._hashingStrategy = this;
+    }
+
+    private static boolean isFree(Object[] objArr, int i) {
+        return objArr[i] == null;
+    }
+
+    static boolean isFull(Object[] objArr, int i) {
+        Object obj = objArr[i];
+        return (obj == null || obj == TObjectHash.REMOVED) ? false : true;
+    }
+
+    private static boolean isRemoved(Object[] objArr, int i) {
+        return objArr[i] == TObjectHash.REMOVED;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readByte(), objectInputStream.readObject());
+            readInt = i;
+        }
+    }
+
+    private static <V> V unwrapNull(V v) {
+        if (v == TObjectHash.NULL) {
+            return null;
+        }
+        return v;
+    }
+
+    private static <V> V wrapNull(V v) {
+        return v == null ? (V) TObjectHash.NULL : v;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected int capacity() {
+        return this._values.length;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        byte[] bArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            bArr[i] = 0;
+            vArr[i] = null;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TByteHashingStrategy
+    public final int computeHashCode(byte b) {
+        HashFunctions.a((int) b);
+        return b;
+    }
+
+    public boolean contains(byte b) {
+        return index(b) >= 0;
+    }
+
+    public boolean containsKey(byte b) {
+        return contains(b);
+    }
+
+    public boolean containsValue(V v) {
+        V[] vArr = this._values;
+        if (v != null) {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return false;
+                }
+                Object unwrapNull = unwrapNull(vArr[i]);
+                if (!isFull(vArr, i) || (v != unwrapNull && !v.equals(unwrapNull))) {
+                    length = i;
+                }
+            }
+            return true;
+        }
+        int length2 = vArr.length;
+        while (true) {
+            int i2 = length2 - 1;
+            if (length2 <= 0) {
+                return false;
+            }
+            if (TObjectHash.NULL == vArr[i2]) {
+                return true;
+            }
+            length2 = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TByteObjectHashMap)) {
+            return false;
+        }
+        TByteObjectHashMap tByteObjectHashMap = (TByteObjectHashMap) obj;
+        if (tByteObjectHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tByteObjectHashMap));
+    }
+
+    public boolean forEach(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tByteProcedure.a(bArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachEntry(TByteObjectProcedure<V> tByteObjectProcedure) {
+        byte[] bArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tByteObjectProcedure.a(bArr[i], unwrapNull(vArr[i]))) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean forEachKey(TByteProcedure tByteProcedure) {
+        return forEach(tByteProcedure);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachValue(TObjectProcedure<V> tObjectProcedure) {
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tObjectProcedure.execute(unwrapNull(vArr[i]))) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public V get(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return null;
+        }
+        return (V) unwrapNull(this._values[index]);
+    }
+
+    public Object[] getValues() {
+        Object[] objArr = new Object[size()];
+        V[] vArr = this._values;
+        int length = vArr.length;
+        int i = 0;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return objArr;
+            }
+            if (isFull(vArr, i2)) {
+                objArr[i] = unwrapNull(vArr[i2]);
+                i++;
+            }
+            length = i2;
+        }
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    protected int index(byte b) {
+        byte[] bArr = this._set;
+        V[] vArr = this._values;
+        if (vArr == THash.EMPTY_OBJECT_ARRAY) {
+            return -1;
+        }
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(b) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (!isFree(vArr, i) && (isRemoved(vArr, i) || bArr[i] != b)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (isFree(vArr, i) || (!isRemoved(vArr, i) && bArr[i] == b)) {
+                    break;
+                }
+            }
+        }
+        if (isFree(vArr, i)) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(byte b) {
+        if (this._values == THash.EMPTY_OBJECT_ARRAY) {
+            setUp(6);
+        }
+        V[] vArr = this._values;
+        byte[] bArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(b) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (isFree(vArr, i)) {
+            return i;
+        }
+        if (!isFull(vArr, i) || bArr[i] != b) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            int i3 = isRemoved(vArr, i) ? i : -1;
+            do {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (i3 == -1 && isRemoved(vArr, i)) {
+                    i3 = i;
+                }
+                if (!isFull(vArr, i)) {
+                    break;
+                }
+            } while (bArr[i] != b);
+            if (isRemoved(vArr, i)) {
+                while (!isFree(vArr, i) && (isRemoved(vArr, i) || bArr[i] != b)) {
+                    i -= i2;
+                    if (i < 0) {
+                        i += length;
+                    }
+                }
+            }
+            if (!isFull(vArr, i)) {
+                return i3 == -1 ? i : i3;
+            }
+        }
+        return (-i) - 1;
+    }
+
+    public TByteObjectIterator<V> iterator() {
+        return new TByteObjectIterator<>(this);
+    }
+
+    public byte[] keys() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        int i = 0;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return bArr;
+            }
+            if (isFull(vArr, i2)) {
+                bArr[i] = bArr2[i2];
+                i++;
+            }
+            length = i2;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public V put(byte b, V v) {
+        V v2;
+        int insertionIndex = insertionIndex(b);
+        boolean z = true;
+        boolean z2 = false;
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            v2 = unwrapNull(this._values[insertionIndex]);
+            z = false;
+        } else {
+            z2 = isFree(this._values, insertionIndex);
+            v2 = null;
+        }
+        this._set[insertionIndex] = b;
+        ((V[]) this._values)[insertionIndex] = wrapNull(v);
+        if (z) {
+            postInsertHook(z2);
+        }
+        return v2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        byte[] bArr = this._set;
+        V[] vArr = this._values;
+        this._set = new byte[i];
+        this._values = (V[]) new Object[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (isFull(vArr, i2)) {
+                byte b = bArr[i2];
+                int insertionIndex = insertionIndex(b);
+                this._set[insertionIndex] = b;
+                this._values[insertionIndex] = vArr[i2];
+            }
+            capacity = i2;
+        }
+    }
+
+    public V remove(byte b) {
+        int index = index(b);
+        if (index < 0) {
+            return null;
+        }
+        V v = (V) unwrapNull(this._values[index]);
+        removeAt(index);
+        return v;
+    }
+
+    @Override // gnu.trove.THash
+    protected void removeAt(int i) {
+        ((V[]) this._values)[i] = TObjectHash.REMOVED;
+        super.removeAt(i);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean retainEntries(TByteObjectProcedure<V> tByteObjectProcedure) {
+        byte[] bArr = this._set;
+        V[] vArr = this._values;
+        stopCompactingOnRemove();
+        boolean z = false;
+        try {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return z;
+                }
+                if (isFull(vArr, i) && !tByteObjectProcedure.a(bArr[i], unwrapNull(vArr[i]))) {
+                    removeAt(i);
+                    z = true;
+                }
+                length = i;
+            }
+        } finally {
+            startCompactingOnRemove(z);
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? (V[]) THash.EMPTY_OBJECT_ARRAY : (V[]) new Object[up];
+        this._set = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TByteObjectProcedure<V>(this) { // from class: gnu.trove.TByteObjectHashMap.1
+            @Override // gnu.trove.TByteObjectProcedure
+            public boolean a(byte b, V v) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append((int) b);
+                sb.append('=');
+                StringBuilder sb3 = sb;
+                if (v == this) {
+                    v = (V) "(this Map)";
+                }
+                sb3.append(v);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public void transformValues(TObjectFunction<V, V> tObjectFunction) {
+        Object[] objArr = this._values;
+        int length = objArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (isFull(objArr, i)) {
+                objArr[i] = wrapNull(tObjectFunction.execute(unwrapNull(objArr[i])));
+            }
+            length = i;
+        }
+    }
+
+    private static final class EqProcedure<V> implements TByteObjectProcedure<V> {
+        private final TByteObjectHashMap<V> a;
+
+        EqProcedure(TByteObjectHashMap<V> tByteObjectHashMap) {
+            this.a = tByteObjectHashMap;
+        }
+
+        @Override // gnu.trove.TByteObjectProcedure
+        public final boolean a(byte b, V v) {
+            return this.a.index(b) >= 0 && a(v, this.a.get(b));
+        }
+
+        private static boolean a(Object obj, Object obj2) {
+            return obj == obj2 || (obj != null && obj.equals(obj2));
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public TByteObjectHashMap<V> clone() {
+        TByteObjectHashMap<V> tByteObjectHashMap = (TByteObjectHashMap) super.clone();
+        V[] vArr = this._values;
+        V[] vArr2 = (V[]) THash.EMPTY_OBJECT_ARRAY;
+        if (vArr != vArr2) {
+            vArr2 = (V[]) ((Object[]) vArr.clone());
+        }
+        tByteObjectHashMap._values = vArr2;
+        tByteObjectHashMap._set = this._values == THash.EMPTY_OBJECT_ARRAY ? null : (byte[]) this._set.clone();
+        return tByteObjectHashMap;
+    }
+
+    public TByteObjectHashMap(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TByteObjectHashMap(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TByteObjectHashMap(TByteHashingStrategy tByteHashingStrategy) {
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+
+    public TByteObjectHashMap(int i, TByteHashingStrategy tByteHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+
+    public TByteObjectHashMap(int i, float f, TByteHashingStrategy tByteHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tByteHashingStrategy;
+    }
+}

sources/gnu/trove/TByteObjectIterator.java

@@ -0,0 +1,31 @@
+package gnu.trove;
+
+import java.util.ConcurrentModificationException;
+
+/* loaded from: classes2.dex */
+public class TByteObjectIterator<V> extends TIterator {
+    private final TByteObjectHashMap<V> d;
+
+    public TByteObjectIterator(TByteObjectHashMap<V> tByteObjectHashMap) {
+        super(tByteObjectHashMap);
+        this.d = tByteObjectHashMap;
+    }
+
+    @Override // gnu.trove.TIterator
+    protected final int nextIndex() {
+        int i;
+        if (this.b != this.d.size()) {
+            throw new ConcurrentModificationException();
+        }
+        V[] vArr = this.d._values;
+        int i2 = this.c;
+        while (true) {
+            i = i2 - 1;
+            if (i2 <= 0 || TByteObjectHashMap.isFull(vArr, i)) {
+                break;
+            }
+            i2 = i;
+        }
+        return i;
+    }
+}

sources/gnu/trove/TByteObjectProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteObjectProcedure<V> {
+    boolean a(byte b, V v);
+}

sources/gnu/trove/TByteProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TByteProcedure {
+    boolean a(byte b);
+}

sources/gnu/trove/TDoubleArrayList.java

@@ -0,0 +1,528 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Random;
+
+/* loaded from: classes2.dex */
+public class TDoubleArrayList implements Serializable, Cloneable {
+    protected static final int DEFAULT_CAPACITY = 4;
+    protected transient double[] _data;
+    protected transient int _pos;
+
+    public TDoubleArrayList() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        this._data = new double[readInt];
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readDouble());
+            readInt = i;
+        }
+    }
+
+    private void swap(int i, int i2) {
+        double[] dArr = this._data;
+        double d = dArr[i];
+        dArr[i] = dArr[i2];
+        dArr[i2] = d;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(size());
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public void add(double d) {
+        ensureCapacity(this._pos + 1);
+        double[] dArr = this._data;
+        int i = this._pos;
+        this._pos = i + 1;
+        dArr[i] = d;
+    }
+
+    public int binarySearch(double d) {
+        return binarySearch(d, 0, this._pos);
+    }
+
+    public void clear() {
+        this._data = null;
+        this._pos = 0;
+    }
+
+    public Object clone() {
+        double[] dArr = null;
+        try {
+            TDoubleArrayList tDoubleArrayList = (TDoubleArrayList) super.clone();
+            try {
+                if (this._data != null) {
+                    dArr = (double[]) this._data.clone();
+                }
+                tDoubleArrayList._data = dArr;
+                return tDoubleArrayList;
+            } catch (CloneNotSupportedException unused) {
+                return tDoubleArrayList;
+            }
+        } catch (CloneNotSupportedException unused2) {
+            return null;
+        }
+    }
+
+    public boolean contains(double d) {
+        return lastIndexOf(d) >= 0;
+    }
+
+    public void ensureCapacity(int i) {
+        if (this._data == null) {
+            this._data = new double[Math.max(4, i)];
+        }
+        double[] dArr = this._data;
+        if (i > dArr.length) {
+            double[] dArr2 = new double[Math.max(dArr.length << 1, i)];
+            double[] dArr3 = this._data;
+            System.arraycopy(dArr3, 0, dArr2, 0, dArr3.length);
+            this._data = dArr2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof TDoubleArrayList)) {
+            return false;
+        }
+        TDoubleArrayList tDoubleArrayList = (TDoubleArrayList) obj;
+        if (tDoubleArrayList.size() != size()) {
+            return false;
+        }
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (this._data[i2] != tDoubleArrayList._data[i2]) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public void fill(double d) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, 0, this._pos, d);
+    }
+
+    public boolean forEach(TDoubleProcedure tDoubleProcedure) {
+        for (int i = 0; i < this._pos; i++) {
+            if (!tDoubleProcedure.a(this._data[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachDescending(TDoubleProcedure tDoubleProcedure) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (!tDoubleProcedure.a(this._data[i2])) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public double get(int i) {
+        if (i < this._pos) {
+            return this._data[i];
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public double getQuick(int i) {
+        return this._data[i];
+    }
+
+    public double getSet(int i, double d) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        double[] dArr = this._data;
+        double d2 = dArr[i];
+        dArr[i] = d;
+        return d2;
+    }
+
+    public TDoubleArrayList grep(TDoubleProcedure tDoubleProcedure) {
+        TDoubleArrayList tDoubleArrayList = new TDoubleArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (tDoubleProcedure.a(this._data[i])) {
+                tDoubleArrayList.add(this._data[i]);
+            }
+        }
+        return tDoubleArrayList;
+    }
+
+    public int hashCode() {
+        int i = this._pos;
+        int i2 = 0;
+        while (true) {
+            int i3 = i - 1;
+            if (i <= 0) {
+                return i2;
+            }
+            i2 += HashFunctions.a(this._data[i3]);
+            i = i3;
+        }
+    }
+
+    public int indexOf(double d) {
+        return indexOf(0, d);
+    }
+
+    public void insert(int i, double d) {
+        int i2 = this._pos;
+        if (i == i2) {
+            add(d);
+            return;
+        }
+        ensureCapacity(i2 + 1);
+        double[] dArr = this._data;
+        System.arraycopy(dArr, i, dArr, i + 1, this._pos - i);
+        this._data[i] = d;
+        this._pos++;
+    }
+
+    public TDoubleArrayList inverseGrep(TDoubleProcedure tDoubleProcedure) {
+        TDoubleArrayList tDoubleArrayList = new TDoubleArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (!tDoubleProcedure.a(this._data[i])) {
+                tDoubleArrayList.add(this._data[i]);
+            }
+        }
+        return tDoubleArrayList;
+    }
+
+    public boolean isEmpty() {
+        return this._pos == 0;
+    }
+
+    public int lastIndexOf(double d) {
+        return lastIndexOf(this._pos, d);
+    }
+
+    public double max() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find maximum of an empty list");
+        }
+        double[] dArr = this._data;
+        int i = this._pos;
+        double d = dArr[i - 1];
+        int i2 = i - 1;
+        while (true) {
+            int i3 = i2 - 1;
+            if (i2 <= 0) {
+                return d;
+            }
+            d = Math.max(d, this._data[this._pos]);
+            i2 = i3;
+        }
+    }
+
+    public double min() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find minimum of an empty list");
+        }
+        double[] dArr = this._data;
+        int i = this._pos;
+        double d = dArr[i - 1];
+        int i2 = i - 1;
+        while (true) {
+            int i3 = i2 - 1;
+            if (i2 <= 0) {
+                return d;
+            }
+            d = Math.min(d, this._data[this._pos]);
+            i2 = i3;
+        }
+    }
+
+    public double remove(int i) {
+        double d = get(i);
+        remove(i, 1);
+        return d;
+    }
+
+    public void reset() {
+        fill(0.0d);
+        this._pos = 0;
+    }
+
+    public void resetQuick() {
+        this._pos = 0;
+    }
+
+    public void reverse() {
+        reverse(0, this._pos);
+    }
+
+    public void set(int i, double d) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        this._data[i] = d;
+    }
+
+    public void setQuick(int i, double d) {
+        this._data[i] = d;
+    }
+
+    public void shuffle(Random random) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 1) {
+                return;
+            }
+            swap(i2, random.nextInt(i2));
+            i = i2;
+        }
+    }
+
+    public int size() {
+        return this._pos;
+    }
+
+    public void sort() {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, 0, this._pos);
+    }
+
+    public double[] toNativeArray() {
+        return toNativeArray(0, this._pos);
+    }
+
+    public String toString() {
+        final StringBuffer stringBuffer = new StringBuffer("{");
+        forEach(new TDoubleProcedure(this) { // from class: gnu.trove.TDoubleArrayList.1
+            @Override // gnu.trove.TDoubleProcedure
+            public boolean a(double d) {
+                stringBuffer.append(d);
+                stringBuffer.append(", ");
+                return true;
+            }
+        });
+        stringBuffer.append("}");
+        return stringBuffer.toString();
+    }
+
+    public void transformValues(TDoubleFunction tDoubleFunction) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return;
+            }
+            double[] dArr = this._data;
+            dArr[i2] = tDoubleFunction.a(dArr[i2]);
+            i = i2;
+        }
+    }
+
+    public void trimToSize() {
+        double[] dArr = this._data;
+        if (dArr == null || dArr.length <= size()) {
+            return;
+        }
+        double[] dArr2 = new double[size()];
+        toNativeArray(dArr2, 0, dArr2.length);
+        this._data = dArr2;
+    }
+
+    public TDoubleArrayList(int i) {
+        this._data = new double[i];
+        this._pos = 0;
+    }
+
+    public int binarySearch(double d, int i, int i2) {
+        if (i < 0) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        if (i2 > this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i2);
+        }
+        int i3 = i2 - 1;
+        while (i <= i3) {
+            int i4 = (i + i3) >> 1;
+            double d2 = this._data[i4];
+            if (d2 < d) {
+                i = i4 + 1;
+            } else {
+                if (d2 <= d) {
+                    return i4;
+                }
+                i3 = i4 - 1;
+            }
+        }
+        return -(i + 1);
+    }
+
+    public void fill(int i, int i2, double d) {
+        if (i2 > this._pos) {
+            ensureCapacity(i2);
+            this._pos = i2;
+        }
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, i, i2, d);
+    }
+
+    public int indexOf(int i, double d) {
+        while (i < this._pos) {
+            if (this._data[i] == d) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public int lastIndexOf(int i, double d) {
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return -1;
+            }
+            if (this._data[i2] == d) {
+                return i2;
+            }
+            i = i2;
+        }
+    }
+
+    public void reverse(int i, int i2) {
+        if (i == i2) {
+            return;
+        }
+        if (i > i2) {
+            throw new IllegalArgumentException("from cannot be greater than to");
+        }
+        for (int i3 = i2 - 1; i < i3; i3--) {
+            swap(i, i3);
+            i++;
+        }
+    }
+
+    public void sort(int i, int i2) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, i, i2);
+    }
+
+    public double[] toNativeArray(int i, int i2) {
+        double[] dArr = new double[i2];
+        toNativeArray(dArr, i, i2);
+        return dArr;
+    }
+
+    public void add(double[] dArr) {
+        add(dArr, 0, dArr.length);
+    }
+
+    public void clear(int i) {
+        this._data = new double[i];
+        this._pos = 0;
+    }
+
+    public void remove(int i, int i2) {
+        int i3;
+        if (i >= 0 && i < (i3 = this._pos)) {
+            if (i == 0) {
+                double[] dArr = this._data;
+                System.arraycopy(dArr, i2, dArr, 0, i3 - i2);
+            } else if (i3 - i2 != i) {
+                double[] dArr2 = this._data;
+                int i4 = i + i2;
+                System.arraycopy(dArr2, i4, dArr2, i, i3 - i4);
+            }
+            this._pos -= i2;
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void add(double[] dArr, int i, int i2) {
+        ensureCapacity(this._pos + i2);
+        System.arraycopy(dArr, i, this._data, this._pos, i2);
+        this._pos += i2;
+    }
+
+    public void set(int i, double[] dArr) {
+        set(i, dArr, 0, dArr.length);
+    }
+
+    public void toNativeArray(double[] dArr, int i, int i2) {
+        if (i2 == 0) {
+            return;
+        }
+        if (i >= 0 && i < this._pos) {
+            System.arraycopy(this._data, i, dArr, 0, i2);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public TDoubleArrayList(double[] dArr) {
+        this(Math.max(dArr.length, 4));
+        add(dArr);
+    }
+
+    public void set(int i, double[] dArr, int i2, int i3) {
+        if (i >= 0 && i + i3 <= this._pos) {
+            System.arraycopy(this._data, i, dArr, i2, i3);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void insert(int i, double[] dArr) {
+        insert(i, dArr, 0, dArr.length);
+    }
+
+    public void insert(int i, double[] dArr, int i2, int i3) {
+        int i4 = this._pos;
+        if (i == i4) {
+            add(dArr, i2, i3);
+            return;
+        }
+        ensureCapacity(i4 + i3);
+        double[] dArr2 = this._data;
+        System.arraycopy(dArr2, i, dArr2, i + i3, this._pos - i);
+        System.arraycopy(dArr, i2, this._data, i, i3);
+        this._pos += i3;
+    }
+}

sources/gnu/trove/TDoubleByteHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TDoubleByteHashMap extends TDoubleHash {
+    protected transient byte[] _values;
+
+    private static final class EqProcedure implements TDoubleByteProcedure {
+        private final TDoubleByteHashMap a;
+
+        EqProcedure(TDoubleByteHashMap tDoubleByteHashMap) {
+            this.a = tDoubleByteHashMap;
+        }
+
+        private static boolean a(byte b, byte b2) {
+            return b == b2;
+        }
+
+        @Override // gnu.trove.TDoubleByteProcedure
+        public final boolean a(double d, byte b) {
+            return this.a.index(d) >= 0 && a(b, this.a.get(d));
+        }
+    }
+
+    private final class HashProcedure implements TDoubleByteProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleByteProcedure
+        public final boolean a(double d, byte b) {
+            int i = this.a;
+            int computeHashCode = TDoubleByteHashMap.this._hashingStrategy.computeHashCode(d);
+            HashFunctions.a((int) b);
+            this.a = i + (computeHashCode ^ b);
+            return true;
+        }
+    }
+
+    public TDoubleByteHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readDouble(), objectInputStream.readByte());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(double d, byte b) {
+        int index = index(d);
+        if (index < 0) {
+            return false;
+        }
+        byte[] bArr = this._values;
+        bArr[index] = (byte) (bArr[index] + b);
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        byte[] bArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            bArr[i] = 0;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TDoubleByteHashMap tDoubleByteHashMap = (TDoubleByteHashMap) super.clone();
+        byte[] bArr = this._values;
+        tDoubleByteHashMap._values = bArr == null ? null : (byte[]) bArr.clone();
+        return tDoubleByteHashMap;
+    }
+
+    public boolean containsKey(double d) {
+        return contains(d);
+    }
+
+    public boolean containsValue(byte b) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && b == bArr2[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleByteHashMap)) {
+            return false;
+        }
+        TDoubleByteHashMap tDoubleByteHashMap = (TDoubleByteHashMap) obj;
+        if (tDoubleByteHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tDoubleByteHashMap));
+    }
+
+    public boolean forEachEntry(TDoubleByteProcedure tDoubleByteProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleByteProcedure.a(dArr[i], bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TDoubleProcedure tDoubleProcedure) {
+        return forEach(tDoubleProcedure);
+    }
+
+    public boolean forEachValue(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteProcedure.a(bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public byte get(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        return this._values[index];
+    }
+
+    public byte[] getValues() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._values;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(double d) {
+        return adjustValue(d, (byte) 1);
+    }
+
+    public TDoubleByteIterator iterator() {
+        return new TDoubleByteIterator(this);
+    }
+
+    public double[] keys() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public byte put(double d, byte b) {
+        boolean z;
+        byte b2;
+        int insertionIndex = insertionIndex(d);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            b2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            b2 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b3 = bArr[insertionIndex];
+        this._set[insertionIndex] = d;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = b;
+        if (z) {
+            postInsertHook(b3 == 0);
+        }
+        return b2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        byte[] bArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new double[i];
+        this._values = new byte[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._values[insertionIndex] = bArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public byte remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        byte b = this._values[index];
+        removeAt(index);
+        return b;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TDoubleByteProcedure tDoubleByteProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        byte[] bArr2 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tDoubleByteProcedure.a(dArr[i], bArr2[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TDoubleByteProcedure(this) { // from class: gnu.trove.TDoubleByteHashMap.1
+            @Override // gnu.trove.TDoubleByteProcedure
+            public boolean a(double d, byte b) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                sb.append('=');
+                sb.append((int) b);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TByteFunction tByteFunction) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                bArr2[i] = tByteFunction.a(bArr2[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TDoubleByteHashMap(int i) {
+        super(i);
+    }
+
+    public TDoubleByteHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TDoubleByteHashMap(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(tDoubleHashingStrategy);
+    }
+
+    public TDoubleByteHashMap(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, tDoubleHashingStrategy);
+    }
+
+    public TDoubleByteHashMap(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f, tDoubleHashingStrategy);
+    }
+}

sources/gnu/trove/TDoubleByteIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TDoubleByteIterator extends TPrimitiveIterator {
+    public TDoubleByteIterator(TDoubleByteHashMap tDoubleByteHashMap) {
+        super(tDoubleByteHashMap);
+    }
+}

sources/gnu/trove/TDoubleByteProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleByteProcedure {
+    boolean a(double d, byte b);
+}

sources/gnu/trove/TDoubleDoubleHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TDoubleDoubleHashMap extends TDoubleHash {
+    protected transient double[] _values;
+
+    private static final class EqProcedure implements TDoubleDoubleProcedure {
+        private final TDoubleDoubleHashMap a;
+
+        EqProcedure(TDoubleDoubleHashMap tDoubleDoubleHashMap) {
+            this.a = tDoubleDoubleHashMap;
+        }
+
+        private static boolean b(double d, double d2) {
+            return d == d2;
+        }
+
+        @Override // gnu.trove.TDoubleDoubleProcedure
+        public final boolean a(double d, double d2) {
+            return this.a.index(d) >= 0 && b(d2, this.a.get(d));
+        }
+    }
+
+    private final class HashProcedure implements TDoubleDoubleProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleDoubleProcedure
+        public final boolean a(double d, double d2) {
+            this.a += TDoubleDoubleHashMap.this._hashingStrategy.computeHashCode(d) ^ HashFunctions.a(d2);
+            return true;
+        }
+    }
+
+    public TDoubleDoubleHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readDouble(), objectInputStream.readDouble());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(double d, double d2) {
+        int index = index(d);
+        if (index < 0) {
+            return false;
+        }
+        double[] dArr = this._values;
+        dArr[index] = dArr[index] + d2;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        double[] dArr2 = this._values;
+        if (dArr2 == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            dArr2[i] = 0.0d;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TDoubleDoubleHashMap tDoubleDoubleHashMap = (TDoubleDoubleHashMap) super.clone();
+        double[] dArr = this._values;
+        tDoubleDoubleHashMap._values = dArr == null ? null : (double[]) dArr.clone();
+        return tDoubleDoubleHashMap;
+    }
+
+    public boolean containsKey(double d) {
+        return contains(d);
+    }
+
+    public boolean containsValue(double d) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && d == dArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleDoubleHashMap)) {
+            return false;
+        }
+        TDoubleDoubleHashMap tDoubleDoubleHashMap = (TDoubleDoubleHashMap) obj;
+        if (tDoubleDoubleHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tDoubleDoubleHashMap));
+    }
+
+    public boolean forEachEntry(TDoubleDoubleProcedure tDoubleDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        double[] dArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleDoubleProcedure.a(dArr[i], dArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TDoubleProcedure tDoubleProcedure) {
+        return forEach(tDoubleProcedure);
+    }
+
+    public boolean forEachValue(TDoubleProcedure tDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleProcedure.a(dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public double get(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0.0d;
+        }
+        return this._values[index];
+    }
+
+    public double[] getValues() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(double d) {
+        return adjustValue(d, 1.0d);
+    }
+
+    public TDoubleDoubleIterator iterator() {
+        return new TDoubleDoubleIterator(this);
+    }
+
+    public double[] keys() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public double put(double d, double d2) {
+        double d3;
+        boolean z;
+        int insertionIndex = insertionIndex(d);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            d3 = this._values[insertionIndex];
+            z = false;
+        } else {
+            d3 = 0.0d;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = d;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = d2;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return d3;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        double[] dArr2 = this._values;
+        byte[] bArr = this._states;
+        this._set = new double[i];
+        this._values = new double[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._values[insertionIndex] = dArr2[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public double remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0.0d;
+        }
+        double d2 = this._values[index];
+        removeAt(index);
+        return d2;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0d;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TDoubleDoubleProcedure tDoubleDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        double[] dArr2 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tDoubleDoubleProcedure.a(dArr[i], dArr2[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new double[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TDoubleDoubleProcedure(this) { // from class: gnu.trove.TDoubleDoubleHashMap.1
+            @Override // gnu.trove.TDoubleDoubleProcedure
+            public boolean a(double d, double d2) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                sb.append('=');
+                sb.append(d2);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TDoubleFunction tDoubleFunction) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                dArr[i] = tDoubleFunction.a(dArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TDoubleDoubleHashMap(int i) {
+        super(i);
+    }
+
+    public TDoubleDoubleHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TDoubleDoubleHashMap(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(tDoubleHashingStrategy);
+    }
+
+    public TDoubleDoubleHashMap(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, tDoubleHashingStrategy);
+    }
+
+    public TDoubleDoubleHashMap(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f, tDoubleHashingStrategy);
+    }
+}

sources/gnu/trove/TDoubleDoubleIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TDoubleDoubleIterator extends TPrimitiveIterator {
+    public TDoubleDoubleIterator(TDoubleDoubleHashMap tDoubleDoubleHashMap) {
+        super(tDoubleDoubleHashMap);
+    }
+}

sources/gnu/trove/TDoubleDoubleProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleDoubleProcedure {
+    boolean a(double d, double d2);
+}

sources/gnu/trove/TDoubleFloatHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TDoubleFloatHashMap extends TDoubleHash {
+    protected transient float[] _values;
+
+    private static final class EqProcedure implements TDoubleFloatProcedure {
+        private final TDoubleFloatHashMap a;
+
+        EqProcedure(TDoubleFloatHashMap tDoubleFloatHashMap) {
+            this.a = tDoubleFloatHashMap;
+        }
+
+        private static boolean a(float f, float f2) {
+            return f == f2;
+        }
+
+        @Override // gnu.trove.TDoubleFloatProcedure
+        public final boolean a(double d, float f) {
+            return this.a.index(d) >= 0 && a(f, this.a.get(d));
+        }
+    }
+
+    private final class HashProcedure implements TDoubleFloatProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleFloatProcedure
+        public final boolean a(double d, float f) {
+            this.a += TDoubleFloatHashMap.this._hashingStrategy.computeHashCode(d) ^ HashFunctions.a(f);
+            return true;
+        }
+    }
+
+    public TDoubleFloatHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readDouble(), objectInputStream.readFloat());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(double d, float f) {
+        int index = index(d);
+        if (index < 0) {
+            return false;
+        }
+        float[] fArr = this._values;
+        fArr[index] = fArr[index] + f;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        float[] fArr = this._values;
+        if (fArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            fArr[i] = 0.0f;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TDoubleFloatHashMap tDoubleFloatHashMap = (TDoubleFloatHashMap) super.clone();
+        float[] fArr = this._values;
+        tDoubleFloatHashMap._values = fArr == null ? null : (float[]) fArr.clone();
+        return tDoubleFloatHashMap;
+    }
+
+    public boolean containsKey(double d) {
+        return contains(d);
+    }
+
+    public boolean containsValue(float f) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && f == fArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleFloatHashMap)) {
+            return false;
+        }
+        TDoubleFloatHashMap tDoubleFloatHashMap = (TDoubleFloatHashMap) obj;
+        if (tDoubleFloatHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tDoubleFloatHashMap));
+    }
+
+    public boolean forEachEntry(TDoubleFloatProcedure tDoubleFloatProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleFloatProcedure.a(dArr[i], fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TDoubleProcedure tDoubleProcedure) {
+        return forEach(tDoubleProcedure);
+    }
+
+    public boolean forEachValue(TFloatProcedure tFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatProcedure.a(fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public float get(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0.0f;
+        }
+        return this._values[index];
+    }
+
+    public float[] getValues() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(double d) {
+        return adjustValue(d, 1.0f);
+    }
+
+    public TDoubleFloatIterator iterator() {
+        return new TDoubleFloatIterator(this);
+    }
+
+    public double[] keys() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public float put(double d, float f) {
+        boolean z;
+        float f2;
+        int insertionIndex = insertionIndex(d);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            f2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            f2 = 0.0f;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = d;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = f;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return f2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        float[] fArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new double[i];
+        this._values = new float[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._values[insertionIndex] = fArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public float remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0.0f;
+        }
+        float f = this._values[index];
+        removeAt(index);
+        return f;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0f;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TDoubleFloatProcedure tDoubleFloatProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        float[] fArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tDoubleFloatProcedure.a(dArr[i], fArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new float[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TDoubleFloatProcedure(this) { // from class: gnu.trove.TDoubleFloatHashMap.1
+            @Override // gnu.trove.TDoubleFloatProcedure
+            public boolean a(double d, float f) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                sb.append('=');
+                sb.append(f);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TFloatFunction tFloatFunction) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                fArr[i] = tFloatFunction.a(fArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TDoubleFloatHashMap(int i) {
+        super(i);
+    }
+
+    public TDoubleFloatHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TDoubleFloatHashMap(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(tDoubleHashingStrategy);
+    }
+
+    public TDoubleFloatHashMap(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, tDoubleHashingStrategy);
+    }
+
+    public TDoubleFloatHashMap(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f, tDoubleHashingStrategy);
+    }
+}

sources/gnu/trove/TDoubleFloatIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TDoubleFloatIterator extends TPrimitiveIterator {
+    public TDoubleFloatIterator(TDoubleFloatHashMap tDoubleFloatHashMap) {
+        super(tDoubleFloatHashMap);
+    }
+}

sources/gnu/trove/TDoubleFloatProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleFloatProcedure {
+    boolean a(double d, float f);
+}

sources/gnu/trove/TDoubleFunction.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleFunction {
+    double a(double d);
+}

sources/gnu/trove/TDoubleHash.java

@@ -0,0 +1,149 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public abstract class TDoubleHash extends TPrimitiveHash implements TDoubleHashingStrategy {
+    protected final TDoubleHashingStrategy _hashingStrategy;
+    protected transient double[] _set;
+
+    public TDoubleHash() {
+        this._hashingStrategy = this;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TDoubleHash tDoubleHash = (TDoubleHash) super.clone();
+        double[] dArr = this._set;
+        tDoubleHash._set = dArr == null ? null : (double[]) dArr.clone();
+        return tDoubleHash;
+    }
+
+    @Override // gnu.trove.TDoubleHashingStrategy
+    public final int computeHashCode(double d) {
+        return HashFunctions.a(d);
+    }
+
+    public boolean contains(double d) {
+        return index(d) >= 0;
+    }
+
+    public boolean forEach(TDoubleProcedure tDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleProcedure.a(dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    protected int index(double d) {
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return -1;
+        }
+        double[] dArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(d) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] != 0 && (bArr[i] == 2 || dArr[i] != d)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (bArr[i] == 0 || (bArr[i] != 2 && dArr[i] == d)) {
+                    break;
+                }
+            }
+        }
+        if (bArr[i] == 0) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(double d) {
+        if (this._set == null) {
+            setUp(6);
+        }
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(d) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] == 0) {
+            return i;
+        }
+        if (bArr[i] == 1 && dArr[i] == d) {
+            return (-i) - 1;
+        }
+        int i2 = (computeHashCode % (length - 2)) + 1;
+        do {
+            i -= i2;
+            if (i < 0) {
+                i += length;
+            }
+            if (bArr[i] != 1) {
+                break;
+            }
+        } while (dArr[i] != d);
+        if (bArr[i] != 2) {
+            return bArr[i] == 1 ? (-i) - 1 : i;
+        }
+        int i3 = i;
+        while (bArr[i3] != 0 && (bArr[i3] == 2 || dArr[i3] != d)) {
+            i3 -= i2;
+            if (i3 < 0) {
+                i3 += length;
+            }
+        }
+        return bArr[i3] == 1 ? (-i3) - 1 : i;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._set[i] = 0.0d;
+        super.removeAt(i);
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._set = i == -1 ? null : new double[up];
+        return up;
+    }
+
+    public TDoubleHash(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TDoubleHash(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TDoubleHash(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        this._hashingStrategy = tDoubleHashingStrategy;
+    }
+
+    public TDoubleHash(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tDoubleHashingStrategy;
+    }
+
+    public TDoubleHash(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tDoubleHashingStrategy;
+    }
+}

sources/gnu/trove/TDoubleHashSet.java

@@ -0,0 +1,282 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public class TDoubleHashSet extends TDoubleHash {
+
+    private final class HashProcedure implements TDoubleProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleProcedure
+        public final boolean a(double d) {
+            this.a += TDoubleHashSet.this._hashingStrategy.computeHashCode(d);
+            return true;
+        }
+    }
+
+    public TDoubleHashSet() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readDouble());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean add(double d) {
+        int insertionIndex = insertionIndex(d);
+        if (insertionIndex < 0) {
+            return false;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = d;
+        bArr[insertionIndex] = 1;
+        postInsertHook(b == 0);
+        return true;
+    }
+
+    public boolean addAll(double[] dArr) {
+        int length = dArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (add(dArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return;
+        }
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    public boolean containsAll(double[] dArr) {
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (!contains(dArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleHashSet)) {
+            return false;
+        }
+        final TDoubleHashSet tDoubleHashSet = (TDoubleHashSet) obj;
+        if (tDoubleHashSet.size() != size()) {
+            return false;
+        }
+        return forEach(new TDoubleProcedure(this) { // from class: gnu.trove.TDoubleHashSet.1
+            @Override // gnu.trove.TDoubleProcedure
+            public final boolean a(double d) {
+                return tDoubleHashSet.contains(d);
+            }
+        });
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEach(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public TDoubleIterator iterator() {
+        return new TDoubleIterator(this);
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        byte[] bArr = this._states;
+        this._set = new double[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public boolean remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return false;
+        }
+        removeAt(index);
+        return true;
+    }
+
+    public boolean removeAll(double[] dArr) {
+        int length = dArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (remove(dArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean retainAll(double[] dArr) {
+        Arrays.sort(dArr);
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        boolean z = false;
+        if (dArr2 != null) {
+            int length = dArr2.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || Arrays.binarySearch(dArr, dArr2[i]) >= 0) {
+                    length = i;
+                } else {
+                    remove(dArr2[i]);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    public double[] toArray() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEach(new TDoubleProcedure(this) { // from class: gnu.trove.TDoubleHashSet.2
+            @Override // gnu.trove.TDoubleProcedure
+            public boolean a(double d) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                return true;
+            }
+        });
+        sb.append(']');
+        sb.insert(0, '[');
+        return sb.toString();
+    }
+
+    public TDoubleHashSet(int i) {
+        super(i);
+    }
+
+    public TDoubleHashSet(int i, float f) {
+        super(i, f);
+    }
+
+    public TDoubleHashSet(double[] dArr) {
+        this(dArr.length);
+        addAll(dArr);
+    }
+
+    public TDoubleHashSet(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(tDoubleHashingStrategy);
+    }
+
+    public TDoubleHashSet(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, tDoubleHashingStrategy);
+    }
+
+    public TDoubleHashSet(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f, tDoubleHashingStrategy);
+    }
+
+    public TDoubleHashSet(double[] dArr, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        this(dArr.length, tDoubleHashingStrategy);
+        addAll(dArr);
+    }
+}

sources/gnu/trove/TDoubleHashingStrategy.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+import java.io.Serializable;
+
+/* loaded from: classes2.dex */
+public interface TDoubleHashingStrategy extends Serializable {
+    int computeHashCode(double d);
+}

sources/gnu/trove/TDoubleIntHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TDoubleIntHashMap extends TDoubleHash {
+    protected transient int[] _values;
+
+    private static final class EqProcedure implements TDoubleIntProcedure {
+        private final TDoubleIntHashMap a;
+
+        EqProcedure(TDoubleIntHashMap tDoubleIntHashMap) {
+            this.a = tDoubleIntHashMap;
+        }
+
+        private static boolean a(int i, int i2) {
+            return i == i2;
+        }
+
+        @Override // gnu.trove.TDoubleIntProcedure
+        public final boolean a(double d, int i) {
+            return this.a.index(d) >= 0 && a(i, this.a.get(d));
+        }
+    }
+
+    private final class HashProcedure implements TDoubleIntProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleIntProcedure
+        public final boolean a(double d, int i) {
+            int i2 = this.a;
+            int computeHashCode = TDoubleIntHashMap.this._hashingStrategy.computeHashCode(d);
+            HashFunctions.a(i);
+            this.a = i2 + (computeHashCode ^ i);
+            return true;
+        }
+    }
+
+    public TDoubleIntHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readDouble(), objectInputStream.readInt());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(double d, int i) {
+        int index = index(d);
+        if (index < 0) {
+            return false;
+        }
+        int[] iArr = this._values;
+        iArr[index] = iArr[index] + i;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        int[] iArr = this._values;
+        if (iArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            iArr[i] = 0;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TDoubleIntHashMap tDoubleIntHashMap = (TDoubleIntHashMap) super.clone();
+        int[] iArr = this._values;
+        tDoubleIntHashMap._values = iArr == null ? null : (int[]) iArr.clone();
+        return tDoubleIntHashMap;
+    }
+
+    public boolean containsKey(double d) {
+        return contains(d);
+    }
+
+    public boolean containsValue(int i) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i2] == 1 && i == iArr[i2]) {
+                return true;
+            }
+            length = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleIntHashMap)) {
+            return false;
+        }
+        TDoubleIntHashMap tDoubleIntHashMap = (TDoubleIntHashMap) obj;
+        if (tDoubleIntHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tDoubleIntHashMap));
+    }
+
+    public boolean forEachEntry(TDoubleIntProcedure tDoubleIntProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleIntProcedure.a(dArr[i], iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TDoubleProcedure tDoubleProcedure) {
+        return forEach(tDoubleProcedure);
+    }
+
+    public boolean forEachValue(TIntProcedure tIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntProcedure.a(iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public int get(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0;
+        }
+        return this._values[index];
+    }
+
+    public int[] getValues() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(double d) {
+        return adjustValue(d, 1);
+    }
+
+    public TDoubleIntIterator iterator() {
+        return new TDoubleIntIterator(this);
+    }
+
+    public double[] keys() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public int put(double d, int i) {
+        boolean z;
+        int i2;
+        int insertionIndex = insertionIndex(d);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            i2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            i2 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = d;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = i;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return i2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        int[] iArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new double[i];
+        this._values = new int[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._values[insertionIndex] = iArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public int remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0;
+        }
+        int i = this._values[index];
+        removeAt(index);
+        return i;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TDoubleIntProcedure tDoubleIntProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        int[] iArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tDoubleIntProcedure.a(dArr[i], iArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new int[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TDoubleIntProcedure(this) { // from class: gnu.trove.TDoubleIntHashMap.1
+            @Override // gnu.trove.TDoubleIntProcedure
+            public boolean a(double d, int i) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                sb.append('=');
+                sb.append(i);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TIntFunction tIntFunction) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                iArr[i] = tIntFunction.a(iArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TDoubleIntHashMap(int i) {
+        super(i);
+    }
+
+    public TDoubleIntHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TDoubleIntHashMap(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(tDoubleHashingStrategy);
+    }
+
+    public TDoubleIntHashMap(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, tDoubleHashingStrategy);
+    }
+
+    public TDoubleIntHashMap(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f, tDoubleHashingStrategy);
+    }
+}

sources/gnu/trove/TDoubleIntIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TDoubleIntIterator extends TPrimitiveIterator {
+    public TDoubleIntIterator(TDoubleIntHashMap tDoubleIntHashMap) {
+        super(tDoubleIntHashMap);
+    }
+}

sources/gnu/trove/TDoubleIntProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleIntProcedure {
+    boolean a(double d, int i);
+}

sources/gnu/trove/TDoubleIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TDoubleIterator extends TPrimitiveIterator {
+    public TDoubleIterator(TDoubleHash tDoubleHash) {
+        super(tDoubleHash);
+    }
+}

sources/gnu/trove/TDoubleLongHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TDoubleLongHashMap extends TDoubleHash {
+    protected transient long[] _values;
+
+    private static final class EqProcedure implements TDoubleLongProcedure {
+        private final TDoubleLongHashMap a;
+
+        EqProcedure(TDoubleLongHashMap tDoubleLongHashMap) {
+            this.a = tDoubleLongHashMap;
+        }
+
+        private static boolean a(long j, long j2) {
+            return j == j2;
+        }
+
+        @Override // gnu.trove.TDoubleLongProcedure
+        public final boolean a(double d, long j) {
+            return this.a.index(d) >= 0 && a(j, this.a.get(d));
+        }
+    }
+
+    private final class HashProcedure implements TDoubleLongProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleLongProcedure
+        public final boolean a(double d, long j) {
+            this.a += TDoubleLongHashMap.this._hashingStrategy.computeHashCode(d) ^ HashFunctions.a(j);
+            return true;
+        }
+    }
+
+    public TDoubleLongHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readDouble(), objectInputStream.readLong());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(double d, long j) {
+        int index = index(d);
+        if (index < 0) {
+            return false;
+        }
+        long[] jArr = this._values;
+        jArr[index] = jArr[index] + j;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        long[] jArr = this._values;
+        if (jArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = dArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            jArr[i] = 0;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TDoubleLongHashMap tDoubleLongHashMap = (TDoubleLongHashMap) super.clone();
+        long[] jArr = this._values;
+        tDoubleLongHashMap._values = jArr == null ? null : (long[]) jArr.clone();
+        return tDoubleLongHashMap;
+    }
+
+    public boolean containsKey(double d) {
+        return contains(d);
+    }
+
+    public boolean containsValue(long j) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && j == jArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleLongHashMap)) {
+            return false;
+        }
+        TDoubleLongHashMap tDoubleLongHashMap = (TDoubleLongHashMap) obj;
+        if (tDoubleLongHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tDoubleLongHashMap));
+    }
+
+    public boolean forEachEntry(TDoubleLongProcedure tDoubleLongProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        long[] jArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleLongProcedure.a(dArr[i], jArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TDoubleProcedure tDoubleProcedure) {
+        return forEach(tDoubleProcedure);
+    }
+
+    public boolean forEachValue(TLongProcedure tLongProcedure) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tLongProcedure.a(jArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public long get(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0L;
+        }
+        return this._values[index];
+    }
+
+    public long[] getValues() {
+        long[] jArr = new long[size()];
+        long[] jArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    jArr[i] = jArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return jArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(double d) {
+        return adjustValue(d, 1L);
+    }
+
+    public TDoubleLongIterator iterator() {
+        return new TDoubleLongIterator(this);
+    }
+
+    public double[] keys() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public long put(double d, long j) {
+        long j2;
+        boolean z;
+        int insertionIndex = insertionIndex(d);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            j2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            j2 = 0;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = d;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = j;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return j2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        long[] jArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new double[i];
+        this._values = new long[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._values[insertionIndex] = jArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public long remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return 0L;
+        }
+        long j = this._values[index];
+        removeAt(index);
+        return j;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TDoubleLongProcedure tDoubleLongProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._set;
+        long[] jArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tDoubleLongProcedure.a(dArr[i], jArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TDoubleHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new long[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TDoubleLongProcedure(this) { // from class: gnu.trove.TDoubleLongHashMap.1
+            @Override // gnu.trove.TDoubleLongProcedure
+            public boolean a(double d, long j) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                sb.append('=');
+                sb.append(j);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TLongFunction tLongFunction) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                jArr[i] = tLongFunction.a(jArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TDoubleLongHashMap(int i) {
+        super(i);
+    }
+
+    public TDoubleLongHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TDoubleLongHashMap(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(tDoubleHashingStrategy);
+    }
+
+    public TDoubleLongHashMap(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, tDoubleHashingStrategy);
+    }
+
+    public TDoubleLongHashMap(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f, tDoubleHashingStrategy);
+    }
+}

sources/gnu/trove/TDoubleLongIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TDoubleLongIterator extends TPrimitiveIterator {
+    public TDoubleLongIterator(TDoubleLongHashMap tDoubleLongHashMap) {
+        super(tDoubleLongHashMap);
+    }
+}

sources/gnu/trove/TDoubleLongProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleLongProcedure {
+    boolean a(double d, long j);
+}

sources/gnu/trove/TDoubleObjectHashMap.java

@@ -0,0 +1,520 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TDoubleObjectHashMap<V> extends THash implements TDoubleHashingStrategy {
+    protected final TDoubleHashingStrategy _hashingStrategy;
+    protected transient double[] _set;
+    protected transient V[] _values;
+
+    private final class HashProcedure implements TDoubleObjectProcedure<V> {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TDoubleObjectProcedure
+        public final boolean a(double d, V v) {
+            this.a += TDoubleObjectHashMap.this._hashingStrategy.computeHashCode(d) ^ HashFunctions.a(v);
+            return true;
+        }
+    }
+
+    public TDoubleObjectHashMap() {
+        this._hashingStrategy = this;
+    }
+
+    private static boolean isFree(Object[] objArr, int i) {
+        return objArr[i] == null;
+    }
+
+    static boolean isFull(Object[] objArr, int i) {
+        Object obj = objArr[i];
+        return (obj == null || obj == TObjectHash.REMOVED) ? false : true;
+    }
+
+    private static boolean isRemoved(Object[] objArr, int i) {
+        return objArr[i] == TObjectHash.REMOVED;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readDouble(), objectInputStream.readObject());
+            readInt = i;
+        }
+    }
+
+    private static <V> V unwrapNull(V v) {
+        if (v == TObjectHash.NULL) {
+            return null;
+        }
+        return v;
+    }
+
+    private static <V> V wrapNull(V v) {
+        return v == null ? (V) TObjectHash.NULL : v;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected int capacity() {
+        return this._values.length;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        double[] dArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            dArr[i] = 0.0d;
+            vArr[i] = null;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TDoubleHashingStrategy
+    public final int computeHashCode(double d) {
+        return HashFunctions.a(d);
+    }
+
+    public boolean contains(double d) {
+        return index(d) >= 0;
+    }
+
+    public boolean containsKey(double d) {
+        return contains(d);
+    }
+
+    public boolean containsValue(V v) {
+        V[] vArr = this._values;
+        if (v != null) {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return false;
+                }
+                Object unwrapNull = unwrapNull(vArr[i]);
+                if (!isFull(vArr, i) || (v != unwrapNull && !v.equals(unwrapNull))) {
+                    length = i;
+                }
+            }
+            return true;
+        }
+        int length2 = vArr.length;
+        while (true) {
+            int i2 = length2 - 1;
+            if (length2 <= 0) {
+                return false;
+            }
+            if (TObjectHash.NULL == vArr[i2]) {
+                return true;
+            }
+            length2 = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TDoubleObjectHashMap)) {
+            return false;
+        }
+        TDoubleObjectHashMap tDoubleObjectHashMap = (TDoubleObjectHashMap) obj;
+        if (tDoubleObjectHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tDoubleObjectHashMap));
+    }
+
+    public boolean forEach(TDoubleProcedure tDoubleProcedure) {
+        double[] dArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tDoubleProcedure.a(dArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachEntry(TDoubleObjectProcedure<V> tDoubleObjectProcedure) {
+        double[] dArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tDoubleObjectProcedure.a(dArr[i], unwrapNull(vArr[i]))) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean forEachKey(TDoubleProcedure tDoubleProcedure) {
+        return forEach(tDoubleProcedure);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachValue(TObjectProcedure<V> tObjectProcedure) {
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tObjectProcedure.execute(unwrapNull(vArr[i]))) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public V get(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return null;
+        }
+        return (V) unwrapNull(this._values[index]);
+    }
+
+    public Object[] getValues() {
+        Object[] objArr = new Object[size()];
+        V[] vArr = this._values;
+        int length = vArr.length;
+        int i = 0;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return objArr;
+            }
+            if (isFull(vArr, i2)) {
+                objArr[i] = unwrapNull(vArr[i2]);
+                i++;
+            }
+            length = i2;
+        }
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    protected int index(double d) {
+        double[] dArr = this._set;
+        V[] vArr = this._values;
+        if (vArr == THash.EMPTY_OBJECT_ARRAY) {
+            return -1;
+        }
+        int length = dArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(d) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (!isFree(vArr, i) && (isRemoved(vArr, i) || dArr[i] != d)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (isFree(vArr, i) || (!isRemoved(vArr, i) && dArr[i] == d)) {
+                    break;
+                }
+            }
+        }
+        if (isFree(vArr, i)) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(double d) {
+        if (this._values == THash.EMPTY_OBJECT_ARRAY) {
+            setUp(6);
+        }
+        V[] vArr = this._values;
+        double[] dArr = this._set;
+        int length = dArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(d) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (isFree(vArr, i)) {
+            return i;
+        }
+        if (!isFull(vArr, i) || dArr[i] != d) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            int i3 = isRemoved(vArr, i) ? i : -1;
+            do {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (i3 == -1 && isRemoved(vArr, i)) {
+                    i3 = i;
+                }
+                if (!isFull(vArr, i)) {
+                    break;
+                }
+            } while (dArr[i] != d);
+            if (isRemoved(vArr, i)) {
+                while (!isFree(vArr, i) && (isRemoved(vArr, i) || dArr[i] != d)) {
+                    i -= i2;
+                    if (i < 0) {
+                        i += length;
+                    }
+                }
+            }
+            if (!isFull(vArr, i)) {
+                return i3 == -1 ? i : i3;
+            }
+        }
+        return (-i) - 1;
+    }
+
+    public TDoubleObjectIterator<V> iterator() {
+        return new TDoubleObjectIterator<>(this);
+    }
+
+    public double[] keys() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        int i = 0;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return dArr;
+            }
+            if (isFull(vArr, i2)) {
+                dArr[i] = dArr2[i2];
+                i++;
+            }
+            length = i2;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public V put(double d, V v) {
+        V v2;
+        int insertionIndex = insertionIndex(d);
+        boolean z = true;
+        boolean z2 = false;
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            v2 = unwrapNull(this._values[insertionIndex]);
+            z = false;
+        } else {
+            z2 = isFree(this._values, insertionIndex);
+            v2 = null;
+        }
+        this._set[insertionIndex] = d;
+        ((V[]) this._values)[insertionIndex] = wrapNull(v);
+        if (z) {
+            postInsertHook(z2);
+        }
+        return v2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        double[] dArr = this._set;
+        V[] vArr = this._values;
+        this._set = new double[i];
+        this._values = (V[]) new Object[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (isFull(vArr, i2)) {
+                double d = dArr[i2];
+                int insertionIndex = insertionIndex(d);
+                this._set[insertionIndex] = d;
+                this._values[insertionIndex] = vArr[i2];
+            }
+            capacity = i2;
+        }
+    }
+
+    public V remove(double d) {
+        int index = index(d);
+        if (index < 0) {
+            return null;
+        }
+        V v = (V) unwrapNull(this._values[index]);
+        removeAt(index);
+        return v;
+    }
+
+    @Override // gnu.trove.THash
+    protected void removeAt(int i) {
+        ((V[]) this._values)[i] = TObjectHash.REMOVED;
+        super.removeAt(i);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean retainEntries(TDoubleObjectProcedure<V> tDoubleObjectProcedure) {
+        double[] dArr = this._set;
+        V[] vArr = this._values;
+        stopCompactingOnRemove();
+        boolean z = false;
+        try {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return z;
+                }
+                if (isFull(vArr, i) && !tDoubleObjectProcedure.a(dArr[i], unwrapNull(vArr[i]))) {
+                    removeAt(i);
+                    z = true;
+                }
+                length = i;
+            }
+        } finally {
+            startCompactingOnRemove(z);
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? (V[]) THash.EMPTY_OBJECT_ARRAY : (V[]) new Object[up];
+        this._set = i == -1 ? null : new double[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TDoubleObjectProcedure<V>(this) { // from class: gnu.trove.TDoubleObjectHashMap.1
+            @Override // gnu.trove.TDoubleObjectProcedure
+            public boolean a(double d, V v) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(d);
+                sb.append('=');
+                StringBuilder sb3 = sb;
+                if (v == this) {
+                    v = (V) "(this Map)";
+                }
+                sb3.append(v);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public void transformValues(TObjectFunction<V, V> tObjectFunction) {
+        Object[] objArr = this._values;
+        int length = objArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (isFull(objArr, i)) {
+                objArr[i] = wrapNull(tObjectFunction.execute(unwrapNull(objArr[i])));
+            }
+            length = i;
+        }
+    }
+
+    private static final class EqProcedure<V> implements TDoubleObjectProcedure<V> {
+        private final TDoubleObjectHashMap<V> a;
+
+        EqProcedure(TDoubleObjectHashMap<V> tDoubleObjectHashMap) {
+            this.a = tDoubleObjectHashMap;
+        }
+
+        @Override // gnu.trove.TDoubleObjectProcedure
+        public final boolean a(double d, V v) {
+            return this.a.index(d) >= 0 && a(v, this.a.get(d));
+        }
+
+        private static boolean a(Object obj, Object obj2) {
+            return obj == obj2 || (obj != null && obj.equals(obj2));
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public TDoubleObjectHashMap<V> clone() {
+        TDoubleObjectHashMap<V> tDoubleObjectHashMap = (TDoubleObjectHashMap) super.clone();
+        V[] vArr = this._values;
+        V[] vArr2 = (V[]) THash.EMPTY_OBJECT_ARRAY;
+        if (vArr != vArr2) {
+            vArr2 = (V[]) ((Object[]) vArr.clone());
+        }
+        tDoubleObjectHashMap._values = vArr2;
+        tDoubleObjectHashMap._set = this._values == THash.EMPTY_OBJECT_ARRAY ? null : (double[]) this._set.clone();
+        return tDoubleObjectHashMap;
+    }
+
+    public TDoubleObjectHashMap(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TDoubleObjectHashMap(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TDoubleObjectHashMap(TDoubleHashingStrategy tDoubleHashingStrategy) {
+        this._hashingStrategy = tDoubleHashingStrategy;
+    }
+
+    public TDoubleObjectHashMap(int i, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tDoubleHashingStrategy;
+    }
+
+    public TDoubleObjectHashMap(int i, float f, TDoubleHashingStrategy tDoubleHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tDoubleHashingStrategy;
+    }
+}

sources/gnu/trove/TDoubleObjectIterator.java

@@ -0,0 +1,31 @@
+package gnu.trove;
+
+import java.util.ConcurrentModificationException;
+
+/* loaded from: classes2.dex */
+public class TDoubleObjectIterator<V> extends TIterator {
+    private final TDoubleObjectHashMap<V> d;
+
+    public TDoubleObjectIterator(TDoubleObjectHashMap<V> tDoubleObjectHashMap) {
+        super(tDoubleObjectHashMap);
+        this.d = tDoubleObjectHashMap;
+    }
+
+    @Override // gnu.trove.TIterator
+    protected final int nextIndex() {
+        int i;
+        if (this.b != this.d.size()) {
+            throw new ConcurrentModificationException();
+        }
+        V[] vArr = this.d._values;
+        int i2 = this.c;
+        while (true) {
+            i = i2 - 1;
+            if (i2 <= 0 || TDoubleObjectHashMap.isFull(vArr, i)) {
+                break;
+            }
+            i2 = i;
+        }
+        return i;
+    }
+}

sources/gnu/trove/TDoubleObjectProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleObjectProcedure<V> {
+    boolean a(double d, V v);
+}

sources/gnu/trove/TDoubleProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TDoubleProcedure {
+    boolean a(double d);
+}

sources/gnu/trove/TFloatArrayList.java

@@ -0,0 +1,528 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Random;
+
+/* loaded from: classes2.dex */
+public class TFloatArrayList implements Serializable, Cloneable {
+    protected static final int DEFAULT_CAPACITY = 4;
+    protected transient float[] _data;
+    protected transient int _pos;
+
+    public TFloatArrayList() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        this._data = new float[readInt];
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readFloat());
+            readInt = i;
+        }
+    }
+
+    private void swap(int i, int i2) {
+        float[] fArr = this._data;
+        float f = fArr[i];
+        fArr[i] = fArr[i2];
+        fArr[i2] = f;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(size());
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public void add(float f) {
+        ensureCapacity(this._pos + 1);
+        float[] fArr = this._data;
+        int i = this._pos;
+        this._pos = i + 1;
+        fArr[i] = f;
+    }
+
+    public int binarySearch(float f) {
+        return binarySearch(f, 0, this._pos);
+    }
+
+    public void clear() {
+        this._data = null;
+        this._pos = 0;
+    }
+
+    public Object clone() {
+        float[] fArr = null;
+        try {
+            TFloatArrayList tFloatArrayList = (TFloatArrayList) super.clone();
+            try {
+                if (this._data != null) {
+                    fArr = (float[]) this._data.clone();
+                }
+                tFloatArrayList._data = fArr;
+                return tFloatArrayList;
+            } catch (CloneNotSupportedException unused) {
+                return tFloatArrayList;
+            }
+        } catch (CloneNotSupportedException unused2) {
+            return null;
+        }
+    }
+
+    public boolean contains(float f) {
+        return lastIndexOf(f) >= 0;
+    }
+
+    public void ensureCapacity(int i) {
+        if (this._data == null) {
+            this._data = new float[Math.max(4, i)];
+        }
+        float[] fArr = this._data;
+        if (i > fArr.length) {
+            float[] fArr2 = new float[Math.max(fArr.length << 1, i)];
+            float[] fArr3 = this._data;
+            System.arraycopy(fArr3, 0, fArr2, 0, fArr3.length);
+            this._data = fArr2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof TFloatArrayList)) {
+            return false;
+        }
+        TFloatArrayList tFloatArrayList = (TFloatArrayList) obj;
+        if (tFloatArrayList.size() != size()) {
+            return false;
+        }
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (this._data[i2] != tFloatArrayList._data[i2]) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public void fill(float f) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, 0, this._pos, f);
+    }
+
+    public boolean forEach(TFloatProcedure tFloatProcedure) {
+        for (int i = 0; i < this._pos; i++) {
+            if (!tFloatProcedure.a(this._data[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachDescending(TFloatProcedure tFloatProcedure) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (!tFloatProcedure.a(this._data[i2])) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public float get(int i) {
+        if (i < this._pos) {
+            return this._data[i];
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public float getQuick(int i) {
+        return this._data[i];
+    }
+
+    public float getSet(int i, float f) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        float[] fArr = this._data;
+        float f2 = fArr[i];
+        fArr[i] = f;
+        return f2;
+    }
+
+    public TFloatArrayList grep(TFloatProcedure tFloatProcedure) {
+        TFloatArrayList tFloatArrayList = new TFloatArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (tFloatProcedure.a(this._data[i])) {
+                tFloatArrayList.add(this._data[i]);
+            }
+        }
+        return tFloatArrayList;
+    }
+
+    public int hashCode() {
+        int i = this._pos;
+        int i2 = 0;
+        while (true) {
+            int i3 = i - 1;
+            if (i <= 0) {
+                return i2;
+            }
+            i2 += HashFunctions.a(this._data[i3]);
+            i = i3;
+        }
+    }
+
+    public int indexOf(float f) {
+        return indexOf(0, f);
+    }
+
+    public void insert(int i, float f) {
+        int i2 = this._pos;
+        if (i == i2) {
+            add(f);
+            return;
+        }
+        ensureCapacity(i2 + 1);
+        float[] fArr = this._data;
+        System.arraycopy(fArr, i, fArr, i + 1, this._pos - i);
+        this._data[i] = f;
+        this._pos++;
+    }
+
+    public TFloatArrayList inverseGrep(TFloatProcedure tFloatProcedure) {
+        TFloatArrayList tFloatArrayList = new TFloatArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (!tFloatProcedure.a(this._data[i])) {
+                tFloatArrayList.add(this._data[i]);
+            }
+        }
+        return tFloatArrayList;
+    }
+
+    public boolean isEmpty() {
+        return this._pos == 0;
+    }
+
+    public int lastIndexOf(float f) {
+        return lastIndexOf(this._pos, f);
+    }
+
+    public float max() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find maximum of an empty list");
+        }
+        float[] fArr = this._data;
+        int i = this._pos;
+        float f = fArr[i - 1];
+        int i2 = i - 1;
+        while (true) {
+            int i3 = i2 - 1;
+            if (i2 <= 0) {
+                return f;
+            }
+            f = Math.max(f, this._data[this._pos]);
+            i2 = i3;
+        }
+    }
+
+    public float min() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find minimum of an empty list");
+        }
+        float[] fArr = this._data;
+        int i = this._pos;
+        float f = fArr[i - 1];
+        int i2 = i - 1;
+        while (true) {
+            int i3 = i2 - 1;
+            if (i2 <= 0) {
+                return f;
+            }
+            f = Math.min(f, this._data[this._pos]);
+            i2 = i3;
+        }
+    }
+
+    public float remove(int i) {
+        float f = get(i);
+        remove(i, 1);
+        return f;
+    }
+
+    public void reset() {
+        fill(0.0f);
+        this._pos = 0;
+    }
+
+    public void resetQuick() {
+        this._pos = 0;
+    }
+
+    public void reverse() {
+        reverse(0, this._pos);
+    }
+
+    public void set(int i, float f) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        this._data[i] = f;
+    }
+
+    public void setQuick(int i, float f) {
+        this._data[i] = f;
+    }
+
+    public void shuffle(Random random) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 1) {
+                return;
+            }
+            swap(i2, random.nextInt(i2));
+            i = i2;
+        }
+    }
+
+    public int size() {
+        return this._pos;
+    }
+
+    public void sort() {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, 0, this._pos);
+    }
+
+    public float[] toNativeArray() {
+        return toNativeArray(0, this._pos);
+    }
+
+    public String toString() {
+        final StringBuffer stringBuffer = new StringBuffer("{");
+        forEach(new TFloatProcedure(this) { // from class: gnu.trove.TFloatArrayList.1
+            @Override // gnu.trove.TFloatProcedure
+            public boolean a(float f) {
+                stringBuffer.append(f);
+                stringBuffer.append(", ");
+                return true;
+            }
+        });
+        stringBuffer.append("}");
+        return stringBuffer.toString();
+    }
+
+    public void transformValues(TFloatFunction tFloatFunction) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return;
+            }
+            float[] fArr = this._data;
+            fArr[i2] = tFloatFunction.a(fArr[i2]);
+            i = i2;
+        }
+    }
+
+    public void trimToSize() {
+        float[] fArr = this._data;
+        if (fArr == null || fArr.length <= size()) {
+            return;
+        }
+        float[] fArr2 = new float[size()];
+        toNativeArray(fArr2, 0, fArr2.length);
+        this._data = fArr2;
+    }
+
+    public TFloatArrayList(int i) {
+        this._data = new float[i];
+        this._pos = 0;
+    }
+
+    public int binarySearch(float f, int i, int i2) {
+        if (i < 0) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        if (i2 > this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i2);
+        }
+        int i3 = i2 - 1;
+        while (i <= i3) {
+            int i4 = (i + i3) >> 1;
+            float f2 = this._data[i4];
+            if (f2 < f) {
+                i = i4 + 1;
+            } else {
+                if (f2 <= f) {
+                    return i4;
+                }
+                i3 = i4 - 1;
+            }
+        }
+        return -(i + 1);
+    }
+
+    public void fill(int i, int i2, float f) {
+        if (i2 > this._pos) {
+            ensureCapacity(i2);
+            this._pos = i2;
+        }
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, i, i2, f);
+    }
+
+    public int indexOf(int i, float f) {
+        while (i < this._pos) {
+            if (this._data[i] == f) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public int lastIndexOf(int i, float f) {
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return -1;
+            }
+            if (this._data[i2] == f) {
+                return i2;
+            }
+            i = i2;
+        }
+    }
+
+    public void reverse(int i, int i2) {
+        if (i == i2) {
+            return;
+        }
+        if (i > i2) {
+            throw new IllegalArgumentException("from cannot be greater than to");
+        }
+        for (int i3 = i2 - 1; i < i3; i3--) {
+            swap(i, i3);
+            i++;
+        }
+    }
+
+    public void sort(int i, int i2) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, i, i2);
+    }
+
+    public float[] toNativeArray(int i, int i2) {
+        float[] fArr = new float[i2];
+        toNativeArray(fArr, i, i2);
+        return fArr;
+    }
+
+    public void add(float[] fArr) {
+        add(fArr, 0, fArr.length);
+    }
+
+    public void clear(int i) {
+        this._data = new float[i];
+        this._pos = 0;
+    }
+
+    public void remove(int i, int i2) {
+        int i3;
+        if (i >= 0 && i < (i3 = this._pos)) {
+            if (i == 0) {
+                float[] fArr = this._data;
+                System.arraycopy(fArr, i2, fArr, 0, i3 - i2);
+            } else if (i3 - i2 != i) {
+                float[] fArr2 = this._data;
+                int i4 = i + i2;
+                System.arraycopy(fArr2, i4, fArr2, i, i3 - i4);
+            }
+            this._pos -= i2;
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void add(float[] fArr, int i, int i2) {
+        ensureCapacity(this._pos + i2);
+        System.arraycopy(fArr, i, this._data, this._pos, i2);
+        this._pos += i2;
+    }
+
+    public void set(int i, float[] fArr) {
+        set(i, fArr, 0, fArr.length);
+    }
+
+    public void toNativeArray(float[] fArr, int i, int i2) {
+        if (i2 == 0) {
+            return;
+        }
+        if (i >= 0 && i < this._pos) {
+            System.arraycopy(this._data, i, fArr, 0, i2);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public TFloatArrayList(float[] fArr) {
+        this(Math.max(fArr.length, 4));
+        add(fArr);
+    }
+
+    public void set(int i, float[] fArr, int i2, int i3) {
+        if (i >= 0 && i + i3 <= this._pos) {
+            System.arraycopy(this._data, i, fArr, i2, i3);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void insert(int i, float[] fArr) {
+        insert(i, fArr, 0, fArr.length);
+    }
+
+    public void insert(int i, float[] fArr, int i2, int i3) {
+        int i4 = this._pos;
+        if (i == i4) {
+            add(fArr, i2, i3);
+            return;
+        }
+        ensureCapacity(i4 + i3);
+        float[] fArr2 = this._data;
+        System.arraycopy(fArr2, i, fArr2, i + i3, this._pos - i);
+        System.arraycopy(fArr, i2, this._data, i, i3);
+        this._pos += i3;
+    }
+}

sources/gnu/trove/TFloatByteHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TFloatByteHashMap extends TFloatHash {
+    protected transient byte[] _values;
+
+    private static final class EqProcedure implements TFloatByteProcedure {
+        private final TFloatByteHashMap a;
+
+        EqProcedure(TFloatByteHashMap tFloatByteHashMap) {
+            this.a = tFloatByteHashMap;
+        }
+
+        private static boolean a(byte b, byte b2) {
+            return b == b2;
+        }
+
+        @Override // gnu.trove.TFloatByteProcedure
+        public final boolean a(float f, byte b) {
+            return this.a.index(f) >= 0 && a(b, this.a.get(f));
+        }
+    }
+
+    private final class HashProcedure implements TFloatByteProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatByteProcedure
+        public final boolean a(float f, byte b) {
+            int i = this.a;
+            int computeHashCode = TFloatByteHashMap.this._hashingStrategy.computeHashCode(f);
+            HashFunctions.a((int) b);
+            this.a = i + (computeHashCode ^ b);
+            return true;
+        }
+    }
+
+    public TFloatByteHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readFloat(), objectInputStream.readByte());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(float f, byte b) {
+        int index = index(f);
+        if (index < 0) {
+            return false;
+        }
+        byte[] bArr = this._values;
+        bArr[index] = (byte) (bArr[index] + b);
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        byte[] bArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            bArr[i] = 0;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TFloatByteHashMap tFloatByteHashMap = (TFloatByteHashMap) super.clone();
+        byte[] bArr = this._values;
+        tFloatByteHashMap._values = bArr == null ? null : (byte[]) bArr.clone();
+        return tFloatByteHashMap;
+    }
+
+    public boolean containsKey(float f) {
+        return contains(f);
+    }
+
+    public boolean containsValue(byte b) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && b == bArr2[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatByteHashMap)) {
+            return false;
+        }
+        TFloatByteHashMap tFloatByteHashMap = (TFloatByteHashMap) obj;
+        if (tFloatByteHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tFloatByteHashMap));
+    }
+
+    public boolean forEachEntry(TFloatByteProcedure tFloatByteProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatByteProcedure.a(fArr[i], bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TFloatProcedure tFloatProcedure) {
+        return forEach(tFloatProcedure);
+    }
+
+    public boolean forEachValue(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteProcedure.a(bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public byte get(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        return this._values[index];
+    }
+
+    public byte[] getValues() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._values;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(float f) {
+        return adjustValue(f, (byte) 1);
+    }
+
+    public TFloatByteIterator iterator() {
+        return new TFloatByteIterator(this);
+    }
+
+    public float[] keys() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public byte put(float f, byte b) {
+        boolean z;
+        byte b2;
+        int insertionIndex = insertionIndex(f);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            b2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            b2 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b3 = bArr[insertionIndex];
+        this._set[insertionIndex] = f;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = b;
+        if (z) {
+            postInsertHook(b3 == 0);
+        }
+        return b2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        byte[] bArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new float[i];
+        this._values = new byte[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._values[insertionIndex] = bArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public byte remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        byte b = this._values[index];
+        removeAt(index);
+        return b;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TFloatByteProcedure tFloatByteProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        byte[] bArr2 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tFloatByteProcedure.a(fArr[i], bArr2[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TFloatByteProcedure(this) { // from class: gnu.trove.TFloatByteHashMap.1
+            @Override // gnu.trove.TFloatByteProcedure
+            public boolean a(float f, byte b) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                sb.append('=');
+                sb.append((int) b);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TByteFunction tByteFunction) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                bArr2[i] = tByteFunction.a(bArr2[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TFloatByteHashMap(int i) {
+        super(i);
+    }
+
+    public TFloatByteHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TFloatByteHashMap(TFloatHashingStrategy tFloatHashingStrategy) {
+        super(tFloatHashingStrategy);
+    }
+
+    public TFloatByteHashMap(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, tFloatHashingStrategy);
+    }
+
+    public TFloatByteHashMap(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f, tFloatHashingStrategy);
+    }
+}

sources/gnu/trove/TFloatByteIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TFloatByteIterator extends TPrimitiveIterator {
+    public TFloatByteIterator(TFloatByteHashMap tFloatByteHashMap) {
+        super(tFloatByteHashMap);
+    }
+}

sources/gnu/trove/TFloatByteProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatByteProcedure {
+    boolean a(float f, byte b);
+}

sources/gnu/trove/TFloatDoubleHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TFloatDoubleHashMap extends TFloatHash {
+    protected transient double[] _values;
+
+    private static final class EqProcedure implements TFloatDoubleProcedure {
+        private final TFloatDoubleHashMap a;
+
+        EqProcedure(TFloatDoubleHashMap tFloatDoubleHashMap) {
+            this.a = tFloatDoubleHashMap;
+        }
+
+        private static boolean a(double d, double d2) {
+            return d == d2;
+        }
+
+        @Override // gnu.trove.TFloatDoubleProcedure
+        public final boolean a(float f, double d) {
+            return this.a.index(f) >= 0 && a(d, this.a.get(f));
+        }
+    }
+
+    private final class HashProcedure implements TFloatDoubleProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatDoubleProcedure
+        public final boolean a(float f, double d) {
+            this.a += TFloatDoubleHashMap.this._hashingStrategy.computeHashCode(f) ^ HashFunctions.a(d);
+            return true;
+        }
+    }
+
+    public TFloatDoubleHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readFloat(), objectInputStream.readDouble());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(float f, double d) {
+        int index = index(f);
+        if (index < 0) {
+            return false;
+        }
+        double[] dArr = this._values;
+        dArr[index] = dArr[index] + d;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        double[] dArr = this._values;
+        if (dArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            dArr[i] = 0.0d;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TFloatDoubleHashMap tFloatDoubleHashMap = (TFloatDoubleHashMap) super.clone();
+        double[] dArr = this._values;
+        tFloatDoubleHashMap._values = dArr == null ? null : (double[]) dArr.clone();
+        return tFloatDoubleHashMap;
+    }
+
+    public boolean containsKey(float f) {
+        return contains(f);
+    }
+
+    public boolean containsValue(double d) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && d == dArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatDoubleHashMap)) {
+            return false;
+        }
+        TFloatDoubleHashMap tFloatDoubleHashMap = (TFloatDoubleHashMap) obj;
+        if (tFloatDoubleHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tFloatDoubleHashMap));
+    }
+
+    public boolean forEachEntry(TFloatDoubleProcedure tFloatDoubleProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatDoubleProcedure.a(fArr[i], dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TFloatProcedure tFloatProcedure) {
+        return forEach(tFloatProcedure);
+    }
+
+    public boolean forEachValue(TDoubleProcedure tDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleProcedure.a(dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public double get(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0.0d;
+        }
+        return this._values[index];
+    }
+
+    public double[] getValues() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(float f) {
+        return adjustValue(f, 1.0d);
+    }
+
+    public TFloatDoubleIterator iterator() {
+        return new TFloatDoubleIterator(this);
+    }
+
+    public float[] keys() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public double put(float f, double d) {
+        double d2;
+        boolean z;
+        int insertionIndex = insertionIndex(f);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            d2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            d2 = 0.0d;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = f;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = d;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return d2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        double[] dArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new float[i];
+        this._values = new double[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._values[insertionIndex] = dArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public double remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0.0d;
+        }
+        double d = this._values[index];
+        removeAt(index);
+        return d;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0d;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TFloatDoubleProcedure tFloatDoubleProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        double[] dArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tFloatDoubleProcedure.a(fArr[i], dArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new double[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TFloatDoubleProcedure(this) { // from class: gnu.trove.TFloatDoubleHashMap.1
+            @Override // gnu.trove.TFloatDoubleProcedure
+            public boolean a(float f, double d) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                sb.append('=');
+                sb.append(d);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TDoubleFunction tDoubleFunction) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                dArr[i] = tDoubleFunction.a(dArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TFloatDoubleHashMap(int i) {
+        super(i);
+    }
+
+    public TFloatDoubleHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TFloatDoubleHashMap(TFloatHashingStrategy tFloatHashingStrategy) {
+        super(tFloatHashingStrategy);
+    }
+
+    public TFloatDoubleHashMap(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, tFloatHashingStrategy);
+    }
+
+    public TFloatDoubleHashMap(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f, tFloatHashingStrategy);
+    }
+}

sources/gnu/trove/TFloatDoubleIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TFloatDoubleIterator extends TPrimitiveIterator {
+    public TFloatDoubleIterator(TFloatDoubleHashMap tFloatDoubleHashMap) {
+        super(tFloatDoubleHashMap);
+    }
+}

sources/gnu/trove/TFloatDoubleProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatDoubleProcedure {
+    boolean a(float f, double d);
+}

sources/gnu/trove/TFloatFloatHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TFloatFloatHashMap extends TFloatHash {
+    protected transient float[] _values;
+
+    private static final class EqProcedure implements TFloatFloatProcedure {
+        private final TFloatFloatHashMap a;
+
+        EqProcedure(TFloatFloatHashMap tFloatFloatHashMap) {
+            this.a = tFloatFloatHashMap;
+        }
+
+        private static boolean b(float f, float f2) {
+            return f == f2;
+        }
+
+        @Override // gnu.trove.TFloatFloatProcedure
+        public final boolean a(float f, float f2) {
+            return this.a.index(f) >= 0 && b(f2, this.a.get(f));
+        }
+    }
+
+    private final class HashProcedure implements TFloatFloatProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatFloatProcedure
+        public final boolean a(float f, float f2) {
+            this.a += TFloatFloatHashMap.this._hashingStrategy.computeHashCode(f) ^ HashFunctions.a(f2);
+            return true;
+        }
+    }
+
+    public TFloatFloatHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readFloat(), objectInputStream.readFloat());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(float f, float f2) {
+        int index = index(f);
+        if (index < 0) {
+            return false;
+        }
+        float[] fArr = this._values;
+        fArr[index] = fArr[index] + f2;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        float[] fArr2 = this._values;
+        if (fArr2 == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            fArr2[i] = 0.0f;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TFloatFloatHashMap tFloatFloatHashMap = (TFloatFloatHashMap) super.clone();
+        float[] fArr = this._values;
+        tFloatFloatHashMap._values = fArr == null ? null : (float[]) fArr.clone();
+        return tFloatFloatHashMap;
+    }
+
+    public boolean containsKey(float f) {
+        return contains(f);
+    }
+
+    public boolean containsValue(float f) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && f == fArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatFloatHashMap)) {
+            return false;
+        }
+        TFloatFloatHashMap tFloatFloatHashMap = (TFloatFloatHashMap) obj;
+        if (tFloatFloatHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tFloatFloatHashMap));
+    }
+
+    public boolean forEachEntry(TFloatFloatProcedure tFloatFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        float[] fArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatFloatProcedure.a(fArr[i], fArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TFloatProcedure tFloatProcedure) {
+        return forEach(tFloatProcedure);
+    }
+
+    public boolean forEachValue(TFloatProcedure tFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatProcedure.a(fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public float get(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0.0f;
+        }
+        return this._values[index];
+    }
+
+    public float[] getValues() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(float f) {
+        return adjustValue(f, 1.0f);
+    }
+
+    public TFloatFloatIterator iterator() {
+        return new TFloatFloatIterator(this);
+    }
+
+    public float[] keys() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public float put(float f, float f2) {
+        boolean z;
+        float f3;
+        int insertionIndex = insertionIndex(f);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            f3 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            f3 = 0.0f;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = f;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = f2;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return f3;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        float[] fArr2 = this._values;
+        byte[] bArr = this._states;
+        this._set = new float[i];
+        this._values = new float[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._values[insertionIndex] = fArr2[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public float remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0.0f;
+        }
+        float f2 = this._values[index];
+        removeAt(index);
+        return f2;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0f;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TFloatFloatProcedure tFloatFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        float[] fArr2 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tFloatFloatProcedure.a(fArr[i], fArr2[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new float[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TFloatFloatProcedure(this) { // from class: gnu.trove.TFloatFloatHashMap.1
+            @Override // gnu.trove.TFloatFloatProcedure
+            public boolean a(float f, float f2) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                sb.append('=');
+                sb.append(f2);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TFloatFunction tFloatFunction) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                fArr[i] = tFloatFunction.a(fArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TFloatFloatHashMap(int i) {
+        super(i);
+    }
+
+    public TFloatFloatHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TFloatFloatHashMap(TFloatHashingStrategy tFloatHashingStrategy) {
+        super(tFloatHashingStrategy);
+    }
+
+    public TFloatFloatHashMap(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, tFloatHashingStrategy);
+    }
+
+    public TFloatFloatHashMap(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f, tFloatHashingStrategy);
+    }
+}

sources/gnu/trove/TFloatFloatIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TFloatFloatIterator extends TPrimitiveIterator {
+    public TFloatFloatIterator(TFloatFloatHashMap tFloatFloatHashMap) {
+        super(tFloatFloatHashMap);
+    }
+}

sources/gnu/trove/TFloatFloatProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatFloatProcedure {
+    boolean a(float f, float f2);
+}

sources/gnu/trove/TFloatFunction.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatFunction {
+    float a(float f);
+}

sources/gnu/trove/TFloatHash.java

@@ -0,0 +1,149 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public abstract class TFloatHash extends TPrimitiveHash implements TFloatHashingStrategy {
+    protected final TFloatHashingStrategy _hashingStrategy;
+    protected transient float[] _set;
+
+    public TFloatHash() {
+        this._hashingStrategy = this;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TFloatHash tFloatHash = (TFloatHash) super.clone();
+        float[] fArr = this._set;
+        tFloatHash._set = fArr == null ? null : (float[]) fArr.clone();
+        return tFloatHash;
+    }
+
+    @Override // gnu.trove.TFloatHashingStrategy
+    public final int computeHashCode(float f) {
+        return HashFunctions.a(f);
+    }
+
+    public boolean contains(float f) {
+        return index(f) >= 0;
+    }
+
+    public boolean forEach(TFloatProcedure tFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatProcedure.a(fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    protected int index(float f) {
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return -1;
+        }
+        float[] fArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(f) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] != 0 && (bArr[i] == 2 || fArr[i] != f)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (bArr[i] == 0 || (bArr[i] != 2 && fArr[i] == f)) {
+                    break;
+                }
+            }
+        }
+        if (bArr[i] == 0) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(float f) {
+        if (this._set == null) {
+            setUp(6);
+        }
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(f) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (bArr[i] == 0) {
+            return i;
+        }
+        if (bArr[i] == 1 && fArr[i] == f) {
+            return (-i) - 1;
+        }
+        int i2 = (computeHashCode % (length - 2)) + 1;
+        do {
+            i -= i2;
+            if (i < 0) {
+                i += length;
+            }
+            if (bArr[i] != 1) {
+                break;
+            }
+        } while (fArr[i] != f);
+        if (bArr[i] != 2) {
+            return bArr[i] == 1 ? (-i) - 1 : i;
+        }
+        int i3 = i;
+        while (bArr[i3] != 0 && (bArr[i3] == 2 || fArr[i3] != f)) {
+            i3 -= i2;
+            if (i3 < 0) {
+                i3 += length;
+            }
+        }
+        return bArr[i3] == 1 ? (-i3) - 1 : i;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._set[i] = 0.0f;
+        super.removeAt(i);
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._set = i == -1 ? null : new float[up];
+        return up;
+    }
+
+    public TFloatHash(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TFloatHash(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TFloatHash(TFloatHashingStrategy tFloatHashingStrategy) {
+        this._hashingStrategy = tFloatHashingStrategy;
+    }
+
+    public TFloatHash(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tFloatHashingStrategy;
+    }
+
+    public TFloatHash(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tFloatHashingStrategy;
+    }
+}

sources/gnu/trove/TFloatHashSet.java

@@ -0,0 +1,282 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public class TFloatHashSet extends TFloatHash {
+
+    private final class HashProcedure implements TFloatProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatProcedure
+        public final boolean a(float f) {
+            this.a += TFloatHashSet.this._hashingStrategy.computeHashCode(f);
+            return true;
+        }
+    }
+
+    public TFloatHashSet() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readFloat());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean add(float f) {
+        int insertionIndex = insertionIndex(f);
+        if (insertionIndex < 0) {
+            return false;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = f;
+        bArr[insertionIndex] = 1;
+        postInsertHook(b == 0);
+        return true;
+    }
+
+    public boolean addAll(float[] fArr) {
+        int length = fArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (add(fArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return;
+        }
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    public boolean containsAll(float[] fArr) {
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (!contains(fArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatHashSet)) {
+            return false;
+        }
+        final TFloatHashSet tFloatHashSet = (TFloatHashSet) obj;
+        if (tFloatHashSet.size() != size()) {
+            return false;
+        }
+        return forEach(new TFloatProcedure(this) { // from class: gnu.trove.TFloatHashSet.1
+            @Override // gnu.trove.TFloatProcedure
+            public final boolean a(float f) {
+                return tFloatHashSet.contains(f);
+            }
+        });
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEach(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public TFloatIterator iterator() {
+        return new TFloatIterator(this);
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        byte[] bArr = this._states;
+        this._set = new float[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public boolean remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return false;
+        }
+        removeAt(index);
+        return true;
+    }
+
+    public boolean removeAll(float[] fArr) {
+        int length = fArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (remove(fArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean retainAll(float[] fArr) {
+        Arrays.sort(fArr);
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        boolean z = false;
+        if (fArr2 != null) {
+            int length = fArr2.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || Arrays.binarySearch(fArr, fArr2[i]) >= 0) {
+                    length = i;
+                } else {
+                    remove(fArr2[i]);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    public float[] toArray() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEach(new TFloatProcedure(this) { // from class: gnu.trove.TFloatHashSet.2
+            @Override // gnu.trove.TFloatProcedure
+            public boolean a(float f) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                return true;
+            }
+        });
+        sb.append(']');
+        sb.insert(0, '[');
+        return sb.toString();
+    }
+
+    public TFloatHashSet(int i) {
+        super(i);
+    }
+
+    public TFloatHashSet(int i, float f) {
+        super(i, f);
+    }
+
+    public TFloatHashSet(float[] fArr) {
+        this(fArr.length);
+        addAll(fArr);
+    }
+
+    public TFloatHashSet(TFloatHashingStrategy tFloatHashingStrategy) {
+        super(tFloatHashingStrategy);
+    }
+
+    public TFloatHashSet(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, tFloatHashingStrategy);
+    }
+
+    public TFloatHashSet(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f, tFloatHashingStrategy);
+    }
+
+    public TFloatHashSet(float[] fArr, TFloatHashingStrategy tFloatHashingStrategy) {
+        this(fArr.length, tFloatHashingStrategy);
+        addAll(fArr);
+    }
+}

sources/gnu/trove/TFloatHashingStrategy.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+import java.io.Serializable;
+
+/* loaded from: classes2.dex */
+public interface TFloatHashingStrategy extends Serializable {
+    int computeHashCode(float f);
+}

sources/gnu/trove/TFloatIntHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TFloatIntHashMap extends TFloatHash {
+    protected transient int[] _values;
+
+    private static final class EqProcedure implements TFloatIntProcedure {
+        private final TFloatIntHashMap a;
+
+        EqProcedure(TFloatIntHashMap tFloatIntHashMap) {
+            this.a = tFloatIntHashMap;
+        }
+
+        private static boolean a(int i, int i2) {
+            return i == i2;
+        }
+
+        @Override // gnu.trove.TFloatIntProcedure
+        public final boolean a(float f, int i) {
+            return this.a.index(f) >= 0 && a(i, this.a.get(f));
+        }
+    }
+
+    private final class HashProcedure implements TFloatIntProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatIntProcedure
+        public final boolean a(float f, int i) {
+            int i2 = this.a;
+            int computeHashCode = TFloatIntHashMap.this._hashingStrategy.computeHashCode(f);
+            HashFunctions.a(i);
+            this.a = i2 + (computeHashCode ^ i);
+            return true;
+        }
+    }
+
+    public TFloatIntHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readFloat(), objectInputStream.readInt());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(float f, int i) {
+        int index = index(f);
+        if (index < 0) {
+            return false;
+        }
+        int[] iArr = this._values;
+        iArr[index] = iArr[index] + i;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        int[] iArr = this._values;
+        if (iArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            iArr[i] = 0;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TFloatIntHashMap tFloatIntHashMap = (TFloatIntHashMap) super.clone();
+        int[] iArr = this._values;
+        tFloatIntHashMap._values = iArr == null ? null : (int[]) iArr.clone();
+        return tFloatIntHashMap;
+    }
+
+    public boolean containsKey(float f) {
+        return contains(f);
+    }
+
+    public boolean containsValue(int i) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i2] == 1 && i == iArr[i2]) {
+                return true;
+            }
+            length = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatIntHashMap)) {
+            return false;
+        }
+        TFloatIntHashMap tFloatIntHashMap = (TFloatIntHashMap) obj;
+        if (tFloatIntHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tFloatIntHashMap));
+    }
+
+    public boolean forEachEntry(TFloatIntProcedure tFloatIntProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatIntProcedure.a(fArr[i], iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TFloatProcedure tFloatProcedure) {
+        return forEach(tFloatProcedure);
+    }
+
+    public boolean forEachValue(TIntProcedure tIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntProcedure.a(iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public int get(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0;
+        }
+        return this._values[index];
+    }
+
+    public int[] getValues() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(float f) {
+        return adjustValue(f, 1);
+    }
+
+    public TFloatIntIterator iterator() {
+        return new TFloatIntIterator(this);
+    }
+
+    public float[] keys() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public int put(float f, int i) {
+        boolean z;
+        int i2;
+        int insertionIndex = insertionIndex(f);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            i2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            i2 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = f;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = i;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return i2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        int[] iArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new float[i];
+        this._values = new int[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._values[insertionIndex] = iArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public int remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0;
+        }
+        int i = this._values[index];
+        removeAt(index);
+        return i;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TFloatIntProcedure tFloatIntProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        int[] iArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tFloatIntProcedure.a(fArr[i], iArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new int[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TFloatIntProcedure(this) { // from class: gnu.trove.TFloatIntHashMap.1
+            @Override // gnu.trove.TFloatIntProcedure
+            public boolean a(float f, int i) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                sb.append('=');
+                sb.append(i);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TIntFunction tIntFunction) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                iArr[i] = tIntFunction.a(iArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TFloatIntHashMap(int i) {
+        super(i);
+    }
+
+    public TFloatIntHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TFloatIntHashMap(TFloatHashingStrategy tFloatHashingStrategy) {
+        super(tFloatHashingStrategy);
+    }
+
+    public TFloatIntHashMap(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, tFloatHashingStrategy);
+    }
+
+    public TFloatIntHashMap(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f, tFloatHashingStrategy);
+    }
+}

sources/gnu/trove/TFloatIntIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TFloatIntIterator extends TPrimitiveIterator {
+    public TFloatIntIterator(TFloatIntHashMap tFloatIntHashMap) {
+        super(tFloatIntHashMap);
+    }
+}

sources/gnu/trove/TFloatIntProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatIntProcedure {
+    boolean a(float f, int i);
+}

sources/gnu/trove/TFloatIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TFloatIterator extends TPrimitiveIterator {
+    public TFloatIterator(TFloatHash tFloatHash) {
+        super(tFloatHash);
+    }
+}

sources/gnu/trove/TFloatLongHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TFloatLongHashMap extends TFloatHash {
+    protected transient long[] _values;
+
+    private static final class EqProcedure implements TFloatLongProcedure {
+        private final TFloatLongHashMap a;
+
+        EqProcedure(TFloatLongHashMap tFloatLongHashMap) {
+            this.a = tFloatLongHashMap;
+        }
+
+        private static boolean a(long j, long j2) {
+            return j == j2;
+        }
+
+        @Override // gnu.trove.TFloatLongProcedure
+        public final boolean a(float f, long j) {
+            return this.a.index(f) >= 0 && a(j, this.a.get(f));
+        }
+    }
+
+    private final class HashProcedure implements TFloatLongProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatLongProcedure
+        public final boolean a(float f, long j) {
+            this.a += TFloatLongHashMap.this._hashingStrategy.computeHashCode(f) ^ HashFunctions.a(j);
+            return true;
+        }
+    }
+
+    public TFloatLongHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readFloat(), objectInputStream.readLong());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(float f, long j) {
+        int index = index(f);
+        if (index < 0) {
+            return false;
+        }
+        long[] jArr = this._values;
+        jArr[index] = jArr[index] + j;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        long[] jArr = this._values;
+        if (jArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = fArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            jArr[i] = 0;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TFloatLongHashMap tFloatLongHashMap = (TFloatLongHashMap) super.clone();
+        long[] jArr = this._values;
+        tFloatLongHashMap._values = jArr == null ? null : (long[]) jArr.clone();
+        return tFloatLongHashMap;
+    }
+
+    public boolean containsKey(float f) {
+        return contains(f);
+    }
+
+    public boolean containsValue(long j) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && j == jArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatLongHashMap)) {
+            return false;
+        }
+        TFloatLongHashMap tFloatLongHashMap = (TFloatLongHashMap) obj;
+        if (tFloatLongHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tFloatLongHashMap));
+    }
+
+    public boolean forEachEntry(TFloatLongProcedure tFloatLongProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        long[] jArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatLongProcedure.a(fArr[i], jArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TFloatProcedure tFloatProcedure) {
+        return forEach(tFloatProcedure);
+    }
+
+    public boolean forEachValue(TLongProcedure tLongProcedure) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tLongProcedure.a(jArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public long get(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0L;
+        }
+        return this._values[index];
+    }
+
+    public long[] getValues() {
+        long[] jArr = new long[size()];
+        long[] jArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    jArr[i] = jArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return jArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(float f) {
+        return adjustValue(f, 1L);
+    }
+
+    public TFloatLongIterator iterator() {
+        return new TFloatLongIterator(this);
+    }
+
+    public float[] keys() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public long put(float f, long j) {
+        long j2;
+        boolean z;
+        int insertionIndex = insertionIndex(f);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            j2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            j2 = 0;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = f;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = j;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return j2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        long[] jArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new float[i];
+        this._values = new long[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._values[insertionIndex] = jArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public long remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return 0L;
+        }
+        long j = this._values[index];
+        removeAt(index);
+        return j;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TFloatLongProcedure tFloatLongProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._set;
+        long[] jArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tFloatLongProcedure.a(fArr[i], jArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TFloatHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new long[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TFloatLongProcedure(this) { // from class: gnu.trove.TFloatLongHashMap.1
+            @Override // gnu.trove.TFloatLongProcedure
+            public boolean a(float f, long j) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                sb.append('=');
+                sb.append(j);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TLongFunction tLongFunction) {
+        byte[] bArr = this._states;
+        long[] jArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                jArr[i] = tLongFunction.a(jArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TFloatLongHashMap(int i) {
+        super(i);
+    }
+
+    public TFloatLongHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TFloatLongHashMap(TFloatHashingStrategy tFloatHashingStrategy) {
+        super(tFloatHashingStrategy);
+    }
+
+    public TFloatLongHashMap(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, tFloatHashingStrategy);
+    }
+
+    public TFloatLongHashMap(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f, tFloatHashingStrategy);
+    }
+}

sources/gnu/trove/TFloatLongIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TFloatLongIterator extends TPrimitiveIterator {
+    public TFloatLongIterator(TFloatLongHashMap tFloatLongHashMap) {
+        super(tFloatLongHashMap);
+    }
+}

sources/gnu/trove/TFloatLongProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatLongProcedure {
+    boolean a(float f, long j);
+}

sources/gnu/trove/TFloatObjectHashMap.java

@@ -0,0 +1,520 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TFloatObjectHashMap<V> extends THash implements TFloatHashingStrategy {
+    protected final TFloatHashingStrategy _hashingStrategy;
+    protected transient float[] _set;
+    protected transient V[] _values;
+
+    private final class HashProcedure implements TFloatObjectProcedure<V> {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TFloatObjectProcedure
+        public final boolean a(float f, V v) {
+            this.a += TFloatObjectHashMap.this._hashingStrategy.computeHashCode(f) ^ HashFunctions.a(v);
+            return true;
+        }
+    }
+
+    public TFloatObjectHashMap() {
+        this._hashingStrategy = this;
+    }
+
+    private static boolean isFree(Object[] objArr, int i) {
+        return objArr[i] == null;
+    }
+
+    static boolean isFull(Object[] objArr, int i) {
+        Object obj = objArr[i];
+        return (obj == null || obj == TObjectHash.REMOVED) ? false : true;
+    }
+
+    private static boolean isRemoved(Object[] objArr, int i) {
+        return objArr[i] == TObjectHash.REMOVED;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readFloat(), objectInputStream.readObject());
+            readInt = i;
+        }
+    }
+
+    private static <V> V unwrapNull(V v) {
+        if (v == TObjectHash.NULL) {
+            return null;
+        }
+        return v;
+    }
+
+    private static <V> V wrapNull(V v) {
+        return v == null ? (V) TObjectHash.NULL : v;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected int capacity() {
+        return this._values.length;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        float[] fArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            fArr[i] = 0.0f;
+            vArr[i] = null;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TFloatHashingStrategy
+    public final int computeHashCode(float f) {
+        return HashFunctions.a(f);
+    }
+
+    public boolean contains(float f) {
+        return index(f) >= 0;
+    }
+
+    public boolean containsKey(float f) {
+        return contains(f);
+    }
+
+    public boolean containsValue(V v) {
+        V[] vArr = this._values;
+        if (v != null) {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return false;
+                }
+                Object unwrapNull = unwrapNull(vArr[i]);
+                if (!isFull(vArr, i) || (v != unwrapNull && !v.equals(unwrapNull))) {
+                    length = i;
+                }
+            }
+            return true;
+        }
+        int length2 = vArr.length;
+        while (true) {
+            int i2 = length2 - 1;
+            if (length2 <= 0) {
+                return false;
+            }
+            if (TObjectHash.NULL == vArr[i2]) {
+                return true;
+            }
+            length2 = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TFloatObjectHashMap)) {
+            return false;
+        }
+        TFloatObjectHashMap tFloatObjectHashMap = (TFloatObjectHashMap) obj;
+        if (tFloatObjectHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tFloatObjectHashMap));
+    }
+
+    public boolean forEach(TFloatProcedure tFloatProcedure) {
+        float[] fArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tFloatProcedure.a(fArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachEntry(TFloatObjectProcedure<V> tFloatObjectProcedure) {
+        float[] fArr = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tFloatObjectProcedure.a(fArr[i], unwrapNull(vArr[i]))) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean forEachKey(TFloatProcedure tFloatProcedure) {
+        return forEach(tFloatProcedure);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachValue(TObjectProcedure<V> tObjectProcedure) {
+        V[] vArr = this._values;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (isFull(vArr, i) && !tObjectProcedure.execute(unwrapNull(vArr[i]))) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public V get(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return null;
+        }
+        return (V) unwrapNull(this._values[index]);
+    }
+
+    public Object[] getValues() {
+        Object[] objArr = new Object[size()];
+        V[] vArr = this._values;
+        int length = vArr.length;
+        int i = 0;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return objArr;
+            }
+            if (isFull(vArr, i2)) {
+                objArr[i] = unwrapNull(vArr[i2]);
+                i++;
+            }
+            length = i2;
+        }
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    protected int index(float f) {
+        float[] fArr = this._set;
+        V[] vArr = this._values;
+        if (vArr == THash.EMPTY_OBJECT_ARRAY) {
+            return -1;
+        }
+        int length = fArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(f) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (!isFree(vArr, i) && (isRemoved(vArr, i) || fArr[i] != f)) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (isFree(vArr, i) || (!isRemoved(vArr, i) && fArr[i] == f)) {
+                    break;
+                }
+            }
+        }
+        if (isFree(vArr, i)) {
+            return -1;
+        }
+        return i;
+    }
+
+    protected int insertionIndex(float f) {
+        if (this._values == THash.EMPTY_OBJECT_ARRAY) {
+            setUp(6);
+        }
+        V[] vArr = this._values;
+        float[] fArr = this._set;
+        int length = fArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(f) & Integer.MAX_VALUE;
+        int i = computeHashCode % length;
+        if (isFree(vArr, i)) {
+            return i;
+        }
+        if (!isFull(vArr, i) || fArr[i] != f) {
+            int i2 = (computeHashCode % (length - 2)) + 1;
+            int i3 = isRemoved(vArr, i) ? i : -1;
+            do {
+                i -= i2;
+                if (i < 0) {
+                    i += length;
+                }
+                if (i3 == -1 && isRemoved(vArr, i)) {
+                    i3 = i;
+                }
+                if (!isFull(vArr, i)) {
+                    break;
+                }
+            } while (fArr[i] != f);
+            if (isRemoved(vArr, i)) {
+                while (!isFree(vArr, i) && (isRemoved(vArr, i) || fArr[i] != f)) {
+                    i -= i2;
+                    if (i < 0) {
+                        i += length;
+                    }
+                }
+            }
+            if (!isFull(vArr, i)) {
+                return i3 == -1 ? i : i3;
+            }
+        }
+        return (-i) - 1;
+    }
+
+    public TFloatObjectIterator<V> iterator() {
+        return new TFloatObjectIterator<>(this);
+    }
+
+    public float[] keys() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._set;
+        V[] vArr = this._values;
+        int length = vArr.length;
+        int i = 0;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return fArr;
+            }
+            if (isFull(vArr, i2)) {
+                fArr[i] = fArr2[i2];
+                i++;
+            }
+            length = i2;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public V put(float f, V v) {
+        V v2;
+        int insertionIndex = insertionIndex(f);
+        boolean z = true;
+        boolean z2 = false;
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            v2 = unwrapNull(this._values[insertionIndex]);
+            z = false;
+        } else {
+            z2 = isFree(this._values, insertionIndex);
+            v2 = null;
+        }
+        this._set[insertionIndex] = f;
+        ((V[]) this._values)[insertionIndex] = wrapNull(v);
+        if (z) {
+            postInsertHook(z2);
+        }
+        return v2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        float[] fArr = this._set;
+        V[] vArr = this._values;
+        this._set = new float[i];
+        this._values = (V[]) new Object[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (isFull(vArr, i2)) {
+                float f = fArr[i2];
+                int insertionIndex = insertionIndex(f);
+                this._set[insertionIndex] = f;
+                this._values[insertionIndex] = vArr[i2];
+            }
+            capacity = i2;
+        }
+    }
+
+    public V remove(float f) {
+        int index = index(f);
+        if (index < 0) {
+            return null;
+        }
+        V v = (V) unwrapNull(this._values[index]);
+        removeAt(index);
+        return v;
+    }
+
+    @Override // gnu.trove.THash
+    protected void removeAt(int i) {
+        ((V[]) this._values)[i] = TObjectHash.REMOVED;
+        super.removeAt(i);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean retainEntries(TFloatObjectProcedure<V> tFloatObjectProcedure) {
+        float[] fArr = this._set;
+        V[] vArr = this._values;
+        stopCompactingOnRemove();
+        boolean z = false;
+        try {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return z;
+                }
+                if (isFull(vArr, i) && !tFloatObjectProcedure.a(fArr[i], unwrapNull(vArr[i]))) {
+                    removeAt(i);
+                    z = true;
+                }
+                length = i;
+            }
+        } finally {
+            startCompactingOnRemove(z);
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? (V[]) THash.EMPTY_OBJECT_ARRAY : (V[]) new Object[up];
+        this._set = i == -1 ? null : new float[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TFloatObjectProcedure<V>(this) { // from class: gnu.trove.TFloatObjectHashMap.1
+            @Override // gnu.trove.TFloatObjectProcedure
+            public boolean a(float f, V v) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(f);
+                sb.append('=');
+                StringBuilder sb3 = sb;
+                if (v == this) {
+                    v = (V) "(this Map)";
+                }
+                sb3.append(v);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public void transformValues(TObjectFunction<V, V> tObjectFunction) {
+        Object[] objArr = this._values;
+        int length = objArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (isFull(objArr, i)) {
+                objArr[i] = wrapNull(tObjectFunction.execute(unwrapNull(objArr[i])));
+            }
+            length = i;
+        }
+    }
+
+    private static final class EqProcedure<V> implements TFloatObjectProcedure<V> {
+        private final TFloatObjectHashMap<V> a;
+
+        EqProcedure(TFloatObjectHashMap<V> tFloatObjectHashMap) {
+            this.a = tFloatObjectHashMap;
+        }
+
+        @Override // gnu.trove.TFloatObjectProcedure
+        public final boolean a(float f, V v) {
+            return this.a.index(f) >= 0 && a(v, this.a.get(f));
+        }
+
+        private static boolean a(Object obj, Object obj2) {
+            return obj == obj2 || (obj != null && obj.equals(obj2));
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public TFloatObjectHashMap<V> clone() {
+        TFloatObjectHashMap<V> tFloatObjectHashMap = (TFloatObjectHashMap) super.clone();
+        V[] vArr = this._values;
+        V[] vArr2 = (V[]) THash.EMPTY_OBJECT_ARRAY;
+        if (vArr != vArr2) {
+            vArr2 = (V[]) ((Object[]) vArr.clone());
+        }
+        tFloatObjectHashMap._values = vArr2;
+        tFloatObjectHashMap._set = this._values == THash.EMPTY_OBJECT_ARRAY ? null : (float[]) this._set.clone();
+        return tFloatObjectHashMap;
+    }
+
+    public TFloatObjectHashMap(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TFloatObjectHashMap(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TFloatObjectHashMap(TFloatHashingStrategy tFloatHashingStrategy) {
+        this._hashingStrategy = tFloatHashingStrategy;
+    }
+
+    public TFloatObjectHashMap(int i, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tFloatHashingStrategy;
+    }
+
+    public TFloatObjectHashMap(int i, float f, TFloatHashingStrategy tFloatHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tFloatHashingStrategy;
+    }
+}

sources/gnu/trove/TFloatObjectIterator.java

@@ -0,0 +1,31 @@
+package gnu.trove;
+
+import java.util.ConcurrentModificationException;
+
+/* loaded from: classes2.dex */
+public class TFloatObjectIterator<V> extends TIterator {
+    private final TFloatObjectHashMap<V> d;
+
+    public TFloatObjectIterator(TFloatObjectHashMap<V> tFloatObjectHashMap) {
+        super(tFloatObjectHashMap);
+        this.d = tFloatObjectHashMap;
+    }
+
+    @Override // gnu.trove.TIterator
+    protected final int nextIndex() {
+        int i;
+        if (this.b != this.d.size()) {
+            throw new ConcurrentModificationException();
+        }
+        V[] vArr = this.d._values;
+        int i2 = this.c;
+        while (true) {
+            i = i2 - 1;
+            if (i2 <= 0 || TFloatObjectHashMap.isFull(vArr, i)) {
+                break;
+            }
+            i2 = i;
+        }
+        return i;
+    }
+}

sources/gnu/trove/TFloatObjectProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatObjectProcedure<V> {
+    boolean a(float f, V v);
+}

sources/gnu/trove/TFloatProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TFloatProcedure {
+    boolean a(float f);
+}

sources/gnu/trove/THash.java

@@ -0,0 +1,131 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public abstract class THash implements Cloneable {
+    protected static final int DEFAULT_INITIAL_CAPACITY = 4;
+    protected static final float DEFAULT_LOAD_FACTOR = 0.8f;
+    protected static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+    protected static final int JUST_CREATED_CAPACITY = -1;
+    protected transient int _deadkeys;
+    protected transient int _free;
+    protected final float _loadFactor;
+    protected int _maxSize;
+    protected transient int _size;
+
+    public THash() {
+        this(-1, DEFAULT_LOAD_FACTOR);
+    }
+
+    private void compactIfNecessary() {
+        if (this._deadkeys <= this._size || capacity() <= 42) {
+            return;
+        }
+        compact();
+    }
+
+    private void computeMaxSize(int i) {
+        this._maxSize = Math.max(0, Math.min(i - 1, (int) (i * this._loadFactor)));
+        this._free = i - this._size;
+        this._deadkeys = 0;
+    }
+
+    protected int calculateGrownCapacity() {
+        return capacity() << 1;
+    }
+
+    protected abstract int capacity();
+
+    public void clear() {
+        this._size = 0;
+        this._free = capacity();
+        this._deadkeys = 0;
+    }
+
+    public Object clone() {
+        try {
+            return super.clone();
+        } catch (CloneNotSupportedException unused) {
+            return null;
+        }
+    }
+
+    public void compact() {
+        rehash(PrimeFinder.a(((int) (size() / this._loadFactor)) + 2));
+        computeMaxSize(capacity());
+    }
+
+    public void ensureCapacity(int i) {
+        if (i > this._maxSize - size()) {
+            rehash(PrimeFinder.a(((int) (i + (size() / this._loadFactor))) + 2));
+            computeMaxSize(capacity());
+        }
+    }
+
+    public boolean isEmpty() {
+        return this._size == 0;
+    }
+
+    protected final void postInsertHook(boolean z) {
+        if (z) {
+            this._free--;
+        } else {
+            this._deadkeys--;
+        }
+        int i = this._size + 1;
+        this._size = i;
+        if (i > this._maxSize || this._free == 0) {
+            rehash(PrimeFinder.a(calculateGrownCapacity()));
+            computeMaxSize(capacity());
+        }
+    }
+
+    protected abstract void rehash(int i);
+
+    protected void removeAt(int i) {
+        this._size--;
+        this._deadkeys++;
+        compactIfNecessary();
+    }
+
+    protected int setUp(int i) {
+        int a = i == -1 ? 0 : PrimeFinder.a(i);
+        computeMaxSize(a);
+        return a;
+    }
+
+    public int size() {
+        return this._size;
+    }
+
+    public final void startCompactingOnRemove(boolean z) {
+        int i = this._deadkeys;
+        if (i > 0) {
+            throw new IllegalStateException("Unpaired stop/startCompactingOnRemove");
+        }
+        this._deadkeys = i + capacity();
+        if (z) {
+            compactIfNecessary();
+        }
+    }
+
+    public final void stopCompactingOnRemove() {
+        int i = this._deadkeys;
+        if (i < 0) {
+            throw new IllegalStateException("Unpaired stop/startCompactingOnRemove");
+        }
+        this._deadkeys = i - capacity();
+    }
+
+    public final void trimToSize() {
+        compact();
+    }
+
+    public THash(int i) {
+        this(i, DEFAULT_LOAD_FACTOR);
+    }
+
+    public THash(int i, float f) {
+        this._loadFactor = f;
+        setUp(i != -1 ? ((int) (i / f)) + 1 : -1);
+    }
+}

sources/gnu/trove/THashIterator.java

@@ -0,0 +1,40 @@
+package gnu.trove;
+
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+abstract class THashIterator<V> extends TIterator implements Iterator<V> {
+    protected final TObjectHash d;
+
+    public THashIterator(TObjectHash tObjectHash) {
+        super(tObjectHash);
+        this.d = tObjectHash;
+    }
+
+    protected abstract V a(int i);
+
+    @Override // java.util.Iterator
+    public V next() {
+        a();
+        return a(this.c);
+    }
+
+    @Override // gnu.trove.TIterator
+    protected final int nextIndex() {
+        int i;
+        if (this.b != this.d.size()) {
+            throw new ConcurrentModificationException();
+        }
+        Object[] objArr = this.d._set;
+        int i2 = this.c;
+        while (true) {
+            i = i2 - 1;
+            if (i2 <= 0 || !(objArr[i] == null || objArr[i] == TObjectHash.REMOVED)) {
+                break;
+            }
+            i2 = i;
+        }
+        return i;
+    }
+}

sources/gnu/trove/THashMap.java

@@ -0,0 +1,663 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public class THashMap<K, V> extends TObjectHash<K> implements Map<K, V> {
+    protected transient V[] _values;
+
+    final class Entry implements Map.Entry<K, V> {
+        private final K a;
+        private V b;
+        private final int c;
+
+        Entry(K k, V v, int i) {
+            this.a = k;
+            this.b = v;
+            this.c = i;
+        }
+
+        @Override // java.util.Map.Entry
+        public K getKey() {
+            return this.a;
+        }
+
+        @Override // java.util.Map.Entry
+        public V getValue() {
+            return this.b;
+        }
+
+        @Override // java.util.Map.Entry
+        public V setValue(V v) {
+            V[] vArr = THashMap.this._values;
+            int i = this.c;
+            V v2 = vArr[i];
+            V v3 = this.b;
+            if (v2 != v3) {
+                throw new ConcurrentModificationException();
+            }
+            vArr[i] = v;
+            this.b = v;
+            return v3;
+        }
+    }
+
+    protected class EntryView extends THashMap<K, V>.MapBackedView<Map.Entry<K, V>> {
+
+        private final class EntryIterator extends THashIterator<Map.Entry<K, V>> {
+            EntryIterator(THashMap<K, V> tHashMap) {
+                super(tHashMap);
+            }
+
+            @Override // gnu.trove.THashIterator
+            public THashMap<K, V>.Entry a(int i) {
+                THashMap tHashMap = THashMap.this;
+                return new Entry(tHashMap._set[i], tHashMap._values[i], i);
+            }
+        }
+
+        EntryView() {
+            super();
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView
+        /* renamed from: c, reason: merged with bridge method [inline-methods] */
+        public boolean b(Map.Entry<K, V> entry) {
+            int index = THashMap.this.index(b((Map.Entry) entry));
+            if (index < 0) {
+                return false;
+            }
+            Object d = d(entry);
+            V[] vArr = THashMap.this._values;
+            if (d != vArr[index] && (d == null || !d.equals(vArr[index]))) {
+                return false;
+            }
+            THashMap.this.removeAt(index);
+            return true;
+        }
+
+        protected V d(Map.Entry<K, V> entry) {
+            return entry.getValue();
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView, java.util.Set, java.util.Collection, java.lang.Iterable
+        public Iterator<Map.Entry<K, V>> iterator() {
+            return new EntryIterator(THashMap.this);
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView
+        public boolean a(Map.Entry<K, V> entry) {
+            Object obj = THashMap.this.get(b((Map.Entry) entry));
+            V value = entry.getValue();
+            return value == obj || (obj != null && obj.equals(value));
+        }
+
+        protected K b(Map.Entry<K, V> entry) {
+            return entry.getKey();
+        }
+    }
+
+    private static final class EqProcedure<K, V> implements TObjectObjectProcedure<K, V> {
+        private final Map<K, V> a;
+
+        EqProcedure(Map<K, V> map) {
+            this.a = map;
+        }
+
+        @Override // gnu.trove.TObjectObjectProcedure
+        public final boolean a(K k, V v) {
+            V v2 = this.a.get(k);
+            return v2 == v || (v2 != null && v2.equals(v));
+        }
+    }
+
+    private final class HashProcedure implements TObjectObjectProcedure<K, V> {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TObjectObjectProcedure
+        public final boolean a(K k, V v) {
+            this.a += THashMap.this._hashingStrategy.computeHashCode(k) ^ (v == null ? 0 : v.hashCode());
+            return true;
+        }
+    }
+
+    protected class KeyView extends THashMap<K, V>.MapBackedView<K> {
+        KeyView() {
+            super();
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView
+        public boolean a(K k) {
+            return THashMap.this.contains(k);
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView
+        public boolean b(K k) {
+            return THashMap.this.remove(k) != null;
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView, java.util.Set, java.util.Collection, java.lang.Iterable
+        public Iterator<K> iterator() {
+            return new TObjectHashIterator(THashMap.this);
+        }
+    }
+
+    protected class ValueView extends THashMap<K, V>.MapBackedView<V> {
+        protected ValueView() {
+            super();
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView
+        public boolean a(V v) {
+            return THashMap.this.containsValue(v);
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView
+        public boolean b(V v) {
+            THashMap tHashMap = THashMap.this;
+            V[] vArr = tHashMap._values;
+            Object[] objArr = tHashMap._set;
+            int length = vArr.length;
+            boolean z = false;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return z;
+                }
+                if ((objArr[i] != null && objArr[i] != TObjectHash.REMOVED && v == vArr[i]) || (vArr[i] != null && vArr[i].equals(v))) {
+                    THashMap.this.removeAt(i);
+                    z = true;
+                }
+                length = i;
+            }
+        }
+
+        @Override // gnu.trove.THashMap.MapBackedView, java.util.Set, java.util.Collection, java.lang.Iterable
+        public Iterator<V> iterator() {
+            return new THashIterator<V>(THashMap.this) { // from class: gnu.trove.THashMap.ValueView.1
+                @Override // gnu.trove.THashIterator
+                protected V a(int i) {
+                    return THashMap.this._values[i];
+                }
+            };
+        }
+    }
+
+    public THashMap() {
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readObject(), objectInputStream.readObject());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        if (size() == 0) {
+            return;
+        }
+        super.clear();
+        Object[] objArr = this._set;
+        V[] vArr = this._values;
+        int length = objArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            objArr[i] = null;
+            vArr[i] = null;
+            length = i;
+        }
+    }
+
+    @Override // java.util.Map
+    public boolean containsKey(Object obj) {
+        return contains(obj);
+    }
+
+    @Override // java.util.Map
+    public boolean containsValue(Object obj) {
+        Object[] objArr = this._set;
+        V[] vArr = this._values;
+        if (obj != null) {
+            int length = vArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return false;
+                }
+                if (objArr[i] == null || objArr[i] == TObjectHash.REMOVED || (obj != vArr[i] && !obj.equals(vArr[i]))) {
+                    length = i;
+                }
+            }
+            return true;
+        }
+        int length2 = vArr.length;
+        while (true) {
+            int i2 = length2 - 1;
+            if (length2 <= 0) {
+                return false;
+            }
+            if (objArr[i2] != null && objArr[i2] != TObjectHash.REMOVED && obj == vArr[i2]) {
+                return true;
+            }
+            length2 = i2;
+        }
+    }
+
+    @Override // java.util.Map
+    public Set<Map.Entry<K, V>> entrySet() {
+        return new EntryView();
+    }
+
+    @Override // java.util.Map
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Map)) {
+            return false;
+        }
+        Map map = (Map) obj;
+        if (map.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(map));
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachEntry(TObjectObjectProcedure<K, V> tObjectObjectProcedure) {
+        Object[] objArr = this._set;
+        V[] vArr = this._values;
+        int length = objArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED && !tObjectObjectProcedure.a(objArr[i], vArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean forEachKey(TObjectProcedure<K> tObjectProcedure) {
+        return forEach(tObjectProcedure);
+    }
+
+    public boolean forEachValue(TObjectProcedure<V> tObjectProcedure) {
+        V[] vArr = this._values;
+        Object[] objArr = this._set;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED && !tObjectProcedure.execute(vArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    @Override // java.util.Map
+    public V get(Object obj) {
+        int index = index(obj);
+        if (index < 0) {
+            return null;
+        }
+        return this._values[index];
+    }
+
+    @Override // java.util.Map
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    @Override // java.util.Map
+    public Set<K> keySet() {
+        return new KeyView();
+    }
+
+    @Override // java.util.Map
+    public V put(K k, V v) {
+        if (k == null) {
+            throw new NullPointerException("null keys not supported");
+        }
+        V v2 = null;
+        int insertionIndex = insertionIndex(k);
+        boolean z = insertionIndex < 0;
+        if (z) {
+            insertionIndex = (-insertionIndex) - 1;
+            v2 = this._values[insertionIndex];
+        }
+        Object[] objArr = this._set;
+        Object obj = objArr[insertionIndex];
+        objArr[insertionIndex] = k;
+        this._values[insertionIndex] = v;
+        if (!z) {
+            postInsertHook(obj == null);
+        }
+        return v2;
+    }
+
+    @Override // java.util.Map
+    public void putAll(Map<? extends K, ? extends V> map) {
+        ensureCapacity(map.size());
+        for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        Object[] objArr = this._set;
+        int length = objArr.length;
+        V[] vArr = this._values;
+        this._set = new Object[i];
+        this._values = (V[]) new Object[i];
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (objArr[i2] != null && objArr[i2] != TObjectHash.REMOVED) {
+                Object obj = objArr[i2];
+                int insertionIndex = insertionIndex(obj);
+                if (insertionIndex < 0) {
+                    throwObjectContractViolation(this._set[(-insertionIndex) - 1], obj);
+                }
+                this._set[insertionIndex] = obj;
+                this._values[insertionIndex] = vArr[i2];
+            }
+            length = i2;
+        }
+    }
+
+    @Override // java.util.Map
+    public V remove(Object obj) {
+        int index = index(obj);
+        if (index < 0) {
+            return null;
+        }
+        V v = this._values[index];
+        removeAt(index);
+        return v;
+    }
+
+    @Override // gnu.trove.TObjectHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = null;
+        super.removeAt(i);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public boolean retainEntries(TObjectObjectProcedure<K, V> tObjectObjectProcedure) {
+        Object[] objArr = this._set;
+        V[] vArr = this._values;
+        stopCompactingOnRemove();
+        boolean z = false;
+        try {
+            int length = objArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    return z;
+                }
+                if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED && !tObjectObjectProcedure.a(objArr[i], vArr[i])) {
+                    removeAt(i);
+                    z = true;
+                }
+                length = i;
+            }
+        } finally {
+            startCompactingOnRemove(z);
+        }
+    }
+
+    @Override // gnu.trove.TObjectHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? (V[]) THash.EMPTY_OBJECT_ARRAY : (V[]) new Object[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TObjectObjectProcedure<K, V>(this) { // from class: gnu.trove.THashMap.1
+            @Override // gnu.trove.TObjectObjectProcedure
+            public boolean a(K k, V v) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                StringBuilder sb3 = sb;
+                if (k == this) {
+                    k = (K) "(this Map)";
+                }
+                sb3.append(k);
+                sb.append('=');
+                StringBuilder sb4 = sb;
+                if (v == this) {
+                    v = (V) "(this Map)";
+                }
+                sb4.append(v);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TObjectFunction<V, V> tObjectFunction) {
+        V[] vArr = this._values;
+        Object[] objArr = this._set;
+        int length = vArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (objArr[i] != null && objArr[i] != TObjectHash.REMOVED) {
+                vArr[i] = tObjectFunction.execute(vArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    @Override // java.util.Map
+    public Collection<V> values() {
+        return new ValueView();
+    }
+
+    public THashMap(TObjectHashingStrategy<K> tObjectHashingStrategy) {
+        super(tObjectHashingStrategy);
+    }
+
+    public THashMap(int i) {
+        super(i);
+    }
+
+    @Override // gnu.trove.TObjectHash, gnu.trove.THash
+    public THashMap<K, V> clone() {
+        THashMap<K, V> tHashMap = (THashMap) super.clone();
+        tHashMap._values = (V[]) ((Object[]) this._values.clone());
+        return tHashMap;
+    }
+
+    private abstract class MapBackedView<E> implements Set<E> {
+        MapBackedView() {
+        }
+
+        public abstract boolean a(E e);
+
+        @Override // java.util.Set, java.util.Collection
+        public boolean add(E e) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public boolean addAll(Collection<? extends E> collection) {
+            throw new UnsupportedOperationException();
+        }
+
+        public abstract boolean b(E e);
+
+        @Override // java.util.Set, java.util.Collection
+        public void clear() {
+            THashMap.this.clear();
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // java.util.Set, java.util.Collection
+        public boolean contains(Object obj) {
+            return a(obj);
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public boolean containsAll(Collection<?> collection) {
+            Iterator<?> it = collection.iterator();
+            while (it.hasNext()) {
+                if (!contains(it.next())) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public boolean isEmpty() {
+            return THashMap.this.isEmpty();
+        }
+
+        @Override // java.util.Set, java.util.Collection, java.lang.Iterable
+        public abstract Iterator<E> iterator();
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // java.util.Set, java.util.Collection
+        public boolean remove(Object obj) {
+            return b(obj);
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public boolean removeAll(Collection<?> collection) {
+            Iterator<?> it = collection.iterator();
+            boolean z = false;
+            while (it.hasNext()) {
+                if (remove(it.next())) {
+                    z = true;
+                }
+            }
+            return z;
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public boolean retainAll(Collection<?> collection) {
+            Iterator<E> it = iterator();
+            boolean z = false;
+            while (it.hasNext()) {
+                if (!collection.contains(it.next())) {
+                    it.remove();
+                    z = true;
+                }
+            }
+            return z;
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public int size() {
+            return THashMap.this.size();
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public Object[] toArray() {
+            Object[] objArr = new Object[size()];
+            Iterator<E> it = iterator();
+            int i = 0;
+            while (it.hasNext()) {
+                objArr[i] = it.next();
+                i++;
+            }
+            return objArr;
+        }
+
+        @Override // java.util.Set, java.util.Collection
+        public <T> T[] toArray(T[] tArr) {
+            int size = size();
+            if (tArr.length < size) {
+                tArr = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), size));
+            }
+            Iterator<E> it = iterator();
+            for (int i = 0; i < size; i++) {
+                tArr[i] = it.next();
+            }
+            if (tArr.length > size) {
+                tArr[size] = null;
+            }
+            return tArr;
+        }
+    }
+
+    public THashMap(int i, TObjectHashingStrategy<K> tObjectHashingStrategy) {
+        super(i, tObjectHashingStrategy);
+    }
+
+    public THashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public THashMap(int i, float f, TObjectHashingStrategy<K> tObjectHashingStrategy) {
+        super(i, f, tObjectHashingStrategy);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public THashMap(Map<K, V> map) {
+        this(map.size());
+        putAll(map);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public THashMap(Map<K, V> map, TObjectHashingStrategy<K> tObjectHashingStrategy) {
+        this(map.size(), tObjectHashingStrategy);
+        putAll(map);
+    }
+}

sources/gnu/trove/THashSet.java

@@ -0,0 +1,281 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public class THashSet<E> extends TObjectHash<E> implements Set<E> {
+
+    private final class HashProcedure implements TObjectProcedure<E> {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TObjectProcedure
+        public final boolean execute(E e) {
+            this.a += THashSet.this._hashingStrategy.computeHashCode(e);
+            return true;
+        }
+    }
+
+    public THashSet() {
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readObject());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean add(E e) {
+        int insertionIndex = insertionIndex(e);
+        if (insertionIndex < 0) {
+            return false;
+        }
+        Object[] objArr = this._set;
+        Object obj = objArr[insertionIndex];
+        objArr[insertionIndex] = e;
+        postInsertHook(obj == null);
+        return true;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean addAll(Collection<? extends E> collection) {
+        int size = collection.size();
+        ensureCapacity(size);
+        Iterator<? extends E> it = collection.iterator();
+        boolean z = false;
+        while (true) {
+            int i = size - 1;
+            if (size <= 0) {
+                return z;
+            }
+            if (add(it.next())) {
+                z = true;
+            }
+            size = i;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        Object[] objArr = this._set;
+        int length = objArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            objArr[i] = null;
+            length = i;
+        }
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean containsAll(Collection<?> collection) {
+        Iterator<?> it = collection.iterator();
+        while (it.hasNext()) {
+            if (!contains(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Set)) {
+            return false;
+        }
+        Set set = (Set) obj;
+        if (set.size() != size()) {
+            return false;
+        }
+        return containsAll(set);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEach(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    @Override // java.util.Set, java.util.Collection, java.lang.Iterable
+    public Iterator<E> iterator() {
+        return new TObjectHashIterator(this);
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        Object[] objArr = this._set;
+        this._set = new Object[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (objArr[i2] != null && objArr[i2] != TObjectHash.REMOVED) {
+                Object obj = objArr[i2];
+                int insertionIndex = insertionIndex(obj);
+                if (insertionIndex < 0) {
+                    throwObjectContractViolation(this._set[(-insertionIndex) - 1], obj);
+                }
+                this._set[insertionIndex] = obj;
+            }
+            capacity = i2;
+        }
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean remove(Object obj) {
+        int index = index(obj);
+        if (index < 0) {
+            return false;
+        }
+        removeAt(index);
+        return true;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean removeAll(Collection<?> collection) {
+        int size = collection.size();
+        Iterator<?> it = collection.iterator();
+        boolean z = false;
+        while (true) {
+            int i = size - 1;
+            if (size <= 0) {
+                return z;
+            }
+            if (remove(it.next())) {
+                z = true;
+            }
+            size = i;
+        }
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public boolean retainAll(Collection<?> collection) {
+        int size = size();
+        Iterator<E> it = iterator();
+        boolean z = false;
+        while (true) {
+            int i = size - 1;
+            if (size <= 0) {
+                return z;
+            }
+            if (!collection.contains(it.next())) {
+                it.remove();
+                z = true;
+            }
+            size = i;
+        }
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public Object[] toArray() {
+        Object[] objArr = new Object[size()];
+        forEach(new ToObjectArrayProcedure(objArr));
+        return objArr;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEach(new TObjectProcedure<E>(this) { // from class: gnu.trove.THashSet.1
+            @Override // gnu.trove.TObjectProcedure
+            public boolean execute(E e) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                StringBuilder sb3 = sb;
+                if (e == this) {
+                    e = (E) "(this set)";
+                }
+                sb3.append(e);
+                return true;
+            }
+        });
+        sb.append(']');
+        sb.insert(0, '[');
+        return sb.toString();
+    }
+
+    public THashSet(TObjectHashingStrategy<E> tObjectHashingStrategy) {
+        super(tObjectHashingStrategy);
+    }
+
+    public THashSet(int i) {
+        super(i);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public <T> T[] toArray(T[] tArr) {
+        int size = size();
+        if (tArr.length < size) {
+            tArr = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), size));
+        }
+        Iterator<E> it = iterator();
+        for (int i = 0; i < size; i++) {
+            tArr[i] = it.next();
+        }
+        if (tArr.length > size) {
+            tArr[size] = null;
+        }
+        return tArr;
+    }
+
+    public THashSet(int i, TObjectHashingStrategy<E> tObjectHashingStrategy) {
+        super(i, tObjectHashingStrategy);
+    }
+
+    public THashSet(int i, float f) {
+        super(i, f);
+    }
+
+    public THashSet(int i, float f, TObjectHashingStrategy<E> tObjectHashingStrategy) {
+        super(i, f, tObjectHashingStrategy);
+    }
+
+    public THashSet(Collection<? extends E> collection) {
+        this(collection.size());
+        addAll(collection);
+    }
+
+    public THashSet(Collection<? extends E> collection, TObjectHashingStrategy<E> tObjectHashingStrategy) {
+        this(collection.size(), tObjectHashingStrategy);
+        addAll(collection);
+    }
+}

sources/gnu/trove/TIntArrayList.java

@@ -0,0 +1,530 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Random;
+
+/* loaded from: classes2.dex */
+public class TIntArrayList implements Serializable, Cloneable {
+    protected static final int DEFAULT_CAPACITY = 4;
+    protected transient int[] _data;
+    protected transient int _pos;
+
+    public TIntArrayList() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        this._data = new int[readInt];
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readInt());
+            readInt = i;
+        }
+    }
+
+    private void swap(int i, int i2) {
+        int[] iArr = this._data;
+        int i3 = iArr[i];
+        iArr[i] = iArr[i2];
+        iArr[i2] = i3;
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(size());
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public void add(int i) {
+        ensureCapacity(this._pos + 1);
+        int[] iArr = this._data;
+        int i2 = this._pos;
+        this._pos = i2 + 1;
+        iArr[i2] = i;
+    }
+
+    public int binarySearch(int i) {
+        return binarySearch(i, 0, this._pos);
+    }
+
+    public void clear() {
+        this._data = null;
+        this._pos = 0;
+    }
+
+    public Object clone() {
+        int[] iArr = null;
+        try {
+            TIntArrayList tIntArrayList = (TIntArrayList) super.clone();
+            try {
+                if (this._data != null) {
+                    iArr = (int[]) this._data.clone();
+                }
+                tIntArrayList._data = iArr;
+                return tIntArrayList;
+            } catch (CloneNotSupportedException unused) {
+                return tIntArrayList;
+            }
+        } catch (CloneNotSupportedException unused2) {
+            return null;
+        }
+    }
+
+    public boolean contains(int i) {
+        return lastIndexOf(i) >= 0;
+    }
+
+    public void ensureCapacity(int i) {
+        if (this._data == null) {
+            this._data = new int[Math.max(4, i)];
+        }
+        int[] iArr = this._data;
+        if (i > iArr.length) {
+            int[] iArr2 = new int[Math.max(iArr.length << 1, i)];
+            int[] iArr3 = this._data;
+            System.arraycopy(iArr3, 0, iArr2, 0, iArr3.length);
+            this._data = iArr2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof TIntArrayList)) {
+            return false;
+        }
+        TIntArrayList tIntArrayList = (TIntArrayList) obj;
+        if (tIntArrayList.size() != size()) {
+            return false;
+        }
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (this._data[i2] != tIntArrayList._data[i2]) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public void fill(int i) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, 0, this._pos, i);
+    }
+
+    public boolean forEach(TIntProcedure tIntProcedure) {
+        for (int i = 0; i < this._pos; i++) {
+            if (!tIntProcedure.a(this._data[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachDescending(TIntProcedure tIntProcedure) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return true;
+            }
+            if (!tIntProcedure.a(this._data[i2])) {
+                return false;
+            }
+            i = i2;
+        }
+    }
+
+    public int get(int i) {
+        if (i < this._pos) {
+            return this._data[i];
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public int getQuick(int i) {
+        return this._data[i];
+    }
+
+    public int getSet(int i, int i2) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        int[] iArr = this._data;
+        int i3 = iArr[i];
+        iArr[i] = i2;
+        return i3;
+    }
+
+    public TIntArrayList grep(TIntProcedure tIntProcedure) {
+        TIntArrayList tIntArrayList = new TIntArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (tIntProcedure.a(this._data[i])) {
+                tIntArrayList.add(this._data[i]);
+            }
+        }
+        return tIntArrayList;
+    }
+
+    public int hashCode() {
+        int i = this._pos;
+        int i2 = 0;
+        while (true) {
+            int i3 = i - 1;
+            if (i <= 0) {
+                return i2;
+            }
+            int i4 = this._data[i3];
+            HashFunctions.a(i4);
+            i2 += i4;
+            i = i3;
+        }
+    }
+
+    public int indexOf(int i) {
+        return indexOf(0, i);
+    }
+
+    public void insert(int i, int i2) {
+        int i3 = this._pos;
+        if (i == i3) {
+            add(i2);
+            return;
+        }
+        ensureCapacity(i3 + 1);
+        int[] iArr = this._data;
+        System.arraycopy(iArr, i, iArr, i + 1, this._pos - i);
+        this._data[i] = i2;
+        this._pos++;
+    }
+
+    public TIntArrayList inverseGrep(TIntProcedure tIntProcedure) {
+        TIntArrayList tIntArrayList = new TIntArrayList();
+        for (int i = 0; i < this._pos; i++) {
+            if (!tIntProcedure.a(this._data[i])) {
+                tIntArrayList.add(this._data[i]);
+            }
+        }
+        return tIntArrayList;
+    }
+
+    public boolean isEmpty() {
+        return this._pos == 0;
+    }
+
+    public int lastIndexOf(int i) {
+        return lastIndexOf(this._pos, i);
+    }
+
+    public int max() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find maximum of an empty list");
+        }
+        int[] iArr = this._data;
+        int i = this._pos;
+        int i2 = iArr[i - 1];
+        int i3 = i - 1;
+        while (true) {
+            int i4 = i3 - 1;
+            if (i3 <= 0) {
+                return i2;
+            }
+            i2 = Math.max(i2, this._data[this._pos]);
+            i3 = i4;
+        }
+    }
+
+    public int min() {
+        if (size() == 0) {
+            throw new IllegalStateException("cannot find minimum of an empty list");
+        }
+        int[] iArr = this._data;
+        int i = this._pos;
+        int i2 = iArr[i - 1];
+        int i3 = i - 1;
+        while (true) {
+            int i4 = i3 - 1;
+            if (i3 <= 0) {
+                return i2;
+            }
+            i2 = Math.min(i2, this._data[this._pos]);
+            i3 = i4;
+        }
+    }
+
+    public int remove(int i) {
+        int i2 = get(i);
+        remove(i, 1);
+        return i2;
+    }
+
+    public void reset() {
+        fill(0);
+        this._pos = 0;
+    }
+
+    public void resetQuick() {
+        this._pos = 0;
+    }
+
+    public void reverse() {
+        reverse(0, this._pos);
+    }
+
+    public void set(int i, int i2) {
+        if (i < 0 || i >= this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i);
+        }
+        this._data[i] = i2;
+    }
+
+    public void setQuick(int i, int i2) {
+        this._data[i] = i2;
+    }
+
+    public void shuffle(Random random) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 1) {
+                return;
+            }
+            swap(i2, random.nextInt(i2));
+            i = i2;
+        }
+    }
+
+    public int size() {
+        return this._pos;
+    }
+
+    public void sort() {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, 0, this._pos);
+    }
+
+    public int[] toNativeArray() {
+        return toNativeArray(0, this._pos);
+    }
+
+    public String toString() {
+        final StringBuffer stringBuffer = new StringBuffer("{");
+        forEach(new TIntProcedure(this) { // from class: gnu.trove.TIntArrayList.1
+            @Override // gnu.trove.TIntProcedure
+            public boolean a(int i) {
+                stringBuffer.append(i);
+                stringBuffer.append(", ");
+                return true;
+            }
+        });
+        stringBuffer.append("}");
+        return stringBuffer.toString();
+    }
+
+    public void transformValues(TIntFunction tIntFunction) {
+        int i = this._pos;
+        while (true) {
+            int i2 = i - 1;
+            if (i <= 0) {
+                return;
+            }
+            int[] iArr = this._data;
+            iArr[i2] = tIntFunction.a(iArr[i2]);
+            i = i2;
+        }
+    }
+
+    public void trimToSize() {
+        int[] iArr = this._data;
+        if (iArr == null || iArr.length <= size()) {
+            return;
+        }
+        int[] iArr2 = new int[size()];
+        toNativeArray(iArr2, 0, iArr2.length);
+        this._data = iArr2;
+    }
+
+    public TIntArrayList(int i) {
+        this._data = new int[i];
+        this._pos = 0;
+    }
+
+    public int binarySearch(int i, int i2, int i3) {
+        if (i2 < 0) {
+            throw new ArrayIndexOutOfBoundsException(i2);
+        }
+        if (i3 > this._pos) {
+            throw new ArrayIndexOutOfBoundsException(i3);
+        }
+        int i4 = i3 - 1;
+        while (i2 <= i4) {
+            int i5 = (i2 + i4) >> 1;
+            int i6 = this._data[i5];
+            if (i6 < i) {
+                i2 = i5 + 1;
+            } else {
+                if (i6 <= i) {
+                    return i5;
+                }
+                i4 = i5 - 1;
+            }
+        }
+        return -(i2 + 1);
+    }
+
+    public void fill(int i, int i2, int i3) {
+        if (i2 > this._pos) {
+            ensureCapacity(i2);
+            this._pos = i2;
+        }
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.fill(this._data, i, i2, i3);
+    }
+
+    public int indexOf(int i, int i2) {
+        while (i < this._pos) {
+            if (this._data[i] == i2) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public int lastIndexOf(int i, int i2) {
+        while (true) {
+            int i3 = i - 1;
+            if (i <= 0) {
+                return -1;
+            }
+            if (this._data[i3] == i2) {
+                return i3;
+            }
+            i = i3;
+        }
+    }
+
+    public void reverse(int i, int i2) {
+        if (i == i2) {
+            return;
+        }
+        if (i > i2) {
+            throw new IllegalArgumentException("from cannot be greater than to");
+        }
+        for (int i3 = i2 - 1; i < i3; i3--) {
+            swap(i, i3);
+            i++;
+        }
+    }
+
+    public void sort(int i, int i2) {
+        if (isEmpty()) {
+            return;
+        }
+        Arrays.sort(this._data, i, i2);
+    }
+
+    public int[] toNativeArray(int i, int i2) {
+        int[] iArr = new int[i2];
+        toNativeArray(iArr, i, i2);
+        return iArr;
+    }
+
+    public void add(int[] iArr) {
+        add(iArr, 0, iArr.length);
+    }
+
+    public void clear(int i) {
+        this._data = new int[i];
+        this._pos = 0;
+    }
+
+    public void remove(int i, int i2) {
+        int i3;
+        if (i >= 0 && i < (i3 = this._pos)) {
+            if (i == 0) {
+                int[] iArr = this._data;
+                System.arraycopy(iArr, i2, iArr, 0, i3 - i2);
+            } else if (i3 - i2 != i) {
+                int[] iArr2 = this._data;
+                int i4 = i + i2;
+                System.arraycopy(iArr2, i4, iArr2, i, i3 - i4);
+            }
+            this._pos -= i2;
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void add(int[] iArr, int i, int i2) {
+        ensureCapacity(this._pos + i2);
+        System.arraycopy(iArr, i, this._data, this._pos, i2);
+        this._pos += i2;
+    }
+
+    public void set(int i, int[] iArr) {
+        set(i, iArr, 0, iArr.length);
+    }
+
+    public void toNativeArray(int[] iArr, int i, int i2) {
+        if (i2 == 0) {
+            return;
+        }
+        if (i >= 0 && i < this._pos) {
+            System.arraycopy(this._data, i, iArr, 0, i2);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public TIntArrayList(int[] iArr) {
+        this(Math.max(iArr.length, 4));
+        add(iArr);
+    }
+
+    public void set(int i, int[] iArr, int i2, int i3) {
+        if (i >= 0 && i + i3 <= this._pos) {
+            System.arraycopy(this._data, i, iArr, i2, i3);
+            return;
+        }
+        throw new ArrayIndexOutOfBoundsException(i);
+    }
+
+    public void insert(int i, int[] iArr) {
+        insert(i, iArr, 0, iArr.length);
+    }
+
+    public void insert(int i, int[] iArr, int i2, int i3) {
+        int i4 = this._pos;
+        if (i == i4) {
+            add(iArr, i2, i3);
+            return;
+        }
+        ensureCapacity(i4 + i3);
+        int[] iArr2 = this._data;
+        System.arraycopy(iArr2, i, iArr2, i + i3, this._pos - i);
+        System.arraycopy(iArr, i2, this._data, i, i3);
+        this._pos += i3;
+    }
+}

sources/gnu/trove/TIntByteHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TIntByteHashMap extends TIntHash {
+    protected transient byte[] _values;
+
+    private static final class EqProcedure implements TIntByteProcedure {
+        private final TIntByteHashMap a;
+
+        EqProcedure(TIntByteHashMap tIntByteHashMap) {
+            this.a = tIntByteHashMap;
+        }
+
+        private static boolean a(byte b, byte b2) {
+            return b == b2;
+        }
+
+        @Override // gnu.trove.TIntByteProcedure
+        public final boolean a(int i, byte b) {
+            return this.a.index(i) >= 0 && a(b, this.a.get(i));
+        }
+    }
+
+    private final class HashProcedure implements TIntByteProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TIntByteProcedure
+        public final boolean a(int i, byte b) {
+            int i2 = this.a;
+            int computeHashCode = TIntByteHashMap.this._hashingStrategy.computeHashCode(i);
+            HashFunctions.a((int) b);
+            this.a = i2 + (computeHashCode ^ b);
+            return true;
+        }
+    }
+
+    public TIntByteHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readInt(), objectInputStream.readByte());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(int i, byte b) {
+        int index = index(i);
+        if (index < 0) {
+            return false;
+        }
+        byte[] bArr = this._values;
+        bArr[index] = (byte) (bArr[index] + b);
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        int[] iArr = this._set;
+        byte[] bArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        byte[] bArr2 = this._states;
+        int length = iArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            iArr[i] = 0;
+            bArr[i] = 0;
+            bArr2[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TIntByteHashMap tIntByteHashMap = (TIntByteHashMap) super.clone();
+        byte[] bArr = this._values;
+        tIntByteHashMap._values = bArr == null ? null : (byte[]) bArr.clone();
+        return tIntByteHashMap;
+    }
+
+    public boolean containsKey(int i) {
+        return contains(i);
+    }
+
+    public boolean containsValue(byte b) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && b == bArr2[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TIntByteHashMap)) {
+            return false;
+        }
+        TIntByteHashMap tIntByteHashMap = (TIntByteHashMap) obj;
+        if (tIntByteHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tIntByteHashMap));
+    }
+
+    public boolean forEachEntry(TIntByteProcedure tIntByteProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntByteProcedure.a(iArr[i], bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TIntProcedure tIntProcedure) {
+        return forEach(tIntProcedure);
+    }
+
+    public boolean forEachValue(TByteProcedure tByteProcedure) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tByteProcedure.a(bArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public byte get(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        return this._values[index];
+    }
+
+    public byte[] getValues() {
+        byte[] bArr = new byte[size()];
+        byte[] bArr2 = this._values;
+        byte[] bArr3 = this._states;
+        if (bArr3 != null) {
+            int length = bArr3.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr3[i2] == 1) {
+                    bArr[i] = bArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return bArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(int i) {
+        return adjustValue(i, (byte) 1);
+    }
+
+    public TIntByteIterator iterator() {
+        return new TIntByteIterator(this);
+    }
+
+    public int[] keys() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public byte put(int i, byte b) {
+        boolean z;
+        byte b2;
+        int insertionIndex = insertionIndex(i);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            b2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            b2 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b3 = bArr[insertionIndex];
+        this._set[insertionIndex] = i;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = b;
+        if (z) {
+            postInsertHook(b3 == 0);
+        }
+        return b2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        int[] iArr = this._set;
+        byte[] bArr = this._values;
+        byte[] bArr2 = this._states;
+        this._set = new int[i];
+        this._values = new byte[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr2[i2] == 1) {
+                int i3 = iArr[i2];
+                int insertionIndex = insertionIndex(i3);
+                this._set[insertionIndex] = i3;
+                this._values[insertionIndex] = bArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public byte remove(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return (byte) 0;
+        }
+        byte b = this._values[index];
+        removeAt(index);
+        return b;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TIntByteProcedure tIntByteProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        byte[] bArr2 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tIntByteProcedure.a(iArr[i], bArr2[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new byte[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TIntByteProcedure(this) { // from class: gnu.trove.TIntByteHashMap.1
+            @Override // gnu.trove.TIntByteProcedure
+            public boolean a(int i, byte b) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(i);
+                sb.append('=');
+                sb.append((int) b);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TByteFunction tByteFunction) {
+        byte[] bArr = this._states;
+        byte[] bArr2 = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                bArr2[i] = tByteFunction.a(bArr2[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TIntByteHashMap(int i) {
+        super(i);
+    }
+
+    public TIntByteHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TIntByteHashMap(TIntHashingStrategy tIntHashingStrategy) {
+        super(tIntHashingStrategy);
+    }
+
+    public TIntByteHashMap(int i, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, tIntHashingStrategy);
+    }
+
+    public TIntByteHashMap(int i, float f, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, f, tIntHashingStrategy);
+    }
+}

sources/gnu/trove/TIntByteIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TIntByteIterator extends TPrimitiveIterator {
+    public TIntByteIterator(TIntByteHashMap tIntByteHashMap) {
+        super(tIntByteHashMap);
+    }
+}

sources/gnu/trove/TIntByteProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TIntByteProcedure {
+    boolean a(int i, byte b);
+}

sources/gnu/trove/TIntDoubleHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TIntDoubleHashMap extends TIntHash {
+    protected transient double[] _values;
+
+    private static final class EqProcedure implements TIntDoubleProcedure {
+        private final TIntDoubleHashMap a;
+
+        EqProcedure(TIntDoubleHashMap tIntDoubleHashMap) {
+            this.a = tIntDoubleHashMap;
+        }
+
+        private static boolean a(double d, double d2) {
+            return d == d2;
+        }
+
+        @Override // gnu.trove.TIntDoubleProcedure
+        public final boolean a(int i, double d) {
+            return this.a.index(i) >= 0 && a(d, this.a.get(i));
+        }
+    }
+
+    private final class HashProcedure implements TIntDoubleProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TIntDoubleProcedure
+        public final boolean a(int i, double d) {
+            this.a += TIntDoubleHashMap.this._hashingStrategy.computeHashCode(i) ^ HashFunctions.a(d);
+            return true;
+        }
+    }
+
+    public TIntDoubleHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readInt(), objectInputStream.readDouble());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(int i, double d) {
+        int index = index(i);
+        if (index < 0) {
+            return false;
+        }
+        double[] dArr = this._values;
+        dArr[index] = dArr[index] + d;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        int[] iArr = this._set;
+        double[] dArr = this._values;
+        if (dArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = iArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            iArr[i] = 0;
+            dArr[i] = 0.0d;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TIntDoubleHashMap tIntDoubleHashMap = (TIntDoubleHashMap) super.clone();
+        double[] dArr = this._values;
+        tIntDoubleHashMap._values = dArr == null ? null : (double[]) dArr.clone();
+        return tIntDoubleHashMap;
+    }
+
+    public boolean containsKey(int i) {
+        return contains(i);
+    }
+
+    public boolean containsValue(double d) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && d == dArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TIntDoubleHashMap)) {
+            return false;
+        }
+        TIntDoubleHashMap tIntDoubleHashMap = (TIntDoubleHashMap) obj;
+        if (tIntDoubleHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tIntDoubleHashMap));
+    }
+
+    public boolean forEachEntry(TIntDoubleProcedure tIntDoubleProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntDoubleProcedure.a(iArr[i], dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TIntProcedure tIntProcedure) {
+        return forEach(tIntProcedure);
+    }
+
+    public boolean forEachValue(TDoubleProcedure tDoubleProcedure) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tDoubleProcedure.a(dArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public double get(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return 0.0d;
+        }
+        return this._values[index];
+    }
+
+    public double[] getValues() {
+        double[] dArr = new double[size()];
+        double[] dArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    dArr[i] = dArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return dArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(int i) {
+        return adjustValue(i, 1.0d);
+    }
+
+    public TIntDoubleIterator iterator() {
+        return new TIntDoubleIterator(this);
+    }
+
+    public int[] keys() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public double put(int i, double d) {
+        double d2;
+        boolean z;
+        int insertionIndex = insertionIndex(i);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            d2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            d2 = 0.0d;
+            z = true;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = i;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = d;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return d2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        int[] iArr = this._set;
+        double[] dArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new int[i];
+        this._values = new double[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                int i3 = iArr[i2];
+                int insertionIndex = insertionIndex(i3);
+                this._set[insertionIndex] = i3;
+                this._values[insertionIndex] = dArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public double remove(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return 0.0d;
+        }
+        double d = this._values[index];
+        removeAt(index);
+        return d;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0d;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TIntDoubleProcedure tIntDoubleProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        double[] dArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tIntDoubleProcedure.a(iArr[i], dArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new double[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TIntDoubleProcedure(this) { // from class: gnu.trove.TIntDoubleHashMap.1
+            @Override // gnu.trove.TIntDoubleProcedure
+            public boolean a(int i, double d) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(i);
+                sb.append('=');
+                sb.append(d);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TDoubleFunction tDoubleFunction) {
+        byte[] bArr = this._states;
+        double[] dArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                dArr[i] = tDoubleFunction.a(dArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TIntDoubleHashMap(int i) {
+        super(i);
+    }
+
+    public TIntDoubleHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TIntDoubleHashMap(TIntHashingStrategy tIntHashingStrategy) {
+        super(tIntHashingStrategy);
+    }
+
+    public TIntDoubleHashMap(int i, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, tIntHashingStrategy);
+    }
+
+    public TIntDoubleHashMap(int i, float f, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, f, tIntHashingStrategy);
+    }
+}

sources/gnu/trove/TIntDoubleIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TIntDoubleIterator extends TPrimitiveIterator {
+    public TIntDoubleIterator(TIntDoubleHashMap tIntDoubleHashMap) {
+        super(tIntDoubleHashMap);
+    }
+}

sources/gnu/trove/TIntDoubleProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TIntDoubleProcedure {
+    boolean a(int i, double d);
+}

sources/gnu/trove/TIntFloatHashMap.java

@@ -0,0 +1,408 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TIntFloatHashMap extends TIntHash {
+    protected transient float[] _values;
+
+    private static final class EqProcedure implements TIntFloatProcedure {
+        private final TIntFloatHashMap a;
+
+        EqProcedure(TIntFloatHashMap tIntFloatHashMap) {
+            this.a = tIntFloatHashMap;
+        }
+
+        private static boolean a(float f, float f2) {
+            return f == f2;
+        }
+
+        @Override // gnu.trove.TIntFloatProcedure
+        public final boolean a(int i, float f) {
+            return this.a.index(i) >= 0 && a(f, this.a.get(i));
+        }
+    }
+
+    private final class HashProcedure implements TIntFloatProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TIntFloatProcedure
+        public final boolean a(int i, float f) {
+            this.a += TIntFloatHashMap.this._hashingStrategy.computeHashCode(i) ^ HashFunctions.a(f);
+            return true;
+        }
+    }
+
+    public TIntFloatHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readInt(), objectInputStream.readFloat());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(int i, float f) {
+        int index = index(i);
+        if (index < 0) {
+            return false;
+        }
+        float[] fArr = this._values;
+        fArr[index] = fArr[index] + f;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        int[] iArr = this._set;
+        float[] fArr = this._values;
+        if (fArr == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = iArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            iArr[i] = 0;
+            fArr[i] = 0.0f;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TIntFloatHashMap tIntFloatHashMap = (TIntFloatHashMap) super.clone();
+        float[] fArr = this._values;
+        tIntFloatHashMap._values = fArr == null ? null : (float[]) fArr.clone();
+        return tIntFloatHashMap;
+    }
+
+    public boolean containsKey(int i) {
+        return contains(i);
+    }
+
+    public boolean containsValue(float f) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i] == 1 && f == fArr[i]) {
+                return true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TIntFloatHashMap)) {
+            return false;
+        }
+        TIntFloatHashMap tIntFloatHashMap = (TIntFloatHashMap) obj;
+        if (tIntFloatHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tIntFloatHashMap));
+    }
+
+    public boolean forEachEntry(TIntFloatProcedure tIntFloatProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntFloatProcedure.a(iArr[i], fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TIntProcedure tIntProcedure) {
+        return forEach(tIntProcedure);
+    }
+
+    public boolean forEachValue(TFloatProcedure tFloatProcedure) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tFloatProcedure.a(fArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public float get(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return 0.0f;
+        }
+        return this._values[index];
+    }
+
+    public float[] getValues() {
+        float[] fArr = new float[size()];
+        float[] fArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    fArr[i] = fArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return fArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(int i) {
+        return adjustValue(i, 1.0f);
+    }
+
+    public TIntFloatIterator iterator() {
+        return new TIntFloatIterator(this);
+    }
+
+    public int[] keys() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public float put(int i, float f) {
+        boolean z;
+        float f2;
+        int insertionIndex = insertionIndex(i);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            f2 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            f2 = 0.0f;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = i;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = f;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return f2;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        int[] iArr = this._set;
+        float[] fArr = this._values;
+        byte[] bArr = this._states;
+        this._set = new int[i];
+        this._values = new float[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                int i3 = iArr[i2];
+                int insertionIndex = insertionIndex(i3);
+                this._set[insertionIndex] = i3;
+                this._values[insertionIndex] = fArr[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public float remove(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return 0.0f;
+        }
+        float f = this._values[index];
+        removeAt(index);
+        return f;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0.0f;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TIntFloatProcedure tIntFloatProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        float[] fArr = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tIntFloatProcedure.a(iArr[i], fArr[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new float[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TIntFloatProcedure(this) { // from class: gnu.trove.TIntFloatHashMap.1
+            @Override // gnu.trove.TIntFloatProcedure
+            public boolean a(int i, float f) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(i);
+                sb.append('=');
+                sb.append(f);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TFloatFunction tFloatFunction) {
+        byte[] bArr = this._states;
+        float[] fArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                fArr[i] = tFloatFunction.a(fArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TIntFloatHashMap(int i) {
+        super(i);
+    }
+
+    public TIntFloatHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TIntFloatHashMap(TIntHashingStrategy tIntHashingStrategy) {
+        super(tIntHashingStrategy);
+    }
+
+    public TIntFloatHashMap(int i, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, tIntHashingStrategy);
+    }
+
+    public TIntFloatHashMap(int i, float f, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, f, tIntHashingStrategy);
+    }
+}

sources/gnu/trove/TIntFloatIterator.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public class TIntFloatIterator extends TPrimitiveIterator {
+    public TIntFloatIterator(TIntFloatHashMap tIntFloatHashMap) {
+        super(tIntFloatHashMap);
+    }
+}

sources/gnu/trove/TIntFloatProcedure.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TIntFloatProcedure {
+    boolean a(int i, float f);
+}

sources/gnu/trove/TIntFunction.java

@@ -0,0 +1,6 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public interface TIntFunction {
+    int a(int i);
+}

sources/gnu/trove/TIntHash.java

@@ -0,0 +1,150 @@
+package gnu.trove;
+
+/* loaded from: classes2.dex */
+public abstract class TIntHash extends TPrimitiveHash implements TIntHashingStrategy {
+    protected final TIntHashingStrategy _hashingStrategy;
+    protected transient int[] _set;
+
+    public TIntHash() {
+        this._hashingStrategy = this;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TIntHash tIntHash = (TIntHash) super.clone();
+        int[] iArr = this._set;
+        tIntHash._set = iArr == null ? null : (int[]) iArr.clone();
+        return tIntHash;
+    }
+
+    @Override // gnu.trove.TIntHashingStrategy
+    public final int computeHashCode(int i) {
+        HashFunctions.a(i);
+        return i;
+    }
+
+    public boolean contains(int i) {
+        return index(i) >= 0;
+    }
+
+    public boolean forEach(TIntProcedure tIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntProcedure.a(iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    protected int index(int i) {
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return -1;
+        }
+        int[] iArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(i) & Integer.MAX_VALUE;
+        int i2 = computeHashCode % length;
+        if (bArr[i2] != 0 && (bArr[i2] == 2 || iArr[i2] != i)) {
+            int i3 = (computeHashCode % (length - 2)) + 1;
+            while (true) {
+                i2 -= i3;
+                if (i2 < 0) {
+                    i2 += length;
+                }
+                if (bArr[i2] == 0 || (bArr[i2] != 2 && iArr[i2] == i)) {
+                    break;
+                }
+            }
+        }
+        if (bArr[i2] == 0) {
+            return -1;
+        }
+        return i2;
+    }
+
+    protected int insertionIndex(int i) {
+        if (this._set == null) {
+            setUp(6);
+        }
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        int length = bArr.length;
+        int computeHashCode = this._hashingStrategy.computeHashCode(i) & Integer.MAX_VALUE;
+        int i2 = computeHashCode % length;
+        if (bArr[i2] == 0) {
+            return i2;
+        }
+        if (bArr[i2] == 1 && iArr[i2] == i) {
+            return (-i2) - 1;
+        }
+        int i3 = (computeHashCode % (length - 2)) + 1;
+        do {
+            i2 -= i3;
+            if (i2 < 0) {
+                i2 += length;
+            }
+            if (bArr[i2] != 1) {
+                break;
+            }
+        } while (iArr[i2] != i);
+        if (bArr[i2] != 2) {
+            return bArr[i2] == 1 ? (-i2) - 1 : i2;
+        }
+        int i4 = i2;
+        while (bArr[i4] != 0 && (bArr[i4] == 2 || iArr[i4] != i)) {
+            i4 -= i3;
+            if (i4 < 0) {
+                i4 += length;
+            }
+        }
+        return bArr[i4] == 1 ? (-i4) - 1 : i2;
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._set[i] = 0;
+        super.removeAt(i);
+    }
+
+    @Override // gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._set = i == -1 ? null : new int[up];
+        return up;
+    }
+
+    public TIntHash(int i) {
+        super(i);
+        this._hashingStrategy = this;
+    }
+
+    public TIntHash(int i, float f) {
+        super(i, f);
+        this._hashingStrategy = this;
+    }
+
+    public TIntHash(TIntHashingStrategy tIntHashingStrategy) {
+        this._hashingStrategy = tIntHashingStrategy;
+    }
+
+    public TIntHash(int i, TIntHashingStrategy tIntHashingStrategy) {
+        super(i);
+        this._hashingStrategy = tIntHashingStrategy;
+    }
+
+    public TIntHash(int i, float f, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, f);
+        this._hashingStrategy = tIntHashingStrategy;
+    }
+}

sources/gnu/trove/TIntHashSet.java

@@ -0,0 +1,282 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public class TIntHashSet extends TIntHash {
+
+    private final class HashProcedure implements TIntProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TIntProcedure
+        public final boolean a(int i) {
+            this.a += TIntHashSet.this._hashingStrategy.computeHashCode(i);
+            return true;
+        }
+    }
+
+    public TIntHashSet() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            add(objectInputStream.readInt());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEach(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean add(int i) {
+        int insertionIndex = insertionIndex(i);
+        if (insertionIndex < 0) {
+            return false;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = i;
+        bArr[insertionIndex] = 1;
+        postInsertHook(b == 0);
+        return true;
+    }
+
+    public boolean addAll(int[] iArr) {
+        int length = iArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (add(iArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        int[] iArr = this._set;
+        byte[] bArr = this._states;
+        if (bArr == null) {
+            return;
+        }
+        int length = iArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            iArr[i] = 0;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    public boolean containsAll(int[] iArr) {
+        int length = iArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return true;
+            }
+            if (!contains(iArr[i])) {
+                return false;
+            }
+            length = i;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TIntHashSet)) {
+            return false;
+        }
+        final TIntHashSet tIntHashSet = (TIntHashSet) obj;
+        if (tIntHashSet.size() != size()) {
+            return false;
+        }
+        return forEach(new TIntProcedure(this) { // from class: gnu.trove.TIntHashSet.1
+            @Override // gnu.trove.TIntProcedure
+            public final boolean a(int i) {
+                return tIntHashSet.contains(i);
+            }
+        });
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEach(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public TIntIterator iterator() {
+        return new TIntIterator(this);
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        int[] iArr = this._set;
+        byte[] bArr = this._states;
+        this._set = new int[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                int i3 = iArr[i2];
+                int insertionIndex = insertionIndex(i3);
+                this._set[insertionIndex] = i3;
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public boolean remove(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return false;
+        }
+        removeAt(index);
+        return true;
+    }
+
+    public boolean removeAll(int[] iArr) {
+        int length = iArr.length;
+        boolean z = false;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return z;
+            }
+            if (remove(iArr[i])) {
+                z = true;
+            }
+            length = i;
+        }
+    }
+
+    public boolean retainAll(int[] iArr) {
+        Arrays.sort(iArr);
+        int[] iArr2 = this._set;
+        byte[] bArr = this._states;
+        boolean z = false;
+        if (iArr2 != null) {
+            int length = iArr2.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || Arrays.binarySearch(iArr, iArr2[i]) >= 0) {
+                    length = i;
+                } else {
+                    remove(iArr2[i]);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    public int[] toArray() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEach(new TIntProcedure(this) { // from class: gnu.trove.TIntHashSet.2
+            @Override // gnu.trove.TIntProcedure
+            public boolean a(int i) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(i);
+                return true;
+            }
+        });
+        sb.append(']');
+        sb.insert(0, '[');
+        return sb.toString();
+    }
+
+    public TIntHashSet(int i) {
+        super(i);
+    }
+
+    public TIntHashSet(int i, float f) {
+        super(i, f);
+    }
+
+    public TIntHashSet(int[] iArr) {
+        this(iArr.length);
+        addAll(iArr);
+    }
+
+    public TIntHashSet(TIntHashingStrategy tIntHashingStrategy) {
+        super(tIntHashingStrategy);
+    }
+
+    public TIntHashSet(int i, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, tIntHashingStrategy);
+    }
+
+    public TIntHashSet(int i, float f, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, f, tIntHashingStrategy);
+    }
+
+    public TIntHashSet(int[] iArr, TIntHashingStrategy tIntHashingStrategy) {
+        this(iArr.length, tIntHashingStrategy);
+        addAll(iArr);
+    }
+}

sources/gnu/trove/TIntHashingStrategy.java

@@ -0,0 +1,8 @@
+package gnu.trove;
+
+import java.io.Serializable;
+
+/* loaded from: classes2.dex */
+public interface TIntHashingStrategy extends Serializable {
+    int computeHashCode(int i);
+}

sources/gnu/trove/TIntIntHashMap.java

@@ -0,0 +1,411 @@
+package gnu.trove;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/* loaded from: classes2.dex */
+public class TIntIntHashMap extends TIntHash {
+    protected transient int[] _values;
+
+    private static final class EqProcedure implements TIntIntProcedure {
+        private final TIntIntHashMap a;
+
+        EqProcedure(TIntIntHashMap tIntIntHashMap) {
+            this.a = tIntIntHashMap;
+        }
+
+        private static boolean b(int i, int i2) {
+            return i == i2;
+        }
+
+        @Override // gnu.trove.TIntIntProcedure
+        public final boolean a(int i, int i2) {
+            return this.a.index(i) >= 0 && b(i2, this.a.get(i));
+        }
+    }
+
+    private final class HashProcedure implements TIntIntProcedure {
+        private int a;
+
+        HashProcedure() {
+        }
+
+        public int a() {
+            return this.a;
+        }
+
+        @Override // gnu.trove.TIntIntProcedure
+        public final boolean a(int i, int i2) {
+            int i3 = this.a;
+            int computeHashCode = TIntIntHashMap.this._hashingStrategy.computeHashCode(i);
+            HashFunctions.a(i2);
+            this.a = i3 + (computeHashCode ^ i2);
+            return true;
+        }
+    }
+
+    public TIntIntHashMap() {
+    }
+
+    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        objectInputStream.defaultReadObject();
+        int readInt = objectInputStream.readInt();
+        setUp(readInt);
+        while (true) {
+            int i = readInt - 1;
+            if (readInt <= 0) {
+                return;
+            }
+            put(objectInputStream.readInt(), objectInputStream.readInt());
+            readInt = i;
+        }
+    }
+
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        objectOutputStream.defaultWriteObject();
+        objectOutputStream.writeInt(this._size);
+        SerializationProcedure serializationProcedure = new SerializationProcedure(objectOutputStream);
+        if (!forEachEntry(serializationProcedure)) {
+            throw serializationProcedure.b;
+        }
+    }
+
+    public boolean adjustValue(int i, int i2) {
+        int index = index(i);
+        if (index < 0) {
+            return false;
+        }
+        int[] iArr = this._values;
+        iArr[index] = iArr[index] + i2;
+        return true;
+    }
+
+    @Override // gnu.trove.THash
+    public void clear() {
+        super.clear();
+        int[] iArr = this._set;
+        int[] iArr2 = this._values;
+        if (iArr2 == null) {
+            return;
+        }
+        byte[] bArr = this._states;
+        int length = iArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            iArr[i] = 0;
+            iArr2[i] = 0;
+            bArr[i] = 0;
+            length = i;
+        }
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    public Object clone() {
+        TIntIntHashMap tIntIntHashMap = (TIntIntHashMap) super.clone();
+        int[] iArr = this._values;
+        tIntIntHashMap._values = iArr == null ? null : (int[]) iArr.clone();
+        return tIntIntHashMap;
+    }
+
+    public boolean containsKey(int i) {
+        return contains(i);
+    }
+
+    public boolean containsValue(int i) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return false;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i2 = length - 1;
+            if (length <= 0) {
+                return false;
+            }
+            if (bArr[i2] == 1 && i == iArr[i2]) {
+                return true;
+            }
+            length = i2;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TIntIntHashMap)) {
+            return false;
+        }
+        TIntIntHashMap tIntIntHashMap = (TIntIntHashMap) obj;
+        if (tIntIntHashMap.size() != size()) {
+            return false;
+        }
+        return forEachEntry(new EqProcedure(tIntIntHashMap));
+    }
+
+    public boolean forEachEntry(TIntIntProcedure tIntIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        int[] iArr2 = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntIntProcedure.a(iArr[i], iArr2[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public boolean forEachKey(TIntProcedure tIntProcedure) {
+        return forEach(tIntProcedure);
+    }
+
+    public boolean forEachValue(TIntProcedure tIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] == 1 && !tIntProcedure.a(iArr[i])) {
+                    return false;
+                }
+                length = i;
+            }
+        }
+        return true;
+    }
+
+    public int get(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return 0;
+        }
+        return this._values[index];
+    }
+
+    public int[] getValues() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._values;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public int hashCode() {
+        HashProcedure hashProcedure = new HashProcedure();
+        forEachEntry(hashProcedure);
+        return hashProcedure.a();
+    }
+
+    public boolean increment(int i) {
+        return adjustValue(i, 1);
+    }
+
+    public TIntIntIterator iterator() {
+        return new TIntIntIterator(this);
+    }
+
+    public int[] keys() {
+        int[] iArr = new int[size()];
+        int[] iArr2 = this._set;
+        byte[] bArr = this._states;
+        if (bArr != null) {
+            int length = bArr.length;
+            int i = 0;
+            while (true) {
+                int i2 = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i2] == 1) {
+                    iArr[i] = iArr2[i2];
+                    i++;
+                }
+                length = i2;
+            }
+        }
+        return iArr;
+    }
+
+    public int put(int i, int i2) {
+        boolean z;
+        int i3;
+        int insertionIndex = insertionIndex(i);
+        if (insertionIndex < 0) {
+            insertionIndex = (-insertionIndex) - 1;
+            i3 = this._values[insertionIndex];
+            z = false;
+        } else {
+            z = true;
+            i3 = 0;
+        }
+        byte[] bArr = this._states;
+        byte b = bArr[insertionIndex];
+        this._set[insertionIndex] = i;
+        bArr[insertionIndex] = 1;
+        this._values[insertionIndex] = i2;
+        if (z) {
+            postInsertHook(b == 0);
+        }
+        return i3;
+    }
+
+    @Override // gnu.trove.THash
+    protected void rehash(int i) {
+        int capacity = capacity();
+        int[] iArr = this._set;
+        int[] iArr2 = this._values;
+        byte[] bArr = this._states;
+        this._set = new int[i];
+        this._values = new int[i];
+        this._states = new byte[i];
+        while (true) {
+            int i2 = capacity - 1;
+            if (capacity <= 0) {
+                return;
+            }
+            if (bArr[i2] == 1) {
+                int i3 = iArr[i2];
+                int insertionIndex = insertionIndex(i3);
+                this._set[insertionIndex] = i3;
+                this._values[insertionIndex] = iArr2[i2];
+                this._states[insertionIndex] = 1;
+            }
+            capacity = i2;
+        }
+    }
+
+    public int remove(int i) {
+        int index = index(i);
+        if (index < 0) {
+            return 0;
+        }
+        int i2 = this._values[index];
+        removeAt(index);
+        return i2;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected void removeAt(int i) {
+        this._values[i] = 0;
+        super.removeAt(i);
+    }
+
+    public boolean retainEntries(TIntIntProcedure tIntIntProcedure) {
+        byte[] bArr = this._states;
+        int[] iArr = this._set;
+        int[] iArr2 = this._values;
+        boolean z = false;
+        if (bArr != null) {
+            int length = bArr.length;
+            while (true) {
+                int i = length - 1;
+                if (length <= 0) {
+                    break;
+                }
+                if (bArr[i] != 1 || tIntIntProcedure.a(iArr[i], iArr2[i])) {
+                    length = i;
+                } else {
+                    removeAt(i);
+                    length = i;
+                    z = true;
+                }
+            }
+        }
+        return z;
+    }
+
+    @Override // gnu.trove.TIntHash, gnu.trove.TPrimitiveHash, gnu.trove.THash
+    protected int setUp(int i) {
+        int up = super.setUp(i);
+        this._values = i == -1 ? null : new int[up];
+        return up;
+    }
+
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        forEachEntry(new TIntIntProcedure(this) { // from class: gnu.trove.TIntIntHashMap.1
+            @Override // gnu.trove.TIntIntProcedure
+            public boolean a(int i, int i2) {
+                if (sb.length() != 0) {
+                    StringBuilder sb2 = sb;
+                    sb2.append(',');
+                    sb2.append(' ');
+                }
+                sb.append(i);
+                sb.append('=');
+                sb.append(i2);
+                return true;
+            }
+        });
+        sb.append('}');
+        sb.insert(0, '{');
+        return sb.toString();
+    }
+
+    public void transformValues(TIntFunction tIntFunction) {
+        byte[] bArr = this._states;
+        int[] iArr = this._values;
+        if (bArr == null) {
+            return;
+        }
+        int length = bArr.length;
+        while (true) {
+            int i = length - 1;
+            if (length <= 0) {
+                return;
+            }
+            if (bArr[i] == 1) {
+                iArr[i] = tIntFunction.a(iArr[i]);
+            }
+            length = i;
+        }
+    }
+
+    public TIntIntHashMap(int i) {
+        super(i);
+    }
+
+    public TIntIntHashMap(int i, float f) {
+        super(i, f);
+    }
+
+    public TIntIntHashMap(TIntHashingStrategy tIntHashingStrategy) {
+        super(tIntHashingStrategy);
+    }
+
+    public TIntIntHashMap(int i, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, tIntHashingStrategy);
+    }
+
+    public TIntIntHashMap(int i, float f, TIntHashingStrategy tIntHashingStrategy) {
+        super(i, f, tIntHashingStrategy);
+    }
+}