Initial import of ADIF API reverse-engineering toolkit

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);
+}