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

@@ -0,0 +1,178 @@
+package s3;
+
+import kotlin.UByte;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Charsets;
+import r3.C0576h;
+import r3.D;
+import r3.x;
+
+/* loaded from: classes3.dex */
+public abstract class a {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final byte[] f8472a;
+
+    static {
+        Intrinsics.checkNotNullParameter("0123456789abcdef", "<this>");
+        byte[] bytes = "0123456789abcdef".getBytes(Charsets.UTF_8);
+        Intrinsics.checkNotNullExpressionValue(bytes, "this as java.lang.String).getBytes(charset)");
+        f8472a = bytes;
+    }
+
+    public static final boolean a(D segment, int i, byte[] bytes, int i4) {
+        Intrinsics.checkNotNullParameter(segment, "segment");
+        Intrinsics.checkNotNullParameter(bytes, "bytes");
+        int i5 = segment.f8250c;
+        byte[] bArr = segment.f8248a;
+        for (int i6 = 1; i6 < i4; i6++) {
+            if (i == i5) {
+                segment = segment.f8253f;
+                Intrinsics.checkNotNull(segment);
+                bArr = segment.f8248a;
+                i = segment.f8249b;
+                i5 = segment.f8250c;
+            }
+            if (bArr[i] != bytes[i6]) {
+                return false;
+            }
+            i++;
+        }
+        return true;
+    }
+
+    public static final String b(C0576h c0576h, long j4) {
+        Intrinsics.checkNotNullParameter(c0576h, "<this>");
+        if (j4 > 0) {
+            long j5 = j4 - 1;
+            if (c0576h.O(j5) == 13) {
+                String d02 = c0576h.d0(j5, Charsets.UTF_8);
+                c0576h.l(2L);
+                return d02;
+            }
+        }
+        c0576h.getClass();
+        String d03 = c0576h.d0(j4, Charsets.UTF_8);
+        c0576h.l(1L);
+        return d03;
+    }
+
+    public static final int c(C0576h c0576h, x options, boolean z3) {
+        int i;
+        byte[] bArr;
+        int i4;
+        int i5;
+        D d4;
+        byte[] bArr2;
+        int i6;
+        Intrinsics.checkNotNullParameter(c0576h, "<this>");
+        Intrinsics.checkNotNullParameter(options, "options");
+        D d5 = c0576h.f8283a;
+        if (d5 == null) {
+            return z3 ? -2 : -1;
+        }
+        int i7 = d5.f8249b;
+        int i8 = d5.f8250c;
+        int[] iArr = options.f8318b;
+        byte[] bArr3 = d5.f8248a;
+        D d6 = d5;
+        int i9 = -1;
+        int i10 = 0;
+        loop0: while (true) {
+            int i11 = i10 + 1;
+            int i12 = iArr[i10];
+            int i13 = i10 + 2;
+            int i14 = iArr[i11];
+            if (i14 != -1) {
+                i9 = i14;
+            }
+            if (d6 == null) {
+                break;
+            }
+            if (i12 >= 0) {
+                int i15 = i7 + 1;
+                int i16 = bArr3[i7] & UByte.MAX_VALUE;
+                int i17 = i13 + i12;
+                while (i13 != i17) {
+                    if (i16 == iArr[i13]) {
+                        i = iArr[i13 + i12];
+                        if (i15 == i8) {
+                            d6 = d6.f8253f;
+                            Intrinsics.checkNotNull(d6);
+                            i5 = d6.f8249b;
+                            i4 = d6.f8250c;
+                            bArr = d6.f8248a;
+                            if (d6 == d5) {
+                                d6 = null;
+                            }
+                        } else {
+                            bArr = bArr3;
+                            i4 = i8;
+                            i5 = i15;
+                        }
+                        if (i >= 0) {
+                            return i;
+                        }
+                        byte[] bArr4 = bArr;
+                        i10 = -i;
+                        i7 = i5;
+                        i8 = i4;
+                        bArr3 = bArr4;
+                    } else {
+                        i13++;
+                    }
+                }
+                break loop0;
+            }
+            int i18 = (i12 * (-1)) + i13;
+            while (true) {
+                int i19 = i7 + 1;
+                int i20 = i13 + 1;
+                if ((bArr3[i7] & UByte.MAX_VALUE) != iArr[i13]) {
+                    break loop0;
+                }
+                boolean z4 = i20 == i18;
+                if (i19 == i8) {
+                    Intrinsics.checkNotNull(d6);
+                    D d7 = d6.f8253f;
+                    Intrinsics.checkNotNull(d7);
+                    i6 = d7.f8249b;
+                    int i21 = d7.f8250c;
+                    bArr2 = d7.f8248a;
+                    if (d7 != d5) {
+                        d4 = d7;
+                        i8 = i21;
+                    } else {
+                        if (!z4) {
+                            break loop0;
+                        }
+                        i8 = i21;
+                        d4 = null;
+                    }
+                } else {
+                    d4 = d6;
+                    bArr2 = bArr3;
+                    i6 = i19;
+                }
+                if (z4) {
+                    i = iArr[i20];
+                    int i22 = i6;
+                    i4 = i8;
+                    i5 = i22;
+                    byte[] bArr5 = bArr2;
+                    d6 = d4;
+                    bArr = bArr5;
+                    break;
+                }
+                i7 = i6;
+                bArr3 = bArr2;
+                d6 = d4;
+                i13 = i20;
+            }
+        }
+        if (z3) {
+            return -2;
+        }
+        return i9;
+    }
+}

apk_decompiled/sources/s3/b.java

@@ -0,0 +1,21 @@
+package s3;
+
+/* loaded from: classes3.dex */
+public abstract class b {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final char[] f8473a = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    public static final int a(char c4) {
+        if ('0' <= c4 && c4 < ':') {
+            return c4 - '0';
+        }
+        if ('a' <= c4 && c4 < 'g') {
+            return c4 - 'W';
+        }
+        if ('A' <= c4 && c4 < 'G') {
+            return c4 - '7';
+        }
+        throw new IllegalArgumentException("Unexpected hex digit: " + c4);
+    }
+}

apk_decompiled/sources/s3/c.java

@@ -0,0 +1,218 @@
+package s3;
+
+import C.w;
+import com.google.firebase.sessions.settings.RemoteSettings;
+import f0.C0338b;
+import java.util.ArrayList;
+import java.util.List;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt__MutableCollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+import r3.C0579k;
+import r3.z;
+
+/* loaded from: classes3.dex */
+public abstract class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0579k f8474a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final C0579k f8475b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final C0579k f8476c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final C0579k f8477d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final C0579k f8478e;
+
+    static {
+        C0579k c0579k = C0579k.f8285d;
+        f8474a = C0338b.n(RemoteSettings.FORWARD_SLASH_STRING);
+        f8475b = C0338b.n("\\");
+        f8476c = C0338b.n("/\\");
+        f8477d = C0338b.n(".");
+        f8478e = C0338b.n("..");
+    }
+
+    public static final int a(z zVar) {
+        if (zVar.f8322a.d() != 0) {
+            C0579k c0579k = zVar.f8322a;
+            if (c0579k.i(0) != 47) {
+                if (c0579k.i(0) == 92) {
+                    if (c0579k.d() > 2 && c0579k.i(1) == 92) {
+                        C0579k other = f8475b;
+                        Intrinsics.checkNotNullParameter(other, "other");
+                        int f2 = c0579k.f(2, other.f8286a);
+                        return f2 == -1 ? c0579k.d() : f2;
+                    }
+                } else if (c0579k.d() > 2 && c0579k.i(1) == 58 && c0579k.i(2) == 92) {
+                    char i = (char) c0579k.i(0);
+                    if ('a' <= i && i < '{') {
+                        return 3;
+                    }
+                    if ('A' <= i && i < '[') {
+                        return 3;
+                    }
+                }
+            }
+            return 1;
+        }
+        return -1;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [java.lang.Object, r3.h] */
+    public static final z b(z zVar, z child, boolean z3) {
+        Intrinsics.checkNotNullParameter(zVar, "<this>");
+        Intrinsics.checkNotNullParameter(child, "child");
+        child.getClass();
+        if (a(child) != -1 || child.g() != null) {
+            return child;
+        }
+        C0579k c4 = c(zVar);
+        if (c4 == null && (c4 = c(child)) == null) {
+            c4 = f(z.f8321b);
+        }
+        ?? obj = new Object();
+        obj.h0(zVar.f8322a);
+        if (obj.f8284b > 0) {
+            obj.h0(c4);
+        }
+        obj.h0(child.f8322a);
+        return d(obj, z3);
+    }
+
+    public static final C0579k c(z zVar) {
+        C0579k c0579k = zVar.f8322a;
+        C0579k c0579k2 = f8474a;
+        if (C0579k.g(c0579k, c0579k2) != -1) {
+            return c0579k2;
+        }
+        C0579k c0579k3 = f8475b;
+        if (C0579k.g(zVar.f8322a, c0579k3) != -1) {
+            return c0579k3;
+        }
+        return null;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [java.lang.Object, r3.h] */
+    public static final z d(C0576h c0576h, boolean z3) {
+        C0579k c0579k;
+        C0579k c0579k2;
+        char O2;
+        C0579k c0579k3;
+        C0579k h;
+        Intrinsics.checkNotNullParameter(c0576h, "<this>");
+        ?? obj = new Object();
+        C0579k c0579k4 = null;
+        int i = 0;
+        while (true) {
+            if (!c0576h.H(f8474a)) {
+                c0579k = f8475b;
+                if (!c0576h.H(c0579k)) {
+                    break;
+                }
+            }
+            byte readByte = c0576h.readByte();
+            if (c0579k4 == null) {
+                c0579k4 = e(readByte);
+            }
+            i++;
+        }
+        boolean z4 = i >= 2 && Intrinsics.areEqual(c0579k4, c0579k);
+        C0579k c0579k5 = f8476c;
+        long j4 = 0;
+        if (z4) {
+            Intrinsics.checkNotNull(c0579k4);
+            obj.h0(c0579k4);
+            obj.h0(c0579k4);
+        } else if (i > 0) {
+            Intrinsics.checkNotNull(c0579k4);
+            obj.h0(c0579k4);
+        } else {
+            long A3 = c0576h.A(c0579k5);
+            if (c0579k4 == null) {
+                c0579k4 = A3 == -1 ? f(z.f8321b) : e(c0576h.O(A3));
+            }
+            if (Intrinsics.areEqual(c0579k4, c0579k)) {
+                c0579k2 = c0579k4;
+                if (c0576h.f8284b >= 2 && c0576h.O(1L) == 58 && (('a' <= (O2 = (char) c0576h.O(0L)) && O2 < '{') || ('A' <= O2 && O2 < '['))) {
+                    if (A3 == 2) {
+                        obj.z(c0576h, 3L);
+                    } else {
+                        obj.z(c0576h, 2L);
+                    }
+                }
+            } else {
+                c0579k2 = c0579k4;
+            }
+            c0579k4 = c0579k2;
+        }
+        boolean z5 = obj.f8284b > 0;
+        ArrayList arrayList = new ArrayList();
+        while (true) {
+            boolean x3 = c0576h.x();
+            c0579k3 = f8477d;
+            if (x3) {
+                break;
+            }
+            long j5 = j4;
+            long A4 = c0576h.A(c0579k5);
+            if (A4 == -1) {
+                h = c0576h.h(c0576h.f8284b);
+            } else {
+                h = c0576h.h(A4);
+                c0576h.readByte();
+            }
+            C0579k c0579k6 = f8478e;
+            if (Intrinsics.areEqual(h, c0579k6)) {
+                if (!z5 || !arrayList.isEmpty()) {
+                    if (!z3 || (!z5 && (arrayList.isEmpty() || Intrinsics.areEqual(CollectionsKt.last((List) arrayList), c0579k6)))) {
+                        arrayList.add(h);
+                    } else if (!z4 || arrayList.size() != 1) {
+                        CollectionsKt__MutableCollectionsKt.removeLastOrNull(arrayList);
+                    }
+                }
+            } else if (!Intrinsics.areEqual(h, c0579k3) && !Intrinsics.areEqual(h, C0579k.f8285d)) {
+                arrayList.add(h);
+            }
+            j4 = j5;
+        }
+        long j6 = j4;
+        int size = arrayList.size();
+        for (int i4 = 0; i4 < size; i4++) {
+            if (i4 > 0) {
+                obj.h0(c0579k4);
+            }
+            obj.h0((C0579k) arrayList.get(i4));
+        }
+        if (obj.f8284b == j6) {
+            obj.h0(c0579k3);
+        }
+        return new z(obj.h(obj.f8284b));
+    }
+
+    public static final C0579k e(byte b4) {
+        if (b4 == 47) {
+            return f8474a;
+        }
+        if (b4 == 92) {
+            return f8475b;
+        }
+        throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(b4, "not a directory separator: "));
+    }
+
+    public static final C0579k f(String str) {
+        if (Intrinsics.areEqual(str, RemoteSettings.FORWARD_SLASH_STRING)) {
+            return f8474a;
+        }
+        if (Intrinsics.areEqual(str, "\\")) {
+            return f8475b;
+        }
+        throw new IllegalArgumentException(w.z("not a directory separator: ", str));
+    }
+}

apk_decompiled/sources/s3/d.java

@@ -0,0 +1,36 @@
+package s3;
+
+import kotlin.jvm.internal.Intrinsics;
+import r3.F;
+
+/* loaded from: classes3.dex */
+public abstract class d {
+    public static final int a(F f2, int i) {
+        int i4;
+        Intrinsics.checkNotNullParameter(f2, "<this>");
+        int[] iArr = f2.f8259f;
+        int i5 = i + 1;
+        int length = f2.f8258e.length;
+        Intrinsics.checkNotNullParameter(iArr, "<this>");
+        int i6 = length - 1;
+        int i7 = 0;
+        while (true) {
+            if (i7 <= i6) {
+                i4 = (i7 + i6) >>> 1;
+                int i8 = iArr[i4];
+                if (i8 >= i5) {
+                    if (i8 <= i5) {
+                        break;
+                    }
+                    i6 = i4 - 1;
+                } else {
+                    i7 = i4 + 1;
+                }
+            } else {
+                i4 = (-i7) - 1;
+                break;
+            }
+        }
+        return i4 >= 0 ? i4 : ~i4;
+    }
+}

apk_decompiled/sources/s3/e.java

@@ -0,0 +1,16 @@
+package s3;
+
+/* loaded from: classes3.dex */
+public final class e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final long f8479a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final long f8480b;
+
+    public e(long j4, long j5, int i) {
+        this.f8479a = j4;
+        this.f8480b = j5;
+    }
+}

apk_decompiled/sources/s3/f.java

@@ -0,0 +1,62 @@
+package s3;
+
+import java.io.IOException;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+import r3.I;
+import r3.p;
+
+/* loaded from: classes3.dex */
+public final class f extends p {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final long f8481a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final boolean f8482b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public long f8483c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public f(I delegate, long j4, boolean z3) {
+        super(delegate);
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.f8481a = j4;
+        this.f8482b = z3;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v5, types: [java.lang.Object, r3.h] */
+    @Override // r3.p, r3.I
+    public final long read(C0576h sink, long j4) {
+        Intrinsics.checkNotNullParameter(sink, "sink");
+        long j5 = this.f8483c;
+        long j6 = this.f8481a;
+        if (j5 > j6) {
+            j4 = 0;
+        } else if (this.f8482b) {
+            long j7 = j6 - j5;
+            if (j7 == 0) {
+                return -1L;
+            }
+            j4 = Math.min(j4, j7);
+        }
+        long read = super.read(sink, j4);
+        if (read != -1) {
+            this.f8483c += read;
+        }
+        long j8 = this.f8483c;
+        if ((j8 >= j6 || read != -1) && j8 <= j6) {
+            return read;
+        }
+        if (read > 0 && j8 > j6) {
+            long j9 = sink.f8284b - (j8 - j6);
+            ?? obj = new Object();
+            obj.D(sink);
+            sink.z(obj, j9);
+            obj.d();
+        }
+        throw new IOException("expected " + j6 + " bytes but got " + this.f8483c);
+    }
+}

apk_decompiled/sources/s3/g.java

@@ -0,0 +1,22 @@
+package s3;
+
+import f0.C0338b;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import r3.z;
+
+/* loaded from: classes3.dex */
+public final class g extends Lambda implements Function1 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final g f8484a = new Lambda(1);
+
+    @Override // kotlin.jvm.functions.Function1
+    public final Object invoke(Object obj) {
+        i entry = (i) obj;
+        Intrinsics.checkNotNullParameter(entry, "entry");
+        z zVar = h.f8485e;
+        return Boolean.valueOf(C0338b.e(entry.f8489a));
+    }
+}

apk_decompiled/sources/s3/h.java

@@ -0,0 +1,149 @@
+package s3;
+
+import a.AbstractC0105a;
+import com.google.firebase.sessions.settings.RemoteSettings;
+import f0.C0338b;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import kotlin.Lazy;
+import kotlin.LazyKt;
+import kotlin.Pair;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt__MutableCollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+import r3.G;
+import r3.I;
+import r3.m;
+import r3.n;
+import r3.u;
+import r3.z;
+
+/* loaded from: classes3.dex */
+public final class h extends n {
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final z f8485e;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ClassLoader f8486b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final u f8487c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Lazy f8488d;
+
+    static {
+        String str = z.f8321b;
+        f8485e = C0338b.o(RemoteSettings.FORWARD_SLASH_STRING);
+    }
+
+    public h(ClassLoader classLoader) {
+        Intrinsics.checkNotNullParameter(classLoader, "classLoader");
+        u systemFileSystem = n.f8299a;
+        Intrinsics.checkNotNullParameter(systemFileSystem, "systemFileSystem");
+        this.f8486b = classLoader;
+        this.f8487c = systemFileSystem;
+        this.f8488d = LazyKt.lazy(new J0.e(this, 12));
+    }
+
+    @Override // r3.n
+    public final void a(z path) {
+        Intrinsics.checkNotNullParameter(path, "path");
+        throw new IOException(this + " is read-only");
+    }
+
+    @Override // r3.n
+    public final List d(z child) {
+        int collectionSizeOrDefault;
+        String removePrefix;
+        String replace$default;
+        Intrinsics.checkNotNullParameter(child, "dir");
+        z zVar = f8485e;
+        zVar.getClass();
+        Intrinsics.checkNotNullParameter(child, "child");
+        String q4 = c.b(zVar, child, true).c(zVar).f8322a.q();
+        LinkedHashSet linkedHashSet = new LinkedHashSet();
+        boolean z3 = false;
+        for (Pair pair : (List) this.f8488d.getValue()) {
+            n nVar = (n) pair.component1();
+            z base = (z) pair.component2();
+            try {
+                List d4 = nVar.d(base.d(q4));
+                ArrayList arrayList = new ArrayList();
+                for (Object obj : d4) {
+                    if (C0338b.e((z) obj)) {
+                        arrayList.add(obj);
+                    }
+                }
+                collectionSizeOrDefault = CollectionsKt__IterablesKt.collectionSizeOrDefault(arrayList, 10);
+                ArrayList arrayList2 = new ArrayList(collectionSizeOrDefault);
+                Iterator it = arrayList.iterator();
+                while (it.hasNext()) {
+                    z zVar2 = (z) it.next();
+                    Intrinsics.checkNotNullParameter(zVar2, "<this>");
+                    Intrinsics.checkNotNullParameter(base, "base");
+                    removePrefix = StringsKt__StringsKt.removePrefix(zVar2.f8322a.q(), (CharSequence) base.f8322a.q());
+                    replace$default = StringsKt__StringsJVMKt.replace$default(removePrefix, '\\', '/', false, 4, (Object) null);
+                    arrayList2.add(zVar.d(replace$default));
+                }
+                CollectionsKt__MutableCollectionsKt.addAll(linkedHashSet, arrayList2);
+                z3 = true;
+            } catch (IOException unused) {
+            }
+        }
+        if (z3) {
+            return CollectionsKt.toList(linkedHashSet);
+        }
+        throw new FileNotFoundException("file not found: " + child);
+    }
+
+    @Override // r3.n
+    public final m f(z child) {
+        Intrinsics.checkNotNullParameter(child, "path");
+        if (!C0338b.e(child)) {
+            return null;
+        }
+        z zVar = f8485e;
+        zVar.getClass();
+        Intrinsics.checkNotNullParameter(child, "child");
+        String q4 = c.b(zVar, child, true).c(zVar).f8322a.q();
+        for (Pair pair : (List) this.f8488d.getValue()) {
+            m f2 = ((n) pair.component1()).f(((z) pair.component2()).d(q4));
+            if (f2 != null) {
+                return f2;
+            }
+        }
+        return null;
+    }
+
+    @Override // r3.n
+    public final G g(z file) {
+        Intrinsics.checkNotNullParameter(file, "file");
+        throw new IOException(this + " is read-only");
+    }
+
+    @Override // r3.n
+    public final I h(z child) {
+        Intrinsics.checkNotNullParameter(child, "file");
+        if (!C0338b.e(child)) {
+            throw new FileNotFoundException("file not found: " + child);
+        }
+        z zVar = f8485e;
+        zVar.getClass();
+        Intrinsics.checkNotNullParameter(child, "child");
+        InputStream resourceAsStream = this.f8486b.getResourceAsStream(c.b(zVar, child, false).c(zVar).f8322a.q());
+        if (resourceAsStream != null) {
+            return AbstractC0105a.R(resourceAsStream);
+        }
+        throw new FileNotFoundException("file not found: " + child);
+    }
+}

apk_decompiled/sources/s3/i.java

@@ -0,0 +1,48 @@
+package s3;
+
+import java.util.ArrayList;
+import kotlin.jvm.internal.Intrinsics;
+import r3.z;
+
+/* loaded from: classes3.dex */
+public final class i {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final z f8489a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final boolean f8490b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final long f8491c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final long f8492d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final int f8493e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final Long f8494f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final long f8495g;
+    public final ArrayList h;
+
+    public /* synthetic */ i(z zVar) {
+        this(zVar, true, "", -1L, -1L, -1, null, -1L);
+    }
+
+    public i(z canonicalPath, boolean z3, String comment, long j4, long j5, int i, Long l4, long j6) {
+        Intrinsics.checkNotNullParameter(canonicalPath, "canonicalPath");
+        Intrinsics.checkNotNullParameter(comment, "comment");
+        this.f8489a = canonicalPath;
+        this.f8490b = z3;
+        this.f8491c = j4;
+        this.f8492d = j5;
+        this.f8493e = i;
+        this.f8494f = l4;
+        this.f8495g = j6;
+        this.h = new ArrayList();
+    }
+}

apk_decompiled/sources/s3/j.java

@@ -0,0 +1,69 @@
+package s3;
+
+import java.io.IOException;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+import r3.C;
+
+/* loaded from: classes3.dex */
+public final class j extends Lambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ Ref.BooleanRef f8496a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ long f8497b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Ref.LongRef f8498c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ C f8499d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ Ref.LongRef f8500e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Ref.LongRef f8501f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public j(Ref.BooleanRef booleanRef, long j4, Ref.LongRef longRef, C c4, Ref.LongRef longRef2, Ref.LongRef longRef3) {
+        super(2);
+        this.f8496a = booleanRef;
+        this.f8497b = j4;
+        this.f8498c = longRef;
+        this.f8499d = c4;
+        this.f8500e = longRef2;
+        this.f8501f = longRef3;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        int intValue = ((Number) obj).intValue();
+        long longValue = ((Number) obj2).longValue();
+        if (intValue == 1) {
+            Ref.BooleanRef booleanRef = this.f8496a;
+            if (booleanRef.element) {
+                throw new IOException("bad zip: zip64 extra repeated");
+            }
+            booleanRef.element = true;
+            if (longValue < this.f8497b) {
+                throw new IOException("bad zip: zip64 extra too short");
+            }
+            Ref.LongRef longRef = this.f8498c;
+            long j4 = longRef.element;
+            C c4 = this.f8499d;
+            if (j4 == 4294967295L) {
+                j4 = c4.O();
+            }
+            longRef.element = j4;
+            Ref.LongRef longRef2 = this.f8500e;
+            longRef2.element = longRef2.element == 4294967295L ? c4.O() : 0L;
+            Ref.LongRef longRef3 = this.f8501f;
+            longRef3.element = longRef3.element == 4294967295L ? c4.O() : 0L;
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/s3/k.java

@@ -0,0 +1,71 @@
+package s3;
+
+import java.io.IOException;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.Ref;
+import r3.C;
+
+/* loaded from: classes3.dex */
+public final class k extends Lambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ C f8502a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Ref.ObjectRef f8503b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Ref.ObjectRef f8504c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Ref.ObjectRef f8505d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public k(C c4, Ref.ObjectRef objectRef, Ref.ObjectRef objectRef2, Ref.ObjectRef objectRef3) {
+        super(2);
+        this.f8502a = c4;
+        this.f8503b = objectRef;
+        this.f8504c = objectRef2;
+        this.f8505d = objectRef3;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v11, types: [T, java.lang.Long] */
+    /* JADX WARN: Type inference failed for: r0v7, types: [T, java.lang.Long] */
+    /* JADX WARN: Type inference failed for: r12v9, types: [T, java.lang.Long] */
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        int intValue = ((Number) obj).intValue();
+        long longValue = ((Number) obj2).longValue();
+        if (intValue == 21589) {
+            if (longValue < 1) {
+                throw new IOException("bad zip: extended timestamp extra too short");
+            }
+            byte readByte = this.f8502a.readByte();
+            boolean z3 = (readByte & 1) == 1;
+            boolean z4 = (readByte & 2) == 2;
+            boolean z5 = (readByte & 4) == 4;
+            long j4 = z3 ? 5L : 1L;
+            if (z4) {
+                j4 += 4;
+            }
+            if (z5) {
+                j4 += 4;
+            }
+            if (longValue < j4) {
+                throw new IOException("bad zip: extended timestamp extra too short");
+            }
+            if (z3) {
+                this.f8503b.element = Long.valueOf(r2.x() * 1000);
+            }
+            if (z4) {
+                this.f8504c.element = Long.valueOf(r2.x() * 1000);
+            }
+            if (z5) {
+                this.f8505d.element = Long.valueOf(r2.x() * 1000);
+            }
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/s3/l.java

@@ -0,0 +1,179 @@
+package s3;
+
+import com.google.firebase.sessions.settings.RemoteSettings;
+import f0.C0338b;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.Map;
+import kotlin.TuplesKt;
+import kotlin.UShort;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+import kotlin.text.CharsKt;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+import kotlinx.coroutines.scheduling.WorkQueueKt;
+import r3.C;
+import r3.C0576h;
+import r3.m;
+import r3.z;
+
+/* loaded from: classes3.dex */
+public abstract class l {
+    public static final Map a(ArrayList arrayList) {
+        String str = z.f8321b;
+        z o4 = C0338b.o(RemoteSettings.FORWARD_SLASH_STRING);
+        Map mutableMapOf = MapsKt.mutableMapOf(TuplesKt.to(o4, new i(o4)));
+        for (i iVar : CollectionsKt.sortedWith(arrayList, new A.i(5))) {
+            if (((i) mutableMapOf.put(iVar.f8489a, iVar)) == null) {
+                while (true) {
+                    z zVar = iVar.f8489a;
+                    z b4 = zVar.b();
+                    if (b4 != null) {
+                        i iVar2 = (i) mutableMapOf.get(b4);
+                        if (iVar2 != null) {
+                            iVar2.h.add(zVar);
+                            break;
+                        }
+                        i iVar3 = new i(b4);
+                        mutableMapOf.put(b4, iVar3);
+                        iVar3.h.add(zVar);
+                        iVar = iVar3;
+                    }
+                }
+            }
+        }
+        return mutableMapOf;
+    }
+
+    public static final String b(int i) {
+        StringBuilder sb = new StringBuilder("0x");
+        String num = Integer.toString(i, CharsKt.checkRadix(16));
+        Intrinsics.checkNotNullExpressionValue(num, "toString(this, checkRadix(radix))");
+        sb.append(num);
+        return sb.toString();
+    }
+
+    public static final i c(C c4) {
+        Long valueOf;
+        boolean contains$default;
+        boolean endsWith$default;
+        Intrinsics.checkNotNullParameter(c4, "<this>");
+        int x3 = c4.x();
+        if (x3 != 33639248) {
+            throw new IOException("bad zip: expected " + b(33639248) + " but was " + b(x3));
+        }
+        c4.l(4L);
+        short Y3 = c4.Y();
+        int i = Y3 & UShort.MAX_VALUE;
+        if ((Y3 & 1) != 0) {
+            throw new IOException("unsupported zip: general purpose bit flag=" + b(i));
+        }
+        int Y4 = c4.Y() & UShort.MAX_VALUE;
+        short Y5 = c4.Y();
+        int i4 = Y5 & UShort.MAX_VALUE;
+        short Y6 = c4.Y();
+        int i5 = Y6 & UShort.MAX_VALUE;
+        if (i4 == -1) {
+            valueOf = null;
+        } else {
+            GregorianCalendar gregorianCalendar = new GregorianCalendar();
+            gregorianCalendar.set(14, 0);
+            gregorianCalendar.set(((i5 >> 9) & WorkQueueKt.MASK) + 1980, ((i5 >> 5) & 15) - 1, Y6 & 31, (i4 >> 11) & 31, (i4 >> 5) & 63, (Y5 & 31) << 1);
+            valueOf = Long.valueOf(gregorianCalendar.getTime().getTime());
+        }
+        Long l4 = valueOf;
+        c4.x();
+        Ref.LongRef longRef = new Ref.LongRef();
+        longRef.element = c4.x() & 4294967295L;
+        Ref.LongRef longRef2 = new Ref.LongRef();
+        longRef2.element = c4.x() & 4294967295L;
+        int Y7 = c4.Y() & UShort.MAX_VALUE;
+        int Y8 = c4.Y() & UShort.MAX_VALUE;
+        int Y9 = c4.Y() & UShort.MAX_VALUE;
+        c4.l(8L);
+        Ref.LongRef longRef3 = new Ref.LongRef();
+        longRef3.element = c4.x() & 4294967295L;
+        String Z = c4.Z(Y7);
+        contains$default = StringsKt__StringsKt.contains$default((CharSequence) Z, (char) 0, false, 2, (Object) null);
+        if (contains$default) {
+            throw new IOException("bad zip: filename contains 0x00");
+        }
+        long j4 = longRef2.element == 4294967295L ? 8 : 0L;
+        if (longRef.element == 4294967295L) {
+            j4 += 8;
+        }
+        if (longRef3.element == 4294967295L) {
+            j4 += 8;
+        }
+        long j5 = j4;
+        Ref.BooleanRef booleanRef = new Ref.BooleanRef();
+        d(c4, Y8, new j(booleanRef, j5, longRef2, c4, longRef, longRef3));
+        if (j5 > 0 && !booleanRef.element) {
+            throw new IOException("bad zip: zip64 extra required but absent");
+        }
+        String Z3 = c4.Z(Y9);
+        String str = z.f8321b;
+        z d4 = C0338b.o(RemoteSettings.FORWARD_SLASH_STRING).d(Z);
+        endsWith$default = StringsKt__StringsJVMKt.endsWith$default(Z, RemoteSettings.FORWARD_SLASH_STRING, false, 2, null);
+        return new i(d4, endsWith$default, Z3, longRef.element, longRef2.element, Y4, l4, longRef3.element);
+    }
+
+    public static final void d(C c4, int i, Function2 function2) {
+        long j4 = i;
+        while (j4 != 0) {
+            if (j4 < 4) {
+                throw new IOException("bad zip: truncated header in extra field");
+            }
+            int Y3 = c4.Y() & UShort.MAX_VALUE;
+            long Y4 = c4.Y() & 65535;
+            long j5 = j4 - 4;
+            if (j5 < Y4) {
+                throw new IOException("bad zip: truncated value in extra field");
+            }
+            c4.P(Y4);
+            C0576h c0576h = c4.f8246b;
+            long j6 = c0576h.f8284b;
+            function2.invoke(Integer.valueOf(Y3), Long.valueOf(Y4));
+            long j7 = (c0576h.f8284b + Y4) - j6;
+            if (j7 < 0) {
+                throw new IOException(com.google.android.gms.measurement.internal.a.l(Y3, "unsupported zip: too many bytes processed for "));
+            }
+            if (j7 > 0) {
+                c0576h.l(j7);
+            }
+            j4 = j5 - Y4;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static final m e(C c4, m mVar) {
+        Ref.ObjectRef objectRef = new Ref.ObjectRef();
+        objectRef.element = mVar != null ? (Long) mVar.f8298g : 0;
+        Ref.ObjectRef objectRef2 = new Ref.ObjectRef();
+        Ref.ObjectRef objectRef3 = new Ref.ObjectRef();
+        int x3 = c4.x();
+        if (x3 != 67324752) {
+            throw new IOException("bad zip: expected " + b(67324752) + " but was " + b(x3));
+        }
+        c4.l(2L);
+        short Y3 = c4.Y();
+        int i = Y3 & UShort.MAX_VALUE;
+        if ((Y3 & 1) != 0) {
+            throw new IOException("unsupported zip: general purpose bit flag=" + b(i));
+        }
+        c4.l(18L);
+        int Y4 = c4.Y() & UShort.MAX_VALUE;
+        c4.l(c4.Y() & 65535);
+        if (mVar == null) {
+            c4.l(Y4);
+            return null;
+        }
+        d(c4, Y4, new k(c4, objectRef, objectRef2, objectRef3));
+        return new m(mVar.f8293b, mVar.f8294c, null, (Long) mVar.f8296e, (Long) objectRef3.element, (Long) objectRef.element, (Long) objectRef2.element);
+    }
+}