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/S2/a.java

@@ -0,0 +1,35 @@
+package S2;
+
+import java.io.Serializable;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public final class a implements GenericArrayType, Serializable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Type f1580a;
+
+    public a(Type type) {
+        Objects.requireNonNull(type);
+        this.f1580a = d.a(type);
+    }
+
+    public final boolean equals(Object obj) {
+        return (obj instanceof GenericArrayType) && d.d(this, (GenericArrayType) obj);
+    }
+
+    @Override // java.lang.reflect.GenericArrayType
+    public final Type getGenericComponentType() {
+        return this.f1580a;
+    }
+
+    public final int hashCode() {
+        return this.f1580a.hashCode();
+    }
+
+    public final String toString() {
+        return d.i(this.f1580a) + "[]";
+    }
+}

apk_decompiled/sources/S2/b.java

@@ -0,0 +1,89 @@
+package S2;
+
+import java.io.Serializable;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public final class b implements ParameterizedType, Serializable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Type f1581a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Type f1582b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Type[] f1583c;
+
+    public b(Type type, Type type2, Type... typeArr) {
+        Objects.requireNonNull(type2);
+        if (type2 instanceof Class) {
+            Class cls = (Class) type2;
+            boolean z3 = true;
+            boolean z4 = Modifier.isStatic(cls.getModifiers()) || cls.getEnclosingClass() == null;
+            if (type == null && !z4) {
+                z3 = false;
+            }
+            d.b(z3);
+        }
+        this.f1581a = type == null ? null : d.a(type);
+        this.f1582b = d.a(type2);
+        Type[] typeArr2 = (Type[]) typeArr.clone();
+        this.f1583c = typeArr2;
+        int length = typeArr2.length;
+        for (int i = 0; i < length; i++) {
+            Objects.requireNonNull(this.f1583c[i]);
+            d.c(this.f1583c[i]);
+            Type[] typeArr3 = this.f1583c;
+            typeArr3[i] = d.a(typeArr3[i]);
+        }
+    }
+
+    public final boolean equals(Object obj) {
+        return (obj instanceof ParameterizedType) && d.d(this, (ParameterizedType) obj);
+    }
+
+    @Override // java.lang.reflect.ParameterizedType
+    public final Type[] getActualTypeArguments() {
+        return (Type[]) this.f1583c.clone();
+    }
+
+    @Override // java.lang.reflect.ParameterizedType
+    public final Type getOwnerType() {
+        return this.f1581a;
+    }
+
+    @Override // java.lang.reflect.ParameterizedType
+    public final Type getRawType() {
+        return this.f1582b;
+    }
+
+    public final int hashCode() {
+        int hashCode = Arrays.hashCode(this.f1583c) ^ this.f1582b.hashCode();
+        Type type = this.f1581a;
+        return (type != null ? type.hashCode() : 0) ^ hashCode;
+    }
+
+    public final String toString() {
+        Type[] typeArr = this.f1583c;
+        int length = typeArr.length;
+        Type type = this.f1582b;
+        if (length == 0) {
+            return d.i(type);
+        }
+        StringBuilder sb = new StringBuilder((length + 1) * 30);
+        sb.append(d.i(type));
+        sb.append("<");
+        sb.append(d.i(typeArr[0]));
+        for (int i = 1; i < length; i++) {
+            sb.append(", ");
+            sb.append(d.i(typeArr[i]));
+        }
+        sb.append(">");
+        return sb.toString();
+    }
+}

apk_decompiled/sources/S2/c.java

@@ -0,0 +1,65 @@
+package S2;
+
+import java.io.Serializable;
+import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public final class c implements WildcardType, Serializable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Type f1584a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Type f1585b;
+
+    public c(Type[] typeArr, Type[] typeArr2) {
+        d.b(typeArr2.length <= 1);
+        d.b(typeArr.length == 1);
+        if (typeArr2.length != 1) {
+            Objects.requireNonNull(typeArr[0]);
+            d.c(typeArr[0]);
+            this.f1585b = null;
+            this.f1584a = d.a(typeArr[0]);
+            return;
+        }
+        Objects.requireNonNull(typeArr2[0]);
+        d.c(typeArr2[0]);
+        d.b(typeArr[0] == Object.class);
+        this.f1585b = d.a(typeArr2[0]);
+        this.f1584a = Object.class;
+    }
+
+    public final boolean equals(Object obj) {
+        return (obj instanceof WildcardType) && d.d(this, (WildcardType) obj);
+    }
+
+    @Override // java.lang.reflect.WildcardType
+    public final Type[] getLowerBounds() {
+        Type type = this.f1585b;
+        return type != null ? new Type[]{type} : d.f1586a;
+    }
+
+    @Override // java.lang.reflect.WildcardType
+    public final Type[] getUpperBounds() {
+        return new Type[]{this.f1584a};
+    }
+
+    public final int hashCode() {
+        Type type = this.f1585b;
+        return (this.f1584a.hashCode() + 31) ^ (type != null ? type.hashCode() + 31 : 1);
+    }
+
+    public final String toString() {
+        Type type = this.f1585b;
+        if (type != null) {
+            return "? super " + d.i(type);
+        }
+        Type type2 = this.f1584a;
+        if (type2 == Object.class) {
+            return "?";
+        }
+        return "? extends " + d.i(type2);
+    }
+}

apk_decompiled/sources/S2/d.java

@@ -0,0 +1,192 @@
+package S2;
+
+import C.w;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public abstract class d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Type[] f1586a = new Type[0];
+
+    public static Type a(Type type) {
+        if (type instanceof Class) {
+            Class cls = (Class) type;
+            return cls.isArray() ? new a(a(cls.getComponentType())) : cls;
+        }
+        if (type instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            return new b(parameterizedType.getOwnerType(), parameterizedType.getRawType(), parameterizedType.getActualTypeArguments());
+        }
+        if (type instanceof GenericArrayType) {
+            return new a(((GenericArrayType) type).getGenericComponentType());
+        }
+        if (!(type instanceof WildcardType)) {
+            return type;
+        }
+        WildcardType wildcardType = (WildcardType) type;
+        return new c(wildcardType.getUpperBounds(), wildcardType.getLowerBounds());
+    }
+
+    public static void b(boolean z3) {
+        if (!z3) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void c(Type type) {
+        b(((type instanceof Class) && ((Class) type).isPrimitive()) ? false : true);
+    }
+
+    public static boolean d(Type type, Type type2) {
+        if (type == type2) {
+            return true;
+        }
+        if (type instanceof Class) {
+            return type.equals(type2);
+        }
+        if (type instanceof ParameterizedType) {
+            if (!(type2 instanceof ParameterizedType)) {
+                return false;
+            }
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            ParameterizedType parameterizedType2 = (ParameterizedType) type2;
+            return Objects.equals(parameterizedType.getOwnerType(), parameterizedType2.getOwnerType()) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
+        }
+        if (type instanceof GenericArrayType) {
+            if (type2 instanceof GenericArrayType) {
+                return d(((GenericArrayType) type).getGenericComponentType(), ((GenericArrayType) type2).getGenericComponentType());
+            }
+            return false;
+        }
+        if (type instanceof WildcardType) {
+            if (!(type2 instanceof WildcardType)) {
+                return false;
+            }
+            WildcardType wildcardType = (WildcardType) type;
+            WildcardType wildcardType2 = (WildcardType) type2;
+            return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
+        }
+        if (!(type instanceof TypeVariable) || !(type2 instanceof TypeVariable)) {
+            return false;
+        }
+        TypeVariable typeVariable = (TypeVariable) type;
+        TypeVariable typeVariable2 = (TypeVariable) type2;
+        return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
+    }
+
+    public static void e(List list) {
+        Iterator it = list.iterator();
+        if (it.hasNext()) {
+            throw w.g(it);
+        }
+    }
+
+    public static Type f(Type type, Class cls, Class cls2) {
+        if (cls2 == cls) {
+            return type;
+        }
+        if (cls2.isInterface()) {
+            Class<?>[] interfaces = cls.getInterfaces();
+            int length = interfaces.length;
+            for (int i = 0; i < length; i++) {
+                Class<?> cls3 = interfaces[i];
+                if (cls3 == cls2) {
+                    return cls.getGenericInterfaces()[i];
+                }
+                if (cls2.isAssignableFrom(cls3)) {
+                    return f(cls.getGenericInterfaces()[i], interfaces[i], cls2);
+                }
+            }
+        }
+        if (!cls.isInterface()) {
+            while (cls != Object.class) {
+                Class<?> superclass = cls.getSuperclass();
+                if (superclass == cls2) {
+                    return cls.getGenericSuperclass();
+                }
+                if (cls2.isAssignableFrom(superclass)) {
+                    return f(cls.getGenericSuperclass(), superclass, cls2);
+                }
+                cls = superclass;
+            }
+        }
+        return cls2;
+    }
+
+    public static Class g(Type type) {
+        if (type instanceof Class) {
+            return (Class) type;
+        }
+        if (type instanceof ParameterizedType) {
+            Type rawType = ((ParameterizedType) type).getRawType();
+            b(rawType instanceof Class);
+            return (Class) rawType;
+        }
+        if (type instanceof GenericArrayType) {
+            return Array.newInstance((Class<?>) g(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
+        }
+        if (type instanceof TypeVariable) {
+            return Object.class;
+        }
+        if (type instanceof WildcardType) {
+            return g(((WildcardType) type).getUpperBounds()[0]);
+        }
+        throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName()));
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:25:0x013b, code lost:
+    
+        if (r3 == null) goto L81;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:26:0x013d, code lost:
+    
+        r12.put(r3, r11);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:27:0x0140, code lost:
+    
+        return r11;
+     */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x013b A[EDGE_INSN: B:24:0x013b->B:25:0x013b BREAK  A[LOOP:0: B:2:0x0004->B:29:?], SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:29:? A[LOOP:0: B:2:0x0004->B:29:?, LOOP_END, SYNTHETIC] */
+    /* JADX WARN: Type inference failed for: r11v0, types: [java.lang.reflect.Type] */
+    /* JADX WARN: Type inference failed for: r11v1, types: [java.lang.reflect.Type] */
+    /* JADX WARN: Type inference failed for: r11v10, types: [java.lang.reflect.Type, java.lang.Object] */
+    /* JADX WARN: Type inference failed for: r11v14 */
+    /* JADX WARN: Type inference failed for: r11v15 */
+    /* JADX WARN: Type inference failed for: r11v17, types: [java.lang.reflect.Type[]] */
+    /* JADX WARN: Type inference failed for: r11v18 */
+    /* JADX WARN: Type inference failed for: r11v2, types: [java.lang.reflect.WildcardType] */
+    /* JADX WARN: Type inference failed for: r11v3, types: [S2.c] */
+    /* JADX WARN: Type inference failed for: r11v4, types: [S2.c] */
+    /* JADX WARN: Type inference failed for: r11v5, types: [java.lang.reflect.ParameterizedType] */
+    /* JADX WARN: Type inference failed for: r11v6, types: [java.lang.reflect.GenericArrayType] */
+    /* JADX WARN: Type inference failed for: r11v7 */
+    /* JADX WARN: Type inference failed for: r11v9 */
+    /* JADX WARN: Type inference failed for: r12v0, types: [java.util.HashMap] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static java.lang.reflect.Type h(java.lang.reflect.Type r9, java.lang.Class r10, java.lang.reflect.Type r11, java.util.HashMap r12) {
+        /*
+            Method dump skipped, instructions count: 321
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: S2.d.h(java.lang.reflect.Type, java.lang.Class, java.lang.reflect.Type, java.util.HashMap):java.lang.reflect.Type");
+    }
+
+    public static String i(Type type) {
+        return type instanceof Class ? ((Class) type).getName() : type.toString();
+    }
+}

apk_decompiled/sources/S2/e.java

@@ -0,0 +1,42 @@
+package S2;
+
+import android.text.TextUtils;
+
+/* loaded from: classes3.dex */
+public final class e implements p, d0.m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f1587a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f1588b;
+
+    public /* synthetic */ e(String str, int i) {
+        this.f1587a = i;
+        this.f1588b = str;
+    }
+
+    @Override // d0.m
+    public Object d() {
+        return this;
+    }
+
+    @Override // S2.p
+    public Object j() {
+        switch (this.f1587a) {
+            case 0:
+                throw new RuntimeException(this.f1588b);
+            default:
+                throw new RuntimeException(this.f1588b);
+        }
+    }
+
+    @Override // d0.m
+    public boolean k(CharSequence charSequence, int i, int i4, d0.t tVar) {
+        if (!TextUtils.equals(charSequence.subSequence(i, i4), this.f1588b)) {
+            return true;
+        }
+        tVar.f6157c = (tVar.f6157c & 3) | 4;
+        return false;
+    }
+}

apk_decompiled/sources/S2/f.java

@@ -0,0 +1,47 @@
+package S2;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.EnumMap;
+import java.util.EnumSet;
+
+/* loaded from: classes3.dex */
+public final class f implements p {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f1589a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Type f1590b;
+
+    public /* synthetic */ f(int i, Type type) {
+        this.f1589a = i;
+        this.f1590b = type;
+    }
+
+    @Override // S2.p
+    public final Object j() {
+        switch (this.f1589a) {
+            case 0:
+                Type type = this.f1590b;
+                if (!(type instanceof ParameterizedType)) {
+                    throw new RuntimeException("Invalid EnumSet type: " + type.toString());
+                }
+                Type type2 = ((ParameterizedType) type).getActualTypeArguments()[0];
+                if (type2 instanceof Class) {
+                    return EnumSet.noneOf((Class) type2);
+                }
+                throw new RuntimeException("Invalid EnumSet type: " + type.toString());
+            default:
+                Type type3 = this.f1590b;
+                if (!(type3 instanceof ParameterizedType)) {
+                    throw new RuntimeException("Invalid EnumMap type: " + type3.toString());
+                }
+                Type type4 = ((ParameterizedType) type3).getActualTypeArguments()[0];
+                if (type4 instanceof Class) {
+                    return new EnumMap((Class) type4);
+                }
+                throw new RuntimeException("Invalid EnumMap type: " + type3.toString());
+        }
+    }
+}

apk_decompiled/sources/S2/g.java

@@ -0,0 +1,97 @@
+package S2;
+
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class g extends Q2.l {
+
+    /* renamed from: a, reason: collision with root package name */
+    public Q2.l f1591a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ boolean f1592b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ boolean f1593c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Q2.d f1594d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ X2.a f1595e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ h f1596f;
+
+    public g(h hVar, boolean z3, boolean z4, Q2.d dVar, X2.a aVar) {
+        this.f1596f = hVar;
+        this.f1592b = z3;
+        this.f1593c = z4;
+        this.f1594d = dVar;
+        this.f1595e = aVar;
+    }
+
+    @Override // Q2.l
+    public final Object a(Y2.a aVar) {
+        if (this.f1592b) {
+            aVar.u0();
+            return null;
+        }
+        Q2.l lVar = this.f1591a;
+        if (lVar == null) {
+            X2.a aVar2 = this.f1595e;
+            Q2.d dVar = this.f1594d;
+            List<Q2.m> list = dVar.f1383e;
+            Q2.m mVar = this.f1596f;
+            if (!list.contains(mVar)) {
+                mVar = dVar.f1382d;
+            }
+            boolean z3 = false;
+            for (Q2.m mVar2 : list) {
+                if (z3) {
+                    Q2.l a2 = mVar2.a(dVar, aVar2);
+                    if (a2 != null) {
+                        this.f1591a = a2;
+                        lVar = a2;
+                    }
+                } else if (mVar2 == mVar) {
+                    z3 = true;
+                }
+            }
+            throw new IllegalArgumentException("GSON cannot serialize " + aVar2);
+        }
+        return lVar.a(aVar);
+    }
+
+    @Override // Q2.l
+    public final void b(Y2.b bVar, Object obj) {
+        if (this.f1593c) {
+            bVar.b0();
+            return;
+        }
+        Q2.l lVar = this.f1591a;
+        if (lVar == null) {
+            X2.a aVar = this.f1595e;
+            Q2.d dVar = this.f1594d;
+            List<Q2.m> list = dVar.f1383e;
+            Q2.m mVar = this.f1596f;
+            if (!list.contains(mVar)) {
+                mVar = dVar.f1382d;
+            }
+            boolean z3 = false;
+            for (Q2.m mVar2 : list) {
+                if (z3) {
+                    Q2.l a2 = mVar2.a(dVar, aVar);
+                    if (a2 != null) {
+                        this.f1591a = a2;
+                        lVar = a2;
+                    }
+                } else if (mVar2 == mVar) {
+                    z3 = true;
+                }
+            }
+            throw new IllegalArgumentException("GSON cannot serialize " + aVar);
+        }
+        lVar.b(bVar, obj);
+    }
+}

apk_decompiled/sources/S2/h.java

@@ -0,0 +1,73 @@
+package S2;
+
+import C.w;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class h implements Q2.m, Cloneable {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final h f1597c;
+
+    /* renamed from: a, reason: collision with root package name */
+    public List f1598a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public List f1599b;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [java.lang.Object, S2.h] */
+    static {
+        ?? obj = new Object();
+        List list = Collections.EMPTY_LIST;
+        obj.f1598a = list;
+        obj.f1599b = list;
+        f1597c = obj;
+    }
+
+    public static boolean c(Class cls) {
+        if (Enum.class.isAssignableFrom(cls) || (cls.getModifiers() & 8) != 0) {
+            return false;
+        }
+        return cls.isAnonymousClass() || cls.isLocalClass();
+    }
+
+    @Override // Q2.m
+    public final Q2.l a(Q2.d dVar, X2.a aVar) {
+        boolean z3;
+        boolean z4;
+        boolean c4 = c(aVar.getRawType());
+        if (c4) {
+            z3 = true;
+        } else {
+            b(true);
+            z3 = false;
+        }
+        if (c4) {
+            z4 = true;
+        } else {
+            b(false);
+            z4 = false;
+        }
+        if (z3 || z4) {
+            return new g(this, z4, z3, dVar, aVar);
+        }
+        return null;
+    }
+
+    public final void b(boolean z3) {
+        Iterator it = (z3 ? this.f1598a : this.f1599b).iterator();
+        if (it.hasNext()) {
+            throw w.g(it);
+        }
+    }
+
+    public final Object clone() {
+        try {
+            return (h) super.clone();
+        } catch (CloneNotSupportedException e4) {
+            throw new AssertionError(e4);
+        }
+    }
+}

apk_decompiled/sources/S2/i.java

@@ -0,0 +1,41 @@
+package S2;
+
+/* loaded from: classes3.dex */
+public abstract class i {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final int f1600a;
+
+    static {
+        int i;
+        String property = System.getProperty("java.version");
+        try {
+            String[] split = property.split("[._]");
+            i = Integer.parseInt(split[0]);
+            if (i == 1 && split.length > 1) {
+                i = Integer.parseInt(split[1]);
+            }
+        } catch (NumberFormatException unused) {
+            i = -1;
+        }
+        if (i == -1) {
+            try {
+                StringBuilder sb = new StringBuilder();
+                for (int i4 = 0; i4 < property.length(); i4++) {
+                    char charAt = property.charAt(i4);
+                    if (!Character.isDigit(charAt)) {
+                        break;
+                    }
+                    sb.append(charAt);
+                }
+                i = Integer.parseInt(sb.toString());
+            } catch (NumberFormatException unused2) {
+                i = -1;
+            }
+        }
+        if (i == -1) {
+            i = 6;
+        }
+        f1600a = i;
+    }
+}

apk_decompiled/sources/S2/j.java

@@ -0,0 +1,68 @@
+package S2;
+
+import java.math.BigDecimal;
+
+/* loaded from: classes3.dex */
+public final class j extends Number {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final String f1601a;
+
+    public j(String str) {
+        this.f1601a = str;
+    }
+
+    @Override // java.lang.Number
+    public final double doubleValue() {
+        return Double.parseDouble(this.f1601a);
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof j)) {
+            return false;
+        }
+        Object obj2 = ((j) obj).f1601a;
+        String str = this.f1601a;
+        return str == obj2 || str.equals(obj2);
+    }
+
+    @Override // java.lang.Number
+    public final float floatValue() {
+        return Float.parseFloat(this.f1601a);
+    }
+
+    public final int hashCode() {
+        return this.f1601a.hashCode();
+    }
+
+    @Override // java.lang.Number
+    public final int intValue() {
+        String str = this.f1601a;
+        try {
+            try {
+                return Integer.parseInt(str);
+            } catch (NumberFormatException unused) {
+                return (int) Long.parseLong(str);
+            }
+        } catch (NumberFormatException unused2) {
+            return new BigDecimal(str).intValue();
+        }
+    }
+
+    @Override // java.lang.Number
+    public final long longValue() {
+        String str = this.f1601a;
+        try {
+            return Long.parseLong(str);
+        } catch (NumberFormatException unused) {
+            return new BigDecimal(str).longValue();
+        }
+    }
+
+    public final String toString() {
+        return this.f1601a;
+    }
+}

apk_decompiled/sources/S2/k.java

@@ -0,0 +1,24 @@
+package S2;
+
+/* loaded from: classes3.dex */
+public final class k extends m {
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ int f1602f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ k(o oVar, int i) {
+        super(oVar);
+        this.f1602f = i;
+    }
+
+    @Override // S2.m, java.util.Iterator
+    public Object next() {
+        switch (this.f1602f) {
+            case 1:
+                return a().f1615f;
+            default:
+                return super.next();
+        }
+    }
+}

apk_decompiled/sources/S2/l.java

@@ -0,0 +1,163 @@
+package S2;
+
+import java.util.AbstractSet;
+import java.util.Iterator;
+
+/* loaded from: classes3.dex */
+public final class l extends AbstractSet {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f1603a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ o f1604b;
+
+    public /* synthetic */ l(o oVar, int i) {
+        this.f1603a = i;
+        this.f1604b = oVar;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public final void clear() {
+        switch (this.f1603a) {
+            case 0:
+                this.f1604b.clear();
+                return;
+            default:
+                this.f1604b.clear();
+                return;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:16:0x0033 A[ORIG_RETURN, RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:17:? A[RETURN, SYNTHETIC] */
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final boolean contains(java.lang.Object r4) {
+        /*
+            r3 = this;
+            int r0 = r3.f1603a
+            switch(r0) {
+                case 0: goto Lc;
+                default: goto L5;
+            }
+        L5:
+            S2.o r3 = r3.f1604b
+            boolean r3 = r3.containsKey(r4)
+            return r3
+        Lc:
+            boolean r0 = r4 instanceof java.util.Map.Entry
+            r1 = 0
+            if (r0 == 0) goto L34
+            S2.o r3 = r3.f1604b
+            java.util.Map$Entry r4 = (java.util.Map.Entry) r4
+            java.lang.Object r0 = r4.getKey()
+            r2 = 0
+            if (r0 == 0) goto L21
+            S2.n r3 = r3.a(r0, r1)     // Catch: java.lang.ClassCastException -> L21
+            goto L22
+        L21:
+            r3 = r2
+        L22:
+            if (r3 == 0) goto L31
+            java.lang.Object r0 = r3.h
+            java.lang.Object r4 = r4.getValue()
+            boolean r4 = java.util.Objects.equals(r0, r4)
+            if (r4 == 0) goto L31
+            r2 = r3
+        L31:
+            if (r2 == 0) goto L34
+            r1 = 1
+        L34:
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: S2.l.contains(java.lang.Object):boolean");
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+    public final Iterator iterator() {
+        switch (this.f1603a) {
+            case 0:
+                return new k(this.f1604b, 0);
+            default:
+                return new k(this.f1604b, 1);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:27:0x0042  */
+    /* JADX WARN: Removed duplicated region for block: B:29:? A[RETURN, SYNTHETIC] */
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final boolean remove(java.lang.Object r5) {
+        /*
+            r4 = this;
+            int r0 = r4.f1603a
+            switch(r0) {
+                case 0: goto L19;
+                default: goto L5;
+            }
+        L5:
+            S2.o r4 = r4.f1604b
+            r0 = 0
+            r1 = 0
+            if (r5 == 0) goto Lf
+            S2.n r1 = r4.a(r5, r0)     // Catch: java.lang.ClassCastException -> Lf
+        Lf:
+            r5 = 1
+            if (r1 == 0) goto L15
+            r4.c(r1, r5)
+        L15:
+            if (r1 == 0) goto L18
+            r0 = r5
+        L18:
+            return r0
+        L19:
+            boolean r0 = r5 instanceof java.util.Map.Entry
+            r1 = 0
+            if (r0 != 0) goto L1f
+            goto L46
+        L1f:
+            java.util.Map$Entry r5 = (java.util.Map.Entry) r5
+            S2.o r4 = r4.f1604b
+            java.lang.Object r0 = r5.getKey()
+            r2 = 0
+            if (r0 == 0) goto L2f
+            S2.n r0 = r4.a(r0, r1)     // Catch: java.lang.ClassCastException -> L2f
+            goto L30
+        L2f:
+            r0 = r2
+        L30:
+            if (r0 == 0) goto L3f
+            java.lang.Object r3 = r0.h
+            java.lang.Object r5 = r5.getValue()
+            boolean r5 = java.util.Objects.equals(r3, r5)
+            if (r5 == 0) goto L3f
+            r2 = r0
+        L3f:
+            if (r2 != 0) goto L42
+            goto L46
+        L42:
+            r1 = 1
+            r4.c(r2, r1)
+        L46:
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: S2.l.remove(java.lang.Object):boolean");
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public final int size() {
+        switch (this.f1603a) {
+            case 0:
+                return this.f1604b.f1620d;
+            default:
+                return this.f1604b.f1620d;
+        }
+    }
+}

apk_decompiled/sources/S2/m.java

@@ -0,0 +1,114 @@
+package S2;
+
+import Z2.B;
+import Z2.C;
+import java.util.AbstractMap;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes3.dex */
+public abstract class m implements Iterator {
+
+    /* renamed from: b, reason: collision with root package name */
+    public int f1606b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Map.Entry f1607c;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ AbstractMap f1609e;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f1605a = 0;
+
+    /* renamed from: d, reason: collision with root package name */
+    public Map.Entry f1608d = null;
+
+    public m(o oVar) {
+        this.f1609e = oVar;
+        this.f1607c = oVar.f1622f.f1613d;
+        this.f1606b = oVar.f1621e;
+    }
+
+    public n a() {
+        n nVar = (n) this.f1607c;
+        o oVar = (o) this.f1609e;
+        if (nVar == oVar.f1622f) {
+            throw new NoSuchElementException();
+        }
+        if (oVar.f1621e != this.f1606b) {
+            throw new ConcurrentModificationException();
+        }
+        this.f1607c = nVar.f1613d;
+        this.f1608d = nVar;
+        return nVar;
+    }
+
+    public B b() {
+        B b4 = (B) this.f1607c;
+        C c4 = (C) this.f1609e;
+        if (b4 == c4.f2201c) {
+            throw new NoSuchElementException();
+        }
+        if (c4.f2203e != this.f1606b) {
+            throw new ConcurrentModificationException();
+        }
+        this.f1607c = b4.f2195d;
+        this.f1608d = b4;
+        return b4;
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        switch (this.f1605a) {
+            case 0:
+                return ((n) this.f1607c) != ((o) this.f1609e).f1622f;
+            default:
+                return ((B) this.f1607c) != ((C) this.f1609e).f2201c;
+        }
+    }
+
+    @Override // java.util.Iterator
+    public Object next() {
+        switch (this.f1605a) {
+            case 0:
+                return a();
+            default:
+                return b();
+        }
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        switch (this.f1605a) {
+            case 0:
+                n nVar = (n) this.f1608d;
+                if (nVar == null) {
+                    throw new IllegalStateException();
+                }
+                o oVar = (o) this.f1609e;
+                oVar.c(nVar, true);
+                this.f1608d = null;
+                this.f1606b = oVar.f1621e;
+                return;
+            default:
+                B b4 = (B) this.f1608d;
+                if (b4 == null) {
+                    throw new IllegalStateException();
+                }
+                C c4 = (C) this.f1609e;
+                c4.c(b4, true);
+                this.f1608d = null;
+                this.f1606b = c4.f2203e;
+                return;
+        }
+    }
+
+    public m(C c4) {
+        this.f1609e = c4;
+        this.f1607c = c4.f2201c.f2195d;
+        this.f1606b = c4.f2203e;
+    }
+}

apk_decompiled/sources/S2/n.java

@@ -0,0 +1,99 @@
+package S2;
+
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class n implements Map.Entry {
+
+    /* renamed from: a, reason: collision with root package name */
+    public n f1610a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public n f1611b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public n f1612c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public n f1613d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public n f1614e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final Object f1615f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final boolean f1616g;
+    public Object h;
+    public int i;
+
+    public n(boolean z3) {
+        this.f1615f = null;
+        this.f1616g = z3;
+        this.f1614e = this;
+        this.f1613d = this;
+    }
+
+    @Override // java.util.Map.Entry
+    public final boolean equals(Object obj) {
+        if (obj instanceof Map.Entry) {
+            Map.Entry entry = (Map.Entry) obj;
+            Object obj2 = this.f1615f;
+            if (obj2 != null ? obj2.equals(entry.getKey()) : entry.getKey() == null) {
+                Object obj3 = this.h;
+                if (obj3 == null) {
+                    if (entry.getValue() == null) {
+                        return true;
+                    }
+                } else if (obj3.equals(entry.getValue())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object getKey() {
+        return this.f1615f;
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object getValue() {
+        return this.h;
+    }
+
+    @Override // java.util.Map.Entry
+    public final int hashCode() {
+        Object obj = this.f1615f;
+        int hashCode = obj == null ? 0 : obj.hashCode();
+        Object obj2 = this.h;
+        return hashCode ^ (obj2 != null ? obj2.hashCode() : 0);
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object setValue(Object obj) {
+        if (obj == null && !this.f1616g) {
+            throw new NullPointerException("value == null");
+        }
+        Object obj2 = this.h;
+        this.h = obj;
+        return obj2;
+    }
+
+    public final String toString() {
+        return this.f1615f + "=" + this.h;
+    }
+
+    public n(boolean z3, n nVar, Object obj, n nVar2, n nVar3) {
+        this.f1610a = nVar;
+        this.f1615f = obj;
+        this.f1616g = z3;
+        this.i = 1;
+        this.f1613d = nVar2;
+        this.f1614e = nVar3;
+        nVar3.f1613d = this;
+        nVar2.f1614e = this;
+    }
+}

apk_decompiled/sources/S2/o.java

@@ -0,0 +1,383 @@
+package S2;
+
+import java.io.Serializable;
+import java.util.AbstractMap;
+import java.util.Comparator;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class o extends AbstractMap implements Serializable {
+    public static final A.i i = new A.i(3);
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Comparator f1617a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final boolean f1618b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public n f1619c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f1620d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public int f1621e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final n f1622f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public l f1623g;
+    public l h;
+
+    public o(boolean z3) {
+        A.i iVar = i;
+        this.f1620d = 0;
+        this.f1621e = 0;
+        this.f1617a = iVar;
+        this.f1618b = z3;
+        this.f1622f = new n(z3);
+    }
+
+    public final n a(Object obj, boolean z3) {
+        int i4;
+        n nVar;
+        n nVar2 = this.f1619c;
+        A.i iVar = i;
+        Comparator comparator = this.f1617a;
+        if (nVar2 != null) {
+            Comparable comparable = comparator == iVar ? (Comparable) obj : null;
+            while (true) {
+                Object obj2 = nVar2.f1615f;
+                i4 = comparable != null ? comparable.compareTo(obj2) : comparator.compare(obj, obj2);
+                if (i4 == 0) {
+                    return nVar2;
+                }
+                n nVar3 = i4 < 0 ? nVar2.f1611b : nVar2.f1612c;
+                if (nVar3 == null) {
+                    break;
+                }
+                nVar2 = nVar3;
+            }
+        } else {
+            i4 = 0;
+        }
+        n nVar4 = nVar2;
+        if (!z3) {
+            return null;
+        }
+        n nVar5 = this.f1622f;
+        if (nVar4 != null) {
+            nVar = new n(this.f1618b, nVar4, obj, nVar5, nVar5.f1614e);
+            if (i4 < 0) {
+                nVar4.f1611b = nVar;
+            } else {
+                nVar4.f1612c = nVar;
+            }
+            b(nVar4, true);
+        } else {
+            if (comparator == iVar && !(obj instanceof Comparable)) {
+                throw new ClassCastException(obj.getClass().getName().concat(" is not Comparable"));
+            }
+            nVar = new n(this.f1618b, nVar4, obj, nVar5, nVar5.f1614e);
+            this.f1619c = nVar;
+        }
+        this.f1620d++;
+        this.f1621e++;
+        return nVar;
+    }
+
+    public final void b(n nVar, boolean z3) {
+        while (nVar != null) {
+            n nVar2 = nVar.f1611b;
+            n nVar3 = nVar.f1612c;
+            int i4 = nVar2 != null ? nVar2.i : 0;
+            int i5 = nVar3 != null ? nVar3.i : 0;
+            int i6 = i4 - i5;
+            if (i6 == -2) {
+                n nVar4 = nVar3.f1611b;
+                n nVar5 = nVar3.f1612c;
+                int i7 = (nVar4 != null ? nVar4.i : 0) - (nVar5 != null ? nVar5.i : 0);
+                if (i7 == -1 || (i7 == 0 && !z3)) {
+                    e(nVar);
+                } else {
+                    f(nVar3);
+                    e(nVar);
+                }
+                if (z3) {
+                    return;
+                }
+            } else if (i6 == 2) {
+                n nVar6 = nVar2.f1611b;
+                n nVar7 = nVar2.f1612c;
+                int i8 = (nVar6 != null ? nVar6.i : 0) - (nVar7 != null ? nVar7.i : 0);
+                if (i8 == 1 || (i8 == 0 && !z3)) {
+                    f(nVar);
+                } else {
+                    e(nVar2);
+                    f(nVar);
+                }
+                if (z3) {
+                    return;
+                }
+            } else if (i6 == 0) {
+                nVar.i = i4 + 1;
+                if (z3) {
+                    return;
+                }
+            } else {
+                nVar.i = Math.max(i4, i5) + 1;
+                if (!z3) {
+                    return;
+                }
+            }
+            nVar = nVar.f1610a;
+        }
+    }
+
+    public final void c(n nVar, boolean z3) {
+        n nVar2;
+        n nVar3;
+        int i4;
+        if (z3) {
+            n nVar4 = nVar.f1614e;
+            nVar4.f1613d = nVar.f1613d;
+            nVar.f1613d.f1614e = nVar4;
+        }
+        n nVar5 = nVar.f1611b;
+        n nVar6 = nVar.f1612c;
+        n nVar7 = nVar.f1610a;
+        int i5 = 0;
+        if (nVar5 == null || nVar6 == null) {
+            if (nVar5 != null) {
+                d(nVar, nVar5);
+                nVar.f1611b = null;
+            } else if (nVar6 != null) {
+                d(nVar, nVar6);
+                nVar.f1612c = null;
+            } else {
+                d(nVar, null);
+            }
+            b(nVar7, false);
+            this.f1620d--;
+            this.f1621e++;
+            return;
+        }
+        if (nVar5.i > nVar6.i) {
+            n nVar8 = nVar5.f1612c;
+            while (true) {
+                n nVar9 = nVar8;
+                nVar3 = nVar5;
+                nVar5 = nVar9;
+                if (nVar5 == null) {
+                    break;
+                } else {
+                    nVar8 = nVar5.f1612c;
+                }
+            }
+        } else {
+            n nVar10 = nVar6.f1611b;
+            while (true) {
+                nVar2 = nVar6;
+                nVar6 = nVar10;
+                if (nVar6 == null) {
+                    break;
+                } else {
+                    nVar10 = nVar6.f1611b;
+                }
+            }
+            nVar3 = nVar2;
+        }
+        c(nVar3, false);
+        n nVar11 = nVar.f1611b;
+        if (nVar11 != null) {
+            i4 = nVar11.i;
+            nVar3.f1611b = nVar11;
+            nVar11.f1610a = nVar3;
+            nVar.f1611b = null;
+        } else {
+            i4 = 0;
+        }
+        n nVar12 = nVar.f1612c;
+        if (nVar12 != null) {
+            i5 = nVar12.i;
+            nVar3.f1612c = nVar12;
+            nVar12.f1610a = nVar3;
+            nVar.f1612c = null;
+        }
+        nVar3.i = Math.max(i4, i5) + 1;
+        d(nVar, nVar3);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final void clear() {
+        this.f1619c = null;
+        this.f1620d = 0;
+        this.f1621e++;
+        n nVar = this.f1622f;
+        nVar.f1614e = nVar;
+        nVar.f1613d = nVar;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final boolean containsKey(Object obj) {
+        n nVar = null;
+        if (obj != null) {
+            try {
+                nVar = a(obj, false);
+            } catch (ClassCastException unused) {
+            }
+        }
+        return nVar != null;
+    }
+
+    public final void d(n nVar, n nVar2) {
+        n nVar3 = nVar.f1610a;
+        nVar.f1610a = null;
+        if (nVar2 != null) {
+            nVar2.f1610a = nVar3;
+        }
+        if (nVar3 == null) {
+            this.f1619c = nVar2;
+        } else if (nVar3.f1611b == nVar) {
+            nVar3.f1611b = nVar2;
+        } else {
+            nVar3.f1612c = nVar2;
+        }
+    }
+
+    public final void e(n nVar) {
+        n nVar2 = nVar.f1611b;
+        n nVar3 = nVar.f1612c;
+        n nVar4 = nVar3.f1611b;
+        n nVar5 = nVar3.f1612c;
+        nVar.f1612c = nVar4;
+        if (nVar4 != null) {
+            nVar4.f1610a = nVar;
+        }
+        d(nVar, nVar3);
+        nVar3.f1611b = nVar;
+        nVar.f1610a = nVar3;
+        int max = Math.max(nVar2 != null ? nVar2.i : 0, nVar4 != null ? nVar4.i : 0) + 1;
+        nVar.i = max;
+        nVar3.i = Math.max(max, nVar5 != null ? nVar5.i : 0) + 1;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Set entrySet() {
+        l lVar = this.f1623g;
+        if (lVar != null) {
+            return lVar;
+        }
+        l lVar2 = new l(this, 0);
+        this.f1623g = lVar2;
+        return lVar2;
+    }
+
+    public final void f(n nVar) {
+        n nVar2 = nVar.f1611b;
+        n nVar3 = nVar.f1612c;
+        n nVar4 = nVar2.f1611b;
+        n nVar5 = nVar2.f1612c;
+        nVar.f1611b = nVar5;
+        if (nVar5 != null) {
+            nVar5.f1610a = nVar;
+        }
+        d(nVar, nVar2);
+        nVar2.f1612c = nVar;
+        nVar.f1610a = nVar2;
+        int max = Math.max(nVar3 != null ? nVar3.i : 0, nVar5 != null ? nVar5.i : 0) + 1;
+        nVar.i = max;
+        nVar2.i = Math.max(max, nVar4 != null ? nVar4.i : 0) + 1;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x000f A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:7:0x000c  */
+    @Override // java.util.AbstractMap, java.util.Map
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object get(java.lang.Object r3) {
+        /*
+            r2 = this;
+            r0 = 0
+            if (r3 == 0) goto L9
+            r1 = 0
+            S2.n r2 = r2.a(r3, r1)     // Catch: java.lang.ClassCastException -> L9
+            goto La
+        L9:
+            r2 = r0
+        La:
+            if (r2 == 0) goto Lf
+            java.lang.Object r2 = r2.h
+            return r2
+        Lf:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: S2.o.get(java.lang.Object):java.lang.Object");
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Set keySet() {
+        l lVar = this.h;
+        if (lVar != null) {
+            return lVar;
+        }
+        l lVar2 = new l(this, 1);
+        this.h = lVar2;
+        return lVar2;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Object put(Object obj, Object obj2) {
+        if (obj == null) {
+            throw new NullPointerException("key == null");
+        }
+        if (obj2 == null && !this.f1618b) {
+            throw new NullPointerException("value == null");
+        }
+        n a2 = a(obj, true);
+        Object obj3 = a2.h;
+        a2.h = obj2;
+        return obj3;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:12:0x0015 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:7:0x000c  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0012  */
+    @Override // java.util.AbstractMap, java.util.Map
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object remove(java.lang.Object r3) {
+        /*
+            r2 = this;
+            r0 = 0
+            if (r3 == 0) goto L9
+            r1 = 0
+            S2.n r3 = r2.a(r3, r1)     // Catch: java.lang.ClassCastException -> L9
+            goto La
+        L9:
+            r3 = r0
+        La:
+            if (r3 == 0) goto L10
+            r1 = 1
+            r2.c(r3, r1)
+        L10:
+            if (r3 == 0) goto L15
+            java.lang.Object r2 = r3.h
+            return r2
+        L15:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: S2.o.remove(java.lang.Object):java.lang.Object");
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int size() {
+        return this.f1620d;
+    }
+}

apk_decompiled/sources/S2/p.java

@@ -0,0 +1,6 @@
+package S2;
+
+/* loaded from: classes3.dex */
+public interface p {
+    Object j();
+}

apk_decompiled/sources/S2/q.java

@@ -0,0 +1,27 @@
+package S2;
+
+import java.lang.reflect.Method;
+
+/* loaded from: classes3.dex */
+public final class q extends u {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Method f1624b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Object f1625c;
+
+    public q(Method method, Object obj) {
+        this.f1624b = method;
+        this.f1625c = obj;
+    }
+
+    @Override // S2.u
+    public final Object a(Class cls) {
+        String m4 = F.i.m(cls);
+        if (m4 != null) {
+            throw new AssertionError("UnsafeAllocator is used for non-instantiable type: ".concat(m4));
+        }
+        return this.f1624b.invoke(this.f1625c, cls);
+    }
+}

apk_decompiled/sources/S2/r.java

@@ -0,0 +1,27 @@
+package S2;
+
+import java.lang.reflect.Method;
+
+/* loaded from: classes3.dex */
+public final class r extends u {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Method f1626b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ int f1627c;
+
+    public r(Method method, int i) {
+        this.f1626b = method;
+        this.f1627c = i;
+    }
+
+    @Override // S2.u
+    public final Object a(Class cls) {
+        String m4 = F.i.m(cls);
+        if (m4 != null) {
+            throw new AssertionError("UnsafeAllocator is used for non-instantiable type: ".concat(m4));
+        }
+        return this.f1626b.invoke(null, cls, Integer.valueOf(this.f1627c));
+    }
+}

apk_decompiled/sources/S2/s.java

@@ -0,0 +1,23 @@
+package S2;
+
+import java.lang.reflect.Method;
+
+/* loaded from: classes3.dex */
+public final class s extends u {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Method f1628b;
+
+    public s(Method method) {
+        this.f1628b = method;
+    }
+
+    @Override // S2.u
+    public final Object a(Class cls) {
+        String m4 = F.i.m(cls);
+        if (m4 != null) {
+            throw new AssertionError("UnsafeAllocator is used for non-instantiable type: ".concat(m4));
+        }
+        return this.f1628b.invoke(null, cls, Object.class);
+    }
+}

apk_decompiled/sources/S2/t.java

@@ -0,0 +1,9 @@
+package S2;
+
+/* loaded from: classes3.dex */
+public final class t extends u {
+    @Override // S2.u
+    public final Object a(Class cls) {
+        throw new UnsupportedOperationException("Cannot allocate " + cls + ". Usage of JDK sun.misc.Unsafe is enabled, but it could not be used. Make sure your runtime is configured correctly.");
+    }
+}

apk_decompiled/sources/S2/u.java

@@ -0,0 +1,49 @@
+package S2;
+
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamClass;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/* loaded from: classes3.dex */
+public abstract class u {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final u f1629a;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r7v3, types: [S2.u] */
+    /* JADX WARN: Type inference failed for: r7v6 */
+    /* JADX WARN: Type inference failed for: r7v7 */
+    /* JADX WARN: Type inference failed for: r7v8 */
+    /* JADX WARN: Type inference failed for: r7v9 */
+    static {
+        ?? r7;
+        try {
+            try {
+                try {
+                    Class<?> cls = Class.forName("sun.misc.Unsafe");
+                    Field declaredField = cls.getDeclaredField("theUnsafe");
+                    declaredField.setAccessible(true);
+                    r7 = new q(cls.getMethod("allocateInstance", Class.class), declaredField.get(null));
+                } catch (Exception unused) {
+                    r7 = new Object();
+                }
+            } catch (Exception unused2) {
+                Method declaredMethod = ObjectInputStream.class.getDeclaredMethod("newInstance", Class.class, Class.class);
+                declaredMethod.setAccessible(true);
+                r7 = new s(declaredMethod);
+            }
+        } catch (Exception unused3) {
+            Method declaredMethod2 = ObjectStreamClass.class.getDeclaredMethod("getConstructorId", Class.class);
+            declaredMethod2.setAccessible(true);
+            int intValue = ((Integer) declaredMethod2.invoke(null, Object.class)).intValue();
+            Method declaredMethod3 = ObjectStreamClass.class.getDeclaredMethod("newInstance", Class.class, Integer.TYPE);
+            declaredMethod3.setAccessible(true);
+            r7 = new r(declaredMethod3, intValue);
+        }
+        f1629a = r7;
+    }
+
+    public abstract Object a(Class cls);
+}