Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/s/C0581a.java

@@ -0,0 +1,101 @@
+package s;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.markers.KMutableIterator;
+
+/* renamed from: s.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0581a implements Iterator, KMutableIterator {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f8327a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public int f8328b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f8329c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ int f8330d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ Object f8331e;
+
+    public C0581a(int i) {
+        this.f8327a = i;
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return this.f8328b < this.f8327a;
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        Object f2;
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        int i = this.f8328b;
+        switch (this.f8330d) {
+            case 0:
+                f2 = ((e) this.f8331e).f(i);
+                break;
+            case 1:
+                f2 = ((e) this.f8331e).i(i);
+                break;
+            default:
+                f2 = ((f) this.f8331e).f8342b[i];
+                break;
+        }
+        this.f8328b++;
+        this.f8329c = true;
+        return f2;
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        if (!this.f8329c) {
+            throw new IllegalStateException("Call next() before removing an element.");
+        }
+        int i = this.f8328b - 1;
+        this.f8328b = i;
+        switch (this.f8330d) {
+            case 0:
+                ((e) this.f8331e).g(i);
+                break;
+            case 1:
+                ((e) this.f8331e).g(i);
+                break;
+            default:
+                ((f) this.f8331e).a(i);
+                break;
+        }
+        this.f8327a--;
+        this.f8329c = false;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public C0581a(f fVar) {
+        this(fVar.f8343c);
+        this.f8330d = 2;
+        this.f8331e = fVar;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public C0581a(e eVar, int i) {
+        this(eVar.f8352c);
+        this.f8330d = i;
+        switch (i) {
+            case 1:
+                this.f8331e = eVar;
+                this(eVar.f8352c);
+                return;
+            default:
+                this.f8331e = eVar;
+                return;
+        }
+    }
+}

apk_decompiled/sources/s/b.java

@@ -0,0 +1,136 @@
+package s;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public final class b implements Set {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ e f8332a;
+
+    public b(e eVar) {
+        this.f8332a = eVar;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean add(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean addAll(Collection collection) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final void clear() {
+        this.f8332a.clear();
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean contains(Object obj) {
+        return this.f8332a.containsKey(obj);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean containsAll(Collection collection) {
+        return this.f8332a.j(collection);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Set)) {
+            return false;
+        }
+        Set set = (Set) obj;
+        e eVar = this.f8332a;
+        try {
+            if (eVar.f8352c == set.size()) {
+                return eVar.j(set);
+            }
+            return false;
+        } catch (ClassCastException | NullPointerException unused) {
+            return false;
+        }
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final int hashCode() {
+        e eVar = this.f8332a;
+        int i = 0;
+        for (int i4 = eVar.f8352c - 1; i4 >= 0; i4--) {
+            Object f2 = eVar.f(i4);
+            i += f2 == null ? 0 : f2.hashCode();
+        }
+        return i;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean isEmpty() {
+        return this.f8332a.isEmpty();
+    }
+
+    @Override // java.util.Set, java.util.Collection, java.lang.Iterable
+    public final Iterator iterator() {
+        return new C0581a(this.f8332a, 0);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean remove(Object obj) {
+        e eVar = this.f8332a;
+        int d4 = eVar.d(obj);
+        if (d4 < 0) {
+            return false;
+        }
+        eVar.g(d4);
+        return true;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean removeAll(Collection collection) {
+        return this.f8332a.k(collection);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final boolean retainAll(Collection collection) {
+        return this.f8332a.l(collection);
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final int size() {
+        return this.f8332a.f8352c;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final Object[] toArray() {
+        e eVar = this.f8332a;
+        int i = eVar.f8352c;
+        Object[] objArr = new Object[i];
+        for (int i4 = 0; i4 < i; i4++) {
+            objArr[i4] = eVar.f(i4);
+        }
+        return objArr;
+    }
+
+    @Override // java.util.Set, java.util.Collection
+    public final Object[] toArray(Object[] objArr) {
+        e eVar = this.f8332a;
+        int i = eVar.f8352c;
+        if (objArr.length < i) {
+            objArr = (Object[]) Array.newInstance(objArr.getClass().getComponentType(), i);
+        }
+        for (int i4 = 0; i4 < i; i4++) {
+            objArr[i4] = eVar.f(i4);
+        }
+        if (objArr.length > i) {
+            objArr[i] = null;
+        }
+        return objArr;
+    }
+}

apk_decompiled/sources/s/c.java

@@ -0,0 +1,108 @@
+package s;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class c implements Iterator, Map.Entry {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f8333a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public int f8334b = -1;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f8335c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ e f8336d;
+
+    public c(e eVar) {
+        this.f8336d = eVar;
+        this.f8333a = eVar.f8352c - 1;
+    }
+
+    @Override // java.util.Map.Entry
+    public final boolean equals(Object obj) {
+        if (!this.f8335c) {
+            throw new IllegalStateException("This container does not support retaining Map.Entry objects");
+        }
+        if (!(obj instanceof Map.Entry)) {
+            return false;
+        }
+        Map.Entry entry = (Map.Entry) obj;
+        Object key = entry.getKey();
+        int i = this.f8334b;
+        e eVar = this.f8336d;
+        return Intrinsics.areEqual(key, eVar.f(i)) && Intrinsics.areEqual(entry.getValue(), eVar.i(this.f8334b));
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object getKey() {
+        if (this.f8335c) {
+            return this.f8336d.f(this.f8334b);
+        }
+        throw new IllegalStateException("This container does not support retaining Map.Entry objects");
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object getValue() {
+        if (this.f8335c) {
+            return this.f8336d.i(this.f8334b);
+        }
+        throw new IllegalStateException("This container does not support retaining Map.Entry objects");
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return this.f8334b < this.f8333a;
+    }
+
+    @Override // java.util.Map.Entry
+    public final int hashCode() {
+        if (!this.f8335c) {
+            throw new IllegalStateException("This container does not support retaining Map.Entry objects");
+        }
+        int i = this.f8334b;
+        e eVar = this.f8336d;
+        Object f2 = eVar.f(i);
+        Object i4 = eVar.i(this.f8334b);
+        return (f2 == null ? 0 : f2.hashCode()) ^ (i4 != null ? i4.hashCode() : 0);
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        this.f8334b++;
+        this.f8335c = true;
+        return this;
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        if (!this.f8335c) {
+            throw new IllegalStateException();
+        }
+        this.f8336d.g(this.f8334b);
+        this.f8334b--;
+        this.f8333a--;
+        this.f8335c = false;
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object setValue(Object obj) {
+        if (this.f8335c) {
+            return this.f8336d.h(this.f8334b, obj);
+        }
+        throw new IllegalStateException("This container does not support retaining Map.Entry objects");
+    }
+
+    public final String toString() {
+        return getKey() + "=" + getValue();
+    }
+}

apk_decompiled/sources/s/d.java

@@ -0,0 +1,136 @@
+package s;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public final class d implements Collection {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ e f8337a;
+
+    public d(e eVar) {
+        this.f8337a = eVar;
+    }
+
+    @Override // java.util.Collection
+    public final boolean add(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Collection
+    public final boolean addAll(Collection collection) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Collection
+    public final void clear() {
+        this.f8337a.clear();
+    }
+
+    @Override // java.util.Collection
+    public final boolean contains(Object obj) {
+        return this.f8337a.a(obj) >= 0;
+    }
+
+    @Override // java.util.Collection
+    public final boolean containsAll(Collection collection) {
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            if (!contains(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.Collection
+    public final boolean isEmpty() {
+        return this.f8337a.isEmpty();
+    }
+
+    @Override // java.util.Collection, java.lang.Iterable
+    public final Iterator iterator() {
+        return new C0581a(this.f8337a, 1);
+    }
+
+    @Override // java.util.Collection
+    public final boolean remove(Object obj) {
+        e eVar = this.f8337a;
+        int a2 = eVar.a(obj);
+        if (a2 < 0) {
+            return false;
+        }
+        eVar.g(a2);
+        return true;
+    }
+
+    @Override // java.util.Collection
+    public final boolean removeAll(Collection collection) {
+        e eVar = this.f8337a;
+        int i = eVar.f8352c;
+        int i4 = 0;
+        boolean z3 = false;
+        while (i4 < i) {
+            if (collection.contains(eVar.i(i4))) {
+                eVar.g(i4);
+                i4--;
+                i--;
+                z3 = true;
+            }
+            i4++;
+        }
+        return z3;
+    }
+
+    @Override // java.util.Collection
+    public final boolean retainAll(Collection collection) {
+        e eVar = this.f8337a;
+        int i = eVar.f8352c;
+        int i4 = 0;
+        boolean z3 = false;
+        while (i4 < i) {
+            if (!collection.contains(eVar.i(i4))) {
+                eVar.g(i4);
+                i4--;
+                i--;
+                z3 = true;
+            }
+            i4++;
+        }
+        return z3;
+    }
+
+    @Override // java.util.Collection
+    public final int size() {
+        return this.f8337a.f8352c;
+    }
+
+    @Override // java.util.Collection
+    public final Object[] toArray() {
+        e eVar = this.f8337a;
+        int i = eVar.f8352c;
+        Object[] objArr = new Object[i];
+        for (int i4 = 0; i4 < i; i4++) {
+            objArr[i4] = eVar.i(i4);
+        }
+        return objArr;
+    }
+
+    @Override // java.util.Collection
+    public final Object[] toArray(Object[] objArr) {
+        e eVar = this.f8337a;
+        int i = eVar.f8352c;
+        if (objArr.length < i) {
+            objArr = (Object[]) Array.newInstance(objArr.getClass().getComponentType(), i);
+        }
+        for (int i4 = 0; i4 < i; i4++) {
+            objArr[i4] = eVar.i(i4);
+        }
+        if (objArr.length > i) {
+            objArr[i] = null;
+        }
+        return objArr;
+    }
+}

apk_decompiled/sources/s/e.java

@@ -0,0 +1,113 @@
+package s;
+
+import androidx.datastore.preferences.protobuf.i0;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class e extends j implements Map {
+
+    /* renamed from: d, reason: collision with root package name */
+    public i0 f8338d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public b f8339e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public d f8340f;
+
+    public e() {
+        super(0);
+    }
+
+    @Override // java.util.Map
+    public final Set entrySet() {
+        i0 i0Var = this.f8338d;
+        if (i0Var != null) {
+            return i0Var;
+        }
+        i0 i0Var2 = new i0(this, 1);
+        this.f8338d = i0Var2;
+        return i0Var2;
+    }
+
+    public final boolean j(Collection collection) {
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            if (!super.containsKey(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public final boolean k(Collection collection) {
+        int i = this.f8352c;
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            super.remove(it.next());
+        }
+        return i != this.f8352c;
+    }
+
+    @Override // java.util.Map
+    public final Set keySet() {
+        b bVar = this.f8339e;
+        if (bVar != null) {
+            return bVar;
+        }
+        b bVar2 = new b(this);
+        this.f8339e = bVar2;
+        return bVar2;
+    }
+
+    public final boolean l(Collection collection) {
+        int i = this.f8352c;
+        for (int i4 = i - 1; i4 >= 0; i4--) {
+            if (!collection.contains(f(i4))) {
+                g(i4);
+            }
+        }
+        return i != this.f8352c;
+    }
+
+    @Override // java.util.Map
+    public final void putAll(Map map) {
+        b(map.size() + this.f8352c);
+        for (Map.Entry entry : map.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override // java.util.Map
+    public final Collection values() {
+        d dVar = this.f8340f;
+        if (dVar != null) {
+            return dVar;
+        }
+        d dVar2 = new d(this);
+        this.f8340f = dVar2;
+        return dVar2;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public e(j map) {
+        super(0);
+        Intrinsics.checkNotNullParameter(map, "map");
+        int i = map.f8352c;
+        b(this.f8352c + i);
+        if (this.f8352c != 0) {
+            for (int i4 = 0; i4 < i; i4++) {
+                put(map.f(i4), map.i(i4));
+            }
+        } else if (i > 0) {
+            ArraysKt___ArraysJvmKt.copyInto(map.f8350a, this.f8350a, 0, 0, i);
+            ArraysKt___ArraysJvmKt.copyInto(map.f8351b, this.f8351b, 0, 0, i << 1);
+            this.f8352c = i;
+        }
+    }
+}

apk_decompiled/sources/s/f.java

@@ -0,0 +1,323 @@
+package s;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.Set;
+import kotlin.collections.ArraysKt;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.collections.CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMutableCollection;
+import kotlin.jvm.internal.markers.KMutableSet;
+import t.AbstractC0613a;
+
+/* loaded from: classes.dex */
+public final class f implements Collection, Set, KMutableCollection, KMutableSet {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int[] f8341a = AbstractC0613a.f8506a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object[] f8342b = AbstractC0613a.f8507b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f8343c;
+
+    public f(int i) {
+        if (i > 0) {
+            h.b(this, i);
+        }
+    }
+
+    public final Object a(int i) {
+        int i4 = this.f8343c;
+        Object[] objArr = this.f8342b;
+        Object obj = objArr[i];
+        if (i4 <= 1) {
+            clear();
+            return obj;
+        }
+        int i5 = i4 - 1;
+        int[] iArr = this.f8341a;
+        if (iArr.length <= 8 || i4 >= iArr.length / 3) {
+            if (i < i5) {
+                int i6 = i + 1;
+                ArraysKt___ArraysJvmKt.copyInto(iArr, iArr, i, i6, i4);
+                Object[] objArr2 = this.f8342b;
+                ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i, i6, i4);
+            }
+            this.f8342b[i5] = null;
+        } else {
+            h.b(this, i4 > 8 ? i4 + (i4 >> 1) : 8);
+            if (i > 0) {
+                ArraysKt___ArraysJvmKt.copyInto$default(iArr, this.f8341a, 0, 0, i, 6, (Object) null);
+                ArraysKt___ArraysJvmKt.copyInto$default(objArr, this.f8342b, 0, 0, i, 6, (Object) null);
+            }
+            if (i < i5) {
+                int i7 = i + 1;
+                ArraysKt___ArraysJvmKt.copyInto(iArr, this.f8341a, i, i7, i4);
+                ArraysKt___ArraysJvmKt.copyInto(objArr, this.f8342b, i, i7, i4);
+            }
+        }
+        if (i4 != this.f8343c) {
+            throw new ConcurrentModificationException();
+        }
+        this.f8343c = i5;
+        return obj;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean add(Object obj) {
+        int i;
+        int c4;
+        int i4 = this.f8343c;
+        if (obj == null) {
+            Intrinsics.checkNotNullParameter(this, "<this>");
+            c4 = h.c(this, null, 0);
+            i = 0;
+        } else {
+            int hashCode = obj.hashCode();
+            i = hashCode;
+            c4 = h.c(this, obj, hashCode);
+        }
+        if (c4 >= 0) {
+            return false;
+        }
+        int i5 = ~c4;
+        int[] iArr = this.f8341a;
+        if (i4 >= iArr.length) {
+            int i6 = 8;
+            if (i4 >= 8) {
+                i6 = (i4 >> 1) + i4;
+            } else if (i4 < 4) {
+                i6 = 4;
+            }
+            Object[] objArr = this.f8342b;
+            h.b(this, i6);
+            if (i4 != this.f8343c) {
+                throw new ConcurrentModificationException();
+            }
+            int[] iArr2 = this.f8341a;
+            if (iArr2.length != 0) {
+                ArraysKt___ArraysJvmKt.copyInto$default(iArr, iArr2, 0, 0, iArr.length, 6, (Object) null);
+                ArraysKt___ArraysJvmKt.copyInto$default(objArr, this.f8342b, 0, 0, objArr.length, 6, (Object) null);
+            }
+        }
+        if (i5 < i4) {
+            int[] iArr3 = this.f8341a;
+            int i7 = i5 + 1;
+            ArraysKt___ArraysJvmKt.copyInto(iArr3, iArr3, i7, i5, i4);
+            Object[] objArr2 = this.f8342b;
+            ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i7, i5, i4);
+        }
+        int i8 = this.f8343c;
+        if (i4 == i8) {
+            int[] iArr4 = this.f8341a;
+            if (i5 < iArr4.length) {
+                iArr4[i5] = i;
+                this.f8342b[i5] = obj;
+                this.f8343c = i8 + 1;
+                return true;
+            }
+        }
+        throw new ConcurrentModificationException();
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean addAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        int size = elements.size() + this.f8343c;
+        int i = this.f8343c;
+        int[] iArr = this.f8341a;
+        if (iArr.length < size) {
+            Object[] objArr = this.f8342b;
+            h.b(this, size);
+            int i4 = this.f8343c;
+            if (i4 > 0) {
+                ArraysKt___ArraysJvmKt.copyInto$default(iArr, this.f8341a, 0, 0, i4, 6, (Object) null);
+                ArraysKt___ArraysJvmKt.copyInto$default(objArr, this.f8342b, 0, 0, this.f8343c, 6, (Object) null);
+            }
+        }
+        if (this.f8343c != i) {
+            throw new ConcurrentModificationException();
+        }
+        Iterator it = elements.iterator();
+        boolean z3 = false;
+        while (it.hasNext()) {
+            z3 |= add(it.next());
+        }
+        return z3;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final void clear() {
+        if (this.f8343c != 0) {
+            int[] iArr = AbstractC0613a.f8506a;
+            Intrinsics.checkNotNullParameter(iArr, "<set-?>");
+            this.f8341a = iArr;
+            Object[] objArr = AbstractC0613a.f8507b;
+            Intrinsics.checkNotNullParameter(objArr, "<set-?>");
+            this.f8342b = objArr;
+            this.f8343c = 0;
+        }
+        if (this.f8343c != 0) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean contains(Object obj) {
+        int c4;
+        if (obj == null) {
+            Intrinsics.checkNotNullParameter(this, "<this>");
+            c4 = h.c(this, null, 0);
+        } else {
+            c4 = h.c(this, obj, obj.hashCode());
+        }
+        return c4 >= 0;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean containsAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        Iterator it = elements.iterator();
+        while (it.hasNext()) {
+            if (!contains(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Set) || this.f8343c != ((Set) obj).size()) {
+            return false;
+        }
+        try {
+            int i = this.f8343c;
+            for (int i4 = 0; i4 < i; i4++) {
+                if (!((Set) obj).contains(this.f8342b[i4])) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (ClassCastException | NullPointerException unused) {
+            return false;
+        }
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final int hashCode() {
+        int[] iArr = this.f8341a;
+        int i = this.f8343c;
+        int i4 = 0;
+        for (int i5 = 0; i5 < i; i5++) {
+            i4 += iArr[i5];
+        }
+        return i4;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean isEmpty() {
+        return this.f8343c <= 0;
+    }
+
+    @Override // java.util.Collection, java.lang.Iterable, java.util.Set
+    public final Iterator iterator() {
+        return new C0581a(this);
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean remove(Object obj) {
+        int c4;
+        if (obj == null) {
+            Intrinsics.checkNotNullParameter(this, "<this>");
+            c4 = h.c(this, null, 0);
+        } else {
+            c4 = h.c(this, obj, obj.hashCode());
+        }
+        if (c4 < 0) {
+            return false;
+        }
+        a(c4);
+        return true;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean removeAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        Iterator it = elements.iterator();
+        boolean z3 = false;
+        while (it.hasNext()) {
+            z3 |= remove(it.next());
+        }
+        return z3;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final boolean retainAll(Collection elements) {
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        boolean z3 = false;
+        for (int i = this.f8343c - 1; -1 < i; i--) {
+            if (!CollectionsKt.contains(elements, this.f8342b[i])) {
+                a(i);
+                z3 = true;
+            }
+        }
+        return z3;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final int size() {
+        return this.f8343c;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final Object[] toArray() {
+        return ArraysKt.copyOfRange(this.f8342b, 0, this.f8343c);
+    }
+
+    public final String toString() {
+        if (isEmpty()) {
+            return "{}";
+        }
+        StringBuilder sb = new StringBuilder(this.f8343c * 14);
+        sb.append('{');
+        int i = this.f8343c;
+        for (int i4 = 0; i4 < i; i4++) {
+            if (i4 > 0) {
+                sb.append(", ");
+            }
+            Object obj = this.f8342b[i4];
+            if (obj != this) {
+                sb.append(obj);
+            } else {
+                sb.append("(this Set)");
+            }
+        }
+        sb.append('}');
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder(capacity).…builderAction).toString()");
+        return sb2;
+    }
+
+    @Override // java.util.Collection, java.util.Set
+    public final Object[] toArray(Object[] result) {
+        Intrinsics.checkNotNullParameter(result, "array");
+        int i = this.f8343c;
+        if (result.length < i) {
+            result = (Object[]) Array.newInstance(result.getClass().getComponentType(), i);
+        } else if (result.length > i) {
+            result[i] = null;
+        }
+        ArraysKt___ArraysJvmKt.copyInto(this.f8342b, result, 0, 0, this.f8343c);
+        Intrinsics.checkNotNullExpressionValue(result, "result");
+        return result;
+    }
+}

apk_decompiled/sources/s/g.java

@@ -0,0 +1,281 @@
+package s;
+
+import java.util.Arrays;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.jvm.internal.Intrinsics;
+import t.AbstractC0613a;
+
+/* loaded from: classes.dex */
+public final class g implements Cloneable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public /* synthetic */ boolean f8344a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ long[] f8345b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public /* synthetic */ Object[] f8346c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public /* synthetic */ int f8347d;
+
+    public g() {
+        int i;
+        int i4 = 4;
+        while (true) {
+            i = 80;
+            if (i4 >= 32) {
+                break;
+            }
+            int i5 = (1 << i4) - 12;
+            if (80 <= i5) {
+                i = i5;
+                break;
+            }
+            i4++;
+        }
+        int i6 = i / 8;
+        this.f8345b = new long[i6];
+        this.f8346c = new Object[i6];
+    }
+
+    public final void a() {
+        int i = this.f8347d;
+        Object[] objArr = this.f8346c;
+        for (int i4 = 0; i4 < i; i4++) {
+            objArr[i4] = null;
+        }
+        this.f8347d = 0;
+        this.f8344a = false;
+    }
+
+    public final Object b(long j4) {
+        Object obj;
+        int b4 = AbstractC0613a.b(this.f8345b, this.f8347d, j4);
+        if (b4 < 0 || (obj = this.f8346c[b4]) == h.f8348a) {
+            return null;
+        }
+        return obj;
+    }
+
+    public final int c(long j4) {
+        if (this.f8344a) {
+            int i = this.f8347d;
+            long[] jArr = this.f8345b;
+            Object[] objArr = this.f8346c;
+            int i4 = 0;
+            for (int i5 = 0; i5 < i; i5++) {
+                Object obj = objArr[i5];
+                if (obj != h.f8348a) {
+                    if (i5 != i4) {
+                        jArr[i4] = jArr[i5];
+                        objArr[i4] = obj;
+                        objArr[i5] = null;
+                    }
+                    i4++;
+                }
+            }
+            this.f8344a = false;
+            this.f8347d = i4;
+        }
+        return AbstractC0613a.b(this.f8345b, this.f8347d, j4);
+    }
+
+    public final Object clone() {
+        Object clone = super.clone();
+        Intrinsics.checkNotNull(clone, "null cannot be cast to non-null type androidx.collection.LongSparseArray<E of androidx.collection.LongSparseArray>");
+        g gVar = (g) clone;
+        gVar.f8345b = (long[]) this.f8345b.clone();
+        gVar.f8346c = (Object[]) this.f8346c.clone();
+        return gVar;
+    }
+
+    public final long d(int i) {
+        int i4;
+        if (i < 0 || i >= (i4 = this.f8347d)) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "Expected index to be within 0..size()-1, but was ").toString());
+        }
+        if (this.f8344a) {
+            long[] jArr = this.f8345b;
+            Object[] objArr = this.f8346c;
+            int i5 = 0;
+            for (int i6 = 0; i6 < i4; i6++) {
+                Object obj = objArr[i6];
+                if (obj != h.f8348a) {
+                    if (i6 != i5) {
+                        jArr[i5] = jArr[i6];
+                        objArr[i5] = obj;
+                        objArr[i6] = null;
+                    }
+                    i5++;
+                }
+            }
+            this.f8344a = false;
+            this.f8347d = i5;
+        }
+        return this.f8345b[i];
+    }
+
+    public final void e(long j4, Object obj) {
+        int b4 = AbstractC0613a.b(this.f8345b, this.f8347d, j4);
+        if (b4 >= 0) {
+            this.f8346c[b4] = obj;
+            return;
+        }
+        int i = ~b4;
+        int i4 = this.f8347d;
+        Object obj2 = h.f8348a;
+        if (i < i4) {
+            Object[] objArr = this.f8346c;
+            if (objArr[i] == obj2) {
+                this.f8345b[i] = j4;
+                objArr[i] = obj;
+                return;
+            }
+        }
+        if (this.f8344a) {
+            long[] jArr = this.f8345b;
+            if (i4 >= jArr.length) {
+                Object[] objArr2 = this.f8346c;
+                int i5 = 0;
+                for (int i6 = 0; i6 < i4; i6++) {
+                    Object obj3 = objArr2[i6];
+                    if (obj3 != obj2) {
+                        if (i6 != i5) {
+                            jArr[i5] = jArr[i6];
+                            objArr2[i5] = obj3;
+                            objArr2[i6] = null;
+                        }
+                        i5++;
+                    }
+                }
+                this.f8344a = false;
+                this.f8347d = i5;
+                i = ~AbstractC0613a.b(this.f8345b, i5, j4);
+            }
+        }
+        int i7 = this.f8347d;
+        if (i7 >= this.f8345b.length) {
+            int i8 = (i7 + 1) * 8;
+            int i9 = 4;
+            while (true) {
+                if (i9 >= 32) {
+                    break;
+                }
+                int i10 = (1 << i9) - 12;
+                if (i8 <= i10) {
+                    i8 = i10;
+                    break;
+                }
+                i9++;
+            }
+            int i11 = i8 / 8;
+            long[] copyOf = Arrays.copyOf(this.f8345b, i11);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+            this.f8345b = copyOf;
+            Object[] copyOf2 = Arrays.copyOf(this.f8346c, i11);
+            Intrinsics.checkNotNullExpressionValue(copyOf2, "copyOf(this, newSize)");
+            this.f8346c = copyOf2;
+        }
+        int i12 = this.f8347d;
+        if (i12 - i != 0) {
+            long[] jArr2 = this.f8345b;
+            int i13 = i + 1;
+            ArraysKt___ArraysJvmKt.copyInto(jArr2, jArr2, i13, i, i12);
+            Object[] objArr3 = this.f8346c;
+            ArraysKt___ArraysJvmKt.copyInto(objArr3, objArr3, i13, i, this.f8347d);
+        }
+        this.f8345b[i] = j4;
+        this.f8346c[i] = obj;
+        this.f8347d++;
+    }
+
+    public final void f(long j4) {
+        int b4 = AbstractC0613a.b(this.f8345b, this.f8347d, j4);
+        if (b4 >= 0) {
+            Object[] objArr = this.f8346c;
+            Object obj = objArr[b4];
+            Object obj2 = h.f8348a;
+            if (obj != obj2) {
+                objArr[b4] = obj2;
+                this.f8344a = true;
+            }
+        }
+    }
+
+    public final int g() {
+        if (this.f8344a) {
+            int i = this.f8347d;
+            long[] jArr = this.f8345b;
+            Object[] objArr = this.f8346c;
+            int i4 = 0;
+            for (int i5 = 0; i5 < i; i5++) {
+                Object obj = objArr[i5];
+                if (obj != h.f8348a) {
+                    if (i5 != i4) {
+                        jArr[i4] = jArr[i5];
+                        objArr[i4] = obj;
+                        objArr[i5] = null;
+                    }
+                    i4++;
+                }
+            }
+            this.f8344a = false;
+            this.f8347d = i4;
+        }
+        return this.f8347d;
+    }
+
+    public final Object h(int i) {
+        int i4;
+        if (i < 0 || i >= (i4 = this.f8347d)) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "Expected index to be within 0..size()-1, but was ").toString());
+        }
+        if (this.f8344a) {
+            long[] jArr = this.f8345b;
+            Object[] objArr = this.f8346c;
+            int i5 = 0;
+            for (int i6 = 0; i6 < i4; i6++) {
+                Object obj = objArr[i6];
+                if (obj != h.f8348a) {
+                    if (i6 != i5) {
+                        jArr[i5] = jArr[i6];
+                        objArr[i5] = obj;
+                        objArr[i6] = null;
+                    }
+                    i5++;
+                }
+            }
+            this.f8344a = false;
+            this.f8347d = i5;
+        }
+        return this.f8346c[i];
+    }
+
+    public final String toString() {
+        if (g() <= 0) {
+            return "{}";
+        }
+        StringBuilder sb = new StringBuilder(this.f8347d * 28);
+        sb.append('{');
+        int i = this.f8347d;
+        for (int i4 = 0; i4 < i; i4++) {
+            if (i4 > 0) {
+                sb.append(", ");
+            }
+            sb.append(d(i4));
+            sb.append('=');
+            Object h = h(i4);
+            if (h != sb) {
+                sb.append(h);
+            } else {
+                sb.append("(this Map)");
+            }
+        }
+        sb.append('}');
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder(capacity).…builderAction).toString()");
+        return sb2;
+    }
+}

apk_decompiled/sources/s/h.java

@@ -0,0 +1,81 @@
+package s;
+
+import java.util.ConcurrentModificationException;
+import kotlin.jvm.internal.Intrinsics;
+import t.AbstractC0613a;
+
+/* loaded from: classes.dex */
+public abstract class h {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Object f8348a = new Object();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final Object f8349b = new Object();
+
+    public static final void a(k kVar) {
+        int i = kVar.f8356d;
+        int[] iArr = kVar.f8354b;
+        Object[] objArr = kVar.f8355c;
+        int i4 = 0;
+        for (int i5 = 0; i5 < i; i5++) {
+            Object obj = objArr[i5];
+            if (obj != f8349b) {
+                if (i5 != i4) {
+                    iArr[i4] = iArr[i5];
+                    objArr[i4] = obj;
+                    objArr[i5] = null;
+                }
+                i4++;
+            }
+        }
+        kVar.f8353a = false;
+        kVar.f8356d = i4;
+    }
+
+    public static final void b(f fVar, int i) {
+        Intrinsics.checkNotNullParameter(fVar, "<this>");
+        int[] iArr = new int[i];
+        fVar.getClass();
+        Intrinsics.checkNotNullParameter(iArr, "<set-?>");
+        fVar.f8341a = iArr;
+        Object[] objArr = new Object[i];
+        Intrinsics.checkNotNullParameter(objArr, "<set-?>");
+        fVar.f8342b = objArr;
+    }
+
+    public static final int c(f fVar, Object obj, int i) {
+        Intrinsics.checkNotNullParameter(fVar, "<this>");
+        int i4 = fVar.f8343c;
+        if (i4 == 0) {
+            return -1;
+        }
+        Intrinsics.checkNotNullParameter(fVar, "<this>");
+        try {
+            int a2 = AbstractC0613a.a(fVar.f8341a, fVar.f8343c, i);
+            if (a2 < 0 || Intrinsics.areEqual(obj, fVar.f8342b[a2])) {
+                return a2;
+            }
+            int i5 = a2 + 1;
+            while (i5 < i4 && fVar.f8341a[i5] == i) {
+                if (Intrinsics.areEqual(obj, fVar.f8342b[i5])) {
+                    return i5;
+                }
+                i5++;
+            }
+            for (int i6 = a2 - 1; i6 >= 0 && fVar.f8341a[i6] == i; i6--) {
+                if (Intrinsics.areEqual(obj, fVar.f8342b[i6])) {
+                    return i6;
+                }
+            }
+            return ~i5;
+        } catch (IndexOutOfBoundsException unused) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    public static final l d(k kVar) {
+        Intrinsics.checkNotNullParameter(kVar, "<this>");
+        return new l(kVar);
+    }
+}

apk_decompiled/sources/s/i.java

@@ -0,0 +1,337 @@
+package s;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+import t.C0614b;
+
+/* loaded from: classes.dex */
+public class i {
+    private int createCount;
+    private int evictionCount;
+    private int hitCount;
+    private final C0614b lock;
+    private final t.c map;
+    private int maxSize;
+    private int missCount;
+    private int putCount;
+    private int size;
+
+    /* JADX WARN: Type inference failed for: r1v3, types: [t.b, java.lang.Object] */
+    public i(int i) {
+        this.maxSize = i;
+        if (i <= 0) {
+            throw new IllegalArgumentException("maxSize <= 0");
+        }
+        this.map = new t.c();
+        this.lock = new Object();
+    }
+
+    public final int a(Object obj, Object obj2) {
+        int sizeOf = sizeOf(obj, obj2);
+        if (sizeOf >= 0) {
+            return sizeOf;
+        }
+        throw new IllegalStateException(("Negative size: " + obj + '=' + obj2).toString());
+    }
+
+    public Object create(Object key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return null;
+    }
+
+    public final int createCount() {
+        int i;
+        synchronized (this.lock) {
+            i = this.createCount;
+        }
+        return i;
+    }
+
+    public void entryRemoved(boolean z3, Object key, Object oldValue, Object obj) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(oldValue, "oldValue");
+    }
+
+    public final void evictAll() {
+        trimToSize(-1);
+    }
+
+    public final int evictionCount() {
+        int i;
+        synchronized (this.lock) {
+            i = this.evictionCount;
+        }
+        return i;
+    }
+
+    public final Object get(Object key) {
+        Object value;
+        Intrinsics.checkNotNullParameter(key, "key");
+        synchronized (this.lock) {
+            t.c cVar = this.map;
+            cVar.getClass();
+            Intrinsics.checkNotNullParameter(key, "key");
+            Object obj = cVar.f8508a.get(key);
+            if (obj != null) {
+                this.hitCount++;
+                return obj;
+            }
+            this.missCount++;
+            Object value2 = create(key);
+            if (value2 == null) {
+                return null;
+            }
+            synchronized (this.lock) {
+                try {
+                    this.createCount++;
+                    t.c cVar2 = this.map;
+                    cVar2.getClass();
+                    Intrinsics.checkNotNullParameter(key, "key");
+                    Intrinsics.checkNotNullParameter(value2, "value");
+                    value = cVar2.f8508a.put(key, value2);
+                    if (value != null) {
+                        t.c cVar3 = this.map;
+                        cVar3.getClass();
+                        Intrinsics.checkNotNullParameter(key, "key");
+                        Intrinsics.checkNotNullParameter(value, "value");
+                        cVar3.f8508a.put(key, value);
+                    } else {
+                        this.size += a(key, value2);
+                        Unit unit = Unit.INSTANCE;
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            if (value != null) {
+                entryRemoved(false, key, value2, value);
+                return value;
+            }
+            trimToSize(this.maxSize);
+            return value2;
+        }
+    }
+
+    public final int hitCount() {
+        int i;
+        synchronized (this.lock) {
+            i = this.hitCount;
+        }
+        return i;
+    }
+
+    public final int maxSize() {
+        int i;
+        synchronized (this.lock) {
+            i = this.maxSize;
+        }
+        return i;
+    }
+
+    public final int missCount() {
+        int i;
+        synchronized (this.lock) {
+            i = this.missCount;
+        }
+        return i;
+    }
+
+    public final Object put(Object key, Object value) {
+        Object put;
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(value, "value");
+        synchronized (this.lock) {
+            try {
+                this.putCount++;
+                this.size += a(key, value);
+                t.c cVar = this.map;
+                cVar.getClass();
+                Intrinsics.checkNotNullParameter(key, "key");
+                Intrinsics.checkNotNullParameter(value, "value");
+                put = cVar.f8508a.put(key, value);
+                if (put != null) {
+                    this.size -= a(key, put);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (put != null) {
+            entryRemoved(false, key, put, value);
+        }
+        trimToSize(this.maxSize);
+        return put;
+    }
+
+    public final int putCount() {
+        int i;
+        synchronized (this.lock) {
+            i = this.putCount;
+        }
+        return i;
+    }
+
+    public final Object remove(Object key) {
+        Object remove;
+        Intrinsics.checkNotNullParameter(key, "key");
+        synchronized (this.lock) {
+            try {
+                t.c cVar = this.map;
+                cVar.getClass();
+                Intrinsics.checkNotNullParameter(key, "key");
+                remove = cVar.f8508a.remove(key);
+                if (remove != null) {
+                    this.size -= a(key, remove);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (remove != null) {
+            entryRemoved(false, key, remove, null);
+        }
+        return remove;
+    }
+
+    public void resize(int i) {
+        if (i <= 0) {
+            throw new IllegalArgumentException("maxSize <= 0");
+        }
+        synchronized (this.lock) {
+            this.maxSize = i;
+            Unit unit = Unit.INSTANCE;
+        }
+        trimToSize(i);
+    }
+
+    public final int size() {
+        int i;
+        synchronized (this.lock) {
+            i = this.size;
+        }
+        return i;
+    }
+
+    public int sizeOf(Object key, Object value) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(value, "value");
+        return 1;
+    }
+
+    public final Map<Object, Object> snapshot() {
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        synchronized (this.lock) {
+            try {
+                Set<Map.Entry> entrySet = this.map.f8508a.entrySet();
+                Intrinsics.checkNotNullExpressionValue(entrySet, "map.entries");
+                for (Map.Entry entry : entrySet) {
+                    linkedHashMap.put(entry.getKey(), entry.getValue());
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return linkedHashMap;
+    }
+
+    public String toString() {
+        String str;
+        synchronized (this.lock) {
+            try {
+                int i = this.hitCount;
+                int i4 = this.missCount + i;
+                str = "LruCache[maxSize=" + this.maxSize + ",hits=" + this.hitCount + ",misses=" + this.missCount + ",hitRate=" + (i4 != 0 ? (i * 100) / i4 : 0) + "%]";
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return str;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:13:0x0073, code lost:
+    
+        throw new java.lang.IllegalStateException("LruCache.sizeOf() is reporting inconsistent results!");
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void trimToSize(int r6) {
+        /*
+            r5 = this;
+        L0:
+            t.b r0 = r5.lock
+            monitor-enter(r0)
+            int r1 = r5.size     // Catch: java.lang.Throwable -> L16
+            if (r1 < 0) goto L6c
+            t.c r1 = r5.map     // Catch: java.lang.Throwable -> L16
+            java.util.LinkedHashMap r1 = r1.f8508a     // Catch: java.lang.Throwable -> L16
+            boolean r1 = r1.isEmpty()     // Catch: java.lang.Throwable -> L16
+            if (r1 == 0) goto L18
+            int r1 = r5.size     // Catch: java.lang.Throwable -> L16
+            if (r1 != 0) goto L6c
+            goto L18
+        L16:
+            r5 = move-exception
+            goto L74
+        L18:
+            int r1 = r5.size     // Catch: java.lang.Throwable -> L16
+            if (r1 <= r6) goto L6a
+            t.c r1 = r5.map     // Catch: java.lang.Throwable -> L16
+            java.util.LinkedHashMap r1 = r1.f8508a     // Catch: java.lang.Throwable -> L16
+            boolean r1 = r1.isEmpty()     // Catch: java.lang.Throwable -> L16
+            if (r1 == 0) goto L27
+            goto L6a
+        L27:
+            t.c r1 = r5.map     // Catch: java.lang.Throwable -> L16
+            java.util.LinkedHashMap r1 = r1.f8508a     // Catch: java.lang.Throwable -> L16
+            java.util.Set r1 = r1.entrySet()     // Catch: java.lang.Throwable -> L16
+            java.lang.String r2 = "map.entries"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r1, r2)     // Catch: java.lang.Throwable -> L16
+            java.lang.Object r1 = kotlin.collections.CollectionsKt.firstOrNull(r1)     // Catch: java.lang.Throwable -> L16
+            java.util.Map$Entry r1 = (java.util.Map.Entry) r1     // Catch: java.lang.Throwable -> L16
+            if (r1 != 0) goto L3e
+            monitor-exit(r0)
+            return
+        L3e:
+            java.lang.Object r2 = r1.getKey()     // Catch: java.lang.Throwable -> L16
+            java.lang.Object r1 = r1.getValue()     // Catch: java.lang.Throwable -> L16
+            t.c r3 = r5.map     // Catch: java.lang.Throwable -> L16
+            r3.getClass()     // Catch: java.lang.Throwable -> L16
+            java.lang.String r4 = "key"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r2, r4)     // Catch: java.lang.Throwable -> L16
+            java.util.LinkedHashMap r3 = r3.f8508a     // Catch: java.lang.Throwable -> L16
+            r3.remove(r2)     // Catch: java.lang.Throwable -> L16
+            int r3 = r5.size     // Catch: java.lang.Throwable -> L16
+            int r4 = r5.a(r2, r1)     // Catch: java.lang.Throwable -> L16
+            int r3 = r3 - r4
+            r5.size = r3     // Catch: java.lang.Throwable -> L16
+            int r3 = r5.evictionCount     // Catch: java.lang.Throwable -> L16
+            r4 = 1
+            int r3 = r3 + r4
+            r5.evictionCount = r3     // Catch: java.lang.Throwable -> L16
+            monitor-exit(r0)
+            r0 = 0
+            r5.entryRemoved(r4, r2, r1, r0)
+            goto L0
+        L6a:
+            monitor-exit(r0)
+            return
+        L6c:
+            java.lang.String r5 = "LruCache.sizeOf() is reporting inconsistent results!"
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException     // Catch: java.lang.Throwable -> L16
+            r6.<init>(r5)     // Catch: java.lang.Throwable -> L16
+            throw r6     // Catch: java.lang.Throwable -> L16
+        L74:
+            monitor-exit(r0)
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: s.i.trimToSize(int):void");
+    }
+}

apk_decompiled/sources/s/j.java

@@ -0,0 +1,417 @@
+package s;
+
+import java.util.Arrays;
+import java.util.ConcurrentModificationException;
+import java.util.Map;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.jvm.internal.Intrinsics;
+import t.AbstractC0613a;
+
+/* loaded from: classes.dex */
+public class j {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int[] f8350a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object[] f8351b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f8352c;
+
+    public j(int i) {
+        this.f8350a = i == 0 ? AbstractC0613a.f8506a : new int[i];
+        this.f8351b = i == 0 ? AbstractC0613a.f8507b : new Object[i << 1];
+    }
+
+    public final int a(Object obj) {
+        int i = this.f8352c * 2;
+        Object[] objArr = this.f8351b;
+        if (obj == null) {
+            for (int i4 = 1; i4 < i; i4 += 2) {
+                if (objArr[i4] == null) {
+                    return i4 >> 1;
+                }
+            }
+            return -1;
+        }
+        for (int i5 = 1; i5 < i; i5 += 2) {
+            if (Intrinsics.areEqual(obj, objArr[i5])) {
+                return i5 >> 1;
+            }
+        }
+        return -1;
+    }
+
+    public final void b(int i) {
+        int i4 = this.f8352c;
+        int[] iArr = this.f8350a;
+        if (iArr.length < i) {
+            int[] copyOf = Arrays.copyOf(iArr, i);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+            this.f8350a = copyOf;
+            Object[] copyOf2 = Arrays.copyOf(this.f8351b, i * 2);
+            Intrinsics.checkNotNullExpressionValue(copyOf2, "copyOf(this, newSize)");
+            this.f8351b = copyOf2;
+        }
+        if (this.f8352c != i4) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    public final int c(int i, Object obj) {
+        int i4 = this.f8352c;
+        if (i4 == 0) {
+            return -1;
+        }
+        int a2 = AbstractC0613a.a(this.f8350a, i4, i);
+        if (a2 < 0 || Intrinsics.areEqual(obj, this.f8351b[a2 << 1])) {
+            return a2;
+        }
+        int i5 = a2 + 1;
+        while (i5 < i4 && this.f8350a[i5] == i) {
+            if (Intrinsics.areEqual(obj, this.f8351b[i5 << 1])) {
+                return i5;
+            }
+            i5++;
+        }
+        for (int i6 = a2 - 1; i6 >= 0 && this.f8350a[i6] == i; i6--) {
+            if (Intrinsics.areEqual(obj, this.f8351b[i6 << 1])) {
+                return i6;
+            }
+        }
+        return ~i5;
+    }
+
+    public final void clear() {
+        if (this.f8352c > 0) {
+            this.f8350a = AbstractC0613a.f8506a;
+            this.f8351b = AbstractC0613a.f8507b;
+            this.f8352c = 0;
+        }
+        if (this.f8352c > 0) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    public boolean containsKey(Object obj) {
+        return d(obj) >= 0;
+    }
+
+    public boolean containsValue(Object obj) {
+        return a(obj) >= 0;
+    }
+
+    public final int d(Object obj) {
+        return obj == null ? e() : c(obj.hashCode(), obj);
+    }
+
+    public final int e() {
+        int i = this.f8352c;
+        if (i == 0) {
+            return -1;
+        }
+        int a2 = AbstractC0613a.a(this.f8350a, i, 0);
+        if (a2 < 0 || this.f8351b[a2 << 1] == null) {
+            return a2;
+        }
+        int i4 = a2 + 1;
+        while (i4 < i && this.f8350a[i4] == 0) {
+            if (this.f8351b[i4 << 1] == null) {
+                return i4;
+            }
+            i4++;
+        }
+        for (int i5 = a2 - 1; i5 >= 0 && this.f8350a[i5] == 0; i5--) {
+            if (this.f8351b[i5 << 1] == null) {
+                return i5;
+            }
+        }
+        return ~i4;
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        try {
+            if (obj instanceof j) {
+                int i = this.f8352c;
+                if (i != ((j) obj).f8352c) {
+                    return false;
+                }
+                j jVar = (j) obj;
+                for (int i4 = 0; i4 < i; i4++) {
+                    Object f2 = f(i4);
+                    Object i5 = i(i4);
+                    Object obj2 = jVar.get(f2);
+                    if (i5 == null) {
+                        if (obj2 != null || !jVar.containsKey(f2)) {
+                            return false;
+                        }
+                    } else if (!Intrinsics.areEqual(i5, obj2)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if (!(obj instanceof Map) || this.f8352c != ((Map) obj).size()) {
+                return false;
+            }
+            int i6 = this.f8352c;
+            for (int i7 = 0; i7 < i6; i7++) {
+                Object f4 = f(i7);
+                Object i8 = i(i7);
+                Object obj3 = ((Map) obj).get(f4);
+                if (i8 == null) {
+                    if (obj3 != null || !((Map) obj).containsKey(f4)) {
+                        return false;
+                    }
+                } else if (!Intrinsics.areEqual(i8, obj3)) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (ClassCastException | NullPointerException unused) {
+        }
+        return false;
+    }
+
+    public final Object f(int i) {
+        if (i < 0 || i >= this.f8352c) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "Expected index to be within 0..size()-1, but was ").toString());
+        }
+        return this.f8351b[i << 1];
+    }
+
+    public final Object g(int i) {
+        int i4;
+        if (i < 0 || i >= (i4 = this.f8352c)) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "Expected index to be within 0..size()-1, but was ").toString());
+        }
+        Object[] objArr = this.f8351b;
+        int i5 = i << 1;
+        Object obj = objArr[i5 + 1];
+        if (i4 <= 1) {
+            clear();
+            return obj;
+        }
+        int i6 = i4 - 1;
+        int[] iArr = this.f8350a;
+        if (iArr.length <= 8 || i4 >= iArr.length / 3) {
+            if (i < i6) {
+                int i7 = i + 1;
+                ArraysKt___ArraysJvmKt.copyInto(iArr, iArr, i, i7, i4);
+                Object[] objArr2 = this.f8351b;
+                ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i5, i7 << 1, i4 << 1);
+            }
+            Object[] objArr3 = this.f8351b;
+            int i8 = i6 << 1;
+            objArr3[i8] = null;
+            objArr3[i8 + 1] = null;
+        } else {
+            int i9 = i4 > 8 ? i4 + (i4 >> 1) : 8;
+            int[] copyOf = Arrays.copyOf(iArr, i9);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+            this.f8350a = copyOf;
+            Object[] copyOf2 = Arrays.copyOf(this.f8351b, i9 << 1);
+            Intrinsics.checkNotNullExpressionValue(copyOf2, "copyOf(this, newSize)");
+            this.f8351b = copyOf2;
+            if (i4 != this.f8352c) {
+                throw new ConcurrentModificationException();
+            }
+            if (i > 0) {
+                ArraysKt___ArraysJvmKt.copyInto(iArr, this.f8350a, 0, 0, i);
+                ArraysKt___ArraysJvmKt.copyInto(objArr, this.f8351b, 0, 0, i5);
+            }
+            if (i < i6) {
+                int i10 = i + 1;
+                ArraysKt___ArraysJvmKt.copyInto(iArr, this.f8350a, i, i10, i4);
+                ArraysKt___ArraysJvmKt.copyInto(objArr, this.f8351b, i5, i10 << 1, i4 << 1);
+            }
+        }
+        if (i4 != this.f8352c) {
+            throw new ConcurrentModificationException();
+        }
+        this.f8352c = i6;
+        return obj;
+    }
+
+    public Object get(Object obj) {
+        int d4 = d(obj);
+        if (d4 >= 0) {
+            return this.f8351b[(d4 << 1) + 1];
+        }
+        return null;
+    }
+
+    public final Object getOrDefault(Object obj, Object obj2) {
+        int d4 = d(obj);
+        return d4 >= 0 ? this.f8351b[(d4 << 1) + 1] : obj2;
+    }
+
+    public final Object h(int i, Object obj) {
+        if (i < 0 || i >= this.f8352c) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "Expected index to be within 0..size()-1, but was ").toString());
+        }
+        int i4 = (i << 1) + 1;
+        Object[] objArr = this.f8351b;
+        Object obj2 = objArr[i4];
+        objArr[i4] = obj;
+        return obj2;
+    }
+
+    public final int hashCode() {
+        int[] iArr = this.f8350a;
+        Object[] objArr = this.f8351b;
+        int i = this.f8352c;
+        int i4 = 1;
+        int i5 = 0;
+        int i6 = 0;
+        while (i5 < i) {
+            Object obj = objArr[i4];
+            i6 += (obj != null ? obj.hashCode() : 0) ^ iArr[i5];
+            i5++;
+            i4 += 2;
+        }
+        return i6;
+    }
+
+    public final Object i(int i) {
+        if (i < 0 || i >= this.f8352c) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "Expected index to be within 0..size()-1, but was ").toString());
+        }
+        return this.f8351b[(i << 1) + 1];
+    }
+
+    public final boolean isEmpty() {
+        return this.f8352c <= 0;
+    }
+
+    public final Object put(Object obj, Object obj2) {
+        int i = this.f8352c;
+        int hashCode = obj != null ? obj.hashCode() : 0;
+        int c4 = obj != null ? c(hashCode, obj) : e();
+        if (c4 >= 0) {
+            int i4 = (c4 << 1) + 1;
+            Object[] objArr = this.f8351b;
+            Object obj3 = objArr[i4];
+            objArr[i4] = obj2;
+            return obj3;
+        }
+        int i5 = ~c4;
+        int[] iArr = this.f8350a;
+        if (i >= iArr.length) {
+            int i6 = 8;
+            if (i >= 8) {
+                i6 = (i >> 1) + i;
+            } else if (i < 4) {
+                i6 = 4;
+            }
+            int[] copyOf = Arrays.copyOf(iArr, i6);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+            this.f8350a = copyOf;
+            Object[] copyOf2 = Arrays.copyOf(this.f8351b, i6 << 1);
+            Intrinsics.checkNotNullExpressionValue(copyOf2, "copyOf(this, newSize)");
+            this.f8351b = copyOf2;
+            if (i != this.f8352c) {
+                throw new ConcurrentModificationException();
+            }
+        }
+        if (i5 < i) {
+            int[] iArr2 = this.f8350a;
+            int i7 = i5 + 1;
+            ArraysKt___ArraysJvmKt.copyInto(iArr2, iArr2, i7, i5, i);
+            Object[] objArr2 = this.f8351b;
+            ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i7 << 1, i5 << 1, this.f8352c << 1);
+        }
+        int i8 = this.f8352c;
+        if (i == i8) {
+            int[] iArr3 = this.f8350a;
+            if (i5 < iArr3.length) {
+                iArr3[i5] = hashCode;
+                Object[] objArr3 = this.f8351b;
+                int i9 = i5 << 1;
+                objArr3[i9] = obj;
+                objArr3[i9 + 1] = obj2;
+                this.f8352c = i8 + 1;
+                return null;
+            }
+        }
+        throw new ConcurrentModificationException();
+    }
+
+    public final Object putIfAbsent(Object obj, Object obj2) {
+        Object obj3 = get(obj);
+        return obj3 == null ? put(obj, obj2) : obj3;
+    }
+
+    public Object remove(Object obj) {
+        int d4 = d(obj);
+        if (d4 >= 0) {
+            return g(d4);
+        }
+        return null;
+    }
+
+    public final Object replace(Object obj, Object obj2) {
+        int d4 = d(obj);
+        if (d4 >= 0) {
+            return h(d4, obj2);
+        }
+        return null;
+    }
+
+    public final int size() {
+        return this.f8352c;
+    }
+
+    public final String toString() {
+        if (isEmpty()) {
+            return "{}";
+        }
+        StringBuilder sb = new StringBuilder(this.f8352c * 28);
+        sb.append('{');
+        int i = this.f8352c;
+        for (int i4 = 0; i4 < i; i4++) {
+            if (i4 > 0) {
+                sb.append(", ");
+            }
+            Object f2 = f(i4);
+            if (f2 != sb) {
+                sb.append(f2);
+            } else {
+                sb.append("(this Map)");
+            }
+            sb.append('=');
+            Object i5 = i(i4);
+            if (i5 != sb) {
+                sb.append(i5);
+            } else {
+                sb.append("(this Map)");
+            }
+        }
+        sb.append('}');
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder(capacity).…builderAction).toString()");
+        return sb2;
+    }
+
+    public final boolean remove(Object obj, Object obj2) {
+        int d4 = d(obj);
+        if (d4 < 0 || !Intrinsics.areEqual(obj2, i(d4))) {
+            return false;
+        }
+        g(d4);
+        return true;
+    }
+
+    public final boolean replace(Object obj, Object obj2, Object obj3) {
+        int d4 = d(obj);
+        if (d4 < 0 || !Intrinsics.areEqual(obj2, i(d4))) {
+            return false;
+        }
+        h(d4, obj3);
+        return true;
+    }
+}

apk_decompiled/sources/s/k.java

@@ -0,0 +1,221 @@
+package s;
+
+import java.util.Arrays;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.jvm.internal.Intrinsics;
+import o0.C0529f;
+import t.AbstractC0613a;
+
+/* loaded from: classes.dex */
+public final class k implements Cloneable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public /* synthetic */ boolean f8353a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ int[] f8354b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public /* synthetic */ Object[] f8355c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public /* synthetic */ int f8356d;
+
+    public k() {
+        int i;
+        int i4 = 4;
+        while (true) {
+            i = 40;
+            if (i4 >= 32) {
+                break;
+            }
+            int i5 = (1 << i4) - 12;
+            if (40 <= i5) {
+                i = i5;
+                break;
+            }
+            i4++;
+        }
+        int i6 = i / 4;
+        this.f8354b = new int[i6];
+        this.f8355c = new Object[i6];
+    }
+
+    public final void a(int i, Object obj) {
+        int i4 = this.f8356d;
+        if (i4 != 0 && i <= this.f8354b[i4 - 1]) {
+            e(i, obj);
+            return;
+        }
+        if (this.f8353a && i4 >= this.f8354b.length) {
+            h.a(this);
+        }
+        int i5 = this.f8356d;
+        if (i5 >= this.f8354b.length) {
+            int i6 = (i5 + 1) * 4;
+            int i7 = 4;
+            while (true) {
+                if (i7 >= 32) {
+                    break;
+                }
+                int i8 = (1 << i7) - 12;
+                if (i6 <= i8) {
+                    i6 = i8;
+                    break;
+                }
+                i7++;
+            }
+            int i9 = i6 / 4;
+            int[] copyOf = Arrays.copyOf(this.f8354b, i9);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+            this.f8354b = copyOf;
+            Object[] copyOf2 = Arrays.copyOf(this.f8355c, i9);
+            Intrinsics.checkNotNullExpressionValue(copyOf2, "copyOf(this, newSize)");
+            this.f8355c = copyOf2;
+        }
+        this.f8354b[i5] = i;
+        this.f8355c[i5] = obj;
+        this.f8356d = i5 + 1;
+    }
+
+    public final boolean b(C0529f c0529f) {
+        if (this.f8353a) {
+            h.a(this);
+        }
+        int i = this.f8356d;
+        int i4 = 0;
+        while (true) {
+            if (i4 >= i) {
+                i4 = -1;
+                break;
+            }
+            if (this.f8355c[i4] == c0529f) {
+                break;
+            }
+            i4++;
+        }
+        return i4 >= 0;
+    }
+
+    public final Object c(int i) {
+        Object obj;
+        Intrinsics.checkNotNullParameter(this, "<this>");
+        int a2 = AbstractC0613a.a(this.f8354b, this.f8356d, i);
+        if (a2 < 0 || (obj = this.f8355c[a2]) == h.f8349b) {
+            return null;
+        }
+        return obj;
+    }
+
+    public final Object clone() {
+        Object clone = super.clone();
+        Intrinsics.checkNotNull(clone, "null cannot be cast to non-null type androidx.collection.SparseArrayCompat<E of androidx.collection.SparseArrayCompat>");
+        k kVar = (k) clone;
+        kVar.f8354b = (int[]) this.f8354b.clone();
+        kVar.f8355c = (Object[]) this.f8355c.clone();
+        return kVar;
+    }
+
+    public final int d(int i) {
+        if (this.f8353a) {
+            h.a(this);
+        }
+        return this.f8354b[i];
+    }
+
+    public final void e(int i, Object obj) {
+        int a2 = AbstractC0613a.a(this.f8354b, this.f8356d, i);
+        if (a2 >= 0) {
+            this.f8355c[a2] = obj;
+            return;
+        }
+        int i4 = ~a2;
+        int i5 = this.f8356d;
+        if (i4 < i5) {
+            Object[] objArr = this.f8355c;
+            if (objArr[i4] == h.f8349b) {
+                this.f8354b[i4] = i;
+                objArr[i4] = obj;
+                return;
+            }
+        }
+        if (this.f8353a && i5 >= this.f8354b.length) {
+            h.a(this);
+            i4 = ~AbstractC0613a.a(this.f8354b, this.f8356d, i);
+        }
+        int i6 = this.f8356d;
+        if (i6 >= this.f8354b.length) {
+            int i7 = (i6 + 1) * 4;
+            int i8 = 4;
+            while (true) {
+                if (i8 >= 32) {
+                    break;
+                }
+                int i9 = (1 << i8) - 12;
+                if (i7 <= i9) {
+                    i7 = i9;
+                    break;
+                }
+                i8++;
+            }
+            int i10 = i7 / 4;
+            int[] copyOf = Arrays.copyOf(this.f8354b, i10);
+            Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(this, newSize)");
+            this.f8354b = copyOf;
+            Object[] copyOf2 = Arrays.copyOf(this.f8355c, i10);
+            Intrinsics.checkNotNullExpressionValue(copyOf2, "copyOf(this, newSize)");
+            this.f8355c = copyOf2;
+        }
+        int i11 = this.f8356d;
+        if (i11 - i4 != 0) {
+            int[] iArr = this.f8354b;
+            int i12 = i4 + 1;
+            ArraysKt___ArraysJvmKt.copyInto(iArr, iArr, i12, i4, i11);
+            Object[] objArr2 = this.f8355c;
+            ArraysKt___ArraysJvmKt.copyInto(objArr2, objArr2, i12, i4, this.f8356d);
+        }
+        this.f8354b[i4] = i;
+        this.f8355c[i4] = obj;
+        this.f8356d++;
+    }
+
+    public final int f() {
+        if (this.f8353a) {
+            h.a(this);
+        }
+        return this.f8356d;
+    }
+
+    public final Object g(int i) {
+        if (this.f8353a) {
+            h.a(this);
+        }
+        return this.f8355c[i];
+    }
+
+    public final String toString() {
+        if (f() <= 0) {
+            return "{}";
+        }
+        StringBuilder sb = new StringBuilder(this.f8356d * 28);
+        sb.append('{');
+        int i = this.f8356d;
+        for (int i4 = 0; i4 < i; i4++) {
+            if (i4 > 0) {
+                sb.append(", ");
+            }
+            sb.append(d(i4));
+            sb.append('=');
+            Object g4 = g(i4);
+            if (g4 != this) {
+                sb.append(g4);
+            } else {
+                sb.append("(this Map)");
+            }
+        }
+        sb.append('}');
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "buffer.toString()");
+        return sb2;
+    }
+}

apk_decompiled/sources/s/l.java

@@ -0,0 +1,35 @@
+package s;
+
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes.dex */
+public final class l implements Iterator, KMappedMarker {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f8357a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ k f8358b;
+
+    public l(k kVar) {
+        this.f8358b = kVar;
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return this.f8357a < this.f8358b.f();
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        int i = this.f8357a;
+        this.f8357a = i + 1;
+        return this.f8358b.g(i);
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+}